@_tc/template-core 0.0.1-bate.9 → 0.0.2

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

@@ -0,0 +1,7 @@
+import type { SchemaFormAllPropsMap, FormFieldType } from '../../../packages/ui/react';
+export type SearchOption = {
+    [K in FormFieldType]: {
+        comType: K;
+    } & (K extends keyof SchemaFormAllPropsMap ? SchemaFormAllPropsMap[K] : unknown);
+}[FormFieldType];
+//# 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;
+};

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,310 @@
+const getGlobalValue = (key) => {
+    return globalThis[key];
+};
+const getTimerGlobal = () => {
+    return globalThis;
+};
+class FallbackHeaders {
+    headers = 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();
+    }
+}
+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((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 !== undefined && value !== null) {
+                searchParams.append(key, String(value));
+            }
+        }
+        return searchParams.toString();
+    }
+    return Object.entries(params)
+        .filter((entry) => entry[1] !== undefined && 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;
+    const fns = Array.isArray(transformers) ? transformers : [transformers];
+    return fns.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 undefined;
+    return new AbortControllerRef();
+}
+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);
+        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 !== undefined && method !== 'GET' && method !== 'HEAD') {
+            init.body = isBodyLike(requestData) ? requestData : JSON.stringify(requestData);
+        }
+        const controller = config.signal ? undefined : createAbortController();
+        init.signal = config.signal ?? controller?.signal;
+        let timeoutId;
+        if (timeout) {
+            if (!controller && !config.signal) {
+                throw this.createError(new Error('FetchAxios timeout requires globalThis.AbortController.'), 'ERR_ABORT_CONTROLLER_UNAVAILABLE', config);
+            }
+            const timer = getTimerGlobal();
+            if (!timer.setTimeout || !timer.clearTimeout) {
+                throw this.createError(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);
+            const error = this.createError(err instanceof Error ? err : new Error(String(err)), 'ECONNABORTED', config);
+            throw error;
+        }
+        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;
+            const transformedData = transformResponse
+                ? applyTransformers(parsed, Array.isArray(transformResponse) ? transformResponse : [transformResponse])
+                : parsed;
+            responseConfig.data = transformedData;
+            return responseConfig;
+        }
+        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;