cnhis-design-vue 3.1.17-beta.0 → 3.1.17-beta.3

package/es/packages/form-render/src/hooks/useFieldListAdaptor.js

@@ -1,6 +1,6 @@
 import { isObject } from '@vueuse/core';
-import { pick } from 'lodash-es';
-import { useFormValidator, useTypeNormalize } from '../../../../packages/form-render';
+import { cloneDeep, pick } from 'lodash-es';
+import { useFormValidator, useFieldNormalize } from '../../../../packages/form-render';
 import { arrayed, parseNumberFromMaybeString, formRenderLog } from '../utils/index.js';
 import { fieldKeyEscape, createLinebarId } from '../utils/schema.js';
 import { transformDateFormat } from '../utils/business.js';
@@ -208,12 +208,12 @@ function useFieldListAdaptor(collector) {
       properties: schemaAdaptor(fieldList)
     };
   };
-  const { normalize } = useTypeNormalize();
+  const { FieldNormalizeWaterfallHook } = useFieldNormalize();
   function schemaAdaptor(fieldList) {
     let prevLinebar = null;
     return fieldList.reduce((fin, cur, idx) => {
       var _a;
-      normalize(cur);
+      cur = FieldNormalizeWaterfallHook.call(cloneDeep(cur));
       const obj_type = (_a = cur.validate) == null ? void 0 : _a.obj_type;
       obj_type && collector.collect(obj_type, cur.val_key);
       if (cur.html_type === "LINEBAR") {

package/es/packages/form-render/src/hooks/useFieldNormalize.d.ts

@@ -0,0 +1,5 @@
+import { SyncWaterfallHook } from '../../../../../es/src/utils/tapable';
+import { FieldItem } from '../types';
+export declare function useFieldNormalize(): {
+    FieldNormalizeWaterfallHook: SyncWaterfallHook<FieldItem, import("../../../../../es/src/utils/tapable").UnsetAdditionalOptions>;
+};

package/es/packages/form-render/src/hooks/useFieldNormalize.js

@@ -0,0 +1,58 @@
+import { SyncWaterfallHook } from '../../../../src/utils/tapable';
+import { FIELD_BUSINESS_TYPE } from '../../../../packages/form-render/src/constants';
+
+function useFieldNormalize() {
+  const FieldNormalizeWaterfallHook = new SyncWaterfallHook(["fieldItem"]);
+  FieldNormalizeWaterfallHook.tap("__block", (fieldItem) => {
+    if (["CHECKBOX_BLOCK", "RADIO_BLOCK"].includes(fieldItem.html_type)) {
+      fieldItem.__vertical = true;
+    }
+    return fieldItem;
+  });
+  FieldNormalizeWaterfallHook.tap("__line", (fieldItem) => {
+    if (["LINE_BREAKS"].includes(fieldItem.html_type)) {
+      fieldItem.__line = true;
+      fieldItem.is_show = "1";
+    }
+    return fieldItem;
+  });
+  FieldNormalizeWaterfallHook.tap("__age", (fieldItem) => {
+    if (fieldItem.html_type === "AGE") {
+      fieldItem.html_type = "INPUT_NUMBER";
+      fieldItem.suffixConfig = [
+        {
+          validate: { obj_type: FIELD_BUSINESS_TYPE.AGE_UNIT },
+          val_key: fieldItem.val_key_unit,
+          html_type: "SELECT",
+          option: fieldItem.option,
+          urlConfig: fieldItem.urlConfig
+        }
+      ];
+    }
+    return fieldItem;
+  });
+  const types = [
+    [["SEARCH", "PHONE_TYPE", "IDCARD_TYPE"], "SELECT"],
+    ["DIGITAL", "INPUT_NUMBER"],
+    ["CHECKBOX_BLOCK", "CHECKBOX"],
+    ["RADIO_BLOCK", "RADIO"],
+    [["DATE-INPUT", "DATETIME-INPUT"], "DATE"],
+    ["SWITCH_COMPONENT", "SWITCH"],
+    ["SLIDER_COMPONENT", "SLIDER"],
+    ["LINE_BREAKS", "LINEBAR"]
+  ];
+  FieldNormalizeWaterfallHook.tap("__normalize", (fieldItem) => {
+    types.some(([rule, target]) => {
+      const match = Array.isArray(rule) ? rule.includes(fieldItem.html_type) : rule === fieldItem.html_type;
+      return match && (fieldItem.html_type = target);
+    });
+    return fieldItem;
+  });
+  FieldNormalizeWaterfallHook.tap("__elem_width", (fieldItem) => {
+    fieldItem.elem_width = ~~((fieldItem.elem_width || 3) * 2);
+    return fieldItem;
+  });
+  return { FieldNormalizeWaterfallHook };
+}
+
+export { useFieldNormalize };

package/es/packages/form-render/src/hooks/useFieldVisitor.js

@@ -29,13 +29,9 @@ function useFieldVisitor() {
           after.push(...arrayed(field2));
         }
       });
-      return fin.concat([...before, current, ...after].map(defaultTransfer));
+      return fin.concat([...before, current, ...after]);
     }, []);
   }
-  function defaultTransfer(field) {
-    field.elem_width = ~~((field.elem_width || 3) * 2);
-    return field;
-  }
   return { traverse };
 }
 

package/es/packages/index.css

@@ -3212,6 +3212,7 @@ body > .vxe-table--tooltip-wrapper {
   display: flex;
   align-items: center;
   padding: 8px;
+  cursor: move;
   border: 1px dashed #d9d9d9;
   box-sizing: border-box;
   background-color: #fafafa;
@@ -3240,8 +3241,8 @@ body > .vxe-table--tooltip-wrapper {
   height: fit-content;
   background: #eeeeee;
   display: grid !important;
-  grid-template-columns: repeat(12, minmax(0px, 1fr));
-  gap: 8px 16px;
+  grid-template-columns: repeat(24, minmax(0px, 1fr));
+  gap: 8px;
 }
 .form-config__displayContentItem {
   grid-column: span var(--item-column) / span var(--item-column);
@@ -3267,6 +3268,9 @@ body > .vxe-table--tooltip-wrapper {
   overflow-y: auto;
   max-height: var(--max-height);
 }
+.form-config__renderer {
+  cursor: move;
+}
 .form-config__renderer--default {
   display: flex;
   align-items: center;
@@ -3279,13 +3283,21 @@ body > .vxe-table--tooltip-wrapper {
   width: 100%;
 }
 .form-config__renderer--complex {
-  border: 1px dashed lightblue;
+  border: 1px dashed skyblue;
+  border-radius: 8px;
   padding: 8px;
 }
+.form-config__renderer--complexHeader {
+  display: flex;
+  justify-content: center;
+  padding: 8px;
+  margin-top: -8px;
+  position: relative;
+}
 .form-config__renderer--complex--grid {
   display: grid !important;
-  grid-template-columns: repeat(12, minmax(0px, 1fr));
-  gap: 8px 16px;
+  grid-template-columns: repeat(24, minmax(0px, 1fr));
+  gap: 8px;
   grid-column: span var(--item-column) / span var(--item-column);
 }
 .form-config__renderer--complex--flex {
@@ -3312,3 +3324,12 @@ body > .vxe-table--tooltip-wrapper {
 .form-config .is-choosing-area {
   background: #f0f7ff;
 }
+.form-config [is-hovering='true'] > .form-config__renderer--closeButton {
+  visibility: visible;
+}
+.form-config .form-config__renderer--closeButton {
+  position: absolute;
+  visibility: hidden;
+  top: 12px;
+  right: 5px;
+}

package/es/packages/index.js

@@ -46,7 +46,7 @@ export { useCommonLog } from './form-render/src/hooks/useCommonLog.js';
 export { useFormField } from './form-render/src/hooks/useFormField.js';
 export { AsyncQueue, useAsyncQueue } from './form-render/src/hooks/useAsyncQueue.js';
 export { useFieldVisitor } from './form-render/src/hooks/useFieldVisitor.js';
-export { useTypeNormalize } from './form-render/src/hooks/useTypeNormalize.js';
+export { useFieldNormalize } from './form-render/src/hooks/useFieldNormalize.js';
 export { useFormValidator } from './form-render/src/hooks/useFormValidator.js';
 export { BusinessCollector, useBusinessBinding } from './form-render/src/hooks/useBusinessBinding.js';
 export { ContextCollector, useChangeContext } from './form-render/src/hooks/useChangeContext.js';

package/es/src/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/src/utils/tapable/AsyncParallelBailHook.js

@@ -0,0 +1,78 @@
+import Hook from './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;
+  }
+}
+const factory = new AsyncParallelBailHookCodeFactory();
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function AsyncParallelBailHook(args = [], name = void 0) {
+  const hook = new Hook(args, name);
+  hook.constructor = AsyncParallelBailHook;
+  hook.compile = COMPILE;
+  hook._call = void 0;
+  hook.call = void 0;
+  return hook;
+}
+AsyncParallelBailHook.prototype = null;
+
+export { AsyncParallelBailHook as default };

package/es/src/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/src/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/src/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/src/utils/tapable/AsyncSeriesBailHook.js

@@ -0,0 +1,33 @@
+import Hook from './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
+    });
+  }
+}
+const factory = new AsyncSeriesBailHookCodeFactory();
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function AsyncSeriesBailHook(args = [], name = void 0) {
+  const hook = new Hook(args, name);
+  hook.constructor = AsyncSeriesBailHook;
+  hook.compile = COMPILE;
+  hook._call = void 0;
+  hook.call = void 0;
+  return hook;
+}
+AsyncSeriesBailHook.prototype = null;
+
+export { AsyncSeriesBailHook as default };

package/es/src/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/src/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/src/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/src/utils/tapable/AsyncSeriesLoopHook.js

@@ -0,0 +1,27 @@
+import Hook from './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
+    });
+  }
+}
+const factory = new AsyncSeriesLoopHookCodeFactory();
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function AsyncSeriesLoopHook(args = [], name = void 0) {
+  const hook = new Hook(args, name);
+  hook.constructor = AsyncSeriesLoopHook;
+  hook.compile = COMPILE;
+  hook._call = void 0;
+  hook.call = void 0;
+  return hook;
+}
+AsyncSeriesLoopHook.prototype = null;
+
+export { AsyncSeriesLoopHook as default };

package/es/src/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/src/utils/tapable/AsyncSeriesWaterfallHook.js

@@ -0,0 +1,40 @@
+import Hook from './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])
+    });
+  }
+}
+const factory = new AsyncSeriesWaterfallHookCodeFactory();
+const COMPILE = function(options) {
+  factory.setup(this, options);
+  return factory.create(options);
+};
+function AsyncSeriesWaterfallHook(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 = AsyncSeriesWaterfallHook;
+  hook.compile = COMPILE;
+  hook._call = void 0;
+  hook.call = void 0;
+  return hook;
+}
+AsyncSeriesWaterfallHook.prototype = null;
+
+export { AsyncSeriesWaterfallHook as default };

package/es/src/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;
+}

package/es/src/utils/tapable/Hook.js

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