@typescript-guy/fn-monitor 1.0.0

package/dist/scope/index.js

@@ -0,0 +1,168 @@
+import { NOINIT, DEADZONE } from '../share/const.js';
+import { Prop, Var } from './variable.js';
+import { create, define } from '../share/util.js';
+
+class Scope {
+  /**
+   * The parent scope along the scope chain
+   * @private
+   * @readonly
+   */
+  parent;
+  /**
+   * To distinguish function scope and block scope
+   * The value is true for function scope or false for block scope
+   * @private
+   * @readonly
+   */
+  isolated;
+  /**
+   * Context simulation object
+   * @private
+   * @readonly
+   */
+  context = create(null);
+  /**
+   * To memoize the object for with-statement context
+   * @private
+   */
+  withContext = create(null);
+  /**
+   * Create a simulated scope
+   * @param parent the parent scope along the scope chain (default: null)
+   * @param isolated true for function scope or false for block scope (default: false)
+   */
+  interpreter = void 0;
+  constructor(parent, isolated = false, interpreter) {
+    this.parent = parent;
+    this.isolated = isolated;
+    this.interpreter = interpreter || (parent ? parent.interpreter : void 0);
+  }
+  hasParent() {
+    return this.parent !== null;
+  }
+  get scopeContext() {
+    return this.context;
+  }
+  get scopeParent() {
+    return this.parent;
+  }
+  get scopeDepth() {
+    let d = 0;
+    let currentScope = this;
+    while (currentScope && currentScope.hasParent()) {
+      d++;
+      currentScope = currentScope.scopeParent;
+    }
+    return d;
+  }
+  /**
+   * Get global scope
+   */
+  global() {
+    let scope = this;
+    while (scope.parent) {
+      scope = scope.parent;
+    }
+    return scope;
+  }
+  /**
+   * Find a variable along scope chain
+   * @param name variable identifier name
+   */
+  find(name) {
+    if (this.context[name]) {
+      return this.context[name];
+    } else if (name in this.withContext) {
+      return new Prop(this.withContext, name);
+    } else if (this.parent) {
+      return this.parent.find(name);
+    } else {
+      const win = this.global().find("window").get();
+      if (name in win) {
+        return new Prop(win, name);
+      } else {
+        return null;
+      }
+    }
+  }
+  /**
+   * Declare a var variable
+   * @param name variable identifier name
+   * @param value variable value
+   */
+  var(name, value) {
+    let scope = this;
+    while (scope.parent && !scope.isolated) {
+      scope = scope.parent;
+    }
+    const variable = scope.context[name];
+    if (!variable) {
+      scope.context[name] = new Var("var", value === NOINIT ? void 0 : value);
+    } else {
+      if (variable.kind === "var") {
+        if (value !== NOINIT) {
+          variable.set(value);
+        }
+      } else {
+        throw new SyntaxError(`Identifier '${name}' has already been declared`);
+      }
+    }
+    if (!scope.parent) {
+      const win = scope.find("window").get();
+      if (value !== NOINIT) {
+        define(win, name, { value, writable: true, enumerable: true });
+      }
+    }
+  }
+  /**
+   * Declare a let variable
+   * @param name variable identifier name
+   * @param value variable value
+   */
+  let(name, value) {
+    const variable = this.context[name];
+    if (!variable || variable.get() === DEADZONE) {
+      this.context[name] = new Var("let", value);
+    } else {
+      throw new SyntaxError(`Identifier '${name}' has already been declared`);
+    }
+  }
+  /**
+   * Declare a const variable
+   * @param name variable identifier name
+   * @param value variable value
+   */
+  const(name, value) {
+    const variable = this.context[name];
+    if (!variable || variable.get() === DEADZONE) {
+      this.context[name] = new Var("const", value);
+    } else {
+      throw new SyntaxError(`Identifier '${name}' has already been declared`);
+    }
+  }
+  /**
+   * Declare a function
+   * @param name function name
+   * @param value function
+   */
+  func(name, value) {
+    const variable = this.context[name];
+    if (!variable || variable.kind === "var") {
+      this.context[name] = new Var("var", value);
+    } else {
+      throw new SyntaxError(`Identifier '${name}' has already been declared`);
+    }
+  }
+  /**
+   * Memoize the object for with-statement context
+   * @param value object
+   */
+  with(value) {
+    if (Object.keys(value)) {
+      this.withContext = value;
+    }
+  }
+}
+
+export { Scope as default };

package/dist/scope/variable.d.ts

@@ -0,0 +1,20 @@
+export type VarKind = 'var' | 'let' | 'const';
+export interface Variable {
+    get(): any;
+    set(value: any): boolean;
+}
+export declare class Var implements Variable {
+    readonly kind: VarKind;
+    private value;
+    constructor(kind: VarKind, value: any);
+    get(): any;
+    set(value: any): any;
+}
+export declare class Prop implements Variable {
+    private readonly object;
+    private readonly property;
+    constructor(object: any, property: string);
+    get(): any;
+    set(value: any): boolean;
+    del(): boolean;
+}

package/dist/scope/variable.js

@@ -0,0 +1,38 @@
+class Var {
+  kind;
+  value;
+  constructor(kind, value) {
+    this.kind = kind;
+    this.value = value;
+  }
+  get() {
+    return this.value;
+  }
+  set(value) {
+    if (this.kind === "const") {
+      throw new TypeError("Assignment to constant variable");
+    } else {
+      return this.value = value;
+    }
+  }
+}
+class Prop {
+  object;
+  property;
+  constructor(object, property) {
+    this.object = object;
+    this.property = property;
+  }
+  get() {
+    return this.object[this.property];
+  }
+  set(value) {
+    this.object[this.property] = value;
+    return true;
+  }
+  del() {
+    return delete this.object[this.property];
+  }
+}
+
+export { Prop, Var };

package/dist/share/async.d.ts

@@ -0,0 +1,7 @@
+export interface runAsyncOptions {
+    res?: any;
+    err?: any;
+    ret?: any;
+    fullRet?: boolean;
+}
+export declare function runAsync(iterator: IterableIterator<any>, options?: runAsyncOptions): Promise<any>;

package/dist/share/async.js

@@ -0,0 +1,43 @@
+import { AWAIT } from './const.js';
+
+function runAsync(iterator, options = {}) {
+  const { res, err, ret, fullRet } = options;
+  return new Promise((resolve, reject) => {
+    if ("ret" in options) {
+      return resolve(iterator.return(ret));
+    }
+    if ("err" in options) {
+      onRejected(err);
+    } else {
+      onFulfilled(res);
+    }
+    function onFulfilled(res2) {
+      let ret2;
+      try {
+        ret2 = iterator.next(res2);
+      } catch (e) {
+        return reject(e);
+      }
+      next(ret2);
+      return null;
+    }
+    function onRejected(err2) {
+      let ret2;
+      try {
+        ret2 = iterator.throw(err2);
+      } catch (e) {
+        return reject(e);
+      }
+      next(ret2);
+    }
+    function next(ret2) {
+      if (ret2.done) return resolve(fullRet ? ret2 : ret2.value);
+      if (ret2.value !== AWAIT) return resolve(ret2);
+      const awaitValue = ret2.value.RES;
+      const value = awaitValue && awaitValue.then === "function" ? awaitValue : Promise.resolve(awaitValue);
+      return value.then(onFulfilled, onRejected);
+    }
+  });
+}
+
+export { runAsync };

package/dist/share/const.d.ts

@@ -0,0 +1,25 @@
+export declare const AWAIT: {
+    RES: any;
+};
+export declare const RETURN: {
+    RES: any;
+};
+export declare const CONTINUE: {
+    LABEL: string;
+};
+export declare const BREAK: {
+    LABEL: string;
+};
+export declare const SUPER: string;
+export declare const SUPERCALL: string;
+export declare const NOCTOR: string;
+export declare const CLSCTOR: string;
+export declare const NEWTARGET: string;
+export declare const PRIVATE: string;
+export declare const NOINIT: string;
+export declare const DEADZONE: string;
+export declare const OPTCHAIN: string;
+export declare const IMPORT: string;
+export declare const EXPORTS: string;
+export declare const STRICT: string;
+export declare const STRICT_FN: string;

package/dist/share/const.js

@@ -0,0 +1,21 @@
+import { createSymbol } from './util.js';
+
+const AWAIT = { RES: void 0 };
+const RETURN = { RES: void 0 };
+const CONTINUE = { LABEL: void 0 };
+const BREAK = { LABEL: void 0 };
+const SUPER = createSymbol("super");
+const SUPERCALL = createSymbol("supercall");
+const NOCTOR = createSymbol("noctor");
+const CLSCTOR = createSymbol("clsctor");
+const NEWTARGET = createSymbol("newtarget");
+const PRIVATE = createSymbol("private");
+const NOINIT = createSymbol("noinit");
+const DEADZONE = createSymbol("deadzone");
+const OPTCHAIN = createSymbol("optchain");
+const IMPORT = createSymbol("import");
+const EXPORTS = createSymbol("exports");
+const STRICT = createSymbol("strict");
+const STRICT_FN = createSymbol("strict-fn");
+
+export { AWAIT, BREAK, CLSCTOR, CONTINUE, DEADZONE, EXPORTS, IMPORT, NEWTARGET, NOCTOR, NOINIT, OPTCHAIN, PRIVATE, RETURN, STRICT, STRICT_FN, SUPER, SUPERCALL };

package/dist/share/util.d.ts

@@ -0,0 +1,33 @@
+export declare const freeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};
+export declare const define: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+export declare const getDptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare function hasOwn(obj: any, key: string): boolean;
+export declare const getOwnNames: (o: any) => string[];
+export declare function setProto(obj: any, proto: any): void;
+export declare function getProto(obj: any): any;
+export declare function getGetter(obj: any, key: string): (() => any) | ((v: any) => void);
+export declare function getSetter(obj: any, key: string): (() => any) | ((v: any) => void);
+export declare const create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+};
+export declare function inherits(subClass: (...args: any[]) => any, superClass: (...args: any[]) => any): void;
+export declare function callSuper(target: any, superClass: (...args: any[]) => any, args?: any[]): any;
+export declare function _assign(target: any): any;
+export declare const assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+    (target: object, ...sources: any[]): any;
+};
+export declare let globalObj: any;
+export declare const WINDOW: string;
+export declare function createSandBox(): any;
+export declare function createSymbol(key: string): string;
+export declare function getAsyncIterator(obj: any): any;