@_tc/template-core 0.0.1-bate.46 → 0.0.1-bate.48

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

@@ -2,7 +2,7 @@
  * @type {SchemaFormComponentsMap}
  */
 declare const frameComponentsMap: {
-    asyncSelect: import("react").LazyExoticComponent<(props: import("../../components/AsyncSelect").AsyncSelectProps) => import("react/jsx-runtime").JSX.Element>;
+    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;

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

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

package/fe/frontend/{widgets → src}/api/baseInfo.d.ts

@@ -1,5 +1,5 @@
-import type { ModeMenuType } from '../../../model/types/model';
-type ProjectMenuType = ModeMenuType;
+import type { MBMenuType } from "../../../model/types/model";
+type ProjectMenuType = MBMenuType;
 export type ModelInfo = {
     model: {
         key: string;

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,3 @@
+export { default } from "../../../../packages/common/http/index";
+export * from "../../../../packages/common/http/index";
+//# sourceMappingURL=CRUD.d.ts.map

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,2 @@
+export * from "./CRUD";
+//# sourceMappingURL=index.d.ts.map

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 };

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

@@ -0,0 +1,21 @@
+//#region frontend/src/common/auth/index.ts
+var AUTH_LOCAL_KEY = "auth_token";
+var API_AUTH_LOCAL_KEY = "p_J_k";
+var AUTH_HEADER_KEY = "Authorization";
+async function getAuthToken() {
+	if (typeof localStorage === "undefined") return null;
+	return localStorage.getItem(AUTH_LOCAL_KEY);
+}
+async function clearAuthToken() {
+	if (typeof localStorage === "undefined") return;
+	localStorage.removeItem(AUTH_LOCAL_KEY);
+}
+var API_AUTH_HEADER_KEY = "projk";
+var getApiAuth = () => {
+	return localStorage.getItem(API_AUTH_LOCAL_KEY) ?? "";
+};
+var setApiAuth = (v) => {
+	return localStorage.setItem(API_AUTH_LOCAL_KEY, v);
+};
+//#endregion
+export { API_AUTH_HEADER_KEY, AUTH_HEADER_KEY, clearAuthToken, getApiAuth, getAuthToken, setApiAuth };

package/fe/frontend/{widgets/defaultPages/Schema/utils → src/common}/fetchErrorShow.d.ts

@@ -1,3 +1,3 @@
-import type { BaseResponse, ResponseConfig } from '../../../../widgets/common/request';
+import type { BaseResponse, ResponseConfig } from "./request";
 export declare const handlingRequestErrors: <D>(data: Promise<ResponseConfig<BaseResponse<D>, any>>) => Promise<ResponseConfig<BaseResponse<D>, any>>;
 //# sourceMappingURL=fetchErrorShow.d.ts.map

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

@@ -0,0 +1,11 @@
+import { getText } from "./language.js";
+import { message } from "../../../packages/react/ui/components/Message/MessageManager.js";
+import "../../../packages/react/ui/components/index.js";
+//#region frontend/src/common/fetchErrorShow.ts
+var handlingRequestErrors = async (data) => {
+	const res = await data;
+	if (res.data.code !== 0) message.error(getText(res.data.message));
+	return res;
+};
+//#endregion
+export { handlingRequestErrors };

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

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

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

@@ -0,0 +1,16 @@
+import { getText } from "./language.js";
+//#region frontend/src/common/generateMenuData.ts
+var generateMenuItemData = (data) => {
+	return data.map((m) => {
+		const children = m.menuType === "group" && m.subMenu.length ? generateMenuItemData(m.subMenu) : void 0;
+		return {
+			key: m.key,
+			label: getText(m.name),
+			icon: m.icon,
+			children,
+			minWidth: 100
+		};
+	});
+};
+//#endregion
+export { generateMenuItemData };

package/fe/frontend/{widgets → src}/common/importComponent.d.ts

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

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

@@ -0,0 +1,23 @@
+import { Skeleton } from "../../../packages/react/ui/components/Skeleton/Skeleton.js";
+import "../../../packages/react/ui/components/index.js";
+import { Suspense, lazy } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/common/importComponent.tsx
+var PageLoading = () => {
+	return /* @__PURE__ */ jsx("div", {
+		className: "h-full min-h-[240px] w-full overflow-hidden bg-theme-bg",
+		children: /* @__PURE__ */ jsx(Skeleton, {
+			mode: "pageloading",
+			rows: 5
+		})
+	});
+};
+var renderImportComponent = (c, fallback) => {
+	const Component = lazy(() => c);
+	return /* @__PURE__ */ jsx(Suspense, {
+		fallback: typeof fallback !== "undefined" ? fallback : /* @__PURE__ */ jsx(PageLoading, {}),
+		children: /* @__PURE__ */ jsx(Component, {})
+	});
+};
+//#endregion
+export { renderImportComponent };

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

@@ -0,0 +1,3 @@
+import type { I18nInterpolationValues, I18nTranslateOptions } from "../../../packages/react/ui/i18n/index";
+export declare const getText: (key: string, fillingData?: I18nInterpolationValues, options?: I18nTranslateOptions) => string;
+//# sourceMappingURL=language.d.ts.map

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

@@ -0,0 +1,12 @@
+import { frontendI18nResources, i18nKeyPrefix } from "../language/index.js";
+import { i18n, i18nStore } from "../../../packages/common/i18n/index.js";
+import "../../../packages/react/ui/i18n/index.js";
+//#region frontend/src/common/language.ts
+i18nStore.getState().addResources("zh-CN", frontendI18nResources["zh-CN"] ?? {});
+i18nStore.getState().addResources("en-US", frontendI18nResources["en-US"] ?? {});
+var getText = (key, fillingData, options) => {
+	if (key.includes("$i18n::")) return i18n(key.replace(i18nKeyPrefix, ""), fillingData, options);
+	return key;
+};
+//#endregion
+export { getText };

package/fe/frontend/{widgets → src}/common/logFn/index.d.ts

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

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

@@ -0,0 +1,14 @@
+import { frontendLangKeys } from "../../language/index.js";
+import { getText } from "../language.js";
+//#region frontend/src/common/logFn/index.ts
+var logJoin = (...logs) => logs.join(`
+    ---------
+    `);
+var logPageNotFound = () => {
+	console.error(logJoin(getText(frontendLangKeys.logPageNotFound), getText(frontendLangKeys.logPageNotFoundEn)));
+};
+var logIllegalComponentCallback = (comName) => console.error(logJoin(getText(frontendLangKeys.logIllegalComponentCallback, { comName }), getText(frontendLangKeys.logIllegalComponentCallbackEn, { comName })));
+var logSubscriptionError = () => console.error(logJoin(getText(frontendLangKeys.logSubscriptionError), getText(frontendLangKeys.logSubscriptionErrorEn)));
+var logApiTamper = () => console.error(logJoin(getText(frontendLangKeys.logApiTamper), getText(frontendLangKeys.logApiTamperEn)));
+//#endregion
+export { logApiTamper, logIllegalComponentCallback, logPageNotFound, logSubscriptionError };

package/fe/frontend/{widgets → src}/common/menu.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectInfo } from "../../widgets/api/baseInfo";
+import type { ProjectInfo } from "../api/baseInfo";
 type MenuItem = {
     key: string;
     name: string;

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

@@ -0,0 +1,97 @@
+import { modeStore } from "../stores/mode.js";
+//#region frontend/src/common/menu.ts
+var QK = /* @__PURE__ */ function(QK) {
+	/**
+	* project key
+	*/
+	QK["pk"] = "projk";
+	/**
+	* key topMenu key
+	*/
+	QK["k"] = "key";
+	/**
+	* sidebar key leftMenu key
+	*/
+	QK["sk"] = "sidek";
+	/**
+	* 自定义 页面的key
+	*/
+	QK["ck"] = "custk";
+	return QK;
+}({});
+var leftSidebarBasePath = "_sidebar_";
+var deserializationUrlSearch = (url = window.location.search) => {
+	const urls = new URLSearchParams(url);
+	const data = {};
+	for (const [k, v] of urls.entries()) data[k] = v;
+	return data;
+};
+var serializationUrl = (url, data) => `${url}?${new URLSearchParams(data).toString()}`;
+var generateMenuItem = (item) => {
+	let data = void 0;
+	if (item.menuType === "module") {
+		const pk = modeStore.getState().projectInfo?.key;
+		const query = { [QK.pk]: pk };
+		switch (item.moduleType) {
+			case "custom":
+				query[QK.ck] = item.key;
+				data = {
+					...item,
+					path: {
+						pathname: item.customConfig.path,
+						search: new URLSearchParams(query).toString()
+					}
+				};
+				break;
+			case "iframe":
+			case "schema":
+			case "sidebar":
+				let path = `/${item.key}`;
+				let search = new URLSearchParams(query).toString();
+				if (item.moduleType === "sidebar") {
+					const sfMenu = findMenuItem(item.sidebarConfig.menu, item.sidebarConfig.menu[0]?.key);
+					path += `${sfMenu.path.pathname}`;
+					search = sfMenu.path.search ?? "";
+				}
+				data = {
+					...item,
+					path: {
+						pathname: path,
+						search
+					}
+				};
+				break;
+			default: break;
+		}
+	}
+	return data;
+};
+var findMenuItem = (menuData, key) => {
+	let data = void 0;
+	const useFirstAvailableMenu = typeof key === "undefined";
+	/**
+	*  url query 分为
+	*
+	*  projk 为项目key
+	*  key  当前选择的top菜单key
+	*  sidek 为侧边栏选中的key
+	*/
+	for (const item of menuData) {
+		if (item.menuType === "module") {
+			if (useFirstAvailableMenu || item.key === key) {
+				data = generateMenuItem(item);
+				break;
+			}
+		}
+		if (item.menuType === "group") {
+			const result = findMenuItem(item.subMenu, key);
+			if (result) {
+				data = { ...result };
+				break;
+			}
+		}
+	}
+	return data;
+};
+//#endregion
+export { QK, deserializationUrlSearch, findMenuItem, leftSidebarBasePath, serializationUrl };

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

@@ -0,0 +1,37 @@
+import type { AxiosError, RequestConfig, ResponseConfig } from "../../../packages/common/http/index";
+import { FetchAxios } from "../../../packages/common/http/index";
+declare const api: FetchAxios;
+export interface PageParams {
+    page?: number;
+    pageSize?: number;
+    [key: string]: string | number | boolean | undefined | null;
+}
+export type PageResponse<T> = {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+export interface BaseResponse<T> {
+    data: T;
+    code: number;
+    message: string;
+}
+/**
+ * GET/DELETE 不发送 body；统一把 data 转到 params。
+ *  */
+export declare const get: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const post: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const put: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const patch: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const del: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export { api, FetchAxios };
+export type { AxiosError, RequestConfig, ResponseConfig };
+export declare const request: {
+    get: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    put: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    post: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    del: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    patch: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+};
+//# sourceMappingURL=request.d.ts.map

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

@@ -0,0 +1,183 @@
+import { frontendLangKeys } from "../language/index.js";
+import { getText } from "./language.js";
+import { FreezeState, apiFreezerStore } from "../stores/apiFreezer.js";
+import FetchAxios from "../../../packages/common/http/index.js";
+import { API_AUTH_HEADER_KEY, AUTH_HEADER_KEY, clearAuthToken, getApiAuth, getAuthToken } from "./auth/index.js";
+import md5 from "md5";
+//#region frontend/src/common/request.ts
+var BASE_URL = "/api";
+var NumberConcurrentCalls = 4;
+var isRequestWhitelisted = (api, params) => {
+	const { requestWhitelist } = apiFreezerStore.getState();
+	return requestWhitelist.some((matcher) => {
+		if (typeof matcher === "string") return matcher === api;
+		if (matcher instanceof RegExp) return matcher.test(api);
+		return matcher(api, params);
+	});
+};
+/**
+* 处理解冻
+* 冻结流程  4～9
+*/
+apiFreezerStore.subscribe((newState) => {
+	if (newState.state === FreezeState.Thawing) {
+		console.time("Thawing");
+		const { freezeQueue } = newState;
+		const queues = [...freezeQueue.values()];
+		freezeQueue.clear();
+		(async () => {
+			/**
+			*  生成 并发队列
+			*  每个队列从头取一个任务
+			*  当所有任务执行完后 这个 Promise.all 才会结束
+			*/
+			await Promise.all(Array.from({ length: Math.min(NumberConcurrentCalls, queues.length) }, async () => {
+				while (queues.length) {
+					const task = queues.shift();
+					if (!task) continue;
+					const { originFn, callBackFns } = task;
+					try {
+						const res = await originFn();
+						callBackFns.forEach(({ resolve }) => {
+							resolve(res);
+						});
+					} catch (error) {
+						callBackFns.forEach(({ reject }) => {
+							reject(error);
+						});
+					}
+				}
+			}));
+			apiFreezerStore.setState({ state: FreezeState.Hibernation });
+			console.timeEnd("Thawing");
+		})();
+	}
+});
+/**
+* 冻结流程 1～3
+*/
+function hijackingFn(fn) {
+	return function(...params) {
+		const { state, freezeQueue } = apiFreezerStore.getState();
+		const [api] = params;
+		if (state !== FreezeState.Freeze || isRequestWhitelisted(api, params)) return fn(...params);
+		else {
+			const key = md5(JSON.stringify(params));
+			if (!freezeQueue.has(key)) freezeQueue.set(key, {
+				originFn: () => fn(...params),
+				callBackFns: []
+			});
+			const { callBackFns } = freezeQueue.get(key);
+			return new Promise((resolve, reject) => {
+				callBackFns.push({
+					reject,
+					resolve
+				});
+			});
+		}
+	};
+}
+var api = new FetchAxios({
+	baseURL: BASE_URL,
+	timeout: 15e3,
+	credentials: "include",
+	validateStatus: (status) => status >= 200 && status < 300
+});
+var removeBaseurlFromURL = (config) => {
+	const { baseURL, url } = config;
+	if (!baseURL || !url) return;
+	const origin = typeof window === "undefined" ? "http://localhost" : window.location.origin;
+	const baseURLObject = new URL(baseURL, origin);
+	const basePath = baseURLObject.pathname.replace(/\/+$/, "");
+	const requestURL = new URL(url, baseURLObject.origin);
+	if (requestURL.origin !== baseURLObject.origin || !basePath) return;
+	if (requestURL.pathname.replace(/\/+$/, "") !== basePath && !requestURL.pathname.startsWith(`${basePath}/`)) return;
+	config.url = `${requestURL.pathname.slice(basePath.length) || "/"}${requestURL.search}${requestURL.hash}`;
+};
+api.interceptors.request.use(async (config) => {
+	removeBaseurlFromURL(config);
+	const token = await getAuthToken();
+	const aauto = getApiAuth();
+	const time = (/* @__PURE__ */ new Date()).getTime();
+	config.headers = {
+		...config.headers,
+		s_t: time + "",
+		s_sign: md5(`${window["_signKey"]}_${time}`),
+		[API_AUTH_HEADER_KEY]: aauto
+	};
+	if (token) config.headers = {
+		...config.headers,
+		[AUTH_HEADER_KEY]: `Bearer ${token}`
+	};
+	return config;
+});
+api.interceptors.request.use((config) => {
+	console.debug(`[API] ${config.method?.toUpperCase()} ${config.url}`);
+	return config;
+});
+api.interceptors.response.use((res) => res, async (err) => {
+	if (err.response?.status === 401) {
+		await clearAuthToken();
+		if (typeof window !== "undefined") window.location.href = "/login";
+	}
+	const message = extractErrorMessage(err);
+	console.error(`[API Error] ${message}`, {
+		url: err.config.url,
+		status: err.response?.status
+	});
+	return Promise.reject(err);
+});
+function extractErrorMessage(err) {
+	if (!(err instanceof Error)) return getText(frontendLangKeys.unknownError);
+	const axiosErr = err;
+	if (axiosErr.response?.data && typeof axiosErr.response.data === "object" && axiosErr.response.data !== null) {
+		const data = axiosErr.response.data;
+		if (typeof data.message === "string") return data.message;
+		if (typeof data.msg === "string") return data.msg;
+		if (Array.isArray(data.errors) && data.errors.length > 0) return String(data.errors[0]);
+	}
+	if (axiosErr.message) return axiosErr.message;
+	if (axiosErr.code === "ECONNABORTED") return getText(frontendLangKeys.requestTimedOut);
+	return getText(frontendLangKeys.networkError);
+}
+/**
+* GET/DELETE 不发送 body；统一把 data 转到 params。
+*  */
+var get = hijackingFn((url, data, config) => {
+	const getConfig = data !== void 0 && data !== null && typeof data === "object" ? {
+		...config,
+		params: {
+			...config?.params,
+			...data
+		}
+	} : config;
+	return api.get(url, getConfig);
+});
+var post = hijackingFn((url, data, config) => {
+	return api.post(url, data, config);
+});
+var put = hijackingFn((url, data, config) => {
+	return api.put(url, data, config);
+});
+var patch = hijackingFn((url, data, config) => {
+	return api.patch(url, data, config);
+});
+var del = hijackingFn((url, data, config) => {
+	const delConfig = data !== void 0 && data !== null && typeof data === "object" ? {
+		...config,
+		params: {
+			...config?.params,
+			...data
+		}
+	} : config;
+	return api.delete(url, delConfig);
+});
+var request = {
+	get,
+	put,
+	post,
+	del,
+	patch
+};
+//#endregion
+export { FetchAxios, api, del, get, patch, post, put, request };

package/fe/frontend/{components → src/components}/AsyncSelect/AsyncSelect.d.ts

@@ -1,6 +1,6 @@
-import { FetchInfo } from '../../../model/types/data/fetchInfo';
-import { SelectProps } from '../../../packages/ui/react';
-import { MergeType, MOmit } from '../../../typings/type';
+import type { MergeType, MOmit } from "../../../../typings/type";
+import { FetchInfo } from "../../../../model/types/data/fetchInfo";
+import { SelectProps } from "../../../../packages/react/ui/index";
 export interface AsyncSelectProps extends MergeType<[MOmit<FetchInfo, 'fetchKey'>, MOmit<SelectProps, 'options'>]> {
 }
 declare const AsyncSelect: (props: AsyncSelectProps) => import("react/jsx-runtime").JSX.Element;

package/fe/frontend/src/components/AsyncSelect/AsyncSelect.js

@@ -0,0 +1,35 @@
+import { Select } from "../../../../packages/react/ui/components/Select/Select.js";
+import "../../../../packages/react/ui/index.js";
+import { request } from "../../common/request.js";
+import { handlingRequestErrors } from "../../common/fetchErrorShow.js";
+import useExecuteOnce from "../../../../packages/react/hooks/useExecuteOnce.js";
+import { useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region frontend/src/components/AsyncSelect/AsyncSelect.tsx
+var AsyncSelect = (props) => {
+	const { fetchConfig, ...params } = props;
+	const [options, setOptions] = useState([]);
+	const [loading, setLoading] = useState(false);
+	useExecuteOnce(async () => {
+		if (fetchConfig) {
+			setLoading(true);
+			const { method = "get", url } = fetchConfig;
+			try {
+				const res = await handlingRequestErrors(request[method](url));
+				if (res.data.code === 0) setOptions(res.data.data.map((i) => {
+					i.searchText = i.label;
+					return i;
+				}));
+			} finally {
+				setLoading(false);
+			}
+		}
+	}, { executionPhase: "mount" });
+	return /* @__PURE__ */ jsx(Select, {
+		loading,
+		options,
+		...params
+	});
+};
+//#endregion
+export { AsyncSelect as default };

package/fe/frontend/src/components/AsyncSelect/index.d.ts

@@ -0,0 +1,4 @@
+import AsyncSelect from "./AsyncSelect";
+export * from "./AsyncSelect";
+export default AsyncSelect;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/components/AsyncSelect/index.js

@@ -0,0 +1,5 @@
+import AsyncSelect from "./AsyncSelect.js";
+//#region frontend/src/components/AsyncSelect/index.ts
+var AsyncSelect_default = AsyncSelect;
+//#endregion
+export { AsyncSelect_default as default };

package/fe/frontend/{widgets → src}/components/BasePage/HeaderView.d.ts

@@ -1,5 +1,6 @@
 import { PropsWithChildren, ReactNode } from "react";
 export interface HeaderViewProps extends PropsWithChildren {
+    icon?: ReactNode;
     menu?: ReactNode;
     title?: ReactNode;
     userArea?: ReactNode;