cnhis-design-vue 3.1.40-release.5 → 3.1.40-release.6

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

@@ -1,27 +0,0 @@
-import Hook from './Hook.js';
-import HookCodeFactory from './HookCodeFactory.js';
-
-class AsyncSeriesHookCodeFactory extends HookCodeFactory {
-  content({ onError, onDone }) {
-    return this.callTapsSeries({
-      onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-      onDone
-    });
-  }
-}
-const factory = new AsyncSeriesHookCodeFactory();
-const COMPILE = function(options) {
-  factory.setup(this, options);
-  return factory.create(options);
-};
-function AsyncSeriesHook(args = [], name = void 0) {
-  const hook = new Hook(args, name);
-  hook.constructor = AsyncSeriesHook;
-  hook.compile = COMPILE;
-  hook._call = void 0;
-  hook.call = void 0;
-  return hook;
-}
-AsyncSeriesHook.prototype = null;
-
-export { AsyncSeriesHook as default };

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

@@ -1,12 +0,0 @@
-import './Hook.js';
-import HookCodeFactory from './HookCodeFactory.js';
-
-class AsyncSeriesLoopHookCodeFactory extends HookCodeFactory {
-  content({ onError, onDone }) {
-    return this.callTapsLooping({
-      onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-      onDone
-    });
-  }
-}
-new AsyncSeriesLoopHookCodeFactory();

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

@@ -1,22 +0,0 @@
-import './Hook.js';
-import HookCodeFactory from './HookCodeFactory.js';
-
-class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
-  content({ onError, onResult }) {
-    return this.callTapsSeries({
-      onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
-      onResult: (i, result, next) => {
-        let code = "";
-        code += `if(${result} !== undefined) {
-`;
-        code += `${this._args[0]} = ${result};
-`;
-        code += "}\n";
-        code += next();
-        return code;
-      },
-      onDone: () => onResult(this._args[0])
-    });
-  }
-}
-new AsyncSeriesWaterfallHookCodeFactory();

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

@@ -1,140 +0,0 @@
-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() {
-    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.js

@@ -1,456 +0,0 @@
-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 += "}\n";
-        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 {\n";
-        code2 += next();
-        code2 += "}\n";
-        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/SyncBailHook.js

@@ -1,19 +0,0 @@
-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.js

@@ -1,34 +0,0 @@
-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 };