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

package/fe/frontend/src/common/request.js

@@ -0,0 +1,217 @@
+import { apiFreezerStore, FreezeState } from '../stores/apiFreezer';
+import { FetchAxios } from '../../../packages/common/http';
+import md5 from 'md5';
+import { API_AUTH_HEADER_KEY, AUTH_HEADER_KEY, clearAuthToken, getApiAuth, getAuthToken } from './auth';
+const BASE_URL = '/api';
+const NumberConcurrentCalls = 4;
+const isRequestWhitelisted = (api, params) => {
+    const { requestWhitelist } = apiFreezerStore.getState();
+    return requestWhitelist.some((matcher) => {
+        if (typeof matcher === 'string')
+            return matcher === api;
+        if (matcher instanceof RegExp)
+            return matcher.test(api);
+        return matcher(api, params);
+    });
+};
+/**
+ * 处理解冻
+ * 冻结流程  4～9
+ */
+apiFreezerStore.subscribe((newState) => {
+    if (newState.state === FreezeState.Thawing) {
+        console.time('Thawing');
+        const { freezeQueue } = newState;
+        const queues = [...freezeQueue.values()];
+        // 清空冻结队列
+        freezeQueue.clear();
+        (async () => {
+            /**
+             *  生成 并发队列
+             *  每个队列从头取一个任务
+             *  当所有任务执行完后 这个 Promise.all 才会结束
+             */
+            await Promise.all(Array.from({ length: Math.min(NumberConcurrentCalls, queues.length) }, async () => {
+                while (queues.length) {
+                    const task = queues.shift();
+                    // 异常数据跳过
+                    if (!task)
+                        continue;
+                    const { originFn, callBackFns } = task;
+                    try {
+                        const res = await originFn();
+                        callBackFns.forEach(({ resolve }) => {
+                            resolve(res);
+                        });
+                    }
+                    catch (error) {
+                        callBackFns.forEach(({ reject }) => {
+                            reject(error);
+                        });
+                    }
+                }
+            }));
+            // 标记完成
+            apiFreezerStore.setState({ state: FreezeState.Hibernation });
+            console.timeEnd('Thawing');
+        })();
+    }
+});
+/**
+ * 冻结流程 1～3
+ */
+function hijackingFn(fn) {
+    return function (...params) {
+        const { state, freezeQueue } = apiFreezerStore.getState();
+        const [api] = params;
+        // 不等于冻结状态 | 在接口白名单内
+        // 直接放行
+        if (state !== FreezeState.Freeze || isRequestWhitelisted(api, params)) {
+            return fn(...params);
+        }
+        // 请求拦截
+        else {
+            const key = md5(JSON.stringify(params));
+            if (!freezeQueue.has(key)) {
+                freezeQueue.set(key, {
+                    originFn: () => fn(...params),
+                    // result: null,
+                    callBackFns: [],
+                });
+            }
+            const { callBackFns } = freezeQueue.get(key);
+            return new Promise((resolve, reject) => {
+                callBackFns.push({ reject, resolve });
+            });
+        }
+    };
+}
+const api = new FetchAxios({
+    baseURL: BASE_URL,
+    timeout: 15000,
+    credentials: 'include',
+    validateStatus: (status) => status >= 200 && status < 300,
+});
+const removeBaseurlFromURL = (config) => {
+    const { baseURL, url } = config;
+    if (!baseURL || !url)
+        return;
+    const origin = typeof window === 'undefined' ? 'http://localhost' : window.location.origin;
+    const baseURLObject = new URL(baseURL, origin);
+    const basePath = baseURLObject.pathname.replace(/\/+$/, '');
+    const requestURL = new URL(url, baseURLObject.origin);
+    if (requestURL.origin !== baseURLObject.origin || !basePath)
+        return;
+    const normalizedPathname = requestURL.pathname.replace(/\/+$/, '');
+    if (normalizedPathname !== basePath && !requestURL.pathname.startsWith(`${basePath}/`))
+        return;
+    const pathname = requestURL.pathname.slice(basePath.length) || '/';
+    config.url = `${pathname}${requestURL.search}${requestURL.hash}`;
+};
+// ---- Request Interceptors ----
+api.interceptors.request.use(async (config) => {
+    removeBaseurlFromURL(config);
+    const token = await getAuthToken();
+    const aauto = getApiAuth();
+    const time = new Date().getTime();
+    config.headers = {
+        ...config.headers,
+        s_t: time + '',
+        s_sign: md5(`sakjdfnkjwjfnfkjkjldljksndf_${time}`),
+        [API_AUTH_HEADER_KEY]: aauto,
+    };
+    if (token) {
+        config.headers = {
+            ...config.headers,
+            [AUTH_HEADER_KEY]: `Bearer ${token}`,
+        };
+    }
+    return config;
+});
+api.interceptors.request.use((config) => {
+    console.debug(`[API] ${config.method?.toUpperCase()} ${config.url}`);
+    return config;
+});
+// ---- Response Interceptors ----
+api.interceptors.response.use((res) => res, async (err) => {
+    const axiosErr = err;
+    if (axiosErr.response?.status === 401) {
+        await clearAuthToken();
+        if (typeof window !== 'undefined') {
+            window.location.href = '/login';
+        }
+    }
+    const message = extractErrorMessage(err);
+    console.error(`[API Error] ${message}`, {
+        url: err.config.url,
+        status: err.response?.status,
+    });
+    return Promise.reject(err);
+});
+// ---- Helpers ----
+function extractErrorMessage(err) {
+    if (!(err instanceof Error))
+        return 'Unknown error';
+    const axiosErr = err;
+    if (axiosErr.response?.data && typeof axiosErr.response.data === 'object' && axiosErr.response.data !== null) {
+        const data = axiosErr.response.data;
+        if (typeof data.message === 'string')
+            return data.message;
+        if (typeof data.msg === 'string')
+            return data.msg;
+        if (Array.isArray(data.errors) && data.errors.length > 0) {
+            return String(data.errors[0]);
+        }
+    }
+    if (axiosErr.message)
+        return axiosErr.message;
+    if (axiosErr.code === 'ECONNABORTED')
+        return 'Request timed out';
+    return 'Network error';
+}
+/**
+ * GET/DELETE 不发送 body；统一把 data 转到 params。
+ *  */
+export const get = hijackingFn((url, data, config) => {
+    const hasDataParams = data !== undefined && data !== null && typeof data === 'object';
+    const getConfig = hasDataParams
+        ? {
+            ...config,
+            params: {
+                ...config?.params,
+                ...data,
+            },
+        }
+        : config;
+    return api.get(url, getConfig);
+});
+export const post = hijackingFn((url, data, config) => {
+    return api.post(url, data, config);
+});
+export const put = hijackingFn((url, data, config) => {
+    return api.put(url, data, config);
+});
+export const patch = hijackingFn((url, data, config) => {
+    return api.patch(url, data, config);
+});
+export const del = hijackingFn((url, data, config) => {
+    const hasDataParams = data !== undefined && data !== null && typeof data === 'object';
+    const delConfig = hasDataParams
+        ? {
+            ...config,
+            params: {
+                ...config?.params,
+                ...data,
+            },
+        }
+        : config;
+    return api.delete(url, delConfig);
+});
+export { api, FetchAxios };
+export const request = {
+    get,
+    put,
+    post,
+    del,
+    patch,
+};

package/fe/frontend/src/components/AsyncSelect/AsyncSelect.d.ts

@@ -0,0 +1,8 @@
+import type { MergeType, MOmit } from '../../../../typings/type';
+import { FetchInfo } from '../../../../model/types/data/fetchInfo';
+import { SelectProps } from '../../../../packages/ui/react';
+export interface AsyncSelectProps extends MergeType<[MOmit<FetchInfo, 'fetchKey'>, MOmit<SelectProps, 'options'>]> {
+}
+declare const AsyncSelect: (props: AsyncSelectProps) => import("react/jsx-runtime").JSX.Element;
+export default AsyncSelect;
+//# sourceMappingURL=AsyncSelect.d.ts.map

package/fe/frontend/src/components/AsyncSelect/AsyncSelect.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { handlingRequestErrors } from '../../common/fetchErrorShow';
+import { request } from '../../common/request';
+import { Select } from '../../../../packages/ui/react';
+import useExecuteOnce from '../../../../packages/ui/react/hooks/useExecuteOnce';
+import { useState } from 'react';
+const AsyncSelect = (props) => {
+    const { fetchConfig, ...params } = props;
+    const [options, setOptions] = useState([]);
+    const [loading, setLoading] = useState(false);
+    useExecuteOnce(async () => {
+        if (fetchConfig) {
+            setLoading(true);
+            const { method = 'get', url } = fetchConfig;
+            try {
+                const res = await handlingRequestErrors(request[method](url));
+                if (res.data.code === 0) {
+                    setOptions(res.data.data.map((i) => {
+                        i.searchText = i.label;
+                        return i;
+                    }));
+                }
+            }
+            finally {
+                setLoading(false);
+            }
+        }
+    }, { executionPhase: 'mount' });
+    // @ts-ignore
+    return _jsx(Select, { loading: loading, options: options, ...params });
+};
+export default AsyncSelect;

package/fe/frontend/src/components/AsyncSelect/index.d.ts

@@ -0,0 +1,4 @@
+import AsyncSelect from './AsyncSelect';
+export * from './AsyncSelect';
+export default AsyncSelect;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/components/AsyncSelect/index.js

@@ -0,0 +1,3 @@
+import AsyncSelect from './AsyncSelect';
+export * from './AsyncSelect';
+export default AsyncSelect;

package/fe/frontend/src/components/BasePage/HeaderView.d.ts

@@ -0,0 +1,9 @@
+import { PropsWithChildren, ReactNode } from "react";
+export interface HeaderViewProps extends PropsWithChildren {
+    menu?: ReactNode;
+    title?: ReactNode;
+    userArea?: ReactNode;
+}
+declare const HeaderView: (props?: HeaderViewProps) => import("react/jsx-runtime").JSX.Element;
+export default HeaderView;
+//# sourceMappingURL=HeaderView.d.ts.map

package/fe/frontend/src/components/BasePage/HeaderView.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "../../../../packages/ui/react/index";
+const defaultTitle = _jsx("span", { children: "Template Core" });
+const defaultProps = {};
+const headerThemeStyle = {
+    "--header-fg": "hsl(var(--theme-text))",
+    "--header-bg": "hsl(var(--theme-bg))",
+    "--header-shadow": "hsl(var(--foreground) / 0.08)",
+};
+const HeaderView = (props) => {
+    const { title, menu, userArea, children } = props ?? defaultProps;
+    return (_jsxs("div", { className: "header-view", style: headerThemeStyle, children: [_jsxs("header", { className: cn("header flex h-14 shrink-0 items-center border-b border-border/70 bg-background/95 text-(--header-fg)", "shadow-[0_1px_0_var(--header-shadow)]"), children: [_jsx("div", { className: "brand flex w-56 items-center px-5 text-sm font-semibold tracking-normal text-foreground", children: title ?? defaultTitle }), _jsx("div", { className: "top-menu flex min-w-0 flex-1 items-center px-3 text-(--header-fg)", children: menu }), _jsx("div", { className: "user-area flex min-w-0 items-center justify-end px-5 text-(--header-fg)", children: userArea })] }), children] }));
+};
+export default HeaderView;

package/fe/frontend/src/components/Router/index.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { RouterType } from './type';
+export type RouteInfo = {
+    path: string;
+    component: ReactNode;
+    children?: RouteInfo[];
+};
+export declare const generateRouter: (routes: RouteInfo[], type: RouterType) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/components/Router/index.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { BrowserRouter, HashRouter, Route, Routes } from 'react-router-dom';
+export const generateRouter = (routes, type) => {
+    const RouterComponent = type === 'browser' ? BrowserRouter : HashRouter;
+    const renderDom = (routes) => {
+        return routes.map((route) => {
+            return (_jsx(Route, { path: route.path, element: route.component, children: route.children && renderDom(route.children) }, route.path));
+        });
+    };
+    return (_jsx(RouterComponent, { basename: window._basePath, children: _jsx(Routes, { children: renderDom(routes) }) }));
+};

package/fe/frontend/src/components/Router/type.d.ts

@@ -0,0 +1,2 @@
+export type RouterType = "hash" | "browser";
+//# sourceMappingURL=type.d.ts.map

package/fe/frontend/src/components/Router/type.js

@@ -0,0 +1 @@
+export {};

package/fe/frontend/src/defaultPages/Iframe/index.d.ts

@@ -0,0 +1,3 @@
+declare const Iframe: () => import("react/jsx-runtime").JSX.Element;
+export default Iframe;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/defaultPages/Iframe/index.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import useCurrentMenuData from '../../hooks/useCurrentMenuData';
+import { useMemo } from 'react';
+const Iframe = () => {
+    const { menu } = useCurrentMenuData(true);
+    const ifUrl = useMemo(() => {
+        if (menu.moduleType === 'iframe') {
+            return menu.iframeConfig.path;
+        }
+        return '';
+    }, []);
+    return (_jsx("div", { className: "iframe w-full h-full", children: _jsx("iframe", { className: " w-full h-full", src: ifUrl }) }));
+};
+export default Iframe;

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/DetailPanel.d.ts

@@ -0,0 +1,7 @@
+import type { CallComNames, SchemaDefaultValue } from '../../schemaType';
+declare const DetailPanel: import("react").MemoExoticComponent<(props: {
+    data: SchemaDefaultValue;
+    comName: CallComNames;
+}) => import("react/jsx-runtime").JSX.Element>;
+export default DetailPanel;
+//# sourceMappingURL=DetailPanel.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/DetailPanel.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { handlingRequestErrors } from '../../../../common/fetchErrorShow';
+import { getText } from '../../../../common/language';
+import { request } from '../../../../common/request';
+import { schemaEventBus } from '../../../../stores/schemaEventBus';
+import { Drawer } from '../../../../../../packages/ui/react/components';
+import useExecuteOnce from '../../../../../../packages/ui/react/hooks/useExecuteOnce';
+import { memo, useMemo, useState } from 'react';
+import { eventsInfo } from '../../data/eventInfo';
+import useComConfig from '../../hooks/useComConfig';
+import { merge } from '../../utils/permissions';
+const EMPTY_TEXT = '-';
+const isEmptyValue = (value) => value === undefined || value === null || value === '';
+const stringifyValue = (value) => {
+    if (isEmptyValue(value))
+        return EMPTY_TEXT;
+    if (typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+};
+const getOptionLabel = (options, value) => {
+    if (!Array.isArray(options))
+        return undefined;
+    const matchedOption = options.find((option) => {
+        if (!option || typeof option !== 'object')
+            return false;
+        return option.value === value;
+    });
+    if (!matchedOption || typeof matchedOption !== 'object')
+        return undefined;
+    const label = matchedOption.label;
+    return label ?? stringifyValue(value);
+};
+const formatValue = (value, fieldInfo) => {
+    if (isEmptyValue(value))
+        return EMPTY_TEXT;
+    const option = fieldInfo.option;
+    const optionLabel = getOptionLabel(option?.options ?? option?.enumList, value);
+    if (optionLabel !== undefined)
+        return optionLabel;
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return EMPTY_TEXT;
+        return value
+            .map((item) => {
+            return stringifyValue(item);
+        })
+            .join(', ');
+    }
+    if (typeof value === 'boolean')
+        return value ? getText('是') : getText('否');
+    return stringifyValue(value);
+};
+const generateFields = (schema, data) => {
+    if (!schema?.properties)
+        return [];
+    return Object.keys(schema.properties)
+        .reduce((fields, key) => {
+        const fieldInfo = schema.properties[key];
+        if (!fieldInfo?.option || fieldInfo.option.visible === false)
+            return fields;
+        fields.push({
+            key,
+            label: getText(fieldInfo.label),
+            value: formatValue(data?.[key], fieldInfo),
+            level: fieldInfo.level ?? 10,
+        });
+        return fields;
+    }, [])
+        .sort((a, b) => a.level - b.level);
+};
+const DetailPanel = memo((props) => {
+    const [open, setOpen] = useState(true);
+    const [data, setData] = useState(props.data);
+    const { config, schema, api } = useComConfig({ comName: props.comName });
+    const fields = useMemo(() => generateFields(schema, data), [data, schema]);
+    useExecuteOnce(async () => {
+        const fetchKey = config?.fetchKey;
+        if (fetchKey) {
+            const params = {
+                [fetchKey]: props.data[fetchKey],
+            };
+            const { url: furl = api, method = 'get' } = config.fetchConfig ?? {};
+            const res = await handlingRequestErrors(request[method](furl, params));
+            if (res.data.code === 0)
+                setData(res.data.data);
+        }
+    }, { executionPhase: 'mount' });
+    return (_jsx("div", { className: "detail-panel", children: _jsx(Drawer, { title: getText(config?.title ?? ''), open: open, onClose: () => {
+                setOpen(false);
+                schemaEventBus.getState().emitCom({ type: merge(eventsInfo.closeCom) });
+            }, children: fields.length > 0 ? (_jsx("div", { className: "grid grid-cols-1 gap-x-6 gap-y-4 sm:grid-cols-2", children: fields.map((field) => (_jsxs("div", { className: "min-w-0 border-b border-border pb-3", children: [_jsx("div", { className: "mb-1 text-xs text-muted-foreground", children: field.label }), _jsx("div", { className: "break-words text-sm leading-6 text-foreground", children: field.value })] }, field.key))) })) : (_jsx("div", { className: "py-8 text-center text-sm text-muted-foreground", children: getText('暂无数据') })) }) }));
+});
+export default DetailPanel;

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/PopFrom.d.ts

@@ -0,0 +1,13 @@
+import type { CallComNames, ComponentConfig, SchemaDefaultValue } from '../../schemaType';
+type PopFormComName = keyof ComponentConfig;
+export interface PopFormValue {
+    comName: PopFormComName;
+    data?: SchemaDefaultValue;
+}
+export interface PopFormProps {
+    data: SchemaDefaultValue;
+    comName: CallComNames;
+}
+declare const PopForm: import("react").MemoExoticComponent<(props: PopFormProps) => import("react/jsx-runtime").JSX.Element>;
+export default PopForm;
+//# sourceMappingURL=PopFrom.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/PopFrom.js

@@ -0,0 +1,124 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { handlingRequestErrors } from '../../../../common/fetchErrorShow';
+import { getText } from '../../../../common/language';
+import { post, put, request } from '../../../../common/request';
+import { schemaEventBus } from '../../../../stores/schemaEventBus';
+import { Modal, SchemaForm } from '../../../../../../packages/ui/react/components';
+import useExecuteOnce from '../../../../../../packages/ui/react/hooks/useExecuteOnce';
+import { memo, useCallback, useMemo, useRef, useState } from 'react';
+import { eventsInfo } from '../../data/eventInfo';
+import useComConfig from '../../hooks/useComConfig';
+import { merge } from '../../utils/permissions';
+import { createAjvValidator } from '../../utils/validator';
+const generateSchemas = (schema) => {
+    if (!schema?.properties)
+        return [];
+    return Object.keys(schema.properties).reduce((schemas, key) => {
+        const fieldInfo = schema.properties[key];
+        const option = fieldInfo?.option;
+        if (!option || option.visible === false)
+            return schemas;
+        const { comType = 'input', default: _defaultValue, visible: _visible, ...fieldProps } = option;
+        schemas.push({
+            key,
+            label: getText(fieldInfo.label),
+            type: comType,
+            required: schema.required?.includes(key),
+            rules: [
+                ...(schema.required?.includes(key)
+                    ? [{ required: true, message: `请输入${getText(fieldInfo.label)}` }]
+                    : []),
+                {
+                    validator: createAjvValidator(fieldInfo),
+                },
+            ],
+            fieldProps: {
+                ...fieldProps,
+                ...(comType === 'select'
+                    ? {
+                        getPopupContainer: 'parent',
+                    }
+                    : []),
+            },
+        });
+        return schemas;
+    }, []);
+};
+const generateDefaultValue = (schema, data) => {
+    const defaultValue = { ...(data ?? {}) };
+    if (!schema?.properties)
+        return defaultValue;
+    Object.keys(schema.properties).forEach((key) => {
+        const defaultFieldValue = schema.properties[key]?.option?.default;
+        if (typeof defaultFieldValue !== 'undefined' && typeof defaultValue[key] === 'undefined') {
+            defaultValue[key] = defaultFieldValue;
+        }
+    });
+    return defaultValue;
+};
+const PopForm = memo((props) => {
+    const [open, setOpen] = useState(true);
+    const [submitting, setSubmitting] = useState(false);
+    const { schema, config, api } = useComConfig({ comName: props.comName });
+    const formRef = useRef(null);
+    const [loading, setLoading] = useState(false);
+    /**
+     * 1. 生成 schemas
+     * 2. 根据config 获取相关展示内容、请求数据
+     * 3. 支持 create、edit
+     *
+     *
+     * 交互结束时 通知上层 清除show component
+     *
+     *
+     */
+    const schemas = useMemo(() => {
+        return generateSchemas(schema);
+    }, [schema]);
+    const closed = submitting
+        ? undefined
+        : () => {
+            schemaEventBus.getState().emitCom({ type: merge(eventsInfo.closeCom) });
+            setOpen(false);
+        };
+    const defaultValue = useMemo(() => generateDefaultValue(schema, props.data), [schema, props.data]);
+    useExecuteOnce(async () => {
+        /**
+         * 编辑弹窗需要 获取一下数据
+         */
+        if (props.comName === 'editForm' && 'fetchKey' in config) {
+            const { fetchKey } = config;
+            const params = {
+                [fetchKey]: props.data[fetchKey],
+            };
+            const { url = api, method = 'get' } = config?.fetchConfig ?? {};
+            setLoading(true);
+            const res = await handlingRequestErrors(request[method](url, params));
+            res.data.code === 0 && formRef.current?.setFieldsValue(res.data.data);
+            setLoading(false);
+        }
+    }, { executionPhase: 'mount' });
+    const handleSubmit = useCallback(async (v) => {
+        setSubmitting(true);
+        // 逻辑处理
+        let fetchFn = put;
+        if (props.comName === 'createForm') {
+            fetchFn = post;
+        }
+        try {
+            const res = await handlingRequestErrors(fetchFn(api, v));
+            if (res.data.code === 0) {
+                // 通知
+                schemaEventBus.getState().emitCom({
+                    type: merge(eventsInfo.closeCom, eventsInfo.initTable, props.comName === 'createForm' ? eventsInfo.resetSearch : eventsInfo.none),
+                });
+            }
+        }
+        finally {
+            setSubmitting(false);
+        }
+    }, [api, props.comName]);
+    return (_jsx(Modal, { open: open, onClose: closed, title: getText(config?.title ?? ''), width: 640, maskClosable: !submitting, children: _jsx(SchemaForm, { schemas: schemas, initialValues: defaultValue, getForm: (f) => (formRef.current = f), onFinish: handleSubmit, onCancel: closed, buttonClassName: "justify-end", submitText: config?.saveBtnText, submitButtonProps: { loading: submitting }, cancelButtonProps: { disabled: submitting } }, `${String(props?.comName ?? '')}-${JSON.stringify(defaultValue)}`) }));
+});
+PopForm.displayName = 'PopForm';
+export default PopForm;

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn.d.ts

@@ -0,0 +1,44 @@
+import type { FetchInfo } from '../../../../../../model/types/data/fetchInfo';
+import type { ComponentType, LazyExoticComponent } from 'react';
+type CallComRenderer = ComponentType<any> | LazyExoticComponent<ComponentType<any>>;
+type CallComDefinition<Config> = CallComRenderer & {
+    readonly __config: Config;
+};
+type CreateFormConfig = {
+    /**
+     * 表单标题
+     */
+    title: string;
+    /**
+     *  保存按钮文案
+     */
+    saveBtnText?: string;
+} & Partial<Pick<FetchInfo, 'fetchConfig'>>;
+type EditFormConfig = {
+    /**
+     * 表单标题
+     */
+    title: string;
+    /**
+     *  保存按钮文案
+     */
+    saveBtnText?: string;
+} & FetchInfo;
+type DetailPanelConfig = {
+    /**
+     * 表单标题
+     */
+    title: string;
+} & FetchInfo;
+export declare const baseComponentsMap: {
+    editForm: CallComDefinition<EditFormConfig>;
+    createForm: CallComDefinition<CreateFormConfig>;
+    detailPanel: CallComDefinition<DetailPanelConfig>;
+};
+export type BuiltInCallComNames = Extract<keyof typeof baseComponentsMap, string>;
+type InferCallComConfig<T> = T extends CallComDefinition<infer Config> ? Config : never;
+export type BuiltInCallComConfigMap = {
+    [K in BuiltInCallComNames]?: InferCallComConfig<(typeof baseComponentsMap)[K]>;
+};
+export {};
+//# sourceMappingURL=builtIn.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/builtIn.js

@@ -0,0 +1,7 @@
+import { lazy } from 'react';
+const defineCallCom = (component) => component;
+export const baseComponentsMap = {
+    editForm: defineCallCom(lazy(() => import('./PopFrom'))),
+    createForm: defineCallCom(lazy(() => import('./PopFrom'))),
+    detailPanel: defineCallCom(lazy(() => import('./DetailPanel'))),
+};

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/data.d.ts

@@ -0,0 +1,4 @@
+import type { CallComComponentsMap } from '../../schemaType';
+export declare const components: CallComComponentsMap;
+export type { CallComComponentsMap };
+//# sourceMappingURL=data.d.ts.map

package/fe/frontend/src/defaultPages/SchemaPage/components/CallCom/data.js

@@ -0,0 +1,6 @@
+import consumerComponentsMap from '@tc/scalability/SchemaPage/CallCom/data';
+import { baseComponentsMap } from './builtIn';
+export const components = {
+    ...baseComponentsMap,
+    ...consumerComponentsMap,
+};

package/fe/frontend/src/defaultPages/SchemaPage/components/SchemaSearch/index.d.ts

@@ -0,0 +1,3 @@
+declare const SchemaSearch: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export default SchemaSearch;
+//# sourceMappingURL=index.d.ts.map