@_tc/template-core 0.0.1-bate.36 → 0.0.1-bate.37

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaEventBus.d.ts

@@ -0,0 +1,23 @@
+import { SchemaComEventInfo, SchemaDefaultValue, SchemaTableEmitData } from '../schemaType';
+type WatchFn<V = SchemaDefaultValue | undefined> = (value: V) => void;
+declare const enum SubscribeEnum {
+    search = "search",
+    table = "table",
+    com = "com"
+}
+interface SchemaEventBusStore {
+    readonly Subscribers: Map<WatchFn, SubscribeEnum>;
+    subscribeSearch: (fn: WatchFn) => void;
+    unSubscribeSearch: (fn: WatchFn) => void;
+    emitSearch: (v: SchemaDefaultValue | undefined) => void;
+    subscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    unSubscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    emitTable: (v: SchemaTableEmitData) => void;
+    emitCall: (v: SchemaDefaultValue | undefined, type: SubscribeEnum) => void;
+    subscribeCom: (fn: WatchFn<SchemaComEventInfo>) => void;
+    unSubscribeCom: (fn: WatchFn<SchemaComEventInfo>) => void;
+    emitCom: (v: SchemaComEventInfo) => void;
+}
+export declare const schemaEventBus: import("zustand").StoreApi<SchemaEventBusStore>;
+export {};
+//# sourceMappingURL=schemaEventBus.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaEventBus.js

@@ -0,0 +1,66 @@
+import { logSubscriptionError } from '../../../../widgets/common/logFn';
+import { createStore } from 'zustand';
+var SubscribeEnum;
+(function (SubscribeEnum) {
+    SubscribeEnum["search"] = "search";
+    SubscribeEnum["table"] = "table";
+    SubscribeEnum["com"] = "com";
+})(SubscribeEnum || (SubscribeEnum = {}));
+export const schemaEventBus = createStore((set, get) => {
+    return {
+        Subscribers: new Map(),
+        subscribeCom(fn) {
+            get().Subscribers.set(fn, SubscribeEnum.com);
+        },
+        unSubscribeCom(fn) {
+            const { Subscribers } = get();
+            if (Subscribers.has(fn)) {
+                Subscribers.delete(fn);
+            }
+            else {
+                logSubscriptionError();
+            }
+        },
+        emitCom(v) {
+            get().emitCall(v, SubscribeEnum.com);
+        },
+        subscribeTable(fn) {
+            get().Subscribers.set(fn, SubscribeEnum.table);
+        },
+        unSubscribeTable(fn) {
+            const { Subscribers } = get();
+            if (Subscribers.has(fn)) {
+                Subscribers.delete(fn);
+            }
+            else {
+                logSubscriptionError();
+            }
+        },
+        emitTable(v) {
+            get().emitCall(v, SubscribeEnum.table);
+        },
+        emitCall(v, calType) {
+            const { Subscribers } = get();
+            for (const [fn, type] of Subscribers.entries()) {
+                if (calType === type) {
+                    fn(v);
+                }
+            }
+        },
+        subscribeSearch(fn) {
+            get().Subscribers.set(fn, SubscribeEnum.search);
+        },
+        unSubscribeSearch(fn) {
+            const { Subscribers } = get();
+            if (Subscribers.has(fn)) {
+                Subscribers.delete(fn);
+            }
+            else {
+                logSubscriptionError();
+            }
+        },
+        emitSearch(v) {
+            get().emitCall(v, SubscribeEnum.search);
+        },
+    };
+});

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaStore.d.ts

@@ -0,0 +1,33 @@
+import { LRUCache } from '../../../../../packages/common/index.js';
+import { TableSearchSchema } from '../../../../../packages/ui/react/components/TableSearch/TableSearch';
+import type { MOmit } from '../../../../../typings/type';
+import type { ComponentConfig, ComponentType, SearchConfig, StoreSchemaType, TableConfig } from '../schemaType';
+interface FunctionalData {
+    api: string;
+    components: ComponentType<ComponentConfig>;
+    tableSchema: StoreSchemaType;
+    tableConfig: TableConfig;
+    searchSchema: StoreSchemaType;
+    searchConfig: SearchConfig;
+}
+interface ComSchemaCache {
+    searchSchema: TableSearchSchema<Record<string, any>>[];
+}
+interface SchemaStoreState extends Partial<FunctionalData> {
+    readonly schemaStoreAvailable: boolean;
+    readonly schemaCache: LRUCache<FunctionalData>;
+    readonly comSchemaCache: LRUCache<ComSchemaCache>;
+}
+interface SchemaStoreActions {
+    setSchemaState: (data: Partial<MOmit<SchemaStoreState, 'schemaStoreAvailable' | 'schemaCache'>>) => void;
+    updateSchemaCache: (data: FunctionalData & {
+        schemaKey: string;
+    }) => void;
+    updateComSchemaCache: (data: ComSchemaCache & {
+        schemaKey: string;
+    }) => void;
+}
+export declare const schemaStore: import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>;
+export declare const useSchemaStore: import("../../../../../packages/ui/react/index").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
+export {};
+//# sourceMappingURL=schemaStore.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaStore.js

@@ -0,0 +1,24 @@
+import { LRUCache } from '../../../../../packages/common/index.js';
+import { createStoreHook } from '../../../../../packages/ui/react/index';
+import { createStore } from 'zustand';
+export const schemaStore = createStore((set, get) => ({
+    api: '',
+    schemaStoreAvailable: false,
+    schemaCache: new LRUCache(5),
+    comSchemaCache: new LRUCache(5),
+    setSchemaState: (state) => {
+        set({ ...state });
+        set({ schemaStoreAvailable: !!get().api });
+    },
+    updateSchemaCache: (data) => {
+        const { schemaKey, ...params } = data;
+        const { schemaCache } = get();
+        schemaCache.set(schemaKey, params);
+    },
+    updateComSchemaCache: (data) => {
+        const { schemaKey, ...params } = data;
+        const { comSchemaCache } = get();
+        comSchemaCache.set(schemaKey, params);
+    },
+}));
+export const useSchemaStore = createStoreHook(schemaStore);

package/fe/frontend/widgets/defaultPages/Schema/utils/fetchErrorShow.d.ts

@@ -0,0 +1,3 @@
+import type { BaseResponse, ResponseConfig } from '../../../../widgets/common/request';
+export declare const handlingRequestErrors: <D>(data: Promise<ResponseConfig<BaseResponse<D>, any>>) => Promise<ResponseConfig<BaseResponse<D>, any>>;
+//# sourceMappingURL=fetchErrorShow.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/utils/fetchErrorShow.js

@@ -0,0 +1,8 @@
+import { message } from '../../../../../packages/ui/react/components';
+export const handlingRequestErrors = async (data) => {
+    const res = await data;
+    if (res.data.code !== 0) {
+        message.error(res.data.message);
+    }
+    return res;
+};

package/fe/frontend/widgets/defaultPages/Schema/utils/permissions.d.ts

@@ -0,0 +1,3 @@
+export declare const merge: (...params: number[]) => number;
+export declare const isAllowed: (key1: number, key2: number) => boolean;
+//# sourceMappingURL=permissions.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/utils/permissions.js

@@ -0,0 +1,3 @@
+import { eventsInfo } from '../data/eventInfo';
+export const merge = (...params) => params.reduce((o, n) => o | n, eventsInfo.none);
+export const isAllowed = (key1, key2) => (key1 & key2) !== eventsInfo.none;

package/fe/frontend/widgets/defaultPages/Schema/utils/schemaConversion.d.ts

@@ -0,0 +1,3 @@
+import { SchemaDataType } from '../../../../../model/types/data/schema';
+export declare const schemaConversion: (schema: SchemaDataType, schemaKey: string) => void;
+//# sourceMappingURL=schemaConversion.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/utils/schemaConversion.js

@@ -0,0 +1,72 @@
+import { suffixKey } from '../data';
+import { schemaStore } from '../stores/schemaStore';
+const buildSchema = (schema, fieldType) => {
+    if (!schema.properties)
+        return;
+    const temSchema = {
+        type: 'object',
+        properties: {},
+        required: schema.required,
+    };
+    for (const key in schema.properties) {
+        const fieldInfo = schema.properties[key];
+        const fieldKeys = Object.keys(fieldInfo);
+        temSchema.properties[key] = fieldKeys.reduce((o, fieldKey) => {
+            if (fieldKey.indexOf(suffixKey) !== -1) {
+                if (fieldKey === `${fieldType}${suffixKey}`) {
+                    o['option'] = fieldInfo[fieldKey];
+                }
+            }
+            else {
+                ;
+                o[fieldKey] = fieldInfo[fieldKey];
+            }
+            return o;
+        }, {});
+    }
+    return temSchema;
+};
+export const schemaConversion = (schema, schemaKey) => {
+    const { schemaCache, setSchemaState } = schemaStore.getState();
+    if (schemaCache.has(schemaKey)) {
+        setSchemaState({
+            ...schemaCache.get(schemaKey),
+        });
+        return;
+    }
+    const { api, schema: schemaMetadata = {}, componentConfig, tableConfig, searchConfig } = schema;
+    const tableSchema = buildSchema(JSON.parse(JSON.stringify(schemaMetadata)), 'table');
+    const searchSchema = buildSchema(JSON.parse(JSON.stringify(schemaMetadata)), 'search');
+    let components = {};
+    if (componentConfig) {
+        const componentKeys = Object.keys(componentConfig ?? {});
+        components = componentKeys.reduce((o, comKey) => {
+            const comSchema = buildSchema(JSON.parse(JSON.stringify(schemaMetadata)), comKey);
+            o[comKey] = {
+                schema: comSchema,
+                config: componentConfig[comKey],
+            };
+            return o;
+        }, {});
+    }
+    {
+        const { setSchemaState, updateSchemaCache } = schemaStore.getState();
+        setSchemaState({
+            api,
+            components,
+            tableSchema,
+            tableConfig,
+            searchSchema,
+            searchConfig,
+        });
+        updateSchemaCache({
+            api,
+            schemaKey,
+            components,
+            tableSchema: tableSchema,
+            tableConfig: tableConfig,
+            searchSchema: searchSchema,
+            searchConfig: searchConfig,
+        });
+    }
+};

package/fe/frontend/widgets/defaultPages/Schema/utils/validator.d.ts

@@ -0,0 +1,4 @@
+import { Ajv } from 'ajv';
+export declare const ajvInstance: Ajv;
+export declare function createAjvValidator(schema: object): (rule: object, value: unknown, callback: (errors?: string[]) => void) => void;
+//# sourceMappingURL=validator.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/utils/validator.js

@@ -0,0 +1,31 @@
+import { Ajv } from 'ajv';
+export const ajvInstance = new Ajv({ allErrors: true, verbose: true, strict: false });
+export function createAjvValidator(schema) {
+    const validate = ajvInstance.compile(schema);
+    return (rule, value, callback) => {
+        const valid = validate(value);
+        if (valid) {
+            callback();
+        }
+        else {
+            const messages = (validate.errors || []).map(formatError);
+            callback(messages);
+        }
+    };
+}
+function formatError(error) {
+    const path = error.instancePath.replace(/^\//, '') || 'value';
+    switch (error.keyword) {
+        case 'required':
+            return `缺少必填字段: ${error.params.missingProperty}`;
+        case 'type':
+            return `${path} 类型错误，期望 ${error.params.type}`;
+        case 'format':
+            return `${path} 格式不正确`;
+        case 'minimum':
+        case 'maximum':
+            return `${path} 超出允许范围`;
+        default:
+            return `${path} ${error.message}`;
+    }
+}

package/fe/frontend/widgets/defaultPages/SidebarSlotPage/SidebarSlotContainer.d.ts

@@ -0,0 +1,10 @@
+import { BaseMenuType } from '../../../../model/types/menuType';
+import { MenuItemData } from '../../../../packages/ui/react/components';
+interface SidebarSlotContainerProps {
+    prefixPath: string;
+    rawMenuData: BaseMenuType[];
+    menuItems: MenuItemData[];
+}
+declare const SidebarSlotContainer: (props: SidebarSlotContainerProps) => import("react/jsx-runtime").JSX.Element;
+export default SidebarSlotContainer;
+//# sourceMappingURL=SidebarSlotContainer.d.ts.map

package/fe/frontend/widgets/defaultPages/SidebarSlotPage/SidebarSlotContainer.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { logPageNotFound } from '../../../widgets/common/logFn';
+import { findMenuItem, QK } from '../../../widgets/common/menu';
+import useRouterParams from '../../../widgets/hooks/useRouterParams';
+import { Menu } from '../../../../packages/ui/react/components';
+import { useEffect, useState } from 'react';
+import { Outlet, useNavigate } from 'react-router-dom';
+const SidebarSlotContainer = (props) => {
+    const { prefixPath, rawMenuData, menuItems } = props;
+    const params = useRouterParams();
+    const [SK, uSK] = useState(params[QK.sk]);
+    const nav = useNavigate();
+    useEffect(() => {
+        if (!params[QK.sk]) {
+            if (params[QK.ck]) {
+                const m = findMenuItem(rawMenuData, params[QK.ck]);
+                if (m) {
+                    uSK(m.key);
+                    return;
+                }
+            }
+            logPageNotFound();
+        }
+    }, [rawMenuData, params]);
+    return (_jsxs("div", { className: "sidebar-slot flex gap-1.5 w-full h-full px-1", children: [_jsx("div", { className: "sidebar-slot-container max-w-full", children: _jsx(Menu, { items: menuItems, selectedKey: SK, onSelect: (e) => {
+                        const m = findMenuItem(rawMenuData, e);
+                        uSK(e);
+                        nav({ ...m.path, pathname: prefixPath + m.path.pathname });
+                    } }) }), _jsx("div", { className: " flex-1", children: _jsx(Outlet, {}) })] }));
+};
+export default SidebarSlotContainer;

package/fe/frontend/widgets/defaultPages/SidebarSlotPage/index.d.ts

@@ -0,0 +1,3 @@
+declare const SidebarSlotPage: () => import("react/jsx-runtime").JSX.Element;
+export default SidebarSlotPage;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/defaultPages/SidebarSlotPage/index.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { generateMenuItemData } from "../../../widgets/common/generateMenuData";
+import { QK } from "../../../widgets/common/menu";
+import useCurrentMenuData from "../../../widgets/hooks/useCurrentMenuData";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+import SidebarSlotContainer from "./SidebarSlotContainer";
+const SidebarSlotPage = () => {
+    const params = useParams();
+    const { menu: parentMenuInfo } = useCurrentMenuData();
+    const prefixPath = useMemo(() => `/${params[QK.k]}`, [params[QK.k]]);
+    const menuItem = generateMenuItemData(parentMenuInfo?.sidebarConfig?.menu ?? []);
+    return (_jsx(SidebarSlotContainer, { menuItems: menuItem, rawMenuData: parentMenuInfo?.sidebarConfig.menu, prefixPath: prefixPath }));
+};
+export default SidebarSlotPage;

package/fe/frontend/widgets/defaultPages/SidebarSlotPageTmp.d.ts

@@ -0,0 +1,3 @@
+declare const SidebarSlotPageTmp: () => import("react/jsx-runtime").JSX.Element;
+export default SidebarSlotPageTmp;
+//# sourceMappingURL=SidebarSlotPageTmp.d.ts.map

package/fe/frontend/widgets/defaultPages/SidebarSlotPageTmp.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import SidebarSlotContainer from "../../widgets/defaultPages/SidebarSlotPage/SidebarSlotContainer";
+import { leftSidebarBasePath } from "../../widgets/common/menu";
+import { useModeStore } from "../../widgets/store/mode";
+import { generateMenuItemData } from "../../widgets/common/generateMenuData";
+const SidebarSlotPageTmp = () => {
+    const projInfo = useModeStore((s) => s.projestInfo);
+    const [menuItems, rawMenuData] = useMemo(() => {
+        if (projInfo) {
+            return [generateMenuItemData(projInfo.menu), projInfo.menu];
+        }
+        return [[], []];
+    }, []);
+    return (_jsx(SidebarSlotContainer, { prefixPath: "/" + leftSidebarBasePath, rawMenuData: rawMenuData, menuItems: menuItems }));
+};
+export default SidebarSlotPageTmp;

package/fe/frontend/widgets/defaultPages/SlotPage/index.d.ts

@@ -0,0 +1,3 @@
+declare const SlotPage: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export default SlotPage;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/defaultPages/SlotPage/index.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from 'react';
+import { logPageNotFound } from '../../../widgets/common/logFn';
+import useCurrentMenuData from '../../../widgets/hooks/useCurrentMenuData';
+import Iframe from '../Iframe';
+import Schema from '../Schema';
+const SlotPage = memo(() => {
+    const { menu } = useCurrentMenuData(true);
+    const RenderDom = useMemo(() => {
+        if (menu?.moduleType === 'iframe') {
+            return _jsx(Iframe, {});
+        }
+        else if (menu?.moduleType === 'schema') {
+            return _jsx(Schema, {});
+        }
+        else {
+            logPageNotFound();
+            return _jsx("div", { children: "404" });
+        }
+    }, [menu?.moduleType]);
+    return RenderDom;
+});
+SlotPage.displayName = 'SlotPage';
+export default SlotPage;

package/fe/frontend/widgets/defaultPages/Todo.d.ts

@@ -0,0 +1,3 @@
+declare const Todo: () => import("react/jsx-runtime").JSX.Element;
+export default Todo;
+//# sourceMappingURL=Todo.d.ts.map

package/fe/frontend/widgets/defaultPages/Todo.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+const Todo = () => {
+    return _jsx("div", { children: "TODO" });
+};
+export default Todo;

package/fe/frontend/widgets/hooks/useCurrentMenuData.d.ts

@@ -0,0 +1,11 @@
+import { BasicModuleType, SidebarModuleType } from "../../../model/types/menuType";
+declare const useCurrentMenuData: <T = {
+    moduleType: BasicModuleType["moduleType"];
+    sidebarConfig: SidebarModuleType["sidebarConfig"];
+}>(useSibe?: boolean) => {
+    menu: T & {
+        moduleType: BasicModuleType["moduleType"];
+    };
+};
+export default useCurrentMenuData;
+//# sourceMappingURL=useCurrentMenuData.d.ts.map

package/fe/frontend/widgets/hooks/useCurrentMenuData.js

@@ -0,0 +1,20 @@
+import { findMenuItem, QK } from "../../widgets/common/menu";
+import { useModeStore } from "../../widgets/store/mode";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+const useCurrentMenuData = (useSibe = false) => {
+    const params = useParams();
+    const projestInfo = useModeStore((s) => s.projestInfo);
+    const menu = useMemo(() => {
+        const isSide = params[QK.sk];
+        const menuTypeIsTop = !!params[QK.k];
+        const menu = findMenuItem(projestInfo?.menu, menuTypeIsTop ? params[QK.k] : params[QK.sk]);
+        if (isSide && useSibe && menuTypeIsTop) {
+            const sMenu = findMenuItem(menu.sidebarConfig?.menu ?? [], params[QK.sk]);
+            return sMenu;
+        }
+        return menu;
+    }, [projestInfo?.menu, params]);
+    return { menu: menu };
+};
+export default useCurrentMenuData;

package/fe/frontend/widgets/hooks/useRouterParams.d.ts

@@ -0,0 +1,5 @@
+declare const useRouterParams: <T extends Record<string, string>>() => Readonly<[T] extends [string] ? import("react-router-dom").Params<T> : Partial<T>> & {
+    custk?: string | undefined;
+};
+export default useRouterParams;
+//# sourceMappingURL=useRouterParams.d.ts.map

package/fe/frontend/widgets/hooks/useRouterParams.js

@@ -0,0 +1,11 @@
+import { deserializationUrlSearch, QK } from "../../widgets/common/menu";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+const useRouterParams = () => {
+    const params = useParams();
+    return useMemo(() => {
+        const query = deserializationUrlSearch(location.search);
+        return { ...params, ...(query[QK.ck] ? { [QK.ck]: query[QK.ck] } : {}) };
+    }, [params]);
+};
+export default useRouterParams;

package/fe/frontend/widgets/store/mode.d.ts

@@ -0,0 +1,16 @@
+import { type ModelInfo, type ProjectInfo } from '../../widgets/api/baseInfo';
+interface ModeState {
+    modeList: ModelInfo[];
+    projestInfo: ProjectInfo | null;
+    initData: boolean;
+}
+interface ModeAction {
+    setModeList: (data: ModeState['modeList']) => void;
+    setProjestInfo: (data: ModeState['projestInfo']) => void;
+    initModeData: () => void;
+}
+type IStore = ModeState & ModeAction;
+export declare const modeStore: import("zustand").StoreApi<IStore>;
+export declare const useModeStore: import("../../../packages/ui/react/index").StoreHook<import("zustand").StoreApi<IStore>>;
+export {};
+//# sourceMappingURL=mode.d.ts.map

package/fe/frontend/widgets/store/mode.js

@@ -0,0 +1,36 @@
+import { getModelList, getProjeckData } from '../../widgets/api/baseInfo';
+import { deserializationUrlSearch } from '../../widgets/common/menu';
+import { createStoreHook } from '../../../packages/ui/react/lib/createStoreHook';
+import { createStore } from 'zustand';
+import { setApiAuth } from '../common/auth';
+export const modeStore = createStore((set, get) => ({
+    modeList: [],
+    projestInfo: null,
+    initData: false,
+    setModeList(modeList) {
+        set({ modeList });
+    },
+    setProjestInfo(projestInfo) {
+        set({ projestInfo });
+    },
+    async initModeData() {
+        const fetchModeData = async () => {
+            const data = await getModelList();
+            return data;
+        };
+        const featchProjeckData = async () => {
+            const urls = deserializationUrlSearch(window.location.search);
+            const key = urls['projk'];
+            setApiAuth(key);
+            const data = await getProjeckData(key);
+            return data;
+        };
+        const [modeList, projestInfo] = await Promise.all([fetchModeData(), featchProjeckData()]);
+        set({
+            modeList,
+            projestInfo,
+            initData: true,
+        });
+    },
+}));
+export const useModeStore = createStoreHook(modeStore);

package/fe/model/types/data/button.d.ts

@@ -0,0 +1,23 @@
+import type { ButtonProps } from '../../../packages/ui/react';
+import { ComponentNames } from './component';
+type ButtonTemplates = {
+    label?: string;
+} & ButtonProps;
+type ParamsValueData = 'schema::tableKey' | string | number;
+type RemoveBtn = {
+    eventKey: 'remove';
+    eventOption: {
+        params: {
+            [paramKey: string]: ParamsValueData;
+        };
+    };
+};
+type HandlerBtn = {
+    eventKey: 'callComponent';
+    eventOption: {
+        comName: ComponentNames;
+    };
+};
+export type BaseButton = ButtonTemplates & (RemoveBtn | HandlerBtn);
+export {};
+//# sourceMappingURL=button.d.ts.map

package/fe/model/types/data/button.js

@@ -0,0 +1 @@
+export {};

package/fe/model/types/data/component.d.ts

@@ -0,0 +1,37 @@
+import { FormItemProps, InputNumberProps, InputProps, SelectProps } from '../../../packages/ui/react';
+import { FetchInfo } from './fetchInfo';
+export type ComponentConfig = {
+    createForm?: {
+        title: string;
+        saveBtnText?: string;
+    } & Pick<FetchInfo, 'fetchConfig'>;
+    editForm?: {
+        title: string;
+        saveBtnText?: string;
+    } & FetchInfo;
+    detailPanel?: {
+        title: string;
+    } & FetchInfo;
+};
+export type ComponentNames = keyof ComponentConfig;
+export type ComponentsOption = {
+    createForm: FormItemProps & {
+        visible?: boolean;
+        disbaled?: boolean;
+        default?: any;
+    } & ComponentOption;
+    editForm: ComponentsOption['createForm'];
+    detailPanel: {};
+};
+export type ComponentOption = InputOption | SelectOption | InputNumberOption;
+type InputOption = {
+    comType: 'input';
+} & InputProps;
+type InputNumberOption = {
+    comType: 'inputNumber';
+} & InputNumberProps;
+type SelectOption = {
+    comType: 'select';
+} & SelectProps;
+export {};
+//# sourceMappingURL=component.d.ts.map

package/fe/model/types/data/component.js

@@ -0,0 +1 @@
+export {};

package/fe/model/types/data/fetchInfo.d.ts

@@ -0,0 +1,8 @@
+export type FetchInfo = {
+    fetchKey: string;
+    fetchConfig?: {
+        url: string;
+        method?: 'get' | 'post';
+    };
+};
+//# sourceMappingURL=fetchInfo.d.ts.map

package/fe/model/types/data/fetchInfo.js

@@ -0,0 +1 @@
+export {};