cnhis-design-vue 3.1.24-beta.7 → 3.1.24-beta.8

package/es/components/form-config/src/components/index.d.ts

@@ -0,0 +1,5 @@
+import FormConfigCreator from './FormConfigCreator.vue';
+import FormConfigEdit from './FormConfigEdit.vue';
+import FormConfigDragDisplay from './FormConfigDragDisplay.vue';
+export * from './renderer';
+export { FormConfigCreator, FormConfigEdit, FormConfigDragDisplay };

package/es/components/form-config/src/components/index.js

@@ -0,0 +1,6 @@
+export { default as FormConfigCreator } from './FormConfigCreator.js';
+export { default as FormConfigEdit } from './FormConfigEdit.js';
+export { default as FormConfigDragDisplay } from './FormConfigDragDisplay.js';
+export { default as CloseButton } from './renderer/CloseButton.js';
+export { default as ComplexNode } from './renderer/ComplexNode.js';
+export { default as DefaultNode } from './renderer/DefaultNode.js';

package/es/components/form-config/src/components/renderer/CloseButton.js

@@ -0,0 +1,45 @@
+import { defineComponent, inject, openBlock, createBlock, unref, withModifiers, withCtx, createVNode } from 'vue';
+import { CloseCircle } from '@vicons/ionicons5';
+import { isArray } from 'lodash-es';
+import { NButton, NIcon } from 'naive-ui';
+import { InjectionFieldList, InjectionMaterialList } from '../../constants/index.js';
+import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "CloseButton",
+  props: {
+    fieldItem: { type: Object, required: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const fieldList = inject(InjectionFieldList);
+    const materialList = inject(InjectionMaterialList);
+    const remove = () => {
+      traverse(fieldList.value);
+      function traverse(_fieldItem) {
+        return isArray(_fieldItem) && _fieldItem.some((_fieldItem2, idx, arr) => {
+          if (_fieldItem2 !== props.fieldItem)
+            return traverse(_fieldItem2.children);
+          !_fieldItem2.__new && materialList.value.push(_fieldItem2);
+          return arr.splice(idx, 1);
+        });
+      }
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(NButton), {
+        text: "",
+        class: "form-config__renderer--closeButton",
+        "text-color": "#a5a5a5",
+        onClick: withModifiers(remove, ["stop"])
+      }, {
+        icon: withCtx(() => [
+          createVNode(unref(NIcon), { component: unref(CloseCircle) }, null, 8, ["component"])
+        ]),
+        _: 1
+      }, 8, ["onClick"]);
+    };
+  }
+});
+var CloseButton = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "CloseButton.vue"]]);
+
+export { CloseButton as default };

package/es/components/form-config/src/components/renderer/CloseButton.vue.d.ts

@@ -0,0 +1,27 @@
+import { PropType } from 'vue';
+import { FormConfigItem } from '../../../../../../es/components/form-config';
+declare const _default: import("vue").DefineComponent<{
+    fieldItem: {
+        type: PropType<FormConfigItem>;
+        required: true;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+    }>> & {}>>;
+    fieldList: import("vue").Ref<FormConfigItem[]>;
+    materialList: import("vue").Ref<FormConfigItem[]>;
+    remove: () => void;
+    CloseCircle: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+    NButton: any;
+    NIcon: any;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    fieldItem: {
+        type: PropType<FormConfigItem>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/es/components/form-config/src/components/renderer/ComplexNode.js

@@ -0,0 +1,45 @@
+import { defineComponent, inject, computed, openBlock, createElementBlock, createElementVNode, mergeProps, unref, withModifiers, createTextVNode, toDisplayString, createVNode } from 'vue';
+import FormConfigDragDisplay from '../FormConfigDragDisplay.js';
+import CloseButton from './CloseButton.js';
+import { InjectionActiveFieldItem } from '../../constants/index.js';
+import { bindHover } from '../../utils/index.js';
+import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.js';
+
+const _hoisted_1 = { class: "form-config__renderer--complex form-config__renderer" };
+const _hoisted_2 = ["onClick"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "ComplexNode",
+  props: {
+    fieldItem: { type: Object, required: true },
+    textFormatter: { type: Function, required: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const currentActiveEditField = inject(InjectionActiveFieldItem);
+    function active() {
+      currentActiveEditField.value = props.fieldItem;
+    }
+    const headerClassList = computed(() => {
+      return [{ "is-active": currentActiveEditField.value === props.fieldItem }, "form-config__renderer--complexHeader"];
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("section", _hoisted_1, [
+        createElementVNode("header", mergeProps(unref(bindHover)(__props.fieldItem), {
+          class: unref(headerClassList),
+          onClick: withModifiers(active, ["stop"])
+        }), [
+          createTextVNode(toDisplayString(props.fieldItem.name) + " ", 1),
+          createVNode(CloseButton, { "field-item": __props.fieldItem }, null, 8, ["field-item"])
+        ], 16, _hoisted_2),
+        createVNode(FormConfigDragDisplay, mergeProps(_ctx.$props, {
+          modelValue: __props.fieldItem.children,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => __props.fieldItem.children = $event),
+          class: "form-config__renderer--complex--grid"
+        }), null, 16, ["modelValue"])
+      ]);
+    };
+  }
+});
+var ComplexNode = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "ComplexNode.vue"]]);
+
+export { ComplexNode as default };

package/es/components/form-config/src/components/renderer/ComplexNode.vue.d.ts

@@ -0,0 +1,167 @@
+import { PropType } from 'vue';
+import { FormConfigItem, FormConfigTextFormatter } from '../../../../../../es/components/form-config';
+import { bindHover } from '../../../../../../es/components/form-config/src/utils';
+declare const _default: import("vue").DefineComponent<{
+    fieldItem: {
+        type: PropType<FormConfigItem>;
+        required: true;
+    };
+    textFormatter: {
+        type: PropType<FormConfigTextFormatter>;
+        required: true;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+        textFormatter: {
+            type: PropType<FormConfigTextFormatter>;
+            required: true;
+        };
+    }>> & {}>>;
+    currentActiveEditField: import("vue").Ref<import("../../../../../shared/types").UndefinedAble<FormConfigItem>>;
+    active: () => void;
+    headerClassList: import("vue").ComputedRef<(string | {
+        'is-active': boolean;
+    })[]>;
+    FormConfigDragDisplay: import("vue").DefineComponent<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+        };
+        textFormatter: {
+            type: PropType<FormConfigTextFormatter>;
+            required: true;
+        };
+    }, {
+        getItemColumnStyle: (fieldItem?: FormConfigItem | undefined) => {
+            '--item-column': number;
+        };
+        getRenderer: (fieldItem: FormConfigItem) => import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | import("vue").FunctionalComponent<{}, {}>;
+        getCommonConfig: () => {
+            onMove: ({ to, from }: import("sortablejs").SortableEvent) => void;
+            onChoose: ({ target, item }: import("sortablejs").SortableEvent) => void;
+            onUnchoose: ({ from, to, target, item }: import("sortablejs").SortableEvent) => void;
+            tag: string;
+            animation: string;
+            'item-key': string;
+        };
+        Draggable: import("vue").DefineComponent<{
+            list: {
+                type: ArrayConstructor;
+                required: boolean;
+                default: any;
+            };
+            modelValue: {
+                type: ArrayConstructor;
+                required: boolean;
+                default: any;
+            };
+            itemKey: {
+                type: (StringConstructor | FunctionConstructor)[];
+                required: boolean;
+            };
+            clone: {
+                type: FunctionConstructor;
+                default: (original: any) => any;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+            move: {
+                type: FunctionConstructor;
+                default: any;
+            };
+            componentData: {
+                type: ObjectConstructor;
+                required: boolean;
+                default: any;
+            };
+        }, unknown, {
+            error: boolean;
+        }, {
+            realList(): any;
+            getKey(): any;
+        }, {
+            getUnderlyingVm(domElement: any): any;
+            getUnderlyingPotencialDraggableComponent(htmElement: any): any;
+            emitChanges(evt: any): void;
+            alterList(onList: any): void;
+            spliceList(): void;
+            updatePosition(oldIndex: any, newIndex: any): void;
+            getRelatedContextFromMoveEvent({ to, related }: {
+                to: any;
+                related: any;
+            }): any;
+            getVmIndexFromDomIndex(domIndex: any): any;
+            onDragStart(evt: any): void;
+            onDragAdd(evt: any): void;
+            onDragRemove(evt: any): void;
+            onDragUpdate(evt: any): void;
+            computeFutureIndex(relatedContext: any, evt: any): any;
+            onDragMove(evt: any, originalEvent: any): any;
+            onDragEnd(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any[], any, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+            move: Function;
+            tag: string;
+            clone: Function;
+            list: unknown[];
+            modelValue: unknown[];
+            componentData: Record<string, any>;
+        } & {
+            itemKey?: string | Function | undefined;
+        }>, {
+            move: Function;
+            tag: string;
+            clone: Function;
+            list: unknown[];
+            modelValue: unknown[];
+            componentData: Record<string, any>;
+        }>;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+        };
+        textFormatter: {
+            type: PropType<FormConfigTextFormatter>;
+            required: true;
+        };
+    }>>, {}>;
+    CloseButton: import("vue").DefineComponent<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            fieldItem: {
+                type: PropType<FormConfigItem>;
+                required: true;
+            };
+        }>> & {}>>;
+        fieldList: import("vue").Ref<FormConfigItem[]>;
+        materialList: import("vue").Ref<FormConfigItem[]>;
+        remove: () => void;
+        CloseCircle: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+        NButton: any;
+        NIcon: any;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+    }>>, {}>;
+    bindHover: typeof bindHover;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    fieldItem: {
+        type: PropType<FormConfigItem>;
+        required: true;
+    };
+    textFormatter: {
+        type: PropType<FormConfigTextFormatter>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/es/components/form-config/src/components/renderer/DefaultNode.js

@@ -0,0 +1,59 @@
+import { defineComponent, inject, computed, openBlock, createBlock, unref, mergeProps, withModifiers, withCtx, createVNode, normalizeClass, createTextVNode, toDisplayString } from 'vue';
+import { NButton, NEllipsis } from 'naive-ui';
+import CloseButton from './CloseButton.js';
+import { InjectionActiveFieldItem, WidgetTextMap } from '../../constants/index.js';
+import { bindHover } from '../../utils/index.js';
+import _export_sfc from '../../../../../_virtual/plugin-vue_export-helper.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DefaultNode",
+  props: {
+    fieldItem: { type: Object, required: true },
+    textFormatter: { type: Function, required: true }
+  },
+  setup(__props) {
+    const props = __props;
+    const currentActiveEditField = inject(InjectionActiveFieldItem);
+    function setActiveField() {
+      currentActiveEditField.value = props.fieldItem;
+    }
+    const classList = computed(() => {
+      return [{ "is-active": currentActiveEditField.value === props.fieldItem }, "form-config__renderer"];
+    });
+    const ellipsisClassList = computed(() => {
+      return ["form-config__renderer--default", { "is-required": props.fieldItem.required }];
+    });
+    const disabled = computed(() => {
+      return props.fieldItem.editable === false;
+    });
+    function getDisplayText() {
+      const type = WidgetTextMap.get(props.fieldItem.type);
+      return props.textFormatter(props.fieldItem, `${props.fieldItem.name}${type ? `(${type})` : ""}`);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(NButton), mergeProps({
+        secondary: !unref(disabled),
+        dashed: unref(disabled)
+      }, unref(bindHover)(__props.fieldItem), {
+        onClick: withModifiers(setActiveField, ["stop"]),
+        class: unref(classList)
+      }), {
+        default: withCtx(() => [
+          createVNode(unref(NEllipsis), {
+            class: normalizeClass(unref(ellipsisClassList))
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(getDisplayText()), 1)
+            ]),
+            _: 1
+          }, 8, ["class"]),
+          createVNode(CloseButton, { "field-item": __props.fieldItem }, null, 8, ["field-item"])
+        ]),
+        _: 1
+      }, 16, ["secondary", "dashed", "onClick", "class"]);
+    };
+  }
+});
+var DefaultNode = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "DefaultNode.vue"]]);
+
+export { DefaultNode as default };

package/es/components/form-config/src/components/renderer/DefaultNode.vue.d.ts

@@ -0,0 +1,71 @@
+import { PropType } from 'vue';
+import { FormConfigItem, FormConfigTextFormatter } from '../../../../../../es/components/form-config';
+import { bindHover } from '../../../../../../es/components/form-config/src/utils';
+declare const _default: import("vue").DefineComponent<{
+    fieldItem: {
+        type: PropType<FormConfigItem>;
+        required: true;
+    };
+    textFormatter: {
+        type: PropType<FormConfigTextFormatter>;
+        required: true;
+    };
+}, {
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+        textFormatter: {
+            type: PropType<FormConfigTextFormatter>;
+            required: true;
+        };
+    }>> & {}>>;
+    currentActiveEditField: import("vue").Ref<import("../../../../../shared/types").UndefinedAble<FormConfigItem>>;
+    setActiveField: () => void;
+    classList: import("vue").ComputedRef<(string | {
+        'is-active': boolean;
+    })[]>;
+    ellipsisClassList: import("vue").ComputedRef<(string | {
+        'is-required': boolean | undefined;
+    })[]>;
+    disabled: import("vue").ComputedRef<boolean>;
+    getDisplayText: () => string;
+    NEllipsis: any;
+    NButton: any;
+    CloseButton: import("vue").DefineComponent<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+    }, {
+        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            fieldItem: {
+                type: PropType<FormConfigItem>;
+                required: true;
+            };
+        }>> & {}>>;
+        fieldList: import("vue").Ref<FormConfigItem[]>;
+        materialList: import("vue").Ref<FormConfigItem[]>;
+        remove: () => void;
+        CloseCircle: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+        NButton: any;
+        NIcon: any;
+    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        fieldItem: {
+            type: PropType<FormConfigItem>;
+            required: true;
+        };
+    }>>, {}>;
+    bindHover: typeof bindHover;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    fieldItem: {
+        type: PropType<FormConfigItem>;
+        required: true;
+    };
+    textFormatter: {
+        type: PropType<FormConfigTextFormatter>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/es/components/form-config/src/components/renderer/index.d.ts

@@ -0,0 +1,4 @@
+import CloseButton from './CloseButton.vue';
+import ComplexNode from './ComplexNode.vue';
+import DefaultNode from './DefaultNode.vue';
+export { CloseButton, ComplexNode, DefaultNode };

package/es/components/form-config/src/components/renderer/index.js

@@ -0,0 +1,3 @@
+export { default as CloseButton } from './CloseButton.js';
+export { default as ComplexNode } from './ComplexNode.js';
+export { default as DefaultNode } from './DefaultNode.js';

package/es/components/form-config/src/constants/index.d.ts

@@ -0,0 +1,64 @@
+import { UndefinedAble } from '../../../../../es/shared/types';
+import { InjectionKey, Ref } from 'vue';
+import { FormConfigItem } from '../../../../../es/components/form-config';
+export declare const WidgetTextMap: Map<string, string>;
+export declare enum EditAbleField {
+    NAME = "name",
+    NOTES = "notes",
+    DEFAULT_VALUE = "defaultValue",
+    LAYOUT_WIDTH_ENUM = "layoutWidthEnum",
+    DESC = "desc",
+    DEFAULT_EXPAND = "defaultExpand",
+    FOLD = "fold",
+    REQUIRED = "required",
+    EDITABLE = "editable"
+}
+export declare function widgetWidthOptionConfig(): {
+    option: {
+        text: string;
+        value: string;
+    }[];
+};
+export declare function isShowOptionConfig(): {
+    open: {
+        describe: string;
+        value: boolean;
+    };
+    close: {
+        describe: string;
+        value: boolean;
+    };
+};
+export declare function isNotFoldOptionConfig(): {
+    open: {
+        describe: string;
+        value: boolean;
+    };
+    close: {
+        describe: string;
+        value: boolean;
+    };
+};
+export declare function isEditOptionConfig(): {
+    open: {
+        describe: string;
+        value: boolean;
+    };
+    close: {
+        describe: string;
+        value: boolean;
+    };
+};
+export declare function isNullOptionConfig(): {
+    open: {
+        describe: string;
+        value: boolean;
+    };
+    close: {
+        describe: string;
+        value: boolean;
+    };
+};
+export declare const InjectionFieldList: InjectionKey<Ref<FormConfigItem[]>>;
+export declare const InjectionMaterialList: InjectionKey<Ref<FormConfigItem[]>>;
+export declare const InjectionActiveFieldItem: InjectionKey<Ref<UndefinedAble<FormConfigItem>>>;

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

@@ -0,0 +1,60 @@
+const WidgetTextMap = /* @__PURE__ */ new Map([
+  ["LINE_BAR", "\u5206\u7EBF\u680F"],
+  ["NEWLINE", "\u5206\u884C\u7B26"]
+]);
+var EditAbleField = /* @__PURE__ */ ((EditAbleField2) => {
+  EditAbleField2["NAME"] = "name";
+  EditAbleField2["NOTES"] = "notes";
+  EditAbleField2["DEFAULT_VALUE"] = "defaultValue";
+  EditAbleField2["LAYOUT_WIDTH_ENUM"] = "layoutWidthEnum";
+  EditAbleField2["DESC"] = "desc";
+  EditAbleField2["DEFAULT_EXPAND"] = "defaultExpand";
+  EditAbleField2["FOLD"] = "fold";
+  EditAbleField2["REQUIRED"] = "required";
+  EditAbleField2["EDITABLE"] = "editable";
+  return EditAbleField2;
+})(EditAbleField || {});
+function widgetWidthOptionConfig() {
+  return {
+    option: [
+      { text: "\u6574\u884C", value: "ALL_LINE" },
+      { text: "\u534A\u884C", value: "HALF_LINE" },
+      { text: "5/6", value: "FIVE_SIX" },
+      { text: "2/3", value: "TWO_THREE" },
+      { text: "1/3", value: "ONE_THREE" },
+      { text: "3/4", value: "THREE_FOUR" },
+      { text: "1/4", value: "ONE_FOUR" },
+      { text: "1/6", value: "ONE_SIX" },
+      { text: "1/8", value: "ONE_EIGHT" }
+    ]
+  };
+}
+function isShowOptionConfig() {
+  return {
+    open: { describe: "\u9ED8\u8BA4\u5C55\u5F00", value: true },
+    close: { describe: "\u9ED8\u8BA4\u6536\u8D77", value: false }
+  };
+}
+function isNotFoldOptionConfig() {
+  return {
+    open: { describe: "\u53EF\u6298\u53E0", value: true },
+    close: { describe: "\u4E0D\u53EF\u6298\u53E0", value: false }
+  };
+}
+function isEditOptionConfig() {
+  return {
+    open: { describe: "\u53EF\u7F16\u8F91", value: true },
+    close: { describe: "\u4E0D\u53EF\u7F16\u8F91", value: false }
+  };
+}
+function isNullOptionConfig() {
+  return {
+    open: { describe: "\u5FC5\u586B", value: true },
+    close: { describe: "\u4E0D\u5FC5\u586B", value: false }
+  };
+}
+const InjectionFieldList = Symbol("InjectionFieldList");
+const InjectionMaterialList = Symbol("InjectionMaterialList");
+const InjectionActiveFieldItem = Symbol("InjectionActiveFieldItem");
+
+export { EditAbleField, InjectionActiveFieldItem, InjectionFieldList, InjectionMaterialList, WidgetTextMap, isEditOptionConfig, isNotFoldOptionConfig, isNullOptionConfig, isShowOptionConfig, widgetWidthOptionConfig };

package/es/components/form-config/src/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './usePresetRenderer';
+export * from './useSortalbeConfig';
+export * from './useConfigurationField';

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

@@ -0,0 +1,3 @@
+export { usePresetRenderer } from './usePresetRenderer.js';
+export { useSortableConfig } from './useSortalbeConfig.js';
+export { useConfigurationField } from './useConfigurationField.js';

package/es/components/form-config/src/hooks/useConfigurationField.d.ts

@@ -0,0 +1,7 @@
+import { FormConfigItem } from '../../../../../es/components/form-config';
+import { EditAbleField } from '../../../../../es/components/form-config/src/constants';
+import { FieldItem } from '../../../../../es/components/form-render';
+export declare function useConfigurationField(): {
+    generateFieldListByKeys: (keyList: EditAbleField[]) => FieldItem[];
+    generateFieldListByFieldItem: (fieldItem: FormConfigItem) => FieldItem[];
+};

package/es/components/form-config/src/hooks/useConfigurationField.js

@@ -0,0 +1,54 @@
+import { EditAbleField, widgetWidthOptionConfig, isShowOptionConfig, isNotFoldOptionConfig, isEditOptionConfig, isNullOptionConfig } from '../constants/index.js';
+
+function useConfigurationField() {
+  const fieldMap = /* @__PURE__ */ new Map([
+    [EditAbleField.NAME, { alias: "\u540D\u79F0", elem_width: 6, is_null: "0", html_type: "INPUT" }],
+    [EditAbleField.NOTES, { alias: "\u95EE\u53F7\u63D0\u793A", elem_width: 6, html_type: "INPUT" }],
+    [
+      EditAbleField.DEFAULT_VALUE,
+      { alias: "\u9ED8\u8BA4\u503C", elem_width: 6, html_type: "INPUT", validate: { max_length: 20 } }
+    ],
+    [
+      EditAbleField.LAYOUT_WIDTH_ENUM,
+      { alias: "\u5BBD\u5EA6", fieldType: "number", html_type: "SELECT", elem_width: 6, ...widgetWidthOptionConfig() }
+    ],
+    [EditAbleField.DESC, { alias: "\u8BF4\u660E\u6587\u672C", elem_width: 6, html_type: "INPUT", validate: { max_length: 30 } }],
+    [
+      EditAbleField.DEFAULT_EXPAND,
+      { alias: "\u662F\u5426\u9ED8\u8BA4\u5C55\u5F00", html_type: "SWITCH", elem_width: 6, ...isShowOptionConfig() }
+    ],
+    [EditAbleField.FOLD, { alias: "\u662F\u5426\u53EF\u6298\u53E0", html_type: "SWITCH", elem_width: 6, ...isNotFoldOptionConfig() }],
+    [EditAbleField.EDITABLE, { alias: "\u662F\u5426\u53EF\u7F16\u8F91", html_type: "SWITCH", elem_width: 6, ...isEditOptionConfig() }],
+    [EditAbleField.REQUIRED, { alias: "\u662F\u5426\u5FC5\u586B", html_type: "SWITCH", elem_width: 6, ...isNullOptionConfig() }]
+  ]);
+  function generateFieldListByKeys(keyList) {
+    return keyList.map((key) => {
+      return { ...fieldMap.get(key), val_key: key };
+    });
+  }
+  function generateFieldListByFieldItem(fieldItem) {
+    const htmlMap = new Map([
+      [
+        "LINE_BAR",
+        [EditAbleField.NAME, EditAbleField.LAYOUT_WIDTH_ENUM, EditAbleField.DEFAULT_EXPAND, EditAbleField.FOLD]
+      ],
+      ...["NEWLINE", "COMPLEX", "COMBINATION"].map(
+        (key) => [key, [EditAbleField.NAME, EditAbleField.LAYOUT_WIDTH_ENUM]]
+      )
+    ]);
+    const defaultItems = [
+      EditAbleField.NAME,
+      EditAbleField.DEFAULT_VALUE,
+      EditAbleField.LAYOUT_WIDTH_ENUM,
+      EditAbleField.DESC,
+      EditAbleField.NOTES,
+      EditAbleField.EDITABLE,
+      EditAbleField.REQUIRED
+    ];
+    const keys = htmlMap.get(fieldItem.type) || defaultItems;
+    return generateFieldListByKeys(keys);
+  }
+  return { generateFieldListByKeys, generateFieldListByFieldItem };
+}
+
+export { useConfigurationField };

package/es/components/form-config/src/hooks/usePresetRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FormConfigItem } from '../types';
+export declare function usePresetRenderer(): {
+    getRenderer: (fieldItem: FormConfigItem) => import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | import("vue").FunctionalComponent<{}, {}>;
+};