cnhis-design-vue 3.1.23-beta.9 → 3.1.23

package/es/shared/components/TextOverTooltip/TextOverTooltip.vue.d.ts

@@ -46,7 +46,7 @@ declare const _default: import("vue").DefineComponent<{
     onMouseOver: (str: any) => void;
     onMouseOut: () => void;
     NTooltip: any;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     content: {
         type: (NumberConstructor | StringConstructor)[];
         required: false;

package/es/shared/components/TextOverTooltip/index.js

@@ -1 +1,2 @@
+import script from './TextOverTooltip.js';
 export { default } from './TextOverTooltip.js';

package/es/shared/components/no-data/NoData.vue.d.ts

@@ -26,11 +26,9 @@ declare const _default: import("vue").DefineComponent<{
             type: BooleanConstructor;
             default: boolean;
         };
-    }>> & {
-        [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
-    }>>;
+    }>> & {}>>;
     handleDesc: import("vue").ComputedRef<string>;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     noDataTip: {
         type: StringConstructor;
         default: string;

package/es/shared/components/no-data/index.js

@@ -1 +1,2 @@
+import script from './NoData.js';
 export { default } from './NoData.js';

package/es/shared/components/player-vod/index.vue.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
 export default _default;

package/es/shared/components/player-vod/player.d.ts

@@ -5,7 +5,7 @@ declare const _default: import("vue").DefineComponent<{
         required: true;
         default: () => void;
     };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     options: {
         type: ObjectConstructor;
         required: true;

package/es/shared/components/player-vod/video-list.d.ts

@@ -11,7 +11,7 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         default: string;
     };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     propsList: {
         type: (ArrayConstructor | StringConstructor)[];
         default: () => never[];

package/es/shared/components/player-vod/video-modal.d.ts

@@ -21,7 +21,7 @@ declare const _default: import("vue").DefineComponent<{
         type: NumberConstructor;
         default: number;
     };
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     visible: BooleanConstructor;
     formData: {
         type: ObjectConstructor;

package/es/shared/global/variable.js

@@ -1 +1,3 @@
-export { COMPONENT_NAMESPACE } from './variable2.js';
+const COMPONENT_NAMESPACE = "C";
+
+export { COMPONENT_NAMESPACE };

package/es/shared/utils/anime.js

@@ -1 +1,129 @@
-export { doAnimation } from './anime2.js';
+const pow = Math.pow, sqrt = Math.sqrt, sin = Math.sin, cos = Math.cos, PI = Math.PI, c1 = 1.70158, c2 = c1 * 1.525, c3 = c1 + 1, c4 = 2 * PI / 3, c5 = 2 * PI / 4.5;
+function bounceOut(x) {
+  const n1 = 7.5625, d1 = 2.75;
+  if (x < 1 / d1) {
+    return n1 * x * x;
+  } else if (x < 2 / d1) {
+    return n1 * (x -= 1.5 / d1) * x + 0.75;
+  } else if (x < 2.5 / d1) {
+    return n1 * (x -= 2.25 / d1) * x + 0.9375;
+  } else {
+    return n1 * (x -= 2.625 / d1) * x + 0.984375;
+  }
+}
+const animeType = {
+  easeInQuad: function(x) {
+    return x * x;
+  },
+  easeOutQuad: function(x) {
+    return 1 - (1 - x) * (1 - x);
+  },
+  easeInOutQuad: function(x) {
+    return x < 0.5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2;
+  },
+  easeInCubic: function(x) {
+    return x * x * x;
+  },
+  easeOutCubic: function(x) {
+    return 1 - pow(1 - x, 3);
+  },
+  easeInOutCubic: function(x) {
+    return x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
+  },
+  easeInQuart: function(x) {
+    return x * x * x * x;
+  },
+  easeOutQuart: function(x) {
+    return 1 - pow(1 - x, 4);
+  },
+  easeInOutQuart: function(x) {
+    return x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2;
+  },
+  easeInQuint: function(x) {
+    return x * x * x * x * x;
+  },
+  easeOutQuint: function(x) {
+    return 1 - pow(1 - x, 5);
+  },
+  easeInOutQuint: function(x) {
+    return x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2;
+  },
+  easeInSine: function(x) {
+    return 1 - cos(x * PI / 2);
+  },
+  easeOutSine: function(x) {
+    return sin(x * PI / 2);
+  },
+  easeInOutSine: function(x) {
+    return -(cos(PI * x) - 1) / 2;
+  },
+  easeInExpo: function(x) {
+    return x === 0 ? 0 : pow(2, 10 * x - 10);
+  },
+  easeOutExpo: function(x) {
+    return x === 1 ? 1 : 1 - pow(2, -10 * x);
+  },
+  easeInOutExpo: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? pow(2, 20 * x - 10) / 2 : (2 - pow(2, -20 * x + 10)) / 2;
+  },
+  easeInCirc: function(x) {
+    return 1 - sqrt(1 - pow(x, 2));
+  },
+  easeOutCirc: function(x) {
+    return sqrt(1 - pow(x - 1, 2));
+  },
+  easeInOutCirc: function(x) {
+    return x < 0.5 ? (1 - sqrt(1 - pow(2 * x, 2))) / 2 : (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2;
+  },
+  easeInElastic: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
+  },
+  easeOutElastic: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
+  },
+  easeInOutElastic: function(x) {
+    return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2 : pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5) / 2 + 1;
+  },
+  easeInBack: function(x) {
+    return c3 * x * x * x - c1 * x * x;
+  },
+  easeOutBack: function(x) {
+    return 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2);
+  },
+  easeInOutBack: function(x) {
+    return x < 0.5 ? pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+  },
+  easeInBounce: function(x) {
+    return 1 - bounceOut(1 - x);
+  },
+  easeOutBounce: bounceOut,
+  easeInOutBounce: function(x) {
+    return x < 0.5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2;
+  }
+};
+const doAnimation = (startValue, endValue, during = 1e3, callback, type = "easeInBack", onAnimationEnd) => {
+  const changeValue = endValue - startValue;
+  const updateTime = 1e3 / 60;
+  const updateCount = during / updateTime;
+  const rAF = window.requestAnimationFrame || function(cb) {
+    setTimeout(cb, updateTime);
+  };
+  const startPosition = 0;
+  const endPosition = 1;
+  const perUpdateDistance = endPosition / updateCount;
+  let position = startPosition;
+  function step() {
+    const stepValue = startValue + changeValue * animeType[type](position);
+    callback(stepValue);
+    position += perUpdateDistance;
+    if (position < endPosition) {
+      rAF(step);
+    } else {
+      rAF(() => callback(endValue));
+      onAnimationEnd == null ? void 0 : onAnimationEnd();
+    }
+  }
+  step();
+};
+
+export { doAnimation };

package/es/shared/utils/clickoutside.js

@@ -1 +1,52 @@
-export { default } from './clickoutside2.js';
+const nodeList = [];
+const ctx = "@@clickoutsideContext";
+let startClick;
+let seed = 0;
+document.addEventListener("mousedown", (e) => startClick = e, false);
+document.addEventListener(
+  "mouseup",
+  (e) => {
+    nodeList.forEach((node) => node[ctx].documentHandler(e, startClick));
+  },
+  false
+);
+function createDocumentHandler(el, binding, vnode) {
+  return function(mouseup = {}, mousedown = {}) {
+    if (!vnode || !vnode.context || !mouseup.target || !mousedown.target || el.contains(mouseup.target) || el.contains(mousedown.target) || el === mouseup.target || vnode.context.popperElm && (vnode.context.popperElm.contains(mouseup.target) || vnode.context.popperElm.contains(mousedown.target)))
+      return;
+    if (binding.expression && el[ctx].methodName && vnode.context[el[ctx].methodName]) {
+      vnode.context[el[ctx].methodName]();
+    } else {
+      el[ctx].bindingFn && el[ctx].bindingFn();
+    }
+  };
+}
+var clickoutside = {
+  mounted(el, binding, vnode) {
+    nodeList.push(el);
+    const id = seed++;
+    el[ctx] = {
+      id,
+      documentHandler: createDocumentHandler(el, binding, vnode),
+      methodName: binding.expression,
+      bindingFn: binding.value
+    };
+  },
+  update(el, binding, vnode) {
+    el[ctx].documentHandler = createDocumentHandler(el, binding, vnode);
+    el[ctx].methodName = binding.expression;
+    el[ctx].bindingFn = binding.value;
+  },
+  unmounted(el) {
+    let len = nodeList.length;
+    for (let i = 0; i < len; i++) {
+      if (nodeList[i][ctx].id === el[ctx].id) {
+        nodeList.splice(i, 1);
+        break;
+      }
+    }
+    delete el[ctx];
+  }
+};
+
+export { clickoutside as default };

package/es/shared/utils/colorLog.js

@@ -1 +1,53 @@
-export { LogsType, default } from './colorLog2.js';
+var LogsType = /* @__PURE__ */ ((LogsType2) => {
+  LogsType2["DEFAULT"] = "default";
+  LogsType2["PRIMARY"] = "primary";
+  LogsType2["SUCCESS"] = "success";
+  LogsType2["WARNING"] = "warning";
+  LogsType2["DANGER"] = "danger";
+  return LogsType2;
+})(LogsType || {});
+function typeColor(type = "primary" /* PRIMARY */) {
+  const colorMap = {
+    ["default" /* DEFAULT */]: "#f5f5f5",
+    ["primary" /* PRIMARY */]: "#409EFF",
+    ["success" /* SUCCESS */]: "#67C23A",
+    ["warning" /* WARNING */]: "#E6A23C",
+    ["danger" /* DANGER */]: "#F56C6C"
+  };
+  return colorMap[type];
+}
+class Log {
+  capsule(title, info, type = "primary" /* PRIMARY */, ...appendInfo) {
+    console.log(
+      `%c ${title} %c ${info} %c`,
+      "background:#35495E; padding: 1px; border-radius: 3px 0 0 3px; color: #fff;",
+      `background:${typeColor(type)}; padding: 1px; border-radius: 0 3px 3px 0;  color: #fff;`,
+      "background:transparent",
+      ...appendInfo
+    );
+  }
+  colorful(textArr) {
+    console.log(
+      `%c${textArr.map((t) => t.text || "").join("%c")}`,
+      ...textArr.map((t) => `color: ${typeColor(t.type)};`)
+    );
+  }
+  text(text) {
+    this.colorful([{ text, type: "default" /* DEFAULT */ }]);
+  }
+  primary(text) {
+    this.colorful([{ text, type: "primary" /* PRIMARY */ }]);
+  }
+  success(text) {
+    this.colorful([{ text, type: "success" /* SUCCESS */ }]);
+  }
+  warning(text) {
+    this.colorful([{ text, type: "warning" /* WARNING */ }]);
+  }
+  danger(text) {
+    this.colorful([{ text, type: "danger" /* DANGER */ }]);
+  }
+}
+const log = new Log();
+
+export { LogsType, log as default };

package/es/shared/utils/index.d.ts

@@ -1,8 +1,9 @@
 import { AnyObject, ArrayAble } from '../../../es/shared/types';
 import { App, Component } from 'vue';
-export declare function traverse<T extends ArrayAble<AnyObject>>(target: T, handler: (item: T extends Array<infer P> ? P : T, stop: () => void) => void, keys?: ArrayAble<string>): void;
+export declare function traverse<T extends ArrayAble<AnyObject>>(target: T, handler: (item: T extends Array<infer P> ? P : T, stop: () => void, parent?: typeof item) => void, keys?: ArrayAble<string>, parent?: T): void;
 export declare function safeComponentRegister(app: App, component: Component, cName?: string | undefined, scheduler?: () => void): void;
 export declare function generateTimeFormat(format: string): string | undefined;
 export declare function arrayed<T>(maybeArray: T): T extends Array<any> ? T : [T];
 export declare function uuidGenerator(): string;
 export declare const getStringWidth: import("@vueuse/core").UseMemoizedFn<number, [str: string]>;
+export declare const DMZ: AnyObject;

package/es/shared/utils/index.js

@@ -1 +1,98 @@
-export { arrayed, generateTimeFormat, getStringWidth, safeComponentRegister, traverse, uuidGenerator } from './index2.js';
+import { useMemoize } from '@vueuse/core';
+import { isArray, isString } from 'lodash-es';
+
+function traverse(target, handler, keys = "children", parent) {
+  function stop() {
+    throw "silence break traverse";
+  }
+  try {
+    arrayed(target).forEach((item) => {
+      handler(item, stop, parent);
+      arrayed(keys).forEach((key) => {
+        isArray(item[key]) && traverse(item[key], handler, keys, item);
+      });
+    });
+  } catch (err) {
+    if (err === "silence break traverse")
+      return;
+    throw err;
+  }
+}
+function safeComponentRegister(app, component, cName = component.name, scheduler) {
+  if (!cName)
+    throw new Error(`[CUI]: invalid component name for ${component}`);
+  const { components = {} } = app._context;
+  if (components[cName]) {
+    return;
+  }
+  if (scheduler) {
+    scheduler();
+  } else {
+    app.component(cName, component);
+  }
+}
+function generateTimeFormat(format) {
+  if (!isString(format))
+    return;
+  const matched = format.match(/[Hms:]+/);
+  if (!matched)
+    return;
+  return matched[0];
+}
+function arrayed(maybeArray) {
+  if (Array.isArray(maybeArray))
+    return maybeArray;
+  return [maybeArray];
+}
+function uuidGenerator() {
+  if (window.isSecureContext && window.crypto)
+    return `key${window.crypto.randomUUID()}`;
+  const uuid = "xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+  return `key${uuid}`;
+}
+const getStringWidth = /* @__PURE__ */ useMemoize(function(str) {
+  if (!str)
+    return 0;
+  return [...str].reduce((width, char) => {
+    if (/[a-z]/.test(char)) {
+      return width + 8;
+    }
+    if (/[A-Z]/.test(char)) {
+      return width + 12;
+    }
+    if (/\d/.test(char)) {
+      return width + 9;
+    }
+    if (/\./.test(char)) {
+      return width + 4;
+    }
+    if (/[\u4e00-\u9fa5]/.test(char)) {
+      return width + 15;
+    }
+    if (/-/.test(char)) {
+      return width + 4;
+    }
+    if (/[（）]/.test(char)) {
+      return width + 14;
+    }
+    if (/[)(]/.test(char)) {
+      return width + 5;
+    }
+    if (/-/.test(char)) {
+      return width + 10;
+    }
+    if (/%/.test(char)) {
+      return width + 14;
+    }
+    if (/‰/.test(char)) {
+      return width + 16;
+    }
+    return width + 6;
+  }, 0);
+});
+const DMZ = Object.seal(/* @__PURE__ */ Object.create(null));
+
+export { DMZ, arrayed, generateTimeFormat, getStringWidth, safeComponentRegister, traverse, uuidGenerator };

package/es/shared/utils/loadViewer.js

@@ -1 +1,11 @@
-export { loadViewer } from './loadViewer2.js';
+import { safeComponentRegister } from './index.js';
+import VueViewer from 'v-viewer';
+
+function loadViewer(app) {
+  safeComponentRegister(app, VueViewer, "viewer", () => {
+    app.use(VueViewer);
+    import('viewerjs/dist/viewer.min.css');
+  });
+}
+
+export { loadViewer };

package/es/shared/utils/state.js

@@ -1 +1,44 @@
-export { getRefs, useComputed, useRef, useRefs, useRefsArray, useState } from './state2.js';
+import { ref, onBeforeUpdate, computed, unref } from 'vue';
+
+function useState(initValue) {
+  const state = ref(initValue);
+  const getState = (isRef) => isRef ? state : unref(state);
+  return [getState, (val) => state.value = val];
+}
+function useRef() {
+  return useState(null)[0];
+}
+function useRefs() {
+  const itemRefs = /* @__PURE__ */ new Set();
+  const setItemRef = (el) => el && itemRefs.add(el);
+  onBeforeUpdate(() => itemRefs.clear());
+  return [itemRefs, setItemRef];
+}
+function useRefsArray() {
+  let itemRefs = [];
+  const setItemRef = (el) => {
+    itemRefs.push(el);
+  };
+  onBeforeUpdate(() => {
+    itemRefs = [];
+  });
+  return [itemRefs, setItemRef];
+}
+function isWritableComputedOptions(arg) {
+  return typeof arg === "object" && Reflect.has(arg || {}, "set");
+}
+function useComputed(arg) {
+  const data = isWritableComputedOptions(arg) ? computed(arg) : computed(arg);
+  const getData = (isRef) => isRef ? data : data.value;
+  if (!isWritableComputedOptions(arg)) {
+    return getData;
+  }
+  return [getData, (val) => data.value = val];
+}
+function getRefs(obj) {
+  const result = {};
+  Object.entries(obj).forEach(([k, fn]) => result[k] = fn(true));
+  return result;
+}
+
+export { getRefs, useComputed, useRef, useRefs, useRefsArray, useState };

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

@@ -9,26 +9,32 @@ class HookCodeFactory {
     let fn;
     switch (this.options.type) {
       case "sync":
-        fn = new Function(this.args(), '"use strict";\n' + this.header() + this.contentWithInterceptors({
-          onError: (err) => `throw ${err};
+        fn = new Function(
+          this.args(),
+          '"use strict";\n' + this.header() + this.contentWithInterceptors({
+            onError: (err) => `throw ${err};
 `,
-          onResult: (result) => `return ${result};
+            onResult: (result) => `return ${result};
 `,
-          resultReturns: true,
-          onDone: () => "",
-          rethrowIfPossible: true
-        }));
+            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});
+        fn = new Function(
+          this.args({
+            after: "_callback"
+          }),
+          '"use strict";\n' + this.header() + this.contentWithInterceptors({
+            onError: (err) => `_callback(${err});
 `,
-          onResult: (result) => `_callback(null, ${result});
+            onResult: (result) => `_callback(null, ${result});
 `,
-          onDone: () => "_callback();\n"
-        }));
+            onDone: () => "_callback();\n"
+          })
+        );
         break;
       case "promise":
         let errorHelperUsed = false;
@@ -92,44 +98,46 @@ class HookCodeFactory {
 `;
         }
       }
-      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});
-`;
+      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 += 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 += 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;
+            code2 += onDone();
+            return code2;
+          })
         })
-      }));
+      );
       return code;
     } else {
       return this.content(options);
@@ -394,26 +402,31 @@ class HookCodeFactory {
           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();
+      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
         }),
-        rethrowIfPossible
-      }), done, doneBreak);
+        done,
+        doneBreak
+      );
     }
     code += "} while(false);\n";
     return code;