@bytexbyte/nxtlinq-ai-agent-web-development 0.1.1

package/dist/legacy/core/lib/useVoiceMode.js

@@ -0,0 +1,373 @@
+import * as React from 'react';
+import { flushSync } from 'react-dom';
+import { mergeStreamingTranscript, normalizeTranscriptKey, } from '../../api/voice';
+import { appendServerHistoryIntoMessages } from './messageHistory';
+import { useVoiceTranscriptMessages } from '../../../voice/useVoiceTranscriptMessages';
+import { useWsRealtimeAudio } from '../../../voice/useWsRealtimeAudio';
+const TURN_SETTLE_MS = 1500;
+const VOICE_HISTORY_SYNC_LAST = 20;
+const USER_TRANSCRIPT_BLOCKED = new Set([
+    'thinking', 'generating', 'speaking',
+]);
+const ASSISTANT_MIC_HOLD_STATUSES = new Set([
+    'transcribing', 'thinking', 'generating', 'speaking',
+]);
+export function useVoiceMode({ apiKey, apiSecret, pseudoId, externalId, aitId, walletAddress, aitToken, metadata, nxtlinqApi, getMessages, setMessages, onError, stopRecording, stopTextToSpeech, voiceTransport = 'ws-realtime', }) {
+    const [isVoiceMode, setIsVoiceMode] = React.useState(false);
+    const [voiceStatus, setVoiceStatus] = React.useState('idle');
+    const [isVoiceConnecting, setIsVoiceConnecting] = React.useState(false);
+    const [isMicMuted, setIsMicMuted] = React.useState(true);
+    const [isMicCaptureActive, setIsMicCaptureActive] = React.useState(false);
+    const [voiceSessionId, setVoiceSessionId] = React.useState(null);
+    const sessionRef = React.useRef(null);
+    const remoteAudioRef = React.useRef(null);
+    const voiceStatusRef = React.useRef('idle');
+    const activeTurnRef = React.useRef(false);
+    const historyRefreshInFlightRef = React.useRef(null);
+    const turnUserTextRef = React.useRef('');
+    const lastCommittedUserRef = React.useRef('');
+    const userMicMutedRef = React.useRef(true);
+    const userMicOptInRef = React.useRef(false);
+    const assistantMicHoldRef = React.useRef(false);
+    const voiceConnectGenerationRef = React.useRef(0);
+    const connectInFlightRef = React.useRef(false);
+    const turnSettleUntilRef = React.useRef(0);
+    const syncVoiceTurnHistory = React.useCallback(async (last = VOICE_HISTORY_SYNC_LAST) => {
+        if (historyRefreshInFlightRef.current)
+            return historyRefreshInFlightRef.current;
+        const run = (async () => {
+            const result = await nxtlinqApi.agent.getMessageHistory({
+                apiKey, apiSecret, pseudoId, externalId, last,
+            });
+            if ('error' in result) {
+                onError?.(new Error(result.error));
+                return;
+            }
+            flushSync(() => {
+                setMessages((prev) => appendServerHistoryIntoMessages(prev, result.messages));
+            });
+        })().finally(() => { historyRefreshInFlightRef.current = null; });
+        historyRefreshInFlightRef.current = run;
+        return run;
+    }, [apiKey, apiSecret, pseudoId, externalId, nxtlinqApi, setMessages, onError]);
+    const voiceSessionIdRef = React.useRef(null);
+    const transcriptApi = React.useMemo(() => ({
+        getMessages,
+        setMessages: (messages) => setMessages(messages),
+        syncVoiceTurnHistory: (opts) => syncVoiceTurnHistory(opts?.last),
+    }), [getMessages, setMessages, syncVoiceTurnHistory]);
+    const { handleTranscript: handleTranscriptUi, handleDone: handleDoneUi, clearVoiceStream } = useVoiceTranscriptMessages(transcriptApi, 'voice', voiceSessionId, () => voiceSessionIdRef.current);
+    const resetMicAfterTurn = React.useCallback(() => {
+        lastCommittedUserRef.current = turnUserTextRef.current.trim();
+        turnUserTextRef.current = '';
+        activeTurnRef.current = false;
+        turnSettleUntilRef.current = Date.now() + TURN_SETTLE_MS;
+        userMicMutedRef.current = true;
+        userMicOptInRef.current = false;
+        setIsMicCaptureActive(false);
+        applyMicStateRef.current();
+    }, []);
+    const applyMicState = React.useCallback(() => {
+        const shouldMute = userMicMutedRef.current || assistantMicHoldRef.current;
+        sessionRef.current?.muteMic(shouldMute);
+        setIsMicMuted(shouldMute);
+        const captureActive = isVoiceMode && !shouldMute && userMicOptInRef.current;
+        setIsMicCaptureActive(captureActive);
+    }, [isVoiceMode]);
+    const applyMicStateRef = React.useRef(applyMicState);
+    applyMicStateRef.current = applyMicState;
+    const wsAudio = useWsRealtimeAudio(isMicCaptureActive, isVoiceMode, {
+        voiceStatus,
+        muteAfterSilenceCommit: () => {
+            userMicMutedRef.current = true;
+            userMicOptInRef.current = false;
+            setIsMicCaptureActive(false);
+            applyMicStateRef.current();
+        },
+    });
+    const wsAudioRef = React.useRef(wsAudio);
+    wsAudioRef.current = wsAudio;
+    const setAssistantMicHold = React.useCallback((held) => {
+        if (assistantMicHoldRef.current === held)
+            return;
+        assistantMicHoldRef.current = held;
+        applyMicState();
+    }, [applyMicState]);
+    const attachRemoteAudio = React.useCallback(() => {
+        if (voiceTransport === 'ws-realtime')
+            return false;
+        const session = sessionRef.current;
+        const audio = remoteAudioRef.current;
+        if (!session || !audio)
+            return false;
+        const stream = session.getRemoteAudioStream();
+        if (stream) {
+            audio.srcObject = stream;
+            void audio.play().catch(() => { });
+            return true;
+        }
+        return false;
+    }, [voiceTransport]);
+    const beginTurn = React.useCallback(() => { activeTurnRef.current = true; }, []);
+    const handleTranscriptTurn = React.useCallback((event) => {
+        if (event.role !== 'user')
+            return;
+        if (Date.now() < turnSettleUntilRef.current)
+            return;
+        if (userMicMutedRef.current)
+            return;
+        if (!userMicOptInRef.current && !activeTurnRef.current)
+            return;
+        if (assistantMicHoldRef.current || USER_TRANSCRIPT_BLOCKED.has(voiceStatusRef.current))
+            return;
+        if (!activeTurnRef.current)
+            beginTurn();
+        const merged = (event.interim === false && event.text.trim())
+            ? event.text.trim()
+            : mergeStreamingTranscript(turnUserTextRef.current, event.text);
+        turnUserTextRef.current = merged;
+        if (lastCommittedUserRef.current &&
+            normalizeTranscriptKey(merged) === normalizeTranscriptKey(lastCommittedUserRef.current)) {
+            turnUserTextRef.current = '';
+            return;
+        }
+        if (!event.interim && event.text.trim())
+            lastCommittedUserRef.current = '';
+    }, [beginTurn]);
+    const handleStatus = React.useCallback((status) => {
+        const prev = voiceStatusRef.current;
+        if (status === 'listening' && userMicMutedRef.current && !activeTurnRef.current &&
+            Date.now() < turnSettleUntilRef.current)
+            return;
+        voiceStatusRef.current = status;
+        setVoiceStatus(status);
+        if (ASSISTANT_MIC_HOLD_STATUSES.has(status))
+            setAssistantMicHold(true);
+        else if (status === 'listening' || status === 'idle')
+            setAssistantMicHold(false);
+        if (status === 'transcribing' && prev === 'listening')
+            beginTurn();
+        if (status === 'generating' && prev !== 'generating')
+            beginTurn();
+        if (status === 'listening' && prev === 'speaking')
+            resetMicAfterTurn();
+    }, [beginTurn, resetMicAfterTurn, setAssistantMicHold]);
+    const handleDone = React.useCallback((event) => {
+        if (event.guardrailsBlocked || event.billingBlocked) {
+            activeTurnRef.current = false;
+            return;
+        }
+        if (event.error) {
+            onError?.(new Error(event.error));
+            return;
+        }
+        handleDoneUi(event);
+        resetMicAfterTurn();
+    }, [handleDoneUi, onError, resetMicAfterTurn]);
+    const voiceHandlersRef = React.useRef({
+        onStatus: (_status) => { },
+        onTranscript: (_event) => { },
+        onDone: (_event) => { },
+    });
+    const stopVoiceSession = React.useCallback(async (reason = 'unknown') => {
+        const session = sessionRef.current;
+        if (!session && !voiceSessionIdRef.current)
+            return;
+        sessionRef.current = null;
+        voiceSessionIdRef.current = null;
+        setVoiceSessionId(null);
+        clearVoiceStream();
+        if (voiceTransport === 'ws-realtime')
+            wsAudioRef.current.bindSession(null);
+        if (session) {
+            try {
+                await session.stop();
+            }
+            catch { /* best-effort */ }
+        }
+        const audio = remoteAudioRef.current;
+        if (audio)
+            audio.srcObject = null;
+        voiceStatusRef.current = 'idle';
+        setVoiceStatus('idle');
+        userMicMutedRef.current = true;
+        userMicOptInRef.current = false;
+        assistantMicHoldRef.current = false;
+        turnSettleUntilRef.current = 0;
+        setIsMicMuted(true);
+        setIsMicCaptureActive(false);
+        lastCommittedUserRef.current = '';
+        turnUserTextRef.current = '';
+        activeTurnRef.current = false;
+    }, [clearVoiceStream, voiceTransport]);
+    const stopVoiceSessionRef = React.useRef(stopVoiceSession);
+    stopVoiceSessionRef.current = stopVoiceSession;
+    const exitVoiceMode = React.useCallback(async () => {
+        voiceConnectGenerationRef.current += 1;
+        setIsVoiceMode(false);
+        setIsVoiceConnecting(false);
+        await stopVoiceSession('exitVoiceMode');
+    }, [stopVoiceSession]);
+    const enterVoiceMode = React.useCallback(async () => {
+        if (connectInFlightRef.current || sessionRef.current)
+            return;
+        connectInFlightRef.current = true;
+        const connectGeneration = voiceConnectGenerationRef.current + 1;
+        voiceConnectGenerationRef.current = connectGeneration;
+        const isConnectCancelled = () => connectGeneration !== voiceConnectGenerationRef.current;
+        stopRecording();
+        stopTextToSpeech();
+        setIsVoiceMode(true);
+        setIsVoiceConnecting(true);
+        clearVoiceStream();
+        lastCommittedUserRef.current = '';
+        turnUserTextRef.current = '';
+        voiceStatusRef.current = 'idle';
+        setVoiceStatus('idle');
+        userMicMutedRef.current = true;
+        userMicOptInRef.current = false;
+        assistantMicHoldRef.current = false;
+        turnSettleUntilRef.current = 0;
+        setIsMicMuted(true);
+        setIsMicCaptureActive(false);
+        activeTurnRef.current = false;
+        const wsCallbacks = voiceTransport === 'ws-realtime'
+            ? wsAudioRef.current.buildCallbacks({
+                onOpen: () => {
+                    if (isConnectCancelled())
+                        return;
+                    voiceStatusRef.current = 'listening';
+                    setVoiceStatus('listening');
+                    assistantMicHoldRef.current = false;
+                    applyMicState();
+                },
+                onClose: () => {
+                    if (isConnectCancelled())
+                        return;
+                    voiceStatusRef.current = 'idle';
+                    setVoiceStatus('idle');
+                    connectInFlightRef.current = false;
+                },
+                onError: (err) => {
+                    if (isConnectCancelled())
+                        return;
+                    onError?.(err);
+                },
+            })
+            : undefined;
+        try {
+            let session;
+            session = await nxtlinqApi.voice.startSession({
+                apiKey, apiSecret, pseudoId, externalId, aitId, walletAddress, aitToken,
+                voiceMode: 'realtime',
+                transport: voiceTransport,
+                startWithMicMuted: true,
+                metadata,
+                onAudioDelta: wsCallbacks?.onAudioDelta,
+                onOpen: wsCallbacks?.onOpen ?? (() => {
+                    if (isConnectCancelled()) {
+                        void session?.stop();
+                        return;
+                    }
+                    voiceStatusRef.current = 'listening';
+                    setVoiceStatus('listening');
+                    assistantMicHoldRef.current = false;
+                    applyMicState();
+                    const tryAttach = () => { if (!attachRemoteAudio())
+                        window.setTimeout(tryAttach, 100); };
+                    tryAttach();
+                }),
+                onClose: wsCallbacks?.onClose ?? (() => {
+                    if (isConnectCancelled())
+                        return;
+                    voiceStatusRef.current = 'idle';
+                    setVoiceStatus('idle');
+                    connectInFlightRef.current = false;
+                }),
+                onStatus: (status) => voiceHandlersRef.current.onStatus(status),
+                onTranscript: (event) => voiceHandlersRef.current.onTranscript(event),
+                onDone: (event) => voiceHandlersRef.current.onDone(event),
+                onError: (err) => {
+                    if (isConnectCancelled())
+                        return;
+                    onError?.(err);
+                },
+            });
+            if (isConnectCancelled()) {
+                await session.stop();
+                return;
+            }
+            voiceSessionIdRef.current = session.id;
+            sessionRef.current = session;
+            setVoiceSessionId(session.id);
+            if (voiceTransport === 'ws-realtime') {
+                wsAudioRef.current.bindSession(session, false);
+            }
+            else {
+                session.muteMic(true);
+                const tryAttach = () => { if (!attachRemoteAudio())
+                    window.setTimeout(tryAttach, 100); };
+                tryAttach();
+            }
+        }
+        catch (err) {
+            if (isConnectCancelled())
+                return;
+            onError?.(err instanceof Error ? err : new Error(String(err)));
+            setIsVoiceMode(false);
+            await stopVoiceSession('enterVoiceMode_error');
+        }
+        finally {
+            connectInFlightRef.current = false;
+            if (!isConnectCancelled())
+                setIsVoiceConnecting(false);
+        }
+    }, [
+        apiKey, apiSecret, pseudoId, externalId, aitId, walletAddress, aitToken, metadata,
+        nxtlinqApi, stopRecording, stopTextToSpeech, attachRemoteAudio,
+        onError, stopVoiceSession, applyMicState, voiceTransport, clearVoiceStream,
+    ]);
+    const toggleMicMute = React.useCallback(() => {
+        if (!sessionRef.current)
+            return;
+        if (assistantMicHoldRef.current && userMicMutedRef.current)
+            return;
+        if (assistantMicHoldRef.current) {
+            userMicMutedRef.current = true;
+            applyMicState();
+            return;
+        }
+        const nextMuted = !userMicMutedRef.current;
+        userMicMutedRef.current = nextMuted;
+        userMicOptInRef.current = !nextMuted;
+        if (!nextMuted)
+            turnSettleUntilRef.current = 0;
+        applyMicState();
+    }, [applyMicState]);
+    const interruptVoice = React.useCallback(() => {
+        sessionRef.current?.interrupt();
+        setAssistantMicHold(false);
+    }, [setAssistantMicHold]);
+    React.useEffect(() => {
+        voiceHandlersRef.current = {
+            onStatus: handleStatus,
+            onTranscript: (event) => {
+                handleTranscriptTurn(event);
+                handleTranscriptUi(event);
+            },
+            onDone: handleDone,
+        };
+    }, [handleStatus, handleTranscriptTurn, handleTranscriptUi, handleDone]);
+    React.useEffect(() => () => { void stopVoiceSessionRef.current('unmount'); }, []);
+    return {
+        isVoiceMode,
+        voiceStatus,
+        isVoiceConnecting,
+        isMicMuted,
+        remoteAudioRef,
+        enterVoiceMode,
+        exitVoiceMode,
+        toggleMicMute,
+        interruptVoice,
+    };
+}

package/dist/legacy/core/metakeepClient.d.ts

@@ -0,0 +1,4 @@
+import { MetaKeep } from 'metakeep';
+declare const metakeepClient: MetaKeep;
+export default metakeepClient;
+//# sourceMappingURL=metakeepClient.d.ts.map

package/dist/legacy/core/metakeepClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metakeepClient.d.ts","sourceRoot":"","sources":["../../../src/legacy/core/metakeepClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,QAAA,MAAM,cAAc,UAOlB,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/dist/legacy/core/metakeepClient.js

@@ -0,0 +1,10 @@
+import { MetaKeep } from 'metakeep';
+const metakeepClient = new MetaKeep({
+    appId: 'e7d521f7-3eea-42d7-af42-4d8b962d9a6d',
+    chainId: 80002,
+    /* RPC node urls map */
+    rpcNodeUrls: {
+        80002: 'https://rpc-amoy.polygon.technology'
+    }
+});
+export default metakeepClient;

package/dist/legacy/core/utils/aitUtils.d.ts

@@ -0,0 +1,31 @@
+export interface AITMetadata {
+    permissions: string[];
+    issuedBy: string;
+}
+export interface CreateAITParams {
+    aitId: string;
+    controller: string;
+    serviceId: string;
+    metadataHash: string;
+    metadataCid: string;
+    isFromAIAgent?: boolean;
+    parentAITId?: string;
+}
+export declare const generateAITId: (address: string) => string;
+export declare const createAITMetadata: (permissions: string[], issuedBy: string) => AITMetadata;
+export declare const generateMetadataHash: (metadata: AITMetadata) => string;
+export declare const prepareAITCreation: (address: string, permissions: string[], serviceId: string, isFromAIAgent?: boolean, parentAITId?: string) => {
+    aitId: string;
+    metadata: AITMetadata;
+    metadataHash: string;
+    createAITParams: {
+        aitId: string;
+        controller: string;
+        serviceId: string;
+        metadataHash: string;
+        metadataCid: string;
+        isFromAIAgent: boolean;
+        parentAITId: string | undefined;
+    };
+};
+//# sourceMappingURL=aitUtils.d.ts.map

package/dist/legacy/core/utils/aitUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aitUtils.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/utils/aitUtils.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,MAG/C,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,aAAa,MAAM,EAAE,EAAE,UAAU,MAAM,KAAG,WAK3E,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,UAAU,WAAW,KAAG,MAG5D,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,aAAa,MAAM,EAAE,EAAE,WAAW,MAAM,EAAE,uBAAqB,EAAE,cAAc,MAAM;;;;;;;;;;;;;CAmBxI,CAAC"}

package/dist/legacy/core/utils/aitUtils.js

@@ -0,0 +1,35 @@
+import { ethers } from 'ethers';
+import stringify from 'fast-json-stable-stringify';
+export const generateAITId = (address) => {
+    const timestamp = Math.floor(Date.now() / 1000);
+    return `did:polygon:nxtlinq:${address}:${timestamp}`;
+};
+export const createAITMetadata = (permissions, issuedBy) => {
+    return {
+        permissions,
+        issuedBy,
+    };
+};
+export const generateMetadataHash = (metadata) => {
+    const metadataStr = stringify(metadata);
+    return ethers.keccak256(ethers.toUtf8Bytes(metadataStr));
+};
+export const prepareAITCreation = (address, permissions, serviceId, isFromAIAgent = false, parentAITId) => {
+    const aitId = generateAITId(address);
+    const metadata = createAITMetadata(permissions, address);
+    const metadataHash = generateMetadataHash(metadata);
+    return {
+        aitId,
+        metadata,
+        metadataHash,
+        createAITParams: {
+            aitId,
+            controller: address,
+            serviceId,
+            metadataHash,
+            metadataCid: '', // Will be set after metadata upload
+            isFromAIAgent,
+            parentAITId,
+        }
+    };
+};

package/dist/legacy/core/utils/ethersUtils.d.ts

@@ -0,0 +1,8 @@
+import { ethers } from 'ethers';
+/**
+ * Safely get ethers library instance
+ * Tries imported ethers first, then falls back to window.ethers
+ * @throws Error if ethers is not available
+ */
+export declare const getEthers: () => typeof ethers;
+//# sourceMappingURL=ethersUtils.d.ts.map

package/dist/legacy/core/utils/ethersUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ethersUtils.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/utils/ethersUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,SAAS,QAAO,OAAO,MAgBnC,CAAC"}

package/dist/legacy/core/utils/ethersUtils.js

@@ -0,0 +1,19 @@
+import { ethers } from 'ethers';
+/**
+ * Safely get ethers library instance
+ * Tries imported ethers first, then falls back to window.ethers
+ * @throws Error if ethers is not available
+ */
+export const getEthers = () => {
+    // Try to use the imported ethers first (most common case)
+    if (ethers && typeof ethers === 'object') {
+        return ethers;
+    }
+    // Fallback: try to get from global window object (in case client site provides it)
+    if (typeof window !== 'undefined' && window.ethers) {
+        return window.ethers;
+    }
+    // Provide error message
+    console.error('[Nxtlinq SDK] Failed to get ethers library');
+    throw new Error('ethers library is not properly loaded. Please ensure ethers v6 is available.');
+};

package/dist/legacy/core/utils/index.d.ts

@@ -0,0 +1,3 @@
+export declare const sleep: (ms: number) => Promise<unknown>;
+export { getEthers } from './ethersUtils';
+//# sourceMappingURL=index.d.ts.map

package/dist/legacy/core/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/utils/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,qBAE/B,CAAA;AAED,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

package/dist/legacy/core/utils/index.js

@@ -0,0 +1,4 @@
+export const sleep = (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+export { getEthers } from './ethersUtils';

package/dist/legacy/core/utils/notificationUtils.d.ts

@@ -0,0 +1,29 @@
+export type NotificationType = 'success' | 'error' | 'warning' | 'info';
+export interface Notification {
+    show: boolean;
+    type: NotificationType;
+    message: string;
+    autoHide?: boolean;
+    duration?: number;
+}
+export declare const createNotification: (type: NotificationType, message: string, duration?: number) => Notification;
+export declare const getNotificationIcon: (type: NotificationType) => string;
+export declare const getNotificationStyles: (type: NotificationType) => {
+    background: string;
+    color: string;
+    position: "fixed";
+    bottom: number;
+    right: number;
+    padding: string;
+    borderRadius: number;
+    zIndex: number;
+    fontWeight: number;
+    boxShadow: string;
+    transition: string;
+    display: string;
+    alignItems: string;
+    gap: string;
+    minWidth: string;
+    maxWidth: string;
+};
+//# sourceMappingURL=notificationUtils.d.ts.map

package/dist/legacy/core/utils/notificationUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notificationUtils.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/utils/notificationUtils.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAExE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,gBAAgB,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,kBAAkB,GAC7B,MAAM,gBAAgB,EACtB,SAAS,MAAM,EACf,iBAAe,KACd,YAMD,CAAC;AAEH,eAAO,MAAM,mBAAmB,GAAI,MAAM,gBAAgB,KAAG,MAW5D,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CA4B3D,CAAC"}

package/dist/legacy/core/utils/notificationUtils.js

@@ -0,0 +1,47 @@
+export const createNotification = (type, message, duration = 5000) => ({
+    show: true,
+    type,
+    message,
+    autoHide: true,
+    duration
+});
+export const getNotificationIcon = (type) => {
+    switch (type) {
+        case 'success':
+            return '✅';
+        case 'error':
+            return '❌';
+        case 'warning':
+            return '⚠️';
+        default:
+            return 'ℹ️';
+    }
+};
+export const getNotificationStyles = (type) => {
+    const baseStyles = {
+        position: 'fixed',
+        bottom: 20,
+        right: 20,
+        padding: '12px 24px',
+        borderRadius: 8,
+        zIndex: 2000,
+        fontWeight: 600,
+        boxShadow: '0 4px 12px rgba(0, 0, 0, 0.15)',
+        transition: 'all 0.3s ease',
+        display: 'flex',
+        alignItems: 'center',
+        gap: '12px',
+        minWidth: '300px',
+        maxWidth: '500px'
+    };
+    switch (type) {
+        case 'success':
+            return { ...baseStyles, background: '#4caf50', color: 'white' };
+        case 'error':
+            return { ...baseStyles, background: '#f44336', color: 'white' };
+        case 'warning':
+            return { ...baseStyles, background: '#ff9800', color: 'white' };
+        default:
+            return { ...baseStyles, background: '#2196f3', color: 'white' };
+    }
+};

package/dist/legacy/core/utils/urlUtils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * URL utility functions for detecting and converting URLs to clickable links
+ */
+import * as React from 'react';
+/**
+ * Check if a string contains URLs
+ * @param text - The text to check
+ * @returns boolean indicating if URLs are found
+ */
+export declare const containsUrls: (text: string) => boolean;
+/**
+ * Convert text with URLs to JSX elements with clickable links
+ * Supports both Markdown format [text](url) and plain URLs
+ * Also handles line breaks (\n)
+ * @param text - The text containing URLs
+ * @returns Array of JSX elements and strings
+ */
+export declare const convertUrlsToLinks: (text: string) => (string | React.ReactElement)[];
+/**
+ * Simple function to wrap URLs in anchor tags for basic HTML rendering
+ * @param text - The text containing URLs
+ * @returns HTML string with clickable links
+ */
+export declare const convertUrlsToHtml: (text: string) => string;
+//# sourceMappingURL=urlUtils.d.ts.map

package/dist/legacy/core/utils/urlUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlUtils.d.ts","sourceRoot":"","sources":["../../../../src/legacy/core/utils/urlUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAc/B;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,KAAG,OAE3C,CAAC;AAwBF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,CAAC,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,EA2F9E,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,MAKhD,CAAC"}