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

package/es/shared/utils/clickoutside.js

@@ -0,0 +1,52 @@
+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.d.ts

@@ -0,0 +1,31 @@
+export declare enum LogsType {
+    DEFAULT = "default",
+    PRIMARY = "primary",
+    SUCCESS = "success",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+declare class Log {
+    /**
+     * @description 打印一个 [ title | text ] 样式的信息
+     * @param {String} title title text
+     * @param {String} info info text
+     * @param {String} type style
+     * @param {any[]} appendInfo
+     */
+    capsule(title: string, info: any, type?: LogsType, ...appendInfo: any[]): void;
+    /**
+     * @description 打印彩色文字
+     */
+    colorful(textArr: {
+        text: any;
+        type: LogsType;
+    }[]): void;
+    text(text: any): void;
+    primary(text: any): void;
+    success(text: any): void;
+    warning(text: any): void;
+    danger(text: any): void;
+}
+declare const log: Log;
+export default log;

package/es/shared/utils/colorLog.js

@@ -0,0 +1,53 @@
+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/crypto.d.ts

@@ -0,0 +1,7 @@
+declare namespace _default {
+    export { encrypt };
+    export { decrypt };
+}
+export default _default;
+declare function encrypt(word: any): any;
+declare function decrypt(word: any): any;

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

@@ -0,0 +1,11 @@
+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, 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;
+export declare function deepOmit<T extends AnyObject>(target: T, keys: Array<keyof T>): AnyObject;
+export declare function separateMetaModule<T extends AnyObject>(modules: Record<string, unknown>): T;

package/es/shared/utils/index.js

@@ -0,0 +1,120 @@
+import { useMemoize } from '@vueuse/core';
+import { isArray, isString, isObject } 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));
+function deepOmit(target, keys) {
+  function search(obj, keys2) {
+    return Object.entries(obj).reduce((result, [k, v]) => {
+      if (keys2.includes(k))
+        return result;
+      if (isArray(v)) {
+        result[k] = v.map((child) => search(child, keys2));
+      } else if (isObject(v)) {
+        result[k] = search(v, keys2);
+      } else {
+        result[k] = v;
+      }
+      return result;
+    }, {});
+  }
+  return search(target, keys);
+}
+function separateMetaModule(modules) {
+  return Object.values(modules).reduce((result, m) => {
+    return Object.assign(result, m);
+  }, {});
+}
+
+export { DMZ, arrayed, deepOmit, generateTimeFormat, getStringWidth, safeComponentRegister, separateMetaModule, traverse, uuidGenerator };

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

@@ -0,0 +1,2 @@
+import { App } from 'vue';
+export declare function loadViewer(app: App): void;

package/es/shared/utils/loadViewer.js

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

@@ -0,0 +1,29 @@
+import { Ref, UnwrapRef, WritableComputedOptions, WritableComputedRef, ComputedRef } from 'vue';
+interface GetState<T> {
+    (isRef: true): Ref<UnwrapRef<T>>;
+    (isRef?: false): UnwrapRef<T>;
+}
+export declare function useState<T>(initValue?: T): [GetState<T>, (val: UnwrapRef<T>) => UnwrapRef<T>];
+export declare function useRef<T>(): GetState<T | null>;
+/**
+ * v-for的ref引用
+ */
+export declare function useRefs<T>(): [Set<T>, (el: T) => void];
+/**
+ * v-for的ref引用
+ * @return 数组
+ */
+export declare function useRefsArray<T>(): [T[], (el: T) => void];
+interface GetComputed<T, R> {
+    (isRef: true): R;
+    (isRef: false): T;
+    (): T;
+}
+export declare function useComputed<T>(getter: WritableComputedOptions<T>['get']): GetComputed<T, ComputedRef<T>>;
+export declare function useComputed<T>(options: WritableComputedOptions<T>): [GetComputed<T, WritableComputedRef<T>>, (val: T) => void];
+/**
+ * 返回{ [key]: Ref }
+ * @params obj { [变量名]: useState或useComputed返回的getter函数 }
+ */
+export declare function getRefs(obj: Record<string, GetState<any> | GetComputed<any, any>>): Record<string, Ref<any>>;
+export {};

package/es/shared/utils/state.js

@@ -0,0 +1,44 @@
+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/AsyncParallelBailHook.d.ts

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

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

@@ -0,0 +1,63 @@
+import './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
+  content({ onError, onResult, onDone }) {
+    let code = "";
+    code += `var _results = new Array(${this.options.taps.length});
+`;
+    code += "var _checkDone = function() {\n";
+    code += "for(var i = 0; i < _results.length; i++) {\n";
+    code += "var item = _results[i];\n";
+    code += "if(item === undefined) return false;\n";
+    code += "if(item.result !== undefined) {\n";
+    code += onResult("item.result");
+    code += "return true;\n";
+    code += "}\n";
+    code += "if(item.error) {\n";
+    code += onError("item.error");
+    code += "return true;\n";
+    code += "}\n";
+    code += "}\n";
+    code += "return false;\n";
+    code += "}\n";
+    code += this.callTapsParallel({
+      onError: (i, err, done, doneBreak) => {
+        let code2 = "";
+        code2 += `if(${i} < _results.length && ((_results.length = ${i + 1}), (_results[${i}] = { error: ${err} }), _checkDone())) {
+`;
+        code2 += doneBreak(true);
+        code2 += "} else {\n";
+        code2 += done();
+        code2 += "}\n";
+        return code2;
+      },
+      onResult: (i, result, done, doneBreak) => {
+        let code2 = "";
+        code2 += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i + 1}), (_results[${i}] = { result: ${result} }), _checkDone())) {
+`;
+        code2 += doneBreak(true);
+        code2 += "} else {\n";
+        code2 += done();
+        code2 += "}\n";
+        return code2;
+      },
+      onTap: (i, run, done, doneBreak) => {
+        let code2 = "";
+        if (i > 0) {
+          code2 += `if(${i} >= _results.length) {
+`;
+          code2 += done();
+          code2 += "} else {\n";
+        }
+        code2 += run();
+        if (i > 0)
+          code2 += "}\n";
+        return code2;
+      },
+      onDone
+    });
+    return code;
+  }
+}
+new AsyncParallelBailHookCodeFactory();

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

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

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

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

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

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

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

@@ -0,0 +1,18 @@
+import './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
+  content({ onError, onResult, resultReturns, onDone }) {
+    return this.callTapsSeries({
+      onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+      onResult: (i, result, next) => `if(${result} !== undefined) {
+${onResult(result)}
+} else {
+${next()}}
+`,
+      resultReturns,
+      onDone
+    });
+  }
+}
+new AsyncSeriesBailHookCodeFactory();

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

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

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

@@ -0,0 +1,27 @@
+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.d.ts

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

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

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

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

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

@@ -0,0 +1,23 @@
+import './Hook.js';
+import HookCodeFactory from './HookCodeFactory.js';
+
+class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
+  content({ onError, onResult, onDone }) {
+    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 += `}
+`;
+        code += next();
+        return code;
+      },
+      onDone: () => onResult(this._args[0])
+    });
+  }
+}
+new AsyncSeriesWaterfallHookCodeFactory();

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

@@ -0,0 +1,50 @@
+export default Hook;
+declare class Hook {
+    constructor(args?: any[], name?: undefined);
+    _args: any[];
+    name: any;
+    taps: any[];
+    interceptors: any[];
+    _call: typeof CALL_DELEGATE;
+    call: typeof CALL_DELEGATE;
+    _callAsync: typeof CALL_ASYNC_DELEGATE;
+    callAsync: typeof CALL_ASYNC_DELEGATE;
+    _promise: typeof PROMISE_DELEGATE;
+    promise: typeof PROMISE_DELEGATE;
+    _x: any;
+    compile(options: any): void;
+    _createCall(type: any): void;
+    _tap(type: any, options: any, fn: any): void;
+    tap(options: any, fn: any): void;
+    tapAsync(options: any, fn: any): void;
+    tapPromise(options: any, fn: any): void;
+    _runRegisterInterceptors(options: any): any;
+    withOptions(options: any): {
+        name: any;
+        tap: (opt: any, fn: any) => void;
+        tapAsync: (opt: any, fn: any) => void;
+        tapPromise: (opt: any, fn: any) => void;
+        intercept: (interceptor: any) => void;
+        isUsed: () => boolean;
+        withOptions: (opt: any) => any;
+    };
+    isUsed(): boolean;
+    intercept(interceptor: any): void;
+    _resetCompilation(): void;
+    _insert(item: any): void;
+}
+declare function CALL_DELEGATE(...args: any[]): any;
+declare class CALL_DELEGATE {
+    constructor(...args: any[]);
+    call: any;
+}
+declare function CALL_ASYNC_DELEGATE(...args: any[]): any;
+declare class CALL_ASYNC_DELEGATE {
+    constructor(...args: any[]);
+    callAsync: any;
+}
+declare function PROMISE_DELEGATE(...args: any[]): any;
+declare class PROMISE_DELEGATE {
+    constructor(...args: any[]);
+    promise: any;
+}