cnhis-design-vue 3.1.12-beta.0 → 3.1.12-beta.1

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

@@ -1 +1,85 @@
-export { useAnchor } from './useAnchor2.js';
+import { doAnimation } from '../../../../src/utils/anime';
+import { useDebounceFn } from '@vueuse/core';
+import { isNumber } from 'lodash-es';
+import { ref, computed, watch, nextTick } from 'vue';
+import { FormItemLineBarDepKeyPrepend } from '../../../../packages/form-render/src/constants';
+import { traverseSchema } from '../../../../packages/form-render/src/utils';
+
+function useAnchor(props, collector) {
+  const __currentAnchor = ref("");
+  const formHeight = computed(() => {
+    if (isNumber(props.maxHeight))
+      return props.maxHeight + "px";
+    return props.maxHeight;
+  });
+  const anchorIdList = ref([]);
+  function generateAnchorList(schema) {
+    anchorIdList.value.length = 0;
+    traverseSchema(schema, (_schema) => {
+      var _a;
+      if (_schema["x-component"] === "LINEBAR") {
+        anchorIdList.value.push({ title: _schema.title, name: ((_a = _schema.name) == null ? void 0 : _a.toString()) || "" });
+      }
+    });
+  }
+  const scrollbarRef = ref();
+  let scrollLock = false;
+  async function scrollTo(id) {
+    scrollLock = true;
+    try {
+      if (!scrollbarRef.value)
+        return;
+      collector.trigger(FormItemLineBarDepKeyPrepend + id, true);
+      await nextTick();
+      const targetAnchor = scrollbarRef.value.querySelector(`#${id}`);
+      if (!targetAnchor)
+        return;
+      await new Promise((resolve) => {
+        doAnimation(scrollbarRef.value.scrollTop, targetAnchor.offsetTop, 300, (top) => {
+          var _a;
+          (_a = scrollbarRef.value) == null ? void 0 : _a.scrollTo({ top });
+        }, "easeInBounce", resolve);
+      });
+    } finally {
+      scrollLock = false;
+    }
+  }
+  const onScroll = useDebounceFn(async function() {
+    var _a;
+    if (scrollLock || !scrollbarRef.value)
+      return;
+    const { scrollTop, clientHeight } = scrollbarRef.value;
+    const result = anchorIdList.value.find((anchor) => {
+      const node = scrollbarRef.value.querySelector(`#${anchor.name}`);
+      if (!node)
+        return;
+      return node.offsetTop >= scrollTop || node.offsetTop < scrollTop && node.clientHeight + node.offsetTop > scrollTop + clientHeight;
+    }) || anchorIdList.value[anchorIdList.value.length - 1];
+    __currentAnchor.value = (_a = result == null ? void 0 : result.name) != null ? _a : "";
+  }, 300);
+  watch(anchorIdList, (anchorIdList2) => {
+    var _a, _b;
+    __currentAnchor.value = (_b = (_a = anchorIdList2[0]) == null ? void 0 : _a.name) != null ? _b : "";
+  }, { deep: true, immediate: true });
+  const currentAnchor = computed({
+    get() {
+      return __currentAnchor.value;
+    },
+    async set(id) {
+      __currentAnchor.value = id;
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      await scrollTo(id);
+    }
+  });
+  return {
+    currentAnchor,
+    onScroll,
+    formHeight,
+    anchorIdList,
+    generateAnchorList,
+    scrollbarRef,
+    scrollTo
+  };
+}
+
+export { useAnchor };

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

@@ -1 +1,137 @@
-export { AsyncQueue, useAsyncQueue } from './useAsyncQueue2.js';
+import { useFormRequest, useCommonLog } from '../../../../packages/form-render';
+
+class AsyncQueueEntry {
+  constructor(item, key, callback) {
+    this.item = item;
+    this.key = key;
+    this.state = 0 /* PENDING */;
+    this.callback = callback;
+  }
+}
+class ArrayQueue {
+  constructor(items) {
+    this._list = items ? Array.from(items) : [];
+  }
+  enqueue(item) {
+    this._list.push(item);
+  }
+  dequeue() {
+    return this._list.shift();
+  }
+}
+class AsyncQueue {
+  constructor({ name, processor, getKey, parallelism }) {
+    this._queued = new ArrayQueue();
+    this._entries = /* @__PURE__ */ new Map();
+    this._activeTasks = 0;
+    this._processingLock = false;
+    this._stopped = false;
+    this.name = name;
+    this.processor = processor;
+    this.getKey = getKey;
+    this.parallelism = parallelism || 100;
+  }
+  add(item, callback) {
+    if (this._stopped)
+      return callback(new Error("Queue was stopped"));
+    const key = this.getKey(item);
+    if (this._entries.has(key)) {
+      const entry = this._entries.get(key);
+      if (entry.state === 1 /* DONE */) {
+        setTimeout(() => {
+          callback && callback(entry.error, entry.result);
+        });
+      } else if (!entry.callbacks) {
+        entry.callbacks = [callback];
+      } else {
+        entry.callbacks.push(callback);
+      }
+      return;
+    }
+    const newEntry = new AsyncQueueEntry(item, key, callback);
+    this._entries.set(key, newEntry);
+    this._queued.enqueue(newEntry);
+    if (!this._processingLock) {
+      this._processingLock = true;
+      Promise.resolve().then(this._ensureProcessing.bind(this));
+    }
+  }
+  addAsync(item) {
+    return new Promise((resolve, reject) => {
+      this.add(item, (err, result) => {
+        err && reject(err);
+        resolve(result);
+      });
+    });
+  }
+  _ensureProcessing() {
+    while (this._activeTasks < this.parallelism) {
+      const entry = this._queued.dequeue();
+      if (!entry)
+        break;
+      this._activeTasks++;
+      entry.state = 0 /* PENDING */;
+      this._startProcess(entry);
+    }
+    this._processingLock = false;
+  }
+  _startProcess(entry) {
+    this.processor(entry.item, (e, r) => {
+      if (e) {
+        this._handlerResult(entry, e);
+        return;
+      }
+      this._handlerResult(entry, e, r);
+    }, () => this._entries.delete(entry.key));
+  }
+  _handlerResult(entry, e, r) {
+    const callback = entry.callback;
+    entry.state = 1 /* DONE */;
+    entry.callback = void 0;
+    entry.result = r;
+    entry.error = e;
+    this._activeTasks--;
+    callback && callback(e, r);
+    if (entry.callbacks) {
+      entry.callbacks.forEach((cb) => cb(e, r));
+    }
+    if (!this._processingLock) {
+      this._processingLock = true;
+      Promise.resolve().then(this._ensureProcessing.bind(this));
+    }
+  }
+}
+function useAsyncQueue() {
+  const { getHttpInstance } = useFormRequest();
+  function create(parallelism = 3) {
+    return new AsyncQueue({
+      name: "FormRenderAsyncQueue",
+      parallelism,
+      async processor({ method = "post", params, url }, cb, removeCache) {
+        const http = getHttpInstance();
+        if (!http) {
+          useCommonLog().invalidHttpInstanceLog();
+          cb();
+          removeCache();
+          return;
+        }
+        try {
+          const res = await http[method](url, params);
+          const { data, success } = res;
+          if (!success)
+            throw res;
+          cb(void 0, data);
+        } catch (e) {
+          cb(new Error(`Request error => ${e}`));
+          removeCache();
+        }
+      },
+      getKey({ url, method = "post", params }) {
+        return url + method + JSON.stringify(params || {});
+      }
+    });
+  }
+  return { create };
+}
+
+export { AsyncQueue, useAsyncQueue };

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

@@ -1 +1,62 @@
-export { BusinessCollector, useBusinessBinding } from './useBusinessBinding2.js';
+import { isString } from '@vueuse/core';
+import { FIELD_BUSINESS_TYPE } from '../constants/index.js';
+import { isIdCard, parseIdCard } from '../utils/index.js';
+
+class BusinessCollector {
+  constructor() {
+    this.typeCollector = /* @__PURE__ */ new Map();
+    this.fieldNameCollector = /* @__PURE__ */ new Map();
+    this.handlerMap = /* @__PURE__ */ new Map([
+      [FIELD_BUSINESS_TYPE.ID_CARD, this.handlerIdCardType.bind(this)]
+    ]);
+  }
+  collect(type, fieldName) {
+    const set = this.typeCollector.get(type) || /* @__PURE__ */ new Set();
+    set.add(fieldName);
+    this.typeCollector.set(type, set);
+    this.fieldNameCollector.set(fieldName, type);
+  }
+  getField(type) {
+    return [...this.typeCollector.get(type) || /* @__PURE__ */ new Set()];
+  }
+  getType(fieldName) {
+    return this.fieldNameCollector.get(fieldName);
+  }
+  handlerIdCardType(formModel, value) {
+    if (!value || !isString(value) || !isIdCard(value))
+      return;
+    const info = parseIdCard(value);
+    const ageFields = this.getField(FIELD_BUSINESS_TYPE.AGE);
+    ageFields.forEach((field) => {
+      formModel.setFieldState(field, (state) => {
+        state.value = info.age;
+      });
+    });
+    const sexFields = this.getField(FIELD_BUSINESS_TYPE.SEX);
+    sexFields.forEach((field) => {
+      formModel.setFieldState(field, (state) => {
+        state.value = info.sex;
+      });
+    });
+    const birthdayFields = this.getField(FIELD_BUSINESS_TYPE.BIRTHDAY);
+    birthdayFields.forEach((field) => {
+      formModel.setFieldState(field, (state) => {
+        state.value = info.birthday;
+      });
+    });
+  }
+  trigger(formModel, fieldName, value) {
+    const type = this.getType(fieldName);
+    if (!type || !this.handlerMap.has(type))
+      return;
+    this.handlerMap.get(type)(formModel, value);
+  }
+}
+function useBusinessBinding() {
+  function create() {
+    return new BusinessCollector();
+  }
+  return { create };
+}
+
+export { BusinessCollector, useBusinessBinding };

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

@@ -1 +1,23 @@
-export { ContextCollector, useChangeContext } from './useChangeContext2.js';
+class ContextCollector {
+  constructor() {
+    this.contextMap = /* @__PURE__ */ new Map();
+  }
+  setContext(key, prop, value) {
+    const context = this.contextMap.get(key) || {};
+    Reflect.set(context, prop, value);
+    this.contextMap.set(key, context);
+  }
+  getContext(key) {
+    const result = this.contextMap.get(key) || {};
+    this.contextMap.delete(key);
+    return result;
+  }
+}
+function useChangeContext() {
+  function create() {
+    return new ContextCollector();
+  }
+  return { create };
+}
+
+export { ContextCollector, useChangeContext };

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

@@ -1 +1,10 @@
-export { useCommonLog } from './useCommonLog2.js';
+import { formRenderLog } from '../utils/index.js';
+
+function useCommonLog() {
+  function invalidHttpInstanceLog() {
+    formRenderLog("before use http feature, you should regist http instance by useFormilyRequest.registGlobHttpInstance()", "warn");
+  }
+  return { invalidHttpInstanceLog };
+}
+
+export { useCommonLog };

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

@@ -1 +1,201 @@
-export { useFieldListAdaptor } from './useFieldListAdaptor2.js';
+import { pick } from 'lodash-es';
+import { arrayed, transformDateFormat } from '../utils/index.js';
+import { useFormValidator, useTypeNormalize } from '../../../../packages/form-render';
+import { isObject } from '@vueuse/core';
+
+function useFieldListAdaptor(collector, uuid) {
+  const { createValidatorSchema } = useFormValidator();
+  const createStandardSchema = (item) => {
+    const result = {
+      name: item.val_key,
+      type: "string",
+      title: item.alias || item.name,
+      "x-decorator": "FORM_ITEM",
+      "x-decorator-props": {
+        span: item.elem_width,
+        showLabel: item.hide_title !== "1",
+        id: `${uuid}-${item.val_key}`
+      },
+      "x-component": item.html_type,
+      "x-component-props": { placeholder: item.placeholder, clearable: item.is_empty === "1" },
+      "x-display": item.is_show === "0" ? "hidden" : "visible",
+      "x-pattern": item.is_edit === "0" ? "disabled" : "editable"
+    };
+    if (isObject(item.reactions)) {
+      result["x-reactions"] = item.reactions;
+    }
+    const rules = createValidatorSchema(item);
+    rules && (result["x-validator"] = rules);
+    item.is_null === "0" && (result.required = true);
+    return result;
+  };
+  const createInputSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      prefix: item.prefix,
+      suffix: item.suffix
+    });
+    return schema;
+  };
+  const createSelectSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      urlConfig: item.urlConfig,
+      options: item.option,
+      multiple: item.multi_select === "0",
+      maxTagCount: +item.multi_select_value
+    });
+    return schema;
+  };
+  const createRadioSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      options: item.option,
+      vertical: item.__vertical
+    });
+    return schema;
+  };
+  const createDateSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      valueFormat: item.date_format,
+      type: transformDateFormat(item.date_format),
+      validate: item.validate
+    });
+    return schema;
+  };
+  const createCascaderSchema = (item) => {
+    var _a;
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      urlConfig: item.urlConfig,
+      deep: (_a = item.wordbook) == null ? void 0 : _a.level_num,
+      options: item.option
+    });
+    return schema;
+  };
+  const createSwitchSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      openDescription: item.open,
+      closeDescription: item.close
+    });
+    return schema;
+  };
+  const createCombinationSchema = (item) => {
+    const schema = createStandardSchema(item);
+    schema["x-decorator-props"].showLabel = false;
+    Object.assign(schema["x-component-props"], {
+      title: item.alias || item.name,
+      getProperties: () => item.children || []
+    });
+    return schema;
+  };
+  const createInputNumberSchema = (item) => {
+    const schema = createStandardSchema(item);
+    const { decimal_length, validate } = item;
+    Object.assign(schema["x-component-props"], {
+      precision: decimal_length || (validate == null ? void 0 : validate.decimal_length),
+      max: validate == null ? void 0 : validate.max_value,
+      min: validate == null ? void 0 : validate.min_value
+    });
+    return schema;
+  };
+  const createSliderSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      step: item.step_length,
+      max: item.max_length,
+      min: item.min_length,
+      option: item.option
+    });
+    return schema;
+  };
+  const createCustomSchema = (item) => {
+    const schema = createStandardSchema(item);
+    item.fieldType && (schema.type = item.fieldType);
+    Object.assign(schema["x-component-props"], {
+      fieldItem: item
+    });
+    return schema;
+  };
+  const createLinebarSchema = (item) => {
+    return {
+      name: item.val_key,
+      type: "void",
+      title: item.alias || item.name,
+      "x-component": "LINEBAR",
+      "x-component-props": {
+        line: item.__line,
+        disabled: item.is_not_fold === "1",
+        id: item.val_key,
+        show: !!item.is_show
+      }
+    };
+  };
+  const createComplexSchema = (item) => {
+    const schema = createStandardSchema(item);
+    const properties = Array.isArray(item.properties) ? schemaAdaptor(item.properties) : {};
+    schema.type = item.fieldType || "void";
+    schema.properties = properties;
+    Object.assign(schema["x-decorator-props"], { showFeedback: false });
+    Object.assign(schema["x-component-props"], pick(item, ["wrapperStyle", "display"]));
+    return schema;
+  };
+  const creatorMap = /* @__PURE__ */ new Map([
+    ["LINEBAR", createLinebarSchema],
+    ["INPUT", createInputSchema],
+    ["INPUT_NUMBER", createInputNumberSchema],
+    ["SELECT", createSelectSchema],
+    ["DATE", createDateSchema],
+    ["SEARCH_CASCADE", createCascaderSchema],
+    ["COMBINATION", createCombinationSchema],
+    ["RADIO", createRadioSchema],
+    ["CHECKBOX", createRadioSchema],
+    ["SWITCH", createSwitchSchema],
+    ["SLIDER", createSliderSchema],
+    ["COMPLEX", createComplexSchema]
+  ]);
+  const createWidgetSchema = (item) => {
+    if (item.suffixConfig)
+      return createWidgetCombinationSchema(item);
+    const creator = creatorMap.get(item.html_type) || createCustomSchema;
+    return creator(item);
+  };
+  const createWidgetCombinationSchema = (item) => {
+    const suffixList = arrayed(item.suffixConfig);
+    const fieldList = [{ ...item, suffixConfig: void 0 }].concat(suffixList.map((suffix) => {
+      return { ...suffix, is_show: item.is_show, alias: " " };
+    }));
+    return {
+      type: "void",
+      title: item.alias || item.name,
+      "x-component": "INPUT_GROUP",
+      "x-component-props": { span: item.elem_width },
+      properties: schemaAdaptor(fieldList)
+    };
+  };
+  const { normalize } = useTypeNormalize();
+  function schemaAdaptor(fieldList) {
+    let prevLinebar = null;
+    return fieldList.reduce((fin, cur) => {
+      var _a;
+      normalize(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") {
+        fin[cur.val_key] = createLinebarSchema(cur);
+        prevLinebar = fin[cur.val_key].properties = {};
+      } else if (prevLinebar) {
+        prevLinebar[cur.val_key] = createWidgetSchema(cur);
+      } else {
+        prevLinebar = null;
+        fin[cur.val_key] = createWidgetSchema(cur);
+      }
+      return fin;
+    }, {});
+  }
+  return { schemaAdaptor };
+}
+
+export { useFieldListAdaptor };

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

@@ -1 +1,38 @@
-export { useFieldVisitor } from './useFieldVisitor2.js';
+import { arrayed } from '../utils/index.js';
+import { isFunction } from '@vueuse/core';
+
+function useFieldVisitor() {
+  function traverse(fieldList, visitorMap, key = "val_key") {
+    if (!visitorMap)
+      return fieldList;
+    return fieldList.reduce((fin, field) => {
+      if (Array.isArray(field.children)) {
+        field.children = traverse(field.children, visitorMap, key);
+      }
+      if (field.suffixConfig) {
+        field.suffixConfig = traverse(arrayed(field.suffixConfig), visitorMap, key);
+      }
+      const visitor = visitorMap[field[key]];
+      let current = field;
+      const before = [];
+      const after = [];
+      isFunction(visitor) && visitor({
+        field,
+        replace(field2) {
+          current = field2;
+        },
+        insertBefore(field2) {
+          before.push(...arrayed(field2));
+        },
+        insertAfter(field2) {
+          after.push(...arrayed(field2));
+        }
+      });
+      fin.push(...before, current, ...after);
+      return fin;
+    }, []);
+  }
+  return { traverse };
+}
+
+export { useFieldVisitor };

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

@@ -1 +1,35 @@
-export { useFormContext } from './useFormContext2.js';
+import { provide } from 'vue';
+import { createSchemaField } from '@formily/vue';
+import { useAsyncQueue, useBusinessBinding, useChangeContext, useFormItemDeps } from '../../../../packages/form-render';
+import * as components from '../../../../packages/form-render/src/components/renderer';
+import { injectOrProvide, uuidGenerator } from '../../../../packages/form-render/src/utils';
+import { InjectAsyncQueue, InjectionSchemaField, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionFormUUID } from '../../../../packages/form-render/src/constants';
+
+function useFormContext(props) {
+  const asyncQueue = injectOrProvide(InjectAsyncQueue, () => useAsyncQueue().create(props.parallelism));
+  const SchemaField = injectOrProvide(InjectionSchemaField, () => createSchemaField({
+    components: {
+      ...components,
+      ...props.components
+    },
+    scope: props.scope
+  }).SchemaField);
+  const businessCollector = useBusinessBinding().create();
+  provide(InjectionBusinessCollector, businessCollector);
+  const changeContextCollector = useChangeContext().create();
+  provide(InjectionChangeContextCollector, changeContextCollector);
+  const formItemDepsCollector = useFormItemDeps().create();
+  provide(InjectionFormItemDepsCollector, formItemDepsCollector);
+  const formUUID = props.uuid || uuidGenerator();
+  provide(InjectionFormUUID, formUUID);
+  return {
+    asyncQueue,
+    SchemaField,
+    businessCollector,
+    changeContextCollector,
+    formItemDepsCollector,
+    formUUID
+  };
+}
+
+export { useFormContext };

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

@@ -1 +1,13 @@
-export { useFormField } from './useFormField2.js';
+import { useField } from '@formily/vue';
+import { computed } from 'vue';
+
+function useFormField() {
+  const field = useField();
+  return {
+    field,
+    title: computed(() => field.value.title),
+    fieldKey: computed(() => field.value.props.name.toString())
+  };
+}
+
+export { useFormField };

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

@@ -1 +1,29 @@
-export { FormItemDepsCollector, useFormItemDeps } from './useFormItemDeps2.js';
+import { arrayed } from '../../../../packages/form-render/src/utils';
+
+class FormItemDepsCollector {
+  constructor() {
+    this.collector = /* @__PURE__ */ new Map();
+  }
+  setDeps(key, dependKey, callback) {
+    dependKey = arrayed(dependKey);
+    dependKey.forEach((dependKey2) => {
+      const map = this.collector.get(dependKey2) || /* @__PURE__ */ new Map();
+      map.set(key, callback);
+      this.collector.set(dependKey2, map);
+    });
+  }
+  trigger(dependKey, payload) {
+    const map = this.collector.get(dependKey);
+    map && map.forEach((cb) => {
+      typeof cb === "function" && cb(payload);
+    });
+  }
+}
+function useFormItemDeps() {
+  function create() {
+    return new FormItemDepsCollector();
+  }
+  return { create };
+}
+
+export { FormItemDepsCollector, useFormItemDeps };

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

@@ -1 +1,12 @@
-export { useFormRequest } from './useFormRequest2.js';
+let http = null;
+function useFormRequest() {
+  function getHttpInstance() {
+    return http;
+  }
+  function registGlobHttpInstance(instance) {
+    http = instance;
+  }
+  return { getHttpInstance, registGlobHttpInstance };
+}
+
+export { useFormRequest };