cnhis-design-vue 3.1.17-beta.0 → 3.1.17-beta.3

package/es/src/utils/tapable/HookCodeFactory.d.ts

@@ -0,0 +1,58 @@
+export default HookCodeFactory;
+declare class HookCodeFactory {
+    constructor(config: any);
+    config: any;
+    options: {
+        type: "sync" | "promise" | "async";
+        taps: Array<Tap>;
+        interceptors: Array<Interceptor>;
+    } | undefined;
+    _args: any;
+    create(options: any): Function;
+    setup(instance: any, options: any): void;
+    /**
+     * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
+     */
+    init(options: {
+        type: "sync" | "promise" | "async";
+        taps: Array<Tap>;
+        interceptors: Array<Interceptor>;
+    }): void;
+    deinit(): void;
+    contentWithInterceptors(options: any): any;
+    header(): string;
+    needContext(): boolean;
+    callTap(tapIndex: any, { onError, onResult, onDone, rethrowIfPossible }: {
+        onError: any;
+        onResult: any;
+        onDone: any;
+        rethrowIfPossible: any;
+    }): string;
+    callTapsSeries({ onError, onResult, resultReturns, onDone, doneReturns, rethrowIfPossible }: {
+        onError: any;
+        onResult: any;
+        resultReturns: any;
+        onDone: any;
+        doneReturns: any;
+        rethrowIfPossible: any;
+    }): any;
+    callTapsLooping({ onError, onDone, rethrowIfPossible }: {
+        onError: any;
+        onDone: any;
+        rethrowIfPossible: any;
+    }): any;
+    callTapsParallel({ onError, onResult, onDone, rethrowIfPossible, onTap }: {
+        onError: any;
+        onResult: any;
+        onDone: any;
+        rethrowIfPossible: any;
+        onTap?: ((i: any, run: any) => any) | undefined;
+    }): any;
+    args({ before, after }?: {
+        before: any;
+        after: any;
+    }): any;
+    getTapFn(idx: any): string;
+    getTap(idx: any): string;
+    getInterceptor(idx: any): string;
+}

package/es/src/utils/tapable/HookCodeFactory.js

@@ -0,0 +1,444 @@
+class HookCodeFactory {
+  constructor(config) {
+    this.config = config;
+    this.options = void 0;
+    this._args = void 0;
+  }
+  create(options) {
+    this.init(options);
+    let fn;
+    switch (this.options.type) {
+      case "sync":
+        fn = new Function(this.args(), '"use strict";\n' + this.header() + this.contentWithInterceptors({
+          onError: (err) => `throw ${err};
+`,
+          onResult: (result) => `return ${result};
+`,
+          resultReturns: true,
+          onDone: () => "",
+          rethrowIfPossible: true
+        }));
+        break;
+      case "async":
+        fn = new Function(this.args({
+          after: "_callback"
+        }), '"use strict";\n' + this.header() + this.contentWithInterceptors({
+          onError: (err) => `_callback(${err});
+`,
+          onResult: (result) => `_callback(null, ${result});
+`,
+          onDone: () => "_callback();\n"
+        }));
+        break;
+      case "promise":
+        let errorHelperUsed = false;
+        const content = this.contentWithInterceptors({
+          onError: (err) => {
+            errorHelperUsed = true;
+            return `_error(${err});
+`;
+          },
+          onResult: (result) => `_resolve(${result});
+`,
+          onDone: () => "_resolve();\n"
+        });
+        let code = "";
+        code += '"use strict";\n';
+        code += this.header();
+        code += "return new Promise((function(_resolve, _reject) {\n";
+        if (errorHelperUsed) {
+          code += "var _sync = true;\n";
+          code += "function _error(_err) {\n";
+          code += "if(_sync)\n";
+          code += "_resolve(Promise.resolve().then((function() { throw _err; })));\n";
+          code += "else\n";
+          code += "_reject(_err);\n";
+          code += "};\n";
+        }
+        code += content;
+        if (errorHelperUsed) {
+          code += "_sync = false;\n";
+        }
+        code += "}));\n";
+        fn = new Function(this.args(), code);
+        break;
+    }
+    this.deinit();
+    return fn;
+  }
+  setup(instance, options) {
+    instance._x = options.taps.map((t) => t.fn);
+  }
+  init(options) {
+    this.options = options;
+    this._args = options.args.slice();
+  }
+  deinit() {
+    this.options = void 0;
+    this._args = void 0;
+  }
+  contentWithInterceptors(options) {
+    if (this.options.interceptors.length > 0) {
+      const onError = options.onError;
+      const onResult = options.onResult;
+      const onDone = options.onDone;
+      let code = "";
+      for (let i = 0; i < this.options.interceptors.length; i++) {
+        const interceptor = this.options.interceptors[i];
+        if (interceptor.call) {
+          code += `${this.getInterceptor(i)}.call(${this.args({
+            before: interceptor.context ? "_context" : void 0
+          })});
+`;
+        }
+      }
+      code += this.content(Object.assign(options, {
+        onError: onError && ((err) => {
+          let code2 = "";
+          for (let i = 0; i < this.options.interceptors.length; i++) {
+            const interceptor = this.options.interceptors[i];
+            if (interceptor.error) {
+              code2 += `${this.getInterceptor(i)}.error(${err});
+`;
+            }
+          }
+          code2 += onError(err);
+          return code2;
+        }),
+        onResult: onResult && ((result) => {
+          let code2 = "";
+          for (let i = 0; i < this.options.interceptors.length; i++) {
+            const interceptor = this.options.interceptors[i];
+            if (interceptor.result) {
+              code2 += `${this.getInterceptor(i)}.result(${result});
+`;
+            }
+          }
+          code2 += onResult(result);
+          return code2;
+        }),
+        onDone: onDone && (() => {
+          let code2 = "";
+          for (let i = 0; i < this.options.interceptors.length; i++) {
+            const interceptor = this.options.interceptors[i];
+            if (interceptor.done) {
+              code2 += `${this.getInterceptor(i)}.done();
+`;
+            }
+          }
+          code2 += onDone();
+          return code2;
+        })
+      }));
+      return code;
+    } else {
+      return this.content(options);
+    }
+  }
+  header() {
+    let code = "";
+    if (this.needContext()) {
+      code += "var _context = {};\n";
+    } else {
+      code += "var _context;\n";
+    }
+    code += "var _x = this._x;\n";
+    if (this.options.interceptors.length > 0) {
+      code += "var _taps = this.taps;\n";
+      code += "var _interceptors = this.interceptors;\n";
+    }
+    return code;
+  }
+  needContext() {
+    for (const tap of this.options.taps)
+      if (tap.context)
+        return true;
+    return false;
+  }
+  callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
+    let code = "";
+    let hasTapCached = false;
+    for (let i = 0; i < this.options.interceptors.length; i++) {
+      const interceptor = this.options.interceptors[i];
+      if (interceptor.tap) {
+        if (!hasTapCached) {
+          code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};
+`;
+          hasTapCached = true;
+        }
+        code += `${this.getInterceptor(i)}.tap(${interceptor.context ? "_context, " : ""}_tap${tapIndex});
+`;
+      }
+    }
+    code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};
+`;
+    const tap = this.options.taps[tapIndex];
+    switch (tap.type) {
+      case "sync":
+        if (!rethrowIfPossible) {
+          code += `var _hasError${tapIndex} = false;
+`;
+          code += "try {\n";
+        }
+        if (onResult) {
+          code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
+            before: tap.context ? "_context" : void 0
+          })});
+`;
+        } else {
+          code += `_fn${tapIndex}(${this.args({
+            before: tap.context ? "_context" : void 0
+          })});
+`;
+        }
+        if (!rethrowIfPossible) {
+          code += "} catch(_err) {\n";
+          code += `_hasError${tapIndex} = true;
+`;
+          code += onError("_err");
+          code += "}\n";
+          code += `if(!_hasError${tapIndex}) {
+`;
+        }
+        if (onResult) {
+          code += onResult(`_result${tapIndex}`);
+        }
+        if (onDone) {
+          code += onDone();
+        }
+        if (!rethrowIfPossible) {
+          code += "}\n";
+        }
+        break;
+      case "async":
+        let cbCode = "";
+        if (onResult)
+          cbCode += `(function(_err${tapIndex}, _result${tapIndex}) {
+`;
+        else
+          cbCode += `(function(_err${tapIndex}) {
+`;
+        cbCode += `if(_err${tapIndex}) {
+`;
+        cbCode += onError(`_err${tapIndex}`);
+        cbCode += "} else {\n";
+        if (onResult) {
+          cbCode += onResult(`_result${tapIndex}`);
+        }
+        if (onDone) {
+          cbCode += onDone();
+        }
+        cbCode += "}\n";
+        cbCode += "})";
+        code += `_fn${tapIndex}(${this.args({
+          before: tap.context ? "_context" : void 0,
+          after: cbCode
+        })});
+`;
+        break;
+      case "promise":
+        code += `var _hasResult${tapIndex} = false;
+`;
+        code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
+          before: tap.context ? "_context" : void 0
+        })});
+`;
+        code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)
+`;
+        code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');
+`;
+        code += `_promise${tapIndex}.then((function(_result${tapIndex}) {
+`;
+        code += `_hasResult${tapIndex} = true;
+`;
+        if (onResult) {
+          code += onResult(`_result${tapIndex}`);
+        }
+        if (onDone) {
+          code += onDone();
+        }
+        code += `}), function(_err${tapIndex}) {
+`;
+        code += `if(_hasResult${tapIndex}) throw _err${tapIndex};
+`;
+        code += onError(`_err${tapIndex}`);
+        code += "});\n";
+        break;
+    }
+    return code;
+  }
+  callTapsSeries({ onError, onResult, resultReturns, onDone, doneReturns, rethrowIfPossible }) {
+    if (this.options.taps.length === 0)
+      return onDone();
+    const firstAsync = this.options.taps.findIndex((t) => t.type !== "sync");
+    const somethingReturns = resultReturns || doneReturns;
+    let code = "";
+    let current = onDone;
+    let unrollCounter = 0;
+    for (let j = this.options.taps.length - 1; j >= 0; j--) {
+      const i = j;
+      const unroll = current !== onDone && (this.options.taps[i].type !== "sync" || unrollCounter++ > 20);
+      if (unroll) {
+        unrollCounter = 0;
+        code += `function _next${i}() {
+`;
+        code += current();
+        code += `}
+`;
+        current = () => `${somethingReturns ? "return " : ""}_next${i}();
+`;
+      }
+      const done = current;
+      const doneBreak = (skipDone) => {
+        if (skipDone)
+          return "";
+        return onDone();
+      };
+      const content = this.callTap(i, {
+        onError: (error) => onError(i, error, done, doneBreak),
+        onResult: onResult && ((result) => {
+          return onResult(i, result, done, doneBreak);
+        }),
+        onDone: !onResult && done,
+        rethrowIfPossible: rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
+      });
+      current = () => content;
+    }
+    code += current();
+    return code;
+  }
+  callTapsLooping({ onError, onDone, rethrowIfPossible }) {
+    if (this.options.taps.length === 0)
+      return onDone();
+    const syncOnly = this.options.taps.every((t) => t.type === "sync");
+    let code = "";
+    if (!syncOnly) {
+      code += "var _looper = (function() {\n";
+      code += "var _loopAsync = false;\n";
+    }
+    code += "var _loop;\n";
+    code += "do {\n";
+    code += "_loop = false;\n";
+    for (let i = 0; i < this.options.interceptors.length; i++) {
+      const interceptor = this.options.interceptors[i];
+      if (interceptor.loop) {
+        code += `${this.getInterceptor(i)}.loop(${this.args({
+          before: interceptor.context ? "_context" : void 0
+        })});
+`;
+      }
+    }
+    code += this.callTapsSeries({
+      onError,
+      onResult: (i, result, next, doneBreak) => {
+        let code2 = "";
+        code2 += `if(${result} !== undefined) {
+`;
+        code2 += "_loop = true;\n";
+        if (!syncOnly)
+          code2 += "if(_loopAsync) _looper();\n";
+        code2 += doneBreak(true);
+        code2 += `} else {
+`;
+        code2 += next();
+        code2 += `}
+`;
+        return code2;
+      },
+      onDone: onDone && (() => {
+        let code2 = "";
+        code2 += "if(!_loop) {\n";
+        code2 += onDone();
+        code2 += "}\n";
+        return code2;
+      }),
+      rethrowIfPossible: rethrowIfPossible && syncOnly
+    });
+    code += "} while(_loop);\n";
+    if (!syncOnly) {
+      code += "_loopAsync = true;\n";
+      code += "});\n";
+      code += "_looper();\n";
+    }
+    return code;
+  }
+  callTapsParallel({ onError, onResult, onDone, rethrowIfPossible, onTap = (i, run) => run() }) {
+    if (this.options.taps.length <= 1) {
+      return this.callTapsSeries({
+        onError,
+        onResult,
+        onDone,
+        rethrowIfPossible
+      });
+    }
+    let code = "";
+    code += "do {\n";
+    code += `var _counter = ${this.options.taps.length};
+`;
+    if (onDone) {
+      code += "var _done = (function() {\n";
+      code += onDone();
+      code += "});\n";
+    }
+    for (let i = 0; i < this.options.taps.length; i++) {
+      const done = () => {
+        if (onDone)
+          return "if(--_counter === 0) _done();\n";
+        else
+          return "--_counter;";
+      };
+      const doneBreak = (skipDone) => {
+        if (skipDone || !onDone)
+          return "_counter = 0;\n";
+        else
+          return "_counter = 0;\n_done();\n";
+      };
+      code += "if(_counter <= 0) break;\n";
+      code += onTap(i, () => this.callTap(i, {
+        onError: (error) => {
+          let code2 = "";
+          code2 += "if(_counter > 0) {\n";
+          code2 += onError(i, error, done, doneBreak);
+          code2 += "}\n";
+          return code2;
+        },
+        onResult: onResult && ((result) => {
+          let code2 = "";
+          code2 += "if(_counter > 0) {\n";
+          code2 += onResult(i, result, done, doneBreak);
+          code2 += "}\n";
+          return code2;
+        }),
+        onDone: !onResult && (() => {
+          return done();
+        }),
+        rethrowIfPossible
+      }), done, doneBreak);
+    }
+    code += "} while(false);\n";
+    return code;
+  }
+  args({ before, after } = {}) {
+    let allArgs = this._args;
+    if (before)
+      allArgs = [before].concat(allArgs);
+    if (after)
+      allArgs = allArgs.concat(after);
+    if (allArgs.length === 0) {
+      return "";
+    } else {
+      return allArgs.join(", ");
+    }
+  }
+  getTapFn(idx) {
+    return `_x[${idx}]`;
+  }
+  getTap(idx) {
+    return `_taps[${idx}]`;
+  }
+  getInterceptor(idx) {
+    return `_interceptors[${idx}]`;
+  }
+}
+
+export { HookCodeFactory as default };

package/es/src/utils/tapable/HookMap.d.ts

@@ -0,0 +1,11 @@
+export default HookMap;
+declare class HookMap {
+    constructor(factory: any, name?: undefined);
+    _map: Map<any, any>;
+    name: any;
+    _factory: any;
+    _interceptors: any[];
+    get(key: any): any;
+    for(key: any): any;
+    intercept(interceptor: any): void;
+}

package/es/src/utils/tapable/HookMap.js

@@ -0,0 +1,32 @@
+const defaultFactory = (key, hook) => hook;
+class HookMap {
+  constructor(factory, name = void 0) {
+    this._map = /* @__PURE__ */ new Map();
+    this.name = name;
+    this._factory = factory;
+    this._interceptors = [];
+  }
+  get(key) {
+    return this._map.get(key);
+  }
+  for(key) {
+    const hook = this.get(key);
+    if (hook !== void 0) {
+      return hook;
+    }
+    let newHook = this._factory(key);
+    const interceptors = this._interceptors;
+    for (let i = 0; i < interceptors.length; i++) {
+      newHook = interceptors[i].factory(key, newHook);
+    }
+    this._map.set(key, newHook);
+    return newHook;
+  }
+  intercept(interceptor) {
+    this._interceptors.push(Object.assign({
+      factory: defaultFactory
+    }, interceptor));
+  }
+}
+
+export { HookMap as default };

package/es/src/utils/tapable/MultiHook.d.ts

@@ -0,0 +1,12 @@
+export default MultiHook;
+declare class MultiHook {
+    constructor(hooks: any, name?: undefined);
+    hooks: any;
+    name: any;
+    tap(options: any, fn: any): void;
+    tapAsync(options: any, fn: any): void;
+    tapPromise(options: any, fn: any): void;
+    isUsed(): boolean;
+    intercept(interceptor: any): void;
+    withOptions(options: any): MultiHook;
+}

package/es/src/utils/tapable/MultiHook.js

@@ -0,0 +1,38 @@
+class MultiHook {
+  constructor(hooks, name = void 0) {
+    this.hooks = hooks;
+    this.name = name;
+  }
+  tap(options, fn) {
+    for (const hook of this.hooks) {
+      hook.tap(options, fn);
+    }
+  }
+  tapAsync(options, fn) {
+    for (const hook of this.hooks) {
+      hook.tapAsync(options, fn);
+    }
+  }
+  tapPromise(options, fn) {
+    for (const hook of this.hooks) {
+      hook.tapPromise(options, fn);
+    }
+  }
+  isUsed() {
+    for (const hook of this.hooks) {
+      if (hook.isUsed())
+        return true;
+    }
+    return false;
+  }
+  intercept(interceptor) {
+    for (const hook of this.hooks) {
+      hook.intercept(interceptor);
+    }
+  }
+  withOptions(options) {
+    return new MultiHook(this.hooks.map((h) => h.withOptions(options)), this.name);
+  }
+}
+
+export { MultiHook as default };

package/es/src/utils/tapable/SyncBailHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncBailHook;
+declare function SyncBailHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/src/utils/tapable/SyncBailHook.js

@@ -0,0 +1,40 @@
+import Hook from './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class SyncBailHookCodeFactory extends HookCodeFactory {
+  content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
+    return this.callTapsSeries({
+      onError: (i, err) => onError(err),
+      onResult: (i, result, next) => `if(${result} !== undefined) {
+${onResult(result)};
+} else {
+${next()}}
+`,
+      resultReturns,
+      onDone,
+      rethrowIfPossible
+    });
+  }
+}
+const factory = new SyncBailHookCodeFactory();
+const TAP_ASYNC = () => {
+  throw new Error("tapAsync is not supported on a SyncBailHook");
+};
+const TAP_PROMISE = () => {
+  throw new Error("tapPromise is not supported on a SyncBailHook");
+};
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function SyncBailHook(args = [], name = void 0) {
+  const hook = new Hook(args, name);
+  hook.constructor = SyncBailHook;
+  hook.tapAsync = TAP_ASYNC;
+  hook.tapPromise = TAP_PROMISE;
+  hook.compile = COMPILE;
+  return hook;
+}
+SyncBailHook.prototype = null;
+
+export { SyncBailHook as default };

package/es/src/utils/tapable/SyncHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncHook;
+declare function SyncHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/src/utils/tapable/SyncHook.js

@@ -0,0 +1,34 @@
+import Hook from './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class SyncHookCodeFactory extends HookCodeFactory {
+  content({ onError, onDone, rethrowIfPossible }) {
+    return this.callTapsSeries({
+      onError: (i, err) => onError(err),
+      onDone,
+      rethrowIfPossible
+    });
+  }
+}
+const factory = new SyncHookCodeFactory();
+const TAP_ASYNC = () => {
+  throw new Error("tapAsync is not supported on a SyncHook");
+};
+const TAP_PROMISE = () => {
+  throw new Error("tapPromise is not supported on a SyncHook");
+};
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function SyncHook(args = [], name = void 0) {
+  const hook = new Hook(args, name);
+  hook.constructor = SyncHook;
+  hook.tapAsync = TAP_ASYNC;
+  hook.tapPromise = TAP_PROMISE;
+  hook.compile = COMPILE;
+  return hook;
+}
+SyncHook.prototype = null;
+
+export { SyncHook as default };

package/es/src/utils/tapable/SyncLoopHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncLoopHook;
+declare function SyncLoopHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";