490 lines
19 KiB
JavaScript
490 lines
19 KiB
JavaScript
// Module ID: 156
|
|
// Function ID: 157
|
|
// Name: importDefaultResult2
|
|
// Dependencies: [41, 42, 90, 91, 70, 154, 157, 162, 164, 166, 167, 168, 169, 170, 126]
|
|
|
|
// Module 156 (importDefaultResult2)
|
|
import _classCallCheck from "_classCallCheck";
|
|
import _classPrivateFieldBase from "_classPrivateFieldBase";
|
|
import importDefaultResult from "_createClass";
|
|
import importDefaultResult1 from "_classPrivateFieldKey";
|
|
import importDefaultResult2Result from "NativePerformanceCxx";
|
|
import setPlatformObject from "setPlatformObject";
|
|
|
|
let c10;
|
|
let c9;
|
|
let closure_12;
|
|
let metroImportAll;
|
|
let unpackModuleId;
|
|
const Performance = arg1;
|
|
let closure_6 = ["mark", "measure"];
|
|
const error = importDefaultResult2Result;
|
|
({ reportMark: metroImportAll, reportMeasure: c9, getMarkTime: c10, clearMarks: unpackModuleId, clearMeasures: closure_12 } = importDefaultResult2Result);
|
|
let closure_13 = { startTime: 0, detail: "channelId" };
|
|
let closure_14 = { name: "", startTime: 0, duration: 0, detail: "dispatch" };
|
|
function getMarkTimeForMeasure(arg0) {
|
|
|
|
}
|
|
let closure_16 = importDefaultResult1("eventCounts");
|
|
class Performance {
|
|
constructor() {
|
|
tmp = outer1_4(this, Performance);
|
|
obj = { writable: true, value: null };
|
|
eventCounts = new require("_isNativeReflectConstruct").EventCounts();
|
|
obj[1] = eventCounts;
|
|
definePropertyResult = Object.defineProperty(this, eventCounts, obj);
|
|
this.now = require("warnNoNativePerformance").getCurrentTimeStamp;
|
|
return;
|
|
}
|
|
}
|
|
let items = [
|
|
{
|
|
key: "eventCounts",
|
|
get() {
|
|
return callback2(this, closure_16)[closure_16];
|
|
}
|
|
},
|
|
{
|
|
key: "memory",
|
|
get() {
|
|
let hermes_allocatedBytes;
|
|
let hermes_heapSize;
|
|
const simpleMemoryInfo = importDefaultResult2Result.getSimpleMemoryInfo();
|
|
if (simpleMemoryInfo.hasOwnProperty("hermes_heapSize")) {
|
|
({ hermes_heapSize, hermes_allocatedBytes } = simpleMemoryInfo);
|
|
const obj = { jsHeapSizeLimit: null, totalJSHeapSize: null, usedJSHeapSize: null };
|
|
obj[1] = hermes_heapSize;
|
|
obj[2] = hermes_allocatedBytes;
|
|
const tmp12 = new importDefault(166)(obj);
|
|
return tmp12;
|
|
} else {
|
|
const tmp5 = new importDefault(166)();
|
|
return tmp5;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "rnStartupTiming",
|
|
get() {
|
|
let endTime;
|
|
let executeJavaScriptBundleEntryPointStart;
|
|
let initializeRuntimeStart;
|
|
let startTime;
|
|
const reactNativeStartupTiming = importDefaultResult2Result.getReactNativeStartupTiming();
|
|
({ startTime, initializeRuntimeStart, executeJavaScriptBundleEntryPointStart, endTime } = reactNativeStartupTiming);
|
|
return new importDefault(167)({ startTime, initializeRuntimeStart, executeJavaScriptBundleEntryPointStart, endTime });
|
|
}
|
|
},
|
|
{
|
|
key: "timeOrigin",
|
|
get() {
|
|
let tmp = null;
|
|
if (null != closure_3) {
|
|
return closure_3;
|
|
} else {
|
|
if (importDefaultResult2Result.timeOrigin) {
|
|
tmp = obj == tmp;
|
|
let timeOriginResult;
|
|
if (!tmp) {
|
|
timeOriginResult = obj.timeOrigin();
|
|
}
|
|
let diff = timeOriginResult;
|
|
} else {
|
|
const _Date = Date;
|
|
const timestamp = Date.now();
|
|
diff = timestamp - Performance(164).getCurrentTimeStamp();
|
|
const obj2 = Performance(164);
|
|
}
|
|
closure_3 = diff;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "mark",
|
|
value: function mark(StringResult) {
|
|
let detail;
|
|
let startTime;
|
|
if (undefined === StringResult) {
|
|
const _TypeError3 = TypeError;
|
|
const typeError = new TypeError("Failed to execute 'mark' on 'Performance': 1 argument required, but only 0 present.");
|
|
throw typeError;
|
|
} else {
|
|
if (typeof StringResult !== "string") {
|
|
const _String = String;
|
|
StringResult = String(StringResult);
|
|
}
|
|
detail = undefined;
|
|
startTime = undefined;
|
|
if (null != arg1) {
|
|
({ startTime, detail } = arg1);
|
|
}
|
|
if (undefined !== startTime) {
|
|
let NumberResult = startTime;
|
|
if (typeof startTime !== "number") {
|
|
const _Number = Number;
|
|
NumberResult = Number(startTime);
|
|
}
|
|
if (NumberResult < 0) {
|
|
const _TypeError2 = TypeError;
|
|
const _HermesInternal = HermesInternal;
|
|
const typeError1 = new TypeError("Failed to execute 'mark' on 'Performance': '" + StringResult + "' cannot have a negative start time.");
|
|
throw typeError1;
|
|
} else {
|
|
if (NumberResult == NumberResult) {
|
|
let currentTimeStamp = NumberResult;
|
|
}
|
|
const _TypeError = TypeError;
|
|
const typeError2 = new TypeError("Failed to execute 'mark' on 'Performance': Failed to read the 'startTime' property from 'PerformanceMarkOptions': The provided double value is non-finite.");
|
|
throw typeError2;
|
|
}
|
|
} else {
|
|
currentTimeStamp = Performance(164).getCurrentTimeStamp();
|
|
const obj = Performance(164);
|
|
}
|
|
let tmp7;
|
|
if (undefined !== detail) {
|
|
tmp7 = importDefault(168)(detail);
|
|
}
|
|
closure_13.startTime = currentTimeStamp;
|
|
closure_13.detail = tmp7;
|
|
const performanceMark = new Performance(169).PerformanceMark(StringResult, closure_13);
|
|
callback3(StringResult, currentTimeStamp, performanceMark);
|
|
return performanceMark;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "clearMarks",
|
|
value: function clearMarks(arg0) {
|
|
callback6(arg0);
|
|
}
|
|
},
|
|
{
|
|
key: "measure",
|
|
value: function measure(str) {
|
|
let detail;
|
|
let duration;
|
|
let end;
|
|
let start;
|
|
if (undefined === str) {
|
|
let typeError = globalThis;
|
|
const _TypeError4 = TypeError;
|
|
typeError = new.target;
|
|
typeError = new.target;
|
|
typeError = new TypeError("Failed to execute 'measure' on 'Performance': 1 argument required, but only 0 present.");
|
|
throw typeError;
|
|
} else {
|
|
typeError = str;
|
|
if (typeof str !== "string") {
|
|
typeError = globalThis;
|
|
const _String3 = String;
|
|
typeError = String(str);
|
|
}
|
|
typeError = arg1;
|
|
if (null != arg1) {
|
|
if ("object" === typeof arg1) {
|
|
if (undefined !== arg2) {
|
|
typeError = globalThis;
|
|
const _TypeError3 = TypeError;
|
|
typeError = new.target;
|
|
typeError = new.target;
|
|
typeError = new TypeError("Failed to execute 'measure' on 'Performance': If a non-empty PerformanceMeasureOptions object was passed, |end_mark| must not be passed.");
|
|
throw typeError;
|
|
} else {
|
|
({ start, end, duration, detail } = arg1);
|
|
if (undefined !== start) {
|
|
if (undefined !== end) {
|
|
if (undefined !== duration) {
|
|
typeError = globalThis;
|
|
const _TypeError2 = TypeError;
|
|
typeError = new.target;
|
|
typeError = new.target;
|
|
typeError = new TypeError("Failed to execute 'measure' on 'Performance': If a non-empty PerformanceMeasureOptions object was passed, it must not have all of its 'start', 'duration', and 'end' properties defined");
|
|
throw typeError;
|
|
}
|
|
}
|
|
}
|
|
let tmp64;
|
|
if ("undefined" !== typeof start) {
|
|
if ("number" === tmp63) {
|
|
tmp64 = start;
|
|
} else if ("string" === tmp63) {
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
tmp64 = callback5(start);
|
|
if (null == tmp64) {
|
|
const _HermesInternal6 = HermesInternal;
|
|
let tmp73 = importDefault(157);
|
|
tmp73 = new tmp73("Failed to execute 'measure' on 'Performance': The mark '" + start + "' does not exist.", "SyntaxError");
|
|
throw tmp73;
|
|
}
|
|
} else {
|
|
const _String = String;
|
|
const StringResult = String(start);
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
tmp64 = callback5(StringResult);
|
|
if (null == tmp64) {
|
|
typeError = importDefault;
|
|
typeError = dependencyMap;
|
|
const _HermesInternal8 = HermesInternal;
|
|
typeError = importDefault(157);
|
|
typeError = new.target;
|
|
typeError = new.target;
|
|
typeError = new typeError("Failed to execute 'measure' on 'Performance': The mark '" + StringResult + "' does not exist.", "SyntaxError");
|
|
throw typeError;
|
|
}
|
|
}
|
|
}
|
|
if ("undefined" !== typeof end) {
|
|
if ("number" === tmp79) {
|
|
let tmp80 = end;
|
|
} else if ("string" === tmp79) {
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
tmp80 = callback5(end);
|
|
if (null == tmp80) {
|
|
const _HermesInternal7 = HermesInternal;
|
|
let tmp89 = importDefault(157);
|
|
tmp89 = new tmp89("Failed to execute 'measure' on 'Performance': The mark '" + end + "' does not exist.", "SyntaxError");
|
|
throw tmp89;
|
|
}
|
|
} else {
|
|
const _String2 = String;
|
|
const StringResult1 = String(end);
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
tmp80 = callback5(StringResult1);
|
|
if (null == tmp80) {
|
|
typeError = importDefault;
|
|
typeError = dependencyMap;
|
|
const _HermesInternal9 = HermesInternal;
|
|
typeError = importDefault(157);
|
|
typeError = new.target;
|
|
typeError = new.target;
|
|
typeError = new typeError("Failed to execute 'measure' on 'Performance': The mark '" + StringResult1 + "' does not exist.", "SyntaxError");
|
|
throw typeError;
|
|
}
|
|
}
|
|
}
|
|
let tmp96;
|
|
if ("undefined" !== typeof duration) {
|
|
if ("number" === tmp95) {
|
|
tmp96 = duration;
|
|
} else {
|
|
const _Number = Number;
|
|
const NumberResult = Number(duration);
|
|
const _Number2 = Number;
|
|
tmp96 = NumberResult;
|
|
if (!Number.isFinite(NumberResult)) {
|
|
const _TypeError = TypeError;
|
|
typeError = new.target;
|
|
typeError = new TypeError("Failed to execute 'measure' on 'Performance': Failed to read the 'duration' property from 'PerformanceMeasureOptions': The provided double value is non-finite.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
}
|
|
if (undefined === tmp64) {
|
|
let num4 = 0;
|
|
if (undefined !== tmp80) {
|
|
num4 = 0;
|
|
if (undefined !== tmp96) {
|
|
num4 = tmp80 - tmp96;
|
|
}
|
|
}
|
|
tmp64 = num4;
|
|
}
|
|
if (undefined !== tmp96) {
|
|
let currentTimeStamp = tmp96;
|
|
let num3 = tmp64;
|
|
if (undefined !== detail) {
|
|
typeError = importDefault;
|
|
typeError = dependencyMap;
|
|
currentTimeStamp = tmp96;
|
|
num3 = tmp64;
|
|
const tmp10 = importDefault(168)(detail);
|
|
}
|
|
} else {
|
|
if (undefined === tmp64) {
|
|
typeError = Performance;
|
|
typeError = dependencyMap;
|
|
typeError = Performance(164).getCurrentTimeStamp() - tmp64;
|
|
const obj4 = Performance(164);
|
|
}
|
|
typeError = tmp80 - tmp64;
|
|
}
|
|
}
|
|
} else if ("string" === tmp19) {
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
const tmp42 = callback5(arg1);
|
|
if (null == tmp42) {
|
|
const _HermesInternal5 = HermesInternal;
|
|
let tmp57 = importDefault(157);
|
|
tmp57 = new tmp57("Failed to execute 'measure' on 'Performance': The mark '" + arg1 + "' does not exist.", "SyntaxError");
|
|
throw tmp57;
|
|
} else {
|
|
if (undefined !== arg2) {
|
|
if (typeof tmp40 !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
const tmp41Result = tmp41(arg2);
|
|
if (null == tmp41Result) {
|
|
const _HermesInternal4 = HermesInternal;
|
|
let tmp49 = importDefault(157);
|
|
tmp49 = new tmp49("Failed to execute 'measure' on 'Performance': The mark '" + arg2 + "' does not exist.", "SyntaxError");
|
|
throw tmp49;
|
|
} else {
|
|
let diff = tmp41Result - tmp42;
|
|
}
|
|
} else {
|
|
diff = Performance(164).getCurrentTimeStamp() - tmp42;
|
|
const obj3 = Performance(164);
|
|
}
|
|
currentTimeStamp = diff;
|
|
num3 = tmp42;
|
|
}
|
|
tmp40 = getMarkTimeForMeasure;
|
|
tmp41 = callback5;
|
|
} else {
|
|
typeError = globalThis;
|
|
const _String4 = String;
|
|
typeError = getMarkTimeForMeasure;
|
|
typeError = String(arg1);
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
const tmp21 = callback5(typeError);
|
|
if (null == tmp21) {
|
|
const _HermesInternal3 = HermesInternal;
|
|
let tmp35 = importDefault(157);
|
|
tmp35 = new tmp35("Failed to execute 'measure' on 'Performance': The mark '" + typeError + "' does not exist.", "SyntaxError");
|
|
throw tmp35;
|
|
} else {
|
|
if (undefined !== arg2) {
|
|
if (typeof typeError !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
const tmp20Result = tmp20(arg2);
|
|
if (null == tmp20Result) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
let tmp28 = importDefault(157);
|
|
tmp28 = new tmp28("Failed to execute 'measure' on 'Performance': The mark '" + arg2 + "' does not exist.", "SyntaxError");
|
|
throw tmp28;
|
|
} else {
|
|
let diff1 = tmp20Result - tmp21;
|
|
}
|
|
} else {
|
|
diff1 = Performance(164).getCurrentTimeStamp() - tmp21;
|
|
const obj2 = Performance(164);
|
|
}
|
|
currentTimeStamp = diff1;
|
|
num3 = tmp21;
|
|
}
|
|
tmp20 = callback5;
|
|
}
|
|
} else {
|
|
if (undefined !== arg2) {
|
|
if (typeof getMarkTimeForMeasure !== "function") {
|
|
typeError = HermesBuiltin.throwTypeError();
|
|
}
|
|
const tmp9 = callback5(arg2);
|
|
if (null == tmp9) {
|
|
const _HermesInternal = HermesInternal;
|
|
let tmp13 = importDefault(157);
|
|
tmp13 = new tmp13("Failed to execute 'measure' on 'Performance': The mark '" + arg2 + "' does not exist.", "SyntaxError");
|
|
throw tmp13;
|
|
} else {
|
|
currentTimeStamp = tmp9;
|
|
}
|
|
} else {
|
|
currentTimeStamp = Performance(164).getCurrentTimeStamp();
|
|
const obj = Performance(164);
|
|
}
|
|
num3 = 0;
|
|
}
|
|
typeError = closure_14;
|
|
closure_14.name = typeError;
|
|
closure_14.startTime = num3;
|
|
closure_14.duration = currentTimeStamp;
|
|
closure_14.detail = tmp10;
|
|
typeError = Performance;
|
|
typeError = dependencyMap;
|
|
typeError = new.target;
|
|
typeError = new.target;
|
|
typeError = closure_14;
|
|
typeError = new Performance(169).PerformanceMeasure(closure_14);
|
|
typeError = callback4;
|
|
typeError = num3;
|
|
typeError = currentTimeStamp;
|
|
typeError = callback4(typeError, num3, currentTimeStamp, typeError);
|
|
return typeError;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "clearMeasures",
|
|
value: function clearMeasures(arg0) {
|
|
callback7(arg0);
|
|
}
|
|
},
|
|
{
|
|
key: "getEntries",
|
|
value: function getEntries() {
|
|
const entries = importDefaultResult2Result.getEntries();
|
|
return entries.map(Performance(170).rawToPerformanceEntry);
|
|
}
|
|
},
|
|
{
|
|
key: "getEntriesByType",
|
|
value: function getEntriesByType(type) {
|
|
if (null != type) {
|
|
if (!closure_6.includes(type)) {
|
|
const _console = console;
|
|
console.warn("Deprecated API for given entry type.");
|
|
let items = [];
|
|
}
|
|
return items;
|
|
}
|
|
const entriesByType = importDefaultResult2Result.getEntriesByType(Performance(170).performanceEntryTypeToRaw(type));
|
|
items = entriesByType.map(Performance(170).rawToPerformanceEntry);
|
|
}
|
|
},
|
|
{
|
|
key: "getEntriesByName",
|
|
value: function getEntriesByName(arg0, type) {
|
|
if (null != type) {
|
|
if (!closure_6.includes(type)) {
|
|
const _console = console;
|
|
console.warn("Deprecated API for given entry type.");
|
|
let items = [];
|
|
}
|
|
return items;
|
|
}
|
|
let result;
|
|
if (null != type) {
|
|
result = Performance(170).performanceEntryTypeToRaw(type);
|
|
const obj = Performance(170);
|
|
}
|
|
const entriesByName = importDefaultResult2Result.getEntriesByName(arg0, result);
|
|
items = entriesByName.map(Performance(170).rawToPerformanceEntry);
|
|
}
|
|
}
|
|
];
|
|
const importDefaultResultResult = importDefaultResult(Performance, items);
|
|
class Performance {
|
|
constructor() {
|
|
typeError = new TypeError("Failed to construct 'Performance': Illegal constructor");
|
|
throw typeError;
|
|
}
|
|
}
|
|
Performance.prototype = importDefaultResultResult.prototype;
|
|
setPlatformObject.setPlatformObject(importDefaultResultResult);
|
|
|
|
export default importDefaultResultResult;
|
|
export const Performance_public = Performance;
|