zone.js
Version:
Zones for JavaScript
1,329 lines (1,322 loc) • 72.2 kB
JavaScript
'use strict';
/**
* @license Angular
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
var __async = (__this, __arguments, generator) => {
return new Promise((resolve, reject) => {
var fulfilled = (value) => {
try {
step(generator.next(value));
} catch (e) {
reject(e);
}
};
var rejected = (value) => {
try {
step(generator.throw(value));
} catch (e) {
reject(e);
}
};
var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
step((generator = generator.apply(__this, __arguments)).next());
});
};
// packages/zone.js/lib/jasmine/jasmine.js
function patchJasmine(Zone2) {
Zone2.__load_patch("jasmine", (global3, Zone3, api) => {
var _a;
const __extends = function(d, b) {
for (const p in b)
if (b.hasOwnProperty(p))
d[p] = b[p];
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
if (!Zone3)
throw new Error("Missing: zone.js");
if (typeof jest !== "undefined") {
return;
}
if (typeof jasmine == "undefined" || jasmine["__zone_patch__"]) {
return;
}
jasmine["__zone_patch__"] = true;
const SyncTestZoneSpec = Zone3["SyncTestZoneSpec"];
const ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
if (!SyncTestZoneSpec)
throw new Error("Missing: SyncTestZoneSpec");
if (!ProxyZoneSpec2)
throw new Error("Missing: ProxyZoneSpec");
const ambientZone = Zone3.current;
const symbol = Zone3.__symbol__;
const disablePatchingJasmineClock = global3[symbol("fakeAsyncDisablePatchingClock")] === true;
const enableAutoFakeAsyncWhenClockPatched = !disablePatchingJasmineClock && (global3[symbol("fakeAsyncPatchLock")] === true || global3[symbol("fakeAsyncAutoFakeAsyncWhenClockPatched")] === true);
const jasmineEnv = jasmine.getEnv();
["describe", "xdescribe", "fdescribe"].forEach((methodName) => {
let originalJasmineFn = jasmineEnv[methodName];
jasmineEnv[methodName] = function(description, specDefinitions) {
return originalJasmineFn.call(this, description, wrapDescribeInZone(description, specDefinitions));
};
});
["it", "xit", "fit"].forEach((methodName) => {
let originalJasmineFn = jasmineEnv[methodName];
jasmineEnv[symbol(methodName)] = originalJasmineFn;
jasmineEnv[methodName] = function(description, specDefinitions, timeout) {
arguments[1] = wrapTestInZone(specDefinitions);
return originalJasmineFn.apply(this, arguments);
};
});
["beforeEach", "afterEach", "beforeAll", "afterAll"].forEach((methodName) => {
let originalJasmineFn = jasmineEnv[methodName];
jasmineEnv[symbol(methodName)] = originalJasmineFn;
jasmineEnv[methodName] = function(specDefinitions, timeout) {
arguments[0] = wrapTestInZone(specDefinitions);
return originalJasmineFn.apply(this, arguments);
};
});
if (!disablePatchingJasmineClock) {
const originalClockFn = jasmine[symbol("clock")] = jasmine["clock"];
jasmine["clock"] = function() {
const clock = originalClockFn.apply(this, arguments);
if (!clock[symbol("patched")]) {
clock[symbol("patched")] = symbol("patched");
const originalTick = clock[symbol("tick")] = clock.tick;
clock.tick = function() {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
return fakeAsyncZoneSpec.tick.apply(fakeAsyncZoneSpec, arguments);
}
return originalTick.apply(this, arguments);
};
const originalMockDate = clock[symbol("mockDate")] = clock.mockDate;
clock.mockDate = function() {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
const dateTime = arguments.length > 0 ? arguments[0] : /* @__PURE__ */ new Date();
return fakeAsyncZoneSpec.setFakeBaseSystemTime.apply(fakeAsyncZoneSpec, dateTime && typeof dateTime.getTime === "function" ? [dateTime.getTime()] : arguments);
}
return originalMockDate.apply(this, arguments);
};
if (enableAutoFakeAsyncWhenClockPatched) {
["install", "uninstall"].forEach((methodName) => {
const originalClockFn2 = clock[symbol(methodName)] = clock[methodName];
clock[methodName] = function() {
const FakeAsyncTestZoneSpec2 = Zone3["FakeAsyncTestZoneSpec"];
if (FakeAsyncTestZoneSpec2) {
jasmine[symbol("clockInstalled")] = "install" === methodName;
return;
}
return originalClockFn2.apply(this, arguments);
};
});
}
}
return clock;
};
}
if (!jasmine[Zone3.__symbol__("createSpyObj")]) {
const originalCreateSpyObj = jasmine.createSpyObj;
jasmine[Zone3.__symbol__("createSpyObj")] = originalCreateSpyObj;
jasmine.createSpyObj = function() {
const args = Array.prototype.slice.call(arguments);
const propertyNames = args.length >= 3 ? args[2] : null;
let spyObj;
if (propertyNames) {
const defineProperty = Object.defineProperty;
Object.defineProperty = function(obj, p, attributes) {
return defineProperty.call(this, obj, p, __spreadProps(__spreadValues({}, attributes), {
configurable: true,
enumerable: true
}));
};
try {
spyObj = originalCreateSpyObj.apply(this, args);
} finally {
Object.defineProperty = defineProperty;
}
} else {
spyObj = originalCreateSpyObj.apply(this, args);
}
return spyObj;
};
}
function wrapDescribeInZone(description, describeBody) {
return function() {
const syncZone = ambientZone.fork(new SyncTestZoneSpec(`jasmine.describe#${description}`));
return syncZone.run(describeBody, this, arguments);
};
}
function runInTestZone(testBody, applyThis, queueRunner, done) {
const isClockInstalled = !!jasmine[symbol("clockInstalled")];
const testProxyZoneSpec = queueRunner.testProxyZoneSpec;
const testProxyZone = queueRunner.testProxyZone;
let lastDelegate;
if (isClockInstalled && enableAutoFakeAsyncWhenClockPatched) {
const fakeAsyncModule = Zone3[Zone3.__symbol__("fakeAsyncTest")];
if (fakeAsyncModule && typeof fakeAsyncModule.fakeAsync === "function") {
testBody = fakeAsyncModule.fakeAsync(testBody);
}
}
if (done) {
return testProxyZone.run(testBody, applyThis, [done]);
} else {
return testProxyZone.run(testBody, applyThis);
}
}
function wrapTestInZone(testBody) {
return testBody && (testBody.length ? function(done) {
return runInTestZone(testBody, this, this.queueRunner, done);
} : function() {
return runInTestZone(testBody, this, this.queueRunner);
});
}
const j$ = jasmine;
const privateApis = ((_a = j$ == null ? void 0 : j$.private) == null ? void 0 : _a.QueueRunner) ? j$ == null ? void 0 : j$.private : j$;
const QueueRunner = privateApis.QueueRunner;
privateApis.QueueRunner = function(_super) {
__extends(ZoneQueueRunner, _super);
function ZoneQueueRunner(attrs) {
if (attrs.onComplete) {
attrs.onComplete = /* @__PURE__ */ ((fn) => () => {
this.testProxyZone = null;
this.testProxyZoneSpec = null;
ambientZone.scheduleMicroTask("jasmine.onComplete", fn);
})(attrs.onComplete);
}
const nativeSetTimeout = global3[Zone3.__symbol__("setTimeout")];
const nativeClearTimeout = global3[Zone3.__symbol__("clearTimeout")];
if (nativeSetTimeout) {
attrs.timeout = {
setTimeout: nativeSetTimeout ? nativeSetTimeout : global3.setTimeout,
clearTimeout: nativeClearTimeout ? nativeClearTimeout : global3.clearTimeout
};
}
if (privateApis.UserContext) {
if (!attrs.userContext) {
attrs.userContext = new privateApis.UserContext();
}
attrs.userContext.queueRunner = this;
} else {
if (!attrs.userContext) {
attrs.userContext = {};
}
attrs.userContext.queueRunner = this;
}
const onException = attrs.onException;
attrs.onException = function(error) {
if (error && error.message === "Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.") {
const proxyZoneSpec = this && this.testProxyZoneSpec;
if (proxyZoneSpec) {
const pendingTasksInfo = proxyZoneSpec.getAndClearPendingTasksInfo();
try {
error.message += pendingTasksInfo;
} catch (err) {
}
}
}
if (onException) {
onException.call(this, error);
}
};
_super.call(this, attrs);
}
ZoneQueueRunner.prototype.execute = function() {
let zone = Zone3.current;
let isChildOfAmbientZone = false;
while (zone) {
if (zone === ambientZone) {
isChildOfAmbientZone = true;
break;
}
zone = zone.parent;
}
if (!isChildOfAmbientZone)
throw new Error("Unexpected Zone: " + Zone3.current.name);
this.testProxyZoneSpec = new ProxyZoneSpec2();
this.testProxyZone = ambientZone.fork(this.testProxyZoneSpec);
if (!Zone3.currentTask) {
Zone3.current.scheduleMicroTask("jasmine.execute().forceTask", () => QueueRunner.prototype.execute.call(this));
} else {
_super.prototype.execute.call(this);
}
};
return ZoneQueueRunner;
}(QueueRunner);
});
}
// packages/zone.js/lib/jest/jest.js
function patchJest(Zone2) {
Zone2.__load_patch("jest", (context, Zone3, api) => {
if (typeof jest === "undefined" || jest["__zone_patch__"]) {
return;
}
Zone3[api.symbol("ignoreConsoleErrorUncaughtError")] = true;
jest["__zone_patch__"] = true;
const ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
const SyncTestZoneSpec = Zone3["SyncTestZoneSpec"];
if (!ProxyZoneSpec2) {
throw new Error("Missing ProxyZoneSpec");
}
const rootZone = Zone3.current;
const syncZone = rootZone.fork(new SyncTestZoneSpec("jest.describe"));
const proxyZoneSpec = new ProxyZoneSpec2();
const proxyZone = rootZone.fork(proxyZoneSpec);
function wrapDescribeFactoryInZone(originalJestFn) {
return function(...tableArgs) {
const originalDescribeFn = originalJestFn.apply(this, tableArgs);
return function(...args) {
args[1] = wrapDescribeInZone(args[1]);
return originalDescribeFn.apply(this, args);
};
};
}
function wrapTestFactoryInZone(originalJestFn) {
return function(...tableArgs) {
return function(...args) {
args[1] = wrapTestInZone(args[1]);
return originalJestFn.apply(this, tableArgs).apply(this, args);
};
};
}
function wrapDescribeInZone(describeBody) {
return function(...args) {
return syncZone.run(describeBody, this, args);
};
}
function wrapTestInZone(testBody, isTestFunc = false) {
if (typeof testBody !== "function") {
return testBody;
}
const wrappedFunc = function() {
if (Zone3[api.symbol("useFakeTimersCalled")] === true && testBody && !testBody.isFakeAsync) {
const fakeAsyncModule = Zone3[Zone3.__symbol__("fakeAsyncTest")];
if (fakeAsyncModule && typeof fakeAsyncModule.fakeAsync === "function") {
testBody = fakeAsyncModule.fakeAsync(testBody);
}
}
proxyZoneSpec.isTestFunc = isTestFunc;
return proxyZone.run(testBody, null, arguments);
};
Object.defineProperty(wrappedFunc, "length", {
configurable: true,
writable: true,
enumerable: false
});
wrappedFunc.length = testBody.length;
return wrappedFunc;
}
["describe", "xdescribe", "fdescribe"].forEach((methodName) => {
let originalJestFn = context[methodName];
if (context[Zone3.__symbol__(methodName)]) {
return;
}
context[Zone3.__symbol__(methodName)] = originalJestFn;
context[methodName] = function(...args) {
args[1] = wrapDescribeInZone(args[1]);
return originalJestFn.apply(this, args);
};
context[methodName].each = wrapDescribeFactoryInZone(originalJestFn.each);
});
context.describe.only = context.fdescribe;
context.describe.skip = context.xdescribe;
["it", "xit", "fit", "test", "xtest"].forEach((methodName) => {
let originalJestFn = context[methodName];
if (context[Zone3.__symbol__(methodName)]) {
return;
}
context[Zone3.__symbol__(methodName)] = originalJestFn;
context[methodName] = function(...args) {
args[1] = wrapTestInZone(args[1], true);
return originalJestFn.apply(this, args);
};
context[methodName].each = wrapTestFactoryInZone(originalJestFn.each);
context[methodName].todo = originalJestFn.todo;
context[methodName].failing = originalJestFn.failing;
});
context.it.only = context.fit;
context.it.skip = context.xit;
context.test.only = context.fit;
context.test.skip = context.xit;
["beforeEach", "afterEach", "beforeAll", "afterAll"].forEach((methodName) => {
let originalJestFn = context[methodName];
if (context[Zone3.__symbol__(methodName)]) {
return;
}
context[Zone3.__symbol__(methodName)] = originalJestFn;
context[methodName] = function(...args) {
args[0] = wrapTestInZone(args[0]);
return originalJestFn.apply(this, args);
};
});
Zone3.patchJestObject = function patchJestObject(Timer, isModern = false) {
function isPatchingFakeTimer() {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
return !!fakeAsyncZoneSpec;
}
function isInTestFunc() {
const proxyZoneSpec2 = Zone3.current.get("ProxyZoneSpec");
return proxyZoneSpec2 && proxyZoneSpec2.isTestFunc;
}
if (Timer[api.symbol("fakeTimers")]) {
return;
}
Timer[api.symbol("fakeTimers")] = true;
api.patchMethod(Timer, "_checkFakeTimers", (delegate) => {
return function(self2, args) {
if (isPatchingFakeTimer()) {
return true;
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "useFakeTimers", (delegate) => {
return function(self2, args) {
Zone3[api.symbol("useFakeTimersCalled")] = true;
if (isModern || isInTestFunc()) {
return delegate.apply(self2, args);
}
return self2;
};
});
api.patchMethod(Timer, "useRealTimers", (delegate) => {
return function(self2, args) {
Zone3[api.symbol("useFakeTimersCalled")] = false;
if (isModern || isInTestFunc()) {
return delegate.apply(self2, args);
}
return self2;
};
});
api.patchMethod(Timer, "setSystemTime", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec && isPatchingFakeTimer()) {
fakeAsyncZoneSpec.setFakeBaseSystemTime(args[0]);
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "getRealSystemTime", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec && isPatchingFakeTimer()) {
return fakeAsyncZoneSpec.getRealSystemTime();
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "runAllTicks", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.flushMicrotasks();
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "runAllTimers", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.flush(100, true);
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "advanceTimersByTime", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.tick(args[0]);
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "runOnlyPendingTimers", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.flushOnlyPendingTimers();
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "advanceTimersToNextTimer", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.tickToNext(args[0]);
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "clearAllTimers", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.removeAllTimers();
} else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "getTimerCount", (delegate) => {
return function(self2, args) {
const fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
return fakeAsyncZoneSpec.getTimerCount();
} else {
return delegate.apply(self2, args);
}
};
});
};
});
}
// packages/zone.js/lib/mocha/mocha.js
function patchMocha(Zone2) {
Zone2.__load_patch("mocha", (global3, Zone3) => {
const Mocha = global3.Mocha;
if (typeof Mocha === "undefined") {
return;
}
if (typeof Zone3 === "undefined") {
throw new Error("Missing Zone.js");
}
const ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
const SyncTestZoneSpec = Zone3["SyncTestZoneSpec"];
if (!ProxyZoneSpec2) {
throw new Error("Missing ProxyZoneSpec");
}
if (Mocha["__zone_patch__"]) {
throw new Error('"Mocha" has already been patched with "Zone".');
}
Mocha["__zone_patch__"] = true;
const rootZone = Zone3.current;
const syncZone = rootZone.fork(new SyncTestZoneSpec("Mocha.describe"));
let testZone = null;
const suiteZone = rootZone.fork(new ProxyZoneSpec2());
const mochaOriginal = {
after: global3.after,
afterEach: global3.afterEach,
before: global3.before,
beforeEach: global3.beforeEach,
describe: global3.describe,
it: global3.it
};
function modifyArguments(args, syncTest, asyncTest) {
for (let i = 0; i < args.length; i++) {
let arg = args[i];
if (typeof arg === "function") {
args[i] = arg.length === 0 ? syncTest(arg) : asyncTest(arg);
args[i].toString = function() {
return arg.toString();
};
}
}
return args;
}
function wrapDescribeInZone(args) {
const syncTest = function(fn) {
return function() {
return syncZone.run(fn, this, arguments);
};
};
return modifyArguments(args, syncTest);
}
function wrapTestInZone(args) {
const asyncTest = function(fn) {
return function(done) {
return testZone.run(fn, this, [done]);
};
};
const syncTest = function(fn) {
return function() {
return testZone.run(fn, this);
};
};
return modifyArguments(args, syncTest, asyncTest);
}
function wrapSuiteInZone(args) {
const asyncTest = function(fn) {
return function(done) {
return suiteZone.run(fn, this, [done]);
};
};
const syncTest = function(fn) {
return function() {
return suiteZone.run(fn, this);
};
};
return modifyArguments(args, syncTest, asyncTest);
}
global3.describe = global3.suite = function() {
return mochaOriginal.describe.apply(this, wrapDescribeInZone(arguments));
};
global3.xdescribe = global3.suite.skip = global3.describe.skip = function() {
return mochaOriginal.describe.skip.apply(this, wrapDescribeInZone(arguments));
};
global3.describe.only = global3.suite.only = function() {
return mochaOriginal.describe.only.apply(this, wrapDescribeInZone(arguments));
};
global3.it = global3.specify = global3.test = function() {
return mochaOriginal.it.apply(this, wrapTestInZone(arguments));
};
global3.xit = global3.xspecify = global3.it.skip = function() {
return mochaOriginal.it.skip.apply(this, wrapTestInZone(arguments));
};
global3.it.only = global3.test.only = function() {
return mochaOriginal.it.only.apply(this, wrapTestInZone(arguments));
};
global3.after = global3.suiteTeardown = function() {
return mochaOriginal.after.apply(this, wrapSuiteInZone(arguments));
};
global3.afterEach = global3.teardown = function() {
return mochaOriginal.afterEach.apply(this, wrapTestInZone(arguments));
};
global3.before = global3.suiteSetup = function() {
return mochaOriginal.before.apply(this, wrapSuiteInZone(arguments));
};
global3.beforeEach = global3.setup = function() {
return mochaOriginal.beforeEach.apply(this, wrapTestInZone(arguments));
};
((originalRunTest, originalRun) => {
Mocha.Runner.prototype.runTest = function(fn) {
Zone3.current.scheduleMicroTask("mocha.forceTask", () => {
originalRunTest.call(this, fn);
});
};
Mocha.Runner.prototype.run = function(fn) {
this.on("test", (e) => {
testZone = rootZone.fork(new ProxyZoneSpec2());
});
this.on("fail", (test, err) => {
const proxyZoneSpec = testZone && testZone.get("ProxyZoneSpec");
if (proxyZoneSpec && err) {
try {
err.message += proxyZoneSpec.getAndClearPendingTasksInfo();
} catch (error) {
}
}
});
return originalRun.call(this, fn);
};
})(Mocha.Runner.prototype.runTest, Mocha.Runner.prototype.run);
});
}
// packages/zone.js/lib/zone-impl.js
var global = globalThis;
function __symbol__(name) {
const symbolPrefix = global["__Zone_symbol_prefix"] || "__zone_symbol__";
return symbolPrefix + name;
}
// packages/zone.js/lib/zone-spec/async-test.js
var __global = globalThis;
var AsyncTestZoneSpec = class _AsyncTestZoneSpec {
constructor(finishCallback, failCallback, namePrefix) {
__publicField(this, "finishCallback");
__publicField(this, "failCallback");
__publicField(this, "_pendingMicroTasks", false);
__publicField(this, "_pendingMacroTasks", false);
__publicField(this, "_alreadyErrored", false);
__publicField(this, "_isSync", false);
__publicField(this, "_existingFinishTimer", null);
__publicField(this, "entryFunction", null);
__publicField(this, "runZone", Zone.current);
__publicField(this, "unresolvedChainedPromiseCount", 0);
__publicField(this, "supportWaitUnresolvedChainedPromise", false);
// ZoneSpec implementation below.
__publicField(this, "name");
__publicField(this, "properties");
this.finishCallback = finishCallback;
this.failCallback = failCallback;
this.name = "asyncTestZone for " + namePrefix;
this.properties = { "AsyncTestZoneSpec": this };
this.supportWaitUnresolvedChainedPromise = __global[__symbol__("supportWaitUnResolvedChainedPromise")] === true;
}
// Needs to be a getter and not a plain property in order run this just-in-time. Otherwise
// `__symbol__` would be evaluated during top-level execution prior to the Zone prefix being
// changed for tests.
static get symbolParentUnresolved() {
return __symbol__("parentUnresolved");
}
isUnresolvedChainedPromisePending() {
return this.unresolvedChainedPromiseCount > 0;
}
_finishCallbackIfDone() {
if (this._existingFinishTimer !== null) {
clearTimeout(this._existingFinishTimer);
this._existingFinishTimer = null;
}
if (!(this._pendingMicroTasks || this._pendingMacroTasks || this.supportWaitUnresolvedChainedPromise && this.isUnresolvedChainedPromisePending())) {
this.runZone.run(() => {
this._existingFinishTimer = setTimeout(() => {
if (!this._alreadyErrored && !(this._pendingMicroTasks || this._pendingMacroTasks)) {
this.finishCallback();
}
}, 0);
});
}
}
patchPromiseForTest() {
if (!this.supportWaitUnresolvedChainedPromise) {
return;
}
const patchPromiseForTest = Promise[Zone.__symbol__("patchPromiseForTest")];
if (patchPromiseForTest) {
patchPromiseForTest();
}
}
unPatchPromiseForTest() {
if (!this.supportWaitUnresolvedChainedPromise) {
return;
}
const unPatchPromiseForTest = Promise[Zone.__symbol__("unPatchPromiseForTest")];
if (unPatchPromiseForTest) {
unPatchPromiseForTest();
}
}
onScheduleTask(delegate, current, target, task) {
if (task.type !== "eventTask") {
this._isSync = false;
}
if (task.type === "microTask" && task.data && task.data instanceof Promise) {
if (task.data[_AsyncTestZoneSpec.symbolParentUnresolved] === true) {
this.unresolvedChainedPromiseCount--;
}
}
return delegate.scheduleTask(target, task);
}
onInvokeTask(delegate, current, target, task, applyThis, applyArgs) {
if (task.type !== "eventTask") {
this._isSync = false;
}
return delegate.invokeTask(target, task, applyThis, applyArgs);
}
onCancelTask(delegate, current, target, task) {
if (task.type !== "eventTask") {
this._isSync = false;
}
return delegate.cancelTask(target, task);
}
// Note - we need to use onInvoke at the moment to call finish when a test is
// fully synchronous. TODO(juliemr): remove this when the logic for
// onHasTask changes and it calls whenever the task queues are dirty.
// updated by(JiaLiPassion), only call finish callback when no task
// was scheduled/invoked/canceled.
onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
if (!this.entryFunction) {
this.entryFunction = delegate;
}
try {
this._isSync = true;
return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
} finally {
if (this._isSync && this.entryFunction === delegate) {
this._finishCallbackIfDone();
}
}
}
onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
const result = parentZoneDelegate.handleError(targetZone, error);
if (result) {
this.failCallback(error);
this._alreadyErrored = true;
}
return false;
}
onHasTask(delegate, current, target, hasTaskState) {
delegate.hasTask(target, hasTaskState);
if (current !== target) {
return;
}
if (hasTaskState.change == "microTask") {
this._pendingMicroTasks = hasTaskState.microTask;
this._finishCallbackIfDone();
} else if (hasTaskState.change == "macroTask") {
this._pendingMacroTasks = hasTaskState.macroTask;
this._finishCallbackIfDone();
}
}
};
function patchAsyncTest(Zone2) {
Zone2["AsyncTestZoneSpec"] = AsyncTestZoneSpec;
Zone2.__load_patch("asynctest", (global3, Zone3, api) => {
Zone3[api.symbol("asyncTest")] = function asyncTest(fn) {
if (global3.jasmine) {
return function(done) {
if (!done) {
done = function() {
};
done.fail = function(e) {
throw e;
};
}
runInTestZone(fn, this, void 0, done, (err) => {
if (typeof err === "string") {
return done.fail(new Error(err));
} else {
done.fail(err);
}
});
};
}
return function(...args) {
return new Promise((finishCallback, failCallback) => {
runInTestZone(fn, this, args, finishCallback, failCallback);
});
};
};
function runInTestZone(fn, context, applyArgs, finishCallback, failCallback) {
const currentZone = Zone3.current;
const AsyncTestZoneSpec2 = Zone3["AsyncTestZoneSpec"];
if (AsyncTestZoneSpec2 === void 0) {
throw new Error("AsyncTestZoneSpec is needed for the async() test helper but could not be found. Please make sure that your environment includes zone.js/plugins/async-test");
}
const ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
if (!ProxyZoneSpec2) {
throw new Error("ProxyZoneSpec is needed for the async() test helper but could not be found. Please make sure that your environment includes zone.js/plugins/proxy");
}
const proxyZoneSpec = ProxyZoneSpec2.get();
ProxyZoneSpec2.assertPresent();
const proxyZone = Zone3.current.getZoneWith("ProxyZoneSpec");
const previousDelegate = proxyZoneSpec.getDelegate();
proxyZone.parent.run(() => {
const testZoneSpec = new AsyncTestZoneSpec2(() => {
if (proxyZoneSpec.getDelegate() == testZoneSpec) {
proxyZoneSpec.setDelegate(previousDelegate);
}
testZoneSpec.unPatchPromiseForTest();
currentZone.run(() => {
finishCallback();
});
}, (error) => {
if (proxyZoneSpec.getDelegate() == testZoneSpec) {
proxyZoneSpec.setDelegate(previousDelegate);
}
testZoneSpec.unPatchPromiseForTest();
currentZone.run(() => {
failCallback(error);
});
}, "test");
proxyZoneSpec.setDelegate(testZoneSpec);
testZoneSpec.patchPromiseForTest();
});
return Zone3.current.runGuarded(fn, context, applyArgs);
}
});
}
// packages/zone.js/lib/zone-spec/proxy.js
function throwProxyZoneError() {
const jestPatched = typeof jest !== "undefined" && jest["__zone_patch__"];
if (jestPatched) {
throw new Error("Only globals are patched with zone-testing. If you import `it`, `describe`, etc. directly, you cannot use `fakeAsync` or `waitForAsync`.");
} else {
throw new Error("ProxyZoneSpec is needed for the fakeAsync and waitForAsync test helpers but could not be found. Make sure that your environment includes zone-testing.js");
}
}
var ProxyZoneSpec = class _ProxyZoneSpec {
constructor(defaultSpecDelegate = null) {
__publicField(this, "defaultSpecDelegate");
__publicField(this, "name", "ProxyZone");
__publicField(this, "_delegateSpec", null);
__publicField(this, "properties", { "ProxyZoneSpec": this });
__publicField(this, "propertyKeys", null);
__publicField(this, "lastTaskState", null);
__publicField(this, "isNeedToTriggerHasTask", false);
__publicField(this, "tasks", []);
this.defaultSpecDelegate = defaultSpecDelegate;
this.setDelegate(defaultSpecDelegate);
}
static get() {
return Zone.current.get("ProxyZoneSpec");
}
static isLoaded() {
return _ProxyZoneSpec.get() instanceof _ProxyZoneSpec;
}
static assertPresent() {
const spec = _ProxyZoneSpec.get();
if (spec === void 0) {
throw new Error(`Expected to be running in 'ProxyZone', but it was not found.`);
}
return spec;
}
setDelegate(delegateSpec) {
const isNewDelegate = this._delegateSpec !== delegateSpec;
this._delegateSpec = delegateSpec;
this.propertyKeys && this.propertyKeys.forEach((key) => delete this.properties[key]);
this.propertyKeys = null;
if (delegateSpec && delegateSpec.properties) {
this.propertyKeys = Object.keys(delegateSpec.properties);
this.propertyKeys.forEach((k) => this.properties[k] = delegateSpec.properties[k]);
}
if (isNewDelegate && this.lastTaskState && (this.lastTaskState.macroTask || this.lastTaskState.microTask)) {
this.isNeedToTriggerHasTask = true;
}
}
getDelegate() {
return this._delegateSpec;
}
resetDelegate() {
const delegateSpec = this.getDelegate();
this.setDelegate(this.defaultSpecDelegate);
}
tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone) {
if (this.isNeedToTriggerHasTask && this.lastTaskState) {
this.isNeedToTriggerHasTask = false;
this.onHasTask(parentZoneDelegate, currentZone, targetZone, this.lastTaskState);
}
}
removeFromTasks(task) {
if (!this.tasks) {
return;
}
for (let i = 0; i < this.tasks.length; i++) {
if (this.tasks[i] === task) {
this.tasks.splice(i, 1);
return;
}
}
}
getAndClearPendingTasksInfo() {
if (this.tasks.length === 0) {
return "";
}
const taskInfo = this.tasks.map((task) => {
const dataInfo = task.data && Object.keys(task.data).map((key) => {
return key + ":" + task.data[key];
}).join(",");
return `type: ${task.type}, source: ${task.source}, args: {${dataInfo}}`;
});
const pendingTasksInfo = "--Pending async tasks are: [" + taskInfo + "]";
this.tasks = [];
return pendingTasksInfo;
}
onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec) {
if (this._delegateSpec && this._delegateSpec.onFork) {
return this._delegateSpec.onFork(parentZoneDelegate, currentZone, targetZone, zoneSpec);
} else {
return parentZoneDelegate.fork(targetZone, zoneSpec);
}
}
onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source) {
if (this._delegateSpec && this._delegateSpec.onIntercept) {
return this._delegateSpec.onIntercept(parentZoneDelegate, currentZone, targetZone, delegate, source);
} else {
return parentZoneDelegate.intercept(targetZone, delegate, source);
}
}
onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source) {
this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
if (this._delegateSpec && this._delegateSpec.onInvoke) {
return this._delegateSpec.onInvoke(parentZoneDelegate, currentZone, targetZone, delegate, applyThis, applyArgs, source);
} else {
return parentZoneDelegate.invoke(targetZone, delegate, applyThis, applyArgs, source);
}
}
onHandleError(parentZoneDelegate, currentZone, targetZone, error) {
if (this._delegateSpec && this._delegateSpec.onHandleError) {
return this._delegateSpec.onHandleError(parentZoneDelegate, currentZone, targetZone, error);
} else {
return parentZoneDelegate.handleError(targetZone, error);
}
}
onScheduleTask(parentZoneDelegate, currentZone, targetZone, task) {
if (task.type !== "eventTask") {
this.tasks.push(task);
}
if (this._delegateSpec && this._delegateSpec.onScheduleTask) {
return this._delegateSpec.onScheduleTask(parentZoneDelegate, currentZone, targetZone, task);
} else {
return parentZoneDelegate.scheduleTask(targetZone, task);
}
}
onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs) {
if (task.type !== "eventTask") {
this.removeFromTasks(task);
}
this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
if (this._delegateSpec && this._delegateSpec.onInvokeTask) {
return this._delegateSpec.onInvokeTask(parentZoneDelegate, currentZone, targetZone, task, applyThis, applyArgs);
} else {
return parentZoneDelegate.invokeTask(targetZone, task, applyThis, applyArgs);
}
}
onCancelTask(parentZoneDelegate, currentZone, targetZone, task) {
if (task.type !== "eventTask") {
this.removeFromTasks(task);
}
this.tryTriggerHasTask(parentZoneDelegate, currentZone, targetZone);
if (this._delegateSpec && this._delegateSpec.onCancelTask) {
return this._delegateSpec.onCancelTask(parentZoneDelegate, currentZone, targetZone, task);
} else {
return parentZoneDelegate.cancelTask(targetZone, task);
}
}
onHasTask(delegate, current, target, hasTaskState) {
this.lastTaskState = hasTaskState;
if (this._delegateSpec && this._delegateSpec.onHasTask) {
this._delegateSpec.onHasTask(delegate, current, target, hasTaskState);
} else {
delegate.hasTask(target, hasTaskState);
}
}
};
function patchProxyZoneSpec(Zone2) {
Zone2["ProxyZoneSpec"] = ProxyZoneSpec;
}
// packages/zone.js/lib/zone-spec/fake-async-test.js
var global2 = typeof window === "object" && window || typeof self === "object" && self || globalThis.global;
var originalSetImmediate = global2.setImmediate;
var originalTimeout = global2.setTimeout;
var OriginalDate = global2.Date;
function FakeDate() {
if (arguments.length === 0) {
const d = new OriginalDate();
d.setTime(FakeDate.now());
return d;
} else {
const args = Array.prototype.slice.call(arguments);
return new OriginalDate(...args);
}
}
FakeDate.now = function() {
const fakeAsyncTestZoneSpec = Zone.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncTestZoneSpec) {
return fakeAsyncTestZoneSpec.getFakeSystemTime();
}
return OriginalDate.now.apply(this, arguments);
};
FakeDate.UTC = OriginalDate.UTC;
FakeDate.parse = OriginalDate.parse;
var patchedTimers;
var timeoutCallback = function() {
};
var _Scheduler = class _Scheduler {
constructor() {
// Scheduler queue with the tuple of end time and callback function - sorted by end time.
__publicField(this, "_schedulerQueue", []);
// Current simulated time in millis.
__publicField(this, "_currentTickTime", 0);
// Current fake system base time in millis.
__publicField(this, "_currentFakeBaseSystemTime", OriginalDate.now());
// track requeuePeriodicTimer
__publicField(this, "_currentTickRequeuePeriodicEntries", []);
}
static getNextId() {
const id = patchedTimers.nativeSetTimeout.call(global2, timeoutCallback, 0);
patchedTimers.nativeClearTimeout.call(global2, id);
if (typeof id === "number") {
return id;
}
return _Scheduler.nextNodeJSId++;
}
getCurrentTickTime() {
return this._currentTickTime;
}
getFakeSystemTime() {
return this._currentFakeBaseSystemTime + this._currentTickTime;
}
setFakeBaseSystemTime(fakeBaseSystemTime) {
this._currentFakeBaseSystemTime = fakeBaseSystemTime;
}
getRealSystemTime() {
return OriginalDate.now();
}
scheduleFunction(cb, delay, options) {
options = __spreadValues(__spreadValues({}, {
args: [],
isPeriodic: false,
isRequestAnimationFrame: false,
id: -1,
isRequeuePeriodic: false
}), options);
let currentId = options.id < 0 ? _Scheduler.nextId : options.id;
_Scheduler.nextId = _Scheduler.getNextId();
let endTime = this._currentTickTime + delay;
let newEntry = {
endTime,
id: currentId,
func: cb,
args: options.args,
delay,
isPeriodic: options.isPeriodic,
isRequestAnimationFrame: options.isRequestAnimationFrame
};
if (options.isRequeuePeriodic) {
this._currentTickRequeuePeriodicEntries.push(newEntry);
}
let i = 0;
for (; i < this._schedulerQueue.length; i++) {
let currentEntry = this._schedulerQueue[i];
if (newEntry.endTime < currentEntry.endTime) {
break;
}
}
this._schedulerQueue.splice(i, 0, newEntry);
return currentId;
}
removeScheduledFunctionWithId(id) {
for (let i = 0; i < this._schedulerQueue.length; i++) {
if (this._schedulerQueue[i].id == id) {
this._schedulerQueue.splice(i, 1);
break;
}
}
}
removeAll() {
this._schedulerQueue = [];
}
getTimerCount() {
return this._schedulerQueue.length;
}
tickToNext(step = 1, doTick, tickOptions) {
if (this._schedulerQueue.length < step) {
return;
}
const startTime = this._currentTickTime;
const targetTask = this._schedulerQueue[step - 1];
this.tick(targetTask.endTime - startTime, doTick, tickOptions);
}
tick(millis = 0, doTick, tickOptions) {
let finalTime = this._currentTickTime + millis;
let lastCurrentTime = 0;
tickOptions = Object.assign({ processNewMacroTasksSynchronously: true }, tickOptions);
const schedulerQueue = tickOptions.processNewMacroTasksSynchronously ? this._schedulerQueue : this._schedulerQueue.slice();
if (schedulerQueue.length === 0 && doTick) {
doTick(millis);
return;
}
while (schedulerQueue.length > 0) {
this._currentTickRequeuePeriodicEntries = [];
let current = schedulerQueue[0];
if (finalTime < current.endTime) {
break;
} else {
let current2 = schedulerQueue.shift();
if (!tickOptions.processNewMacroTasksSynchronously) {
const idx = this._schedulerQueue.indexOf(current2);
if (idx >= 0) {
this._schedulerQueue.splice(idx, 1);
}
}
lastCurrentTime = this._currentTickTime;
this._currentTickTime = current2.endTime;
if (doTick) {
doTick(this._currentTickTime - lastCurrentTime);
}
let retval = current2.func.apply(global2, current2.isRequestAnimationFrame ? [this._currentTickTime] : current2.args);
if (!retval) {
break;
}
if (!tickOptions.processNewMacroTasksSynchronously) {
this._currentTickRequeuePeriodicEntries.forEach((newEntry) => {
let i = 0;
for (; i < schedulerQueue.length; i++) {
const currentEntry = schedulerQueue[i];
if (newEntry.endTime < currentEntry.endTime) {
break;
}
}
schedulerQueue.splice(i, 0, newEntry);
});
}
}
}
lastCurrentTime = this._currentTickTime;
this._currentTickTime = finalTime;
if (doTick) {
doTick(this._currentTickTime - lastCurrentTime);
}
}
executeNextTask(doTick) {
const current = this._schedulerQueue.shift();
if (current === void 0) {
return;
}
doTick == null ? void 0 : doTick(current.endTime - this._currentTickTime);
this._currentTickTime = current.endTime;
current.func.apply(global2, current.isRequestAnimationFrame ? [this._currentTickTime] : current.args);
}
flushOnlyPendingTimers(doTick) {
if (this._schedulerQueue.length === 0) {
return 0;
}
const startTime = this._currentTickTime;
const lastTask = this._schedulerQueue[this._schedulerQueue.length - 1];
this.tick(lastTask.endTime - startTime, doTick, { processNewMacroTasksSynchronously: false });
return this._currentTickTime - startTime;
}
flush(limit = 20, flushPeriodic = false, doTick) {
if (flushPeriodic) {
return this.flushPeriodic(doTick);
} else {
return this.flushNonPeriodic(limit, doTick);
}
}
flushPeriodic(doTick) {
if (this._schedulerQueue.length === 0) {
return 0;
}
const startTime = this._currentTickTime;
const lastTask = this._schedulerQueue[this._schedulerQueue.length - 1];
this.tick(lastTask.endTime - startTime, doTick);
return this._currentTickTime - startTime;
}
flushNonPeriodic(limit, doTick) {
const startTime = this._currentTickTime;
let lastCurrentTime = 0;
let count = 0;
while (this._schedulerQueue.length > 0) {
count++;
if (count > limit) {
throw new Error("flush failed after reaching the limit of " + limit + " tasks. Does your code use a polling timeout?");
}
if (this._schedulerQueue.filter((task) => !task.isPeriodic && !task.isRequestAnimationFrame).length === 0) {
break;
}
const current = this._schedulerQueue.shift();
lastCurrentTime = this._currentTickTime;
this._currentTickTime = current.endTime;
if (doTick) {
doTick(this._currentTickTime - lastCurrentTime);
}
const retval = current.func.apply(global2, current.args);
if (!retval) {
break;
}
}
return this._currentTickTime - startTime;
}
};
// Next scheduler id.
__publicField(_Scheduler, "nextNodeJSId", 1);
__publicField(_Scheduler, "nextId", -1);
var Scheduler = _Scheduler;
var FakeAsyncTestZoneSpec = class _FakeAsyncTestZoneSpec {
constructor(namePrefix, trackPendingRequestAnimationFrame = false, macroTaskOptions) {
__publicField(this, "trackPendingRequestAnimationFrame");
__publicField(this, "macroTaskOptions");
__publicField(this, "_scheduler", new Scheduler());
__publicField(this, "_microtasks", []);
__publicField(this, "_lastError", null);
__publicField(this, "_uncaughtPromiseErrors", Promise[Zone.__symbol__("uncaughtPromiseErrors")]);
__publicField(this, "pendingPeriodicTimers", []);
__publicField(this, "pendingTimers", []);
__publicField(this, "patchDateLocked", false);
__publicField(this, "tickMode", {
counter: 0,
mode: "manual"
});
// ZoneSpec implementation below.
__publicField(this, "name");
__publicField(this, "properties", { "FakeAsyncTestZoneSpec": this });
this.trackPendingRequestAnimationFrame = trackPendingRequestAnimationFrame;
this.macroTaskOptions = macroTaskOptions;
this.name = "fakeAsyncTestZone for " + namePrefix;
if (!this.macroTaskOptions) {
this.macroTaskOptions = global2[Zone.__symbol__("FakeAsyncTestMacroTask")];
}
}
static assertInZone() {
if (Zone.current.get("FakeAsyncTestZoneSpec") == null) {
throw new Error("The code should be running in the fakeAsync zone to call this function");
}
}
_fnAndFlush(fn, completers) {
return (...args) => {
fn.apply(global2, args);
if (this._lastError === null) {
if (completers.onSuccess != null) {
completers.onSuccess.apply(global2);
}
this.flushMicrotasks();
} else {
if (completers.onError != null) {
completers.onError.apply(global2);
}
}
return this._lastError === null;
};
}
static _removeTimer(timers, id) {
let index = timers.indexOf(id);
if (index > -1) {
timers.splice(index, 1);
}
}
_dequeueTimer(id) {
return () => {
_FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
};
}
_requeuePeriodicTimer(fn, interval, args, id) {
return () => {
if (this.pendingPeriodicTimers.indexOf(id) !== -1) {
this._scheduler.scheduleFunction(fn, interval, {
args,
isPeriodic: true,
id,
isRequeuePeriodic: true
});
}
};
}
_dequeuePeriodicTimer(id) {
return () => {
_FakeAsyncTestZoneSpec._removeTimer(this.pendingPeriodicTimers, id);
};
}
_setTimeout(fn, delay, args, isTimer = true) {
let removeTimerFn = this._dequeueTimer(Scheduler.nextId);
let cb = this._fnAndFlush(fn, { onSuccess: removeTimerFn, onError: removeTimerFn });
let id = this._scheduler.scheduleFunction(cb, delay, { args, isRequestAnimationFrame: !isTimer });
if (isTimer) {
this.pendingTimers.push(id);
}
return id;
}
_clearTimeout(id) {
_FakeAsyncTestZoneSpec._removeTimer(this.pendingTimers, id);
this._scheduler.removeScheduledFunctionWithId(id);
}
_setInterval(fn, interval, args) {
let id = Scheduler.nextId;
let completers = { onSuccess: null, onError: this._dequeuePeriodicTimer(id) };
let cb = this._fnAndFlush(fn, c