312 lines
10 KiB
JavaScript
312 lines
10 KiB
JavaScript
// Module ID: 1156
|
|
// Function ID: 13139
|
|
// Name: init
|
|
// Dependencies: []
|
|
// Exports: close, crashedLastRun, flush, init, nativeCrash, withScope, wrap
|
|
|
|
// Module 1156 (init)
|
|
let closure_2 = importAll(dependencyMap[0]);
|
|
let fn = this;
|
|
if (this) {
|
|
fn = this.__awaiter;
|
|
}
|
|
if (!fn) {
|
|
fn = (arg0, arg1, arg2, arg3) => {
|
|
let _Promise = arg2;
|
|
arg1 = arg0;
|
|
const dependencyMap = arg1;
|
|
if (!arg2) {
|
|
_Promise = Promise;
|
|
}
|
|
_Promise = new _Promise((arg0, arg1) => {
|
|
function fulfilled(arg0) {
|
|
step(iter.next(arg0));
|
|
}
|
|
let arg3 = function rejected(arg0) {
|
|
step(iter.throw(arg0));
|
|
};
|
|
function step(iter) {
|
|
if (iter.done) {
|
|
iter(iter.value);
|
|
} else {
|
|
function adopt(value) {
|
|
let tmp = value;
|
|
if (!(value instanceof ctor)) {
|
|
const prototype = ctor.prototype;
|
|
tmp = new ctor((arg0) => {
|
|
arg0(arg0);
|
|
});
|
|
}
|
|
return tmp;
|
|
}(iter.value).then(fulfilled, iter);
|
|
const promise = function adopt(value) {
|
|
let tmp = value;
|
|
if (!(value instanceof ctor)) {
|
|
const prototype = ctor.prototype;
|
|
tmp = new ctor((arg0) => {
|
|
arg0(arg0);
|
|
});
|
|
}
|
|
return tmp;
|
|
}(iter.value);
|
|
}
|
|
}
|
|
let items = arg1;
|
|
if (!arg1) {
|
|
items = [];
|
|
}
|
|
const iter = arg3.apply(arg0, items);
|
|
arg3 = iter;
|
|
step(iter.next());
|
|
});
|
|
return _Promise;
|
|
};
|
|
}
|
|
const obj = { maxQueueSize: arg1(dependencyMap[1]).DEFAULT_BUFFER_SIZE };
|
|
|
|
export const init = function init(maxQueueSize) {
|
|
let obj = callback(dependencyMap[2]);
|
|
if (!obj.isRunningInMetroDevServer()) {
|
|
maxQueueSize = maxQueueSize.maxQueueSize;
|
|
if (null === maxQueueSize) {
|
|
let transportOptions = maxQueueSize.transportOptions;
|
|
let bufferSize;
|
|
if (null !== transportOptions) {
|
|
if (undefined !== transportOptions) {
|
|
bufferSize = transportOptions.bufferSize;
|
|
}
|
|
}
|
|
maxQueueSize = bufferSize;
|
|
}
|
|
if (null === maxQueueSize) {
|
|
maxQueueSize = obj.maxQueueSize;
|
|
}
|
|
let isNativeAvailableResult = !tmp4;
|
|
if (!(undefined !== maxQueueSize.enableNative && !maxQueueSize.enableNative)) {
|
|
const NATIVE = callback(dependencyMap[3]).NATIVE;
|
|
isNativeAvailableResult = NATIVE.isNativeAvailable();
|
|
}
|
|
let obj1 = callback(dependencyMap[4]);
|
|
const encodePolyfill = obj1.useEncodePolyfill();
|
|
if (isNativeAvailableResult) {
|
|
let obj2 = callback(dependencyMap[5]);
|
|
let obj3 = callback(dependencyMap[6]);
|
|
obj2.enableSyncToNative(obj3.getGlobalScope());
|
|
let obj4 = callback(dependencyMap[5]);
|
|
let obj5 = callback(dependencyMap[6]);
|
|
obj4.enableSyncToNative(obj5.getIsolationScope());
|
|
}
|
|
obj = { loggerMessage: "The beforeBreadcrumb threw an error" };
|
|
const callback = callback(dependencyMap[7]).safeFactory(maxQueueSize.beforeBreadcrumb, obj);
|
|
const obj7 = callback(dependencyMap[7]);
|
|
const devServer = callback(dependencyMap[8]).getDevServer();
|
|
let url;
|
|
if (null !== devServer) {
|
|
if (undefined !== devServer) {
|
|
url = devServer.url;
|
|
}
|
|
}
|
|
const dependencyMap = url;
|
|
const dsn = maxQueueSize.dsn;
|
|
let combined;
|
|
if (dsn) {
|
|
url = callback(dependencyMap[6]).makeDsn(dsn);
|
|
if (url) {
|
|
let str4 = "";
|
|
if (url.port) {
|
|
const _HermesInternal = HermesInternal;
|
|
str4 = ":" + url.port;
|
|
}
|
|
const _HermesInternal2 = HermesInternal;
|
|
combined = "" + url.protocol + "://" + url.host + str4;
|
|
} else {
|
|
const debug = callback(dependencyMap[6]).debug;
|
|
debug.error("Failed to extract url from DSN: ", dsn);
|
|
}
|
|
const obj10 = callback(dependencyMap[6]);
|
|
}
|
|
let closure_2 = combined;
|
|
const _Object = Object;
|
|
const _Object2 = Object;
|
|
obj = {};
|
|
let release = maxQueueSize.release;
|
|
const merged = Object.assign(Object.assign({}, obj), maxQueueSize);
|
|
if (null === release) {
|
|
release = callback(dependencyMap[9]).getDefaultRelease();
|
|
const obj12 = callback(dependencyMap[9]);
|
|
}
|
|
obj.release = release;
|
|
obj.enableNative = isNativeAvailableResult;
|
|
const obj9 = callback(dependencyMap[8]);
|
|
obj.enableNativeNagger = callback(dependencyMap[10]).shouldEnableNativeNagger(maxQueueSize.enableNativeNagger);
|
|
let makeFetchTransport = maxQueueSize.transport;
|
|
if (!makeFetchTransport) {
|
|
obj1 = { enableNative: isNativeAvailableResult };
|
|
makeFetchTransport = callback(dependencyMap[1]).makeNativeTransportFactory(obj1);
|
|
const obj14 = callback(dependencyMap[1]);
|
|
}
|
|
if (!makeFetchTransport) {
|
|
makeFetchTransport = callback(dependencyMap[11]).makeFetchTransport;
|
|
}
|
|
obj.transport = makeFetchTransport;
|
|
const _Object3 = Object;
|
|
transportOptions = maxQueueSize.transportOptions;
|
|
const merged1 = Object.assign({}, obj.transportOptions);
|
|
if (null === transportOptions) {
|
|
transportOptions = {};
|
|
}
|
|
obj2 = { bufferSize: maxQueueSize };
|
|
obj.transportOptions = Object.assign(Object.assign(merged1, transportOptions), obj2);
|
|
obj.maxQueueSize = maxQueueSize;
|
|
obj.integrations = [];
|
|
const obj13 = callback(dependencyMap[10]);
|
|
let defaultStackParser = maxQueueSize.stackParser;
|
|
if (!defaultStackParser) {
|
|
defaultStackParser = callback(dependencyMap[11]).defaultStackParser;
|
|
}
|
|
obj.stackParser = callback(dependencyMap[6]).stackParserFromStackParserOptions(defaultStackParser);
|
|
obj.beforeBreadcrumb = function chainedBeforeBreadcrumb(arg0, arg1) {
|
|
let tmp = arg0;
|
|
if (callback) {
|
|
tmp = callback(arg0, arg1);
|
|
if (null === tmp) {
|
|
return null;
|
|
}
|
|
}
|
|
const data = tmp.data;
|
|
let url;
|
|
if (null !== data) {
|
|
if (undefined !== data) {
|
|
url = data.url;
|
|
}
|
|
}
|
|
let str = "";
|
|
if ("string" === typeof url) {
|
|
str = tmp.data.url;
|
|
}
|
|
if ("http" === tmp5) {
|
|
if (!url) {
|
|
if (combined) {
|
|
let tmp9 = null;
|
|
}
|
|
} else {
|
|
tmp9 = null;
|
|
}
|
|
return tmp9;
|
|
}
|
|
tmp9 = tmp;
|
|
};
|
|
const obj18 = callback(dependencyMap[6]);
|
|
obj3 = { loggerMessage: "The initialScope threw an error" };
|
|
obj.initialScope = callback(dependencyMap[7]).safeFactory(maxQueueSize.initialScope, obj3);
|
|
const merged2 = Object.assign(merged, obj);
|
|
if ("tracesSampler" in merged2) {
|
|
merged2.tracesSampler = callback(dependencyMap[7]).safeTracesSampler(merged2.tracesSampler);
|
|
const obj21 = callback(dependencyMap[7]);
|
|
}
|
|
if (!("environment" in merged2)) {
|
|
merged2.environment = callback(dependencyMap[2]).getDefaultEnvironment();
|
|
const obj22 = callback(dependencyMap[2]);
|
|
}
|
|
if (undefined === maxQueueSize.defaultIntegrations) {
|
|
let defaultIntegrations = callback(dependencyMap[12]).getDefaultIntegrations(merged2);
|
|
const obj23 = callback(dependencyMap[12]);
|
|
} else {
|
|
defaultIntegrations = maxQueueSize.defaultIntegrations;
|
|
}
|
|
const obj19 = callback(dependencyMap[7]);
|
|
obj4 = {};
|
|
const obj24 = callback(dependencyMap[6]);
|
|
obj5 = { loggerMessage: "The integrations threw an error" };
|
|
obj4.integrations = callback(dependencyMap[7]).safeFactory(maxQueueSize.integrations, obj5);
|
|
obj4.defaultIntegrations = defaultIntegrations;
|
|
merged2.integrations = obj24.getIntegrationsToSetup(obj4);
|
|
const obj26 = callback(dependencyMap[7]);
|
|
const andBind = callback(dependencyMap[6]).initAndBind(callback(dependencyMap[13]).ReactNativeClient, merged2);
|
|
const obj28 = callback(dependencyMap[6]);
|
|
if (obj29.isExpoGo()) {
|
|
const debug2 = callback(dependencyMap[6]).debug;
|
|
debug2.log("Offline caching, native errors features are not available in Expo Go.");
|
|
const debug3 = callback(dependencyMap[6]).debug;
|
|
debug3.log("Use EAS Build / Native Release Build to test these features.");
|
|
}
|
|
const obj29 = callback(dependencyMap[2]);
|
|
}
|
|
};
|
|
export const wrap = function wrap(displayName, profilerProps) {
|
|
profilerProps = displayName;
|
|
const dependencyMap = profilerProps;
|
|
profilerProps = undefined;
|
|
if (null != profilerProps) {
|
|
profilerProps = profilerProps.profilerProps;
|
|
}
|
|
const obj = {};
|
|
displayName = displayName.displayName;
|
|
let str = "Root";
|
|
const merged = Object.assign({}, profilerProps);
|
|
if (null !== displayName) {
|
|
str = "Root";
|
|
if (undefined !== displayName) {
|
|
str = displayName;
|
|
}
|
|
}
|
|
obj.name = str;
|
|
obj.updateProps = {};
|
|
let closure_2 = Object.assign(merged, obj);
|
|
if (obj2.isWeb()) {
|
|
let ReactNativeProfiler = tmp3(tmp4[11]).Profiler;
|
|
} else {
|
|
ReactNativeProfiler = tmp3(tmp4[14]).ReactNativeProfiler;
|
|
}
|
|
return function RootApp(arg0) {
|
|
let prop;
|
|
if (null != arg1) {
|
|
prop = arg1.touchEventBoundaryProps;
|
|
}
|
|
if (null === prop) {
|
|
prop = {};
|
|
}
|
|
const merged = Object.assign({}, prop);
|
|
const merged1 = Object.assign({}, React);
|
|
return React.createElement(arg0(arg1[15]).TouchEventBoundary, merged, <ReactNativeProfiler {......merged1}>{React.createElement(arg0(arg1[16]).FeedbackWidgetProvider, null, <arg0 {......Object.assign({}, arg0)} />)}</ReactNativeProfiler>);
|
|
};
|
|
};
|
|
export const nativeCrash = function nativeCrash() {
|
|
const NATIVE = arg1(dependencyMap[3]).NATIVE;
|
|
NATIVE.nativeCrash();
|
|
};
|
|
export const flush = function flush() {
|
|
return fn(this, undefined, undefined, function*() {
|
|
const client = callback(closure_1[6]).getClient();
|
|
if (client) {
|
|
return yield obj2.flush();
|
|
} else {
|
|
const debug = callback(closure_1[6]).debug;
|
|
debug.error("Failed to flush the event queue.");
|
|
}
|
|
});
|
|
};
|
|
export const close = function close() {
|
|
return fn(this, undefined, undefined, function*() {
|
|
const client = callback(closure_1[6]).getClient();
|
|
if (client) {
|
|
yield obj2.close();
|
|
}
|
|
});
|
|
};
|
|
export const withScope = function withScope(arg0) {
|
|
const arg1 = arg0;
|
|
return arg1(dependencyMap[6]).withScope(function safeCallback(arg0) {
|
|
return arg0(arg0);
|
|
});
|
|
};
|
|
export const crashedLastRun = function crashedLastRun() {
|
|
return fn(this, undefined, undefined, function*() {
|
|
if (obj) {
|
|
return obj.resume();
|
|
} else {
|
|
const NATIVE = callback(closure_1[3]).NATIVE;
|
|
return NATIVE.crashedLastRun();
|
|
}
|
|
});
|
|
};
|