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

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

@@ -0,0 +1,53 @@
+import { logSubscriptionError } from "../common/logFn/index.js";
+import { createStore } from "zustand";
+//#region frontend/src/stores/schemaEventBus.ts
+var SubscribeEnum = /* @__PURE__ */ function(SubscribeEnum) {
+	SubscribeEnum["search"] = "search";
+	SubscribeEnum["table"] = "table";
+	SubscribeEnum["com"] = "com";
+	return SubscribeEnum;
+}(SubscribeEnum || {});
+var schemaEventBus = createStore((set, get) => {
+	return {
+		Subscribers: /* @__PURE__ */ new Map(),
+		subscribeCom(fn) {
+			get().Subscribers.set(fn, SubscribeEnum.com);
+		},
+		unSubscribeCom(fn) {
+			const { Subscribers } = get();
+			if (Subscribers.has(fn)) Subscribers.delete(fn);
+			else logSubscriptionError();
+		},
+		emitCom(v) {
+			get().emitCall(v, SubscribeEnum.com);
+		},
+		subscribeTable(fn) {
+			get().Subscribers.set(fn, SubscribeEnum.table);
+		},
+		unSubscribeTable(fn) {
+			const { Subscribers } = get();
+			if (Subscribers.has(fn)) Subscribers.delete(fn);
+			else logSubscriptionError();
+		},
+		emitTable(v) {
+			get().emitCall(v, SubscribeEnum.table);
+		},
+		emitCall(v, calType) {
+			const { Subscribers } = get();
+			for (const [fn, type] of Subscribers.entries()) if (calType === type) fn(v);
+		},
+		subscribeSearch(fn) {
+			get().Subscribers.set(fn, SubscribeEnum.search);
+		},
+		unSubscribeSearch(fn) {
+			const { Subscribers } = get();
+			if (Subscribers.has(fn)) Subscribers.delete(fn);
+			else logSubscriptionError();
+		},
+		emitSearch(v) {
+			get().emitCall(v, SubscribeEnum.search);
+		}
+	};
+});
+//#endregion
+export { schemaEventBus };

package/fe/frontend/{widgets/defaultPages/Schema → src}/stores/schemaStore.d.ts

@@ -1,7 +1,7 @@
-import { LRUCache } from '../../../../../packages/common/index.js';
-import { TableSearchSchema } from '../../../../../packages/ui/react/components/TableSearch/TableSearch';
-import type { MOmit } from '../../../../../typings/type';
-import type { ComponentConfig, ComponentType, SearchConfig, StoreSchemaType, TableConfig } from '../schemaType';
+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>;
@@ -42,6 +42,6 @@ interface SchemaStoreActions {
     }) => void;
 }
 export declare const schemaStore: import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>;
-export declare const useSchemaStore: import("../../../../../packages/ui/react").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
+export declare const useSchemaStore: import("../../../packages/react/ui/index").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
 export {};
 //# sourceMappingURL=schemaStore.d.ts.map

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/{typing → src/typing}/scalability.d.ts

@@ -1,12 +1,12 @@
-import type { FrameComponentPropsMap, FrameComponentsMap } from '../extended/SchemaForm/data';
-import type { SelectProps } from '../../packages/ui/react';
+import type { FrameComponentPropsMap, FrameComponentsMap } from "../../extended/SchemaForm/data";
+import type { SelectProps } from "../../../packages/react/ui/index";
 /**
  * 扩展 SchemaForm 字段类型
  *
  * 框架业务侧可以在这里扩展业务特定的表单组件类型。
  * 消费方也可以在自己的项目中创建类似的声明文件继续扩展。
  */
-declare module '../../packages/ui/react' {
+declare module '../../../packages/react/ui/index' {
     namespace SchemaFormNamespace {
         /**
          * 扩展字段类型

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

@@ -0,0 +1,9 @@
+export {};
+declare global {
+    interface Window {
+        _basePath: string;
+        _projKey: string;
+        _signKey: string;
+    }
+}
+//# sourceMappingURL=window.d.ts.map

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

@@ -1,12 +1,12 @@
-import type { ButtonProps } from '../../../packages/ui/react';
-import { ComponentNames } from './component';
+import type { ButtonProps } from "../../../packages/react/ui/index";
+import { ComponentNames } from "./component";
 type ButtonTemplates = {
     /**
      * 按钮名
      */
     label?: string;
 } & ButtonProps;
-type ParamsValueData = 'schema::tableKey' | string | number;
+type ParamsValueData = '$schema::tableKey' | string | number;
 type RemoveBtn = {
     eventKey: 'remove';
     /**
@@ -15,7 +15,7 @@ type RemoveBtn = {
     eventOption: {
         params: {
             /**
-             *  @example user_id: 'schema::tableKey' | '123' | 123
+             *  @example user_id: '$schema::tableKey' | '123' | 123
              */
             [paramKey: string]: ParamsValueData;
         };

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

@@ -1,52 +1,37 @@
-import type { FormFieldType, FormItemProps, SchemaFormAllPropsMap } from '../../../packages/ui/react';
-import { FetchInfo } from './fetchInfo';
-export type ComponentConfig = {
-    createForm?: {
-        /**
-         * 表单标题
-         */
-        title: string;
-        /**
-         *  保存按钮文案
-         */
-        saveBtnText?: string;
-    } & Pick<FetchInfo, 'fetchConfig'>;
-    editForm?: {
-        /**
-         * 表单标题
-         */
-        title: string;
-        /**
-         *  保存按钮文案
-         */
-        saveBtnText?: string;
-    } & FetchInfo;
-    detailPanel?: {
-        /**
-         * 表单标题
-         */
-        title: string;
-    } & FetchInfo;
-};
-export type ComponentNames = keyof ComponentConfig;
-export type ComponentsOption = {
-    createForm: FormItemProps & {
-        /**
-         * 是否展示 默认为true
-         */
-        visible?: boolean;
-        /**
-         * 是否禁用
-         */
-        disbaled?: boolean;
-        /**
-         * 默认值
-         */
-        default?: any;
-    } & ComponentOption;
-    editForm: ComponentsOption['createForm'];
+import type { FormFieldType, FormItemProps, SchemaFormAllPropsMap } from "../../../packages/react/ui/index";
+import type { BuiltInCallComConfigMap } from "../../../frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn";
+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 & {
+    /**
+     * 是否展示 默认为true
+     */
+    visible?: boolean;
+    /**
+     * 是否禁用
+     */
+    disbaled?: 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;

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

@@ -1,9 +1,9 @@
-import { TableColumnDef } from '../../../packages/ui/react';
-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';
+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'> & {
         /**

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

@@ -1,4 +1,4 @@
-import type { SchemaFormAllPropsMap, FormFieldType } from '../../../packages/ui/react';
+import type { SchemaFormAllPropsMap, FormFieldType } from "../../../packages/react/ui/index";
 export type SearchOption = {
     [K in FormFieldType]: {
         comType: K;

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