@_tc/template-core 0.0.1-bate.4 → 0.0.1-bate.41

package/fe/frontend/widgets/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/widgets/hooks/useCurrentMenuData.js

@@ -0,0 +1,28 @@
+import { findMenuItem, QK } from "../../widgets/common/menu";
+import { useModeStore } from "../../widgets/store/mode";
+import { useMemo } from "react";
+import { useParams } from "react-router-dom";
+/**
+ *
+ * 自定义路由直接交由路由器渲染
+ *
+ * 也就是说 这里找不到 自定义相关的菜单数据
+ *
+ * @param useSibe 使用侧边数据
+ */
+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,19 @@
+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,37 @@
+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';
+// create Store 可在任意地方使用
+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,32 @@
+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: {
+            /**
+             *  @example user_id: 'schema::tableKey' | '123' | 123
+             */
+            [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,16 @@
+export {};
+// & {
+// 	/**
+// 	 * 按钮事件名
+// 	 */
+// 	eventKey: 'romve' | 'showComponent';
+// 	/**
+// 	 * 事件配置 (参数配置)
+// 	 */
+// 	params: {
+// 		/**
+// 		 *  @example user_id: 'schema::tableKey' | '123' | 123
+// 		 */
+// 		[paramKey: string]: ParamsValueData;
+// 	};
+// };

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

@@ -0,0 +1,61 @@
+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 & {
+        /**
+         * 是否展示 默认为true
+         */
+        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,11 @@
+export {};
+// type DynamicSelect = {
+// 	comType: 'dynamicSelect';
+// 	/**
+// 	 * 请求动态列表地址
+// 	 */
+// 	api: string;
+// } & SelectProps;
+// type DateRange = {
+// 	comType: 'dateRange';
+// };

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

@@ -0,0 +1,20 @@
+export type FetchInfo = {
+    /**
+     * 表单主键，  获取数据源的key
+     */
+    fetchKey: string;
+    /**
+     * 请求配置 如果不配置则使用 统一的 [get] api 内容
+     */
+    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,98 @@
+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 = {
+    /**
+     * 不配置则不在 search 中显示
+     */
+    searchOption?: {
+        /**
+         * 控件默认值
+         */
+        default?: any;
+    } & SearchOption;
+};
+export type TableConfig = {
+    /**
+     * table 头部按钮
+     */
+    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]: 字段描述
+         */
+        [key: string]: T & MOmit<UsedConfigSchema, 'properties'> & {
+            /**
+             * 展示 字符
+             */
+            label: string;
+            /**
+             *  原数据 序列化后 会丢失编写时的顺序
+             * 	字段层级  默认10
+             *
+             */
+            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 {
+    /**
+     * 数据源地址  遵循 RESTFUL 规范
+     * *[参考地址](https://www.ruanyifeng.com/blog/2014/05/restful_api.html)*
+     *
+     * 即:
+     *
+     * - 获取数据 GET [api]
+     * - 新增数据 POST [api]
+     * - ...
+     */
+    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,73 @@
+import { SchemaDataType } from "./data/schema";
+/**
+ *  - parent menuLaout === 'top'
+ *    - child menuLayout === 'top' | 'left'
+ *  - parent menuLayout === 'left'
+ *    - child menuLayout === 'left'
+ */
+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";
+}
+/**
+ *
+ * ----------------------------- moduletype -----------------------------
+ *
+ */
+interface IframeModuleType {
+    moduleType: "iframe";
+    iframeConfig: {
+        /**
+         * iframe 路径
+         */
+        path: string;
+    };
+}
+interface CustomModuleType {
+    moduleType: "custom";
+    customConfig: {
+        /**
+         * 自定义路由路径
+         */
+        path: string;
+    };
+}
+interface SchemaModuleType {
+    moduleType: "schema";
+    schemaConfig: SchemaDataType;
+}
+export interface SidebarModuleType {
+    moduleType: "sidebar";
+    sidebarConfig: {
+        menu: BaseMenuType[];
+        /**
+         * 只能为left
+         */
+        menuLayout?: "left";
+    };
+}
+export type BasicModuleType = SchemaModuleType | CustomModuleType | IframeModuleType;
+export type BaseMenuType = GroupMenuType<"left"> | (ModuleMenuType & BasicModuleType);
+type ModuleType = BasicModuleType | SidebarModuleType;
+/**
+ * top 包含所有
+ */
+export type TopMenuType = GroupMenuType<"top"> | (ModuleMenuType & ModuleType);
+/**
+ * left 不包含 sidebar
+ */
+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,33 @@
+import { TopMenuType, LeftMenuType } from "./menuType";
+type MTopMenuType = {
+    /**
+     * 默认为 left
+     */
+    menuLayout: "top";
+    menu: TopMenuType[];
+};
+type MLeftMenuType = {
+    /**
+     * 默认为 left
+     */
+    menuLayout?: "left";
+    menu: LeftMenuType[];
+};
+export type ModeMenuType = MTopMenuType | MLeftMenuType;
+export type ModelDataType = {
+    /**
+     * - 使用哪一块的模型数据 内置 MB
+     * 	- MB = 管理后台
+     */
+    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;
+};