@_tc/template-core 0.0.1-bate.5 → 0.0.1-bate.50

package/fe/frontend/src/language/index.js

@@ -0,0 +1,79 @@
+import { frontendEnUSResources } from "./en-US.js";
+import { frontendZhCNResources } from "./zh-CN.js";
+//#region frontend/src/language/index.ts
+var i18nKeyPrefix = "$i18n::";
+var frontendI18nResources = {
+	"zh-CN": frontendZhCNResources,
+	"en-US": frontendEnUSResources
+};
+var withI18nKey = (key) => `${i18nKeyPrefix}${key}`;
+var frontendLangKeys = {
+	appTitle: withI18nKey("frontend.app.title"),
+	uiComponentsTitle: withI18nKey("frontend.app.uiComponentsTitle"),
+	uiComponentsButton: withI18nKey("frontend.app.uiComponentsButton"),
+	languageSwitchPlaceholder: withI18nKey("frontend.components.languageSwitch.placeholder"),
+	languageSwitchZhCN: withI18nKey("frontend.components.languageSwitch.zhCN"),
+	languageSwitchEnUS: withI18nKey("frontend.components.languageSwitch.enUS"),
+	themeSwitchLight: withI18nKey("frontend.components.themeSwitch.light"),
+	themeSwitchDark: withI18nKey("frontend.components.themeSwitch.dark"),
+	themeSwitchToLight: withI18nKey("frontend.components.themeSwitch.toLight"),
+	themeSwitchToDark: withI18nKey("frontend.components.themeSwitch.toDark"),
+	yes: withI18nKey("frontend.common.yes"),
+	no: withI18nKey("frontend.common.no"),
+	noData: withI18nKey("frontend.common.noData"),
+	loading: withI18nKey("frontend.common.loading"),
+	operation: withI18nKey("frontend.common.operation"),
+	confirmDelete: withI18nKey("frontend.feedback.confirmDelete"),
+	requiredInput: withI18nKey("frontend.feedback.requiredInput"),
+	unknownError: withI18nKey("frontend.feedback.unknownError"),
+	requestTimedOut: withI18nKey("frontend.feedback.requestTimedOut"),
+	networkError: withI18nKey("frontend.feedback.networkError"),
+	notFoundTitle: withI18nKey("frontend.notFound.title"),
+	notFoundDescription: withI18nKey("frontend.notFound.description"),
+	validatorValue: withI18nKey("frontend.validator.value"),
+	validatorRequired: withI18nKey("frontend.validator.required"),
+	validatorType: withI18nKey("frontend.validator.type"),
+	validatorTypeString: withI18nKey("frontend.validator.typeString"),
+	validatorTypeNumber: withI18nKey("frontend.validator.typeNumber"),
+	validatorTypeInteger: withI18nKey("frontend.validator.typeInteger"),
+	validatorTypeBoolean: withI18nKey("frontend.validator.typeBoolean"),
+	validatorTypeArray: withI18nKey("frontend.validator.typeArray"),
+	validatorTypeObject: withI18nKey("frontend.validator.typeObject"),
+	validatorTypeNull: withI18nKey("frontend.validator.typeNull"),
+	validatorFormat: withI18nKey("frontend.validator.format"),
+	validatorMinimum: withI18nKey("frontend.validator.minimum"),
+	validatorMaximum: withI18nKey("frontend.validator.maximum"),
+	validatorExclusiveMinimum: withI18nKey("frontend.validator.exclusiveMinimum"),
+	validatorExclusiveMaximum: withI18nKey("frontend.validator.exclusiveMaximum"),
+	validatorMultipleOf: withI18nKey("frontend.validator.multipleOf"),
+	validatorMinLength: withI18nKey("frontend.validator.minLength"),
+	validatorMaxLength: withI18nKey("frontend.validator.maxLength"),
+	validatorPattern: withI18nKey("frontend.validator.pattern"),
+	validatorMinItems: withI18nKey("frontend.validator.minItems"),
+	validatorMaxItems: withI18nKey("frontend.validator.maxItems"),
+	validatorUniqueItems: withI18nKey("frontend.validator.uniqueItems"),
+	validatorMinProperties: withI18nKey("frontend.validator.minProperties"),
+	validatorMaxProperties: withI18nKey("frontend.validator.maxProperties"),
+	validatorAdditionalProperties: withI18nKey("frontend.validator.additionalProperties"),
+	validatorEnum: withI18nKey("frontend.validator.enum"),
+	validatorConst: withI18nKey("frontend.validator.const"),
+	validatorOneOf: withI18nKey("frontend.validator.oneOf"),
+	validatorAnyOf: withI18nKey("frontend.validator.anyOf"),
+	validatorAllOf: withI18nKey("frontend.validator.allOf"),
+	validatorNot: withI18nKey("frontend.validator.not"),
+	validatorPropertyNames: withI18nKey("frontend.validator.propertyNames"),
+	validatorDependencies: withI18nKey("frontend.validator.dependencies"),
+	validatorContains: withI18nKey("frontend.validator.contains"),
+	validatorIf: withI18nKey("frontend.validator.if"),
+	validatorFallback: withI18nKey("frontend.validator.fallback"),
+	logPageNotFound: withI18nKey("frontend.log.pageNotFound"),
+	logPageNotFoundEn: withI18nKey("frontend.log.pageNotFoundEn"),
+	logIllegalComponentCallback: withI18nKey("frontend.log.illegalComponentCallback"),
+	logIllegalComponentCallbackEn: withI18nKey("frontend.log.illegalComponentCallbackEn"),
+	logSubscriptionError: withI18nKey("frontend.log.subscriptionError"),
+	logSubscriptionErrorEn: withI18nKey("frontend.log.subscriptionErrorEn"),
+	logApiTamper: withI18nKey("frontend.log.apiTamper"),
+	logApiTamperEn: withI18nKey("frontend.log.apiTamperEn")
+};
+//#endregion
+export { frontendI18nResources, frontendLangKeys, i18nKeyPrefix, withI18nKey };

package/fe/frontend/src/language/zh-CN.d.ts

@@ -0,0 +1,88 @@
+export declare const frontendZhCNResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI 组件";
+            readonly uiComponentsButton: "点击我";
+        };
+        readonly components: {
+            readonly languageSwitch: {
+                readonly placeholder: "选择语言";
+                readonly zhCN: "简体中文";
+                readonly enUS: "English";
+            };
+            readonly themeSwitch: {
+                readonly light: "浅色";
+                readonly dark: "深色";
+                readonly toLight: "切换为浅色主题";
+                readonly toDark: "切换为深色主题";
+            };
+        };
+        readonly common: {
+            readonly yes: "是";
+            readonly no: "否";
+            readonly noData: "暂无数据";
+            readonly loading: "加载中";
+            readonly operation: "操作";
+        };
+        readonly feedback: {
+            readonly confirmDelete: "确认删除？";
+            readonly requiredInput: "请输入{label}";
+            readonly unknownError: "未知错误";
+            readonly requestTimedOut: "请求超时";
+            readonly networkError: "网络错误";
+        };
+        readonly notFound: {
+            readonly title: "页面不存在";
+            readonly description: "当前路径无效，或页面未在路由中注册。";
+        };
+        readonly validator: {
+            readonly value: "值";
+            readonly required: "缺少必填字段: {field}";
+            readonly type: "{path} 类型错误，期望 {type}";
+            readonly typeString: "字符串";
+            readonly typeNumber: "数字";
+            readonly typeInteger: "整数";
+            readonly typeBoolean: "布尔值";
+            readonly typeArray: "数组";
+            readonly typeObject: "对象";
+            readonly typeNull: "空值";
+            readonly format: "{path} 格式不正确";
+            readonly minimum: "{path} 不能小于 {limit}";
+            readonly maximum: "{path} 不能大于 {limit}";
+            readonly exclusiveMinimum: "{path} 必须大于 {limit}";
+            readonly exclusiveMaximum: "{path} 必须小于 {limit}";
+            readonly multipleOf: "{path} 必须是 {multipleOf} 的倍数";
+            readonly minLength: "{path} 长度不能少于 {limit} 个字符";
+            readonly maxLength: "{path} 长度不能超过 {limit} 个字符";
+            readonly pattern: "{path} 格式不符合要求";
+            readonly minItems: "{path} 至少需要 {limit} 项";
+            readonly maxItems: "{path} 不能超过 {limit} 项";
+            readonly uniqueItems: "{path} 不能包含重复项";
+            readonly minProperties: "{path} 至少需要 {limit} 个属性";
+            readonly maxProperties: "{path} 不能超过 {limit} 个属性";
+            readonly additionalProperties: "{path} 包含不允许的属性 {property}";
+            readonly enum: "{path} 不在可选范围内";
+            readonly const: "{path} 必须等于指定值";
+            readonly oneOf: "{path} 只能匹配一个规则";
+            readonly anyOf: "{path} 至少需要匹配一个规则";
+            readonly allOf: "{path} 未满足全部规则";
+            readonly not: "{path} 不能匹配该规则";
+            readonly propertyNames: "{path} 属性名不符合要求";
+            readonly dependencies: "{path} 缺少关联字段";
+            readonly contains: "{path} 缺少符合要求的项";
+            readonly if: "{path} 条件校验未通过";
+            readonly fallback: "{path} 校验未通过";
+        };
+        readonly log: {
+            readonly pageNotFound: "url有问题 或者 自定义页面未在路由器注册";
+            readonly pageNotFoundEn: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly illegalComponentCallback: "非法的组件回调 - {comName}";
+            readonly illegalComponentCallbackEn: "Illegal component callback - {comName}";
+            readonly subscriptionError: "不曾订阅过，请检查代码，关注函数与取消函数必须为同一个";
+            readonly subscriptionErrorEn: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly apiTamper: "api属性不允许篡改";
+            readonly apiTamperEn: "API attributes cannot be tampered with";
+        };
+    };
+};

package/fe/frontend/src/language/zh-CN.js

@@ -0,0 +1,89 @@
+//#region frontend/src/language/zh-CN.ts
+var frontendZhCNResources = { frontend: {
+	app: {
+		title: "Template Core",
+		uiComponentsTitle: "UI 组件",
+		uiComponentsButton: "点击我"
+	},
+	components: {
+		languageSwitch: {
+			placeholder: "选择语言",
+			zhCN: "简体中文",
+			enUS: "English"
+		},
+		themeSwitch: {
+			light: "浅色",
+			dark: "深色",
+			toLight: "切换为浅色主题",
+			toDark: "切换为深色主题"
+		}
+	},
+	common: {
+		yes: "是",
+		no: "否",
+		noData: "暂无数据",
+		loading: "加载中",
+		operation: "操作"
+	},
+	feedback: {
+		confirmDelete: "确认删除？",
+		requiredInput: "请输入{label}",
+		unknownError: "未知错误",
+		requestTimedOut: "请求超时",
+		networkError: "网络错误"
+	},
+	notFound: {
+		title: "页面不存在",
+		description: "当前路径无效，或页面未在路由中注册。"
+	},
+	validator: {
+		value: "值",
+		required: "缺少必填字段: {field}",
+		type: "{path} 类型错误，期望 {type}",
+		typeString: "字符串",
+		typeNumber: "数字",
+		typeInteger: "整数",
+		typeBoolean: "布尔值",
+		typeArray: "数组",
+		typeObject: "对象",
+		typeNull: "空值",
+		format: "{path} 格式不正确",
+		minimum: "{path} 不能小于 {limit}",
+		maximum: "{path} 不能大于 {limit}",
+		exclusiveMinimum: "{path} 必须大于 {limit}",
+		exclusiveMaximum: "{path} 必须小于 {limit}",
+		multipleOf: "{path} 必须是 {multipleOf} 的倍数",
+		minLength: "{path} 长度不能少于 {limit} 个字符",
+		maxLength: "{path} 长度不能超过 {limit} 个字符",
+		pattern: "{path} 格式不符合要求",
+		minItems: "{path} 至少需要 {limit} 项",
+		maxItems: "{path} 不能超过 {limit} 项",
+		uniqueItems: "{path} 不能包含重复项",
+		minProperties: "{path} 至少需要 {limit} 个属性",
+		maxProperties: "{path} 不能超过 {limit} 个属性",
+		additionalProperties: "{path} 包含不允许的属性 {property}",
+		enum: "{path} 不在可选范围内",
+		const: "{path} 必须等于指定值",
+		oneOf: "{path} 只能匹配一个规则",
+		anyOf: "{path} 至少需要匹配一个规则",
+		allOf: "{path} 未满足全部规则",
+		not: "{path} 不能匹配该规则",
+		propertyNames: "{path} 属性名不符合要求",
+		dependencies: "{path} 缺少关联字段",
+		contains: "{path} 缺少符合要求的项",
+		if: "{path} 条件校验未通过",
+		fallback: "{path} 校验未通过"
+	},
+	log: {
+		pageNotFound: "url有问题 或者 自定义页面未在路由器注册",
+		pageNotFoundEn: "The URL is incorrect, or the custom page is not registered with the router.",
+		illegalComponentCallback: "非法的组件回调 - {comName}",
+		illegalComponentCallbackEn: "Illegal component callback - {comName}",
+		subscriptionError: "不曾订阅过，请检查代码，关注函数与取消函数必须为同一个",
+		subscriptionErrorEn: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.",
+		apiTamper: "api属性不允许篡改",
+		apiTamperEn: "API attributes cannot be tampered with"
+	}
+} };
+//#endregion
+export { frontendZhCNResources };

package/fe/frontend/src/main.css

@@ -0,0 +1,96 @@
+@import '../../packages/react/ui/index.css';
+
+/* 内容扫描 */
+/* enhancedComponents */
+@source "./**/*.{js,ts,jsx,tsx}";
+
+.dark {
+    --background: 238 12% 7%;
+    --foreground: 225 16% 92%;
+    --card: 238 11% 8%;
+    --card-foreground: 225 16% 92%;
+    --popover: 238 11% 8%;
+    --popover-foreground: 225 16% 92%;
+    --primary: 225 16% 92%;
+    --primary-foreground: 238 12% 9%;
+    --secondary: 235 10% 15%;
+    --secondary-foreground: 225 16% 90%;
+    --muted: 235 10% 17%;
+    --muted-foreground: 228 9% 66%;
+    --accent: 226 16% 18%;
+    --accent-foreground: 225 16% 92%;
+    --border: 235 10% 20%;
+    --input: 235 10% 20%;
+    --ring: 225 16% 72%;
+
+    --theme-primary: 225 16% 92%;
+    --theme-primary-foreground: 238 12% 9%;
+    --theme-bg: 238 13% 9%;
+    --theme-text: 225 16% 92%;
+
+    --table-header-bg: 235 9% 18%;
+    --table-header-text: 228 10% 72%;
+    --table-head-text: 228 10% 72%;
+    --table-cell-text: 225 16% 90%;
+    --table-action-bg: 235 9% 19%;
+    --table-action-text: 225 16% 86%;
+}
+
+* {
+    scrollbar-color: hsl(var(--muted-foreground) / 0.34) transparent;
+    scrollbar-width: thin;
+}
+
+*::-webkit-scrollbar {
+    width: 10px;
+    height: 10px;
+}
+
+*::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+*::-webkit-scrollbar-thumb {
+    min-height: 40px;
+    border: 3px solid transparent;
+    border-radius: 999px;
+    background: hsl(var(--muted-foreground) / 0.28);
+    background-clip: padding-box;
+}
+
+*::-webkit-scrollbar-thumb:hover {
+    background: hsl(var(--muted-foreground) / 0.46);
+    background-clip: padding-box;
+}
+
+*::-webkit-scrollbar-corner {
+    background: transparent;
+}
+
+.sidebar-shell-menu.tc-ui-menu {
+    width: 168px;
+    height: 100%;
+    border-radius: 0;
+    background: transparent;
+    box-shadow: none;
+}
+
+.sidebar-shell-menu .menuitem,
+.sidebar-shell-menu .subMenuItem {
+    border-radius: 8px;
+    color: hsl(var(--muted-foreground));
+    font-weight: 500;
+}
+
+.sidebar-shell-menu .menuitem:hover,
+.sidebar-shell-menu .subMenuItem:hover {
+    background: hsl(var(--muted) / 0.42);
+    color: hsl(var(--foreground));
+}
+
+.sidebar-shell-menu .menuitem.bg-theme,
+.sidebar-shell-menu .subMenuItem.bg-theme\/10 {
+    background: hsl(var(--foreground) / 0.08);
+    color: hsl(var(--foreground));
+    box-shadow: inset 0 0 0 1px hsl(var(--border) / 0.8);
+}

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

@@ -0,0 +1,14 @@
+import type { JSX } from "react/jsx-runtime";
+import { RouteInfo } from "./components/Router/index";
+import { RouterType } from "./components/Router/type";
+import { type ReactNode } from "react";
+import "./main.css";
+import "./typing/window";
+export declare const initApp: (RootComponent: (props: {
+    children: Exclude<ReactNode, null | undefined>;
+}) => JSX.Element, options?: {
+    routes?: RouteInfo[];
+    routerType?: RouterType;
+    modelType?: string;
+    initModeData?: boolean;
+}) => void;

package/fe/frontend/src/main.js

@@ -0,0 +1,60 @@
+import "./main.css";
+import { modeStore } from "./stores/mode.js";
+import { renderImportComponent } from "./common/importComponent.js";
+import { generateRouter } from "./components/Router/index.js";
+import "./exportStore.js";
+/* empty css      */
+import { Fragment, jsx } from "react/jsx-runtime";
+import { createRoot } from "react-dom/client";
+//#region frontend/src/main.tsx
+var renderRouter = async ({ routerDom, requestModelData }) => {
+	if (requestModelData) {
+		const { initModeData } = modeStore.getState();
+		if (!modeStore.getState().initData) await new Promise((resolve, reject) => {
+			let settled = false;
+			let unsubscribe = () => {};
+			const done = () => {
+				if (settled) return;
+				settled = true;
+				unsubscribe();
+				resolve();
+			};
+			const fail = (error) => {
+				if (settled) return;
+				settled = true;
+				unsubscribe();
+				reject(error);
+			};
+			unsubscribe = modeStore.subscribe((ns) => {
+				if (ns.initData) done();
+			});
+			let initResult;
+			try {
+				initResult = initModeData();
+			} catch (error) {
+				fail(error);
+				return;
+			}
+			Promise.resolve(initResult).then(() => {
+				if (modeStore.getState().initData) done();
+			}, fail);
+		});
+	}
+	return { default: () => /* @__PURE__ */ jsx(Fragment, { children: routerDom }) };
+};
+var initApp = (RootComponent, options) => {
+	console.log("initApp");
+	const root = createRoot(document.getElementById("root"));
+	const { routerType = "browser", routes: pRoutes = [], initModeData = true, modelType = "MD" } = options ?? {};
+	const routes = [...pRoutes];
+	const usedRouter = !!routes.length;
+	let routerDom;
+	if (usedRouter) routerDom = generateRouter(routes, routerType);
+	const Component = renderImportComponent(renderRouter({
+		routerDom,
+		requestModelData: initModeData || modelType === "MD"
+	}));
+	root.render(/* @__PURE__ */ jsx(RootComponent, { children: Component }));
+};
+//#endregion
+export { initApp };

package/fe/frontend/src/stores/apiFreezer.d.ts

@@ -0,0 +1,26 @@
+type freezeQueue = Map<string, {
+    originFn: Function;
+    callBackFns: {
+        resolve: (value: unknown) => void;
+        reject: (reason?: any) => void;
+    }[];
+}>;
+export declare const FreezeState: {
+    readonly Hibernation: "Hibernation";
+    readonly Freeze: "Freeze";
+    readonly Thawing: "Thawing";
+};
+export type FreezeStateKeys = keyof typeof FreezeState;
+export type FreezeStateEnum = (typeof FreezeState)[FreezeStateKeys];
+export type ApiFreezerRequestMatcher = string | RegExp | ((api: string, params: readonly unknown[]) => boolean);
+interface ApiFreezerState {
+    readonly state: FreezeStateEnum;
+    freezing: () => void;
+    thawing: () => void;
+    requestWhitelist: ApiFreezerRequestMatcher[];
+    setRequestWhitelist: (data: ApiFreezerState['requestWhitelist']) => void;
+    readonly freezeQueue: freezeQueue;
+}
+export declare const apiFreezerStore: import("zustand").StoreApi<ApiFreezerState>;
+export declare const useApiFreezer: import("../../../packages/react/ui/index").StoreHook<import("zustand").StoreApi<ApiFreezerState>>;
+export {};

package/fe/frontend/src/stores/apiFreezer.js

@@ -0,0 +1,53 @@
+import { createStoreHook } from "../../../packages/react/ui/lib/createStoreHook.js";
+import "../../../packages/react/ui/index.js";
+import { createStore } from "zustand";
+//#region frontend/src/stores/apiFreezer.ts
+var FreezeState = {
+	/**
+	* 休眠 - 待机状态
+	*/
+	Hibernation: "Hibernation",
+	/**
+	* 冻结状态
+	*/
+	Freeze: "Freeze",
+	/**
+	* 正在解冻
+	*/
+	Thawing: "Thawing"
+};
+/**
+*
+* 解冻的过程中 又插入了请求  如何处理？
+*
+* 冻结流程
+*
+* 1. 如果处于休眠 或者 api在白名单中  直接调用
+* 2. 获取冻结队列
+*    1. 如果没有则新增
+* 3. 返回一个 Promise 给调用方 // 请求并未发出
+* 4. 监听状态变化
+* 5. 变为解冻时
+* 6. 获取消息 冻结列表
+* 7. 批处理请求
+* 8. 响应后 回调 调用方 返回结果
+* 9. 清空 冻结队列
+*
+*/
+var apiFreezerStore = createStore((set) => ({
+	state: FreezeState.Hibernation,
+	freezing() {
+		set({ state: FreezeState.Freeze });
+	},
+	thawing() {
+		set({ state: FreezeState.Thawing });
+	},
+	requestWhitelist: [],
+	setRequestWhitelist(requestWhitelist) {
+		set({ requestWhitelist });
+	},
+	freezeQueue: /* @__PURE__ */ new Map()
+}));
+var useApiFreezer = createStoreHook(apiFreezerStore);
+//#endregion
+export { FreezeState, apiFreezerStore, useApiFreezer };

package/fe/frontend/src/stores/mode.d.ts

@@ -0,0 +1,15 @@
+import { type ModelInfo, type ProjectInfo } from "../api/baseInfo";
+interface ModeState {
+    modeList: ModelInfo[];
+    projectInfo: ProjectInfo | null;
+    initData: boolean;
+}
+interface ModeAction {
+    setModeList: (data: ModeState['modeList']) => void;
+    setProjectInfo: (data: ModeState['projectInfo']) => void;
+    initModeData: () => Promise<void>;
+}
+type IStore = ModeState & ModeAction;
+export declare const modeStore: import("zustand").StoreApi<IStore>;
+export declare const useModeStore: import("../../../packages/react/ui/index").StoreHook<import("zustand").StoreApi<IStore>>;
+export {};

package/fe/frontend/src/stores/mode.js

@@ -0,0 +1,36 @@
+import { createStoreHook } from "../../../packages/react/ui/lib/createStoreHook.js";
+import { setApiAuth } from "../common/auth/index.js";
+import { getModelList, getProjectData } from "../api/baseInfo.js";
+import { deserializationUrlSearch } from "../common/menu.js";
+import { createStore } from "zustand";
+//#region frontend/src/stores/mode.ts
+var modeStore = createStore((set, get) => ({
+	modeList: [],
+	projectInfo: null,
+	initData: false,
+	setModeList(modeList) {
+		set({ modeList });
+	},
+	setProjectInfo(projectInfo) {
+		set({ projectInfo });
+	},
+	async initModeData() {
+		const fetchModeData = async () => {
+			return await getModelList();
+		};
+		const fetchProjectData = async () => {
+			const key = deserializationUrlSearch(window.location.search)["projk"];
+			setApiAuth(key);
+			return await getProjectData(key);
+		};
+		const [modeList, projectInfo] = await Promise.all([fetchModeData(), fetchProjectData()]);
+		set({
+			modeList,
+			projectInfo,
+			initData: true
+		});
+	}
+}));
+var useModeStore = createStoreHook(modeStore);
+//#endregion
+export { modeStore, useModeStore };

package/fe/frontend/src/stores/schemaEventBus.d.ts

@@ -0,0 +1,22 @@
+import type { SchemaComEventInfo, SchemaDefaultValue, SchemaTableEmitData } from "../defaultPages/SchemaPage/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 {};

package/fe/frontend/src/stores/schemaEventBus.js

@@ -0,0 +1,53 @@
+import { logSubscriptionError } from "../common/logFn/index.js";
+import { createStore } from "zustand";
+//#region frontend/src/stores/schemaEventBus.ts
+var SubscribeEnum = /* @__PURE__ */ function(SubscribeEnum) {
+	SubscribeEnum["search"] = "search";
+	SubscribeEnum["table"] = "table";
+	SubscribeEnum["com"] = "com";
+	return SubscribeEnum;
+}(SubscribeEnum || {});
+var schemaEventBus = createStore((set, get) => {
+	return {
+		Subscribers: /* @__PURE__ */ 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);
+		}
+	};
+});
+//#endregion
+export { schemaEventBus };

package/fe/frontend/src/stores/schemaStore.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentConfig, ComponentType, SearchConfig, StoreSchemaType, TableConfig } from "../defaultPages/SchemaPage/schemaType";
+import type { TableSearchSchema } from "../../../packages/react/ui/components/TableSearch/TableSearch";
+import type { MOmit } from "../../../typings/type";
+import { LRUCache } from "../../../packages/common/index";
+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/react/ui/index").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
+export {};