@_tc/template-core 0.0.1-bate.46 → 0.0.1-bate.47

package/fe/frontend/{widgets/defaultPages/Schema → src/defaultPages/SchemaPage}/hooks/useComConfig.d.ts

@@ -1,4 +1,4 @@
-import type { CallComNames, NamedComponentConfig, NamedSchemaType } from '../schemaType';
+import type { CallComNames, NamedComponentConfig, NamedSchemaType } from "../schemaType";
 declare const useComConfig: <CN extends CallComNames>({ comName }: {
     comName: CallComNames;
 }) => {

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

@@ -0,0 +1,17 @@
+import { useSchemaStore } from "../../../stores/schemaStore.js";
+import { useShallow } from "zustand/react/shallow";
+//#region frontend/src/defaultPages/SchemaPage/hooks/useComConfig.ts
+var useComConfig = ({ comName }) => {
+	const params = useSchemaStore(useShallow((s) => ({
+		comConfig: s.components,
+		api: s.api
+	})));
+	const comConfig = params.comConfig?.[comName];
+	return {
+		config: comConfig?.config,
+		schema: comConfig?.schema,
+		api: params.api
+	};
+};
+//#endregion
+export { useComConfig as default };

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

@@ -0,0 +1,112 @@
+.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;
+}

package/fe/frontend/{widgets/defaultPages/Schema → src/defaultPages/SchemaPage}/index.d.ts

@@ -1,3 +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,90 @@
+import "./index.css";
+import { frontendLangKeys } from "../../language/index.js";
+import { getText } from "../../common/language.js";
+import useInit from "../../../../packages/react/hooks/useInit.js";
+import { logIllegalComponentCallback } from "../../common/logFn/index.js";
+import { schemaEventBus } from "../../stores/schemaEventBus.js";
+import { useSchemaStore } from "../../stores/schemaStore.js";
+import useExecuteOnce, { executionPhaseType } from "../../../../packages/react/hooks/useExecuteOnce.js";
+import useCurrentMenuData from "../../hooks/useCurrentMenuData.js";
+import { eventsInfo } from "./data/eventInfo.js";
+import { isAllowed } from "./utils/permissions.js";
+import { components } from "./components/CallCom/data.js";
+import SchemaSearch from "./components/SchemaSearch/index.js";
+import SchemaTable from "./components/SchemaTable/index.js";
+/* empty css       */
+import { schemaConversion } from "./utils/schemaConversion.js";
+import { Suspense, memo, useCallback, useMemo, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SchemaPage/index.tsx
+var 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(void 0);
+			setComProps(void 0);
+		}
+		if (isAllowed(type, eventsInfo.initTable)) TableRef.current?.initData();
+		if (isAllowed(type, eventsInfo.resetSearch)) {}
+	}, []);
+	useInit(() => {
+		schemaConversion(menu.schemaConfig, menu.key);
+	});
+	useExecuteOnce(() => {
+		schemaEventBus.getState().subscribeSearch(onSearch);
+		schemaEventBus.getState().subscribeCom(comDone);
+		schemaEventBus.getState().subscribeTable(callCom);
+	}, { executionPhase: executionPhaseType.mount });
+	useExecuteOnce(() => {
+		schemaEventBus.getState().unSubscribeSearch(onSearch);
+		schemaEventBus.getState().unSubscribeTable(callCom);
+		schemaEventBus.getState().unSubscribeCom(comDone);
+	}, { executionPhase: executionPhaseType.unMount });
+	return useMemo(() => {
+		if (schemaStoreAvailable) {
+			const CallCom = components[showCompoentKey];
+			if (!CallCom && showCompoentKey) logIllegalComponentCallback(showCompoentKey);
+			return /* @__PURE__ */ 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: [/* @__PURE__ */ jsxs("div", {
+					className: "schema-workspace flex min-h-0 flex-1 flex-col overflow-hidden",
+					children: [/* @__PURE__ */ jsx("div", {
+						className: "schema-search-region shrink-0",
+						children: /* @__PURE__ */ jsx(SchemaSearch, {})
+					}), /* @__PURE__ */ jsx("div", {
+						className: "schema-table-region min-h-0 flex-1 overflow-auto p-3",
+						children: /* @__PURE__ */ jsx(SchemaTable, { ref: TableRef })
+					})]
+				}), /* @__PURE__ */ jsx(Suspense, { children: CallCom && /* @__PURE__ */ jsx(CallCom, { ...comProps }) })]
+			});
+		} else return /* @__PURE__ */ jsx("div", {
+			className: "flex h-full items-center justify-center text-sm text-muted-foreground",
+			children: getText(frontendLangKeys.loading)
+		});
+	}, [
+		comProps,
+		schemaStoreAvailable,
+		showCompoentKey
+	]);
+});
+Schema.displayName = "SchemaPage";
+//#endregion
+export { Schema as default };

package/fe/frontend/{widgets/defaultPages/Schema → src/defaultPages/SchemaPage}/schemaType.d.ts

@@ -1,6 +1,7 @@
-import type { ComponentConfig } from '../../../../model/types/data/component';
-import type { BaseOption, ConfigSchema, SchemaDataType, SearchConfig, TableConfig, UsedConfigSchema } from '../../../../model/types/data/schema';
-import type { SuffixKey } from './data';
+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'];
@@ -31,6 +32,7 @@ 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;
@@ -44,7 +46,6 @@ export type SchemaComEventInfo = {
      */
     type: number;
 };
-export type CallComponent<T> = {
-    [K in CallComNames]: T;
-};
+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,7 @@
+//#region frontend/src/defaultPages/SchemaPage/schemaType.ts
+var ComEventType = /* @__PURE__ */ function(ComEventType) {
+	ComEventType[ComEventType["close"] = 0] = "close";
+	return ComEventType;
+}({});
+//#endregion
+export { ComEventType };

package/fe/frontend/src/defaultPages/SchemaPage/utils/permissions.js

@@ -0,0 +1,6 @@
+import { eventsInfo } from "../data/eventInfo.js";
+//#region frontend/src/defaultPages/SchemaPage/utils/permissions.ts
+var merge = (...params) => params.reduce((o, n) => o | n, eventsInfo.none);
+var isAllowed = (key1, key2) => (key1 & key2) !== eventsInfo.none;
+//#endregion
+export { isAllowed, merge };

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,66 @@
+import { schemaStore } from "../../../stores/schemaStore.js";
+import "../data/index.js";
+//#region frontend/src/defaultPages/SchemaPage/utils/schemaConversion.ts
+/**
+*
+* 构建出需要optios + 其他字段
+*/
+var 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("Option") !== -1) {
+				if (fieldKey === `${fieldType}Option`) o["option"] = fieldInfo[fieldKey];
+			} else o[fieldKey] = fieldInfo[fieldKey];
+			return o;
+		}, {});
+	}
+	return temSchema;
+};
+var 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) components = Object.keys(componentConfig ?? {}).reduce((o, comKey) => {
+		o[comKey] = {
+			schema: buildSchema(JSON.parse(JSON.stringify(schemaMetadata)), comKey),
+			config: componentConfig[comKey]
+		};
+		return o;
+	}, {});
+	{
+		const { setSchemaState, updateSchemaCache } = schemaStore.getState();
+		setSchemaState({
+			api,
+			components,
+			tableSchema,
+			tableConfig,
+			searchSchema,
+			searchConfig
+		});
+		updateSchemaCache({
+			api,
+			schemaKey,
+			components,
+			tableSchema,
+			tableConfig,
+			searchSchema,
+			searchConfig
+		});
+	}
+};
+//#endregion
+export { schemaConversion };

package/fe/frontend/src/defaultPages/SchemaPage/utils/validator.d.ts

@@ -0,0 +1,11 @@
+import { Ajv } from "ajv";
+export declare const ajvInstance: Ajv;
+type AjvValidatorOptions = {
+    required?: boolean;
+};
+/**
+ * 创建验证器
+ */
+export declare function createAjvValidator(schema: object, options?: AjvValidatorOptions): (rule: object, value: unknown, callback: (errors?: string[]) => void) => void;
+export {};
+//# sourceMappingURL=validator.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/utils/validator.js

@@ -0,0 +1,122 @@
+import { frontendLangKeys } from "../../../language/index.js";
+import { getText } from "../../../common/language.js";
+import { Ajv } from "ajv";
+//#region frontend/src/defaultPages/SchemaPage/utils/validator.ts
+var ajvInstance = new Ajv({
+	allErrors: true,
+	verbose: true,
+	strict: false
+});
+var isPlainObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+var isEmptyValue = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0 || isPlainObject(value) && Object.keys(value).length === 0;
+var getErrorPath = (error) => {
+	const path = error.instancePath.replace(/^\//, "");
+	if (path) return path;
+	return error.params.missingProperty || getText(frontendLangKeys.validatorValue);
+};
+var getTypeText = (type) => {
+	return (Array.isArray(type) ? type : [type]).filter((item) => typeof item === "string").map((item) => {
+		switch (item) {
+			case "string": return getText(frontendLangKeys.validatorTypeString);
+			case "number": return getText(frontendLangKeys.validatorTypeNumber);
+			case "integer": return getText(frontendLangKeys.validatorTypeInteger);
+			case "boolean": return getText(frontendLangKeys.validatorTypeBoolean);
+			case "array": return getText(frontendLangKeys.validatorTypeArray);
+			case "object": return getText(frontendLangKeys.validatorTypeObject);
+			case "null": return getText(frontendLangKeys.validatorTypeNull);
+			default: return item;
+		}
+	}).join(" / ");
+};
+/**
+* 创建验证器
+*/
+function createAjvValidator(schema, options = {}) {
+	const validate = ajvInstance.compile(schema);
+	return (rule, value, callback) => {
+		if (!options.required && isEmptyValue(value)) {
+			callback();
+			return;
+		}
+		if (validate(value)) callback();
+		else callback((validate.errors || []).map(formatError));
+	};
+}
+function formatError(error) {
+	const path = getErrorPath(error);
+	switch (error.keyword) {
+		case "required": return getText(frontendLangKeys.validatorRequired, { field: error.params.missingProperty });
+		case "type": return getText(frontendLangKeys.validatorType, {
+			path,
+			type: getTypeText(error.params.type)
+		});
+		case "format": return getText(frontendLangKeys.validatorFormat, {
+			path,
+			format: String(error.params.format ?? "")
+		});
+		case "minimum": return getText(frontendLangKeys.validatorMinimum, {
+			path,
+			limit: error.params.limit
+		});
+		case "maximum": return getText(frontendLangKeys.validatorMaximum, {
+			path,
+			limit: error.params.limit
+		});
+		case "exclusiveMinimum": return getText(frontendLangKeys.validatorExclusiveMinimum, {
+			path,
+			limit: error.params.limit
+		});
+		case "exclusiveMaximum": return getText(frontendLangKeys.validatorExclusiveMaximum, {
+			path,
+			limit: error.params.limit
+		});
+		case "multipleOf": return getText(frontendLangKeys.validatorMultipleOf, {
+			path,
+			multipleOf: error.params.multipleOf
+		});
+		case "minLength": return getText(frontendLangKeys.validatorMinLength, {
+			path,
+			limit: error.params.limit
+		});
+		case "maxLength": return getText(frontendLangKeys.validatorMaxLength, {
+			path,
+			limit: error.params.limit
+		});
+		case "pattern": return getText(frontendLangKeys.validatorPattern, { path });
+		case "minItems": return getText(frontendLangKeys.validatorMinItems, {
+			path,
+			limit: error.params.limit
+		});
+		case "maxItems": return getText(frontendLangKeys.validatorMaxItems, {
+			path,
+			limit: error.params.limit
+		});
+		case "uniqueItems": return getText(frontendLangKeys.validatorUniqueItems, { path });
+		case "minProperties": return getText(frontendLangKeys.validatorMinProperties, {
+			path,
+			limit: error.params.limit
+		});
+		case "maxProperties": return getText(frontendLangKeys.validatorMaxProperties, {
+			path,
+			limit: error.params.limit
+		});
+		case "additionalProperties": return getText(frontendLangKeys.validatorAdditionalProperties, {
+			path,
+			property: error.params.additionalProperty
+		});
+		case "enum": return getText(frontendLangKeys.validatorEnum, { path });
+		case "const": return getText(frontendLangKeys.validatorConst, { path });
+		case "oneOf": return getText(frontendLangKeys.validatorOneOf, { path });
+		case "anyOf": return getText(frontendLangKeys.validatorAnyOf, { path });
+		case "allOf": return getText(frontendLangKeys.validatorAllOf, { path });
+		case "not": return getText(frontendLangKeys.validatorNot, { path });
+		case "propertyNames": return getText(frontendLangKeys.validatorPropertyNames, { path });
+		case "dependencies":
+		case "dependentRequired": return getText(frontendLangKeys.validatorDependencies, { path });
+		case "contains": return getText(frontendLangKeys.validatorContains, { path });
+		case "if": return getText(frontendLangKeys.validatorIf, { path });
+		default: return getText(frontendLangKeys.validatorFallback, { path });
+	}
+}
+//#endregion
+export { ajvInstance, createAjvValidator };

package/fe/frontend/{widgets → src}/defaultPages/SidebarSlotPage/SidebarSlotContainer.d.ts

@@ -1,5 +1,5 @@
-import { BaseMenuType } from '../../../../model/types/menuType';
-import { MenuItemData } from '../../../../packages/ui/react/components';
+import { BaseMenuType } from "../../../../model/types/menuType";
+import { MenuItemData } from "../../../../packages/react/ui/components/index";
 interface SidebarSlotContainerProps {
     prefixPath: string;
     rawMenuData: BaseMenuType[];

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

@@ -0,0 +1,55 @@
+import { Menu } from "../../../../packages/react/ui/components/Menu/Menu.js";
+import "../../../../packages/react/ui/components/index.js";
+import { QK, findMenuItem } from "../../common/menu.js";
+import useRouterParams from "../../hooks/useRouterParams.js";
+import { logPageNotFound } from "../../common/logFn/index.js";
+import { useEffect, useState } from "react";
+import { Outlet, useNavigate } from "react-router-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SidebarSlotPage/SidebarSlotContainer.tsx
+var SidebarSlotContainer = (props) => {
+	const { prefixPath, rawMenuData, menuItems } = props;
+	const params = useRouterParams();
+	const [SK, uSK] = useState(params[QK.sk]);
+	const nav = useNavigate();
+	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 /* @__PURE__ */ jsxs("div", {
+		className: "sidebar-slot flex h-full w-full gap-0 overflow-hidden bg-theme-bg",
+		children: [/* @__PURE__ */ jsx("div", {
+			className: "sidebar-slot-container flex h-full shrink-0 border-r border-border/70 bg-background/70 px-2 py-2",
+			children: /* @__PURE__ */ 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
+					});
+				}
+			})
+		}), /* @__PURE__ */ jsx("div", {
+			className: "min-w-0 flex-1 overflow-hidden",
+			children: /* @__PURE__ */ jsx(Outlet, {})
+		})]
+	});
+};
+//#endregion
+export { SidebarSlotContainer as default };

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

@@ -0,0 +1,21 @@
+import { generateMenuItemData } from "../../common/generateMenuData.js";
+import { QK } from "../../common/menu.js";
+import useCurrentMenuData from "../../hooks/useCurrentMenuData.js";
+import SidebarSlotContainer from "./SidebarSlotContainer.js";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SidebarSlotPage/index.tsx
+var SidebarSlotPage = () => {
+	const params = useParams();
+	const { menu: parentMenuInfo } = useCurrentMenuData();
+	const menuKey = params[QK.k];
+	const prefixPath = useMemo(() => `/${menuKey}`, [menuKey]);
+	return /* @__PURE__ */ jsx(SidebarSlotContainer, {
+		menuItems: generateMenuItemData(parentMenuInfo?.sidebarConfig?.menu ?? []),
+		rawMenuData: parentMenuInfo?.sidebarConfig.menu,
+		prefixPath
+	});
+};
+//#endregion
+export { SidebarSlotPage as default };

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

@@ -0,0 +1,21 @@
+import { generateMenuItemData } from "../common/generateMenuData.js";
+import { useModeStore } from "../stores/mode.js";
+import { leftSidebarBasePath } from "../common/menu.js";
+import SidebarSlotContainer from "./SidebarSlotPage/SidebarSlotContainer.js";
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SidebarSlotPageTmp.tsx
+var SidebarSlotPageTmp = () => {
+	const projInfo = useModeStore((s) => s.projectInfo);
+	const [menuItems, rawMenuData] = useMemo(() => {
+		if (projInfo) return [generateMenuItemData(projInfo.menu), projInfo.menu];
+		return [[], []];
+	}, [projInfo]);
+	return /* @__PURE__ */ jsx(SidebarSlotContainer, {
+		prefixPath: "/" + leftSidebarBasePath,
+		rawMenuData,
+		menuItems
+	});
+};
+//#endregion
+export { SidebarSlotPageTmp as default };

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

@@ -0,0 +1,22 @@
+import { logPageNotFound } from "../../common/logFn/index.js";
+import useCurrentMenuData from "../../hooks/useCurrentMenuData.js";
+import Iframe from "../Iframe/index.js";
+import NotFoundPage from "../NotFoundPage/index.js";
+import Schema from "../SchemaPage/index.js";
+import { memo, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/defaultPages/SlotPage/index.tsx
+var SlotPage = memo(() => {
+	const { menu } = useCurrentMenuData(true);
+	return useMemo(() => {
+		if (menu?.moduleType === "iframe") return /* @__PURE__ */ jsx(Iframe, {});
+		else if (menu?.moduleType === "schema") return /* @__PURE__ */ jsx(Schema, {});
+		else {
+			logPageNotFound();
+			return /* @__PURE__ */ jsx(NotFoundPage, {});
+		}
+	}, [menu?.moduleType]);
+});
+SlotPage.displayName = "SlotPage";
+//#endregion
+export { SlotPage as default };

package/fe/frontend/src/exportStore.d.ts

@@ -0,0 +1,17 @@
+/**
+ * mode 数据
+ */
+export * from "./stores/mode";
+/**
+ *  callcom 与SchemaPage 通信
+ */
+export * from "./stores/schemaEventBus";
+/**
+ * 获取 schema 数据
+ */
+export * from "./stores/schemaStore";
+/**
+ * 请求冻结处理仓库
+ */
+export * from "./stores/apiFreezer";
+//# sourceMappingURL=exportStore.d.ts.map

package/fe/frontend/src/exportStore.js

@@ -0,0 +1,5 @@
+import { FreezeState, apiFreezerStore, useApiFreezer } from "./stores/apiFreezer.js";
+import { modeStore, useModeStore } from "./stores/mode.js";
+import { schemaEventBus } from "./stores/schemaEventBus.js";
+import { schemaStore, useSchemaStore } from "./stores/schemaStore.js";
+export { FreezeState, apiFreezerStore, modeStore, schemaEventBus, schemaStore, useApiFreezer, useModeStore, useSchemaStore };