@_tc/template-core 0.0.1 → 0.0.2

package/fe/frontend/src/defaultPages/SchemaPage/data/eventInfo.d.ts

@@ -0,0 +1,8 @@
+export declare const eventsInfo: {
+    readonly none: 0;
+    readonly closeCom: 1;
+    readonly initTable: 2;
+    readonly resetSearch: 2;
+};
+export type EventInfoKey = keyof typeof eventsInfo;
+//# sourceMappingURL=eventInfo.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/data/eventInfo.js

@@ -0,0 +1,6 @@
+export const eventsInfo = {
+    none: /**      */ 0b00000000000000,
+    closeCom: /**     */ 0b00000000000001,
+    initTable: /** */ 0b00000000000010,
+    resetSearch: /** */ 0b00000000000010,
+};

package/fe/frontend/src/defaultPages/SchemaPage/data/index.d.ts

@@ -0,0 +1,3 @@
+export declare const suffixKey = "Option";
+export type SuffixKey = typeof suffixKey;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/data/index.js

@@ -0,0 +1 @@
+export const suffixKey = "Option";

package/fe/frontend/src/defaultPages/SchemaPage/hooks/useComConfig.d.ts

@@ -0,0 +1,10 @@
+import type { CallComNames, NamedComponentConfig, NamedSchemaType } from '../schemaType';
+declare const useComConfig: <CN extends CallComNames>({ comName }: {
+    comName: CallComNames;
+}) => {
+    config: NamedComponentConfig<CN>;
+    schema: NamedSchemaType<`${CN}Option`>;
+    api: string | undefined;
+};
+export default useComConfig;
+//# sourceMappingURL=useComConfig.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/hooks/useComConfig.js

@@ -0,0 +1,14 @@
+import { useSchemaStore } from '../../../stores/schemaStore';
+import { useShallow } from 'zustand/react/shallow';
+const useComConfig = ({ comName }) => {
+    const params = useSchemaStore(useShallow((s) => ({ comConfig: s.components, api: s.api })));
+    const comConfig = params.comConfig?.[comName];
+    const config = comConfig?.config;
+    const schema = comConfig?.schema;
+    return {
+        config,
+        schema,
+        api: params.api,
+    };
+};
+export default useComConfig;

package/fe/frontend/src/defaultPages/SchemaPage/index.css

@@ -0,0 +1,167 @@
+.schema-container {
+    --schema-radius: 8px;
+    --schema-soft-border: hsl(var(--border) / 0.68);
+}
+
+.schema-workspace {
+    background:
+        linear-gradient(180deg, hsl(var(--background) / 0.62), hsl(var(--background) / 0.3)),
+        hsl(var(--theme-bg));
+}
+
+.schema-search-region {
+    padding-bottom: 12px;
+}
+
+.schema-search .tc-ui-search {
+    align-items: flex-end;
+    gap: 10px 16px;
+    border: 1px solid var(--schema-soft-border);
+    border-radius: var(--schema-radius);
+    background: hsl(var(--background) / 0.72);
+    padding: 12px;
+}
+
+.schema-search .tc-ui-schema-form {
+    gap: 10px 12px;
+}
+
+.schema-search .tc-ui-form-item {
+    min-width: 212px;
+}
+
+.schema-search .tc-ui-date-picker {
+    min-width: 246px;
+}
+
+.schema-search .tc-ui-label {
+    gap: 5px;
+}
+
+.schema-search .tc-ui-label label {
+    color: hsl(var(--muted-foreground));
+    font-size: 12px;
+    font-weight: 600;
+    line-height: 16px;
+}
+
+.schema-search .tc-ui-input input,
+.schema-search .tc-ui-select > div:first-child,
+.schema-search .tc-ui-date-picker > div > div:first-child {
+    min-height: 34px;
+    border-color: hsl(var(--border) / 0.8);
+    border-radius: 7px;
+    background-color: hsl(var(--theme-bg) / 0.54);
+    padding: 7px 10px;
+}
+
+.schema-search .tc-ui-date-picker .tc-ui-input input {
+    min-height: 0;
+    padding: 0;
+}
+
+.schema-search .tc-ui-input input:hover,
+.schema-search .tc-ui-select > div:first-child:hover,
+.schema-search .tc-ui-date-picker > div > div:first-child:hover {
+    border-color: hsl(var(--foreground) / 0.28);
+    background-color: hsl(var(--background) / 0.9);
+}
+
+.schema-search .tc-ui-input input:focus,
+.schema-search .tc-ui-select > div:first-child:focus,
+.schema-search .tc-ui-date-picker > div > div:first-child:focus-within {
+    border-color: hsl(var(--theme-primary) / 0.74);
+    box-shadow: 0 0 0 3px hsl(var(--theme-primary) / 0.1);
+}
+
+.schema-search .tc-ui-button {
+    height: 34px;
+    border-radius: 7px;
+    padding-inline: 14px;
+}
+
+.schema-search .tc-ui-button:first-of-type {
+    box-shadow: 0 1px 0 hsl(var(--background) / 0.2) inset;
+}
+
+.schema-table-region {
+    min-height: 0;
+    scrollbar-gutter: stable;
+}
+
+.schema-table {
+    display: flex;
+    min-height: 100%;
+    flex-direction: column;
+}
+
+.schema-table-actions {
+    min-height: 0;
+    justify-content: flex-end;
+    gap: 8px;
+    padding-bottom: 10px;
+}
+
+.schema-table-actions:empty {
+    display: none;
+}
+
+.schema-table-actions .tc-ui-button {
+    height: 34px;
+    border-radius: 7px;
+}
+
+.schema-table .tc-ui-data-table {
+    flex: 1;
+    overflow: hidden;
+    border: 1px solid var(--schema-soft-border);
+    border-radius: var(--schema-radius);
+    background-color: hsl(var(--background) / 0.58);
+    box-shadow: none;
+}
+
+.schema-table .tc-ui-table {
+    border-radius: var(--schema-radius) var(--schema-radius) 0 0;
+}
+
+.schema-table .tc-ui-table-header {
+    background: hsl(var(--muted) / 0.5);
+}
+
+.schema-table .tc-ui-table-head {
+    height: 40px;
+    padding: 0 16px;
+    font-size: 12px;
+    font-weight: 600;
+    color: hsl(var(--muted-foreground));
+}
+
+.schema-table .tc-ui-table-cell {
+    padding: 13px 16px;
+}
+
+.schema-table .tc-ui-table-row {
+    border-color: hsl(var(--border) / 0.58);
+}
+
+.schema-table .tc-ui-table-row:hover {
+    background-color: hsl(var(--muted) / 0.28);
+}
+
+.schema-table .tc-ui-table-head[style*='right'],
+.schema-table .tc-ui-table-cell[style*='right'] {
+    box-shadow: -1px 0 0 hsl(var(--border) / 0.58);
+}
+
+.schema-table .tc-ui-data-table > .px-6 {
+    margin-top: 0;
+    border-top: 1px solid hsl(var(--border) / 0.58);
+    padding: 12px 16px;
+}
+
+.schema-table .tc-ui-data-table > .px-6 .tc-ui-select > div:first-child {
+    min-height: 34px;
+    border-radius: 7px;
+    background: hsl(var(--muted) / 0.58);
+    padding-block: 7px;
+}

package/fe/frontend/src/defaultPages/SchemaPage/index.d.ts

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

package/fe/frontend/src/defaultPages/SchemaPage/index.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { logIllegalComponentCallback } from '../../common/logFn';
+import useCurrentMenuData from '../../hooks/useCurrentMenuData';
+import { schemaEventBus } from '../../stores/schemaEventBus';
+import { useSchemaStore } from '../../stores/schemaStore';
+import useExecuteOnce, { executionPhaseType } from '../../../../packages/ui/react/hooks/useExecuteOnce';
+import useInit from '../../../../packages/ui/react/hooks/useInit';
+import { memo, Suspense, useCallback, useMemo, useRef, useState } from 'react';
+import { components } from './components/CallCom/data';
+import SchemaSearch from './components/SchemaSearch';
+import SchemaTable from './components/SchemaTable';
+import { eventsInfo } from './data/eventInfo';
+import './index.css';
+import { isAllowed } from './utils/permissions';
+import { schemaConversion } from './utils/schemaConversion';
+const Schema = memo(() => {
+    const { menu } = useCurrentMenuData();
+    const [showCompoentKey, setShowCompoentKey] = useState();
+    const [comProps, setComProps] = useState({});
+    const schemaStoreAvailable = useSchemaStore((s) => s.schemaStoreAvailable);
+    const TableRef = useRef(null);
+    const onSearch = useCallback((v) => {
+        TableRef.current?.initData(v);
+    }, []);
+    const callCom = useCallback((v) => {
+        const { comName, ...params } = v;
+        setComProps({ data: params, comName });
+        setShowCompoentKey(comName);
+    }, []);
+    const comDone = useCallback(({ type }) => {
+        /**
+         * 解析出需要执行的操作
+         */
+        if (isAllowed(type, eventsInfo.closeCom)) {
+            setShowCompoentKey(undefined);
+            setComProps(undefined);
+        }
+        if (isAllowed(type, eventsInfo.initTable)) {
+            TableRef.current?.initData();
+        }
+        if (isAllowed(type, eventsInfo.resetSearch)) {
+        }
+    }, []);
+    useInit(() => {
+        // schema数据分离
+        schemaConversion(menu.schemaConfig, menu.key);
+    });
+    useExecuteOnce(() => {
+        // 关联search
+        schemaEventBus.getState().subscribeSearch(onSearch);
+        // 订阅组件消息
+        schemaEventBus.getState().subscribeCom(comDone);
+        // 关联table
+        schemaEventBus.getState().subscribeTable(callCom);
+    }, { executionPhase: executionPhaseType.mount });
+    useExecuteOnce(() => {
+        schemaEventBus.getState().unSubscribeSearch(onSearch);
+        schemaEventBus.getState().unSubscribeTable(callCom);
+        schemaEventBus.getState().unSubscribeCom(comDone);
+    }, { executionPhase: executionPhaseType.unMount });
+    const dom = useMemo(() => {
+        if (schemaStoreAvailable) {
+            const CallCom = components[showCompoentKey];
+            if (!CallCom && showCompoentKey) {
+                logIllegalComponentCallback(showCompoentKey);
+            }
+            return (_jsxs("div", { className: "schema-container flex h-full min-h-0 w-full flex-col overflow-hidden bg-theme-bg px-4 py-3", children: [_jsxs("div", { className: "schema-workspace flex min-h-0 flex-1 flex-col overflow-hidden", children: [_jsx("div", { className: "schema-search-region shrink-0", children: _jsx(SchemaSearch, {}) }), _jsx("div", { className: "schema-table-region min-h-0 flex-1 overflow-auto p-3", children: _jsx(SchemaTable, { ref: TableRef }) })] }), _jsx(Suspense, { children: CallCom && _jsx(CallCom, { ...comProps }) })] }));
+        }
+        else
+            return _jsx("div", { className: "flex h-full items-center justify-center text-sm text-muted-foreground", children: "loading" });
+    }, [comProps, schemaStoreAvailable, showCompoentKey]);
+    return dom;
+});
+Schema.displayName = 'SchemaPage';
+export default Schema;

package/fe/frontend/src/defaultPages/SchemaPage/schemaType.d.ts

@@ -0,0 +1,51 @@
+import type { ComponentConfig } from '../../../../model/types/data/component';
+import type { BaseOption, ConfigSchema, SchemaDataType, SearchConfig, TableConfig, UsedConfigSchema } from '../../../../model/types/data/schema';
+import type { LazyExoticComponent, ComponentType as ReactComponentType } from 'react';
+import type { SuffixKey } from './data';
+export type { ComponentConfig, SearchConfig, TableConfig };
+export type FieldType = ConfigSchema['properties'][''];
+export type SchemaType = Required<SchemaDataType>['schema'];
+export type AllFieldKeys = keyof FieldType;
+export type AllOptionsPreNames = {
+    [K in AllFieldKeys]: K extends `${infer Name}${SuffixKey}` ? Name : never;
+}[AllFieldKeys];
+export type NonOptionKey = {
+    [K in AllFieldKeys]: K extends `${string}${SuffixKey}` ? never : K;
+}[AllFieldKeys];
+export type StoreSchemaType = UsedConfigSchema<BaseOption<FieldType[`${AllOptionsPreNames}${SuffixKey}`]>>;
+export type NamedSchemaType<N extends `${AllOptionsPreNames}${SuffixKey}`> = UsedConfigSchema<BaseOption<FieldType[N]>>;
+/**
+ * 获取具体名称的 components options 配置
+ */
+export type NamedComOption<N extends CallComNames> = ComponentType<ComponentConfig>[N];
+/**
+ * 获取具名 组件配置
+ */
+export type NamedComponentConfig<N extends CallComNames> = ComponentConfig[N];
+type ComponentC<C extends ComponentConfig> = {
+    [K in keyof C]: {
+        schema: StoreSchemaType;
+        config: C[K];
+    };
+}[keyof C];
+export type ComponentType<C extends ComponentConfig> = {
+    [K in keyof C]: ComponentC<C>;
+};
+export type CallComNames = keyof ComponentConfig;
+export type CallComRenderer = ReactComponentType<any> | LazyExoticComponent<ReactComponentType<any>>;
+export type SchemaDefaultValue = Record<string, any>;
+export type SchemaTableEmitData = SchemaDefaultValue & {
+    comName: CallComNames;
+};
+export declare const enum ComEventType {
+    close = 0
+}
+export type SchemaComEventInfo = {
+    /**
+     * 操作权限合集
+     */
+    type: number;
+};
+export type CallComponent<T> = Partial<Record<CallComNames, T>>;
+export type CallComComponentsMap = CallComponent<CallComRenderer>;
+//# sourceMappingURL=schemaType.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/schemaType.js

@@ -0,0 +1,4 @@
+export var ComEventType;
+(function (ComEventType) {
+    ComEventType[ComEventType["close"] = 0] = "close";
+})(ComEventType || (ComEventType = {}));

package/fe/frontend/src/defaultPages/SchemaPage/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/src/defaultPages/SchemaPage/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/src/defaultPages/SchemaPage/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/src/defaultPages/SchemaPage/utils/schemaConversion.js

@@ -0,0 +1,115 @@
+import { suffixKey } from '../data';
+import { schemaStore } from '../../../stores/schemaStore';
+/**
+ *
+ * 构建出需要optios + 其他字段
+ */
+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) => {
+            // 为xxxoption
+            if (fieldKey.indexOf(suffixKey) !== -1) {
+                // 需要的option
+                if (fieldKey === `${fieldType}${suffixKey}`) {
+                    o['option'] = fieldInfo[fieldKey];
+                }
+            }
+            // 其余属性
+            else {
+                ;
+                o[fieldKey] = fieldInfo[fieldKey];
+            }
+            return o;
+        }, {});
+    }
+    return temSchema;
+};
+// properties 构建
+// const buildSchema = (data: FieldType, fieldType: AllOptionsPreNames) => {
+//   console.log(data);
+//   const keys = Object.keys(data) as (keyof FieldType)[];
+//   type TargetOptionKey = `${typeof fieldType}${typeof suffixKey}`;
+//   type NewState = Partial<{
+//     [K in NonOptionKey]: FieldType[K];
+//   }> & {
+//     option?: FieldType[TargetOptionKey];
+//   };
+//   const newData = produce<NewState>(data, (temData) => {
+//     const newState: NewState = {
+//       option: undefined,
+//     } as unknown as NewState;
+//     keys.forEach((k) => {
+//       // 是 Option
+//       if (k.indexOf(suffixKey) !== -1) {
+//         // 需要的options
+//         if (k === (`${fieldType}${suffixKey}` as const)) {
+//           newState["option"] = (temData as FieldType)[k];
+//         }
+//       } else {
+//         (newState as any)[k] = (temData as FieldType)[
+//           k
+//         ] as NewState[keyof NewState];
+//       }
+//     });
+//     return newState;
+//   });
+//   return newData;
+// };
+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;
+    //   整个schema 进行移动
+    const tableSchema = buildSchema(JSON.parse(JSON.stringify(schemaMetadata)), 'table');
+    const searchSchema = buildSchema(JSON.parse(JSON.stringify(schemaMetadata)), 'search');
+    let components = {};
+    //  page components
+    if (componentConfig) {
+        const componentKeys = Object.keys(componentConfig ?? {});
+        components = componentKeys.reduce((o, comKey) => {
+            // 获取组件的 schema
+            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/src/defaultPages/SchemaPage/utils/validator.d.ts

@@ -0,0 +1,7 @@
+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/src/defaultPages/SchemaPage/utils/validator.js

@@ -0,0 +1,36 @@
+import { Ajv } from 'ajv';
+// 初始化 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/src/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/src/defaultPages/SidebarSlotPage/SidebarSlotContainer.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { logPageNotFound } from '../../common/logFn';
+import { findMenuItem, QK } from '../../common/menu';
+import useRouterParams from '../../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();
+    //  menu 初始化选中
+    useEffect(() => {
+        /**
+         * 如果没有 sidebar key 说明当前是 自定义路由
+         * 则需要获取 query 中的 ck 来查找 menuinfo
+         */
+        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 h-full w-full gap-0 overflow-hidden bg-theme-bg", children: [_jsx("div", { className: "sidebar-slot-container flex h-full shrink-0 border-r border-border/70 bg-background/70 px-2 py-2", children: _jsx(Menu, { className: "sidebar-shell-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: "min-w-0 flex-1 overflow-hidden", children: _jsx(Outlet, {}) })] }));
+};
+export default SidebarSlotContainer;

package/fe/frontend/src/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/src/defaultPages/SidebarSlotPage/index.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { generateMenuItemData } from '../../common/generateMenuData';
+import { QK } from '../../common/menu';
+import useCurrentMenuData from '../../hooks/useCurrentMenuData';
+import { useMemo } from 'react';
+import { useParams } from 'react-router-dom';
+import SidebarSlotContainer from './SidebarSlotContainer';
+const SidebarSlotPage = () => {
+    const params = useParams();
+    // top left 从当前路由中获取到 sidebarConfig中的数据
+    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/src/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/src/defaultPages/SidebarSlotPageTmp.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { generateMenuItemData } from '../common/generateMenuData';
+import { leftSidebarBasePath } from '../common/menu';
+import SidebarSlotContainer from '../defaultPages/SidebarSlotPage/SidebarSlotContainer';
+import { useModeStore } from '../stores/mode';
+import { useMemo } from 'react';
+const SidebarSlotPageTmp = () => {
+    const projInfo = useModeStore((s) => s.projectInfo);
+    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/src/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/src/defaultPages/SlotPage/index.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from 'react';
+import { logPageNotFound } from '../../common/logFn';
+import useCurrentMenuData from '../../hooks/useCurrentMenuData';
+import Iframe from '../Iframe';
+import Schema from '../SchemaPage';
+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;