cnhis-design-vue 3.1.7 → 3.1.8-beta.1

package/es/packages/form-render/src/components/textarea.mjs

@@ -0,0 +1 @@
+export { TEXTAREA } from './textarea2.mjs';

package/es/packages/form-render/src/components/textarea2.mjs

@@ -0,0 +1,11 @@
+import { assignUpdateValue } from '../utils/index2.mjs';
+import { connect, mapProps } from '@formily/vue';
+import { NInput } from 'naive-ui';
+
+const TEXTAREA = connect(NInput, mapProps((props, field) => {
+  const _props = assignUpdateValue(props, field);
+  _props.type = "textarea";
+  return _props;
+}));
+
+export { TEXTAREA };

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

@@ -0,0 +1,23 @@
+import { BusinessCollector } 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 enum FIELD_BUSINESS_TYPE {
+    PASSWORD = "password",
+    ID_CARD = "id_card",
+    AGE = "age",
+    MOBILE = "mobile",
+    TELEPHONE = "telephone",
+    EMAIL = "email",
+    BANK_CARD = "bank_card",
+    WEBSITE = "website",
+    GESTATIONAL_WEEKS = "gestational_weeks",
+    GESTATIONAL_STAGE = "gestational_stage",
+    CUSTOMER_NAME = "customer_name"
+}
+export declare enum FIELD_SEX_VALUE {
+    MALE = "1",
+    FEMALE = "2"
+}

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

@@ -0,0 +1 @@
+export { FIELD_BUSINESS_TYPE, FIELD_SEX_VALUE, InjectAsyncQueue, InjectionBusinessCollector, InjectionSchemaField } from './index2.mjs';

package/es/packages/form-render/src/constants/index2.mjs

@@ -0,0 +1,24 @@
+const InjectAsyncQueue = Symbol("InjectAsyncQueue");
+const InjectionSchemaField = Symbol("InjectionSchemaField");
+const InjectionBusinessCollector = Symbol("InjectionBusinessCollector");
+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["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, InjectAsyncQueue, InjectionBusinessCollector, InjectionSchemaField };

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

@@ -0,0 +1,9 @@
+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";

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

@@ -0,0 +1,9 @@
+export { useFieldList2Schema } from './useFieldList2Schema2.mjs';
+export { useFormRequest } from './useFormRequest2.mjs';
+export { useCommonLog } from './useCommonLog2.mjs';
+export { useFormField } from './useFormField2.mjs';
+export { AsyncQueue, useAsyncQueue } from './useAsyncQueue2.mjs';
+export { useFieldVisitor } from './useFieldVisitor2.mjs';
+export { useTypeNormalize } from './useTypeNormalize2.mjs';
+export { useFormValidator } from './useFormValidator2.mjs';
+export { BusinessCollector, useBusinessBinding } from './useBusinessBinding2.mjs';

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

@@ -0,0 +1,60 @@
+import { FormAsyncQueueItem } from "../types";
+declare enum ENTRY_STATE {
+    PENDING = 0,
+    DONE = 1
+}
+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;
+}
+interface AsyncQueueOptions<T = any, K = any> {
+    name: string;
+    processor: Processor<T>;
+    parallelism: number;
+    getKey: (item: T) => K;
+}
+/**
+ * @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;
+    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;
+}
+export declare function useAsyncQueue(): {
+    create: (parallelism?: number) => AsyncQueue<FormAsyncQueueItem, any, {
+        label: string;
+        value: any;
+    }[]>;
+};
+export {};

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

@@ -0,0 +1 @@
+export { AsyncQueue, useAsyncQueue } from './useAsyncQueue2.mjs';

package/es/packages/form-render/src/hooks/useAsyncQueue2.mjs

@@ -0,0 +1,138 @@
+import { useCommonLog } from './useCommonLog2.mjs';
+import { useFormRequest } from './useFormRequest2.mjs';
+
+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 new Error(`Request error => ${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.d.ts

@@ -0,0 +1,13 @@
+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>;
+    collect(type: FIELD_BUSINESS_TYPE, fieldName: string): void;
+    getField(type: FIELD_BUSINESS_TYPE): string[];
+    getType(fieldName: string): FIELD_BUSINESS_TYPE | undefined;
+}
+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

@@ -0,0 +1 @@
+export { BusinessCollector, useBusinessBinding } from './useBusinessBinding2.mjs';

package/es/packages/form-render/src/hooks/useBusinessBinding2.mjs

@@ -0,0 +1,48 @@
+import { isString } from '@vueuse/core';
+import { FIELD_BUSINESS_TYPE } from '../constants/index2.mjs';
+import { isIdCard, parseIdCard } from '../utils/index2.mjs';
+
+class BusinessCollector {
+  constructor() {
+    this.typeCollector = /* @__PURE__ */ new Map();
+    this.fieldNameCollector = /* @__PURE__ */ new Map();
+  }
+  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);
+  }
+}
+function useBusinessBinding() {
+  function create() {
+    return new BusinessCollector();
+  }
+  function handlerIdCardType(formModel, collector, value) {
+    if (!value || !isString(value) || !isIdCard(value))
+      return;
+    const info = parseIdCard(value);
+    const ageFields = collector.getField(FIELD_BUSINESS_TYPE.AGE);
+    ageFields.forEach((field) => {
+      formModel.setFieldState(field, (state) => {
+        state.value = info.age;
+      });
+    });
+  }
+  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))
+      return;
+    handlerMap.get(type)(formModel, collector, value);
+  }
+  return { create, trigger };
+}
+
+export { BusinessCollector, useBusinessBinding };

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

@@ -0,0 +1,3 @@
+export declare function useCommonLog(): {
+    invalidHttpInstanceLog: () => void;
+};

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

@@ -0,0 +1 @@
+export { useCommonLog } from './useCommonLog2.mjs';

package/es/packages/form-render/src/hooks/useCommonLog2.mjs

@@ -0,0 +1,10 @@
+import { formRenderLog } from '../utils/index2.mjs';
+
+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

@@ -0,0 +1,64 @@
+import { FieldItem } from '../types';
+import { BusinessCollector } from './useBusinessBinding';
+/**
+ * @description 胶水层, 将低代码平台中的fieldList转换为JSONSchema
+ */
+export declare function useFieldList2Schema(collector: BusinessCollector): {
+    transform: (fieldList: FieldItem[]) => Record<string, import("@formily/json-schema/esm/types").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string | undefined;
+        name?: import("@formily/json-schema/esm/types").SchemaKey | undefined;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean | undefined;
+        writeOnly?: boolean | undefined;
+        type?: import("@formily/json-schema/esm/types").SchemaTypes | undefined;
+        enum?: import("@formily/json-schema/esm/types").SchemaEnum<any> | undefined;
+        const?: any;
+        multipleOf?: number | undefined;
+        maximum?: number | undefined;
+        exclusiveMaximum?: number | undefined;
+        minimum?: number | undefined;
+        exclusiveMinimum?: number | undefined;
+        maxLength?: number | undefined;
+        minLength?: number | undefined;
+        pattern?: string | RegExp | undefined;
+        maxItems?: number | undefined;
+        minItems?: number | undefined;
+        uniqueItems?: boolean | undefined;
+        maxProperties?: number | undefined;
+        minProperties?: number | undefined;
+        required?: string | boolean | string[] | undefined;
+        format?: string | undefined;
+        $ref?: string | undefined;
+        $namespace?: string | undefined;
+        definitions?: import("@formily/json-schema/esm/types").SchemaProperties<any, any, any, any, any, any, any, any> | undefined;
+        properties?: import("@formily/json-schema/esm/types").SchemaProperties<any, any, any, any, any, any, any, any> | undefined;
+        items?: import("@formily/json-schema/esm/types").SchemaItems<any, any, any, any, any, any, any, any> | undefined;
+        additionalItems?: import("@formily/json-schema/esm/types").Stringify<any> | undefined;
+        patternProperties?: import("@formily/json-schema/esm/types").SchemaProperties<any, any, any, any, any, any, any, any> | undefined;
+        additionalProperties?: import("@formily/json-schema/esm/types").Stringify<any> | undefined;
+        "x-value"?: any;
+        "x-index"?: number | undefined;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@formily/json-schema/esm/types").SchemaReactions<any> | undefined;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean | undefined;
+        "x-hidden"?: boolean | undefined;
+        "x-disabled"?: boolean | undefined;
+        "x-editable"?: boolean | undefined;
+        "x-read-only"?: boolean | undefined;
+        "x-read-pretty"?: boolean | undefined;
+        "x-compile-omitted"?: string[] | undefined;
+    }>>;
+};

package/es/packages/form-render/src/hooks/useFieldList2Schema.mjs

@@ -0,0 +1 @@
+export { useFieldList2Schema } from './useFieldList2Schema2.mjs';

package/es/packages/form-render/src/hooks/useFieldList2Schema2.mjs

@@ -0,0 +1,184 @@
+import { arrayed, transformDateFormat } from '../utils/index2.mjs';
+import { useFormValidator } from './useFormValidator2.mjs';
+import { isObject } from '@vueuse/core';
+import { useTypeNormalize } from './useTypeNormalize2.mjs';
+
+function useFieldList2Schema(collector) {
+  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" },
+      "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,
+      properties: transform(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);
+    Object.assign(schema["x-component-props"], {
+      fieldItem: item
+    });
+    return schema;
+  };
+  const createCollapseSchema = (item) => {
+    return {
+      name: item.val_key,
+      type: "void",
+      title: item.alias || item.name,
+      "x-component": "COLLAPSE",
+      "x-component-props": {
+        disabled: item.is_not_fold === "1",
+        show: !!item.is_show
+      }
+    };
+  };
+  const creatorMap = /* @__PURE__ */ new Map([
+    ["LINEBAR", createCollapseSchema],
+    ["INPUT", createInputSchema],
+    ["INPUT_NUMBER", createInputNumberSchema],
+    ["SELECT", createSelectSchema],
+    ["DATE", createDateSchema],
+    ["SEARCH_CASCADE", createCascaderSchema],
+    ["COMBINATION", createCombinationSchema],
+    ["RADIO", createRadioSchema],
+    ["CHECKBOX", createRadioSchema],
+    ["SWITCH", createSwitchSchema],
+    ["SLIDER", createSliderSchema]
+  ]);
+  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: "1", hide_title: "1" };
+    }));
+    return {
+      type: "void",
+      title: item.alias || item.name,
+      "x-component": "INPUT_GROUP",
+      "x-component-props": { span: item.elem_width },
+      properties: transform(fieldList)
+    };
+  };
+  const { normalize } = useTypeNormalize();
+  function transform(fieldList) {
+    let prevCollapse = 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);
+      } else {
+        prevCollapse = null;
+        fin[cur.val_key] = createWidgetSchema(cur);
+      }
+      return fin;
+    }, {});
+  }
+  return { transform };
+}
+
+export { useFieldList2Schema };

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

@@ -0,0 +1,4 @@
+import { FieldItem, FieldVisitor } from "../types";
+export declare function useFieldVisitor(): {
+    traverse: (fieldList: FieldItem[], visitorMap?: FieldVisitor, key?: string) => FieldItem[];
+};

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

@@ -0,0 +1 @@
+export { useFieldVisitor } from './useFieldVisitor2.mjs';

package/es/packages/form-render/src/hooks/useFieldVisitor2.mjs

@@ -0,0 +1,38 @@
+import { arrayed } from '../utils/index2.mjs';
+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 };