cnhis-design-vue 3.1.23-beta.9 → 3.1.24-beta.0

package/es/components/form-render/src/components/renderer/searchCascade.js

@@ -1,12 +1,13 @@
 import { defineComponent, ref, computed, inject, watch, createVNode } from 'vue';
 import { isField } from '@formily/core';
 import { isEqual, isArray } from 'lodash-es';
-import { useCommonInjection } from '../../hooks/useCommonInjection2.js';
-import { InjectAsyncQueue } from '../../constants/index2.js';
+import { useCommonInjection } from '../../hooks/useCommonInjection.js';
+import { InjectAsyncQueue } from '../../constants/index.js';
+import '../../../../../shared/utils/index.js';
 import '@vueuse/core';
-import '../../../index2.js';
+import '../../../index.js';
 import '../../utils/index.js';
-import { useFormField } from '../../hooks/useFormField2.js';
+import { useFormField } from '../../hooks/useFormField.js';
 import '../../../../../shared/utils/tapable/SyncHook.js';
 import '../../../../../shared/utils/tapable/SyncBailHook.js';
 import '../../../../../shared/utils/tapable/SyncWaterfallHook.js';
@@ -24,8 +25,8 @@ import './select.js';
 import './formItem.js';
 import './textarea.js';
 import './inputNumber.js';
-import './linebar.js';
-import './inputGroup2.js';
+import './lineBar/index.js';
+import './inputGroup.js';
 import './date.js';
 import './levelSearchCascade.js';
 import './jsonCombination/index.js';
@@ -39,7 +40,7 @@ import './complex.js';
 import './simpleComponent.js';
 import './search.js';
 import { NCascader } from 'naive-ui';
-import { assignUpdateValue, traverseDependKey } from '../../utils/schema2.js';
+import { assignUpdateValue, traverseDependKey } from '../../utils/schema.js';
 
 const script = defineComponent({
   name: "FormCascader",
@@ -54,6 +55,10 @@ const script = defineComponent({
     urlConfig: {
       type: Object
     },
+    requestCache: {
+      type: Boolean,
+      default: true
+    },
     onFocus: {
       type: Function
     },
@@ -108,14 +113,15 @@ const script = defineComponent({
       return props.filterable ? fetchFullData() : fetchGradeData(option);
     }
     async function fetchFullData() {
-      if (!props.urlConfig || remoteOptions.value)
+      if (!props.urlConfig || remoteOptions.value && props.requestCache)
         return;
       const data = await asyncQueue.addAsync({
         ...props.urlConfig,
         params: {
           lvlnr: 1 + ""
         },
-        key: title.value
+        key: title.value,
+        cache: props.requestCache
       });
       remoteOptions.value = data.map((item) => optionNormalize(item, 0));
       function optionNormalize(data2, depth) {
@@ -145,7 +151,7 @@ const script = defineComponent({
       const result = data.map((item) => optionNormalize(item, deepFor(option)));
       option ? option.children = result : remoteOptions.value = result;
       function notNeedToFetchData(props2, option2) {
-        return !configFor(props2) || !option2 && remoteOptions.value || deepFor(option2) >= deepFor(props2) - 1;
+        return !configFor(props2) || !option2 && remoteOptions.value && props2.requestCache || deepFor(option2) >= deepFor(props2) - 1;
       }
       function createRequestParams(deep, config, key2, option2) {
         const params = {
@@ -159,7 +165,8 @@ const script = defineComponent({
         return {
           params,
           ...config,
-          key: key2
+          key: key2,
+          cache: props.requestCache
         };
       }
       function getOptionChain(option2) {

package/es/components/form-render/src/components/renderer/select.d.ts

@@ -9,6 +9,10 @@ export declare const SELECT: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     options: {
         type: PropType<AnyObject[]>;
         default: () => never[];
@@ -28,6 +32,10 @@ export declare const SELECT: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
+    requestCache: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     options: {
         type: PropType<AnyObject[]>;
         default: () => never[];
@@ -44,4 +52,5 @@ export declare const SELECT: import("vue").DefineComponent<{
 }, {
     options: AnyObject[];
     lazyRequest: boolean;
+    requestCache: boolean;
 }>;

package/es/components/form-render/src/components/renderer/select.js

@@ -2,11 +2,12 @@ import { defineComponent, computed, ref, inject, watch, createVNode } from 'vue'
 import { isField } from '@formily/core';
 import { useDebounceFn } from '@vueuse/core';
 import { isString, cloneDeep, isEqual } from 'lodash-es';
-import { useCommonInjection } from '../../hooks/useCommonInjection2.js';
-import { InjectAsyncQueue, InjectionChangeContextCollector, InjectionFormItemDepsCollector } from '../../constants/index2.js';
-import '../../../index2.js';
+import { useCommonInjection } from '../../hooks/useCommonInjection.js';
+import { InjectAsyncQueue, InjectionChangeContextCollector, InjectionFormItemDepsCollector } from '../../constants/index.js';
+import '../../../../../shared/utils/index.js';
+import '../../../index.js';
 import { formRenderLog, optionMatcher } from '../../utils/index.js';
-import { useFormField } from '../../hooks/useFormField2.js';
+import { useFormField } from '../../hooks/useFormField.js';
 import '../../../../../shared/utils/tapable/SyncHook.js';
 import '../../../../../shared/utils/tapable/SyncBailHook.js';
 import '../../../../../shared/utils/tapable/SyncWaterfallHook.js';
@@ -23,8 +24,8 @@ import './input.js';
 import './formItem.js';
 import './textarea.js';
 import './inputNumber.js';
-import './linebar.js';
-import './inputGroup2.js';
+import './lineBar/index.js';
+import './inputGroup.js';
 import './date.js';
 import './levelSearchCascade.js';
 import './jsonCombination/index.js';
@@ -39,7 +40,7 @@ import './simpleComponent.js';
 import './search.js';
 import './searchCascade.js';
 import { NSelect } from 'naive-ui';
-import { traverseDependKey, visitedDecorator, assignUpdateValue, assignClearBindVisited } from '../../utils/schema2.js';
+import { traverseDependKey, visitedDecorator, assignUpdateValue, assignClearBindVisited } from '../../utils/schema.js';
 
 const script = defineComponent({
   name: "FormSelect",
@@ -51,6 +52,10 @@ const script = defineComponent({
       type: Boolean,
       default: true
     },
+    requestCache: {
+      type: Boolean,
+      default: true
+    },
     options: {
       type: Array,
       default: () => []
@@ -92,7 +97,7 @@ const script = defineComponent({
       if (!configFor(props)) {
         return remoteOptions.value = null;
       }
-      if (remoteOptions.value)
+      if (remoteOptions.value && props.requestCache)
         return;
       try {
         remoteOptions.value = await asyncQueue.addAsync(await createParams(configFor(props), field.value, fieldKey.value));
@@ -117,7 +122,8 @@ const script = defineComponent({
         return {
           ...config,
           params: Object.assign({}, config.params, _params),
-          key: key2
+          key: key2,
+          cache: props.requestCache
         };
       }
       function configFor(target) {

package/es/components/form-render/src/components/renderer/slider.js

@@ -2,7 +2,7 @@ import { defineComponent, computed, createVNode } from 'vue';
 import { connect, mapProps } from '@formily/vue';
 import { NSlider } from 'naive-ui';
 import { parseNumberFromMaybeString } from '../../utils/index.js';
-import { assignUpdateValue, assignValueBindKey } from '../../utils/schema2.js';
+import { assignUpdateValue, assignValueBindKey } from '../../utils/schema.js';
 
 const script = defineComponent({
   props: {

package/es/components/form-render/src/components/renderer/switch.d.ts

@@ -11,7 +11,7 @@ export declare const SWITCH: import("vue").DefineComponent<{
         type: PropType<Description>;
     };
     onChange: {};
-}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     openDescription: {
         type: PropType<Description>;
     };

package/es/components/form-render/src/components/renderer/switch.js

@@ -2,7 +2,7 @@ import { defineComponent, computed, createVNode, createTextVNode } from 'vue';
 import { NSwitch } from 'naive-ui';
 import '../../utils/index.js';
 import { connect, mapProps } from '@formily/vue';
-import { assignUpdateValue, assignValueBindKey } from '../../utils/schema2.js';
+import { assignUpdateValue, assignValueBindKey } from '../../utils/schema.js';
 
 const script = defineComponent({
   name: "FormSwitch",

package/es/components/form-render/src/components/renderer/textarea.js

@@ -1,9 +1,9 @@
 import { defineComponent, computed, createVNode } from 'vue';
-import { useCommonInjection } from '../../hooks/useCommonInjection2.js';
+import { useCommonInjection } from '../../hooks/useCommonInjection.js';
 import '../../utils/index.js';
 import { connect, mapProps } from '@formily/vue';
 import { NInput } from 'naive-ui';
-import { assignUpdateValue, assignClearBindVisited } from '../../utils/schema2.js';
+import { assignUpdateValue, assignClearBindVisited } from '../../utils/schema.js';
 
 const script = defineComponent({
   name: "FormTextarea",

package/es/components/form-render/src/constants/index.js

@@ -1 +1,45 @@
-export { FIELD_AGE_UNIT, FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, FormItemLineBarDepKeyPrepend, InjectAsyncQueue, InjectionAnnotation, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionFormUUID, InjectionSchemaField } from './index2.js';
+const InjectAsyncQueue = Symbol("InjectAsyncQueue");
+const InjectionSchemaField = Symbol("InjectionSchemaField");
+const InjectionBusinessCollector = Symbol("InjectionBusinessCollector");
+const InjectionChangeContextCollector = Symbol(
+  "InjectionChangeContextCollector"
+);
+const InjectionFormItemDepsCollector = Symbol(
+  "InjectionFormItemDepsCollector"
+);
+const InjectionFormUUID = Symbol("InjectionFormUUID");
+const InjectionAnnotation = Symbol("InjectionAnnotation");
+const FormItemLineBarDepKeyPrepend = "__dep_LINEBAR_";
+var FIELD_BUSINESS_TYPE = /* @__PURE__ */ ((FIELD_BUSINESS_TYPE2) => {
+  FIELD_BUSINESS_TYPE2["PASSWORD"] = "password";
+  FIELD_BUSINESS_TYPE2["ID_CARD"] = "id_card";
+  FIELD_BUSINESS_TYPE2["AGE"] = "age";
+  FIELD_BUSINESS_TYPE2["AGE_UNIT"] = "age_unit";
+  FIELD_BUSINESS_TYPE2["MOBILE"] = "mobile";
+  FIELD_BUSINESS_TYPE2["TELEPHONE"] = "telephone";
+  FIELD_BUSINESS_TYPE2["EMAIL"] = "email";
+  FIELD_BUSINESS_TYPE2["SEX"] = "sex";
+  FIELD_BUSINESS_TYPE2["BIRTHDAY"] = "birthday";
+  FIELD_BUSINESS_TYPE2["BANK_CARD"] = "bank_card";
+  FIELD_BUSINESS_TYPE2["WEBSITE"] = "website";
+  FIELD_BUSINESS_TYPE2["GESTATIONAL_WEEKS"] = "gestational_weeks";
+  FIELD_BUSINESS_TYPE2["GESTATIONAL_STAGE"] = "gestational_stage";
+  FIELD_BUSINESS_TYPE2["CUSTOMER_NAME"] = "customer_name";
+  return FIELD_BUSINESS_TYPE2;
+})(FIELD_BUSINESS_TYPE || {});
+var FIELD_SEX_VALUE = /* @__PURE__ */ ((FIELD_SEX_VALUE2) => {
+  FIELD_SEX_VALUE2["MALE"] = "1";
+  FIELD_SEX_VALUE2["FEMALE"] = "2";
+  return FIELD_SEX_VALUE2;
+})(FIELD_SEX_VALUE || {});
+var FIELD_AGE_UNIT = /* @__PURE__ */ ((FIELD_AGE_UNIT2) => {
+  FIELD_AGE_UNIT2["DAY"] = "D";
+  FIELD_AGE_UNIT2["MONTH"] = "M";
+  FIELD_AGE_UNIT2["YEAR"] = "Y";
+  FIELD_AGE_UNIT2["HOUR"] = "H";
+  FIELD_AGE_UNIT2["WEEK"] = "W";
+  FIELD_AGE_UNIT2["MINUTE"] = "N";
+  return FIELD_AGE_UNIT2;
+})(FIELD_AGE_UNIT || {});
+
+export { FIELD_AGE_UNIT, FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, FormItemLineBarDepKeyPrepend, InjectAsyncQueue, InjectionAnnotation, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionFormUUID, InjectionSchemaField };

package/es/components/form-render/src/hooks/index.js

@@ -1,13 +1,13 @@
-export { useFieldListAdaptor } from './useFieldListAdaptor2.js';
-export { useFormRequest } from './useFormRequest2.js';
-export { useCommonLog } from './useCommonLog2.js';
-export { useFormField } from './useFormField2.js';
-export { AsyncQueue, useAsyncQueue } from './useAsyncQueue2.js';
-export { useFieldVisitor } from './useFieldVisitor2.js';
-export { useFieldNormalize } from './useFieldNormalize2.js';
-export { useFormValidator } from './useFormValidator2.js';
-export { BusinessCollector, useBusinessBinding } from './useBusinessBinding2.js';
-export { ContextCollector, useChangeContext } from './useChangeContext2.js';
-export { FormItemDepsCollector, useFormItemDeps } from './useFormItemDeps2.js';
-export { useAnchor } from './useAnchor2.js';
-export { useFormContext } from './useFormContext2.js';
+export { useFieldListAdaptor } from './useFieldListAdaptor.js';
+export { useFormRequest } from './useFormRequest.js';
+export { useCommonLog } from './useCommonLog.js';
+export { useFormField } from './useFormField.js';
+export { AsyncQueue, useAsyncQueue } from './useAsyncQueue.js';
+export { useFieldVisitor } from './useFieldVisitor.js';
+export { useFieldNormalize } from './useFieldNormalize.js';
+export { useFormValidator } from './useFormValidator.js';
+export { BusinessCollector, useBusinessBinding } from './useBusinessBinding.js';
+export { ContextCollector, useChangeContext } from './useChangeContext.js';
+export { FormItemDepsCollector, useFormItemDeps } from './useFormItemDeps.js';
+export { useAnchor } from './useAnchor.js';
+export { useFormContext } from './useFormContext.js';

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

@@ -1 +1,99 @@
-export { useAnchor } from './useAnchor2.js';
+import { doAnimation } from '../../../../shared/utils/anime.js';
+import { useDebounceFn } from '@vueuse/core';
+import { isNumber } from 'lodash-es';
+import { ref, computed, watch, nextTick } from 'vue';
+import { FormItemLineBarDepKeyPrepend } from '../constants/index.js';
+import '../utils/index.js';
+import { createLinebarId, traverseSchema } from '../utils/schema.js';
+
+function useAnchor(props, scrollbarRef, 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()) || "" });
+      }
+    });
+  }
+  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(`#${createLinebarId(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 });
+          },
+          "easeInSine",
+          () => setTimeout(resolve, 300)
+        );
+      });
+    } finally {
+      scrollLock = false;
+    }
+  }
+  const onScroll = useDebounceFn(function() {
+    var _a;
+    if (scrollLock || !scrollbarRef.value)
+      return;
+    const { scrollTop, clientHeight } = scrollbarRef.value;
+    const result = anchorIdList.value.find((anchor, idx, arr) => {
+      const nextAnchor = arr[idx + 1];
+      if (!nextAnchor)
+        return true;
+      const node = scrollbarRef.value.querySelector(`#${createLinebarId(nextAnchor.name)}`);
+      if (!node)
+        return;
+      return node.offsetTop > scrollTop + clientHeight / 2;
+    }) || anchorIdList.value[anchorIdList.value.length - 1];
+    __currentAnchor.value = (_a = result == null ? void 0 : result.name) != null ? _a : "";
+  }, 300);
+  watch(
+    anchorIdList,
+    (_anchorIdList) => {
+      var _a, _b;
+      __currentAnchor.value = (_b = (_a = _anchorIdList[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/components/form-render/src/hooks/useAsyncQueue.js

@@ -1 +1,151 @@
-export { AsyncQueue, useAsyncQueue } from './useAsyncQueue2.js';
+import { uuidGenerator } from '../../../../shared/utils/index.js';
+import { cloneDeep, isFunction } from 'lodash-es';
+import '../../index.js';
+import { useCommonLog } from './useCommonLog.js';
+import { useFormRequest } from './useFormRequest.js';
+
+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(cloneDeep(entry.error), cloneDeep(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 = cloneDeep(r);
+    entry.error = cloneDeep(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, option) {
+    return new AsyncQueue({
+      name: "FormRenderAsyncQueue",
+      parallelism,
+      async processor({ key, method = "post", params, url }, cb, removeCache) {
+        var _a;
+        const http = getHttpInstance();
+        if (!http) {
+          useCommonLog().invalidHttpInstanceLog();
+          cb();
+          removeCache();
+          return;
+        }
+        try {
+          if (option && isFunction(option.beforeRequest)) {
+            params = (_a = option.beforeRequest(key, params)) != null ? _a : {};
+          }
+          let res = await http[method](url, params);
+          if (option && isFunction(option.afterRequest)) {
+            res = option.afterRequest(key, res);
+          }
+          cb(void 0, Array.isArray(res) ? res : []);
+        } catch (e) {
+          cb(new Error(`Request error => ${e}`));
+          removeCache();
+        }
+      },
+      getKey({ url, method = "post", cache, params }) {
+        if (!cache)
+          return uuidGenerator();
+        return url + method + JSON.stringify(params || {});
+      }
+    });
+  }
+  return { create };
+}
+
+export { AsyncQueue, useAsyncQueue };

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

@@ -1 +1,107 @@
-export { BusinessCollector, useBusinessBinding } from './useBusinessBinding2.js';
+import { isField } from '@formily/core';
+import { isString } from '@vueuse/core';
+import { isFunction, isNumber } from 'lodash-es';
+import { FIELD_BUSINESS_TYPE } from '../constants/index.js';
+import '../utils/index.js';
+import { isIdCard, parseIdCard, parseAge2FromContext, parseBirthday, parseAge2Birthday } from '../utils/business.js';
+
+class BusinessCollector {
+  constructor(formModel, businessFormatter) {
+    this.formModel = formModel;
+    this.businessFormatter = businessFormatter;
+    this.typeCollector = /* @__PURE__ */ new Map();
+    this.fieldNameCollector = /* @__PURE__ */ new Map();
+    this.changeHandlerMap = /* @__PURE__ */ new Map([]);
+    this.blurHandlerMap = /* @__PURE__ */ new Map([]);
+  }
+  formatter(...args) {
+    return isFunction(this.businessFormatter) ? this.businessFormatter(...args) : args[0].value;
+  }
+  collect(type, fieldName) {
+    this.typeCollector.set(type, fieldName);
+    this.fieldNameCollector.set(fieldName, type);
+  }
+  getField(type) {
+    return this.typeCollector.get(type);
+  }
+  getFieldInstanceByType(type) {
+    const field = this.getField(type);
+    return field ? this.formModel.query(field).take() : null;
+  }
+  getType(fieldName) {
+    return this.fieldNameCollector.get(fieldName);
+  }
+  getValueByField(fieldName) {
+    const _field = this.formModel.query(fieldName).take();
+    return isField(_field) ? _field.value : null;
+  }
+  getValueByType(type) {
+    const field = this.getField(type);
+    return field ? this.getValueByField(field) : null;
+  }
+  setValueByType(type, value, force = true) {
+    const field = this.getField(type);
+    field && this.formModel.setFieldState(field, (state) => {
+      if (!force && state.value)
+        return;
+      state.value = this.formatter({ value, type, fieldKey: field });
+    });
+  }
+  registerChangeBusiness(type, handler) {
+    this.changeHandlerMap.set(type, handler);
+    return this;
+  }
+  registerBlurBusiness(type, handler) {
+    this.blurHandlerMap.set(type, handler);
+    return this;
+  }
+  trigger(fieldName, triggerType = "change") {
+    var _a, _b;
+    const type = this.getType(fieldName);
+    const handlerMaps = { change: this.changeHandlerMap, blur: this.blurHandlerMap };
+    type && ((_b = (_a = handlerMaps[triggerType]) == null ? void 0 : _a.get(type)) == null ? void 0 : _b.call(this));
+  }
+}
+function useBusinessBinding() {
+  function handlerIdCardType() {
+    const idCard = this.getValueByType(FIELD_BUSINESS_TYPE.ID_CARD);
+    if (!idCard || !isString(idCard) || !isIdCard(idCard)) {
+      setSexDisabled.call(this, false);
+      return;
+    }
+    const info = parseIdCard(idCard);
+    const { age, ageUnit } = parseAge2FromContext(info);
+    this.setValueByType(FIELD_BUSINESS_TYPE.AGE_UNIT, ageUnit);
+    this.setValueByType(FIELD_BUSINESS_TYPE.AGE, age);
+    this.setValueByType(FIELD_BUSINESS_TYPE.SEX, info.sex);
+    this.setValueByType(FIELD_BUSINESS_TYPE.BIRTHDAY, info.birthday);
+    setSexDisabled.call(this, true);
+    function setSexDisabled(value) {
+      const sexField = this.getFieldInstanceByType(FIELD_BUSINESS_TYPE.SEX);
+      isField(sexField) && (sexField.disabled = value);
+    }
+  }
+  function handlerBirthdayType() {
+    const birthday = this.getValueByType(FIELD_BUSINESS_TYPE.BIRTHDAY);
+    if (!isString(birthday))
+      return;
+    const { age, ageUnit } = parseAge2FromContext(parseBirthday(birthday));
+    this.setValueByType(FIELD_BUSINESS_TYPE.AGE_UNIT, ageUnit);
+    this.setValueByType(FIELD_BUSINESS_TYPE.AGE, age);
+  }
+  function handlerAgeType() {
+    const age = this.getValueByType(FIELD_BUSINESS_TYPE.AGE);
+    const ageUnit = this.getValueByType(FIELD_BUSINESS_TYPE.AGE_UNIT);
+    if (!isString(age) && !isNumber(age) || age === "")
+      return;
+    if (!isString(ageUnit) || ageUnit === "")
+      return;
+    this.setValueByType(FIELD_BUSINESS_TYPE.BIRTHDAY, parseAge2Birthday(+age, ageUnit), false);
+  }
+  function create(formModel, formatter) {
+    return new BusinessCollector(formModel, formatter).registerChangeBusiness(FIELD_BUSINESS_TYPE.ID_CARD, handlerIdCardType).registerChangeBusiness(FIELD_BUSINESS_TYPE.AGE_UNIT, handlerAgeType).registerBlurBusiness(FIELD_BUSINESS_TYPE.BIRTHDAY, handlerBirthdayType).registerBlurBusiness(FIELD_BUSINESS_TYPE.AGE, handlerAgeType);
+  }
+  return { create };
+}
+
+export { BusinessCollector, useBusinessBinding };