@localzet/data-connector 1.0.0

package/dist/api/websocket.js

@@ -0,0 +1,201 @@
+import { mixIdApi } from './mixIdApi';
+class WebSocketClient {
+    constructor() {
+        Object.defineProperty(this, "ws", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "maxReconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        Object.defineProperty(this, "reconnectDelay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1000
+        });
+        Object.defineProperty(this, "isConnecting", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "eventHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "messageQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "isOnline", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: typeof navigator !== 'undefined' ? navigator.onLine : true
+        });
+        if (typeof window !== 'undefined') {
+            // Listen to online/offline events
+            window.addEventListener('online', () => {
+                this.isOnline = true;
+                if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+                    this.connect();
+                }
+            });
+            window.addEventListener('offline', () => {
+                this.isOnline = false;
+            });
+        }
+    }
+    connect() {
+        if (this.isConnecting || (this.ws && this.ws.readyState === WebSocket.OPEN)) {
+            return;
+        }
+        const config = mixIdApi.getConfig();
+        if (!config || !config.accessToken) {
+            return;
+        }
+        this.isConnecting = true;
+        try {
+            const apiBase = config.apiBase || (typeof import.meta !== 'undefined' && import.meta.env?.VITE_MIX_ID_API_BASE)
+                ? (import.meta.env?.VITE_MIX_ID_API_BASE || 'http://localhost:3000/api')
+                : 'http://localhost:3000/api';
+            const wsUrl = apiBase.replace(/^http/, 'ws').replace(/\/api$/, '') + '/ws';
+            const ws = new WebSocket(`${wsUrl}?token=${config.accessToken}`);
+            ws.onopen = () => {
+                this.ws = ws;
+                this.isConnecting = false;
+                this.reconnectAttempts = 0;
+                console.log('WebSocket connected');
+                // Dispatch custom event for connection status update
+                if (typeof window !== 'undefined') {
+                    window.dispatchEvent(new Event('mixid-ws-status-changed'));
+                }
+                // Send queued messages
+                this.flushMessageQueue();
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data);
+                    this.handleMessage(message);
+                }
+                catch (error) {
+                    console.error('Error parsing WebSocket message:', error);
+                }
+            };
+            ws.onerror = (error) => {
+                console.error('WebSocket error:', error);
+                this.isConnecting = false;
+            };
+            ws.onclose = () => {
+                this.ws = null;
+                this.isConnecting = false;
+                // Dispatch custom event for connection status update
+                if (typeof window !== 'undefined') {
+                    window.dispatchEvent(new Event('mixid-ws-status-changed'));
+                }
+                this.attemptReconnect();
+            };
+        }
+        catch (error) {
+            console.error('WebSocket connection error:', error);
+            this.isConnecting = false;
+            this.attemptReconnect();
+        }
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.log('Max reconnection attempts reached');
+            return;
+        }
+        if (!this.isOnline) {
+            // Wait for online event
+            return;
+        }
+        this.reconnectAttempts++;
+        const delay = Math.min(this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1), 30000);
+        setTimeout(() => {
+            if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+                this.connect();
+            }
+        }, delay);
+    }
+    handleMessage(message) {
+        // Handle ping/pong
+        if (message.type === 'ping') {
+            this.send({ type: 'pong' });
+            return;
+        }
+        // Call registered event handlers
+        const handlers = this.eventHandlers.get(message.type);
+        if (handlers) {
+            handlers.forEach((handler) => handler(message));
+        }
+        // Also call wildcard handlers
+        const wildcardHandlers = this.eventHandlers.get('*');
+        if (wildcardHandlers) {
+            wildcardHandlers.forEach((handler) => handler(message));
+        }
+    }
+    send(message) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            // Queue message for later
+            this.messageQueue.push(message);
+        }
+    }
+    flushMessageQueue() {
+        while (this.messageQueue.length > 0) {
+            const message = this.messageQueue.shift();
+            if (message) {
+                this.send(message);
+            }
+        }
+    }
+    on(eventType, handler) {
+        if (!this.eventHandlers.has(eventType)) {
+            this.eventHandlers.set(eventType, new Set());
+        }
+        this.eventHandlers.get(eventType).add(handler);
+    }
+    off(eventType, handler) {
+        const handlers = this.eventHandlers.get(eventType);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.eventHandlers.clear();
+        this.messageQueue = [];
+        this.reconnectAttempts = 0;
+        // Dispatch custom event for connection status update
+        if (typeof window !== 'undefined') {
+            window.dispatchEvent(new Event('mixid-ws-status-changed'));
+        }
+    }
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+}
+export const wsClient = new WebSocketClient();

package/dist/components/MixIdCallbackPage.d.ts

@@ -0,0 +1,6 @@
+export interface MixIdCallbackPageProps {
+    onCallback?: (code: string, state: string | null) => void;
+    redirectTo?: string;
+}
+export default function MixIdCallbackPage({ onCallback, redirectTo }?: MixIdCallbackPageProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MixIdCallbackPage.d.ts.map

package/dist/components/MixIdCallbackPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MixIdCallbackPage.d.ts","sourceRoot":"","sources":["../../src/components/MixIdCallbackPage.tsx"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAA;IACzD,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EAAE,UAAU,EAAE,UAAwB,EAAE,GAAE,sBAA2B,2CA2C9G"}

package/dist/components/MixIdCallbackPage.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { Center, Loader, Text, Stack } from '@mantine/core';
+export default function MixIdCallbackPage({ onCallback, redirectTo = '/settings' } = {}) {
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const urlParams = new URLSearchParams(window.location.search);
+        const code = urlParams.get('code');
+        const state = urlParams.get('state');
+        if (code) {
+            // Send message to parent window
+            if (window.opener) {
+                window.opener.postMessage({
+                    type: 'mixid-oauth-callback',
+                    code,
+                    state,
+                }, window.location.origin);
+                window.close();
+            }
+            else {
+                // If no opener, call callback or redirect
+                if (onCallback) {
+                    onCallback(code, state);
+                }
+                else if (redirectTo && typeof window !== 'undefined') {
+                    window.location.href = redirectTo;
+                }
+            }
+        }
+        else {
+            if (redirectTo && typeof window !== 'undefined') {
+                window.location.href = redirectTo;
+            }
+        }
+    }, [onCallback, redirectTo]);
+    return (_jsx(Center, { h: "100vh", children: _jsxs(Stack, { align: "center", gap: "md", children: [_jsx(Loader, {}), _jsx(Text, { children: "\u041E\u0431\u0440\u0430\u0431\u043E\u0442\u043A\u0430 \u0430\u0432\u0442\u043E\u0440\u0438\u0437\u0430\u0446\u0438\u0438 MIX ID..." })] }) }));
+}

package/dist/components/MixIdConnection.d.ts

@@ -0,0 +1,18 @@
+export interface MixIdConnectionProps {
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+    showSyncSettings?: boolean;
+    showSyncData?: boolean;
+    apiBase?: string;
+    clientId?: string;
+    clientSecret?: string;
+    notifications?: {
+        show: (options: {
+            title: string;
+            message: string;
+            color?: string;
+        }) => void;
+    };
+}
+export default function MixIdConnection({ onConnected, onDisconnected, showSyncSettings, showSyncData, apiBase, clientId, clientSecret, notifications, }: MixIdConnectionProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=MixIdConnection.d.ts.map

package/dist/components/MixIdConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MixIdConnection.d.ts","sourceRoot":"","sources":["../../src/components/MixIdConnection.tsx"],"names":[],"mappings":"AAkBA,MAAM,WAAW,oBAAoB;IACnC,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE;QACd,IAAI,EAAE,CAAC,OAAO,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC;YAAC,KAAK,CAAC,EAAE,MAAM,CAAA;SAAE,KAAK,IAAI,CAAA;KAC5E,CAAA;CACF;AAED,MAAM,CAAC,OAAO,UAAU,eAAe,CAAC,EACtC,WAAW,EACX,cAAc,EACd,gBAAuB,EACvB,YAAmB,EACnB,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,aAAa,GACd,EAAE,oBAAoB,2CAwStB"}

package/dist/components/MixIdConnection.js

@@ -0,0 +1,197 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { Paper, Group, Button, Text, Badge, Modal, Stack, Switch, Alert, Loader, } from '@mantine/core';
+import { IconPlug, IconSettings, IconLogout, IconX } from '@tabler/icons-react';
+import { useDisclosure } from '@mantine/hooks';
+import { mixIdApi } from '../api/mixIdApi';
+import { useMixIdStatus } from '../hooks/useMixIdStatus';
+export default function MixIdConnection({ onConnected, onDisconnected, showSyncSettings = true, showSyncData = true, apiBase, clientId, clientSecret, notifications, }) {
+    const { isConnected, syncStatus, hasConfig } = useMixIdStatus();
+    const [loading, setLoading] = useState(true);
+    const [syncStatusData, setSyncStatusData] = useState(null);
+    const [settingsModalOpened, { open: openSettings, close: closeSettings }] = useDisclosure(false);
+    const [syncSettings, setSyncSettings] = useState(false);
+    const [syncData, setSyncData] = useState(false);
+    useEffect(() => {
+        checkConnection();
+    }, []);
+    const checkConnection = async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                setSyncStatusData(null);
+                return;
+            }
+            const status = await mixIdApi.getSyncStatus();
+            setSyncStatusData(status);
+            setSyncSettings(status.syncSettings);
+            setSyncData(status.syncData);
+        }
+        catch (error) {
+            setSyncStatusData(null);
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const handleConnect = async () => {
+        try {
+            // Get config from props or environment
+            const finalApiBase = apiBase ||
+                (typeof import.meta !== 'undefined' && import.meta.env?.VITE_MIX_ID_API_BASE)
+                ? (import.meta.env?.VITE_MIX_ID_API_BASE || 'http://localhost:3000/api')
+                : 'http://localhost:3000/api';
+            const finalClientId = clientId ||
+                (typeof import.meta !== 'undefined' && import.meta.env?.VITE_MIX_ID_CLIENT_ID)
+                ? (import.meta.env?.VITE_MIX_ID_CLIENT_ID || '')
+                : '';
+            const finalClientSecret = clientSecret ||
+                (typeof import.meta !== 'undefined' && import.meta.env?.VITE_MIX_ID_CLIENT_SECRET)
+                ? (import.meta.env?.VITE_MIX_ID_CLIENT_SECRET || '')
+                : '';
+            if (!finalClientId || !finalClientSecret) {
+                const message = 'MIX ID не настроен. Укажите VITE_MIX_ID_CLIENT_ID и VITE_MIX_ID_CLIENT_SECRET';
+                if (notifications) {
+                    notifications.show({
+                        title: 'Ошибка',
+                        message,
+                        color: 'red',
+                    });
+                }
+                else {
+                    alert(message);
+                }
+                return;
+            }
+            mixIdApi.setConfig({
+                apiBase: finalApiBase || 'http://localhost:3000/api',
+                clientId: finalClientId,
+                clientSecret: finalClientSecret
+            });
+            // Initiate OAuth flow
+            const redirectUri = typeof window !== 'undefined' ? window.location.origin + '/mixid-callback' : '';
+            const { authorizationUrl, code } = await mixIdApi.initiateOAuth(redirectUri);
+            // Open OAuth window
+            if (typeof window === 'undefined')
+                return;
+            const width = 600;
+            const height = 700;
+            const left = window.screenX + (window.outerWidth - width) / 2;
+            const top = window.screenY + (window.outerHeight - height) / 2;
+            const oauthWindow = window.open(authorizationUrl, 'MIX ID Authorization', `width=${width},height=${height},left=${left},top=${top}`);
+            // Listen for OAuth callback
+            const handleMessage = async (event) => {
+                if (event.origin !== window.location.origin)
+                    return;
+                if (event.data.type === 'mixid-oauth-callback') {
+                    window.removeEventListener('message', handleMessage);
+                    oauthWindow?.close();
+                    try {
+                        const { code: callbackCode } = event.data;
+                        await mixIdApi.exchangeCodeForToken(callbackCode || code, redirectUri);
+                        // Dispatch event to trigger WebSocket connection and status update
+                        window.dispatchEvent(new Event('mixid-config-changed'));
+                        await checkConnection();
+                        if (notifications) {
+                            notifications.show({
+                                title: 'Успешно',
+                                message: 'MIX ID подключен',
+                                color: 'green',
+                            });
+                        }
+                        onConnected?.();
+                        openSettings();
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : 'Не удалось подключить MIX ID';
+                        if (notifications) {
+                            notifications.show({
+                                title: 'Ошибка',
+                                message,
+                                color: 'red',
+                            });
+                        }
+                        else {
+                            alert(message);
+                        }
+                    }
+                }
+            };
+            window.addEventListener('message', handleMessage);
+            // Fallback: check if window was closed manually
+            const checkClosed = setInterval(() => {
+                if (oauthWindow?.closed) {
+                    clearInterval(checkClosed);
+                    window.removeEventListener('message', handleMessage);
+                }
+            }, 1000);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Не удалось инициировать подключение';
+            if (notifications) {
+                notifications.show({
+                    title: 'Ошибка',
+                    message,
+                    color: 'red',
+                });
+            }
+            else {
+                alert(message);
+            }
+        }
+    };
+    const handleDisconnect = async () => {
+        if (typeof window === 'undefined')
+            return;
+        if (!confirm('Вы уверены, что хотите отключить MIX ID?'))
+            return;
+        mixIdApi.clearConfig();
+        // Dispatch event to trigger WebSocket disconnection and status update
+        window.dispatchEvent(new Event('mixid-config-changed'));
+        setSyncStatusData(null);
+        if (notifications) {
+            notifications.show({
+                title: 'Успешно',
+                message: 'MIX ID отключен',
+                color: 'blue',
+            });
+        }
+        onDisconnected?.();
+    };
+    const handleSaveSettings = async () => {
+        try {
+            await mixIdApi.updateSyncPreferences(syncSettings, syncData);
+            if (notifications) {
+                notifications.show({
+                    title: 'Успешно',
+                    message: 'Настройки синхронизации сохранены',
+                    color: 'green',
+                });
+            }
+            closeSettings();
+            await checkConnection();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Не удалось сохранить настройки';
+            if (notifications) {
+                notifications.show({
+                    title: 'Ошибка',
+                    message,
+                    color: 'red',
+                });
+            }
+            else {
+                alert(message);
+            }
+        }
+    };
+    if (loading) {
+        return (_jsx(Paper, { p: "md", withBorder: true, children: _jsx(Loader, { size: "sm" }) }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Paper, { p: "md", withBorder: true, children: _jsxs(Group, { justify: "space-between", children: [_jsxs(Group, { children: [_jsx(IconPlug, { size: 24 }), _jsxs("div", { children: [_jsx(Text, { fw: 500, children: "MIX ID" }), _jsx(Text, { size: "sm", c: "dimmed", children: "\u0421\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u044F \u0434\u0430\u043D\u043D\u044B\u0445 \u0447\u0435\u0440\u0435\u0437 Zorin Projects" })] })] }), isConnected ? (_jsxs(Group, { children: [syncStatusData && (_jsxs(Group, { gap: "xs", children: [showSyncSettings && (_jsx(Badge, { color: syncStatusData.syncSettings ? 'green' : 'gray', children: "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438" })), showSyncData && (_jsx(Badge, { color: syncStatusData.syncData ? 'green' : 'gray', children: "\u0414\u0430\u043D\u043D\u044B\u0435" }))] })), _jsx(Button, { leftSection: _jsx(IconSettings, { size: 16 }), variant: "light", onClick: openSettings, children: "\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u044B" }), _jsx(Button, { leftSection: _jsx(IconLogout, { size: 16 }), variant: "subtle", onClick: handleDisconnect, children: "\u0412\u044B\u0439\u0442\u0438" })] })) : (_jsx(Button, { leftSection: _jsx(IconPlug, { size: 16 }), onClick: handleConnect, children: "\u041F\u043E\u0434\u043A\u043B\u044E\u0447\u0438\u0442\u044C" }))] }) }), _jsx(Modal, { opened: settingsModalOpened, onClose: closeSettings, title: "\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u044B \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u0438 MIX ID", children: _jsxs(Stack, { gap: "md", children: [_jsx(Alert, { children: _jsx(Text, { size: "sm", children: "MIX ID \u043F\u043E\u0437\u0432\u043E\u043B\u044F\u0435\u0442 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0432\u0430\u0448\u0438 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 \u0438 \u0434\u0430\u043D\u043D\u044B\u0435 \u043C\u0435\u0436\u0434\u0443 \u0443\u0441\u0442\u0440\u043E\u0439\u0441\u0442\u0432\u0430\u043C\u0438. \u0412\u044B \u043C\u043E\u0436\u0435\u0442\u0435 \u0432\u044B\u0431\u0440\u0430\u0442\u044C, \u0447\u0442\u043E \u0438\u043C\u0435\u043D\u043D\u043E \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C." }) }), showSyncSettings && (_jsx(Switch, { label: "\u0421\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438", description: "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u0431\u0443\u0434\u0443\u0442 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C\u0441\u044F \u0441 \u0441\u0435\u0440\u0432\u0435\u0440\u043E\u043C", checked: syncSettings, onChange: (e) => {
+                                setSyncSettings(e.currentTarget.checked);
+                                if (!e.currentTarget.checked) {
+                                    setSyncData(false);
+                                }
+                            } })), showSyncData && (_jsx(Switch, { label: "\u0421\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0434\u0430\u043D\u043D\u044B\u0435", description: "\u0414\u0430\u043D\u043D\u044B\u0435 \u043F\u0440\u0438\u043B\u043E\u0436\u0435\u043D\u0438\u044F \u0431\u0443\u0434\u0443\u0442 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C\u0441\u044F \u0441 \u0441\u0435\u0440\u0432\u0435\u0440\u043E\u043C", checked: syncData, onChange: (e) => setSyncData(e.currentTarget.checked), disabled: showSyncSettings && !syncSettings })), showSyncSettings && !syncSettings && (_jsx(Alert, { color: "yellow", icon: _jsx(IconX, { size: 16 }), children: "\u0414\u043B\u044F \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u0438 \u0434\u0430\u043D\u043D\u044B\u0445 \u043D\u0435\u043E\u0431\u0445\u043E\u0434\u0438\u043C\u043E \u0432\u043A\u043B\u044E\u0447\u0438\u0442\u044C \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u044E \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043A" })), syncStatusData?.lastSyncAt && (_jsxs(Text, { size: "sm", c: "dimmed", children: ["\u041F\u043E\u0441\u043B\u0435\u0434\u043D\u044F\u044F \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u044F: ", new Date(syncStatusData.lastSyncAt).toLocaleString('ru-RU')] })), _jsxs(Group, { justify: "flex-end", children: [_jsx(Button, { variant: "subtle", onClick: closeSettings, children: "\u041E\u0442\u043C\u0435\u043D\u0430" }), _jsx(Button, { onClick: handleSaveSettings, children: "\u0421\u043E\u0445\u0440\u0430\u043D\u0438\u0442\u044C" })] })] }) })] }));
+}

package/dist/components/index.d.ts

@@ -0,0 +1,5 @@
+export { default as MixIdConnection } from './MixIdConnection';
+export { default as MixIdCallbackPage } from './MixIdCallbackPage';
+export type { MixIdConnectionProps } from './MixIdConnection';
+export type { MixIdCallbackPageProps } from './MixIdCallbackPage';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAC9D,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAClE,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAC7D,YAAY,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/components/index.js

@@ -0,0 +1,2 @@
+export { default as MixIdConnection } from './MixIdConnection';
+export { default as MixIdCallbackPage } from './MixIdCallbackPage';

package/dist/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useMixIdStatus';
+export * from './useMixIdSync';
+export * from './useNotifications';
+export * from './useMixIdSession';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,4 @@
+export * from './useMixIdStatus';
+export * from './useMixIdSync';
+export * from './useNotifications';
+export * from './useMixIdSession';

package/dist/hooks/useMixIdSession.d.ts

@@ -0,0 +1,19 @@
+export interface Session {
+    id: string;
+    deviceInfo: any;
+    lastActivityAt: string;
+    createdAt: string;
+}
+export interface UseMixIdSessionOptions {
+    onSessionDeleted?: () => void;
+    onSessionExpired?: () => void;
+    onSessionInvalid?: () => void;
+    heartbeatInterval?: number;
+    checkSessionOnMount?: boolean;
+}
+export declare function useMixIdSession(options?: UseMixIdSessionOptions): {
+    sendHeartbeat: () => Promise<void>;
+    checkSession: () => Promise<void>;
+    currentSessionId: string | null;
+};
+//# sourceMappingURL=useMixIdSession.d.ts.map

package/dist/hooks/useMixIdSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMixIdSession.d.ts","sourceRoot":"","sources":["../../src/hooks/useMixIdSession.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,GAAG,CAAA;IACf,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC7B,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC7B,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B;;;;EAwInE"}

package/dist/hooks/useMixIdSession.js

@@ -0,0 +1,124 @@
+import { useEffect, useCallback, useState } from 'react';
+import { mixIdApi } from '../api/mixIdApi';
+import { wsClient } from '../api/websocket';
+export function useMixIdSession(options = {}) {
+    const { onSessionDeleted, onSessionExpired, onSessionInvalid, heartbeatInterval = 30 * 1000, // 30 seconds
+    checkSessionOnMount = true, } = options;
+    const [currentSessionId, setCurrentSessionId] = useState(null);
+    const sendHeartbeat = useCallback(async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return;
+            }
+            const result = await mixIdApi.heartbeat({
+                platform: typeof navigator !== 'undefined' ? navigator.platform : 'unknown',
+                userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
+                timestamp: new Date().toISOString(),
+            });
+            // Store session ID if returned
+            if (result && result.sessionId) {
+                setCurrentSessionId(result.sessionId);
+            }
+        }
+        catch (error) {
+            console.error('Heartbeat failed:', error);
+            // If heartbeat fails with 401/403, session might be deleted or expired
+            if (error instanceof Error) {
+                if (error.message.includes('401') || error.message.includes('403')) {
+                    mixIdApi.clearConfig();
+                    wsClient.disconnect();
+                    onSessionExpired?.();
+                }
+                else if (error.message.includes('404')) {
+                    // Session not found - might have been deleted
+                    mixIdApi.clearConfig();
+                    wsClient.disconnect();
+                    onSessionDeleted?.();
+                }
+                else {
+                    onSessionInvalid?.();
+                }
+            }
+        }
+    }, [onSessionDeleted, onSessionExpired, onSessionInvalid]);
+    const checkSession = useCallback(async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return;
+            }
+            // Try to get sessions to verify current session exists
+            const sessions = await mixIdApi.getSessions();
+            // If we have a current session ID, check if it still exists
+            if (currentSessionId) {
+                const sessionExists = sessions.some(s => s.id === currentSessionId);
+                if (!sessionExists) {
+                    // Session was deleted
+                    mixIdApi.clearConfig();
+                    wsClient.disconnect();
+                    onSessionDeleted?.();
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to check session:', error);
+            if (error instanceof Error && (error.message.includes('401') || error.message.includes('403'))) {
+                mixIdApi.clearConfig();
+                wsClient.disconnect();
+                onSessionExpired?.();
+            }
+        }
+    }, [currentSessionId, onSessionDeleted, onSessionExpired]);
+    useEffect(() => {
+        const config = mixIdApi.getConfig();
+        if (!config || !config.accessToken) {
+            return;
+        }
+        // Check session on mount if enabled
+        if (checkSessionOnMount) {
+            checkSession();
+        }
+        // Set up WebSocket handlers for session events
+        const handleSessionDeleted = (message) => {
+            // If message contains sessionId, check if it's our session
+            if (message.sessionId) {
+                if (currentSessionId && message.sessionId === currentSessionId) {
+                    // Our session was deleted
+                    mixIdApi.clearConfig();
+                    wsClient.disconnect();
+                    onSessionDeleted?.();
+                }
+            }
+            else {
+                // Session deletion event without specific ID - might be ours
+                // Check by making a request
+                checkSession();
+            }
+        };
+        const handleSessionExpired = () => {
+            mixIdApi.clearConfig();
+            wsClient.disconnect();
+            onSessionExpired?.();
+        };
+        wsClient.on('session:deleted', handleSessionDeleted);
+        wsClient.on('session:expired', handleSessionExpired);
+        // Start heartbeat
+        const heartbeatIntervalId = setInterval(sendHeartbeat, heartbeatInterval);
+        // Send initial heartbeat
+        sendHeartbeat();
+        // Check session periodically (every 5 minutes)
+        const sessionCheckInterval = setInterval(checkSession, 5 * 60 * 1000);
+        return () => {
+            wsClient.off('session:deleted', handleSessionDeleted);
+            wsClient.off('session:expired', handleSessionExpired);
+            clearInterval(heartbeatIntervalId);
+            clearInterval(sessionCheckInterval);
+        };
+    }, [sendHeartbeat, checkSession, onSessionDeleted, onSessionExpired, heartbeatInterval, checkSessionOnMount, currentSessionId]);
+    return {
+        sendHeartbeat,
+        checkSession,
+        currentSessionId,
+    };
+}

package/dist/hooks/useMixIdStatus.d.ts

@@ -0,0 +1,9 @@
+export type MixIdSyncStatus = 'connected-ws' | 'connected-rest' | 'disconnected' | 'checking';
+export interface UseMixIdStatusReturn {
+    isConnected: boolean;
+    syncStatus: MixIdSyncStatus;
+    hasConfig: boolean;
+    refresh: () => void;
+}
+export declare function useMixIdStatus(): UseMixIdStatusReturn;
+//# sourceMappingURL=useMixIdStatus.d.ts.map