@_tc/template-core 0.1.16 → 0.2.0-bate.1

package/model/frontend/src/defaultPages/SchemaPage/hooks/useComConfig.d.ts

@@ -0,0 +1,9 @@
+import type { CallComNames, NamedComponentConfig, NamedSchemaType } from "../schemaType";
+declare const useComConfig: <CN extends CallComNames>({ comName }: {
+    comName: CallComNames;
+}) => {
+    config: NamedComponentConfig<CN>;
+    schema: NamedSchemaType<`${CN}Option`>;
+    api: string | undefined;
+};
+export default useComConfig;

package/model/frontend/src/defaultPages/SchemaPage/schemaType.d.ts

@@ -0,0 +1,41 @@
+import type { ComponentConfig } from "@model/data/component";
+import type { BaseOption, ConfigSchema, SchemaDataType, SearchConfig, TableConfig, UsedConfigSchema } from "@model/data/schema";
+import type { LazyExoticComponent, ComponentType as ReactComponentType } from "react";
+import type { SuffixKey } from "./data";
+export type { ComponentConfig, SearchConfig, TableConfig };
+export type FieldType = ConfigSchema['properties'][''];
+export type SchemaType = Required<SchemaDataType>['schema'];
+export type AllFieldKeys = keyof FieldType;
+export type AllOptionsPreNames = {
+    [K in AllFieldKeys]: K extends `${infer Name}${SuffixKey}` ? Name : never;
+}[AllFieldKeys];
+export type NonOptionKey = {
+    [K in AllFieldKeys]: K extends `${string}${SuffixKey}` ? never : K;
+}[AllFieldKeys];
+export type StoreSchemaType = UsedConfigSchema<BaseOption<FieldType[`${AllOptionsPreNames}${SuffixKey}`]>>;
+export type NamedSchemaType<N extends `${AllOptionsPreNames}${SuffixKey}`> = UsedConfigSchema<BaseOption<FieldType[N]>>;
+export type NamedComOption<N extends CallComNames> = ComponentType<ComponentConfig>[N];
+export type NamedComponentConfig<N extends CallComNames> = ComponentConfig[N];
+type ComponentC<C extends ComponentConfig> = {
+    [K in keyof C]: {
+        schema: StoreSchemaType;
+        config: C[K];
+    };
+}[keyof C];
+export type ComponentType<C extends ComponentConfig> = {
+    [K in keyof C]: ComponentC<C>;
+};
+export type CallComNames = keyof ComponentConfig;
+export type CallComRenderer = ReactComponentType<any> | LazyExoticComponent<ReactComponentType<any>>;
+export type SchemaDefaultValue = Record<string, any>;
+export type SchemaTableEmitData = SchemaDefaultValue & {
+    comName: CallComNames;
+};
+export declare const enum ComEventType {
+    close = 0
+}
+export type SchemaComEventInfo = {
+    type: number;
+};
+export type CallComponent<T> = Partial<Record<CallComNames, T>>;
+export type CallComComponentsMap = CallComponent<CallComRenderer>;

package/model/frontend/src/defaultPages/SchemaPage/utils/permissions.d.ts

@@ -0,0 +1,2 @@
+export declare const merge: (...params: number[]) => number;
+export declare const isAllowed: (key1: number, key2: number) => boolean;

package/model/frontend/src/defaultPages/SchemaPage/utils/validator.d.ts

@@ -0,0 +1,7 @@
+import { Ajv } from "ajv";
+export declare const ajvInstance: Ajv;
+type AjvValidatorOptions = {
+    required?: boolean;
+};
+export declare function createAjvValidator(schema: object, options?: AjvValidatorOptions): (rule: object, value: unknown, callback: (errors?: string[]) => void) => void;
+export {};

package/model/frontend/src/language/en-US.d.ts

@@ -0,0 +1,88 @@
+export declare const frontendEnUSResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI Components";
+            readonly uiComponentsButton: "Click me";
+        };
+        readonly components: {
+            readonly languageSwitch: {
+                readonly placeholder: "Select language";
+                readonly zhCN: "简体中文";
+                readonly enUS: "English";
+            };
+            readonly themeSwitch: {
+                readonly light: "Light";
+                readonly dark: "Dark";
+                readonly toLight: "Switch to light theme";
+                readonly toDark: "Switch to dark theme";
+            };
+        };
+        readonly common: {
+            readonly yes: "Yes";
+            readonly no: "No";
+            readonly noData: "No data";
+            readonly loading: "Loading";
+            readonly operation: "Actions";
+        };
+        readonly feedback: {
+            readonly confirmDelete: "Confirm delete?";
+            readonly requiredInput: "Please enter {label}";
+            readonly unknownError: "Unknown error";
+            readonly requestTimedOut: "Request timed out";
+            readonly networkError: "Network error";
+        };
+        readonly notFound: {
+            readonly title: "Page not found";
+            readonly description: "The current path is invalid, or the page is not registered in the router.";
+        };
+        readonly validator: {
+            readonly value: "value";
+            readonly required: "Missing required field: {field}";
+            readonly type: "{path} type error, expected {type}";
+            readonly typeString: "string";
+            readonly typeNumber: "number";
+            readonly typeInteger: "integer";
+            readonly typeBoolean: "boolean";
+            readonly typeArray: "array";
+            readonly typeObject: "object";
+            readonly typeNull: "null";
+            readonly format: "{path} format is invalid";
+            readonly minimum: "{path} cannot be less than {limit}";
+            readonly maximum: "{path} cannot be greater than {limit}";
+            readonly exclusiveMinimum: "{path} must be greater than {limit}";
+            readonly exclusiveMaximum: "{path} must be less than {limit}";
+            readonly multipleOf: "{path} must be a multiple of {multipleOf}";
+            readonly minLength: "{path} must be at least {limit} characters";
+            readonly maxLength: "{path} must be at most {limit} characters";
+            readonly pattern: "{path} format does not match the requirement";
+            readonly minItems: "{path} must contain at least {limit} items";
+            readonly maxItems: "{path} must contain at most {limit} items";
+            readonly uniqueItems: "{path} must not contain duplicate items";
+            readonly minProperties: "{path} must contain at least {limit} properties";
+            readonly maxProperties: "{path} must contain at most {limit} properties";
+            readonly additionalProperties: "{path} contains disallowed property {property}";
+            readonly enum: "{path} is not in the allowed options";
+            readonly const: "{path} must equal the specified value";
+            readonly oneOf: "{path} must match exactly one rule";
+            readonly anyOf: "{path} must match at least one rule";
+            readonly allOf: "{path} does not satisfy all rules";
+            readonly not: "{path} must not match this rule";
+            readonly propertyNames: "{path} property name is invalid";
+            readonly dependencies: "{path} is missing dependent fields";
+            readonly contains: "{path} is missing a required matching item";
+            readonly if: "{path} conditional validation failed";
+            readonly fallback: "{path} validation failed";
+        };
+        readonly log: {
+            readonly pageNotFound: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly pageNotFoundEn: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly illegalComponentCallback: "Illegal component callback - {comName}";
+            readonly illegalComponentCallbackEn: "Illegal component callback - {comName}";
+            readonly subscriptionError: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly subscriptionErrorEn: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly apiTamper: "API attributes cannot be tampered with";
+            readonly apiTamperEn: "API attributes cannot be tampered with";
+        };
+    };
+};

package/model/frontend/src/language/index.d.ts

@@ -0,0 +1,72 @@
+import type { I18nResources } from "../../../../fe/packages/react/ui/i18n/index";
+export declare const i18nKeyPrefix = "$i18n::";
+export declare const frontendI18nResources: I18nResources;
+export declare const withI18nKey: (key: string) => string;
+export declare const frontendLangKeys: {
+    readonly appTitle: string;
+    readonly uiComponentsTitle: string;
+    readonly uiComponentsButton: string;
+    readonly languageSwitchPlaceholder: string;
+    readonly languageSwitchZhCN: string;
+    readonly languageSwitchEnUS: string;
+    readonly themeSwitchLight: string;
+    readonly themeSwitchDark: string;
+    readonly themeSwitchToLight: string;
+    readonly themeSwitchToDark: string;
+    readonly yes: string;
+    readonly no: string;
+    readonly noData: string;
+    readonly loading: string;
+    readonly operation: string;
+    readonly confirmDelete: string;
+    readonly requiredInput: string;
+    readonly unknownError: string;
+    readonly requestTimedOut: string;
+    readonly networkError: string;
+    readonly notFoundTitle: string;
+    readonly notFoundDescription: string;
+    readonly validatorValue: string;
+    readonly validatorRequired: string;
+    readonly validatorType: string;
+    readonly validatorTypeString: string;
+    readonly validatorTypeNumber: string;
+    readonly validatorTypeInteger: string;
+    readonly validatorTypeBoolean: string;
+    readonly validatorTypeArray: string;
+    readonly validatorTypeObject: string;
+    readonly validatorTypeNull: string;
+    readonly validatorFormat: string;
+    readonly validatorMinimum: string;
+    readonly validatorMaximum: string;
+    readonly validatorExclusiveMinimum: string;
+    readonly validatorExclusiveMaximum: string;
+    readonly validatorMultipleOf: string;
+    readonly validatorMinLength: string;
+    readonly validatorMaxLength: string;
+    readonly validatorPattern: string;
+    readonly validatorMinItems: string;
+    readonly validatorMaxItems: string;
+    readonly validatorUniqueItems: string;
+    readonly validatorMinProperties: string;
+    readonly validatorMaxProperties: string;
+    readonly validatorAdditionalProperties: string;
+    readonly validatorEnum: string;
+    readonly validatorConst: string;
+    readonly validatorOneOf: string;
+    readonly validatorAnyOf: string;
+    readonly validatorAllOf: string;
+    readonly validatorNot: string;
+    readonly validatorPropertyNames: string;
+    readonly validatorDependencies: string;
+    readonly validatorContains: string;
+    readonly validatorIf: string;
+    readonly validatorFallback: string;
+    readonly logPageNotFound: string;
+    readonly logPageNotFoundEn: string;
+    readonly logIllegalComponentCallback: string;
+    readonly logIllegalComponentCallbackEn: string;
+    readonly logSubscriptionError: string;
+    readonly logSubscriptionErrorEn: string;
+    readonly logApiTamper: string;
+    readonly logApiTamperEn: string;
+};

package/model/frontend/src/language/zh-CN.d.ts

@@ -0,0 +1,88 @@
+export declare const frontendZhCNResources: {
+    readonly frontend: {
+        readonly app: {
+            readonly title: "Template Core";
+            readonly uiComponentsTitle: "UI 组件";
+            readonly uiComponentsButton: "点击我";
+        };
+        readonly components: {
+            readonly languageSwitch: {
+                readonly placeholder: "选择语言";
+                readonly zhCN: "简体中文";
+                readonly enUS: "English";
+            };
+            readonly themeSwitch: {
+                readonly light: "浅色";
+                readonly dark: "深色";
+                readonly toLight: "切换为浅色主题";
+                readonly toDark: "切换为深色主题";
+            };
+        };
+        readonly common: {
+            readonly yes: "是";
+            readonly no: "否";
+            readonly noData: "暂无数据";
+            readonly loading: "加载中";
+            readonly operation: "操作";
+        };
+        readonly feedback: {
+            readonly confirmDelete: "确认删除？";
+            readonly requiredInput: "请输入{label}";
+            readonly unknownError: "未知错误";
+            readonly requestTimedOut: "请求超时";
+            readonly networkError: "网络错误";
+        };
+        readonly notFound: {
+            readonly title: "页面不存在";
+            readonly description: "当前路径无效，或页面未在路由中注册。";
+        };
+        readonly validator: {
+            readonly value: "值";
+            readonly required: "缺少必填字段: {field}";
+            readonly type: "{path} 类型错误，期望 {type}";
+            readonly typeString: "字符串";
+            readonly typeNumber: "数字";
+            readonly typeInteger: "整数";
+            readonly typeBoolean: "布尔值";
+            readonly typeArray: "数组";
+            readonly typeObject: "对象";
+            readonly typeNull: "空值";
+            readonly format: "{path} 格式不正确";
+            readonly minimum: "{path} 不能小于 {limit}";
+            readonly maximum: "{path} 不能大于 {limit}";
+            readonly exclusiveMinimum: "{path} 必须大于 {limit}";
+            readonly exclusiveMaximum: "{path} 必须小于 {limit}";
+            readonly multipleOf: "{path} 必须是 {multipleOf} 的倍数";
+            readonly minLength: "{path} 长度不能少于 {limit} 个字符";
+            readonly maxLength: "{path} 长度不能超过 {limit} 个字符";
+            readonly pattern: "{path} 格式不符合要求";
+            readonly minItems: "{path} 至少需要 {limit} 项";
+            readonly maxItems: "{path} 不能超过 {limit} 项";
+            readonly uniqueItems: "{path} 不能包含重复项";
+            readonly minProperties: "{path} 至少需要 {limit} 个属性";
+            readonly maxProperties: "{path} 不能超过 {limit} 个属性";
+            readonly additionalProperties: "{path} 包含不允许的属性 {property}";
+            readonly enum: "{path} 不在可选范围内";
+            readonly const: "{path} 必须等于指定值";
+            readonly oneOf: "{path} 只能匹配一个规则";
+            readonly anyOf: "{path} 至少需要匹配一个规则";
+            readonly allOf: "{path} 未满足全部规则";
+            readonly not: "{path} 不能匹配该规则";
+            readonly propertyNames: "{path} 属性名不符合要求";
+            readonly dependencies: "{path} 缺少关联字段";
+            readonly contains: "{path} 缺少符合要求的项";
+            readonly if: "{path} 条件校验未通过";
+            readonly fallback: "{path} 校验未通过";
+        };
+        readonly log: {
+            readonly pageNotFound: "url有问题 或者 自定义页面未在路由器注册";
+            readonly pageNotFoundEn: "The URL is incorrect, or the custom page is not registered with the router.";
+            readonly illegalComponentCallback: "非法的组件回调 - {comName}";
+            readonly illegalComponentCallbackEn: "Illegal component callback - {comName}";
+            readonly subscriptionError: "不曾订阅过，请检查代码，关注函数与取消函数必须为同一个";
+            readonly subscriptionErrorEn: "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same.";
+            readonly apiTamper: "api属性不允许篡改";
+            readonly apiTamperEn: "API attributes cannot be tampered with";
+        };
+    };
+};

package/model/frontend/src/stores/apiFreezer.d.ts

@@ -0,0 +1,26 @@
+type freezeQueue = Map<string, {
+    originFn: Function;
+    callBackFns: {
+        resolve: (value: unknown) => void;
+        reject: (reason?: any) => void;
+    }[];
+}>;
+export declare const FreezeState: {
+    readonly Hibernation: "Hibernation";
+    readonly Freeze: "Freeze";
+    readonly Thawing: "Thawing";
+};
+export type FreezeStateKeys = keyof typeof FreezeState;
+export type FreezeStateEnum = (typeof FreezeState)[FreezeStateKeys];
+export type ApiFreezerRequestMatcher = string | RegExp | ((api: string, params: readonly unknown[]) => boolean);
+interface ApiFreezerState {
+    readonly state: FreezeStateEnum;
+    freezing: () => void;
+    thawing: () => void;
+    requestWhitelist: ApiFreezerRequestMatcher[];
+    setRequestWhitelist: (data: ApiFreezerState['requestWhitelist']) => void;
+    readonly freezeQueue: freezeQueue;
+}
+export declare const apiFreezerStore: import("zustand").StoreApi<ApiFreezerState>;
+export declare const useApiFreezer: import("../../../../fe/packages/react/ui/index").StoreHook<import("zustand").StoreApi<ApiFreezerState>>;
+export {};

package/model/frontend/src/stores/schemaEventBus.d.ts

@@ -0,0 +1,22 @@
+import type { SchemaComEventInfo, SchemaDefaultValue, SchemaTableEmitData } from "@/defaultPages/SchemaPage/schemaType";
+type WatchFn<V = SchemaDefaultValue | undefined> = (value: V) => void;
+declare const enum SubscribeEnum {
+    search = "search",
+    table = "table",
+    com = "com"
+}
+interface SchemaEventBusStore {
+    readonly Subscribers: Map<WatchFn, SubscribeEnum>;
+    subscribeSearch: (fn: WatchFn) => void;
+    unSubscribeSearch: (fn: WatchFn) => void;
+    emitSearch: (v: SchemaDefaultValue | undefined) => void;
+    subscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    unSubscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    emitTable: (v: SchemaTableEmitData) => void;
+    emitCall: (v: SchemaDefaultValue | undefined, type: SubscribeEnum) => void;
+    subscribeCom: (fn: WatchFn<SchemaComEventInfo>) => void;
+    unSubscribeCom: (fn: WatchFn<SchemaComEventInfo>) => void;
+    emitCom: (v: SchemaComEventInfo) => void;
+}
+export declare const schemaEventBus: import("zustand").StoreApi<SchemaEventBusStore>;
+export {};

package/model/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 "../../../../fe/packages/react/ui/components/TableSearch/TableSearch";
+import type { MOmit } from "../../../../types/typings/type";
+import { LRUCache } from "@tc/common";
+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("../../../../fe/packages/react/ui/index").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
+export {};

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

@@ -0,0 +1,15 @@
+import type { FrameComponentPropsMap, FrameComponentsMap } from "../../extended/SchemaForm/data";
+import type { SelectProps } from "../../../../fe/packages/react/ui/index";
+declare module '../../../../fe/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/model/frontend/src/typing/window.d.ts

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

package/model/{index.d.ts → model/index.d.ts}

@@ -1,2 +1 @@
-export type { MBMenuType, ModelDataType, ModelMode, ModelModeMap } from './types';
-//# sourceMappingURL=index.d.ts.map
+export type { MBMenuType, ModelDataType, ModelMode, ModelModeMap } from "./types";

package/model/{types → model/types}/data/button.d.ts

@@ -1,22 +1,13 @@
-import type { ButtonProps } from '../../../fe/packages/ui/react';
-import { ComponentNames } from './component';
+import type { ButtonProps } from "../../../../fe/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: {
-            /**
-             *  @example user_id: '$schema::tableKey' | '123' | 123
-             */
             [paramKey: string]: ParamsValueData;
         };
     };
@@ -29,4 +20,3 @@ type HandlerBtn = {
 };
 export type BaseButton = ButtonTemplates & (RemoveBtn | HandlerBtn);
 export {};
-//# sourceMappingURL=button.d.ts.map

package/model/{types → model/types}/data/component.d.ts

@@ -1,6 +1,6 @@
-import type { FormFieldType, FormItemProps, SchemaFormAllPropsMap } from '../../../fe/packages/ui/react';
-import type { BuiltInCallComConfigMap } from '../../../fe/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn';
-export type { BuiltInCallComConfigMap, BuiltInCallComNames } from '../../../fe/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn';
+import type { BuiltInCallComConfigMap } from "../../../../fe/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn";
+import type { FormFieldType, FormItemProps, SchemaFormAllPropsMap } from "../../../../fe/packages/react/ui/index";
+export type { BuiltInCallComConfigMap, BuiltInCallComNames } from "../../../../fe/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn";
 export declare namespace CallComNamespace {
     interface ConfigMap {
     }
@@ -10,17 +10,8 @@ export declare namespace CallComNamespace {
 export type ComponentConfig = BuiltInCallComConfigMap & Partial<CallComNamespace.ConfigMap>;
 export type ComponentNames = Extract<keyof ComponentConfig, string>;
 type FormComponentOption = FormItemProps & {
-    /**
-     * 是否展示 默认为true
-     */
     visible?: boolean;
-    /**
-     * 是否禁用
-     */
-    disbaled?: boolean;
-    /**
-     * 默认值
-     */
+    disabled?: boolean;
     default?: any;
 } & ComponentOption;
 export type BuiltInCallComOptionMap = {
@@ -37,4 +28,3 @@ export type ComponentOption = {
         comType: K;
     } & (K extends keyof SchemaFormAllPropsMap ? SchemaFormAllPropsMap[K] : unknown);
 }[FormFieldType];
-//# sourceMappingURL=component.d.ts.map

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

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

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

@@ -0,0 +1,46 @@
+import { TableColumnDef } from "../../../../fe/packages/react/ui/index";
+import type { JSONSchema7 } from "json-schema";
+import { MOmit } from "../../../../types/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/model/{types → model/types}/data/search.d.ts

@@ -1,7 +1,6 @@
-import type { SchemaFormAllPropsMap, FormFieldType } from '../../../fe/packages/ui/react';
+import type { SchemaFormAllPropsMap, FormFieldType } from "../../../../fe/packages/react/ui/index";
 export type SearchOption = {
     [K in FormFieldType]: {
         comType: K;
     } & (K extends keyof SchemaFormAllPropsMap ? SchemaFormAllPropsMap[K] : unknown);
 }[FormFieldType];
-//# sourceMappingURL=search.d.ts.map

package/model/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/model/{types → model/types}/menuType.d.ts

@@ -1,17 +1,8 @@
 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 {
@@ -21,26 +12,15 @@ interface GroupMenuType<T extends MenuLayout> extends BaseMenu {
 interface ModuleMenuType extends BaseMenu {
     menuType: "module";
 }
-/**
- *
- * ----------------------------- moduletype -----------------------------
- *
- */
 interface IframeModuleType {
     moduleType: "iframe";
     iframeConfig: {
-        /**
-         * iframe 路径
-         */
         path: string;
     };
 }
 interface CustomModuleType {
     moduleType: "custom";
     customConfig: {
-        /**
-         * 自定义路由路径
-         */
         path: string;
     };
 }
@@ -52,22 +32,12 @@ 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