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

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

@@ -1,33 +1,40 @@
-import { TopMenuType, LeftMenuType } from "./menuType";
+import { LeftMenuType, TopMenuType } from "./menuType";
 type MTopMenuType = {
     /**
      * 默认为 left
      */
-    menuLayout: "top";
+    menuLayout: 'top';
     menu: TopMenuType[];
 };
 type MLeftMenuType = {
     /**
      * 默认为 left
      */
-    menuLayout?: "left";
+    menuLayout?: 'left';
     menu: LeftMenuType[];
 };
-export type ModeMenuType = MTopMenuType | MLeftMenuType;
-export type ModelDataType = {
+export type MBMenuType = MTopMenuType | MLeftMenuType;
+export interface ModelModeMap {
+    MB: MBMenuType;
+}
+export type ModelMode = Extract<keyof ModelModeMap, string>;
+type ModelBaseDataType<M extends ModelMode> = {
     /**
      * - 使用哪一块的模型数据 内置 MB
      * 	- MB = 管理后台
      */
-    mode: "MB";
+    mode: M;
     key?: string;
-    name: string;
-    desc: string;
-    icon: string;
+    name?: string;
+    desc?: string;
+    icon?: string;
     /**
-     * 首页(项目配置)
+     * 首页(项目配置) 不配置 会自动找寻第一个可用路由地址
      */
-    homePage: string;
-} & ModeMenuType;
+    homePage?: string;
+};
+export type ModelDataType<M extends ModelMode = ModelMode> = {
+    [K in M]: ModelBaseDataType<K> & ModelModeMap[K];
+}[M];
 export {};
 //# sourceMappingURL=model.d.ts.map

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

@@ -1,47 +1,43 @@
-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);
-    }
-}
+//#region packages/common/cache/LRUCache.ts
+var LRUCache = class {
+	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 = /* @__PURE__ */ new Map();
+	}
+	get size() {
+		return this.data.size;
+	}
+	has(k) {
+		return this.data.has(k);
+	}
+	get(k) {
+		if (!this.data.has(k)) return void 0;
+		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 !== void 0) this.data.delete(firstKey);
+	}
+	updateSorting(k, v) {
+		this.data.delete(k);
+		this.data.set(k, v);
+	}
+};
+//#endregion
+export { LRUCache };

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

@@ -1,24 +1,8 @@
-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;
-};
+//#region packages/common/guards/index.ts
+var isPlainObject = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+//#endregion
+export { isPlainObject };

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

@@ -0,0 +1,90 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export type HttpHeaders = Record<string, string>;
+export type RequestCredentials = 'omit' | 'same-origin' | 'include';
+export type RequestCache = 'default' | 'force-cache' | 'no-cache' | 'no-store' | 'only-if-cached' | 'reload';
+export type RequestRedirect = 'error' | 'follow' | 'manual';
+export type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export interface HeadersLike {
+    forEach(callback: (value: string, key: string) => void): void;
+    has(name: string): boolean;
+    set(name: string, value: string): void;
+}
+export interface ProgressEventLike {
+    loaded?: number;
+    total?: number;
+    lengthComputable?: boolean;
+}
+export type RequestBodyLike = string | ArrayBuffer | ArrayBufferView | object;
+export interface RequestConfig<D = unknown> {
+    url?: string;
+    method?: HttpMethod;
+    baseURL?: string;
+    headers?: HttpHeaders;
+    params?: Record<string, string | number | boolean | undefined | null>;
+    data?: D;
+    timeout?: number;
+    signal?: unknown;
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    redirect?: RequestRedirect;
+    referrer?: string;
+    referrerPolicy?: ReferrerPolicy;
+    transformRequest?: ((data: D, headers: HeadersLike) => D | RequestBodyLike) | ((data: D, headers: HeadersLike) => D | RequestBodyLike)[];
+    transformResponse?: ((data: unknown) => unknown) | ((data: unknown) => unknown)[];
+    validateStatus?: (status: number) => boolean;
+    onUploadProgress?: (progress: ProgressEventLike) => void;
+    onDownloadProgress?: (progress: ProgressEventLike) => void;
+}
+export interface ResponseConfig<T = unknown, D = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: HttpHeaders;
+    config: RequestConfig<D>;
+    request?: unknown;
+}
+export interface AxiosError<T = unknown, D = unknown> extends Error {
+    config: RequestConfig<D>;
+    code?: string;
+    request?: unknown;
+    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 applyRequestInterceptors;
+    private applyResponseInterceptors;
+    private applyResponseErrorInterceptors;
+    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=index.d.ts.map

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

@@ -0,0 +1,300 @@
+//#region packages/common/http/index.ts
+var getGlobalValue = (key) => {
+	return globalThis[key];
+};
+var getTimerGlobal = () => {
+	return globalThis;
+};
+var FallbackHeaders = class {
+	headers = /* @__PURE__ */ new Map();
+	constructor(init = {}) {
+		Object.entries(init).forEach(([key, value]) => {
+			this.set(key, value);
+		});
+	}
+	forEach(callback) {
+		this.headers.forEach((value, key) => {
+			callback(value, key);
+		});
+	}
+	has(name) {
+		return this.headers.has(this.normalizeName(name));
+	}
+	set(name, value) {
+		this.headers.set(this.normalizeName(name), value);
+	}
+	toRecord() {
+		return Object.fromEntries(this.headers);
+	}
+	normalizeName(name) {
+		return name.toLowerCase();
+	}
+};
+var InterceptorManager = class {
+	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((handler) => handler.id === id);
+		if (idx !== -1) this.handlers.splice(idx, 1);
+	}
+	clear() {
+		this.handlers = [];
+	}
+	getHandlers() {
+		return [...this.handlers];
+	}
+};
+function createHeaders(headers) {
+	const HeadersRef = getGlobalValue("Headers");
+	if (HeadersRef) return new HeadersRef(headers);
+	return new FallbackHeaders(headers);
+}
+function toFetchHeaders(headers) {
+	return headers instanceof FallbackHeaders ? headers.toRecord() : headers;
+}
+function serializeParams(params) {
+	const URLSearchParamsRef = getGlobalValue("URLSearchParams");
+	if (URLSearchParamsRef) {
+		const searchParams = new URLSearchParamsRef();
+		for (const [key, value] of Object.entries(params)) if (value !== void 0 && value !== null) searchParams.append(key, String(value));
+		return searchParams.toString();
+	}
+	return Object.entries(params).filter((entry) => entry[1] !== void 0 && entry[1] !== null).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+}
+function buildURL(url, baseURL, params) {
+	let fullUrl = baseURL ? `${baseURL.replace(/\/+$/, "")}/${url.replace(/^\/+/, "")}` : url;
+	if (params) {
+		const query = serializeParams(params);
+		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 isRuntimeInstance(value, ctorName) {
+	const RuntimeCtor = getGlobalValue(ctorName);
+	return typeof RuntimeCtor === "function" && value instanceof RuntimeCtor;
+}
+function isBodyLike(value) {
+	if (typeof value === "string") return true;
+	if (value instanceof ArrayBuffer) return true;
+	if (ArrayBuffer.isView(value)) return true;
+	return isRuntimeInstance(value, "Blob") || isRuntimeInstance(value, "FormData") || isRuntimeInstance(value, "URLSearchParams") || isRuntimeInstance(value, "ReadableStream");
+}
+function applyTransformers(value, transformers) {
+	if (!transformers?.length) return value;
+	return transformers.reduce((acc, fn) => fn(acc), value);
+}
+function applyRequestTransformers(value, headers, transformers) {
+	if (!transformers) return value;
+	return (Array.isArray(transformers) ? transformers : [transformers]).reduce((acc, fn) => fn(acc, headers), value);
+}
+function getFetch() {
+	const fetchRef = getGlobalValue("fetch");
+	if (!fetchRef) throw new Error("FetchAxios requires globalThis.fetch. Use Node.js 18+ or provide a fetch polyfill.");
+	return fetchRef;
+}
+function createAbortController() {
+	const AbortControllerRef = getGlobalValue("AbortController");
+	if (!AbortControllerRef) return void 0;
+	return new AbortControllerRef();
+}
+var FetchAxios = class {
+	defaults;
+	interceptors = {
+		request: new InterceptorManager(),
+		response: new InterceptorManager()
+	};
+	constructor(config = {}) {
+		this.defaults = config;
+	}
+	async request(config) {
+		const merged = mergeConfig(this.defaults, config);
+		try {
+			const currentConfig = await this.applyRequestInterceptors(merged);
+			const response = await this._doRequest(currentConfig);
+			return this.applyResponseInterceptors(response);
+		} catch (err) {
+			return this.applyResponseErrorInterceptors(err);
+		}
+	}
+	async applyRequestInterceptors(config) {
+		let currentConfig = config;
+		const handlers = this.interceptors.request.getHandlers().reverse();
+		for (const handler of handlers) {
+			if (!handler.fulfilled) continue;
+			try {
+				currentConfig = await handler.fulfilled(currentConfig);
+			} catch (err) {
+				if (!handler.rejected) throw err;
+				currentConfig = await handler.rejected(err);
+			}
+		}
+		return currentConfig;
+	}
+	async applyResponseInterceptors(response) {
+		let currentResponse = response;
+		for (const handler of this.interceptors.response.getHandlers()) {
+			if (!handler.fulfilled) continue;
+			currentResponse = await handler.fulfilled(currentResponse);
+		}
+		return currentResponse;
+	}
+	async applyResponseErrorInterceptors(error) {
+		let currentError = error;
+		for (const handler of this.interceptors.response.getHandlers()) {
+			if (!handler.rejected) continue;
+			try {
+				return await handler.rejected(currentError);
+			} catch (err) {
+				currentError = err;
+			}
+		}
+		throw currentError;
+	}
+	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 = createHeaders(rawHeaders);
+		let requestData = data;
+		if (transformRequest && (method === "POST" || method === "PUT" || method === "PATCH")) {
+			requestData = applyRequestTransformers(data, requestHeaders, transformRequest);
+			if ((isObject(requestData) || Array.isArray(requestData)) && !requestHeaders.has("Content-Type")) requestHeaders.set("Content-Type", "application/json");
+		}
+		const init = {
+			method,
+			headers: toFetchHeaders(requestHeaders),
+			credentials: credentials ?? "same-origin",
+			cache,
+			redirect,
+			referrer,
+			referrerPolicy
+		};
+		if (requestData !== void 0 && method !== "GET" && method !== "HEAD") init.body = isBodyLike(requestData) ? requestData : JSON.stringify(requestData);
+		const controller = config.signal ? void 0 : createAbortController();
+		init.signal = config.signal ?? controller?.signal;
+		let timeoutId;
+		if (timeout) {
+			if (!controller && !config.signal) throw this.createError(/* @__PURE__ */ new Error("FetchAxios timeout requires globalThis.AbortController."), "ERR_ABORT_CONTROLLER_UNAVAILABLE", config);
+			const timer = getTimerGlobal();
+			if (!timer.setTimeout || !timer.clearTimeout) throw this.createError(/* @__PURE__ */ new Error("FetchAxios timeout requires globalThis.setTimeout and globalThis.clearTimeout."), "ERR_TIMER_UNAVAILABLE", config);
+			timeoutId = timer.setTimeout(() => controller?.abort(), timeout);
+		}
+		let response;
+		try {
+			response = await getFetch()(url, init);
+		} catch (err) {
+			if (timeoutId) getTimerGlobal().clearTimeout?.(timeoutId);
+			throw this.createError(err instanceof Error ? err : new Error(String(err)), "ECONNABORTED", config);
+		}
+		if (timeoutId) getTimerGlobal().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;
+			responseConfig.data = transformResponse ? applyTransformers(parsed, Array.isArray(transformResponse) ? transformResponse : [transformResponse]) : parsed;
+			return responseConfig;
+		}
+		const rawData = response.body ? await response.text() : null;
+		responseConfig.data = rawData ? JSON.parse(rawData) : null;
+		throw this.createError(/* @__PURE__ */ new Error(`Request failed with status ${response.status}`), void 0, config, responseConfig);
+	}
+	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"
+		});
+	}
+};
+var axios = new FetchAxios();
+var createInstance = (defaultConfig) => new FetchAxios(defaultConfig);
+//#endregion
+export { axios, createInstance, FetchAxios as default };