cnhis-design-vue 3.1.23-beta.14 → 3.1.23-beta.16

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.js

@@ -1 +1,98 @@
-export { DMZ, 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;