zone.js
Version:
Zones for JavaScript
1,013 lines • 105 kB
JavaScript
'use strict';
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
/**
* @license Angular
* (c) 2010-2026 Google LLC. https://angular.dev/
* License: MIT
*/ (function (g, f) { if (typeof define == "function" && define.amd) {
define(f);
}
else if (typeof exports == "object" && typeof module < "u") {
module.exports = f();
}
else {
var m = f();
for (var i in m)
g[i] = m[i];
} }(typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : this, function () {
var exports = {};
var __exports = exports;
var module = { exports: exports };
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 = function (obj, key, value) { return key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value: value }) : obj[key] = value; };
var __spreadValues = function (a, b) {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var _i = 0, _c = __getOwnPropSymbols(b); _i < _c.length; _i++) {
var prop = _c[_i];
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var __spreadProps = function (a, b) { return __defProps(a, __getOwnPropDescs(b)); };
var __publicField = function (obj, key, value) {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
var __async = function (__this, __arguments, generator) {
return new Promise(function (resolve, reject) {
var fulfilled = function (value) {
try {
step(generator.next(value));
}
catch (e) {
reject(e);
}
};
var rejected = function (value) {
try {
step(generator.throw(value));
}
catch (e) {
reject(e);
}
};
var step = function (x) { return 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", function (global3, Zone3, api) {
var _a;
var __extends = function (d, b) {
for (var 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;
var SyncTestZoneSpec = Zone3["SyncTestZoneSpec"];
var ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
if (!SyncTestZoneSpec)
throw new Error("Missing: SyncTestZoneSpec");
if (!ProxyZoneSpec2)
throw new Error("Missing: ProxyZoneSpec");
var ambientZone = Zone3.current;
var symbol = Zone3.__symbol__;
var disablePatchingJasmineClock = global3[symbol("fakeAsyncDisablePatchingClock")] === true;
var enableAutoFakeAsyncWhenClockPatched = !disablePatchingJasmineClock && (global3[symbol("fakeAsyncPatchLock")] === true || global3[symbol("fakeAsyncAutoFakeAsyncWhenClockPatched")] === true);
var jasmineEnv = jasmine.getEnv();
["describe", "xdescribe", "fdescribe"].forEach(function (methodName) {
var originalJasmineFn = jasmineEnv[methodName];
jasmineEnv[methodName] = function (description, specDefinitions) {
return originalJasmineFn.call(this, description, wrapDescribeInZone(description, specDefinitions));
};
});
["it", "xit", "fit"].forEach(function (methodName) {
var 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(function (methodName) {
var originalJasmineFn = jasmineEnv[methodName];
jasmineEnv[symbol(methodName)] = originalJasmineFn;
jasmineEnv[methodName] = function (specDefinitions, timeout) {
arguments[0] = wrapTestInZone(specDefinitions);
return originalJasmineFn.apply(this, arguments);
};
});
if (!disablePatchingJasmineClock) {
var originalClockFn_1 = jasmine[symbol("clock")] = jasmine["clock"];
jasmine["clock"] = function () {
var clock = originalClockFn_1.apply(this, arguments);
if (!clock[symbol("patched")]) {
clock[symbol("patched")] = symbol("patched");
var originalTick_1 = clock[symbol("tick")] = clock.tick;
clock.tick = function () {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
return fakeAsyncZoneSpec.tick.apply(fakeAsyncZoneSpec, arguments);
}
return originalTick_1.apply(this, arguments);
};
var originalMockDate_1 = clock[symbol("mockDate")] = clock.mockDate;
clock.mockDate = function () {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
var dateTime = arguments.length > 0 ? arguments[0] : /* @__PURE__ */ new Date();
return fakeAsyncZoneSpec.setFakeBaseSystemTime.apply(fakeAsyncZoneSpec, dateTime && typeof dateTime.getTime === "function" ? [dateTime.getTime()] : arguments);
}
return originalMockDate_1.apply(this, arguments);
};
if (enableAutoFakeAsyncWhenClockPatched) {
["install", "uninstall"].forEach(function (methodName) {
var originalClockFn2 = clock[symbol(methodName)] = clock[methodName];
clock[methodName] = function () {
var FakeAsyncTestZoneSpec2 = Zone3["FakeAsyncTestZoneSpec"];
if (FakeAsyncTestZoneSpec2) {
jasmine[symbol("clockInstalled")] = "install" === methodName;
return;
}
return originalClockFn2.apply(this, arguments);
};
});
}
}
return clock;
};
}
if (!jasmine[Zone3.__symbol__("createSpyObj")]) {
var originalCreateSpyObj_1 = jasmine.createSpyObj;
jasmine[Zone3.__symbol__("createSpyObj")] = originalCreateSpyObj_1;
jasmine.createSpyObj = function () {
var args = Array.prototype.slice.call(arguments);
var propertyNames = args.length >= 3 ? args[2] : null;
var spyObj;
if (propertyNames) {
var defineProperty_1 = Object.defineProperty;
Object.defineProperty = function (obj, p, attributes) {
return defineProperty_1.call(this, obj, p, __spreadProps(__spreadValues({}, attributes), {
configurable: true,
enumerable: true
}));
};
try {
spyObj = originalCreateSpyObj_1.apply(this, args);
}
finally {
Object.defineProperty = defineProperty_1;
}
}
else {
spyObj = originalCreateSpyObj_1.apply(this, args);
}
return spyObj;
};
}
function wrapDescribeInZone(description, describeBody) {
return function () {
var syncZone = ambientZone.fork(new SyncTestZoneSpec("jasmine.describe#".concat(description)));
return syncZone.run(describeBody, this, arguments);
};
}
function runInTestZone(testBody, applyThis, queueRunner, done) {
var isClockInstalled = !!jasmine[symbol("clockInstalled")];
var testProxyZoneSpec = queueRunner.testProxyZoneSpec;
var testProxyZone = queueRunner.testProxyZone;
var lastDelegate;
if (isClockInstalled && enableAutoFakeAsyncWhenClockPatched) {
var 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);
});
}
var j$ = jasmine;
var privateApis = ((_a = j$ == null ? void 0 : j$.private) == null ? void 0 : _a.QueueRunner) ? j$ == null ? void 0 : j$.private : j$;
var QueueRunner = privateApis.QueueRunner;
privateApis.QueueRunner = function (_super) {
__extends(ZoneQueueRunner, _super);
function ZoneQueueRunner(attrs) {
var _this = this;
if (attrs.onComplete) {
attrs.onComplete = /* @__PURE__ */ (function (fn) { return function () {
_this.testProxyZone = null;
_this.testProxyZoneSpec = null;
ambientZone.scheduleMicroTask("jasmine.onComplete", fn);
}; })(attrs.onComplete);
}
var nativeSetTimeout = global3[Zone3.__symbol__("setTimeout")];
var 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;
}
var 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.") {
var proxyZoneSpec = this && this.testProxyZoneSpec;
if (proxyZoneSpec) {
var pendingTasksInfo = proxyZoneSpec.getAndClearPendingTasksInfo();
try {
error.message += pendingTasksInfo;
}
catch (err) {
}
}
}
if (onException) {
onException.call(this, error);
}
};
_super.call(this, attrs);
}
ZoneQueueRunner.prototype.execute = function () {
var _this = this;
var zone = Zone3.current;
var 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", function () { return 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", function (context, Zone3, api) {
if (typeof jest === "undefined" || jest["__zone_patch__"]) {
return;
}
Zone3[api.symbol("ignoreConsoleErrorUncaughtError")] = true;
jest["__zone_patch__"] = true;
var ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
var SyncTestZoneSpec = Zone3["SyncTestZoneSpec"];
if (!ProxyZoneSpec2) {
throw new Error("Missing ProxyZoneSpec");
}
var rootZone = Zone3.current;
var syncZone = rootZone.fork(new SyncTestZoneSpec("jest.describe"));
var proxyZoneSpec = new ProxyZoneSpec2();
var proxyZone = rootZone.fork(proxyZoneSpec);
function wrapDescribeFactoryInZone(originalJestFn) {
return function () {
var tableArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
tableArgs[_i] = arguments[_i];
}
var originalDescribeFn = originalJestFn.apply(this, tableArgs);
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
args[1] = wrapDescribeInZone(args[1]);
return originalDescribeFn.apply(this, args);
};
};
}
function wrapTestFactoryInZone(originalJestFn) {
return function () {
var tableArgs = [];
for (var _i = 0; _i < arguments.length; _i++) {
tableArgs[_i] = arguments[_i];
}
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
args[1] = wrapTestInZone(args[1]);
return originalJestFn.apply(this, tableArgs).apply(this, args);
};
};
}
function wrapDescribeInZone(describeBody) {
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return syncZone.run(describeBody, this, args);
};
}
function wrapTestInZone(testBody, isTestFunc) {
if (isTestFunc === void 0) { isTestFunc = false; }
if (typeof testBody !== "function") {
return testBody;
}
var wrappedFunc = function () {
if (Zone3[api.symbol("useFakeTimersCalled")] === true && testBody && !testBody.isFakeAsync) {
var 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(function (methodName) {
var originalJestFn = context[methodName];
if (context[Zone3.__symbol__(methodName)]) {
return;
}
context[Zone3.__symbol__(methodName)] = originalJestFn;
context[methodName] = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
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(function (methodName) {
var originalJestFn = context[methodName];
if (context[Zone3.__symbol__(methodName)]) {
return;
}
context[Zone3.__symbol__(methodName)] = originalJestFn;
context[methodName] = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
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(function (methodName) {
var originalJestFn = context[methodName];
if (context[Zone3.__symbol__(methodName)]) {
return;
}
context[Zone3.__symbol__(methodName)] = originalJestFn;
context[methodName] = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
args[0] = wrapTestInZone(args[0]);
return originalJestFn.apply(this, args);
};
});
Zone3.patchJestObject = function patchJestObject(Timer, isModern) {
if (isModern === void 0) { isModern = false; }
function isPatchingFakeTimer() {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
return !!fakeAsyncZoneSpec;
}
function isInTestFunc() {
var proxyZoneSpec2 = Zone3.current.get("ProxyZoneSpec");
return proxyZoneSpec2 && proxyZoneSpec2.isTestFunc;
}
if (Timer[api.symbol("fakeTimers")]) {
return;
}
Timer[api.symbol("fakeTimers")] = true;
api.patchMethod(Timer, "_checkFakeTimers", function (delegate) {
return function (self2, args) {
if (isPatchingFakeTimer()) {
return true;
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "useFakeTimers", function (delegate) {
return function (self2, args) {
Zone3[api.symbol("useFakeTimersCalled")] = true;
if (isModern || isInTestFunc()) {
return delegate.apply(self2, args);
}
return self2;
};
});
api.patchMethod(Timer, "useRealTimers", function (delegate) {
return function (self2, args) {
Zone3[api.symbol("useFakeTimersCalled")] = false;
if (isModern || isInTestFunc()) {
return delegate.apply(self2, args);
}
return self2;
};
});
api.patchMethod(Timer, "setSystemTime", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec && isPatchingFakeTimer()) {
fakeAsyncZoneSpec.setFakeBaseSystemTime(args[0]);
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "getRealSystemTime", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec && isPatchingFakeTimer()) {
return fakeAsyncZoneSpec.getRealSystemTime();
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "runAllTicks", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.flushMicrotasks();
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "runAllTimers", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.flush(100, true);
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "advanceTimersByTime", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.tick(args[0]);
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "runOnlyPendingTimers", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.flushOnlyPendingTimers();
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "advanceTimersToNextTimer", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.tickToNext(args[0]);
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "clearAllTimers", function (delegate) {
return function (self2, args) {
var fakeAsyncZoneSpec = Zone3.current.get("FakeAsyncTestZoneSpec");
if (fakeAsyncZoneSpec) {
fakeAsyncZoneSpec.removeAllTimers();
}
else {
return delegate.apply(self2, args);
}
};
});
api.patchMethod(Timer, "getTimerCount", function (delegate) {
return function (self2, args) {
var 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", function (global3, Zone3) {
var Mocha = global3.Mocha;
if (typeof Mocha === "undefined") {
return;
}
if (typeof Zone3 === "undefined") {
throw new Error("Missing Zone.js");
}
var ProxyZoneSpec2 = Zone3["ProxyZoneSpec"];
var 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;
var rootZone = Zone3.current;
var syncZone = rootZone.fork(new SyncTestZoneSpec("Mocha.describe"));
var testZone = null;
var suiteZone = rootZone.fork(new ProxyZoneSpec2());
var mochaOriginal = {
after: global3.after,
afterEach: global3.afterEach,
before: global3.before,
beforeEach: global3.beforeEach,
describe: global3.describe,
it: global3.it
};
function modifyArguments(args, syncTest, asyncTest) {
var _loop_1 = function (i) {
var arg = args[i];
if (typeof arg === "function") {
args[i] = arg.length === 0 ? syncTest(arg) : asyncTest(arg);
args[i].toString = function () {
return arg.toString();
};
}
};
for (var i = 0; i < args.length; i++) {
_loop_1(i);
}
return args;
}
function wrapDescribeInZone(args) {
var syncTest = function (fn) {
return function () {
return syncZone.run(fn, this, arguments);
};
};
return modifyArguments(args, syncTest);
}
function wrapTestInZone(args) {
var asyncTest = function (fn) {
return function (done) {
return testZone.run(fn, this, [done]);
};
};
var syncTest = function (fn) {
return function () {
return testZone.run(fn, this);
};
};
return modifyArguments(args, syncTest, asyncTest);
}
function wrapSuiteInZone(args) {
var asyncTest = function (fn) {
return function (done) {
return suiteZone.run(fn, this, [done]);
};
};
var 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));
};
(function (originalRunTest, originalRun) {
Mocha.Runner.prototype.runTest = function (fn) {
var _this = this;
Zone3.current.scheduleMicroTask("mocha.forceTask", function () {
originalRunTest.call(_this, fn);
});
};
Mocha.Runner.prototype.run = function (fn) {
this.on("test", function (e) {
testZone = rootZone.fork(new ProxyZoneSpec2());
});
this.on("fail", function (test, err) {
var 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) {
var 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 */ (function () {
function _AsyncTestZoneSpec(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;
}
Object.defineProperty(_AsyncTestZoneSpec, "symbolParentUnresolved", {
// 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.
get: function () {
return __symbol__("parentUnresolved");
},
enumerable: false,
configurable: true
});
_AsyncTestZoneSpec.prototype.isUnresolvedChainedPromisePending = function () {
return this.unresolvedChainedPromiseCount > 0;
};
_AsyncTestZoneSpec.prototype._finishCallbackIfDone = function () {
var _this = this;
if (this._existingFinishTimer !== null) {
clearTimeout(this._existingFinishTimer);
this._existingFinishTimer = null;
}
if (!(this._pendingMicroTasks || this._pendingMacroTasks || this.supportWaitUnresolvedChainedPromise && this.isUnresolvedChainedPromisePending())) {
this.runZone.run(function () {
_this._existingFinishTimer = setTimeout(function () {
if (!_this._alreadyErrored && !(_this._pendingMicroTasks || _this._pendingMacroTasks)) {
_this.finishCallback();
}
}, 0);
});
}
};
_AsyncTestZoneSpec.prototype.patchPromiseForTest = function () {
if (!this.supportWaitUnresolvedChainedPromise) {
return;
}
var patchPromiseForTest = Promise[Zone.__symbol__("patchPromiseForTest")];
if (patchPromiseForTest) {
patchPromiseForTest();
}
};
_AsyncTestZoneSpec.prototype.unPatchPromiseForTest = function () {
if (!this.supportWaitUnresolvedChainedPromise) {
return;
}
var unPatchPromiseForTest = Promise[Zone.__symbol__("unPatchPromiseForTest")];
if (unPatchPromiseForTest) {
unPatchPromiseForTest();
}
};
_AsyncTestZoneSpec.prototype.onScheduleTask = function (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);
};
_AsyncTestZoneSpec.prototype.onInvokeTask = function (delegate, current, target, task, applyThis, applyArgs) {
if (task.type !== "eventTask") {
this._isSync = false;
}
return delegate.invokeTask(target, task, applyThis, applyArgs);
};
_AsyncTestZoneSpec.prototype.onCancelTask = function (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.
_AsyncTestZoneSpec.prototype.onInvoke = function (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();
}
}
};
_AsyncTestZoneSpec.prototype.onHandleError = function (parentZoneDelegate, currentZone, targetZone, error) {
var result = parentZoneDelegate.handleError(targetZone, error);
if (result) {
this.failCallback(error);
this._alreadyErrored = true;
}
return false;
};
_AsyncTestZoneSpec.prototype.onHasTask = function (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();
}
};
return _AsyncTestZoneSpec;
}());
function patchAsyncTest(Zone2) {
Zone2["AsyncTestZoneSpec"] = AsyncTestZoneSpec;
Zone2.__load_patch("asynctest", function (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, function (err) {
if (typeof err === "string") {
return done.fail(new Error(err));
}
else {
done.fail(err);
}
});
};
}
return function () {
var _this = this;
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return new Promise(function (finishCallback, failCallback) {
runInTestZone(fn, _this, args, finishCallback, failCallback);
});
};
};
function runInTestZone(fn, context, applyArgs, finishCallback, failCallback) {
var currentZone = Zone3.current;
var 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");
}
var 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");
}
var proxyZoneSpec = ProxyZoneSpec2.get();
ProxyZoneSpec2.assertPresent();
var proxyZone = Zone3.current.getZoneWith("ProxyZoneSpec");
var previousDelegate = proxyZoneSpec.getDelegate();
proxyZone.parent.run(function () {
var testZoneSpec = new AsyncTestZoneSpec2(function () {
if (proxyZoneSpec.getDelegate() == testZoneSpec) {
proxyZoneSpec.setDelegate(previousDelegate);
}
testZoneSpec.unPatchPromiseForTest();
currentZone.run(function () {
finishCallback();
});
}, function (error) {
if (proxyZoneSpec.getDelegate() == testZoneSpec) {
proxyZoneSpec.setDelegate(previousDelegate);
}
testZoneSpec.unPatchPromiseForTest();
currentZone.run(function () {
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() {
var 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 */ (function () {
function _ProxyZoneSpec(defaultSpecDelegate) {
if (defaultSpecDelegate === void 0) { 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);
}
_ProxyZoneSpec.get = function () {
return Zone.current.get("ProxyZoneSpec");
};
_ProxyZoneSpec.isLoaded = function () {
return _ProxyZoneSpec.get() instanceof _ProxyZoneSpec;
};
_ProxyZoneSpec.assertPresent = function () {
var spec = _ProxyZoneSpec.get();
if (spec === void 0) {
throw new Error("Expected to be running in 'ProxyZone', but it was not found.");
}
return spec;
};
_ProxyZoneSpec.prototype.setDelegate = function (delegateSpec) {
var _this = this;
var isNewDelegate = this._delegateSpec !== delegateSpec;
this._delegateSpec = delegateSpec;
this.propertyKeys && this.propertyKeys.forEach(function (key) { return delete _this.properties[key]; });
this.propertyKeys = null;
if (delegateSpec && delegateSpec.properties) {
this.propertyKeys = Object.keys(delegateSpec.properties);
this.prope