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

package/fe/frontend/src/stores/schemaStore.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentConfig, ComponentType, SearchConfig, StoreSchemaType, TableConfig } from "../defaultPages/SchemaPage/schemaType";
+import type { TableSearchSchema } from "../../../packages/react/ui/components/TableSearch/TableSearch";
+import type { MOmit } from "../../../typings/type";
+import { LRUCache } from "../../../packages/common/index";
+interface FunctionalData {
+    api: string;
+    components: ComponentType<ComponentConfig>;
+    tableSchema: StoreSchemaType;
+    tableConfig: TableConfig;
+    searchSchema: StoreSchemaType;
+    searchConfig: SearchConfig;
+}
+interface ComSchemaCache {
+    searchSchema: TableSearchSchema<Record<string, any>>[];
+}
+interface SchemaStoreState extends Partial<FunctionalData> {
+    readonly schemaStoreAvailable: boolean;
+    readonly schemaCache: LRUCache<FunctionalData>;
+    readonly comSchemaCache: LRUCache<ComSchemaCache>;
+}
+interface SchemaStoreActions {
+    setSchemaState: (data: Partial<MOmit<SchemaStoreState, 'schemaStoreAvailable' | 'schemaCache'>>) => void;
+    updateSchemaCache: (data: FunctionalData & {
+        schemaKey: string;
+    }) => void;
+    updateComSchemaCache: (data: ComSchemaCache & {
+        schemaKey: string;
+    }) => void;
+}
+export declare const schemaStore: import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>;
+export declare const useSchemaStore: import("../../../packages/react/ui/index").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
+export {};

package/fe/frontend/src/stores/schemaStore.js

@@ -0,0 +1,28 @@
+import { createStoreHook } from "../../../packages/react/ui/lib/createStoreHook.js";
+import "../../../packages/react/ui/index.js";
+import { LRUCache } from "../../../packages/common/cache/LRUCache.js";
+import { createStore } from "zustand";
+//#region frontend/src/stores/schemaStore.ts
+var schemaStore = createStore((set, get) => ({
+	api: "",
+	schemaStoreAvailable: false,
+	schemaCache: new LRUCache(5),
+	comSchemaCache: new LRUCache(5),
+	setSchemaState: (state) => {
+		set({ ...state });
+		set({ schemaStoreAvailable: !!get().api });
+	},
+	updateSchemaCache: (data) => {
+		const { schemaKey, ...params } = data;
+		const { schemaCache } = get();
+		schemaCache.set(schemaKey, params);
+	},
+	updateComSchemaCache: (data) => {
+		const { schemaKey, ...params } = data;
+		const { comSchemaCache } = get();
+		comSchemaCache.set(schemaKey, params);
+	}
+}));
+var useSchemaStore = createStoreHook(schemaStore);
+//#endregion
+export { schemaStore, useSchemaStore };

package/fe/frontend/src/typing/scalability.d.ts

@@ -0,0 +1,15 @@
+import type { FrameComponentPropsMap, FrameComponentsMap } from "../../extended/SchemaForm/data";
+import type { SelectProps } from "../../../packages/react/ui/index";
+declare module '../../../packages/react/ui/index' {
+    namespace SchemaFormNamespace {
+        interface FieldTypes extends FrameComponentsMap {
+        }
+        interface PropsMap extends FrameComponentPropsMap {
+        }
+    }
+}
+export type SchemaFormFrameSelectProps = SelectProps & {
+    requestUrl?: string;
+    valueField?: string;
+    labelField?: string;
+};

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

@@ -0,0 +1,8 @@
+export {};
+declare global {
+    interface Window {
+        _basePath: string;
+        _projKey: string;
+        _signKey: string;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { ButtonProps } from "../../../packages/react/ui/index";
+import { ComponentNames } from "./component";
+type ButtonTemplates = {
+    label?: string;
+} & ButtonProps;
+type ParamsValueData = '$schema::tableKey' | string | number;
+type RemoveBtn = {
+    eventKey: 'remove';
+    eventOption: {
+        params: {
+            [paramKey: string]: ParamsValueData;
+        };
+    };
+};
+type HandlerBtn = {
+    eventKey: 'callComponent';
+    eventOption: {
+        comName: ComponentNames;
+    };
+};
+export type BaseButton = ButtonTemplates & (RemoveBtn | HandlerBtn);
+export {};

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

@@ -0,0 +1,30 @@
+import type { BuiltInCallComConfigMap } from "../../../frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn";
+import type { FormFieldType, FormItemProps, SchemaFormAllPropsMap } from "../../../packages/react/ui/index";
+export type { BuiltInCallComConfigMap, BuiltInCallComNames } from "../../../frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn";
+export declare namespace CallComNamespace {
+    interface ConfigMap {
+    }
+    interface OptionMap {
+    }
+}
+export type ComponentConfig = BuiltInCallComConfigMap & Partial<CallComNamespace.ConfigMap>;
+export type ComponentNames = Extract<keyof ComponentConfig, string>;
+type FormComponentOption = FormItemProps & {
+    visible?: boolean;
+    disabled?: boolean;
+    default?: any;
+} & ComponentOption;
+export type BuiltInCallComOptionMap = {
+    createForm: FormComponentOption;
+    editForm: FormComponentOption;
+    detailPanel: {};
+};
+export type ComponentsOption = BuiltInCallComOptionMap & Partial<{
+    [K in Exclude<ComponentNames, keyof BuiltInCallComOptionMap>]: K extends keyof CallComNamespace.OptionMap ? CallComNamespace.OptionMap[K] : Record<string, unknown>;
+}>;
+export type ComponentFieldOption<N extends ComponentNames> = N extends keyof BuiltInCallComOptionMap ? BuiltInCallComOptionMap[N] : N extends keyof CallComNamespace.OptionMap ? CallComNamespace.OptionMap[N] : Record<string, unknown>;
+export type ComponentOption = {
+    [K in FormFieldType]: {
+        comType: K;
+    } & (K extends keyof SchemaFormAllPropsMap ? SchemaFormAllPropsMap[K] : unknown);
+}[FormFieldType];

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

@@ -0,0 +1,7 @@
+export type FetchInfo = {
+    fetchKey: string;
+    fetchConfig?: {
+        url: string;
+        method?: 'get' | 'post';
+    };
+};

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

@@ -0,0 +1,46 @@
+import { TableColumnDef } from "../../../packages/react/ui/index";
+import type { JSONSchema7 } from "json-schema";
+import { MOmit } from "../../../typings/type";
+import { BaseButton } from "./button";
+import { ComponentConfig, ComponentNames, ComponentsOption } from "./component";
+import { SearchOption } from "./search";
+export type TableColumnsSchema = {
+    tableOption?: MOmit<TableColumnDef, 'key' | 'title'> & {
+        visible?: boolean;
+        toFixed?: number;
+    };
+};
+export type TableSearchOption = {
+    searchOption?: {
+        default?: any;
+    } & SearchOption;
+};
+export type TableConfig = {
+    headerButtons?: BaseButton[];
+    rowButtons?: BaseButton[];
+};
+export type SearchConfig = {};
+export type BaseOption<O> = {
+    option: O;
+};
+export type UsedConfigSchema<T = {}> = {
+    type: 'object' | 'string' | 'array' | 'number' | 'boolean';
+    properties: {
+        [key: string]: T & MOmit<UsedConfigSchema, 'properties'> & {
+            label: string;
+            level?: number;
+        };
+    };
+    required?: string[];
+} & Omit<JSONSchema7, 'properties'>;
+export type TableComponentConfig = {
+    [K in ComponentNames as `${K & string}Option`]?: ComponentsOption[K];
+};
+export type ConfigSchema = UsedConfigSchema<TableColumnsSchema & TableSearchOption & TableComponentConfig>;
+export interface SchemaDataType {
+    api: string;
+    schema?: ConfigSchema;
+    tableConfig?: TableConfig;
+    searchConfig?: SearchConfig;
+    componentConfig?: ComponentConfig;
+}

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

@@ -0,0 +1,6 @@
+import type { SchemaFormAllPropsMap, FormFieldType } from "../../../packages/react/ui/index";
+export type SearchOption = {
+    [K in FormFieldType]: {
+        comType: K;
+    } & (K extends keyof SchemaFormAllPropsMap ? SchemaFormAllPropsMap[K] : unknown);
+}[FormFieldType];

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

@@ -0,0 +1,2 @@
+export type { MBMenuType, ModelDataType, ModelMode, ModelModeMap } from "./model";
+export type { BuiltInCallComConfigMap, BuiltInCallComNames, BuiltInCallComOptionMap, CallComNamespace, ComponentConfig, ComponentFieldOption, ComponentNames, ComponentsOption, } from "./data/component";

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

@@ -0,0 +1,43 @@
+import { SchemaDataType } from "./data/schema";
+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";
+}
+interface IframeModuleType {
+    moduleType: "iframe";
+    iframeConfig: {
+        path: string;
+    };
+}
+interface CustomModuleType {
+    moduleType: "custom";
+    customConfig: {
+        path: string;
+    };
+}
+interface SchemaModuleType {
+    moduleType: "schema";
+    schemaConfig: SchemaDataType;
+}
+export interface SidebarModuleType {
+    moduleType: "sidebar";
+    sidebarConfig: {
+        menu: BaseMenuType[];
+        menuLayout?: "left";
+    };
+}
+export type BasicModuleType = SchemaModuleType | CustomModuleType | IframeModuleType;
+export type BaseMenuType = GroupMenuType<"left"> | (ModuleMenuType & BasicModuleType);
+type ModuleType = BasicModuleType | SidebarModuleType;
+export type TopMenuType = GroupMenuType<"top"> | (ModuleMenuType & ModuleType);
+export type LeftMenuType = GroupMenuType<"left"> | BaseMenuType;
+export {};

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

@@ -0,0 +1,26 @@
+import { LeftMenuType, TopMenuType } from "./menuType";
+type MTopMenuType = {
+    menuLayout: 'top';
+    menu: TopMenuType[];
+};
+type MLeftMenuType = {
+    menuLayout?: 'left';
+    menu: LeftMenuType[];
+};
+export type MBMenuType = MTopMenuType | MLeftMenuType;
+export interface ModelModeMap {
+    MB: MBMenuType;
+}
+export type ModelMode = Extract<keyof ModelModeMap, string>;
+type ModelBaseDataType<M extends ModelMode> = {
+    mode: M;
+    key?: string;
+    name?: string;
+    desc?: string;
+    icon?: string;
+    homePage?: string;
+};
+export type ModelDataType<M extends ModelMode = ModelMode> = {
+    [K in M]: ModelBaseDataType<K> & ModelModeMap[K];
+}[M];
+export {};

package/fe/packages/common/LRUCache.d.ts

@@ -0,0 +1 @@
+export { LRUCache } from "./cache/LRUCache";

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

@@ -0,0 +1,6 @@
+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[][];

package/fe/packages/common/cache/LRUCache.d.ts

@@ -0,0 +1,12 @@
+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;
+}

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

@@ -0,0 +1,43 @@
+//#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/cache/index.d.ts

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

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

@@ -0,0 +1,8 @@
+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;

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

@@ -0,0 +1,8 @@
+//#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,89 @@
+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;