@_tc/template-core 0.0.1 → 0.0.2

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,16 @@
+/**
+ * mode 数据
+ */
+export * from './stores/mode';
+/**
+ *  callcom 与SchemaPage 通信
+ */
+export * from './stores/schemaEventBus';
+/**
+ * 获取 schema 数据
+ */
+export * from './stores/schemaStore';
+/**
+ * 请求冻结处理仓库
+ */
+export * from './stores/apiFreezer';

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

@@ -0,0 +1,19 @@
+import { BasicModuleType, SidebarModuleType } from '../../../model/types/menuType';
+/**
+ *
+ * 自定义路由直接交由路由器渲染
+ *
+ * 也就是说 这里找不到 自定义相关的菜单数据
+ *
+ * @param useSibe 使用侧边数据
+ */
+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/src/hooks/useCurrentMenuData.js

@@ -0,0 +1,28 @@
+import { findMenuItem, QK } from '../common/menu';
+import { useModeStore } from '../stores/mode';
+import { useMemo } from 'react';
+import { useParams } from 'react-router-dom';
+/**
+ *
+ * 自定义路由直接交由路由器渲染
+ *
+ * 也就是说 这里找不到 自定义相关的菜单数据
+ *
+ * @param useSibe 使用侧边数据
+ */
+const useCurrentMenuData = (useSibe = false) => {
+    const params = useParams();
+    const projectInfo = useModeStore((s) => s.projectInfo);
+    const menu = useMemo(() => {
+        const isSide = params[QK.sk];
+        const menuTypeIsTop = !!params[QK.k];
+        const menu = findMenuItem(projectInfo?.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;
+    }, [projectInfo?.menu, params]);
+    return { menu: menu };
+};
+export default useCurrentMenuData;

package/fe/frontend/src/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/src/hooks/useRouterParams.js

@@ -0,0 +1,11 @@
+import { deserializationUrlSearch, QK } from '../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/src/index.d.ts

@@ -0,0 +1,16 @@
+import './typing/scalability';
+export type * from '../apps/dash/types';
+export * from './main';
+export type { CallComComponentsMap, CallComRenderer } from './defaultPages/SchemaPage/schemaType';
+export type { FormFieldSchema, SchemaFormComponentsMap, SchemaFormNamespace, SelectProps } from '../../packages/ui/react';
+export { del, get, patch, post, put, request } from './common/request';
+/**
+ * callCom 事件通信 权限
+ */
+export * from './defaultPages/SchemaPage/data/eventInfo';
+export { merge } from './defaultPages/SchemaPage/utils/permissions';
+/**
+ * 导出依赖的 共享数据
+ */
+export * from './exportStore';
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/index.js

@@ -0,0 +1,13 @@
+import './typing/scalability';
+export * from './main';
+// 导出请求方法
+export { del, get, patch, post, put, request } from './common/request';
+/**
+ * callCom 事件通信 权限
+ */
+export * from './defaultPages/SchemaPage/data/eventInfo';
+export { merge } from './defaultPages/SchemaPage/utils/permissions';
+/**
+ * 导出依赖的 共享数据
+ */
+export * from './exportStore';

package/fe/frontend/src/main.css

@@ -0,0 +1,96 @@
+@import "../packages/ui/react/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,27 @@
+import type { JSX } from 'react/jsx-runtime';
+import { RouteInfo } from './components/Router';
+import { RouterType } from './components/Router/type';
+import { type ReactNode } from 'react';
+import './main.css';
+import './typing/window';
+export declare const initApp: (
+/**
+ * ## ⚠️ ‼️如果你有配置路由，一定要渲染 children
+ * 根组件函数
+ *
+ */
+RootComponent: (props: {
+    children: Exclude<ReactNode, null | undefined>;
+}) => JSX.Element, options?: {
+    routes?: RouteInfo[];
+    routerType?: RouterType;
+    modelType?: string;
+    /**
+     * - 初始化 model 数据
+     * - 默认开启
+     * - modelType 为 MD 时 默认开启
+     * @default true
+     */
+    initModeData?: boolean;
+}) => void;
+//# sourceMappingURL=main.d.ts.map

package/fe/frontend/src/main.js

@@ -0,0 +1,72 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { generateRouter } from './components/Router';
+import { createRoot } from 'react-dom/client';
+import { renderImportComponent } from './common/importComponent';
+import { modeStore } from './exportStore';
+import './main.css';
+import './typing/window';
+const 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: () => _jsx(_Fragment, { children: routerDom }) };
+};
+export const initApp = (
+/**
+ * ## ⚠️ ‼️如果你有配置路由，一定要渲染 children
+ * 根组件函数
+ *
+ */
+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(_jsx(RootComponent, { children: Component }));
+};

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

@@ -0,0 +1,93 @@
+/** 根据参数 + 路径 + config 生成hash key */
+type freezeQueue = Map<string, {
+    /**
+     * - 包装的原始请求函数， 只需要存一次  因为参数完全一致
+     *
+     * - () =>  fn(...params)
+     */
+    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 {
+    /**
+     *
+
+    * 冻结器状态
+    * - 流程：
+    *   1. 开启冻结 标记 Freeze
+    *   2. 收录请求
+    *   3. 开始解冻 标记 Thaw
+    *   4. 消费队列
+    *   5. 标记 Hibernation
+
+    */
+    readonly state: FreezeStateEnum;
+    /**
+     *   - 开启冻结
+     *   - 所有触发的请求不会实际发出，而是进入消息队列
+     */
+    freezing: () => void;
+    /**
+     *  - 开始解冻
+     *  - 处理消息队列
+     */
+    thawing: () => void;
+    /**
+     * - 请求白名单
+     * - 需要放行的 api请求
+     */
+    requestWhitelist: ApiFreezerRequestMatcher[];
+    setRequestWhitelist: (data: ApiFreezerState['requestWhitelist']) => void;
+    /**
+     *  - 收录的待处理请求
+     */
+    readonly freezeQueue: freezeQueue;
+}
+/**
+ *
+ * 解冻的过程中 又插入了请求  如何处理？
+ *
+ * 冻结流程
+ *
+ * 1. 如果处于休眠 或者 api在白名单中  直接调用
+ * 2. 获取冻结队列
+ *    1. 如果没有则新增
+ * 3. 返回一个 Promise 给调用方 // 请求并未发出
+ * 4. 监听状态变化
+ * 5. 变为解冻时
+ * 6. 获取消息 冻结列表
+ * 7. 批处理请求
+ * 8. 响应后 回调 调用方 返回结果
+ * 9. 清空 冻结队列
+ *
+ */
+export declare const apiFreezerStore: import("zustand").StoreApi<ApiFreezerState>;
+export declare const useApiFreezer: import("../../../packages/ui/react").StoreHook<import("zustand").StoreApi<ApiFreezerState>>;
+export {};
+//# sourceMappingURL=apiFreezer.d.ts.map

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

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

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

@@ -0,0 +1,19 @@
+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/ui/react").StoreHook<import("zustand").StoreApi<IStore>>;
+export {};
+//# sourceMappingURL=mode.d.ts.map

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

@@ -0,0 +1,37 @@
+import { getModelList, getProjectData } from '../api/baseInfo';
+import { setApiAuth } from '../common/auth';
+import { deserializationUrlSearch } from '../common/menu';
+import { createStoreHook } from '../../../packages/ui/react/lib/createStoreHook';
+import { createStore } from 'zustand';
+// create Store 可在任意地方使用
+export const modeStore = createStore((set, get) => ({
+    modeList: [],
+    projectInfo: null,
+    initData: false,
+    setModeList(modeList) {
+        set({ modeList });
+    },
+    setProjectInfo(projectInfo) {
+        set({ projectInfo });
+    },
+    async initModeData() {
+        const fetchModeData = async () => {
+            const data = await getModelList();
+            return data;
+        };
+        const fetchProjectData = async () => {
+            const urls = deserializationUrlSearch(window.location.search);
+            const key = urls['projk'];
+            setApiAuth(key);
+            const data = await getProjectData(key);
+            return data;
+        };
+        const [modeList, projectInfo] = await Promise.all([fetchModeData(), fetchProjectData()]);
+        set({
+            modeList,
+            projectInfo,
+            initData: true,
+        });
+    },
+}));
+export const useModeStore = createStoreHook(modeStore);

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

@@ -0,0 +1,42 @@
+import type { SchemaComEventInfo, SchemaDefaultValue, SchemaTableEmitData } from '../defaultPages/SchemaPage/schemaType';
+/**
+ * 消费方 subscribeSearch(fn)
+ *      unSubscribeSearch(fn)
+ *
+ * 通知方 emitSearch (value)
+ *
+ */
+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>;
+    /**
+     * 订阅 Search 变化
+     */
+    subscribeSearch: (fn: WatchFn) => void;
+    unSubscribeSearch: (fn: WatchFn) => void;
+    emitSearch: (v: SchemaDefaultValue | undefined) => void;
+    /**
+     * 订阅 Table 变化
+     */
+    subscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    unSubscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    emitTable: (v: SchemaTableEmitData) => void;
+    /**
+     * 通用 call
+     */
+    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/src/stores/schemaEventBus.js

@@ -0,0 +1,70 @@
+import { logSubscriptionError } from '../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(),
+        // com
+        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);
+        },
+        // table
+        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);
+                }
+            }
+        },
+        // search
+        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);
+        },
+        //
+    };
+});