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

package/fe/frontend/dash/Dashboard.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+declare const Dashboard: {
+    (props: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default Dashboard;
+//# sourceMappingURL=Dashboard.d.ts.map

package/fe/frontend/dash/Dashboard.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Outlet, useNavigate } from 'react-router-dom';
+import { generateMenuItemData } from '../widgets/common/generateMenuData';
+import { findMenuItem, leftSidebarBasePath } from '../widgets/common/menu';
+import HeaderView from '../widgets/components/BasePage/HeaderView';
+import useRouterParams from '../widgets/hooks/useRouterParams';
+import { useModeStore } from '../widgets/store/mode';
+import { Menu } from '../../packages/ui/react/components';
+import useInit from '../../packages/ui/react/hooks/useInit';
+const Dashboard = (props) => {
+    const { initModeData, initData, projestInfo } = useModeStore();
+    useInit(initModeData);
+    const isInit = useRef(false);
+    const params = useRouterParams();
+    const [SK, uSK] = useState(params.key ?? params.custk);
+    const nav = useNavigate();
+    const menu = useMemo(() => {
+        if (initData && projestInfo?.menuLayout === 'top') {
+            const menuData = generateMenuItemData(projestInfo.menu);
+            return (_jsx(Menu, { className: " w-full", mode: "top", items: menuData, selectedKey: SK, onSelect: (e) => {
+                    uSK(e);
+                    const m = findMenuItem(projestInfo.menu, e);
+                    m && nav(m?.path);
+                } }));
+        }
+        return _jsx(_Fragment, {});
+    }, [initData, projestInfo, SK, nav]);
+    useEffect(() => {
+        if (initData && projestInfo) {
+            if (isInit.current)
+                return;
+            if (projestInfo.menuLayout !== 'top') {
+                console.log('left sidebar');
+                if (Object.keys(params).length && location.pathname.includes(`/${leftSidebarBasePath}`)) {
+                    return;
+                }
+                const m = findMenuItem(projestInfo.menu);
+                nav({
+                    pathname: `/${leftSidebarBasePath}${m.path.pathname}`,
+                    search: m.path.search,
+                }, {
+                    replace: true,
+                });
+            }
+            else {
+                console.log('top sidebar');
+                if (!Object.keys(params).length ||
+                    location.pathname.includes(`/${leftSidebarBasePath}`)) {
+                    const m = findMenuItem(projestInfo.menu);
+                    uSK(m.key);
+                    nav(m.path, {
+                        replace: true,
+                    });
+                }
+            }
+            isInit.current = true;
+        }
+    }, [initData, projestInfo, params, nav]);
+    return (_jsxs("div", { className: "dash-main h-screen flex flex-col", children: [_jsx(HeaderView, { title: projestInfo?.desc, menu: menu }), _jsx("div", { className: "dash-container p-1.5 flex-1", children: _jsx(Outlet, {}) })] }));
+};
+Dashboard.displayName = 'Dashboard';
+export default Dashboard;

package/fe/frontend/dash/dash.entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dash.entry.d.ts.map

package/fe/frontend/dash/dash.entry.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderImportComponent } from '../widgets/common/importComponent';
+import { leftSidebarBasePath, QK } from '../widgets/common/menu';
+import { initApp } from '../main';
+import Dashboard from './Dashboard';
+const baseRoutes = [
+    {
+        path: '/',
+        component: _jsx(Dashboard, {}),
+        children: [
+            {
+                path: `/:${QK.k}`,
+                component: renderImportComponent(import('../widgets/defaultPages/SlotPage')),
+            },
+            {
+                path: `/testPage`,
+                component: renderImportComponent(import('../testPage')),
+            },
+            {
+                path: `todo`,
+                component: renderImportComponent(import('../widgets/defaultPages/Todo')),
+            },
+        ],
+    },
+];
+const sidebarRoutes = [
+    {
+        path: `/:${QK.k}/*`,
+        component: renderImportComponent(import('../widgets/defaultPages/SidebarSlotPage')),
+        children: [
+            {
+                path: `todo`,
+                component: renderImportComponent(import('../widgets/defaultPages/Todo')),
+            },
+            {
+                path: `:${QK.sk}`,
+                component: renderImportComponent(import('../widgets/defaultPages/SlotPage')),
+            },
+        ],
+    },
+    {
+        path: `/${leftSidebarBasePath}/*`,
+        component: renderImportComponent(import('../widgets/defaultPages/SidebarSlotPageTmp')),
+        children: [
+            {
+                path: `todo`,
+                component: renderImportComponent(import('../widgets/defaultPages/Todo')),
+            },
+            {
+                path: `:${QK.sk}`,
+                component: renderImportComponent(import('../widgets/defaultPages/SlotPage')),
+            },
+        ],
+    },
+];
+const getDefaultPageRoutes = () => {
+    baseRoutes[0].children?.push(...sidebarRoutes);
+    return [...baseRoutes];
+};
+initApp(({ children }) => _jsx("div", { className: "dash", children: children }), {
+    routes: getDefaultPageRoutes(),
+});

package/fe/frontend/index.d.ts

@@ -0,0 +1,3 @@
+export * from './main';
+export type { FormFieldSchema, SchemaFormBusinessComponentsMap, SchemaFormNamespace, SelectProps, } from '../packages/ui/react';
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/index.js

@@ -0,0 +1 @@
+export * from './main';

package/fe/frontend/main.css

@@ -1 +1,5 @@
-@import 'tailwindcss';
+@import "../packages/ui/react/index.css";
+
+/* 内容扫描 */
+/* enhancedComponents */
+@source "./**/*.{js,ts,jsx,tsx}";

package/fe/frontend/main.d.ts

@@ -1,4 +1,11 @@
-import { ReactNode } from "react";
-import './main.css';
-export declare const initApp: (rootComponent: ReactNode) => void;
+import { PropsWithChildren } from "react";
+import type { JSX } from "react/jsx-runtime";
+import "./main.css";
+import "./typing/window";
+import { RouterType } from "./widgets/components/Router/type";
+import { RouteInfo } from "./widgets/components/Router";
+export declare const initApp: (RootComponent: (props: PropsWithChildren) => JSX.Element, options?: {
+    routes: RouteInfo[];
+    routerType?: RouterType;
+}) => void;
 //# sourceMappingURL=main.d.ts.map

package/fe/frontend/main.js

@@ -1,7 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { createRoot } from "react-dom/client";
-import './main.css';
-export const initApp = (rootComponent) => {
+import "./main.css";
+import "./typing/window";
+import { generateRouter } from "./widgets/components/Router";
+export const initApp = (RootComponent, options) => {
     const root = createRoot(document.getElementById("root"));
-    // 挂在 根节点
-    root.render(rootComponent);
+    const { routerType = "browser", routes: pRoutes = [] } = options ?? {};
+    const routes = [...pRoutes];
+    const usedRouter = !!routes.length;
+    let routerDom;
+    if (usedRouter) {
+        routerDom = generateRouter(routes, routerType);
+    }
+    root.render(_jsx(RootComponent, { children: routerDom }));
 };

package/fe/frontend/testPage/testPage.entry.js

@@ -1,4 +1,3 @@
-import { jsx as _jsx } from "react/jsx-runtime";
 import App from "./index";
 import { initApp } from "../main";
-initApp(_jsx(App, {}));
+initApp(App);

package/fe/frontend/typing/window.d.ts

@@ -0,0 +1,7 @@
+export {};
+declare global {
+    interface Window {
+        _basePath: string;
+    }
+}
+//# sourceMappingURL=window.d.ts.map

package/fe/frontend/typing/window.js

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

package/fe/frontend/widgets/api/baseInfo.d.ts

@@ -0,0 +1,31 @@
+import type { ModeMenuType } from '../../../model/types/model';
+type ProjectMenuType = ModeMenuType;
+export type ModelInfo = {
+    model: {
+        key: string;
+        name: string;
+        desc: string;
+    };
+    project: {
+        [k: string]: {
+            key: string;
+            name: string;
+            desc: string;
+            homePage: string;
+        };
+    };
+};
+export declare const getModelList: () => Promise<ModelInfo[]>;
+export type ProjectInfo = {
+    mode: string;
+    homePage: string;
+    icon: string;
+    name: string;
+    desc: string;
+} & ProjectMenuType & {
+    key: string;
+    modelKey: string;
+};
+export declare const getProjeckData: (key: string) => Promise<ProjectInfo | null>;
+export {};
+//# sourceMappingURL=baseInfo.d.ts.map

package/fe/frontend/widgets/api/baseInfo.js

@@ -0,0 +1,15 @@
+import { get } from '../../widgets/common/request';
+export const getModelList = async () => {
+    const res = await get('/project/model_list');
+    if (res.data.code === 0) {
+        return res.data.data;
+    }
+    return [];
+};
+export const getProjeckData = async (key) => {
+    const res = await get(`/project/${key}`);
+    if (res.data.code === 0) {
+        return res.data.data;
+    }
+    return null;
+};

package/fe/frontend/widgets/common/CRUD/CRUD.d.ts

@@ -0,0 +1,70 @@
+export interface RequestConfig<D = unknown> {
+    url?: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+    baseURL?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean | undefined | null>;
+    data?: D;
+    timeout?: number;
+    signal?: AbortSignal;
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    redirect?: RequestRedirect;
+    referrer?: string;
+    referrerPolicy?: ReferrerPolicy;
+    transformRequest?: ((data: D, headers: Headers) => D | string | ArrayBuffer | Blob) | ((data: D, headers: Headers) => D | string | ArrayBuffer | Blob)[];
+    transformResponse?: ((data: unknown) => unknown) | ((data: unknown) => unknown)[];
+    validateStatus?: (status: number) => boolean;
+    onUploadProgress?: (progress: ProgressEvent) => void;
+    onDownloadProgress?: (progress: ProgressEvent) => void;
+}
+export interface ResponseConfig<T = unknown, D = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    config: RequestConfig<D>;
+    request?: Request;
+}
+export interface AxiosError<T = unknown, D = unknown> extends Error {
+    config: RequestConfig<D>;
+    code?: string;
+    request?: Request;
+    response?: ResponseConfig<T, D>;
+    isAxiosError: boolean;
+}
+interface InterceptorHandler<V> {
+    fulfilled?: (value: V) => V | Promise<V>;
+    rejected?: (error: unknown) => unknown;
+    id: number;
+}
+declare class InterceptorManager<V> {
+    private handlers;
+    private nextId;
+    use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: unknown) => unknown): number;
+    eject(id: number): void;
+    clear(): void;
+    getHandlers(): InterceptorHandler<V>[];
+}
+export declare class FetchAxios {
+    defaults: RequestConfig;
+    interceptors: {
+        request: InterceptorManager<RequestConfig<unknown>>;
+        response: InterceptorManager<ResponseConfig<unknown, unknown>>;
+    };
+    constructor(config?: RequestConfig);
+    private request;
+    private _doRequest;
+    private createError;
+    get<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    post<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    put<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    patch<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    delete<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    head<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+    options<T = unknown, D = unknown>(url: string, config?: RequestConfig<D>): Promise<ResponseConfig<T, D>>;
+}
+export declare const axios: FetchAxios;
+export declare const createInstance: (defaultConfig: RequestConfig) => FetchAxios;
+export default FetchAxios;
+//# sourceMappingURL=CRUD.d.ts.map

package/fe/frontend/widgets/common/CRUD/CRUD.js

@@ -0,0 +1,207 @@
+class InterceptorManager {
+    handlers = [];
+    nextId = 0;
+    use(onFulfilled, onRejected) {
+        const id = this.nextId++;
+        this.handlers.push({ id, fulfilled: onFulfilled, rejected: onRejected });
+        return id;
+    }
+    eject(id) {
+        const idx = this.handlers.findIndex((h) => h.id === id);
+        if (idx !== -1)
+            this.handlers.splice(idx, 1);
+    }
+    clear() {
+        this.handlers = [];
+    }
+    getHandlers() {
+        return this.handlers;
+    }
+}
+function buildURL(url, baseURL, params) {
+    let fullUrl = baseURL ? `${baseURL.replace(/\/+$/, '')}/${url.replace(/^\/+/, '')}` : url;
+    if (params) {
+        const searchParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null) {
+                searchParams.append(key, String(value));
+            }
+        }
+        const query = searchParams.toString();
+        if (query) {
+            fullUrl += (fullUrl.includes('?') ? '&' : '?') + query;
+        }
+    }
+    return fullUrl;
+}
+function parseHeaders(rawHeaders) {
+    const headers = {};
+    rawHeaders.forEach((value, key) => {
+        headers[key] = value;
+    });
+    return headers;
+}
+function mergeConfig(primary, secondary) {
+    return {
+        ...secondary,
+        ...primary,
+        headers: {
+            ...secondary?.headers,
+            ...primary.headers,
+        },
+    };
+}
+function isObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+function applyTransformers(value, transformers) {
+    if (!transformers?.length)
+        return value;
+    return transformers.reduce((acc, fn) => fn(acc), value);
+}
+export class FetchAxios {
+    defaults;
+    interceptors = {
+        request: new InterceptorManager(),
+        response: new InterceptorManager(),
+    };
+    constructor(config = {}) {
+        this.defaults = config;
+    }
+    async request(config) {
+        const merged = mergeConfig(this.defaults, config);
+        const chain = [];
+        this.interceptors.request.getHandlers().forEach((h) => {
+            chain.unshift({
+                fulfilled: h.fulfilled,
+                rejected: h.rejected,
+            });
+        });
+        chain.push({
+            fulfilled: (cfg) => Promise.resolve(cfg),
+            rejected: undefined,
+        });
+        this.interceptors.response.getHandlers().forEach((h) => {
+            chain.push({
+                fulfilled: h.fulfilled,
+                rejected: h.rejected,
+            });
+        });
+        let currentConfig = merged;
+        for (let i = 0; i < chain.length; i++) {
+            const item = chain[i];
+            const { fulfilled, rejected } = item;
+            try {
+                currentConfig = await fulfilled(currentConfig);
+            }
+            catch (err) {
+                if (rejected) {
+                    void (await rejected(err));
+                }
+                throw err;
+            }
+        }
+        return this._doRequest(currentConfig);
+    }
+    async _doRequest(config) {
+        const { method = 'GET', baseURL, headers: rawHeaders = {}, params, data, timeout, credentials, cache, redirect, referrer, referrerPolicy, transformRequest, transformResponse, validateStatus, } = config;
+        const url = buildURL(config.url ?? '', baseURL, params);
+        const requestHeaders = new Headers(rawHeaders);
+        let requestData = data;
+        if (transformRequest && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+            const fns = Array.isArray(transformRequest) ? transformRequest : [transformRequest];
+            requestData = applyTransformers(data, fns);
+            if (isObject(requestData) || Array.isArray(requestData)) {
+                if (!requestHeaders.has('Content-Type')) {
+                    requestHeaders.set('Content-Type', 'application/json');
+                }
+            }
+        }
+        const init = {
+            method,
+            headers: requestHeaders,
+            credentials: credentials ?? 'same-origin',
+            cache: cache,
+            redirect: redirect,
+            referrer: referrer,
+            referrerPolicy: referrerPolicy,
+        };
+        if (requestData !== undefined && method !== 'GET' && method !== 'HEAD') {
+            init.body = typeof requestData === 'string' ? requestData : JSON.stringify(requestData);
+        }
+        const controller = new AbortController();
+        init.signal = config.signal ?? controller.signal;
+        let timeoutId;
+        if (timeout) {
+            timeoutId = setTimeout(() => controller.abort(), timeout);
+        }
+        let response;
+        try {
+            response = await fetch(url, init);
+        }
+        catch (err) {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            const error = this.createError(err instanceof Error ? err : new Error(String(err)), 'ECONNABORTED', config);
+            throw error;
+        }
+        if (timeoutId)
+            clearTimeout(timeoutId);
+        const responseHeaders = parseHeaders(response.headers);
+        const responseConfig = {
+            data: null,
+            status: response.status,
+            statusText: response.statusText,
+            headers: responseHeaders,
+            config,
+        };
+        if (!validateStatus || validateStatus(response.status)) {
+            const rawData = await response.text();
+            const parsed = rawData ? JSON.parse(rawData) : null;
+            const transformedData = transformResponse
+                ? applyTransformers(parsed, Array.isArray(transformResponse) ? transformResponse : [transformResponse])
+                : parsed;
+            responseConfig.data = transformedData;
+            return responseConfig;
+        }
+        else {
+            const rawData = response.body ? await response.text() : null;
+            responseConfig.data = rawData ? JSON.parse(rawData) : null;
+            const error = this.createError(new Error(`Request failed with status ${response.status}`), undefined, config, responseConfig);
+            throw error;
+        }
+    }
+    createError(message, code, config, response) {
+        const error = message;
+        error.config = config;
+        error.code = code;
+        error.response = response;
+        error.isAxiosError = true;
+        return error;
+    }
+    get(url, config) {
+        return this.request({ ...config, url, method: 'GET' });
+    }
+    post(url, data, config) {
+        return this.request({ ...config, url, method: 'POST', data });
+    }
+    put(url, data, config) {
+        return this.request({ ...config, url, method: 'PUT', data });
+    }
+    patch(url, data, config) {
+        return this.request({ ...config, url, method: 'PATCH', data });
+    }
+    delete(url, config) {
+        return this.request({ ...config, url, method: 'DELETE' });
+    }
+    head(url, config) {
+        return this.request({ ...config, url, method: 'HEAD' });
+    }
+    options(url, config) {
+        return this.request({ ...config, url, method: 'OPTIONS' });
+    }
+}
+const instance = new FetchAxios();
+export const axios = instance;
+export const createInstance = (defaultConfig) => new FetchAxios(defaultConfig);
+export default FetchAxios;

package/fe/frontend/widgets/common/CRUD/index.d.ts

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

package/fe/frontend/widgets/common/CRUD/index.js

@@ -0,0 +1 @@
+export * from './CRUD';

package/fe/frontend/widgets/common/auth/index.d.ts

@@ -0,0 +1,7 @@
+export declare const AUTH_HEADER_KEY = "Authorization";
+export declare function getAuthToken(): Promise<string | null>;
+export declare function clearAuthToken(): Promise<void>;
+export declare const API_AUTH_HEADER_KEY = "projk";
+export declare const getApiAuth: () => string;
+export declare const setApiAuth: (v: string) => void;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/common/auth/index.js

@@ -0,0 +1,20 @@
+const AUTH_LOCAL_KEY = 'auth_token';
+const API_AUTH_LOCAL_KEY = 'p_J_k';
+export const AUTH_HEADER_KEY = 'Authorization';
+export async function getAuthToken() {
+    if (typeof localStorage === 'undefined')
+        return null;
+    return localStorage.getItem(AUTH_LOCAL_KEY);
+}
+export async function clearAuthToken() {
+    if (typeof localStorage === 'undefined')
+        return;
+    localStorage.removeItem(AUTH_LOCAL_KEY);
+}
+export const API_AUTH_HEADER_KEY = 'projk';
+export const getApiAuth = () => {
+    return localStorage.getItem(API_AUTH_LOCAL_KEY) ?? '';
+};
+export const setApiAuth = (v) => {
+    return localStorage.setItem(API_AUTH_LOCAL_KEY, v);
+};

package/fe/frontend/widgets/common/generateMenuData.d.ts

@@ -0,0 +1,4 @@
+import { ProjectInfo } from "../../widgets/api/baseInfo";
+import { MenuItemData } from "../../../packages/ui/react/components";
+export declare const generateMenuItemData: (data: ProjectInfo["menu"]) => MenuItemData[];
+//# sourceMappingURL=generateMenuData.d.ts.map

package/fe/frontend/widgets/common/generateMenuData.js

@@ -0,0 +1,14 @@
+export const generateMenuItemData = (data) => {
+    return data.map((m) => {
+        const children = (m.menuType === "group" && m.subMenu.length
+            ? generateMenuItemData(m.subMenu)
+            : undefined);
+        return {
+            key: m.key,
+            label: m.name,
+            icon: m.icon,
+            children: children,
+            minWidth: 100,
+        };
+    });
+};

package/fe/frontend/widgets/common/importComponent.d.ts

@@ -0,0 +1,5 @@
+import { ComponentType, ReactNode } from 'react';
+export declare const renderImportComponent: (c: Promise<{
+    default: ComponentType<any>;
+}>, fallback?: ReactNode) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=importComponent.d.ts.map

package/fe/frontend/widgets/common/importComponent.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy, Suspense } from 'react';
+export const renderImportComponent = (c, fallback) => {
+    const Component = lazy(() => c);
+    const showFallback = typeof fallback !== 'undefined' ? fallback : 'loading';
+    return (_jsx(Suspense, { fallback: showFallback, children: _jsx(Component, {}) }));
+};

package/fe/frontend/widgets/common/language.d.ts

@@ -0,0 +1,2 @@
+export declare const getText: (key: string) => string;
+//# sourceMappingURL=language.d.ts.map

package/fe/frontend/widgets/common/language.js

@@ -0,0 +1,8 @@
+import { i18n } from '../../../packages/ui/react/i18n';
+const useI18nKey = '$i18n_';
+export const getText = (key) => {
+    if (key.includes(useI18nKey)) {
+        return i18n(key);
+    }
+    return key;
+};

package/fe/frontend/widgets/common/logFn/index.d.ts

@@ -0,0 +1,4 @@
+export declare const logPageNotFound: () => void;
+export declare const logIllegalComponentCallback: (comName: string) => void;
+export declare const logSubscriptionError: () => void;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/common/logFn/index.js

@@ -0,0 +1,8 @@
+const logJoin = (...logs) => logs.join(`
+    ---------
+    `);
+export const logPageNotFound = () => {
+    console.error(logJoin('url有问题 或者 自定义页面未在路由器注册', 'The URL is incorrect, or the custom page is not registered with the router.'));
+};
+export const logIllegalComponentCallback = (comName) => console.error(logJoin(`非法的组件回调 - ${comName}`, `Illegal component callback - ${comName}`));
+export const logSubscriptionError = () => console.error(logJoin('不曾订阅过，请检查代码，关注函数与取消函数必须为同一个', "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same."));

package/fe/frontend/widgets/common/menu.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectInfo } from "../../widgets/api/baseInfo";
+type MenuItem = {
+    key: string;
+    name: string;
+    path: Partial<{
+        pathname: string;
+        search: string;
+        hash: string;
+    }>;
+};
+export declare const enum QK {
+    pk = "projk",
+    k = "key",
+    sk = "sidek",
+    ck = "custk"
+}
+export declare const leftSidebarBasePath = "_sidebar_";
+export declare const deserializationUrlSearch: <T = Record<string, string>>(url?: string) => T;
+export declare const serializationUrl: (url: string, data: Record<string, string>) => string;
+export declare const findMenuItem: <T = Record<string, any>>(menuData: ProjectInfo["menu"], key?: string) => MenuItem & T;
+export {};
+//# sourceMappingURL=menu.d.ts.map