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

package/es/shared/utils/index.js

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

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

package/es/shared/utils/loadViewer.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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(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

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