@lark-apaas/miaoda-core 0.1.0-alpha.1

package/lib/components/theme/util.d.ts

@@ -0,0 +1,20 @@
+import { type ThemeConfig } from 'antd';
+import { UIComponentConfig } from './ui-config';
+export type IThemeMode = 'dark' | 'light' | 'system';
+export interface IThemeMeta {
+    /**
+     * 品牌色
+     */
+    colorPrimary: string;
+    /**
+     * 边框圆角
+     */
+    borderRadius: number;
+    /**
+     * 疏密度（间距）
+     */
+    spacing: number;
+}
+export declare const generateTailwindRadiusToken: (radiusRemValue: number) => UIComponentConfig;
+export declare function generateLightTheme(override?: Partial<IThemeMeta>): ThemeConfig;
+export declare function generateDarkTheme(override?: Partial<IThemeMeta>): ThemeConfig;

package/lib/components/theme/util.js

@@ -0,0 +1,188 @@
+import { generate } from "@ant-design/colors";
+import { defaultDarkTheme } from "./miaoDarkTheme.js";
+import { defaultLightTheme } from "./miaoLightTheme.js";
+const generateColorPalettes = (baseColor, mode)=>{
+    const colors = generate(baseColor, {
+        theme: mode
+    });
+    return {
+        1: colors[0],
+        2: colors[1],
+        3: colors[2],
+        4: colors[3],
+        5: colors[6],
+        6: colors[5],
+        7: colors[4],
+        8: colors[6],
+        9: colors[5],
+        10: colors[4]
+    };
+};
+function generateColorPrimaryToken(colorPrimary, mode = 'light') {
+    const primaryColors = generateColorPalettes(colorPrimary, 'dark' === mode ? 'dark' : 'default');
+    return {
+        colorPrimaryBg: primaryColors[1],
+        colorPrimaryBgHover: primaryColors[2],
+        colorPrimaryBorder: primaryColors[3],
+        colorPrimaryBorderHover: primaryColors[4],
+        colorPrimaryHover: primaryColors[5],
+        colorPrimary: primaryColors[6],
+        colorPrimaryActive: primaryColors[7],
+        colorPrimaryTextHover: primaryColors[8],
+        colorPrimaryText: primaryColors[9],
+        colorPrimaryTextActive: primaryColors[10]
+    };
+}
+const generateBorderRadiusTokenSyncTailwind = (radiusBase)=>({
+        borderRadius: radiusBase,
+        borderRadiusXS: radiusBase - 4,
+        borderRadiusSM: radiusBase - 2,
+        borderRadiusLG: radiusBase + 2,
+        borderRadiusOuter: radiusBase + 4
+    });
+const generateSpacingToken = (token)=>{
+    const { sizeUnit, sizeStep } = token;
+    return {
+        sizeXXL: sizeUnit * (sizeStep + 8),
+        sizeXL: sizeUnit * (sizeStep + 4),
+        sizeLG: sizeUnit * (sizeStep + 2),
+        sizeMD: sizeUnit * (sizeStep + 1),
+        sizeMS: sizeUnit * sizeStep,
+        size: sizeUnit * sizeStep,
+        sizeSM: sizeUnit * (sizeStep - 1),
+        sizeXS: sizeUnit * (sizeStep - 2),
+        sizeXXS: sizeUnit * (sizeStep - 3)
+    };
+};
+const generateTailwindRadiusToken = (radiusRemValue)=>{
+    try {
+        const rootFontSize = parseFloat(getComputedStyle(document.documentElement).fontSize);
+        const radiusPx = radiusRemValue * rootFontSize;
+        const tempElement = document.createElement('div');
+        tempElement.style.position = 'absolute';
+        tempElement.style.visibility = 'hidden';
+        document.body.appendChild(tempElement);
+        tempElement.style.borderRadius = `${radiusPx}px`;
+        const computed = getComputedStyle(tempElement).borderRadius;
+        document.body.removeChild(tempElement);
+        if (computed && 'auto' !== computed && 'initial' !== computed) return {
+            type: 'select',
+            options: [
+                {
+                    value: 'rounded-none',
+                    label: 'none（0px）',
+                    rawValue: '0'
+                },
+                {
+                    value: 'rounded-sm',
+                    label: `sm (${Math.max(0, radiusPx - 4)}px)`,
+                    rawValue: `${Math.max(0, radiusPx - 4)}`
+                },
+                {
+                    value: 'rounded',
+                    label: 's (4px)',
+                    rawValue: '4'
+                },
+                {
+                    value: 'rounded-md',
+                    label: `m (${Math.max(0, radiusPx - 2)}px)`,
+                    rawValue: `${Math.max(0, radiusPx - 2)}`
+                },
+                {
+                    value: 'rounded-lg',
+                    label: `l (${radiusPx}px)`,
+                    rawValue: `${radiusPx}`
+                },
+                {
+                    value: 'rounded-xl',
+                    label: `xl (${radiusPx + 4}px)`,
+                    rawValue: `${radiusPx + 4}`
+                },
+                {
+                    value: 'rounded-2xl',
+                    label: '2xl (16px)',
+                    rawValue: '16'
+                },
+                {
+                    value: 'rounded-full',
+                    label: 'Full',
+                    rawValue: '9999'
+                }
+            ]
+        };
+        throw new Error('Browser calculation validation failed');
+    } catch (error) {
+        console.warn('Failed to get computed values from browser, falling back to default calculation:', error);
+        const radiusPx = 16 * radiusRemValue;
+        return {
+            type: 'select',
+            options: [
+                {
+                    value: 'rounded-none',
+                    label: 'none（0px）',
+                    rawValue: '0'
+                },
+                {
+                    value: 'rounded-sm',
+                    label: `sm (${Math.max(0, radiusPx - 4)}px)`,
+                    rawValue: `${Math.max(0, radiusPx - 4)}`
+                },
+                {
+                    value: 'rounded',
+                    label: 's (4px)',
+                    rawValue: '4'
+                },
+                {
+                    value: 'rounded-md',
+                    label: `m (${Math.max(0, radiusPx - 2)}px)`,
+                    rawValue: `${Math.max(0, radiusPx - 2)}`
+                },
+                {
+                    value: 'rounded-lg',
+                    label: `l (${radiusPx}px)`,
+                    rawValue: `${radiusPx}`
+                },
+                {
+                    value: 'rounded-xl',
+                    label: `xl (${radiusPx + 4}px)`,
+                    rawValue: `${radiusPx + 4}`
+                },
+                {
+                    value: 'rounded-2xl',
+                    label: '2xl (16px)',
+                    rawValue: '16'
+                },
+                {
+                    value: 'rounded-full',
+                    label: 'Full',
+                    rawValue: '9999'
+                }
+            ]
+        };
+    }
+};
+const lightColorPrimary = '#1456f0';
+const darkColorPrimary = '#336df4';
+function generateLightTheme(override) {
+    return {
+        ...defaultLightTheme,
+        token: {
+            ...defaultLightTheme.token,
+            ...generateColorPrimaryToken(override?.colorPrimary || lightColorPrimary, 'light'),
+            ...generateBorderRadiusTokenSyncTailwind(override?.borderRadius || 4),
+            ...generateSpacingToken(override)
+        }
+    };
+}
+function generateDarkTheme(override) {
+    return {
+        ...defaultDarkTheme,
+        token: {
+            ...defaultDarkTheme.token,
+            ...generateColorPrimaryToken(override?.colorPrimary || darkColorPrimary, 'dark'),
+            ...generateBorderRadiusTokenSyncTailwind(override?.borderRadius || 4),
+            ...generateSpacingToken(override)
+        }
+    };
+}
+export { generateDarkTheme, generateLightTheme, generateTailwindRadiusToken };

package/lib/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useCurrentAppInfo';
+export * from './useCurrentUserProfile';
+export * from './useIsMobile';
+export * from './useLogout';
+export * from './useTheme';

package/lib/hooks/index.js

@@ -0,0 +1,5 @@
+export * from "./useCurrentAppInfo.js";
+export * from "./useCurrentUserProfile.js";
+export * from "./useIsMobile.js";
+export * from "./useLogout.js";
+export * from "./useTheme.js";

package/lib/hooks/useCurrentAppInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const useCurrentAppInfo: () => {
+    appName: string;
+    appLogo: string;
+    name?: string;
+    avatar?: string;
+};

package/lib/hooks/useCurrentAppInfo.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from "react";
+import { getAppInfo } from "../integrations/getAppInfo.js";
+const useCurrentAppInfo = ()=>{
+    const [appInfo, setAppInfo] = useState(()=>getAppInfo());
+    useEffect(()=>{
+        const handleMetaInfoChanged = ()=>{
+            setAppInfo(getAppInfo());
+        };
+        window.addEventListener('MiaoDaMetaInfoChanged', handleMetaInfoChanged);
+        return ()=>{
+            window.removeEventListener('MiaoDaMetaInfoChanged', handleMetaInfoChanged);
+        };
+    }, []);
+    return {
+        ...appInfo,
+        appName: appInfo.name,
+        appLogo: appInfo.avatar
+    };
+};
+export { useCurrentAppInfo };

package/lib/hooks/useCurrentUserProfile.d.ts

@@ -0,0 +1,12 @@
+import { IUserProfile } from '../apis/udt-types';
+export interface ICompatibilityUserProfile extends IUserProfile {
+    /**
+     * @deprecated please use `name`
+     */
+    userName: string;
+    /**
+     * @deprecated please use `avatar`
+     */
+    userAvatar: string;
+}
+export declare const useCurrentUserProfile: () => ICompatibilityUserProfile;

package/lib/hooks/useCurrentUserProfile.js

@@ -0,0 +1,26 @@
+import { useEffect, useState } from "react";
+import { logger } from "../logger/index.js";
+import { getCurrentUserProfile } from "../integrations/getCurrentUserProfile.js";
+function getCompatibilityUserProfile() {
+    const userInfo = getCurrentUserProfile();
+    return {
+        ...userInfo,
+        userName: userInfo.name,
+        userAvatar: userInfo.avatar
+    };
+}
+const useCurrentUserProfile = ()=>{
+    const [userInfo, setUserInfo] = useState(()=>getCompatibilityUserProfile());
+    useEffect(()=>{
+        const handleMetaInfoChanged = ()=>{
+            logger.info('MiaoDaMetaInfoChanged', getCurrentUserProfile());
+            setUserInfo(getCompatibilityUserProfile());
+        };
+        window.addEventListener('MiaoDaMetaInfoChanged', handleMetaInfoChanged);
+        return ()=>{
+            window.removeEventListener('MiaoDaMetaInfoChanged', handleMetaInfoChanged);
+        };
+    }, []);
+    return userInfo;
+};
+export { useCurrentUserProfile };

package/lib/hooks/useIsMobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/lib/hooks/useIsMobile.js

@@ -0,0 +1,20 @@
+import react from "react";
+import { debounce } from "lodash";
+const MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+    const [isMobile, setIsMobile] = react.useState(window.innerWidth < MOBILE_BREAKPOINT);
+    react.useEffect(()=>{
+        const handleResize = ()=>{
+            setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+        };
+        const debouncedHandleResize = debounce(handleResize, 200);
+        window.addEventListener('resize', debouncedHandleResize);
+        handleResize();
+        return ()=>{
+            window.removeEventListener('resize', debouncedHandleResize);
+            debouncedHandleResize.cancel();
+        };
+    }, []);
+    return isMobile;
+}
+export { useIsMobile };

package/lib/hooks/useLogout.d.ts

@@ -0,0 +1,4 @@
+export declare function useLogout(): {
+    handlerLogout: () => Promise<void>;
+    isLoading: boolean;
+};

package/lib/hooks/useLogout.js

@@ -0,0 +1,23 @@
+import { useState } from "react";
+function useLogout() {
+    const [isLoading, setIsLoading] = useState(false);
+    async function handlerLogout() {
+        if ('production' !== process.env.NODE_ENV) return void console.log('只有生产环境才执行登出');
+        setIsLoading(true);
+        try {
+            await fetch('/ai/api/ui/page/logout', {
+                method: 'GET'
+            });
+            window.location.reload();
+        } catch (error) {
+            console.error('登出失败', error);
+        } finally{
+            setIsLoading(false);
+        }
+    }
+    return {
+        handlerLogout,
+        isLoading
+    };
+}
+export { useLogout };

package/lib/hooks/useTheme.d.ts

@@ -0,0 +1,4 @@
+export declare const useTheme: () => {
+    theme: import("../types").ITheme;
+    setTheme: (theme: import("../types").ITheme) => void;
+};

package/lib/hooks/useTheme.js

@@ -0,0 +1,8 @@
+import { useContext } from "react";
+import { ThemeProviderContext } from "../components/theme/index.js";
+const useTheme = ()=>{
+    const context = useContext(ThemeProviderContext);
+    if (void 0 === context) throw new Error('useTheme 必须在 ThemeProvider 内使用');
+    return context;
+};
+export { useTheme };

package/lib/hooks/useUpdatingRef.d.ts

@@ -0,0 +1 @@
+export declare function useUpdatingRef<T>(value: T): import("react").MutableRefObject<T>;

package/lib/hooks/useUpdatingRef.js

@@ -0,0 +1,7 @@
+import { useRef } from "react";
+function useUpdatingRef(value) {
+    const ref = useRef(value);
+    ref.current = value;
+    return ref;
+}
+export { useUpdatingRef };

package/lib/index.css

@@ -0,0 +1,3 @@
+@import "./tailwind-theme.css";
+@import "./override.css";
+

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    version: string;
+};
+export default _default;

package/lib/index.js

@@ -0,0 +1,5 @@
+import { version } from "../package.json";
+const src = {
+    version: version
+};
+export { src as default };

package/lib/integrations/dataloom.d.ts

@@ -0,0 +1 @@
+export declare const dataloom: import("@data-loom/js").DataloomClient<any, "public", any>;

package/lib/integrations/dataloom.js

@@ -0,0 +1,18 @@
+import { splitWorkspaceUrl } from "../utils/url.js";
+import { createClient } from "@data-loom/js";
+const PAT_URL_NAMESPACE = 'FEISUDA_UUU';
+const PAT_TOKEN_NAMESPACE = 'FEISUDA_TTT';
+const DATALOOM_CLIENT_URL = window[PAT_URL_NAMESPACE];
+const DATALOOM_PAT = window[PAT_TOKEN_NAMESPACE];
+const createDataLoomClient = (url, pat)=>{
+    if (!url || !pat) return null;
+    const { baseUrl, workspace } = splitWorkspaceUrl(url);
+    return createClient(baseUrl, pat, workspace, {
+        global: {
+            enablePostgresBuilderLog: 'production' !== process.env.NODE_ENV,
+            requestRateLimit: 'production' !== process.env.NODE_ENV ? 100 : void 0
+        }
+    });
+};
+const dataloom = createDataLoomClient(DATALOOM_CLIENT_URL, DATALOOM_PAT);
+export { dataloom };

package/lib/integrations/generateImage.d.ts

@@ -0,0 +1 @@
+export declare function generateImage(prompt: string, size?: string, headers?: Record<string, string>): Promise<any>;

package/lib/integrations/generateImage.js

@@ -0,0 +1,32 @@
+import { getAppId } from "../utils/getAppId.js";
+import { getEnvPath } from "../utils/getEnvPath.js";
+async function generateImage(prompt, size = '1024x1024', headers = {}) {
+    const appId = getAppId(window.location.pathname);
+    if (!appId) return {
+        code: 1,
+        msg: 'appId is required',
+        data: {}
+    };
+    const defaultHeaders = {
+        'Content-Type': 'application/json'
+    };
+    const mergedHeaders = {
+        ...defaultHeaders,
+        ...headers,
+        'X-Kunlun-Token': window.token,
+        'x-miaoda-token': window.MIAODA_BUILTIN_TTT,
+        'x-lgw-csrf-token': window.lgw_csrf_token,
+        ...window.CSRF_HEADERS || {}
+    };
+    const response = await fetch(`${window.location.origin}/ai/api/${getEnvPath()}/v1/apps/${appId}/text2image`, {
+        method: 'POST',
+        headers: mergedHeaders,
+        credentials: 'include',
+        body: JSON.stringify({
+            prompt: prompt,
+            size: size
+        })
+    });
+    return await response.json();
+}
+export { generateImage };

package/lib/integrations/generateTextStream.d.ts

@@ -0,0 +1,26 @@
+declare global {
+    interface Window {
+        token?: string;
+    }
+}
+interface GenerateTextOptions {
+    text: string;
+    thinking_type?: 'enabled' | 'disabled';
+    headers?: Record<string, string>;
+}
+interface GenerateTextResult {
+    content: string;
+    reasoning_content: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * 文生文 - 流式版本
+ * 支持实时接收生成内容的回调
+ */
+export declare function generateTextStream(options: GenerateTextOptions, onChunk?: (chunk: {
+    content: string;
+    reasoning_content: string;
+    finished: boolean;
+}) => void): Promise<GenerateTextResult>;
+export {};

package/lib/integrations/generateTextStream.js

@@ -0,0 +1,83 @@
+import { getAppId } from "../utils/getAppId.js";
+import { getEnvPath } from "../utils/getEnvPath.js";
+async function generateTextStream(options, onChunk) {
+    const { text, thinking_type = 'disabled', headers = {} } = options;
+    const appId = getAppId(window.location.pathname);
+    if (!appId) return {
+        content: '',
+        reasoning_content: '',
+        success: false,
+        error: 'appId is required'
+    };
+    try {
+        const response = await fetch(`${window.location.origin}/ai/api/${getEnvPath()}/v1/apps/${appId}/text/generate`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+                'X-Kunlun-Token': window.token,
+                'x-miaoda-token': window.MIAODA_BUILTIN_TTT,
+                'x-lgw-csrf-token': window.lgw_csrf_token,
+                ...window.CSRF_HEADERS || {}
+            },
+            credentials: 'include',
+            body: JSON.stringify({
+                text,
+                thinking_type
+            })
+        });
+        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+        const reader = response.body?.getReader();
+        if (!reader) throw new Error('无法获取响应流');
+        let fullContent = '';
+        let fullReasoningContent = '';
+        const decoder = new TextDecoder();
+        while(true){
+            const { done, value } = await reader.read();
+            if (done) break;
+            const chunk = decoder.decode(value, {
+                stream: true
+            });
+            const lines = chunk.split('\n').filter((line)=>line.trim());
+            for (const line of lines)if (line.startsWith('data: ')) {
+                const jsonStr = line.slice(6);
+                try {
+                    const data = JSON.parse(jsonStr);
+                    if (0 !== data.code) return {
+                        content: '',
+                        reasoning_content: '',
+                        success: false,
+                        error: data.msg || '生成失败'
+                    };
+                    if (data.data.content) fullContent += data.data.content;
+                    if (data.data.reasoning_content) fullReasoningContent += data.data.reasoning_content;
+                    if (onChunk) onChunk({
+                        content: data.data.content || '',
+                        reasoning_content: data.data.reasoning_content || '',
+                        finished: data.finished
+                    });
+                    if (data.finished) return {
+                        content: fullContent,
+                        reasoning_content: fullReasoningContent,
+                        success: true
+                    };
+                } catch (parseError) {
+                    console.error(`解析JSON失败: ${jsonStr}`);
+                }
+            }
+        }
+        return {
+            content: fullContent,
+            reasoning_content: fullReasoningContent,
+            success: true
+        };
+    } catch (error) {
+        return {
+            content: '',
+            reasoning_content: '',
+            success: false,
+            error: error instanceof Error ? error.message : '未知错误'
+        };
+    }
+}
+export { generateTextStream };

package/lib/integrations/getAppInfo.d.ts

@@ -0,0 +1,2 @@
+import { AppInfoPayload } from '../types/common';
+export declare function getAppInfo(): AppInfoPayload;

package/lib/integrations/getAppInfo.js

@@ -0,0 +1,4 @@
+function getAppInfo() {
+    return window._appInfo || {};
+}
+export { getAppInfo };

package/lib/integrations/getCurrentUserProfile.d.ts

@@ -0,0 +1,6 @@
+import { IUserProfile } from '../apis/udt-types';
+export declare function getCurrentUserProfile(): IUserProfile;
+/**
+ * @deprecated 请使用 getCurrentUserProfile 代替
+ */
+export declare const getUserInfo: typeof getCurrentUserProfile;

package/lib/integrations/getCurrentUserProfile.js

@@ -0,0 +1,5 @@
+function getCurrentUserProfile() {
+    return window._userInfo || {};
+}
+const getUserInfo = getCurrentUserProfile;
+export { getCurrentUserProfile, getUserInfo };

package/lib/logger/index.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    debug(message: any, ...args: any[]): void;
+    info(message: any, ...args: any[]): void;
+    warn(message: any, ...args: any[]): void;
+    error(message: any, ...args: any[]): void;
+};

package/lib/logger/index.js

@@ -0,0 +1,54 @@
+const LOG_LEVELS = [
+    'debug',
+    'info',
+    'warn',
+    'error'
+];
+const defaultConfig = {
+    showLevel: false,
+    showTimestamp: false,
+    level: 'info',
+    prefix: ''
+};
+let config = {
+    ...defaultConfig
+};
+function configureLogger(options) {
+    config = {
+        ...defaultConfig,
+        ...options
+    };
+}
+function getLogLevel() {
+    return config.level;
+}
+function shouldLog(level) {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(getLogLevel());
+}
+function getFormattedPrefix(level) {
+    const parts = [];
+    if (config.prefix) parts.push(`[${config.prefix}]`);
+    if (config.showLevel) parts.push(`[${level.toUpperCase()}]`);
+    return parts;
+}
+configureLogger({
+    showLevel: true,
+    showTimestamp: false,
+    level: 'development' === process.env.NODE_ENV ? 'debug' : 'error',
+    prefix: 'MiaoDa'
+});
+const logger = {
+    debug (message, ...args) {
+        if (shouldLog('debug')) console.log(...getFormattedPrefix('debug'), message, ...args);
+    },
+    info (message, ...args) {
+        if (shouldLog('info')) console.log(...getFormattedPrefix('info'), message, ...args);
+    },
+    warn (message, ...args) {
+        if (shouldLog('warn')) console.log(...getFormattedPrefix('warn'), message, ...args);
+    },
+    error (message, ...args) {
+        if (shouldLog('error')) console.error(...getFormattedPrefix('error'), message, ...args);
+    }
+};
+export { logger };