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

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

@@ -1,459 +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 += `}
-`;
-        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

@@ -1,11 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

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

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.d.ts

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

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 };

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

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

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

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

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

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

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

@@ -1,48 +0,0 @@
-import Hook from './Hook.js';
-import HookCodeFactory from './HookCodeFactory.js';
-
-class SyncWaterfallHookCodeFactory extends HookCodeFactory {
-  content({ onError, onResult, resultReturns, rethrowIfPossible }) {
-    return this.callTapsSeries({
-      onError: (i, err) => onError(err),
-      onResult: (i, result, next) => {
-        let code = "";
-        code += `if(${result} !== undefined) {
-`;
-        code += `${this._args[0]} = ${result};
-`;
-        code += `}
-`;
-        code += next();
-        return code;
-      },
-      onDone: () => onResult(this._args[0]),
-      doneReturns: resultReturns,
-      rethrowIfPossible
-    });
-  }
-}
-const factory = new SyncWaterfallHookCodeFactory();
-const TAP_ASYNC = () => {
-  throw new Error("tapAsync is not supported on a SyncWaterfallHook");
-};
-const TAP_PROMISE = () => {
-  throw new Error("tapPromise is not supported on a SyncWaterfallHook");
-};
-const COMPILE = function(options) {
-  factory.setup(this, options);
-  return factory.create(options);
-};
-function SyncWaterfallHook(args = [], name = void 0) {
-  if (args.length < 1)
-    throw new Error("Waterfall hooks must have at least one argument");
-  const hook = new Hook(args, name);
-  hook.constructor = SyncWaterfallHook;
-  hook.tapAsync = TAP_ASYNC;
-  hook.tapPromise = TAP_PROMISE;
-  hook.compile = COMPILE;
-  return hook;
-}
-SyncWaterfallHook.prototype = null;
-
-export { SyncWaterfallHook as default };