Function patchWtf

packages/zone.js/lib/zone-spec/wtf.ts:18–197

(Zone: ZoneType)

  (typeof window === 'object' && window) || (typeof self === 'object' && self) || global;

export function patchWtf(Zone: ZoneType): void {
  interface Wtf {
    trace: WtfTrace;
  }
  interface WtfScope {}
  interface WtfRange {}
  interface WtfTrace {
    events: WtfEvents;
    leaveScope(scope: WtfScope, returnValue?: any): void;
    beginTimeRange(rangeType: string, action: string): WtfRange;
    endTimeRange(range: WtfRange): void;
  }
  interface WtfEvents {
    createScope(signature: string, flags?: any): WtfScopeFn;
    createInstance(signature: string, flags?: any): WtfEventFn;
  }

  type WtfScopeFn = (...args: any[]) => WtfScope;
  type WtfEventFn = (...args: any[]) => any;

  // Detect and setup WTF.
  let wtfTrace: WtfTrace | null = null;
  let wtfEvents: WtfEvents | null = null;
  const wtfEnabled: boolean = (function (): boolean {
    const wtf: Wtf = _global['wtf'];
    if (wtf) {
      wtfTrace = wtf.trace;
      if (wtfTrace) {
        wtfEvents = wtfTrace.events;
        return true;
      }
    }
    return false;
  })();

  class WtfZoneSpec implements ZoneSpec {
    name: string = 'WTF';

    static forkInstance = wtfEnabled
      ? wtfEvents!.createInstance('Zone:fork(ascii zone, ascii newZone)')
      : null;
    static scheduleInstance: {[key: string]: WtfEventFn} = {};
    static cancelInstance: {[key: string]: WtfEventFn} = {};
    static invokeScope: {[key: string]: WtfEventFn} = {};
    static invokeTaskScope: {[key: string]: WtfEventFn} = {};

    onFork(
      parentZoneDelegate: ZoneDelegate,
      currentZone: Zone,
      targetZone: Zone,
      zoneSpec: ZoneSpec,
    ): Zone {
      const retValue = parentZoneDelegate.fork(targetZone, zoneSpec);
      WtfZoneSpec.forkInstance!(zonePathName(targetZone), retValue.name);
      return retValue;
    }

    onInvoke(