@_tc/template-core 0.0.1-bate.36 → 0.0.1-bate.37

package/fe/frontend/widgets/common/CRUD/CRUD.js

@@ -0,0 +1,207 @@
+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((h) => h.id === id);
+        if (idx !== -1)
+            this.handlers.splice(idx, 1);
+    }
+    clear() {
+        this.handlers = [];
+    }
+    getHandlers() {
+        return this.handlers;
+    }
+}
+function buildURL(url, baseURL, params) {
+    let fullUrl = baseURL ? `${baseURL.replace(/\/+$/, '')}/${url.replace(/^\/+/, '')}` : url;
+    if (params) {
+        const searchParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined && value !== null) {
+                searchParams.append(key, String(value));
+            }
+        }
+        const query = searchParams.toString();
+        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 applyTransformers(value, transformers) {
+    if (!transformers?.length)
+        return value;
+    return transformers.reduce((acc, fn) => fn(acc), value);
+}
+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);
+        const chain = [];
+        this.interceptors.request.getHandlers().forEach((h) => {
+            chain.unshift({
+                fulfilled: h.fulfilled,
+                rejected: h.rejected,
+            });
+        });
+        chain.push({
+            fulfilled: (cfg) => Promise.resolve(cfg),
+            rejected: undefined,
+        });
+        this.interceptors.response.getHandlers().forEach((h) => {
+            chain.push({
+                fulfilled: h.fulfilled,
+                rejected: h.rejected,
+            });
+        });
+        let currentConfig = merged;
+        for (let i = 0; i < chain.length; i++) {
+            const item = chain[i];
+            const { fulfilled, rejected } = item;
+            try {
+                currentConfig = await fulfilled(currentConfig);
+            }
+            catch (err) {
+                if (rejected) {
+                    void (await rejected(err));
+                }
+                throw err;
+            }
+        }
+        return this._doRequest(currentConfig);
+    }
+    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 = new Headers(rawHeaders);
+        let requestData = data;
+        if (transformRequest && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+            const fns = Array.isArray(transformRequest) ? transformRequest : [transformRequest];
+            requestData = applyTransformers(data, fns);
+            if (isObject(requestData) || Array.isArray(requestData)) {
+                if (!requestHeaders.has('Content-Type')) {
+                    requestHeaders.set('Content-Type', 'application/json');
+                }
+            }
+        }
+        const init = {
+            method,
+            headers: requestHeaders,
+            credentials: credentials ?? 'same-origin',
+            cache: cache,
+            redirect: redirect,
+            referrer: referrer,
+            referrerPolicy: referrerPolicy,
+        };
+        if (requestData !== undefined && method !== 'GET' && method !== 'HEAD') {
+            init.body = typeof requestData === 'string' ? requestData : JSON.stringify(requestData);
+        }
+        const controller = new AbortController();
+        init.signal = config.signal ?? controller.signal;
+        let timeoutId;
+        if (timeout) {
+            timeoutId = setTimeout(() => controller.abort(), timeout);
+        }
+        let response;
+        try {
+            response = await fetch(url, init);
+        }
+        catch (err) {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            const error = this.createError(err instanceof Error ? err : new Error(String(err)), 'ECONNABORTED', config);
+            throw error;
+        }
+        if (timeoutId)
+            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;
+        }
+        else {
+            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;

package/fe/frontend/widgets/common/CRUD/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CRUD';
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/common/CRUD/index.js

@@ -0,0 +1 @@
+export * from './CRUD';

package/fe/frontend/widgets/common/auth/index.d.ts

@@ -0,0 +1,7 @@
+export declare const AUTH_HEADER_KEY = "Authorization";
+export declare function getAuthToken(): Promise<string | null>;
+export declare function clearAuthToken(): Promise<void>;
+export declare const API_AUTH_HEADER_KEY = "projk";
+export declare const getApiAuth: () => string;
+export declare const setApiAuth: (v: string) => void;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/common/auth/index.js

@@ -0,0 +1,20 @@
+const AUTH_LOCAL_KEY = 'auth_token';
+const API_AUTH_LOCAL_KEY = 'p_J_k';
+export const AUTH_HEADER_KEY = 'Authorization';
+export async function getAuthToken() {
+    if (typeof localStorage === 'undefined')
+        return null;
+    return localStorage.getItem(AUTH_LOCAL_KEY);
+}
+export async function clearAuthToken() {
+    if (typeof localStorage === 'undefined')
+        return;
+    localStorage.removeItem(AUTH_LOCAL_KEY);
+}
+export const API_AUTH_HEADER_KEY = 'projk';
+export const getApiAuth = () => {
+    return localStorage.getItem(API_AUTH_LOCAL_KEY) ?? '';
+};
+export const setApiAuth = (v) => {
+    return localStorage.setItem(API_AUTH_LOCAL_KEY, v);
+};

package/fe/frontend/widgets/common/generateMenuData.d.ts

@@ -0,0 +1,4 @@
+import { ProjectInfo } from "../../widgets/api/baseInfo";
+import { MenuItemData } from "../../../packages/ui/react/components";
+export declare const generateMenuItemData: (data: ProjectInfo["menu"]) => MenuItemData[];
+//# sourceMappingURL=generateMenuData.d.ts.map

package/fe/frontend/widgets/common/generateMenuData.js

@@ -0,0 +1,14 @@
+export const generateMenuItemData = (data) => {
+    return data.map((m) => {
+        const children = (m.menuType === "group" && m.subMenu.length
+            ? generateMenuItemData(m.subMenu)
+            : undefined);
+        return {
+            key: m.key,
+            label: m.name,
+            icon: m.icon,
+            children: children,
+            minWidth: 100,
+        };
+    });
+};

package/fe/frontend/widgets/common/importComponent.d.ts

@@ -0,0 +1,5 @@
+import { ComponentType, ReactNode } from 'react';
+export declare const renderImportComponent: (c: Promise<{
+    default: ComponentType<any>;
+}>, fallback?: ReactNode) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=importComponent.d.ts.map

package/fe/frontend/widgets/common/importComponent.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy, Suspense } from 'react';
+export const renderImportComponent = (c, fallback) => {
+    const Component = lazy(() => c);
+    const showFallback = typeof fallback !== 'undefined' ? fallback : 'loading';
+    return (_jsx(Suspense, { fallback: showFallback, children: _jsx(Component, {}) }));
+};

package/fe/frontend/widgets/common/language.d.ts

@@ -0,0 +1,2 @@
+export declare const getText: (key: string) => string;
+//# sourceMappingURL=language.d.ts.map

package/fe/frontend/widgets/common/language.js

@@ -0,0 +1,8 @@
+import { i18n } from '../../../packages/ui/react/i18n';
+const useI18nKey = '$i18n_';
+export const getText = (key) => {
+    if (key.includes(useI18nKey)) {
+        return i18n(key);
+    }
+    return key;
+};

package/fe/frontend/widgets/common/logFn/index.d.ts

@@ -0,0 +1,4 @@
+export declare const logPageNotFound: () => void;
+export declare const logIllegalComponentCallback: (comName: string) => void;
+export declare const logSubscriptionError: () => void;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/common/logFn/index.js

@@ -0,0 +1,8 @@
+const logJoin = (...logs) => logs.join(`
+    ---------
+    `);
+export const logPageNotFound = () => {
+    console.error(logJoin('url有问题 或者 自定义页面未在路由器注册', 'The URL is incorrect, or the custom page is not registered with the router.'));
+};
+export const logIllegalComponentCallback = (comName) => console.error(logJoin(`非法的组件回调 - ${comName}`, `Illegal component callback - ${comName}`));
+export const logSubscriptionError = () => console.error(logJoin('不曾订阅过，请检查代码，关注函数与取消函数必须为同一个', "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same."));

package/fe/frontend/widgets/common/menu.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectInfo } from "../../widgets/api/baseInfo";
+type MenuItem = {
+    key: string;
+    name: string;
+    path: Partial<{
+        pathname: string;
+        search: string;
+        hash: string;
+    }>;
+};
+export declare const enum QK {
+    pk = "projk",
+    k = "key",
+    sk = "sidek",
+    ck = "custk"
+}
+export declare const leftSidebarBasePath = "_sidebar_";
+export declare const deserializationUrlSearch: <T = Record<string, string>>(url?: string) => T;
+export declare const serializationUrl: (url: string, data: Record<string, string>) => string;
+export declare const findMenuItem: <T = Record<string, any>>(menuData: ProjectInfo["menu"], key?: string) => MenuItem & T;
+export {};
+//# sourceMappingURL=menu.d.ts.map

package/fe/frontend/widgets/common/menu.js

@@ -0,0 +1,80 @@
+import { modeStore } from "../../widgets/store/mode";
+export var QK;
+(function (QK) {
+    QK["pk"] = "projk";
+    QK["k"] = "key";
+    QK["sk"] = "sidek";
+    QK["ck"] = "custk";
+})(QK || (QK = {}));
+export const leftSidebarBasePath = "_sidebar_";
+export const deserializationUrlSearch = (url = window.location.search) => {
+    const urls = new URLSearchParams(url);
+    const data = {};
+    for (const [k, v] of urls.entries()) {
+        data[k] = v;
+    }
+    return data;
+};
+export const serializationUrl = (url, data) => `${url}?${new URLSearchParams(data).toString()}`;
+const generateMenuItem = (item) => {
+    let data = undefined;
+    if (item.menuType === "module") {
+        const pk = modeStore.getState().projestInfo?.key;
+        const query = {
+            [QK.pk]: pk,
+        };
+        switch (item.moduleType) {
+            case "custom":
+                query[QK.ck] = item.key;
+                data = {
+                    ...item,
+                    path: {
+                        pathname: item.customConfig.path,
+                        search: new URLSearchParams(query).toString(),
+                    },
+                };
+                break;
+            case "iframe":
+            case "schema":
+            case "sidebar":
+                let path = `/${item.key}`;
+                let search = new URLSearchParams(query).toString();
+                if (item.moduleType === "sidebar") {
+                    const sfMenu = findMenuItem(item.sidebarConfig.menu, item.sidebarConfig.menu[0].key);
+                    path += `${sfMenu.path.pathname}`;
+                    search = sfMenu.path.search ?? "";
+                }
+                data = {
+                    ...item,
+                    path: {
+                        pathname: path,
+                        search,
+                    },
+                };
+                break;
+            default:
+                break;
+        }
+    }
+    return data;
+};
+export const findMenuItem = (menuData, key) => {
+    let data = undefined;
+    const useFirstAvailableMenu = typeof key === "undefined";
+    for (const item of menuData) {
+        if (item.menuType === "module") {
+            if (useFirstAvailableMenu || item.key === key) {
+                data = generateMenuItem(item);
+                break;
+            }
+        }
+        if (item.menuType === "group") {
+            const result = findMenuItem(item.subMenu, key);
+            if (result) {
+                data = { ...result };
+                break;
+            }
+        }
+    }
+    return data;
+};

package/fe/frontend/widgets/common/request.d.ts

@@ -0,0 +1,33 @@
+import { AxiosError, FetchAxios, RequestConfig, ResponseConfig } from './CRUD';
+declare const api: FetchAxios;
+export interface PageParams {
+    page?: number;
+    pageSize?: number;
+    [key: string]: string | number | boolean | undefined | null;
+}
+export type PageResponse<T> = {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+export interface BaseResponse<T> {
+    data: T;
+    code: number;
+    message: string;
+}
+export declare function get<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare function post<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare function put<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare function patch<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare function del<T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>): Promise<ResponseConfig<BaseResponse<T>, D>>;
+export { api, FetchAxios };
+export type { AxiosError, RequestConfig, ResponseConfig };
+export declare const request: {
+    get: typeof get;
+    put: typeof put;
+    post: typeof post;
+    del: typeof del;
+    patch: typeof patch;
+};
+//# sourceMappingURL=request.d.ts.map

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

@@ -0,0 +1,127 @@
+import md5 from 'md5';
+import { API_AUTH_HEADER_KEY, AUTH_HEADER_KEY, clearAuthToken, getApiAuth, getAuthToken } from './auth';
+import { FetchAxios } from './CRUD';
+const BASE_URL = '/api';
+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}`;
+};
+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;
+});
+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);
+});
+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';
+}
+export function get(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 function post(url, data, config) {
+    return api.post(url, data, config);
+}
+export function put(url, data, config) {
+    return api.put(url, data, config);
+}
+export function patch(url, data, config) {
+    return api.patch(url, data, config);
+}
+export function del(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/widgets/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/widgets/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(--theme-primary) / 0.18)",
+};
+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-16 items-center border-b", "shadow-[0_10px_30px_var(--header-shadow)]"), children: [_jsx("div", { className: "brand flex w-60 items-center border-r border-[hsl(var(--theme-bg)/0.14)] px-6 text-base font-semibold tracking-[0.02em] text-(--header-fg)", children: title ?? defaultTitle }), _jsx("div", { className: "top-menu flex flex-1 items-center px-6 text-(--header-fg)", children: menu }), _jsx("div", { className: "user-area flex items-center justify-end border-l border-[hsl(var(--theme-bg)/0.14)] px-6 text-(--header-fg)", children: userArea })] }), children] }));
+};
+export default HeaderView;

package/fe/frontend/widgets/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/widgets/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/widgets/components/Router/type.d.ts

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

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

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

package/fe/frontend/widgets/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/widgets/defaultPages/Iframe/index.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import useCurrentMenuData from "../../../widgets/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/widgets/defaultPages/Schema/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