cnhis-design-vue 3.1.5-beta.16 → 3.1.5-beta.17

package/es/packages/form-render/src/components/{radio.d.ts → renderer/radio.d.ts}

@@ -1,4 +1,4 @@
-import { AnyObject } from '../../../../../es/src/types';
+import { AnyObject } from '../../../../../../es/src/types';
 import { PropType } from "vue";
 export declare const RADIO: import("vue").DefineComponent<{
     options: {

package/es/packages/form-render/src/components/{radio2.js → renderer/radio.js}

@@ -1,7 +1,7 @@
 import { defineComponent, createVNode } from 'vue';
 import { connect, mapProps } from '@formily/vue';
 import { NRadioGroup, NSpace, NRadio } from 'naive-ui';
-import { assignUpdateValue } from '../utils/index2.js';
+import { assignUpdateValue } from '../../utils/index.js';
 
 const script = defineComponent({
   props: {

package/es/packages/form-render/src/components/{select.d.ts → renderer/select.d.ts}

@@ -1,5 +1,5 @@
-import { AnyObject } from '../../../../../es/src/types';
-import { FormRequestType } from '../types';
+import { AnyObject } from '../../../../../../es/src/types';
+import { FormRequestType } from '../../types';
 import { PropType } from 'vue';
 declare type UrlConfig = {
     method: FormRequestType;

package/es/packages/form-render/src/components/{select2.js → renderer/select.js}

@@ -1,12 +1,11 @@
 import { defineComponent, ref, inject, computed, watch, createVNode } from 'vue';
 import { cloneDeep } from 'lodash-es';
-import { InjectAsyncQueue, InjectionFormItemDepsCollector, InjectionChangeContextCollector } from '../constants/index2.js';
-import { assignUpdateValue, formRenderLog, generateUrlParams } from '../utils/index2.js';
+import { InjectAsyncQueue, InjectionFormItemDepsCollector, InjectionChangeContextCollector } from '../../constants/index.js';
+import { assignUpdateValue, formRenderLog, generateUrlParams } from '../../utils/index.js';
 import { isObject } from '@vueuse/core';
-import { useFormField } from '../hooks/useFormField2.js';
-import '../../../../packages/form-render/src/utils';
 import { connect, mapProps } from '@formily/vue';
 import { NSelect } from 'naive-ui';
+import { useFormField } from '../../hooks/useFormField.js';
 
 const script = defineComponent({
   name: "FormSelect",

package/es/packages/form-render/src/components/{slider.d.ts → renderer/slider.d.ts}

@@ -143,7 +143,7 @@ export declare const SLIDER: import("vue").DefineComponent<{
         style: import("vue").CSSProperties;
     }[]>;
     isShowTooltip: (index: number) => boolean;
-    isSkipCSSDetection: (index: number) => boolean;
+    shouldKeepTooltipTransition: (index: number) => boolean;
     handleRailRef: import("vue").Ref<HTMLElement | null>;
     setHandleRefs: (key: number) => (el: any) => void;
     setFollowerRefs: (key: number) => (el: any) => void;
@@ -333,15 +333,15 @@ export declare const SLIDER: import("vue").DefineComponent<{
         dotBorderRadius: string;
     }, any>>>;
 }>>, {
-    range: boolean;
-    reverse: boolean;
-    vertical: boolean;
-    tooltip: boolean;
-    disabled: boolean | undefined;
-    step: number | "mark";
-    max: number;
-    min: number;
-    to: string | boolean | HTMLElement;
-    defaultValue: number | number[];
-    showTooltip: boolean | undefined;
+    readonly range: boolean;
+    readonly reverse: boolean;
+    readonly vertical: boolean;
+    readonly tooltip: boolean;
+    readonly disabled: boolean | undefined;
+    readonly step: number | "mark";
+    readonly max: number;
+    readonly min: number;
+    readonly to: string | boolean | HTMLElement;
+    readonly defaultValue: number | number[];
+    readonly showTooltip: boolean | undefined;
 }>;

package/es/packages/form-render/src/components/{slider2.js → renderer/slider.js}

@@ -1,6 +1,6 @@
 import { connect, mapProps } from '@formily/vue';
 import { NSlider } from 'naive-ui';
-import { assignUpdateValue } from '../../../../packages/form-render/src/utils';
+import { assignUpdateValue } from '../../utils/index.js';
 
 const SLIDER = connect(NSlider, mapProps((props, field) => {
   const _props = assignUpdateValue(props, field);

package/es/packages/form-render/src/components/{switch2.js → renderer/switch.js}

@@ -1,6 +1,6 @@
 import { defineComponent, computed, createVNode, createTextVNode } from 'vue';
 import { NSwitch } from 'naive-ui';
-import { assignUpdateValue } from '../utils/index2.js';
+import { assignUpdateValue } from '../../utils/index.js';
 import { connect, mapProps } from '@formily/vue';
 
 const script = defineComponent({

package/es/packages/form-render/src/components/{textarea.d.ts → renderer/textarea.d.ts}

@@ -56,6 +56,7 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: undefined;
     };
+    allowInput: import("vue").PropType<(value: string) => boolean>;
     onMousedown: import("vue").PropType<(e: MouseEvent) => void>;
     onKeydown: import("vue").PropType<(e: KeyboardEvent) => void>;
     onKeyup: import("vue").PropType<(e: KeyboardEvent) => void>;
@@ -276,8 +277,8 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
         contentRef: HTMLElement | null;
         containerScrollTop: number;
         syncUnifiedContainer: () => void;
-        scrollTo: import("naive-ui/es/_internal/scrollbar/src/ScrollBar").ScrollTo;
-        scrollBy: import("naive-ui/es/_internal/scrollbar/src/ScrollBar").ScrollBy;
+        scrollTo: import("naive-ui/es/_internal/scrollbar/src/Scrollbar").ScrollTo;
+        scrollBy: import("naive-ui/es/_internal/scrollbar/src/Scrollbar").ScrollBy;
         sync: () => void;
         handleMouseEnterWrapper: () => void;
         handleMouseLeaveWrapper: () => void;
@@ -293,7 +294,7 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
     isComposing: import("vue").Ref<boolean>;
     activated: import("vue").Ref<boolean>;
     showClearButton: import("vue").ComputedRef<boolean>;
-    mergedSize: import("vue").ComputedRef<"small" | "medium" | "large" | "tiny">;
+    mergedSize: import("vue").ComputedRef<"small" | "medium" | "tiny" | "large">;
     mergedDisabled: import("vue").ComputedRef<boolean>;
     textDecorationStyle: import("vue").ComputedRef<string[] | {
         textDecoration: string;
@@ -311,7 +312,7 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
     handleCompositionEnd: (e: CompositionEvent) => void;
     handleInput: (e: Event | CompositionEvent | InputEvent, index?: 0 | 1 | undefined, event?: string | undefined) => void;
     handleInputBlur: (e: FocusEvent) => void;
-    handleInputFocus: (e: FocusEvent) => void;
+    handleInputFocus: (e: FocusEvent, index: number) => void;
     handleWrapperBlur: (e: FocusEvent) => void;
     handleWrapperFocus: (e: FocusEvent) => void;
     handleMouseEnter: () => void;
@@ -322,7 +323,7 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
     handleClear: (e: MouseEvent) => void;
     handlePasswordToggleClick: () => void;
     handlePasswordToggleMousedown: (e: MouseEvent) => void;
-    handleWrapperKeyDown: (e: KeyboardEvent) => void;
+    handleWrapperKeydown: (e: KeyboardEvent) => void;
     handleTextAreaMirrorResize: () => void;
     getTextareaScrollContainer: () => HTMLTextAreaElement | null;
     mergedTheme: import("vue").ComputedRef<{
@@ -366,10 +367,11 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
             opacity5: string;
             dividerColor: string;
             borderColor: string;
-            closeColor: string;
+            closeIconColor: string;
+            closeIconColorHover: string;
+            closeIconColorPressed: string;
             closeColorHover: string;
             closeColorPressed: string;
-            closeColorDisabled: string;
             clearColor: string;
             clearColorHover: string;
             clearColorPressed: string;
@@ -610,6 +612,7 @@ export declare const TEXTAREA: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: undefined;
     };
+    allowInput: import("vue").PropType<(value: string) => boolean>;
     onMousedown: import("vue").PropType<(e: MouseEvent) => void>;
     onKeydown: import("vue").PropType<(e: KeyboardEvent) => void>;
     onKeyup: import("vue").PropType<(e: KeyboardEvent) => void>;

package/es/packages/form-render/src/components/{textarea2.js → renderer/textarea.js}

@@ -1,4 +1,4 @@
-import { assignUpdateValue } from '../utils/index2.js';
+import { assignUpdateValue } from '../../utils/index.js';
 import { connect, mapProps } from '@formily/vue';
 import { NInput } from 'naive-ui';
 

package/es/packages/form-render/src/constants/index.d.ts

@@ -7,6 +7,7 @@ export declare const InjectionSchemaField: InjectionKey<Component>;
 export declare const InjectionBusinessCollector: InjectionKey<BusinessCollector>;
 export declare const InjectionChangeContextCollector: InjectionKey<ContextCollector>;
 export declare const InjectionFormItemDepsCollector: InjectionKey<FormItemDepsCollector>;
+export declare const FormItemLineBarDepKeyPrepend = "__dep_LINEBAR_";
 export declare enum FIELD_BUSINESS_TYPE {
     PASSWORD = "password",
     ID_CARD = "id_card",

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

@@ -1 +1,29 @@
-export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, InjectAsyncQueue, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, 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 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["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 || {});
+
+export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, FormItemLineBarDepKeyPrepend, InjectAsyncQueue, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionSchemaField };

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

@@ -9,3 +9,6 @@ export * from './useFormValidator';
 export * from './useBusinessBinding';
 export * from './useChangeContext';
 export * from './useFormItemDeps';
+export * from './useInitialData';
+export * from './useAnchor';
+export * from './useFormContext';

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

@@ -1,11 +1,14 @@
-export { useFieldList2Schema } from './useFieldList2Schema2.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 { useTypeNormalize } from './useTypeNormalize2.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 { useFieldList2Schema } from './useFieldList2Schema.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 { useTypeNormalize } from './useTypeNormalize.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 { useInitialData } from './useInitialData.js';
+export { useAnchor } from './useAnchor.js';
+export { useFormContext } from './useFormContext.js';

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

@@ -0,0 +1,16 @@
+import { AnyObject } from '../../../../../es/src/types';
+import { ISchema } from '@formily/json-schema/esm/types';
+import { FormItemDepsCollector } from '../../../../../es/packages/form-render';
+export declare function useAnchor(props: Readonly<AnyObject>, collector: FormItemDepsCollector): {
+    currentAnchor: import("vue").Ref<string>;
+    updateCurrentAnchor: (id: string) => Promise<void>;
+    onScroll: () => Promise<void>;
+    formHeight: import("vue").ComputedRef<any>;
+    anchorIdList: import("vue").Ref<{
+        name: string;
+        title: string;
+    }[]>;
+    generateAnchorList: (schema: ISchema) => void;
+    scrollbarRef: import("vue").Ref<HTMLElement | undefined>;
+    scrollTo: (id: string) => Promise<void>;
+};

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

@@ -0,0 +1,81 @@
+import { doAnimation } from '../../../../src/utils/anime';
+import { useDebounceFn } from '@vueuse/core';
+import { isNumber } from 'lodash-es';
+import { ref, computed, nextTick, watch } 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("");
+  async function updateCurrentAnchor(id) {
+    currentAnchor.value = id;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    await scrollTo(id);
+  }
+  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 });
+  return {
+    currentAnchor,
+    updateCurrentAnchor,
+    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(item) {
+        return item.url + JSON.stringify(item.params || {});
+      }
+    });
+  }
+  return { create };
+}
+
+export { AsyncQueue, useAsyncQueue };

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

@@ -1 +1,60 @@
-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.d.ts

@@ -1,4 +1,4 @@
-import { FormChangeContext } from '../../../../../es/packages/form-render';
+import { FormChangeContext } from '../types';
 export declare class ContextCollector {
     private readonly contextMap;
     setContext(key: string, prop: keyof FormChangeContext, value: any): void;

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

@@ -1 +1,21 @@
-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) {
+    return this.contextMap.get(key) || {};
+  }
+}
+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/useFieldList2Schema.d.ts

@@ -1,5 +1,5 @@
 import { FieldItem } from '../types';
-import { BusinessCollector } from './useBusinessBinding';
+import { BusinessCollector } from '../../../../../es/packages/form-render';
 /**
  * @description 胶水层, 将低代码平台中的fieldList转换为JSONSchema
  */