cnhis-design-vue 3.1.9 → 3.1.11-beta.1

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

@@ -1,4 +1,4 @@
-import { assignUpdateValue } from '../utils/index.mjs';
+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

@@ -1,9 +1,13 @@
-import { BusinessCollector } from '../hooks';
+import { ContextCollector } from '../../../../../es/packages/form-render/src/hooks/useChangeContext';
+import { BusinessCollector, FormItemDepsCollector } from '../hooks';
 import { FormAsyncQueue } from '../types';
 import { Component, InjectionKey } from 'vue';
 export declare const InjectAsyncQueue: InjectionKey<FormAsyncQueue>;
 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.mjs → index.js}

@@ -1,6 +1,9 @@
 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";
@@ -23,4 +26,4 @@ var FIELD_SEX_VALUE = /* @__PURE__ */ ((FIELD_SEX_VALUE2) => {
   return FIELD_SEX_VALUE2;
 })(FIELD_SEX_VALUE || {});
 
-export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, InjectAsyncQueue, InjectionBusinessCollector, InjectionSchemaField };
+export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, FormItemLineBarDepKeyPrepend, InjectAsyncQueue, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionSchemaField };

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

@@ -1,9 +1,14 @@
-export * from "./useFieldList2Schema";
-export * from "./useFormRequest";
-export * from "./useCommonLog";
-export * from "./useFormField";
-export * from "./useAsyncQueue";
-export * from "./useFieldVisitor";
-export * from "./useTypeNormalize";
-export * from "./useFormValidator";
-export * from "./useBusinessBinding";
+export * from './useFieldList2Schema';
+export * from './useFormRequest';
+export * from './useCommonLog';
+export * from './useFormField';
+export * from './useAsyncQueue';
+export * from './useFieldVisitor';
+export * from './useTypeNormalize';
+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

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

@@ -1,27 +1,7 @@
-import { FormAsyncQueueItem } from "../types";
-declare enum ENTRY_STATE {
-    PENDING = 0,
-    DONE = 1
-}
+import { FormAsyncQueueItem } from '../types';
 interface EntryCallback {
     (err?: any, result?: any): void;
 }
-declare class AsyncQueueEntry<K = any> {
-    key: K;
-    item: any;
-    state: ENTRY_STATE;
-    callback?: EntryCallback;
-    callbacks?: EntryCallback[];
-    result?: any;
-    error?: any;
-    constructor(item: any, key: K, callback: EntryCallback);
-}
-declare class ArrayQueue<K = any> {
-    _list: AsyncQueueEntry<K>[];
-    constructor(items?: AsyncQueueEntry<K>[]);
-    enqueue(item: AsyncQueueEntry<K>): void;
-    dequeue(): AsyncQueueEntry<K> | undefined;
-}
 interface Processor<T, R = any> {
     (item: T, cb: (err?: any, result?: R) => void, removeCache: () => void): void;
 }
@@ -35,21 +15,21 @@ interface AsyncQueueOptions<T = any, K = any> {
  * @constructor 并发控制器
  */
 export declare class AsyncQueue<T = any, K = any, R = any> {
-    name: string;
-    processor: Processor<T, R>;
-    getKey: AsyncQueueOptions<T, K>["getKey"];
-    parallelism: number;
-    _queued: ArrayQueue<K>;
-    _entries: Map<K, AsyncQueueEntry<K>>;
-    _activeTasks: number;
-    _processingLock: boolean;
-    _stopped: boolean;
+    readonly name: string;
+    private readonly processor;
+    private readonly getKey;
+    private readonly parallelism;
+    private readonly _queued;
+    private readonly _entries;
+    private _activeTasks;
+    private _processingLock;
+    private _stopped;
     constructor({ name, processor, getKey, parallelism }: AsyncQueueOptions<T>);
     add(item: T, callback: EntryCallback): void;
     addAsync(item: T): Promise<R>;
-    _ensureProcessing(): void;
-    _startProcess(entry: AsyncQueueEntry): void;
-    _handlerResult(entry: AsyncQueueEntry, e?: any, r?: any): void;
+    private _ensureProcessing;
+    private _startProcess;
+    private _handlerResult;
 }
 export declare function useAsyncQueue(): {
     create: (parallelism?: number) => AsyncQueue<FormAsyncQueueItem, any, {

package/es/packages/form-render/src/hooks/{useAsyncQueue.mjs → useAsyncQueue.js}

@@ -1,5 +1,5 @@
-import { useCommonLog } from './useCommonLog.mjs';
-import { useFormRequest } from './useFormRequest.mjs';
+import { useCommonLog } from './useCommonLog.js';
+import { useFormRequest } from './useFormRequest.js';
 
 class AsyncQueueEntry {
   constructor(item, key, callback) {
@@ -120,7 +120,7 @@ function useAsyncQueue() {
           const res = await http[method](url, params);
           const { data, success } = res;
           if (!success)
-            throw new Error(`Request error => ${res}`);
+            throw res;
           cb(void 0, data);
         } catch (e) {
           cb(new Error(`Request error => ${e}`));

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

@@ -1,13 +1,15 @@
 import { Form } from '@formily/core';
 import { FIELD_BUSINESS_TYPE } from '../constants';
 export declare class BusinessCollector {
-    typeCollector: Map<FIELD_BUSINESS_TYPE, Set<string>>;
-    fieldNameCollector: Map<string, FIELD_BUSINESS_TYPE>;
+    private readonly typeCollector;
+    private readonly fieldNameCollector;
     collect(type: FIELD_BUSINESS_TYPE, fieldName: string): void;
     getField(type: FIELD_BUSINESS_TYPE): string[];
     getType(fieldName: string): FIELD_BUSINESS_TYPE | undefined;
+    handlerIdCardType(formModel: Form, value: unknown): void;
+    handlerMap: Map<FIELD_BUSINESS_TYPE, (formModel: Form, value: unknown) => void>;
+    trigger(formModel: Form, fieldName: string, value: unknown): void;
 }
 export declare function useBusinessBinding(): {
     create: () => BusinessCollector;
-    trigger: (collector: BusinessCollector, formModel: Form, fieldName: string, value: unknown) => void;
 };

package/es/packages/form-render/src/hooks/{useBusinessBinding.mjs → useBusinessBinding.js}

@@ -1,11 +1,12 @@
 import { isString } from '@vueuse/core';
-import { FIELD_BUSINESS_TYPE } from '../constants/index.mjs';
-import { isIdCard, parseIdCard } from '../utils/index.mjs';
+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();
@@ -19,42 +20,41 @@ class BusinessCollector {
   getType(fieldName) {
     return this.fieldNameCollector.get(fieldName);
   }
-}
-function useBusinessBinding() {
-  function create() {
-    return new BusinessCollector();
-  }
-  function handlerIdCardType(formModel, collector, value) {
+  handlerIdCardType(formModel, value) {
     if (!value || !isString(value) || !isIdCard(value))
       return;
     const info = parseIdCard(value);
-    const ageFields = collector.getField(FIELD_BUSINESS_TYPE.AGE);
+    const ageFields = this.getField(FIELD_BUSINESS_TYPE.AGE);
     ageFields.forEach((field) => {
       formModel.setFieldState(field, (state) => {
         state.value = info.age;
       });
     });
-    const sexFields = collector.getField(FIELD_BUSINESS_TYPE.SEX);
+    const sexFields = this.getField(FIELD_BUSINESS_TYPE.SEX);
     sexFields.forEach((field) => {
       formModel.setFieldState(field, (state) => {
         state.value = info.sex;
       });
     });
-    const birthdayFields = collector.getField(FIELD_BUSINESS_TYPE.BIRTHDAY);
+    const birthdayFields = this.getField(FIELD_BUSINESS_TYPE.BIRTHDAY);
     birthdayFields.forEach((field) => {
       formModel.setFieldState(field, (state) => {
         state.value = info.birthday;
       });
     });
   }
-  const handlerMap = /* @__PURE__ */ new Map([[FIELD_BUSINESS_TYPE.ID_CARD, handlerIdCardType]]);
-  function trigger(collector, formModel, fieldName, value) {
-    const type = collector.fieldNameCollector.get(fieldName);
-    if (!type || !handlerMap.has(type))
+  trigger(formModel, fieldName, value) {
+    const type = this.getType(fieldName);
+    if (!type || !this.handlerMap.has(type))
       return;
-    handlerMap.get(type)(formModel, collector, value);
+    this.handlerMap.get(type)(formModel, value);
+  }
+}
+function useBusinessBinding() {
+  function create() {
+    return new BusinessCollector();
   }
-  return { create, trigger };
+  return { create };
 }
 
 export { BusinessCollector, useBusinessBinding };

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

@@ -0,0 +1,11 @@
+import { FormChangeContext } from '../types';
+export declare class ContextCollector {
+    private readonly contextMap;
+    setContext(key: string, prop: keyof FormChangeContext, value: any): void;
+    getContext(key: string): Partial<{
+        currentOption: import("../../../../src/types").AnyObject;
+    }>;
+}
+export declare function useChangeContext(): {
+    create: () => ContextCollector;
+};

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

@@ -0,0 +1,21 @@
+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.mjs → useCommonLog.js}

@@ -1,4 +1,4 @@
-import { formRenderLog } from '../utils/index.mjs';
+import { formRenderLog } from '../utils/index.js';
 
 function useCommonLog() {
   function invalidHttpInstanceLog() {

package/es/packages/form-render/src/hooks/{useFieldList2Schema.mjs → useFieldList2Schema.js}

@@ -1,7 +1,7 @@
-import { arrayed, transformDateFormat } from '../utils/index.mjs';
-import { useFormValidator } from './useFormValidator.mjs';
+import { arrayed, transformDateFormat } from '../utils/index.js';
+import { useFormValidator } from './useFormValidator.js';
 import { isObject } from '@vueuse/core';
-import { useTypeNormalize } from './useTypeNormalize.mjs';
+import { useTypeNormalize } from './useTypeNormalize.js';
 
 function useFieldList2Schema(collector) {
   const { createValidatorSchema } = useFormValidator();
@@ -115,14 +115,15 @@ function useFieldList2Schema(collector) {
     });
     return schema;
   };
-  const createCollapseSchema = (item) => {
+  const createLinebarSchema = (item) => {
     return {
       name: item.val_key,
       type: "void",
       title: item.alias || item.name,
-      "x-component": "COLLAPSE",
+      "x-component": "LINEBAR",
       "x-component-props": {
         disabled: item.is_not_fold === "1",
+        id: item.val_key,
         show: !!item.is_show
       }
     };
@@ -135,7 +136,7 @@ function useFieldList2Schema(collector) {
     return schema;
   };
   const creatorMap = /* @__PURE__ */ new Map([
-    ["LINEBAR", createCollapseSchema],
+    ["LINEBAR", createLinebarSchema],
     ["INPUT", createInputSchema],
     ["INPUT_NUMBER", createInputNumberSchema],
     ["SELECT", createSelectSchema],
@@ -157,7 +158,7 @@ function useFieldList2Schema(collector) {
   const createWidgetCombinationSchema = (item) => {
     const suffixList = arrayed(item.suffixConfig);
     const fieldList = [{ ...item, suffixConfig: void 0 }].concat(suffixList.map((suffix) => {
-      return { ...suffix, is_show: "1", hide_title: "1" };
+      return { ...suffix, is_show: item.is_show, alias: " " };
     }));
     return {
       type: "void",
@@ -169,19 +170,19 @@ function useFieldList2Schema(collector) {
   };
   const { normalize } = useTypeNormalize();
   function transform(fieldList) {
-    let prevCollapse = null;
+    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] = createCollapseSchema(cur);
-        prevCollapse = fin[cur.val_key].properties = {};
-      } else if (prevCollapse) {
-        prevCollapse[cur.val_key] = createWidgetSchema(cur);
+        fin[cur.val_key] = createLinebarSchema(cur);
+        prevLinebar = fin[cur.val_key].properties = {};
+      } else if (prevLinebar) {
+        prevLinebar[cur.val_key] = createWidgetSchema(cur);
       } else {
-        prevCollapse = null;
+        prevLinebar = null;
         fin[cur.val_key] = createWidgetSchema(cur);
       }
       return fin;

package/es/packages/form-render/src/hooks/{useFieldVisitor.mjs → useFieldVisitor.js}

@@ -1,4 +1,4 @@
-import { arrayed } from '../utils/index.mjs';
+import { arrayed } from '../utils/index.js';
 import { isFunction } from '@vueuse/core';
 
 function useFieldVisitor() {

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

@@ -0,0 +1,8 @@
+import { AnyObject } from '../../../../../es/src/types';
+export declare function useFormContext(props: AnyObject): {
+    asyncQueue: import("../../../../../es/packages/form-render").FormAsyncQueue;
+    SchemaField: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>;
+    businessCollector: import("../../../../../es/packages/form-render").BusinessCollector;
+    changeContextCollector: import("../../../../../es/packages/form-render").ContextCollector;
+    formItemDepsCollector: import("../../../../../es/packages/form-render").FormItemDepsCollector;
+};

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

@@ -0,0 +1,26 @@
+import { createSchemaField } from '@formily/vue';
+import { provide } from 'vue';
+import { useAsyncQueue, useBusinessBinding, useChangeContext, useFormItemDeps } from '../../../../packages/form-render';
+import * as components from '../../../../packages/form-render/src/components/renderer';
+import { InjectAsyncQueue, InjectionSchemaField, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector } from '../../../../packages/form-render/src/constants';
+import { injectOrProvide } from '../../../../packages/form-render/src/utils';
+
+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);
+  return { asyncQueue, SchemaField, businessCollector, changeContextCollector, formItemDepsCollector };
+}
+
+export { useFormContext };

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

@@ -1,4 +1,5 @@
 export declare function useFormField(): {
     field: import("vue").Ref<import("@formily/core").GeneralField>;
     title: import("vue").ComputedRef<any>;
+    fieldKey: import("vue").ComputedRef<string>;
 };

package/es/packages/form-render/src/hooks/{useFormField.mjs → useFormField.js}

@@ -3,7 +3,11 @@ import { computed } from 'vue';
 
 function useFormField() {
   const field = useField();
-  return { field, title: computed(() => field.value.title) };
+  return {
+    field,
+    title: computed(() => field.value.title),
+    fieldKey: computed(() => field.value.props.name.toString())
+  };
 }
 
 export { useFormField };

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

@@ -0,0 +1,8 @@
+export declare class FormItemDepsCollector {
+    private readonly collector;
+    setDeps(key: string, dependKey: string | string[], callback: Function): void;
+    trigger(dependKey: string, payload?: any): void;
+}
+export declare function useFormItemDeps(): {
+    create: () => FormItemDepsCollector;
+};

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

@@ -0,0 +1,29 @@
+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/useFormValidator.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject } from 'cnhis-design-vue/es/src/types';
+import { AnyObject } from '../../../../../es/src/types';
 import { FieldItem } from '../types';
 export declare function useFormValidator(): {
     createValidatorSchema: (fieldItem: FieldItem) => AnyObject[];

package/es/packages/form-render/src/hooks/{useFormValidator.mjs → useFormValidator.js}

@@ -1,4 +1,4 @@
-import { arrayed } from '../utils/index.mjs';
+import { arrayed } from '../utils/index.js';
 import { isFunction } from '@vueuse/core';
 
 function useFormValidator() {

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

@@ -0,0 +1,5 @@
+import { AnyObject } from '../../../../../es/src/types';
+import { FieldItem } from '../types';
+export declare function useInitialData(): {
+    assignInitialData: (initialData?: AnyObject, fieldList?: FieldItem[]) => AnyObject;
+};

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

@@ -0,0 +1,11 @@
+function useInitialData() {
+  function assignInitialData(initialData, fieldList) {
+    return Object.assign({}, initialData, fieldList == null ? void 0 : fieldList.reduce((fin, cur) => {
+      cur.default_val && (fin[cur.val_key] = cur.default_val);
+      return fin;
+    }, {}));
+  }
+  return { assignInitialData };
+}
+
+export { useInitialData };

package/es/packages/form-render/src/types/fieldItem.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject } from 'cnhis-design-vue/es/src/types';
+import { AnyObject } from '../../../../../es/src/types';
 export declare type ValidateItem = Partial<{
     obj_type: string;
     vali_obj: string;

package/es/packages/form-render/src/types/fieldItem.js

@@ -0,0 +1 @@
+