ele-admin-plus 1.2.2-beta.5 → 1.3.0-beta.3

package/lib/ele-pro-form-builder/components/body-header.d.ts

@@ -0,0 +1,76 @@
+import { UserComponent } from '../../ele-app/types';
+import { ProFormItemTypeData } from '../../ele-pro-form/types';
+import { TemplateFormConfig, HeaderRightToolName } from '../types';
+
+declare function __VLS_template(): Partial<Record<string, (_: any) => any>> & {
+    headerTools?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 是否禁用撤销 */
+    undoDisabled?: boolean;
+    /** 是否禁用恢复 */
+    redoDisabled?: boolean;
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 顶栏右侧操作按钮顺序 */
+    headerTools?: HeaderRightToolName[];
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+    /** JSON 编辑器组件 */
+    jsonEditerComponent?: UserComponent;
+    /** 高级表单组件类型数据 */
+    itemTypeData?: ProFormItemTypeData[];
+    /** 远程数据源请求工具 */
+    httpRequest?: any;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:currentScreen": (size?: string | undefined) => void;
+    undo: () => void;
+    redo: () => void;
+    clear: () => void;
+    previewFormSubmit: (data: Record<string, any>) => void;
+    importData: (data: TemplateFormConfig) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 是否禁用撤销 */
+    undoDisabled?: boolean;
+    /** 是否禁用恢复 */
+    redoDisabled?: boolean;
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 顶栏右侧操作按钮顺序 */
+    headerTools?: HeaderRightToolName[];
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+    /** JSON 编辑器组件 */
+    jsonEditerComponent?: UserComponent;
+    /** 高级表单组件类型数据 */
+    itemTypeData?: ProFormItemTypeData[];
+    /** 远程数据源请求工具 */
+    httpRequest?: any;
+}>>> & {
+    onClear?: (() => any) | undefined;
+    onPreviewFormSubmit?: ((data: Record<string, any>) => any) | undefined;
+    onImportData?: ((data: TemplateFormConfig) => any) | undefined;
+    "onUpdate:currentScreen"?: ((size?: string | undefined) => any) | undefined;
+    onUndo?: (() => any) | undefined;
+    onRedo?: (() => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-pro-form-builder/components/build-core.cjs

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("../../utils/core");
+const util = require("../../ele-pro-form/util");
+const itemTypeData = require("../../ele-pro-form/components/item-type-data");
+const fixedChildTypes = [
+  { type: "tabs", childType: "tabPane" },
+  { type: "collapse", childType: "collapseItem" },
+  { type: "row", childType: "col" },
+  { type: "carousel", childType: "carouselItem" },
+  { type: "descriptions", childType: "descriptionsItem" },
+  { type: "table", childType: "tableRow" },
+  { type: "tableRow", childType: "tableCell" }
+];
+function generateItemKey() {
+  return `f${core.uuid(15, 36).toLowerCase()}`;
+}
+function generateUniqueItemKey(items, keys) {
+  let itemKey = generateItemKey();
+  while (true) {
+    if (!core.findTree(items, (d) => d.key === itemKey) && (!keys || !keys.includes(itemKey))) {
+      break;
+    }
+    itemKey = generateItemKey();
+  }
+  return itemKey;
+}
+function getComponentItemByType(type, componentData) {
+  if (!type || !componentData) {
+    return;
+  }
+  return componentData.map((groupItem) => groupItem.items).flat().find((item) => item.type === type);
+}
+function generateChildFormItem(parentType, childNo, childKey, componentData) {
+  var _a, _b;
+  let child;
+  if (parentType) {
+    const fc = fixedChildTypes.find((d) => d.type === parentType);
+    if (fc) {
+      child = { prop: "", type: fc.childType };
+    }
+  }
+  if (!child) {
+    child = { prop: "", type: "div" };
+  }
+  if (childKey) {
+    child.key = childKey;
+    child.prop = childKey;
+  }
+  const componentItem = getComponentItemByType(child.type, componentData);
+  const initialProps = (componentItem == null ? void 0 : componentItem.initialProps) ? JSON.parse(JSON.stringify(componentItem.initialProps)) : void 0;
+  if (initialProps) {
+    child.props = initialProps;
+  }
+  if (childNo && child.type) {
+    if (child.type === "collapseItem") {
+      if ((_a = child.props) == null ? void 0 : _a.title) {
+        child.props.title = child.props.title + childNo;
+      }
+    } else if (["descriptionsItem", "tabPane"].includes(child.type)) {
+      if ((_b = child.props) == null ? void 0 : _b.label) {
+        child.props.label = child.props.label + childNo;
+      }
+    } else if (child.label) {
+      child.label = child.label + childNo;
+    }
+  }
+  return child;
+}
+function generateBuildFormItem(type, formItems, componentData, itemTypeData$1) {
+  const componentItem = getComponentItemByType(type, componentData);
+  if (!componentItem) {
+    return;
+  }
+  const itemKey = generateUniqueItemKey(formItems);
+  const addedKeys = [itemKey];
+  const item = {
+    key: itemKey,
+    prop: itemKey,
+    label: componentItem.name,
+    type: componentItem.type,
+    required: false,
+    props: componentItem.initialProps ? JSON.parse(JSON.stringify(componentItem.initialProps)) : void 0
+  };
+  const typeData = item.type ? [...itemTypeData$1 || [], ...itemTypeData.defaultItemTypeData].find(
+    (d) => d.type === item.type
+  ) : void 0;
+  if (!item.type || item.type === "div" || util.isContainerType(item, itemTypeData$1) && !(typeData == null ? void 0 : typeData.renderLabelText)) {
+    item.label = "";
+  }
+  if (item.type === "table") {
+    item.label = "";
+    item.children = Array.from({ length: 2 }).map(() => {
+      const trKey = generateUniqueItemKey(formItems, addedKeys);
+      addedKeys.push(trKey);
+      const childItem = generateChildFormItem(
+        item.type,
+        void 0,
+        trKey,
+        componentData
+      );
+      const children = Array.from({ length: 3 }).map(() => {
+        const tdKey = generateUniqueItemKey(formItems, addedKeys);
+        addedKeys.push(tdKey);
+        return generateChildFormItem(
+          childItem.type,
+          void 0,
+          tdKey,
+          componentData
+        );
+      });
+      childItem.children = children;
+      return childItem;
+    });
+  } else if (item.type === "steps") {
+    item.label = "";
+    if (!item.props) {
+      item.props = {};
+    }
+    item.props.items = Array.from({ length: 3 }).map((_, i) => {
+      const childNo = String(i + 1).padStart(2, "0");
+      return {
+        title: `步骤${childNo}`,
+        description: `步骤${childNo}的描述内容`
+      };
+    });
+  } else if (item.type && fixedChildTypes.some((d) => d.type === item.type)) {
+    item.label = "";
+    item.children = Array.from({
+      length: item.type === "carousel" ? 3 : 2
+    }).map((_, i) => {
+      const childKey = generateUniqueItemKey(formItems, addedKeys);
+      addedKeys.push(childKey);
+      const childNo = String(i + 1).padStart(2, "0");
+      return generateChildFormItem(item.type, childNo, childKey, componentData);
+    });
+  }
+  return item;
+}
+function getFormDataAndItems(item, componentData) {
+  const data = item ? JSON.parse(JSON.stringify(item)) : item;
+  if (!data) {
+    return { data: {}, items: [] };
+  }
+  const componentItem = getComponentItemByType(data.type, componentData);
+  return {
+    data: util.mergeValue(
+      {},
+      { props: (componentItem == null ? void 0 : componentItem.presetProps) || {} },
+      { props: (componentItem == null ? void 0 : componentItem.defaultProps) || {} },
+      data
+    ),
+    items: (componentItem == null ? void 0 : componentItem.configForm) || []
+  };
+}
+function getPropertyPath(data, excludeKeys, prefix) {
+  const keys = [];
+  if (data != null) {
+    if (Array.isArray(data)) {
+      data.forEach((v, i) => {
+        const path = prefix ? `${prefix}[${i}]` : String(i);
+        if (v != null && typeof v === "object") {
+          getPropertyPath(v, excludeKeys, path).forEach((k) => {
+            keys.push(k);
+          });
+        } else {
+          keys.push(path);
+        }
+      });
+    } else if (typeof data === "object") {
+      Object.keys(data).forEach((key) => {
+        if (!excludeKeys || !excludeKeys.includes(key)) {
+          const path = prefix ? `${prefix}.${key}` : key;
+          const v = data[key];
+          if (v != null && typeof v === "object") {
+            getPropertyPath(v, excludeKeys, path).forEach((k) => {
+              keys.push(k);
+            });
+          } else {
+            keys.push(path);
+          }
+        }
+      });
+    }
+  }
+  return keys;
+}
+exports.fixedChildTypes = fixedChildTypes;
+exports.generateBuildFormItem = generateBuildFormItem;
+exports.generateChildFormItem = generateChildFormItem;
+exports.generateItemKey = generateItemKey;
+exports.generateUniqueItemKey = generateUniqueItemKey;
+exports.getComponentItemByType = getComponentItemByType;
+exports.getFormDataAndItems = getFormDataAndItems;
+exports.getPropertyPath = getPropertyPath;

package/lib/ele-pro-form-builder/components/build-core.d.ts

@@ -0,0 +1,58 @@
+import { ProFormItemProps, ProFormItemTypeData } from '../../ele-pro-form/types';
+import { ComponentGroup } from '../types';
+
+/**
+ * 有固定子级的组件类型
+ */
+export declare const fixedChildTypes: {
+    type: string;
+    childType: string;
+}[];
+/**
+ * 生成表单项 id
+ */
+export declare function generateItemKey(): string;
+/**
+ * 生成表单项 id 并检查重复
+ * @param items 当前表单项数据
+ * @param keys 新生成还未添加的表单项 id
+ */
+export declare function generateUniqueItemKey(items?: ProFormItemProps[], keys?: string[]): string;
+/**
+ * 根据组件类型名称获取对应组件定义
+ * @param type 组件类型名称
+ * @param componentData 组件库数据
+ */
+export declare function getComponentItemByType(type: string | undefined, componentData?: ComponentGroup[]): import('../types').ComponentItem | undefined;
+/**
+ * 生成子级表单项数据
+ * @param parentType 父组件类型
+ * @param childNo 子组件编号
+ * @param childKey 子组件 id
+ * @param componentData 组件库数据
+ */
+export declare function generateChildFormItem(parentType?: string, childNo?: string, childKey?: string, componentData?: ComponentGroup[]): ProFormItemProps;
+/**
+ * 生成表单项数据
+ * @param type 组件类型或组件数据
+ * @param formItems 当前的全部表单项数据
+ * @param componentData 组件库数据
+ * @param itemTypeData 高级表单组件类型数据
+ */
+export declare function generateBuildFormItem(type: string | undefined, formItems: ProFormItemProps[] | undefined, componentData?: ComponentGroup[], itemTypeData?: ProFormItemTypeData[]): ProFormItemProps | undefined;
+/**
+ * 获取表单项的属性值和对应的属性配置表单项数据
+ * @param item 表单项
+ * @param componentData 组件库数据
+ */
+export declare function getFormDataAndItems(item: ProFormItemProps | undefined, componentData?: ComponentGroup[]): {
+    data: Record<string, any>;
+    items: ProFormItemProps[];
+};
+/**
+ * 获取数据所有属性的路径数组
+ * @param data 数据
+ * @param excludeKeys 排除的属性名
+ * @param prefix 前缀
+ */
+export declare function getPropertyPath(data: any, excludeKeys?: string[], prefix?: string): string[];

package/lib/ele-pro-form-builder/components/build-util.cjs

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("../../utils/core");
+const buildCore = require("./build-core");
+const tableUtil = require("./table-util");
+function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, actionType, formItems, position, componentData) {
+  if (!triggerItem.type) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const parentItemId = triggerParent == null ? void 0 : triggerParent.key;
+  const afterIndex = triggerItemIndex == null ? void 0 : triggerItemIndex + 1;
+  if ([
+    "tabPane",
+    "collapseItem",
+    "col",
+    "carouselItem",
+    "descriptionsItem"
+  ].includes(triggerItem.type)) {
+    const item = buildCore.generateChildFormItem(
+      {
+        tabPane: "tabs",
+        collapseItem: "collapse",
+        col: "row",
+        carouselItem: "carousel",
+        descriptionsItem: "descriptions"
+      }[triggerItem.type],
+      void 0,
+      void 0,
+      componentData
+    );
+    itemsGenerateNewKey(item, formItems, true);
+    return {
+      addItems: [{ item, parentItemId, index: afterIndex }],
+      updateItems: [],
+      deleteItemIds: []
+    };
+  }
+  if (triggerItem.type === "tableCell") {
+    const result = {
+      addItems: [],
+      updateItems: [],
+      deleteItemIds: []
+    };
+    core.eachTree(formItems, (trItem, _trIndex, tableItem) => {
+      if (triggerParent && trItem.key === triggerParent.key && tableItem) {
+        const { addItems, updateItems, deleteItemIds } = (actionType === "addTableCol" ? tableUtil.generateAddTableColData : tableUtil.generateAddTableRowData)(tableItem, formItems, triggerItem, position, componentData);
+        result.addItems = addItems;
+        result.updateItems = updateItems;
+        result.deleteItemIds = deleteItemIds;
+        return false;
+      }
+    });
+    return result;
+  }
+  if (triggerItem.type === "table") {
+    return (actionType === "addTableCol" ? tableUtil.generateAddTableColData : tableUtil.generateAddTableRowData)(triggerItem, formItems, void 0, void 0, componentData);
+  }
+  const child = buildCore.generateChildFormItem(
+    triggerItem.type,
+    void 0,
+    void 0,
+    componentData
+  );
+  itemsGenerateNewKey(child, formItems, true);
+  return {
+    addItems: [{ item: child, parentItemId: triggerItem.key }],
+    updateItems: [],
+    deleteItemIds: []
+  };
+}
+function itemsGenerateNewKey(items, formItems, overwriteProp) {
+  if (!items) {
+    return;
+  }
+  const addedKeys = [];
+  core.eachTree(Array.isArray(items) ? items : [items], (item) => {
+    const itemKey = buildCore.generateUniqueItemKey(formItems, addedKeys);
+    addedKeys.push(itemKey);
+    item.key = itemKey;
+    if (overwriteProp) {
+      item.prop = itemKey;
+    }
+  });
+}
+function generateCopyItemData(formItemId, formItems) {
+  const result = {
+    addItems: [],
+    updateItems: [],
+    deleteItemIds: []
+  };
+  core.eachTree(formItems, (item, index, parent) => {
+    if (item.key === formItemId) {
+      const newItem = JSON.parse(JSON.stringify(item));
+      itemsGenerateNewKey(newItem, formItems, true);
+      result.addItems.push({
+        item: newItem,
+        parentItemId: parent == null ? void 0 : parent.key,
+        index: index + 1
+      });
+      return false;
+    }
+  });
+  return result;
+}
+exports.generateAddChildData = generateAddChildData;
+exports.generateCopyItemData = generateCopyItemData;
+exports.itemsGenerateNewKey = itemsGenerateNewKey;

package/lib/ele-pro-form-builder/components/build-util.d.ts

@@ -0,0 +1,28 @@
+import { ProFormItemKey, ProFormItemProps } from '../../ele-pro-form/types';
+import { ComponentGroup, UpdateItemsResult, AddChildrenItemAction } from '../types';
+
+/**
+ * 添加子级时生成需要的数据
+ * @param triggerItem 触发添加的表单项
+ * @param triggerParent 触发添加的表单项父级
+ * @param triggerItemIndex 触发添加的表单项在父级中的位置
+ * @param actionType 添加类型
+ * @param formItems 当前的全部表单项数据
+ * @param position 触发位置的上方(左侧)或下方(右侧)添加, 默认下方(左侧)
+ * @param componentData 组件库数据
+ */
+export declare function generateAddChildData(triggerItem: ProFormItemProps, triggerParent: ProFormItemProps | undefined, triggerItemIndex: number | undefined, actionType: AddChildrenItemAction | undefined, formItems?: ProFormItemProps[], position?: -1, componentData?: ComponentGroup[]): UpdateItemsResult;
+/**
+ * 表单项数据生成新的 id
+ * @param items 表单项数据
+ * @param formItems 当前的全部表单项数据
+ * @param overwriteProp prop 是否也重新生成
+ * @param generateTypeName 是否生成类型名称到数据
+ */
+export declare function itemsGenerateNewKey(items?: ProFormItemProps[] | ProFormItemProps, formItems?: ProFormItemProps[], overwriteProp?: boolean): void;
+/**
+ * 复制表单项时生成需要的数据
+ * @param formItemId 表单项 id
+ * @param formItems 当前的全部表单项数据
+ */
+export declare function generateCopyItemData(formItemId: ProFormItemKey, formItems?: ProFormItemProps[]): UpdateItemsResult;

package/lib/ele-pro-form-builder/components/builder-tools.cjs

@@ -0,0 +1,120 @@
+"use strict";
+const vue = require("vue");
+const icons = require("../../icons");
+const ToolButton = require("./tool-button");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "builder-tools",
+  props: {
+    itemType: {}
+  },
+  emits: ["delete", "copy", "add", "addTableRow", "addTableCol", "openTableTool"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const handleDelete = (e) => {
+      emit("delete", e);
+    };
+    const handleCopy = (e) => {
+      emit("copy", e);
+    };
+    const handleAdd = (e) => {
+      emit("add", e);
+    };
+    const handleAddTableRow = (e) => {
+      emit("addTableRow", e);
+    };
+    const handleAddTableCol = (e) => {
+      emit("addTableCol", e);
+    };
+    const handleOpenTableTool = (e) => {
+      emit("openTableTool", e);
+    };
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        _ctx.itemType && ["table", "tableCell"].includes(_ctx.itemType) ? (vue.openBlock(), vue.createBlock(ToolButton, {
+          key: 0,
+          buttonProps: {
+            size: "small",
+            type: "primary",
+            icon: vue.unref(icons.InsertRowOutlined)
+          },
+          tooltip: _ctx.itemType === "tableCell" ? "插入行" : "新增行",
+          onClick: handleAddTableRow
+        }, null, 8, ["buttonProps", "tooltip"])) : vue.createCommentVNode("", true),
+        _ctx.itemType && ["table", "tableCell"].includes(_ctx.itemType) ? (vue.openBlock(), vue.createBlock(ToolButton, {
+          key: 1,
+          buttonProps: {
+            size: "small",
+            type: "primary",
+            icon: vue.unref(icons.InsertColumnOutlined)
+          },
+          tooltip: _ctx.itemType === "tableCell" ? "插入列" : "新增列",
+          onClick: handleAddTableCol
+        }, null, 8, ["buttonProps", "tooltip"])) : vue.createCommentVNode("", true),
+        _ctx.itemType && [
+          "tabs",
+          "tabPane",
+          "collapse",
+          "collapseItem",
+          "row",
+          "col",
+          "carousel",
+          "carouselItem",
+          "descriptions",
+          "descriptionsItem"
+        ].includes(_ctx.itemType) ? (vue.openBlock(), vue.createBlock(ToolButton, {
+          key: 2,
+          buttonProps: {
+            size: "small",
+            type: "primary",
+            icon: vue.unref(icons.PlusSquareDashOutlined)
+          },
+          tooltip: {
+            tabs: "添加选项卡",
+            tabPane: "插入选项卡",
+            collapse: "添加折叠面板",
+            collapseItem: "插入折叠面板",
+            row: "添加栅格列",
+            col: "插入栅格列",
+            carousel: "添加走马灯",
+            carouselItem: "插入走马灯",
+            descriptions: "添加描述列表",
+            descriptionsItem: "插入描述列表"
+          }[_ctx.itemType] || "添加",
+          onClick: handleAdd
+        }, null, 8, ["buttonProps", "tooltip"])) : vue.createCommentVNode("", true),
+        _ctx.itemType !== "tableCell" ? (vue.openBlock(), vue.createBlock(ToolButton, {
+          key: 3,
+          buttonProps: {
+            size: "small",
+            type: "primary",
+            icon: vue.unref(icons.CopyOutlined)
+          },
+          tooltip: "复制",
+          onClick: handleCopy
+        }, null, 8, ["buttonProps"])) : vue.createCommentVNode("", true),
+        _ctx.itemType !== "tableCell" ? (vue.openBlock(), vue.createBlock(ToolButton, {
+          key: 4,
+          buttonProps: {
+            size: "small",
+            type: "danger",
+            icon: vue.unref(icons.DeleteOutlined)
+          },
+          tooltip: "删除",
+          onClick: handleDelete
+        }, null, 8, ["buttonProps"])) : vue.createCommentVNode("", true),
+        _ctx.itemType === "tableCell" ? (vue.openBlock(), vue.createBlock(ToolButton, {
+          key: 5,
+          buttonProps: {
+            size: "small",
+            type: "primary",
+            icon: vue.unref(icons.AppstoreAddOutlined),
+            style: { fontSize: "14px" }
+          },
+          tooltip: "更多",
+          onClick: handleOpenTableTool
+        }, null, 8, ["buttonProps"])) : vue.createCommentVNode("", true)
+      ], 64);
+    };
+  }
+});
+module.exports = _sfc_main;

package/lib/ele-pro-form-builder/components/builder-tools.d.ts

@@ -0,0 +1,31 @@
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    /** 对应的表单项类型 */
+    itemType?: string;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    delete: (event: MouseEvent) => void;
+    copy: (event: MouseEvent) => void;
+    add: (event: MouseEvent) => void;
+    addTableRow: (event: MouseEvent) => void;
+    addTableCol: (event: MouseEvent) => void;
+    openTableTool: (event: MouseEvent) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    /** 对应的表单项类型 */
+    itemType?: string;
+}>>> & {
+    onCopy?: ((event: MouseEvent) => any) | undefined;
+    onDelete?: ((event: MouseEvent) => any) | undefined;
+    onAdd?: ((event: MouseEvent) => any) | undefined;
+    onAddTableRow?: ((event: MouseEvent) => any) | undefined;
+    onAddTableCol?: ((event: MouseEvent) => any) | undefined;
+    onOpenTableTool?: ((event: MouseEvent) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};