@_tc/template-core 0.0.1-bate.6 → 0.0.1-bate.60

package/esm/scripts/vite-build/normalize.js

@@ -0,0 +1,78 @@
+import { toArray as e } from "./utils.js";
+import { DEFAULT_EXTENSIONS as t, DEFAULT_FORMATS as n, DEFAULT_NON_CODE_EXTENSIONS as r } from "./constants.js";
+import i from "node:path";
+//#region scripts/vite-build/normalize.ts
+function a(e) {
+	let n = e?.input ?? [], r = e?.mergeDefault ?? !0 ? [...t, ...n] : n;
+	return r.length === 0 ? [...t] : [...new Set(r.map((e) => e.startsWith(".") ? e : `.${e}`))];
+}
+function o(e) {
+	return {
+		input: e?.input ?? [],
+		importPolicy: e?.importPolicy ?? "error"
+	};
+}
+function s(e, t) {
+	return e ? Array.isArray(e) ? e.map((e) => ({
+		find: e.find,
+		replacement: i.resolve(t, e.replacement)
+	})) : Object.entries(e).map(([e, n]) => ({
+		find: e,
+		replacement: i.resolve(t, n)
+	})) : [];
+}
+function c(e) {
+	let t = e?.input ?? [], n = e?.mergeDefault ?? !0 ? [...r, ...t] : t;
+	return [...new Set(n.map((e) => e.startsWith(".") ? e : `.${e}`))];
+}
+function l(t) {
+	let r = e(t);
+	return r.length === 0 ? [...n] : [...new Set(r)];
+}
+function u(e, t) {
+	return e === !1 ? {
+		enabled: !1,
+		outDir: i.join(t, "types"),
+		rewriteAliases: !0,
+		rewriteAliasMode: "source",
+		useInputFiles: !0,
+		clean: !0
+	} : e === !0 || e == null ? {
+		enabled: !0,
+		outDir: i.join(t, "types"),
+		rewriteAliases: !0,
+		rewriteAliasMode: "source",
+		useInputFiles: !0,
+		clean: !0
+	} : {
+		enabled: e.enabled ?? !0,
+		outDir: i.resolve(t, e.outDir ?? "types"),
+		tsconfig: e.tsconfig,
+		tempDir: e.tempDir,
+		rewriteAliases: e.rewriteAliases ?? !0,
+		rewriteAliasMode: e.rewriteAliasMode ?? "source",
+		rewriteAlias: e.rewriteAlias,
+		useInputFiles: e.useInputFiles ?? !0,
+		clean: e.clean ?? !0
+	};
+}
+function d(e) {
+	return e ?? {};
+}
+function f(e, t) {
+	let n = new Set(t), r = e.filter((e) => n.has(e));
+	if (r.length !== 0) throw Error(`These extensions look like non-code assets and should not be added to "extensions": ${r.join(", ")}.\nUse the default copy behavior, the "copy" config, createCopyPlugin(), or createFilePlugin() instead.`);
+}
+function p(e) {
+	return {
+		input: e?.input,
+		ignore: e?.ignore,
+		onlyConfiguredExtensions: e?.onlyConfiguredExtensions ?? !1,
+		extensions: e?.extensions ?? {
+			input: [],
+			mergeDefault: !1
+		}
+	};
+}
+//#endregion
+export { f as assertNoCommonAssetExtensions, s as normalizeAlias, p as normalizeCopy, u as normalizeDtsConfig, a as normalizeExtensions, d as normalizeFormatOutDir, l as normalizeFormats, o as normalizeIgnore, c as normalizeNonCodeExtensions };

package/esm/scripts/vite-build/plugins.js

@@ -0,0 +1,106 @@
+import { toArray as e } from "./utils.js";
+import { normalizeExtensions as t } from "./normalize.js";
+import { createExtensionMatcher as n } from "./resolve.js";
+import { ensurePluginFiles as r } from "./collect.js";
+import { promises as i } from "node:fs";
+import a from "node:path";
+//#region scripts/vite-build/plugins.ts
+async function o(e, t) {
+	let n = a.resolve(t, e.fileName);
+	if (await i.mkdir(a.dirname(n), { recursive: !0 }), e.type === "copy") {
+		await i.copyFile(e.sourcePath, n);
+		return;
+	}
+	await i.writeFile(n, e.content);
+}
+function s(e = {}) {
+	return {
+		name: e.name ?? "build-entries-file-plugin",
+		apply: e.apply,
+		enforce: e.enforce,
+		kind: e.kind,
+		__buildEntriesFilePlugin: e
+	};
+}
+function c(e = {}) {
+	return s({
+		...e,
+		kind: "copy",
+		name: e.name ?? "copy-files",
+		async transform({ filePath: t, relativePath: n }) {
+			return {
+				type: "copy",
+				fileName: e.rename ? e.rename(n, t) : n,
+				sourcePath: t
+			};
+		}
+	});
+}
+function l(e = {}) {
+	return s({
+		...e,
+		name: e.name ?? "file-transform"
+	});
+}
+function u(s, c) {
+	let l = s.__buildEntriesFilePlugin, u = l.extensions ? n(l.extensions) : null, d = l.kind === "copy" ? t(l.copyExtensions ?? {
+		input: [],
+		mergeDefault: !1
+	}) : [], f = l.test ?? ((e) => {
+		if (u) return u.test(e);
+		if (l.kind === "copy") {
+			let t = a.extname(e);
+			return l.onlyConfiguredExtensions ? d.includes(t) : t !== ".d.ts" && (!c.extensions.includes(t) || d.includes(t));
+		}
+		return !1;
+	});
+	return {
+		name: s.name,
+		apply: l.apply ?? "build",
+		enforce: l.enforce,
+		async writeBundle() {
+			let t = await r(l.input ?? c.inputPaths, l.rootDir ? a.resolve(l.rootDir) : c.rootDir, l.ignore?.input ?? c.ignorePaths, [{
+				test: f,
+				transform: l.transform ?? (() => void 0)
+			}], l.allowMissing ?? c.allowMissingInput);
+			for (let n of t) {
+				let t = l.rootDir ? a.resolve(l.rootDir) : c.rootDir, r = a.relative(t, n.filePath).split(a.sep).join("/"), s = await n.plugin.transform({
+					filePath: n.filePath,
+					relativePath: r,
+					rootDir: t,
+					outDir: c.outDir,
+					format: c.format,
+					read: () => i.readFile(n.filePath, "utf8")
+				});
+				for (let t of e(s)) t && await o({
+					...t,
+					fileName: t.fileName ?? r
+				}, c.outDir);
+			}
+		}
+	};
+}
+function d(e, t) {
+	return e.map((e) => e.__buildEntriesFilePlugin ? u(e, t) : e);
+}
+function f(e, t = []) {
+	if (Array.isArray(e)) return p(t, m(e));
+	let n = e?.input ?? [];
+	return e?.mergeDefault ?? !0 ? p(t, m(n)) : m(n);
+}
+function p(e, t) {
+	return [...t.some((e) => e?.__buildEntriesFilePlugin?.kind === "copy") ? e.filter((e) => e?.__buildEntriesFilePlugin?.kind !== "copy") : e, ...t];
+}
+function m(e) {
+	let t = [];
+	for (let n of e) if (n) {
+		if (Array.isArray(n)) {
+			t.push(...m(n));
+			continue;
+		}
+		t.push(n);
+	}
+	return t;
+}
+//#endregion
+export { s as createBuildEntriesFilePlugin, c as createCopyPlugin, l as createFilePlugin, m as flattenPluginOptions, u as hydrateFilePlugin, p as mergePlugins, f as normalizePlugins, d as prepareVitePlugins };

package/esm/scripts/vite-build/resolve.js

@@ -0,0 +1,46 @@
+import { isStringAlias as e, toArray as t } from "./utils.js";
+import { BUILTIN_MODULES as n } from "./constants.js";
+import { normalizeExtensions as r } from "./normalize.js";
+import { promises as i } from "node:fs";
+import a from "node:path";
+//#region scripts/vite-build/resolve.ts
+async function o(t, n, r, o) {
+	let s = o.find((t) => e(t) && (n === t.find || n.startsWith(`${t.find}/`))), c = (s ? a.join(s.replacement, n.slice(s.find.length).replace(/^\/+/, "")) : null) ?? a.resolve(a.dirname(t), n), l = [
+		...r.map((e) => `${c}${e}`),
+		...r.map((e) => a.join(c, `index${e}`)),
+		c
+	];
+	for (let e of l) if ((await i.stat(e).catch(() => null))?.isFile()) return e;
+	return c;
+}
+function s(e, t) {
+	let n = e.map((e) => a.resolve(t, e));
+	return (e) => {
+		let t = a.resolve(e);
+		return n.some((e) => t === e || t.startsWith(`${e}${a.sep}`));
+	};
+}
+function c(t, n) {
+	return n.some((n) => e(n) && (t === n.find || t.startsWith(`${n.find}/`)));
+}
+function l(e) {
+	return !e.startsWith(".") && !a.isAbsolute(e);
+}
+function u(e, t, n) {
+	return typeof n == "function" ? n(e, t) : typeof n == "string" ? e === n || e.startsWith(`${n}/`) : n.test(e);
+}
+function d(e, r, i = !0, a = !1) {
+	let o = t(r);
+	return (t, r) => i && n.has(t) || a && l(t) && !c(t, e) ? !0 : o.some((e) => u(t, r, e));
+}
+function f(e) {
+	let t = r(e), n = new Set(t);
+	return {
+		extensions: t,
+		test(e) {
+			return n.has(a.extname(e));
+		}
+	};
+}
+//#endregion
+export { f as createExtensionMatcher, d as createExternalPredicate, s as createIgnoreMatcher, l as isBareImport, c as matchesAlias, u as matchesExternalRule, o as resolveImportPath };

package/esm/scripts/vite-build/utils.js

@@ -0,0 +1,24 @@
+import { promises as e } from "node:fs";
+import t from "node:path";
+//#region scripts/vite-build/utils.ts
+async function n(t) {
+	try {
+		return await e.access(t), !0;
+	} catch {
+		return !1;
+	}
+}
+function r(e) {
+	return e.split(t.sep).join("/");
+}
+function i(e) {
+	return e === "" || e === "." ? "./" : e.startsWith(".") ? e : `./${e}`;
+}
+function a(e) {
+	return Array.isArray(e) ? e : e == null ? [] : [e];
+}
+function o(e) {
+	return typeof e.find == "string";
+}
+//#endregion
+export { i as ensureRelativeImportPath, o as isStringAlias, n as pathExists, a as toArray, r as toPosixPath };

package/fe/bundler/defaultAlias.js

@@ -0,0 +1,4 @@
+//#region bundler/defaultAlias.ts
+var defaultAlias_default = {};
+//#endregion
+export { defaultAlias_default as default };

package/fe/bundler/defaultRouteGuard.js

@@ -0,0 +1,4 @@
+//#region bundler/defaultRouteGuard.ts
+var defaultRouteGuard_default = {};
+//#endregion
+export { defaultRouteGuard_default as default };

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

@@ -0,0 +1,5 @@
+declare const Dashboard: {
+    (): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default Dashboard;

package/fe/frontend/apps/dash/Dashboard.js

@@ -0,0 +1,185 @@
+import { getAuthToken } from "../../src/common/auth/index.js";
+import { getText } from "../../src/common/language.js";
+import { generateMenuItemData } from "../../src/common/generateMenuData.js";
+import defaultAlias_default from "../../../bundler/defaultAlias.js";
+import { Menu } from "../../../packages/react/ui/components/Menu/Menu.js";
+import "../../../packages/react/ui/components/index.js";
+import { useModeStore } from "../../src/stores/mode.js";
+import { findMenuItem, leftSidebarBasePath } from "../../src/common/menu.js";
+import HeaderView from "../../src/components/BasePage/HeaderView.js";
+import useRouterParams from "../../src/hooks/useRouterParams.js";
+import defaultRouteGuard_default from "../../../bundler/defaultRouteGuard.js";
+import useInit from "../../../packages/react/hooks/useInit.js";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Outlet, useNavigate } from "react-router-dom";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+//#region frontend/apps/dash/Dashboard.tsx
+var normalizePathname = (pathname) => {
+	if (!pathname) return "/";
+	const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+	return normalized.length > 1 ? normalized.replace(/\/+$/, "") : normalized;
+};
+var stripCurrentBasePath = (pathname) => {
+	const normalizedPathname = normalizePathname(pathname);
+	const basePath = normalizePathname(window._basePath ?? "");
+	if (basePath === "/") return normalizedPathname;
+	if (normalizedPathname === basePath) return "/";
+	if (normalizedPathname.startsWith(`${basePath}/`)) return normalizePathname(normalizedPathname.slice(basePath.length));
+	return normalizedPathname;
+};
+var getSearchParams = (search) => new URLSearchParams(search?.replace(/^\?/, ""));
+var includesSearchParams = (expectedSearch, actualSearch) => {
+	const expectedParams = getSearchParams(expectedSearch);
+	const actualParams = getSearchParams(actualSearch);
+	for (const [key, value] of expectedParams.entries()) if (actualParams.get(key) !== value) return false;
+	return true;
+};
+var parseDashboardPath = (path) => {
+	const targetPath = path.trim();
+	if (!targetPath) return;
+	const url = new URL(targetPath, window.location.origin);
+	if (url.origin !== window.location.origin) return;
+	return {
+		pathname: stripCurrentBasePath(url.pathname),
+		search: url.search,
+		hash: url.hash
+	};
+};
+var collectRenderableMenuPaths = (menu, pathnamePrefix = "", selectedKey) => {
+	const paths = [];
+	menu.forEach((item) => {
+		if (item.menuType === "group") {
+			paths.push(...collectRenderableMenuPaths(item.subMenu ?? [], pathnamePrefix, selectedKey));
+			return;
+		}
+		if (item.moduleType === "sidebar") {
+			paths.push(...collectRenderableMenuPaths(item.sidebarConfig?.menu ?? [], `${pathnamePrefix}/${item.key}`, selectedKey ?? item.key));
+			return;
+		}
+		const menuItem = findMenuItem(menu, item.key);
+		if (menuItem?.path?.pathname) paths.push({
+			pathname: normalizePathname(`${pathnamePrefix}${menuItem.path.pathname}`),
+			search: menuItem.path.search,
+			selectedKey: selectedKey ?? item.key
+		});
+	});
+	return paths;
+};
+var getRenderableHomePage = (projectInfo) => {
+	const homePage = parseDashboardPath(projectInfo.homePage);
+	if (!homePage) return;
+	const pathnamePrefix = projectInfo.menuLayout === "top" ? "" : `/${leftSidebarBasePath}`;
+	const targetMenuPath = collectRenderableMenuPaths(projectInfo.menu, pathnamePrefix).find((item) => {
+		return item.pathname === homePage.pathname && includesSearchParams(item.search, homePage.search);
+	});
+	if (!targetMenuPath) return;
+	return {
+		pathname: homePage.pathname,
+		search: homePage.search,
+		hash: homePage.hash,
+		selectedKey: projectInfo.menuLayout === "top" ? targetMenuPath.selectedKey : void 0
+	};
+};
+var Dashboard = () => {
+	const { initModeData, initData, projectInfo } = useModeStore();
+	const HeaderUserArea = defaultAlias_default["HeaderView.userArea"];
+	useInit(() => {
+		!initData && initModeData();
+	});
+	const isInit = useRef(false);
+	const params = useRouterParams();
+	const [SK, uSK] = useState(params.key ?? params.custk);
+	const nav = useNavigate();
+	const menu = useMemo(() => {
+		if (initData && projectInfo?.menuLayout === "top") return /* @__PURE__ */ jsx(Menu, {
+			className: " w-full",
+			mode: "top",
+			items: generateMenuItemData(projectInfo.menu),
+			selectedKey: SK,
+			onSelect: (e) => {
+				uSK(e);
+				const m = findMenuItem(projectInfo.menu, e);
+				m && nav(m?.path);
+			}
+		});
+		return /* @__PURE__ */ jsx(Fragment$1, {});
+	}, [
+		initData,
+		projectInfo,
+		SK,
+		nav
+	]);
+	useEffect(() => {
+		if (initData && projectInfo) {
+			if (isInit.current) return;
+			if (typeof defaultRouteGuard_default === "function") {
+				const authToken = getAuthToken();
+				const loginUrl = defaultRouteGuard_default({
+					projectInfo,
+					params,
+					pathname: location.pathname,
+					search: location.search,
+					hash: location.hash,
+					authToken,
+					isLoggedIn: Boolean(authToken)
+				});
+				if (typeof loginUrl === "string") {
+					isInit.current = true;
+					window.location.href = loginUrl;
+					return;
+				}
+				isInit.current = true;
+				return;
+			}
+			const homePage = getRenderableHomePage(projectInfo);
+			if (homePage) {
+				homePage.selectedKey && uSK(homePage.selectedKey);
+				isInit.current = true;
+				nav(homePage, { replace: true });
+				return;
+			}
+			if (projectInfo.menuLayout !== "top") {
+				console.log("left sidebar");
+				if (Object.keys(params).length && location.pathname.includes(`/_sidebar_`)) return;
+				const m = findMenuItem(projectInfo.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(`/_sidebar_`)) {
+					const m = findMenuItem(projectInfo.menu);
+					uSK(m.key);
+					nav(m.path, { replace: true });
+				}
+			}
+			isInit.current = true;
+		}
+	}, [
+		initData,
+		projectInfo,
+		params,
+		nav
+	]);
+	const getTitle = () => {
+		const title = projectInfo?.desc ?? projectInfo?.name;
+		if (!isInit.current && title) document.title = projectInfo?.name ?? title;
+		return title ? getText(title) : void 0;
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dash-main h-screen flex flex-col overflow-hidden bg-theme-bg text-foreground",
+		children: [/* @__PURE__ */ jsx(HeaderView, {
+			icon: projectInfo?.icon,
+			title: getTitle(),
+			menu,
+			userArea: HeaderUserArea ? /* @__PURE__ */ jsx(HeaderUserArea, { projectInfo }) : void 0
+		}), /* @__PURE__ */ jsx("div", {
+			className: "dash-container min-h-0 flex-1 overflow-hidden",
+			children: /* @__PURE__ */ jsx(Outlet, {})
+		})]
+	});
+};
+Dashboard.displayName = "Dashboard";
+//#endregion
+export { Dashboard as default };

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

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

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

@@ -0,0 +1,59 @@
+import defaultAlias_default from "../../../bundler/defaultAlias.js";
+import { QK, leftSidebarBasePath } from "../../src/common/menu.js";
+import Dashboard from "./Dashboard.js";
+import { renderImportComponent } from "../../src/common/importComponent.js";
+import { initApp } from "../../src/main.js";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/apps/dash/dash.entry.tsx
+var baseRoutes = [{
+	path: "/",
+	component: /* @__PURE__ */ jsx(Dashboard, {}),
+	children: [{
+		path: `/:${QK.k}`,
+		component: renderImportComponent(import("../../src/defaultPages/SlotPage/index.js"))
+	}, {
+		path: `/ui-components`,
+		component: renderImportComponent(import("../ui-components/index.js"))
+	}]
+}];
+var sidebarRoutes = [{
+	path: `/:${QK.k}/*`,
+	component: renderImportComponent(import("../../src/defaultPages/SidebarSlotPage/index.js")),
+	children: [{
+		path: `:${QK.sk}`,
+		component: renderImportComponent(import("../../src/defaultPages/SlotPage/index.js"))
+	}]
+}, {
+	path: `/${leftSidebarBasePath}/*`,
+	component: renderImportComponent(import("../../src/defaultPages/SidebarSlotPageTmp.js")),
+	children: [{
+		path: `:${QK.sk}`,
+		component: renderImportComponent(import("../../src/defaultPages/SlotPage/index.js"))
+	}]
+}];
+var getDefaultPageRoutes = () => {
+	if (typeof defaultAlias_default === "function") {
+		const ctx = {
+			topRoutes: [],
+			sidebarRoutes: []
+		};
+		defaultAlias_default(ctx);
+		const { topRoutes: customTopRoutes, sidebarRoutes: customSidebarRoutes } = ctx;
+		baseRoutes[0]?.children?.push(...customTopRoutes);
+		sidebarRoutes.forEach((sr) => {
+			sr.children?.push(...customSidebarRoutes);
+		});
+	}
+	baseRoutes[0]?.children?.push(...sidebarRoutes);
+	return [...baseRoutes];
+};
+initApp(({ children }) => /* @__PURE__ */ jsx("div", {
+	className: "dash",
+	children
+}), {
+	routes: getDefaultPageRoutes(),
+	beforeRender: async (context) => {
+		if (typeof defaultAlias_default === "function") await defaultAlias_default(context);
+	}
+});
+//#endregion

package/fe/frontend/apps/dash/types.d.ts

@@ -0,0 +1,27 @@
+import type { ProjectInfo } from "../../src/api/baseInfo";
+import type { RouteInfo } from "../../src/components/Router";
+import type { InitAppHook } from "../../src/main";
+import type { ComponentType, LazyExoticComponent } from "react";
+export type DashRoutesContext = {
+    topRoutes: RouteInfo[];
+    sidebarRoutes: RouteInfo[];
+};
+export type DashRoutesExtender = (context: DashRoutesContext) => void;
+export type DashInit = InitAppHook;
+export type DashHeaderUserAreaProps = {
+    projectInfo: ProjectInfo | null;
+};
+export type DashComponentsMap = {
+    'HeaderView.userArea'?: ComponentType<DashHeaderUserAreaProps> | LazyExoticComponent<ComponentType<DashHeaderUserAreaProps>>;
+};
+export type DashRouteGuardContext = {
+    projectInfo: ProjectInfo;
+    params: Record<string, string | undefined>;
+    pathname: string;
+    search: string;
+    hash: string;
+    authToken: string | null;
+    isLoggedIn: boolean;
+};
+export type DashRouteGuardResult = string | undefined;
+export type DashRouteGuard = (context: DashRouteGuardContext) => DashRouteGuardResult;

package/fe/frontend/apps/ui-components/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("react/jsx-runtime").JSX.Element;
+export default _default;

package/fe/frontend/apps/ui-components/index.js

@@ -0,0 +1,8 @@
+import TestPage from "../../../packages/react/ui/components/testPage/index.js";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/apps/ui-components/index.tsx
+var ui_components_default = () => {
+	return /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx(TestPage, {}) });
+};
+//#endregion
+export { ui_components_default as default };

package/fe/frontend/apps/ui-components/ui-components.entry.d.ts

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

package/fe/frontend/apps/ui-components/ui-components.entry.js

@@ -0,0 +1,8 @@
+import { initApp } from "../../src/main.js";
+import ui_components_default from "./index.js";
+//#region frontend/apps/ui-components/ui-components.entry.tsx
+initApp(ui_components_default, {
+	initModeData: false,
+	modelType: "preview-ui"
+});
+//#endregion

package/fe/frontend/extended/SchemaForm/data.d.ts

@@ -0,0 +1,9 @@
+declare const frameComponentsMap: {
+    asyncSelect: import("react").LazyExoticComponent<(props: import("../../src/components/AsyncSelect/index").AsyncSelectProps) => import("react/jsx-runtime").JSX.Element>;
+};
+export type FrameComponentsMap = typeof frameComponentsMap;
+export type FrameComponentsMapKey = keyof FrameComponentsMap;
+export type FrameComponentPropsMap = {
+    [K in FrameComponentsMapKey]: FrameComponentsMap[K] extends React.ComponentType<infer P> ? P : never;
+};
+export default frameComponentsMap;

package/fe/frontend/extended/SchemaForm/data.js

@@ -0,0 +1,8 @@
+import { lazy } from "react";
+//#region frontend/extended/SchemaForm/data.ts
+/**
+* @type {SchemaFormComponentsMap}
+*/
+var frameComponentsMap = { asyncSelect: lazy(async () => await import("../../src/components/AsyncSelect/index.js")) };
+//#endregion
+export { frameComponentsMap as default };

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

@@ -0,0 +1,30 @@
+import type { MBMenuType } from "../../../model/types/model";
+type ProjectMenuType = MBMenuType;
+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 getProjectData: (key: string) => Promise<ProjectInfo | null>;
+export {};

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

@@ -0,0 +1,14 @@
+import { get } from "../common/request.js";
+//#region frontend/src/api/baseInfo.ts
+var getModelList = async () => {
+	const res = await get("/project/model_list");
+	if (res.data.code === 0) return res.data.data;
+	return [];
+};
+var getProjectData = async (key) => {
+	const res = await get(`/project/${key}`);
+	if (res.data.code === 0) return res.data.data;
+	return null;
+};
+//#endregion
+export { getModelList, getProjectData };

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

@@ -0,0 +1,2 @@
+export { default } from "../../../../packages/common/http/index";
+export * from "../../../../packages/common/http/index";

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

@@ -0,0 +1,2 @@
+import FetchAxios, { axios, createInstance } from "../../../../packages/common/http/index.js";
+export { FetchAxios, axios, createInstance, FetchAxios as default };

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

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

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

@@ -0,0 +1,2 @@
+import FetchAxios, { axios, createInstance } from "../../../../packages/common/http/index.js";
+export { FetchAxios, axios, createInstance };