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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,47 @@
+import { TableColumnDef } from '../../../packages/ui/react';
+import type { JSONSchema7 } from 'json-schema';
+import { MOmit } from '../../../typings/type';
+import { BaseButton } from './button';
+import { ComponentConfig, ComponentNames, ComponentsOption } from './component';
+import { SearchOption } from './search';
+export type TableColumnsSchema = {
+    tableOption?: MOmit<TableColumnDef, 'key' | 'title'> & {
+        visible?: boolean;
+        toFixed?: number;
+    };
+};
+export type TableSearchOption = {
+    searchOption?: {
+        default?: any;
+    } & SearchOption;
+};
+export type TableConfig = {
+    headerButtons?: BaseButton[];
+    rowButtons?: BaseButton[];
+};
+export type SearchConfig = {};
+export type BaseOption<O> = {
+    option: O;
+};
+export type UsedConfigSchema<T = {}> = {
+    type: 'object' | 'string' | 'array' | 'number' | 'boolean';
+    properties: {
+        [key: string]: T & MOmit<UsedConfigSchema, 'properties'> & {
+            label: string;
+            level?: number;
+        };
+    };
+    required?: string[];
+} & Omit<JSONSchema7, 'properties'>;
+export type TableComponentConfig = {
+    [K in ComponentNames as `${K & string}Option`]?: ComponentsOption[K];
+};
+export type ConfigSchema = UsedConfigSchema<TableColumnsSchema & TableSearchOption & TableComponentConfig>;
+export interface SchemaDataType {
+    api: string;
+    schema?: ConfigSchema;
+    tableConfig?: TableConfig;
+    searchConfig?: SearchConfig;
+    componentConfig?: ComponentConfig;
+}
+//# sourceMappingURL=schema.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import type { SchemaFormComponentPropsMap, SchemaFormFieldType } from '../../../packages/ui/react';
+export type SearchOption = {
+    [K in SchemaFormFieldType]: {
+        comType: K;
+    } & SchemaFormComponentPropsMap[K];
+}[SchemaFormFieldType];
+//# sourceMappingURL=search.d.ts.map

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

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

package/fe/model/types/menuType.d.ts

@@ -0,0 +1,44 @@
+import { SchemaDataType } from "./data/schema";
+export type MenuLayout = "left" | "top";
+interface BaseMenu {
+    key: string;
+    icon?: string;
+    name: string;
+}
+interface GroupMenuType<T extends MenuLayout> extends BaseMenu {
+    menuType: "group";
+    subMenu: T extends "top" ? TopMenuType[] : LeftMenuType[];
+}
+interface ModuleMenuType extends BaseMenu {
+    menuType: "module";
+}
+interface IframeModuleType {
+    moduleType: "iframe";
+    iframeConfig: {
+        path: string;
+    };
+}
+interface CustomModuleType {
+    moduleType: "custom";
+    customConfig: {
+        path: string;
+    };
+}
+interface SchemaModuleType {
+    moduleType: "schema";
+    schemaConfig: SchemaDataType;
+}
+export interface SidebarModuleType {
+    moduleType: "sidebar";
+    sidebarConfig: {
+        menu: BaseMenuType[];
+        menuLayout?: "left";
+    };
+}
+export type BasicModuleType = SchemaModuleType | CustomModuleType | IframeModuleType;
+export type BaseMenuType = GroupMenuType<"left"> | (ModuleMenuType & BasicModuleType);
+type ModuleType = BasicModuleType | SidebarModuleType;
+export type TopMenuType = GroupMenuType<"top"> | (ModuleMenuType & ModuleType);
+export type LeftMenuType = GroupMenuType<"left"> | BaseMenuType;
+export {};
+//# sourceMappingURL=menuType.d.ts.map

package/fe/model/types/menuType.js

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

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

@@ -0,0 +1,20 @@
+import { TopMenuType, LeftMenuType } from "./menuType";
+type MTopMenuType = {
+    menuLayout: "top";
+    menu: TopMenuType[];
+};
+type MLeftMenuType = {
+    menuLayout?: "left";
+    menu: LeftMenuType[];
+};
+export type ModeMenuType = MTopMenuType | MLeftMenuType;
+export type ModelDataType = {
+    mode: "MB";
+    key?: string;
+    name: string;
+    desc: string;
+    icon: string;
+    homePage: string;
+} & ModeMenuType;
+export {};
+//# sourceMappingURL=model.d.ts.map

package/fe/model/types/model.js

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

package/fe/packages/common/array/index.d.ts

@@ -0,0 +1,7 @@
+export declare function toArray<T>(value: readonly T[]): T[];
+export declare function toArray<T>(value: T | null | undefined): T[];
+export declare const compact: <T>(items: readonly (T | null | undefined)[]) => T[];
+export declare const uniqueBy: <T, K extends PropertyKey>(items: readonly T[], getKey: (item: T) => K) => T[];
+export declare const groupBy: <T, K extends PropertyKey>(items: readonly T[], getKey: (item: T) => K) => Record<K, T[]>;
+export declare const chunk: <T>(items: readonly T[], size: number) => T[][];
+//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/array/index.js

@@ -0,0 +1,40 @@
+import { isNonNullable } from "../guards";
+export function toArray(value) {
+    if (value === null || value === undefined)
+        return [];
+    return Array.isArray(value) ? [...value] : [value];
+}
+export const compact = (items) => {
+    return items.filter(isNonNullable);
+};
+export const uniqueBy = (items, getKey) => {
+    const keys = new Set();
+    const result = [];
+    for (const item of items) {
+        const key = getKey(item);
+        if (keys.has(key))
+            continue;
+        keys.add(key);
+        result.push(item);
+    }
+    return result;
+};
+export const groupBy = (items, getKey) => {
+    const result = {};
+    for (const item of items) {
+        const key = getKey(item);
+        result[key] = result[key] ?? [];
+        result[key].push(item);
+    }
+    return result;
+};
+export const chunk = (items, size) => {
+    if (!Number.isInteger(size) || size <= 0) {
+        throw new RangeError("chunk size must be a positive integer");
+    }
+    const result = [];
+    for (let index = 0; index < items.length; index += size) {
+        result.push(items.slice(index, index + size));
+    }
+    return result;
+};

package/fe/packages/common/cache/LRUCache.d.ts

@@ -0,0 +1,13 @@
+export declare class LRUCache<T> {
+    private readonly limit;
+    private readonly data;
+    constructor(limit: number);
+    get size(): number;
+    has(k: string): boolean;
+    get(k: string): NonNullable<T> | undefined;
+    set(k: string, v: T): void;
+    push(k: string, v: T): void;
+    private deleteFirstKey;
+    private updateSorting;
+}
+//# sourceMappingURL=LRUCache.d.ts.map

package/fe/packages/common/cache/LRUCache.js

@@ -0,0 +1,47 @@
+export class LRUCache {
+    limit;
+    data;
+    constructor(limit) {
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new Error("LRUCache limit must be a positive integer");
+        }
+        this.limit = limit;
+        this.data = new Map();
+    }
+    get size() {
+        return this.data.size;
+    }
+    has(k) {
+        return this.data.has(k);
+    }
+    get(k) {
+        if (!this.data.has(k))
+            return undefined;
+        const value = this.data.get(k);
+        this.updateSorting(k, value);
+        return value;
+    }
+    set(k, v) {
+        if (this.data.has(k)) {
+            this.updateSorting(k, v);
+            return;
+        }
+        if (this.data.size >= this.limit) {
+            this.deleteFirstKey();
+        }
+        this.data.set(k, v);
+    }
+    push(k, v) {
+        this.set(k, v);
+    }
+    deleteFirstKey() {
+        const firstKey = this.data.keys().next().value;
+        if (firstKey !== undefined) {
+            this.data.delete(firstKey);
+        }
+    }
+    updateSorting(k, v) {
+        this.data.delete(k);
+        this.data.set(k, v);
+    }
+}

package/fe/packages/common/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./LRUCache";
+//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/cache/index.js

@@ -0,0 +1 @@
+export * from "./LRUCache";

package/fe/packages/common/guards/index.d.ts

@@ -0,0 +1,9 @@
+import type { Dictionary, Maybe } from "../types";
+export declare const isNil: <T>(value: Maybe<T>) => value is null | undefined;
+export declare const isNonNullable: <T>(value: T) => value is NonNullable<T>;
+export declare const isString: (value: unknown) => value is string;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isFunction: <TArgs extends unknown[], TResult>(value: unknown) => value is (...args: TArgs) => TResult;
+export declare const isPlainObject: (value: unknown) => value is Dictionary;
+//# sourceMappingURL=index.d.ts.map

package/fe/packages/common/guards/index.js

@@ -0,0 +1,24 @@
+export const isNil = (value) => {
+    return value === null || value === undefined;
+};
+export const isNonNullable = (value) => {
+    return value !== null && value !== undefined;
+};
+export const isString = (value) => {
+    return typeof value === "string";
+};
+export const isNumber = (value) => {
+    return typeof value === "number" && Number.isFinite(value);
+};
+export const isBoolean = (value) => {
+    return typeof value === "boolean";
+};
+export const isFunction = (value) => {
+    return typeof value === "function";
+};
+export const isPlainObject = (value) => {
+    if (value === null || typeof value !== "object")
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};