cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

package/es/shared/utils/tapable/Hook.js

@@ -0,0 +1,140 @@
+function CALL_DELEGATE(...args) {
+  this.call = this._createCall("sync");
+  return this.call(...args);
+}
+function CALL_ASYNC_DELEGATE(...args) {
+  this.callAsync = this._createCall("async");
+  return this.callAsync(...args);
+}
+function PROMISE_DELEGATE(...args) {
+  this.promise = this._createCall("promise");
+  return this.promise(...args);
+}
+class Hook {
+  constructor(args = [], name = void 0) {
+    this._args = args;
+    this.name = name;
+    this.taps = [];
+    this.interceptors = [];
+    this._call = CALL_DELEGATE;
+    this.call = CALL_DELEGATE;
+    this._callAsync = CALL_ASYNC_DELEGATE;
+    this.callAsync = CALL_ASYNC_DELEGATE;
+    this._promise = PROMISE_DELEGATE;
+    this.promise = PROMISE_DELEGATE;
+    this._x = void 0;
+  }
+  compile(options) {
+    throw new Error("Abstract: should be overridden");
+  }
+  _createCall(type) {
+    return this.compile({
+      taps: this.taps,
+      interceptors: this.interceptors,
+      args: this._args,
+      type
+    });
+  }
+  _tap(type, options, fn) {
+    if (typeof options === "string") {
+      options = {
+        name: options.trim()
+      };
+    } else if (typeof options !== "object" || options === null) {
+      throw new Error("Invalid tap options");
+    }
+    if (typeof options.name !== "string" || options.name === "") {
+      throw new Error("Missing name for tap");
+    }
+    options = Object.assign({ type, fn }, options);
+    options = this._runRegisterInterceptors(options);
+    this._insert(options);
+  }
+  tap(options, fn) {
+    this._tap("sync", options, fn);
+  }
+  tapAsync(options, fn) {
+    this._tap("async", options, fn);
+  }
+  tapPromise(options, fn) {
+    this._tap("promise", options, fn);
+  }
+  _runRegisterInterceptors(options) {
+    for (const interceptor of this.interceptors) {
+      if (interceptor.register) {
+        const newOptions = interceptor.register(options);
+        if (newOptions !== void 0) {
+          options = newOptions;
+        }
+      }
+    }
+    return options;
+  }
+  withOptions(options) {
+    const mergeOptions = (opt) => Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
+    return {
+      name: this.name,
+      tap: (opt, fn) => this.tap(mergeOptions(opt), fn),
+      tapAsync: (opt, fn) => this.tapAsync(mergeOptions(opt), fn),
+      tapPromise: (opt, fn) => this.tapPromise(mergeOptions(opt), fn),
+      intercept: (interceptor) => this.intercept(interceptor),
+      isUsed: () => this.isUsed(),
+      withOptions: (opt) => this.withOptions(mergeOptions(opt))
+    };
+  }
+  isUsed() {
+    return this.taps.length > 0 || this.interceptors.length > 0;
+  }
+  intercept(interceptor) {
+    this._resetCompilation();
+    this.interceptors.push(Object.assign({}, interceptor));
+    if (interceptor.register) {
+      for (let i = 0; i < this.taps.length; i++) {
+        this.taps[i] = interceptor.register(this.taps[i]);
+      }
+    }
+  }
+  _resetCompilation() {
+    this.call = this._call;
+    this.callAsync = this._callAsync;
+    this.promise = this._promise;
+  }
+  _insert(item) {
+    this._resetCompilation();
+    let before;
+    if (typeof item.before === "string") {
+      before = /* @__PURE__ */ new Set([item.before]);
+    } else if (Array.isArray(item.before)) {
+      before = new Set(item.before);
+    }
+    let stage = 0;
+    if (typeof item.stage === "number") {
+      stage = item.stage;
+    }
+    let i = this.taps.length;
+    while (i > 0) {
+      i--;
+      const x = this.taps[i];
+      this.taps[i + 1] = x;
+      const xStage = x.stage || 0;
+      if (before) {
+        if (before.has(x.name)) {
+          before.delete(x.name);
+          continue;
+        }
+        if (before.size > 0) {
+          continue;
+        }
+      }
+      if (xStage > stage) {
+        continue;
+      }
+      i++;
+      break;
+    }
+    this.taps[i] = item;
+  }
+}
+Object.setPrototypeOf(Hook.prototype, null);
+
+export { Hook as default };

package/es/shared/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/shared/utils/tapable/HookCodeFactory.js

@@ -0,0 +1,459 @@
+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/shared/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/shared/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/shared/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/shared/utils/tapable/SyncBailHook.js

@@ -0,0 +1,19 @@
+import './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
+    });
+  }
+}
+new SyncBailHookCodeFactory();

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

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