1435 lines
55 KiB
TypeScript
Executable file
1435 lines
55 KiB
TypeScript
Executable file
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
/// <amd-module name="angular/packages/zone.js/lib/zone" />
|
|
/**
|
|
* Suppress closure compiler errors about unknown 'global' variable
|
|
* @fileoverview
|
|
* @suppress {undefinedVars}
|
|
*/
|
|
/**
|
|
* Zone is a mechanism for intercepting and keeping track of asynchronous work.
|
|
*
|
|
* A Zone is a global object which is configured with rules about how to intercept and keep track
|
|
* of the asynchronous callbacks. Zone has these responsibilities:
|
|
*
|
|
* 1. Intercept asynchronous task scheduling
|
|
* 2. Wrap callbacks for error-handling and zone tracking across async operations.
|
|
* 3. Provide a way to attach data to zones
|
|
* 4. Provide a context specific last frame error handling
|
|
* 5. (Intercept blocking methods)
|
|
*
|
|
* A zone by itself does not do anything, instead it relies on some other code to route existing
|
|
* platform API through it. (The zone library ships with code which monkey patches all of the
|
|
* browsers's asynchronous API and redirects them through the zone for interception.)
|
|
*
|
|
* In its simplest form a zone allows one to intercept the scheduling and calling of asynchronous
|
|
* operations, and execute additional code before as well as after the asynchronous task. The rules
|
|
* of interception are configured using [ZoneConfig]. There can be many different zone instances in
|
|
* a system, but only one zone is active at any given time which can be retrieved using
|
|
* [Zone#current].
|
|
*
|
|
*
|
|
*
|
|
* ## Callback Wrapping
|
|
*
|
|
* An important aspect of the zones is that they should persist across asynchronous operations. To
|
|
* achieve this, when a future work is scheduled through async API, it is necessary to capture, and
|
|
* subsequently restore the current zone. For example if a code is running in zone `b` and it
|
|
* invokes `setTimeout` to scheduleTask work later, the `setTimeout` method needs to 1) capture the
|
|
* current zone and 2) wrap the `wrapCallback` in code which will restore the current zone `b` once
|
|
* the wrapCallback executes. In this way the rules which govern the current code are preserved in
|
|
* all future asynchronous tasks. There could be a different zone `c` which has different rules and
|
|
* is associated with different asynchronous tasks. As these tasks are processed, each asynchronous
|
|
* wrapCallback correctly restores the correct zone, as well as preserves the zone for future
|
|
* asynchronous callbacks.
|
|
*
|
|
* Example: Suppose a browser page consist of application code as well as third-party
|
|
* advertisement code. (These two code bases are independent, developed by different mutually
|
|
* unaware developers.) The application code may be interested in doing global error handling and
|
|
* so it configures the `app` zone to send all of the errors to the server for analysis, and then
|
|
* executes the application in the `app` zone. The advertising code is interested in the same
|
|
* error processing but it needs to send the errors to a different third-party. So it creates the
|
|
* `ads` zone with a different error handler. Now both advertising as well as application code
|
|
* create many asynchronous operations, but the [Zone] will ensure that all of the asynchronous
|
|
* operations created from the application code will execute in `app` zone with its error
|
|
* handler and all of the advertisement code will execute in the `ads` zone with its error handler.
|
|
* This will not only work for the async operations created directly, but also for all subsequent
|
|
* asynchronous operations.
|
|
*
|
|
* If you think of chain of asynchronous operations as a thread of execution (bit of a stretch)
|
|
* then [Zone#current] will act as a thread local variable.
|
|
*
|
|
*
|
|
*
|
|
* ## Asynchronous operation scheduling
|
|
*
|
|
* In addition to wrapping the callbacks to restore the zone, all operations which cause a
|
|
* scheduling of work for later are routed through the current zone which is allowed to intercept
|
|
* them by adding work before or after the wrapCallback as well as using different means of
|
|
* achieving the request. (Useful for unit testing, or tracking of requests). In some instances
|
|
* such as `setTimeout` the wrapping of the wrapCallback and scheduling is done in the same
|
|
* wrapCallback, but there are other examples such as `Promises` where the `then` wrapCallback is
|
|
* wrapped, but the execution of `then` is triggered by `Promise` scheduling `resolve` work.
|
|
*
|
|
* Fundamentally there are three kinds of tasks which can be scheduled:
|
|
*
|
|
* 1. [MicroTask] used for doing work right after the current task. This is non-cancelable which is
|
|
* guaranteed to run exactly once and immediately.
|
|
* 2. [MacroTask] used for doing work later. Such as `setTimeout`. This is typically cancelable
|
|
* which is guaranteed to execute at least once after some well understood delay.
|
|
* 3. [EventTask] used for listening on some future event. This may execute zero or more times, with
|
|
* an unknown delay.
|
|
*
|
|
* Each asynchronous API is modeled and routed through one of these APIs.
|
|
*
|
|
*
|
|
* ### [MicroTask]
|
|
*
|
|
* [MicroTask]s represent work which will be done in current VM turn as soon as possible, before VM
|
|
* yielding.
|
|
*
|
|
*
|
|
* ### [MacroTask]
|
|
*
|
|
* [MacroTask]s represent work which will be done after some delay. (Sometimes the delay is
|
|
* approximate such as on next available animation frame). Typically these methods include:
|
|
* `setTimeout`, `setImmediate`, `setInterval`, `requestAnimationFrame`, and all browser specific
|
|
* variants.
|
|
*
|
|
*
|
|
* ### [EventTask]
|
|
*
|
|
* [EventTask]s represent a request to create a listener on an event. Unlike the other task
|
|
* events they may never be executed, but typically execute more than once. There is no queue of
|
|
* events, rather their callbacks are unpredictable both in order and time.
|
|
*
|
|
*
|
|
* ## Global Error Handling
|
|
*
|
|
*
|
|
* ## Composability
|
|
*
|
|
* Zones can be composed together through [Zone.fork()]. A child zone may create its own set of
|
|
* rules. A child zone is expected to either:
|
|
*
|
|
* 1. Delegate the interception to a parent zone, and optionally add before and after wrapCallback
|
|
* hooks.
|
|
* 2. Process the request itself without delegation.
|
|
*
|
|
* Composability allows zones to keep their concerns clean. For example a top most zone may choose
|
|
* to handle error handling, while child zones may choose to do user action tracking.
|
|
*
|
|
*
|
|
* ## Root Zone
|
|
*
|
|
* At the start the browser will run in a special root zone, which is configured to behave exactly
|
|
* like the platform, making any existing code which is not zone-aware behave as expected. All
|
|
* zones are children of the root zone.
|
|
*
|
|
*/
|
|
interface Zone {
|
|
/**
|
|
*
|
|
* @returns {Zone} The parent Zone.
|
|
*/
|
|
parent: Zone | null;
|
|
/**
|
|
* @returns {string} The Zone name (useful for debugging)
|
|
*/
|
|
name: string;
|
|
/**
|
|
* Returns a value associated with the `key`.
|
|
*
|
|
* If the current zone does not have a key, the request is delegated to the parent zone. Use
|
|
* [ZoneSpec.properties] to configure the set of properties associated with the current zone.
|
|
*
|
|
* @param key The key to retrieve.
|
|
* @returns {any} The value for the key, or `undefined` if not found.
|
|
*/
|
|
get(key: string): any;
|
|
/**
|
|
* Returns a Zone which defines a `key`.
|
|
*
|
|
* Recursively search the parent Zone until a Zone which has a property `key` is found.
|
|
*
|
|
* @param key The key to use for identification of the returned zone.
|
|
* @returns {Zone} The Zone which defines the `key`, `null` if not found.
|
|
*/
|
|
getZoneWith(key: string): Zone | null;
|
|
/**
|
|
* Used to create a child zone.
|
|
*
|
|
* @param zoneSpec A set of rules which the child zone should follow.
|
|
* @returns {Zone} A new child zone.
|
|
*/
|
|
fork(zoneSpec: ZoneSpec): Zone;
|
|
/**
|
|
* Wraps a callback function in a new function which will properly restore the current zone upon
|
|
* invocation.
|
|
*
|
|
* The wrapped function will properly forward `this` as well as `arguments` to the `callback`.
|
|
*
|
|
* Before the function is wrapped the zone can intercept the `callback` by declaring
|
|
* [ZoneSpec.onIntercept].
|
|
*
|
|
* @param callback the function which will be wrapped in the zone.
|
|
* @param source A unique debug location of the API being wrapped.
|
|
* @returns {function(): *} A function which will invoke the `callback` through [Zone.runGuarded].
|
|
*/
|
|
wrap<F extends Function>(callback: F, source: string): F;
|
|
/**
|
|
* Invokes a function in a given zone.
|
|
*
|
|
* The invocation of `callback` can be intercepted by declaring [ZoneSpec.onInvoke].
|
|
*
|
|
* @param callback The function to invoke.
|
|
* @param applyThis
|
|
* @param applyArgs
|
|
* @param source A unique debug location of the API being invoked.
|
|
* @returns {any} Value from the `callback` function.
|
|
*/
|
|
run<T>(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
|
|
/**
|
|
* Invokes a function in a given zone and catches any exceptions.
|
|
*
|
|
* Any exceptions thrown will be forwarded to [Zone.HandleError].
|
|
*
|
|
* The invocation of `callback` can be intercepted by declaring [ZoneSpec.onInvoke]. The
|
|
* handling of exceptions can be intercepted by declaring [ZoneSpec.handleError].
|
|
*
|
|
* @param callback The function to invoke.
|
|
* @param applyThis
|
|
* @param applyArgs
|
|
* @param source A unique debug location of the API being invoked.
|
|
* @returns {any} Value from the `callback` function.
|
|
*/
|
|
runGuarded<T>(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
|
|
/**
|
|
* Execute the Task by restoring the [Zone.currentTask] in the Task's zone.
|
|
*
|
|
* @param task to run
|
|
* @param applyThis
|
|
* @param applyArgs
|
|
* @returns {any} Value from the `task.callback` function.
|
|
*/
|
|
runTask<T>(task: Task, applyThis?: any, applyArgs?: any): T;
|
|
/**
|
|
* Schedule a MicroTask.
|
|
*
|
|
* @param source
|
|
* @param callback
|
|
* @param data
|
|
* @param customSchedule
|
|
*/
|
|
scheduleMicroTask(source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void): MicroTask;
|
|
/**
|
|
* Schedule a MacroTask.
|
|
*
|
|
* @param source
|
|
* @param callback
|
|
* @param data
|
|
* @param customSchedule
|
|
* @param customCancel
|
|
*/
|
|
scheduleMacroTask(source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, customCancel?: (task: Task) => void): MacroTask;
|
|
/**
|
|
* Schedule an EventTask.
|
|
*
|
|
* @param source
|
|
* @param callback
|
|
* @param data
|
|
* @param customSchedule
|
|
* @param customCancel
|
|
*/
|
|
scheduleEventTask(source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void, customCancel?: (task: Task) => void): EventTask;
|
|
/**
|
|
* Schedule an existing Task.
|
|
*
|
|
* Useful for rescheduling a task which was already canceled.
|
|
*
|
|
* @param task
|
|
*/
|
|
scheduleTask<T extends Task>(task: T): T;
|
|
/**
|
|
* Allows the zone to intercept canceling of scheduled Task.
|
|
*
|
|
* The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes
|
|
* the [Task.cancelFn].
|
|
*
|
|
* @param task
|
|
* @returns {any}
|
|
*/
|
|
cancelTask(task: Task): any;
|
|
}
|
|
interface ZoneType {
|
|
/**
|
|
* @returns {Zone} Returns the current [Zone]. The only way to change
|
|
* the current zone is by invoking a run() method, which will update the current zone for the
|
|
* duration of the run method callback.
|
|
*/
|
|
current: Zone;
|
|
/**
|
|
* @returns {Task} The task associated with the current execution.
|
|
*/
|
|
currentTask: Task | null;
|
|
/**
|
|
* Verify that Zone has been correctly patched. Specifically that Promise is zone aware.
|
|
*/
|
|
assertZonePatched(): void;
|
|
/**
|
|
* Return the root zone.
|
|
*/
|
|
root: Zone;
|
|
/**
|
|
* load patch for specified native module, allow user to
|
|
* define their own patch, user can use this API after loading zone.js
|
|
*/
|
|
__load_patch(name: string, fn: _PatchFn, ignoreDuplicate?: boolean): void;
|
|
/**
|
|
* Zone symbol API to generate a string with __zone_symbol__ prefix
|
|
*/
|
|
__symbol__(name: string): string;
|
|
}
|
|
/**
|
|
* Patch Function to allow user define their own monkey patch module.
|
|
*/
|
|
declare type _PatchFn = (global: Window, Zone: ZoneType, api: _ZonePrivate) => void;
|
|
/**
|
|
* _ZonePrivate interface to provide helper method to help user implement
|
|
* their own monkey patch module.
|
|
*/
|
|
interface _ZonePrivate {
|
|
currentZoneFrame: () => _ZoneFrame;
|
|
symbol: (name: string) => string;
|
|
scheduleMicroTask: (task?: MicroTask) => void;
|
|
onUnhandledError: (error: Error) => void;
|
|
microtaskDrainDone: () => void;
|
|
showUncaughtError: () => boolean;
|
|
patchEventTarget: (global: any, apis: any[], options?: any) => boolean[];
|
|
patchOnProperties: (obj: any, properties: string[] | null, prototype?: any) => void;
|
|
patchThen: (ctro: Function) => void;
|
|
patchMethod: (target: any, name: string, patchFn: (delegate: Function, delegateName: string, name: string) => (self: any, args: any[]) => any) => Function | null;
|
|
bindArguments: (args: any[], source: string) => any[];
|
|
patchMacroTask: (obj: any, funcName: string, metaCreator: (self: any, args: any[]) => any) => void;
|
|
patchEventPrototype: (_global: any, api: _ZonePrivate) => void;
|
|
isIEOrEdge: () => boolean;
|
|
ObjectDefineProperty: (o: any, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => any;
|
|
ObjectGetOwnPropertyDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
|
|
ObjectCreate(o: object | null, properties?: PropertyDescriptorMap & ThisType<any>): any;
|
|
ArraySlice(start?: number, end?: number): any[];
|
|
patchClass: (className: string) => void;
|
|
wrapWithCurrentZone: (callback: any, source: string) => any;
|
|
filterProperties: (target: any, onProperties: string[], ignoreProperties: any[]) => string[];
|
|
attachOriginToPatched: (target: any, origin: any) => void;
|
|
_redefineProperty: (target: any, callback: string, desc: any) => void;
|
|
patchCallbacks: (api: _ZonePrivate, target: any, targetName: string, method: string, callbacks: string[]) => void;
|
|
getGlobalObjects: () => {
|
|
globalSources: any;
|
|
zoneSymbolEventNames: any;
|
|
eventNames: string[];
|
|
isBrowser: boolean;
|
|
isMix: boolean;
|
|
isNode: boolean;
|
|
TRUE_STR: string;
|
|
FALSE_STR: string;
|
|
ZONE_SYMBOL_PREFIX: string;
|
|
ADD_EVENT_LISTENER_STR: string;
|
|
REMOVE_EVENT_LISTENER_STR: string;
|
|
} | undefined;
|
|
}
|
|
/**
|
|
* _ZoneFrame represents zone stack frame information
|
|
*/
|
|
interface _ZoneFrame {
|
|
parent: _ZoneFrame | null;
|
|
zone: Zone;
|
|
}
|
|
interface UncaughtPromiseError extends Error {
|
|
zone: Zone;
|
|
task: Task;
|
|
promise: Promise<any>;
|
|
rejection: any;
|
|
throwOriginal?: boolean;
|
|
}
|
|
/**
|
|
* Provides a way to configure the interception of zone events.
|
|
*
|
|
* Only the `name` property is required (all other are optional).
|
|
*/
|
|
interface ZoneSpec {
|
|
/**
|
|
* The name of the zone. Useful when debugging Zones.
|
|
*/
|
|
name: string;
|
|
/**
|
|
* A set of properties to be associated with Zone. Use [Zone.get] to retrieve them.
|
|
*/
|
|
properties?: {
|
|
[key: string]: any;
|
|
};
|
|
/**
|
|
* Allows the interception of zone forking.
|
|
*
|
|
* When the zone is being forked, the request is forwarded to this method for interception.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param zoneSpec The argument passed into the `fork` method.
|
|
*/
|
|
onFork?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, zoneSpec: ZoneSpec) => Zone;
|
|
/**
|
|
* Allows interception of the wrapping of the callback.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param delegate The argument passed into the `wrap` method.
|
|
* @param source The argument passed into the `wrap` method.
|
|
*/
|
|
onIntercept?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, source: string) => Function;
|
|
/**
|
|
* Allows interception of the callback invocation.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param delegate The argument passed into the `run` method.
|
|
* @param applyThis The argument passed into the `run` method.
|
|
* @param applyArgs The argument passed into the `run` method.
|
|
* @param source The argument passed into the `run` method.
|
|
*/
|
|
onInvoke?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, applyThis: any, applyArgs?: any[], source?: string) => any;
|
|
/**
|
|
* Allows interception of the error handling.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param error The argument passed into the `handleError` method.
|
|
*/
|
|
onHandleError?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any) => boolean;
|
|
/**
|
|
* Allows interception of task scheduling.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param task The argument passed into the `scheduleTask` method.
|
|
*/
|
|
onScheduleTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => Task;
|
|
onInvokeTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task, applyThis: any, applyArgs?: any[]) => any;
|
|
/**
|
|
* Allows interception of task cancellation.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param task The argument passed into the `cancelTask` method.
|
|
*/
|
|
onCancelTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => any;
|
|
/**
|
|
* Notifies of changes to the task queue empty status.
|
|
*
|
|
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
|
|
* @param currentZone The current [Zone] where the current interceptor has been declared.
|
|
* @param targetZone The [Zone] which originally received the request.
|
|
* @param hasTaskState
|
|
*/
|
|
onHasTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, hasTaskState: HasTaskState) => void;
|
|
}
|
|
/**
|
|
* A delegate when intercepting zone operations.
|
|
*
|
|
* A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. For
|
|
* example a child zone wrap can't just call parent zone wrap. Doing so would create a callback
|
|
* which is bound to the parent zone. What we are interested in is intercepting the callback before
|
|
* it is bound to any zone. Furthermore, we also need to pass the targetZone (zone which received
|
|
* the original request) to the delegate.
|
|
*
|
|
* The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in
|
|
* the method signature. (The original Zone which received the request.) Some methods are renamed
|
|
* to prevent confusion, because they have slightly different semantics and arguments.
|
|
*
|
|
* - `wrap` => `intercept`: The `wrap` method delegates to `intercept`. The `wrap` method returns
|
|
* a callback which will run in a given zone, where as intercept allows wrapping the callback
|
|
* so that additional code can be run before and after, but does not associate the callback
|
|
* with the zone.
|
|
* - `run` => `invoke`: The `run` method delegates to `invoke` to perform the actual execution of
|
|
* the callback. The `run` method switches to new zone; saves and restores the `Zone.current`;
|
|
* and optionally performs error handling. The invoke is not responsible for error handling,
|
|
* or zone management.
|
|
*
|
|
* Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate
|
|
* stores the closest zone which overwrites this behavior along with the closest ZoneSpec.
|
|
*
|
|
* NOTE: We have tried to make this API analogous to Event bubbling with target and current
|
|
* properties.
|
|
*
|
|
* Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its `this` to
|
|
* store internal state.
|
|
*/
|
|
interface ZoneDelegate {
|
|
zone: Zone;
|
|
fork(targetZone: Zone, zoneSpec: ZoneSpec): Zone;
|
|
intercept(targetZone: Zone, callback: Function, source: string): Function;
|
|
invoke(targetZone: Zone, callback: Function, applyThis?: any, applyArgs?: any[], source?: string): any;
|
|
handleError(targetZone: Zone, error: any): boolean;
|
|
scheduleTask(targetZone: Zone, task: Task): Task;
|
|
invokeTask(targetZone: Zone, task: Task, applyThis?: any, applyArgs?: any[]): any;
|
|
cancelTask(targetZone: Zone, task: Task): any;
|
|
hasTask(targetZone: Zone, isEmpty: HasTaskState): void;
|
|
}
|
|
declare type HasTaskState = {
|
|
microTask: boolean;
|
|
macroTask: boolean;
|
|
eventTask: boolean;
|
|
change: TaskType;
|
|
};
|
|
/**
|
|
* Task type: `microTask`, `macroTask`, `eventTask`.
|
|
*/
|
|
declare type TaskType = 'microTask' | 'macroTask' | 'eventTask';
|
|
/**
|
|
* Task type: `notScheduled`, `scheduling`, `scheduled`, `running`, `canceling`, 'unknown'.
|
|
*/
|
|
declare type TaskState = 'notScheduled' | 'scheduling' | 'scheduled' | 'running' | 'canceling' | 'unknown';
|
|
/**
|
|
*/
|
|
interface TaskData {
|
|
/**
|
|
* A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
|
|
*/
|
|
isPeriodic?: boolean;
|
|
/**
|
|
* Delay in milliseconds when the Task will run.
|
|
*/
|
|
delay?: number;
|
|
/**
|
|
* identifier returned by the native setTimeout.
|
|
*/
|
|
handleId?: number;
|
|
}
|
|
/**
|
|
* Represents work which is executed with a clean stack.
|
|
*
|
|
* Tasks are used in Zones to mark work which is performed on clean stack frame. There are three
|
|
* kinds of task. [MicroTask], [MacroTask], and [EventTask].
|
|
*
|
|
* A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set.
|
|
*
|
|
* - [MicroTask] queue represents a set of tasks which are executing right after the current stack
|
|
* frame becomes clean and before a VM yield. All [MicroTask]s execute in order of insertion
|
|
* before VM yield and the next [MacroTask] is executed.
|
|
* - [MacroTask] queue represents a set of tasks which are executed one at a time after each VM
|
|
* yield. The queue is ordered by time, and insertions can happen in any location.
|
|
* - [EventTask] is a set of tasks which can at any time be inserted to the end of the [MacroTask]
|
|
* queue. This happens when the event fires.
|
|
*
|
|
*/
|
|
interface Task {
|
|
/**
|
|
* Task type: `microTask`, `macroTask`, `eventTask`.
|
|
*/
|
|
type: TaskType;
|
|
/**
|
|
* Task state: `notScheduled`, `scheduling`, `scheduled`, `running`, `canceling`, `unknown`.
|
|
*/
|
|
state: TaskState;
|
|
/**
|
|
* Debug string representing the API which requested the scheduling of the task.
|
|
*/
|
|
source: string;
|
|
/**
|
|
* The Function to be used by the VM upon entering the [Task]. This function will delegate to
|
|
* [Zone.runTask] and delegate to `callback`.
|
|
*/
|
|
invoke: Function;
|
|
/**
|
|
* Function which needs to be executed by the Task after the [Zone.currentTask] has been set to
|
|
* the current task.
|
|
*/
|
|
callback: Function;
|
|
/**
|
|
* Task specific options associated with the current task. This is passed to the `scheduleFn`.
|
|
*/
|
|
data?: TaskData;
|
|
/**
|
|
* Represents the default work which needs to be done to schedule the Task by the VM.
|
|
*
|
|
* A zone may choose to intercept this function and perform its own scheduling.
|
|
*/
|
|
scheduleFn?: (task: Task) => void;
|
|
/**
|
|
* Represents the default work which needs to be done to un-schedule the Task from the VM. Not all
|
|
* Tasks are cancelable, and therefore this method is optional.
|
|
*
|
|
* A zone may chose to intercept this function and perform its own un-scheduling.
|
|
*/
|
|
cancelFn?: (task: Task) => void;
|
|
/**
|
|
* @type {Zone} The zone which will be used to invoke the `callback`. The Zone is captured
|
|
* at the time of Task creation.
|
|
*/
|
|
readonly zone: Zone;
|
|
/**
|
|
* Number of times the task has been executed, or -1 if canceled.
|
|
*/
|
|
runCount: number;
|
|
/**
|
|
* Cancel the scheduling request. This method can be called from `ZoneSpec.onScheduleTask` to
|
|
* cancel the current scheduling interception. Once canceled the task can be discarded or
|
|
* rescheduled using `Zone.scheduleTask` on a different zone.
|
|
*/
|
|
cancelScheduleRequest(): void;
|
|
}
|
|
interface MicroTask extends Task {
|
|
type: 'microTask';
|
|
}
|
|
interface MacroTask extends Task {
|
|
type: 'macroTask';
|
|
}
|
|
interface EventTask extends Task {
|
|
type: 'eventTask';
|
|
}
|
|
declare const Zone: ZoneType;
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
/**
|
|
* Additional `EventTarget` methods added by `Zone.js`.
|
|
*
|
|
* 1. removeAllListeners, remove all event listeners of the given event name.
|
|
* 2. eventListeners, get all event listeners of the given event name.
|
|
*/
|
|
interface EventTarget {
|
|
/**
|
|
*
|
|
* Remove all event listeners by name for this event target.
|
|
*
|
|
* This method is optional because it may not be available if you use `noop zone` when
|
|
* bootstrapping Angular application or disable the `EventTarget` monkey patch by `zone.js`.
|
|
*
|
|
* If the `eventName` is provided, will remove event listeners of that name.
|
|
* If the `eventName` is not provided, will remove all event listeners associated with
|
|
* `EventTarget`.
|
|
*
|
|
* @param eventName the name of the event, such as `click`. This parameter is optional.
|
|
*/
|
|
removeAllListeners?(eventName?: string): void;
|
|
/**
|
|
*
|
|
* Retrieve all event listeners by name.
|
|
*
|
|
* This method is optional because it may not be available if you use `noop zone` when
|
|
* bootstrapping Angular application or disable the `EventTarget` monkey patch by `zone.js`.
|
|
*
|
|
* If the `eventName` is provided, will return an array of event handlers or event listener
|
|
* objects of the given event.
|
|
* If the `eventName` is not provided, will return all listeners.
|
|
*
|
|
* @param eventName the name of the event, such as click. This parameter is optional.
|
|
*/
|
|
eventListeners?(eventName?: string): EventListenerOrEventListenerObject[];
|
|
}
|
|
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
/**
|
|
* Interface of `zone.js` configurations.
|
|
*
|
|
* You can define the following configurations on the `window/global` object before
|
|
* importing `zone.js` to change `zone.js` default behaviors.
|
|
*/
|
|
interface ZoneGlobalConfigurations {
|
|
/**
|
|
* Disable the monkey patch of the `Node.js` `EventEmitter` API.
|
|
*
|
|
* By default, `zone.js` monkey patches the `Node.js` `EventEmitter` APIs to make asynchronous
|
|
* callbacks of those APIs in the same zone when scheduled.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const EventEmitter = require('events');
|
|
* class MyEmitter extends EventEmitter {}
|
|
* const myEmitter = new MyEmitter();
|
|
*
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* myEmitter.on('event', () => {
|
|
* console.log('an event occurs in the zone', Zone.current.name);
|
|
* // the callback runs in the zone when it is scheduled,
|
|
* // so the output is 'an event occurs in the zone myZone'.
|
|
* });
|
|
* });
|
|
* myEmitter.emit('event');
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_EventEmitter = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `EventEmitter` APIs and the above code
|
|
* outputs 'an event occurred <root>'.
|
|
*/
|
|
__Zone_disable_EventEmitter?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the `Node.js` `fs` API.
|
|
*
|
|
* By default, `zone.js` monkey patches `Node.js` `fs` APIs to make asynchronous callbacks of
|
|
* those APIs in the same zone when scheduled.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const fs = require('fs');
|
|
*
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* fs.stat('/tmp/world', (err, stats) => {
|
|
* console.log('fs.stats() callback is invoked in the zone', Zone.current.name);
|
|
* // since the callback of the `fs.stat()` runs in the same zone
|
|
* // when it is called, so the output is 'fs.stats() callback is invoked in the zone myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_fs = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `fs` API and the above code
|
|
* outputs 'get stats occurred <root>'.
|
|
*/
|
|
__Zone_disable_fs?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the `Node.js` `timer` API.
|
|
*
|
|
* By default, `zone.js` monkey patches the `Node.js` `timer` APIs to make asynchronous
|
|
* callbacks of those APIs in the same zone when scheduled.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* setTimeout(() => {
|
|
* console.log('setTimeout() callback is invoked in the zone', Zone.current.name);
|
|
* // since the callback of `setTimeout()` runs in the same zone
|
|
* // when it is scheduled, so the output is 'setTimeout() callback is invoked in the zone
|
|
* // myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_timers = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `timer` APIs and the above code
|
|
* outputs 'timeout <root>'.
|
|
*/
|
|
__Zone_disable_node_timers?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the `Node.js` `process.nextTick()` API.
|
|
*
|
|
* By default, `zone.js` monkey patches the `Node.js` `process.nextTick()` API to make the
|
|
* callback in the same zone when calling `process.nextTick()`.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* process.nextTick(() => {
|
|
* console.log('process.nextTick() callback is invoked in the zone', Zone.current.name);
|
|
* // since the callback of `process.nextTick()` runs in the same zone
|
|
* // when it is scheduled, so the output is 'process.nextTick() callback is invoked in the
|
|
* // zone myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_nextTick = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `process.nextTick()` API and the above code
|
|
* outputs 'nextTick <root>'.
|
|
*/
|
|
__Zone_disable_nextTick?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the `Node.js` `crypto` API.
|
|
*
|
|
* By default, `zone.js` monkey patches the `Node.js` `crypto` APIs to make asynchronous callbacks
|
|
* of those APIs in the same zone when called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const crypto = require('crypto');
|
|
*
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* crypto.randomBytes(() => {
|
|
* console.log('crypto.randomBytes() callback is invoked in the zone', Zone.current.name);
|
|
* // since the callback of `crypto.randomBytes()` runs in the same zone
|
|
* // when it is called, so the output is 'crypto.randomBytes() callback is invoked in the
|
|
* // zone myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_crypto = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `crypto` API and the above code
|
|
* outputs 'crypto <root>'.
|
|
*/
|
|
__Zone_disable_crypto?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the `Object.defineProperty()` API.
|
|
*
|
|
* Note: This configuration is available only in the legacy bundle (dist/zone.js). This module is
|
|
* not available in the evergreen bundle (zone-evergreen.js).
|
|
*
|
|
* In the legacy browser, the default behavior of `zone.js` is to monkey patch
|
|
* `Object.defineProperty()` and `Object.create()` to try to ensure PropertyDescriptor parameter's
|
|
* configurable property to be true. This patch is only needed in some old mobile browsers.
|
|
*
|
|
* If you set `__Zone_disable_defineProperty = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `Object.defineProperty()` API and does not
|
|
* modify desc.configurable to true.
|
|
*
|
|
*/
|
|
__Zone_disable_defineProperty?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `registerElement()` API.
|
|
*
|
|
* NOTE: This configuration is only available in the legacy bundle (dist/zone.js), this
|
|
* module is not available in the evergreen bundle (zone-evergreen.js).
|
|
*
|
|
* In the legacy browser, the default behavior of `zone.js` is to monkey patch the
|
|
* `registerElement()` API to make asynchronous callbacks of the API in the same zone when
|
|
* `registerElement()` is called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const proto = Object.create(HTMLElement.prototype);
|
|
* proto.createdCallback = function() {
|
|
* console.log('createdCallback is invoked in the zone', Zone.current.name);
|
|
* };
|
|
* proto.attachedCallback = function() {
|
|
* console.log('attachedCallback is invoked in the zone', Zone.current.name);
|
|
* };
|
|
* proto.detachedCallback = function() {
|
|
* console.log('detachedCallback is invoked in the zone', Zone.current.name);
|
|
* };
|
|
* proto.attributeChangedCallback = function() {
|
|
* console.log('attributeChangedCallback is invoked in the zone', Zone.current.name);
|
|
* };
|
|
*
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* document.registerElement('x-elem', {prototype: proto});
|
|
* });
|
|
* ```
|
|
*
|
|
* When these callbacks are invoked, those callbacks will be in the zone when
|
|
* `registerElement()` is called.
|
|
*
|
|
* If you set `__Zone_disable_registerElement = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch `registerElement()` API and the above code
|
|
* outputs '<root>'.
|
|
*/
|
|
__Zone_disable_registerElement?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser legacy `EventTarget` API.
|
|
*
|
|
* NOTE: This configuration is only available in the legacy bundle (dist/zone.js), this module
|
|
* is not available in the evergreen bundle (zone-evergreen.js).
|
|
*
|
|
* In some old browsers, the `EventTarget` is not available, so `zone.js` cannot directly monkey
|
|
* patch the `EventTarget`. Instead, `zone.js` patches all known HTML elements' prototypes (such
|
|
* as `HtmlDivElement`). The callback of the `addEventListener()` will be in the same zone when
|
|
* the `addEventListener()` is called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* div.addEventListener('click', () => {
|
|
* console.log('div click event listener is invoked in the zone', Zone.current.name);
|
|
* // the output is 'div click event listener is invoked in the zone myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_EventTargetLegacy = true` before importing `zone.js`
|
|
* In some old browsers, where `EventTarget` is not available, if you set
|
|
* `__Zone_disable_EventTargetLegacy = true` before importing `zone.js`, `zone.js` does not monkey
|
|
* patch all HTML element APIs and the above code outputs 'clicked <root>'.
|
|
*/
|
|
__Zone_disable_EventTargetLegacy?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `timer` APIs.
|
|
*
|
|
* By default, `zone.js` monkey patches browser timer
|
|
* APIs (`setTimeout()`/`setInterval()`/`setImmediate()`) to make asynchronous callbacks of those
|
|
* APIs in the same zone when scheduled.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* setTimeout(() => {
|
|
* console.log('setTimeout() callback is invoked in the zone', Zone.current.name);
|
|
* // since the callback of `setTimeout()` runs in the same zone
|
|
* // when it is scheduled, so the output is 'setTimeout() callback is invoked in the zone
|
|
* // myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_timers = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch `timer` API and the above code
|
|
* outputs 'timeout <root>'.
|
|
*
|
|
*/
|
|
__Zone_disable_timers?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `requestAnimationFrame()` API.
|
|
*
|
|
* By default, `zone.js` monkey patches the browser `requestAnimationFrame()` API
|
|
* to make the asynchronous callback of the `requestAnimationFrame()` in the same zone when
|
|
* scheduled.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* requestAnimationFrame(() => {
|
|
* console.log('requestAnimationFrame() callback is invoked in the zone', Zone.current.name);
|
|
* // since the callback of `requestAnimationFrame()` will be in the same zone
|
|
* // when it is scheduled, so the output will be 'requestAnimationFrame() callback is invoked
|
|
* // in the zone myZone'
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_requestAnimationFrame = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `requestAnimationFrame()` API and the above code
|
|
* outputs 'raf <root>'.
|
|
*/
|
|
__Zone_disable_requestAnimationFrame?: boolean;
|
|
|
|
/**
|
|
*
|
|
* Disable the monkey patching of the browser's `queueMicrotask()` API.
|
|
*
|
|
* By default, `zone.js` monkey patches the browser's `queueMicrotask()` API
|
|
* to ensure that `queueMicrotask()` callback is invoked in the same zone as zone used to invoke
|
|
* `queueMicrotask()`. And also the callback is running as `microTask` like
|
|
* `Promise.prototype.then()`.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* queueMicrotask(() => {
|
|
* console.log('queueMicrotask() callback is invoked in the zone', Zone.current.name);
|
|
* // Since `queueMicrotask()` was invoked in `myZone`, same zone is restored
|
|
* // when 'queueMicrotask() callback is invoked, resulting in `myZone` being console logged.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_queueMicrotask = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch the `queueMicrotask()` API and the above code
|
|
* output will change to: 'queueMicrotask() callback is invoked in the zone <root>'.
|
|
*/
|
|
__Zone_disable_queueMicrotask?: boolean;
|
|
|
|
/**
|
|
*
|
|
* Disable the monkey patch of the browser blocking APIs(`alert()`/`prompt()`/`confirm()`).
|
|
*/
|
|
__Zone_disable_blocking?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `EventTarget` APIs.
|
|
*
|
|
* By default, `zone.js` monkey patches EventTarget APIs. The callbacks of the
|
|
* `addEventListener()` run in the same zone when the `addEventListener()` is called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* div.addEventListener('click', () => {
|
|
* console.log('div event listener is invoked in the zone', Zone.current.name);
|
|
* // the output is 'div event listener is invoked in the zone myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_EventTarget = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch EventTarget API and the above code
|
|
* outputs 'clicked <root>'.
|
|
*
|
|
*/
|
|
__Zone_disable_EventTarget?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `FileReader` APIs.
|
|
*/
|
|
__Zone_disable_FileReader?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `MutationObserver` APIs.
|
|
*/
|
|
__Zone_disable_MutationObserver?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `IntersectionObserver` APIs.
|
|
*/
|
|
__Zone_disable_IntersectionObserver?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser onProperty APIs(such as onclick).
|
|
*
|
|
* By default, `zone.js` monkey patches onXXX properties (such as onclick). The callbacks of onXXX
|
|
* properties run in the same zone when the onXXX properties is set.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* div.onclick = () => {
|
|
* console.log('div click event listener is invoked in the zone', Zone.current.name);
|
|
* // the output will be 'div click event listener is invoked in the zone myZone'
|
|
* }
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_on_property = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch onXXX properties and the above code
|
|
* outputs 'clicked <root>'.
|
|
*
|
|
*/
|
|
__Zone_disable_on_property?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `customElements` APIs.
|
|
*
|
|
* By default, `zone.js` monkey patches `customElements` APIs to make callbacks run in the
|
|
* same zone when the `customElements.define()` is called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* class TestCustomElement extends HTMLElement {
|
|
* constructor() { super(); }
|
|
* connectedCallback() {}
|
|
* disconnectedCallback() {}
|
|
* attributeChangedCallback(attrName, oldVal, newVal) {}
|
|
* adoptedCallback() {}
|
|
* }
|
|
*
|
|
* const zone = Zone.fork({name: 'myZone'});
|
|
* zone.run(() => {
|
|
* customElements.define('x-elem', TestCustomElement);
|
|
* });
|
|
* ```
|
|
*
|
|
* All those callbacks defined in TestCustomElement runs in the zone when
|
|
* the `customElements.define()` is called.
|
|
*
|
|
* If you set `__Zone_disable_customElements = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch `customElements` APIs and the above code
|
|
* runs inside <root> zone.
|
|
*/
|
|
__Zone_disable_customElements?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `XMLHttpRequest` APIs.
|
|
*
|
|
* By default, `zone.js` monkey patches `XMLHttpRequest` APIs to make XMLHttpRequest act
|
|
* as macroTask.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({
|
|
* name: 'myZone',
|
|
* onScheduleTask: (delegate, curr, target, task) => {
|
|
* console.log('task is scheduled', task.type, task.source, task.zone.name);
|
|
* return delegate.scheduleTask(target, task);
|
|
* }
|
|
* })
|
|
* const xhr = new XMLHttpRequest();
|
|
* zone.run(() => {
|
|
* xhr.onload = function() {};
|
|
* xhr.open('get', '/', true);
|
|
* xhr.send();
|
|
* });
|
|
* ```
|
|
*
|
|
* In this example, the instance of XMLHttpRequest runs in the zone and acts as a macroTask. The
|
|
* output is 'task is scheduled macroTask, XMLHttpRequest.send, zone'.
|
|
*
|
|
* If you set `__Zone_disable_XHR = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch `XMLHttpRequest` APIs and the above onScheduleTask callback
|
|
* will not be called.
|
|
*
|
|
*/
|
|
__Zone_disable_XHR?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser geolocation APIs.
|
|
*
|
|
* By default, `zone.js` monkey patches geolocation APIs to make callbacks run in the same zone
|
|
* when those APIs are called.
|
|
*
|
|
* Consider the following examples:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({
|
|
* name: 'myZone'
|
|
* });
|
|
*
|
|
* zone.run(() => {
|
|
* navigator.geolocation.getCurrentPosition(pos => {
|
|
* console.log('navigator.getCurrentPosition() callback is invoked in the zone',
|
|
* Zone.current.name);
|
|
* // output is 'navigator.getCurrentPosition() callback is invoked in the zone myZone'.
|
|
* }
|
|
* });
|
|
* ```
|
|
*
|
|
* If set you `__Zone_disable_geolocation = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch geolocation APIs and the above code
|
|
* outputs 'getCurrentPosition <root>'.
|
|
*
|
|
*/
|
|
__Zone_disable_geolocation?: boolean;
|
|
|
|
/**
|
|
* Disable the monkey patch of the browser `canvas` APIs.
|
|
*
|
|
* By default, `zone.js` monkey patches `canvas` APIs to make callbacks run in the same zone when
|
|
* those APIs are called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({
|
|
* name: 'myZone'
|
|
* });
|
|
*
|
|
* zone.run(() => {
|
|
* canvas.toBlob(blog => {
|
|
* console.log('canvas.toBlob() callback is invoked in the zone', Zone.current.name);
|
|
* // output is 'canvas.toBlob() callback is invoked in the zone myZone'.
|
|
* }
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_canvas = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch `canvas` APIs and the above code
|
|
* outputs 'canvas.toBlob <root>'.
|
|
*/
|
|
__Zone_disable_canvas?: boolean;
|
|
|
|
/**
|
|
* Disable the `Promise` monkey patch.
|
|
*
|
|
* By default, `zone.js` monkey patches `Promise` APIs to make the `then()/catch()` callbacks in
|
|
* the same zone when those callbacks are called.
|
|
*
|
|
* Consider the following examples:
|
|
*
|
|
* ```
|
|
* const zone = Zone.current.fork({name: 'myZone'});
|
|
*
|
|
* const p = Promise.resolve(1);
|
|
*
|
|
* zone.run(() => {
|
|
* p.then(() => {
|
|
* console.log('then() callback is invoked in the zone', Zone.current.name);
|
|
* // output is 'then() callback is invoked in the zone myZone'.
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
* If you set `__Zone_disable_ZoneAwarePromise = true` before importing `zone.js`,
|
|
* `zone.js` does not monkey patch `Promise` APIs and the above code
|
|
* outputs 'promise then callback <root>'.
|
|
*/
|
|
__Zone_disable_ZoneAwarePromise?: boolean;
|
|
|
|
/**
|
|
* Define event names that users don't want monkey patched by the `zone.js`.
|
|
*
|
|
* By default, `zone.js` monkey patches EventTarget.addEventListener(). The event listener
|
|
* callback runs in the same zone when the addEventListener() is called.
|
|
*
|
|
* Sometimes, you don't want all of the event names used in this patched version because it
|
|
* impacts performance. For example, you might want `scroll` or `mousemove` event listeners to run
|
|
* the native `addEventListener()` for better performance.
|
|
*
|
|
* Users can achieve this goal by defining `__zone_symbol__UNPATCHED_EVENTS = ['scroll',
|
|
* 'mousemove'];` before importing `zone.js`.
|
|
*/
|
|
__zone_symbol__UNPATCHED_EVENTS?: string[];
|
|
|
|
/**
|
|
* Define the event names of the passive listeners.
|
|
*
|
|
* To add passive event listeners, you can use `elem.addEventListener('scroll', listener,
|
|
* {passive: true});` or implement your own `EventManagerPlugin`.
|
|
*
|
|
* You can also define a global variable as follows:
|
|
*
|
|
* ```
|
|
* __zone_symbol__PASSIVE_EVENTS = ['scroll'];
|
|
* ```
|
|
*
|
|
* The preceding code makes all scroll event listeners passive.
|
|
*/
|
|
__zone_symbol__PASSIVE_EVENTS?: string[];
|
|
|
|
/**
|
|
* Disable wrapping uncaught promise rejection.
|
|
*
|
|
* By default, `zone.js` wraps the uncaught promise rejection in a new `Error` object
|
|
* which contains additional information such as a value of the rejection and a stack trace.
|
|
*
|
|
* If you set `__zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION = true;` before
|
|
* importing `zone.js`, `zone.js` will not wrap the uncaught promise rejection.
|
|
*/
|
|
__zone_symbol__DISABLE_WRAPPING_UNCAUGHT_PROMISE_REJECTION?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Interface of `zone-testing.js` test configurations.
|
|
*
|
|
* You can define the following configurations on the `window` or `global` object before
|
|
* importing `zone-testing.js` to change `zone-testing.js` default behaviors in the test runner.
|
|
*/
|
|
interface ZoneTestConfigurations {
|
|
/**
|
|
* Disable the Jasmine integration.
|
|
*
|
|
* In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches Jasmine APIs
|
|
* to make Jasmine APIs run in specified zone.
|
|
*
|
|
* 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone.
|
|
* 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`beforeAll()`/`afterAll()`
|
|
* methods run in the ProxyZone.
|
|
*
|
|
* With this patch, `async()`/`fakeAsync()` can work with the Jasmine runner.
|
|
*
|
|
* If you set `__Zone_disable_jasmine = true` before importing `zone-testing.js`,
|
|
* `zone-testing.js` does not monkey patch the jasmine APIs and the `async()`/`fakeAsync()` cannot
|
|
* work with the Jasmine runner any longer.
|
|
*/
|
|
__Zone_disable_jasmine?: boolean;
|
|
|
|
/**
|
|
* Disable the Mocha integration.
|
|
*
|
|
* In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches the Mocha APIs
|
|
* to make Mocha APIs run in the specified zone.
|
|
*
|
|
* 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone.
|
|
* 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`beforeAll()`/`afterAll()`
|
|
* methods run in the ProxyZone.
|
|
*
|
|
* With this patch, `async()`/`fakeAsync()` can work with the Mocha runner.
|
|
*
|
|
* If you set `__Zone_disable_mocha = true` before importing `zone-testing.js`,
|
|
* `zone-testing.js` does not monkey patch the Mocha APIs and the `async()/`fakeAsync()` can not
|
|
* work with the Mocha runner any longer.
|
|
*/
|
|
__Zone_disable_mocha?: boolean;
|
|
|
|
/**
|
|
* Disable the Jest integration.
|
|
*
|
|
* In the `zone-testing.js` bundle, by default, `zone-testing.js` monkey patches Jest APIs
|
|
* to make Jest APIs run in the specified zone.
|
|
*
|
|
* 1. Make the `describe()`/`xdescribe()`/`fdescribe()` methods run in the syncTestZone.
|
|
* 2. Make the `it()`/`xit()`/`fit()`/`beforeEach()`/`afterEach()`/`before()`/`after()` methods
|
|
* run in the ProxyZone.
|
|
*
|
|
* With this patch, `async()`/`fakeAsync()` can work with the Jest runner.
|
|
*
|
|
* If you set `__Zone_disable_jest = true` before importing `zone-testing.js`,
|
|
* `zone-testing.js` does not monkey patch the jest APIs and `async()`/`fakeAsync()` cannot
|
|
* work with the Jest runner any longer.
|
|
*/
|
|
__Zone_disable_jest?: boolean;
|
|
|
|
/**
|
|
* Disable monkey patch the jasmine clock APIs.
|
|
*
|
|
* By default, `zone-testing.js` monkey patches the `jasmine.clock()` API,
|
|
* so the `jasmine.clock()` can work with the `fakeAsync()/tick()` API.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* describe('jasmine.clock integration', () => {
|
|
* beforeEach(() => {
|
|
* jasmine.clock().install();
|
|
* });
|
|
* afterEach(() => {
|
|
* jasmine.clock().uninstall();
|
|
* });
|
|
* it('fakeAsync test', fakeAsync(() => {
|
|
* setTimeout(spy, 100);
|
|
* expect(spy).not.toHaveBeenCalled();
|
|
* jasmine.clock().tick(100);
|
|
* expect(spy).toHaveBeenCalled();
|
|
* }));
|
|
* });
|
|
* ```
|
|
*
|
|
* In the `fakeAsync()` method, `jasmine.clock().tick()` works just like `tick()`.
|
|
*
|
|
* If you set `__zone_symbol__fakeAsyncDisablePatchingClock = true` before importing
|
|
* `zone-testing.js`,`zone-testing.js` does not monkey patch the `jasmine.clock()` APIs and the
|
|
* `jasmine.clock()` cannot work with `fakeAsync()` any longer.
|
|
*/
|
|
__zone_symbol__fakeAsyncDisablePatchingClock?: boolean;
|
|
|
|
/**
|
|
* Enable auto running into `fakeAsync()` when installing the `jasmine.clock()`.
|
|
*
|
|
* By default, `zone-testing.js` does not automatically run into `fakeAsync()`
|
|
* if the `jasmine.clock().install()` is called.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* describe('jasmine.clock integration', () => {
|
|
* beforeEach(() => {
|
|
* jasmine.clock().install();
|
|
* });
|
|
* afterEach(() => {
|
|
* jasmine.clock().uninstall();
|
|
* });
|
|
* it('fakeAsync test', fakeAsync(() => {
|
|
* setTimeout(spy, 100);
|
|
* expect(spy).not.toHaveBeenCalled();
|
|
* jasmine.clock().tick(100);
|
|
* expect(spy).toHaveBeenCalled();
|
|
* }));
|
|
* });
|
|
* ```
|
|
*
|
|
* You must run `fakeAsync()` to make test cases in the `FakeAsyncTestZone`.
|
|
*
|
|
* If you set `__zone_symbol__fakeAsyncAutoFakeAsyncWhenClockPatched = true` before importing
|
|
* `zone-testing.js`, `zone-testing.js` can run test case automatically in the
|
|
* `FakeAsyncTestZone` without calling the `fakeAsync()`.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* describe('jasmine.clock integration', () => {
|
|
* beforeEach(() => {
|
|
* jasmine.clock().install();
|
|
* });
|
|
* afterEach(() => {
|
|
* jasmine.clock().uninstall();
|
|
* });
|
|
* it('fakeAsync test', () => { // here we don't need to call fakeAsync
|
|
* setTimeout(spy, 100);
|
|
* expect(spy).not.toHaveBeenCalled();
|
|
* jasmine.clock().tick(100);
|
|
* expect(spy).toHaveBeenCalled();
|
|
* });
|
|
* });
|
|
* ```
|
|
*
|
|
*/
|
|
__zone_symbol__fakeAsyncAutoFakeAsyncWhenClockPatched?: boolean;
|
|
|
|
/**
|
|
* Enable waiting for the unresolved promise in the `async()` test.
|
|
*
|
|
* In the `async()` test, `AsyncTestZone` waits for all the asynchronous tasks to finish. By
|
|
* default, if some promises remain unresolved, `AsyncTestZone` does not wait and reports that it
|
|
* received an unexpected result.
|
|
*
|
|
* Consider the following example:
|
|
*
|
|
* ```
|
|
* describe('wait never resolved promise', () => {
|
|
* it('async with never resolved promise test', async(() => {
|
|
* const p = new Promise(() => {});
|
|
* p.then(() => {
|
|
* // do some expectation.
|
|
* });
|
|
* }))
|
|
* });
|
|
* ```
|
|
*
|
|
* By default, this case passes, because the callback of `p.then()` is never called. Because `p`
|
|
* is an unresolved promise, there is no pending asynchronous task, which means the `async()`
|
|
* method does not wait.
|
|
*
|
|
* If you set `__zone_symbol__supportWaitUnResolvedChainedPromise = true`, the above case
|
|
* times out, because `async()` will wait for the unresolved promise.
|
|
*/
|
|
__zone_symbol__supportWaitUnResolvedChainedPromise?: boolean;
|
|
}
|
|
|
|
/**
|
|
* The interface of the `zone.js` runtime configurations.
|
|
*
|
|
* These configurations can be defined on the `Zone` object after
|
|
* importing zone.js to change behaviors. The differences between
|
|
* the `ZoneRuntimeConfigurations` and the `ZoneGlobalConfigurations` are,
|
|
*
|
|
* 1. `ZoneGlobalConfigurations` must be defined on the `global/window` object before importing
|
|
* `zone.js`. The value of the configuration cannot be changed at runtime.
|
|
*
|
|
* 2. `ZoneRuntimeConfigurations` must be defined on the `Zone` object after importing `zone.js`.
|
|
* You can change the value of this configuration at runtime.
|
|
*
|
|
*/
|
|
interface ZoneRuntimeConfigurations {
|
|
/**
|
|
* Ignore outputting errors to the console when uncaught Promise errors occur.
|
|
*
|
|
* By default, if an uncaught Promise error occurs, `zone.js` outputs the
|
|
* error to the console by calling `console.error()`.
|
|
*
|
|
* If you set `__zone_symbol__ignoreConsoleErrorUncaughtError = true`, `zone.js` does not output
|
|
* the uncaught error to `console.error()`.
|
|
*/
|
|
__zone_symbol__ignoreConsoleErrorUncaughtError?: boolean;
|
|
}
|