SQL Operations Studio Public Preview 1 (0.23) release source code

src/typings/globals/zone.js/index.d.ts

@@ -0,0 +1,343 @@
+// Generated by typings
+// Source: node_modules/zone.js/dist/zone.js.d.ts
+interface Zone {
+    /**
+     *
+     * @returns {Zone} The parent Zone.
+     */
+    parent: Zone;
+    /**
+     * @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;
+    /**
+     * 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(callback: Function, source: string): Function;
+    /**
+     * Invokes a function in a given zone.
+     *
+     * The invocation of `callback` can be intercepted be 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 be declaring [ZoneSpec.onInvoke]. The
+     * handling of exceptions can 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 callback
+     * @param applyThis
+     * @param applyArgs
+     * @returns {*}
+     */
+    runTask(task: Task, applyThis?: any, applyArgs?: any): any;
+    scheduleMicroTask(source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void): MicroTask;
+    scheduleMacroTask(source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void, customCancel: (task: Task) => void): MacroTask;
+    scheduleEventTask(source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void, customCancel: (task: Task) => void): EventTask;
+    /**
+     * 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]. 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;
+    /**
+     * Verify that Zone has been correctly patched. Specifically that Promise is zone aware.
+     */
+    assertZonePatched(): any;
+}
+/**
+ * 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. Usefull when debugging Zones.
+     */
+    name: string;
+    /**
+     * A set of properties to be associated with Zone. Use [Zone.get] to retrive 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 beed 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 beed declared.
+     * @param targetZone The [Zone] which originally received the request.
+     * @param delegate The argument passed into the `warp` method.
+     * @param source The argument passed into the `warp` 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 beed 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 beed 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 beed 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 cancelation.
+     *
+     * @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
+     * @param currentZone The current [Zone] where the current interceptor has beed 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 beed declared.
+     * @param targetZone The [Zone] which originally received the request.
+     * @param isEmpty
+     */
+    onHasTask?: (delegate: ZoneDelegate, current: Zone, target: 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 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 associated 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 = string;
+/**
+ */
+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 order 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;
+    /**
+     * Debug string representing the API which requested the scheduling of the task.
+     */
+    source: string;
+    /**
+     * The Function to be used by the VM on 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 chose 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 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.
+     */
+    zone: Zone;
+    /**
+     * Number of times the task has been executed, or -1 if canceled.
+     */
+    runCount: number;
+}
+interface MicroTask extends Task {
+}
+interface MacroTask extends Task {
+}
+interface EventTask extends Task {
+}
+declare const Zone: ZoneType;

src/typings/globals/zone.js/typings.json

@@ -0,0 +1,6 @@
+{
+  "resolution": "main",
+  "tree": {
+    "src": "npm:zone.js\\dist\\zone.js.d.ts"
+  }
+}