@localzet/data-connector 1.0.0

package/README.md

@@ -0,0 +1,52 @@
+# @localzet/data-connector
+
+Библиотека для подключения к MIX ID с поддержкой синхронизации в реальном времени, уведомлений и управления сессиями.
+
+## Установка
+
+```bash
+npm install @localzet/data-connector
+```
+
+## Использование
+
+### Базовое подключение
+
+```tsx
+import { MixIdConnection } from '@localzet/data-connector/components';
+import { useMixIdSync } from '@localzet/data-connector/hooks';
+
+function App() {
+  const { performSync } = useMixIdSync();
+  
+  return (
+    <div>
+      <MixIdConnection />
+    </div>
+  );
+}
+```
+
+### Хуки
+
+- `useMixIdSync()` - синхронизация данных
+- `useMixIdStatus()` - статус подключения
+- `useNotifications()` - уведомления
+- `useMixIdSession()` - управление сессиями
+
+### API
+
+- `mixIdApi` - основной API клиент
+- `wsClient` - WebSocket клиент
+- `offlineQueue` - очередь для офлайн операций
+
+## Особенности
+
+- ✅ OAuth 2.0 авторизация
+- ✅ Синхронизация в реальном времени через WebSocket
+- ✅ Уведомления в реальном времени
+- ✅ Управление сессиями с взаимоудалением
+- ✅ Офлайн поддержка с очередью операций
+- ✅ React компоненты для быстрой интеграции
+- ✅ TypeScript поддержка
+

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+export * from './mixIdApi';
+export * from './websocket';
+export * from './offlineQueue';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA"}

package/dist/api/index.js

@@ -0,0 +1,3 @@
+export * from './mixIdApi';
+export * from './websocket';
+export * from './offlineQueue';

package/dist/api/mixIdApi.d.ts

@@ -0,0 +1,76 @@
+export interface MixIdConfig {
+    apiBase: string;
+    clientId: string;
+    clientSecret: string;
+    accessToken?: string;
+    refreshToken?: string;
+}
+declare class MixIdApi {
+    private config;
+    setConfig(config: MixIdConfig): void;
+    getConfig(): MixIdConfig | null;
+    clearConfig(): void;
+    private request;
+    private refreshAccessToken;
+    initiateOAuth(redirectUri: string, state?: string): Promise<{
+        authorizationUrl: string;
+        code: string;
+    }>;
+    exchangeCodeForToken(code: string, redirectUri?: string): Promise<{
+        access_token: string;
+        refresh_token: string;
+        token_type: string;
+        expires_in: number;
+    }>;
+    getSyncStatus(): Promise<{
+        syncSettings: boolean;
+        syncData: boolean;
+        lastSyncAt: string | null;
+    }>;
+    updateSyncPreferences(syncSettings: boolean, syncData: boolean): Promise<{
+        success: boolean;
+    }>;
+    uploadSettings(settings: any): Promise<{
+        success: boolean;
+        version: number;
+    }>;
+    downloadSettings(): Promise<{
+        settings: any;
+        version: number;
+        updatedAt: string;
+    }>;
+    uploadData(dataType: string, data: Record<string, any>): Promise<{
+        success: boolean;
+    }>;
+    downloadData(dataType: string): Promise<{
+        data: Record<string, any>;
+        dataType: string;
+    }>;
+    checkUpdates(settingsVersion?: number, dataTypes?: string[]): Promise<{
+        updates: {
+            settings?: {
+                version: number;
+                updatedAt: string;
+            };
+            data?: Record<string, {
+                updatedAt: string;
+            }>;
+        };
+        hasUpdates: boolean;
+    }>;
+    heartbeat(deviceInfo?: any): Promise<{
+        success: boolean;
+    }>;
+    getSessions(): Promise<Array<{
+        id: string;
+        deviceInfo: any;
+        lastActivityAt: string;
+        createdAt: string;
+    }>>;
+    deleteSession(sessionId: string): Promise<{
+        success: boolean;
+    }>;
+}
+export declare const mixIdApi: MixIdApi;
+export {};
+//# sourceMappingURL=mixIdApi.d.ts.map

package/dist/api/mixIdApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixIdApi.d.ts","sourceRoot":"","sources":["../../src/api/mixIdApi.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,cAAM,QAAQ;IACZ,OAAO,CAAC,MAAM,CAA2B;IAEzC,SAAS,CAAC,MAAM,EAAE,WAAW;IAmB7B,SAAS,IAAI,WAAW,GAAG,IAAI;IA2B/B,WAAW;YAYG,OAAO;YAkDP,kBAAkB;IA0C1B,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,gBAAgB,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAmBvG,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QACtE,YAAY,EAAE,MAAM,CAAA;QACpB,aAAa,EAAE,MAAM,CAAA;QACrB,UAAU,EAAE,MAAM,CAAA;QAClB,UAAU,EAAE,MAAM,CAAA;KACnB,CAAC;IA4CI,aAAa,IAAI,OAAO,CAAC;QAC7B,YAAY,EAAE,OAAO,CAAA;QACrB,QAAQ,EAAE,OAAO,CAAA;QACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;KAC1B,CAAC;IAII,qBAAqB,CAAC,YAAY,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAO9F,cAAc,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAO7E,gBAAgB,IAAI,OAAO,CAAC;QAAE,QAAQ,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAIlF,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAkCtF,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAIxF,YAAY,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;QAC1E,OAAO,EAAE;YACP,QAAQ,CAAC,EAAE;gBAAE,OAAO,EAAE,MAAM,CAAC;gBAAC,SAAS,EAAE,MAAM,CAAA;aAAE,CAAA;YACjD,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;gBAAE,SAAS,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAC7C,CAAA;QACD,UAAU,EAAE,OAAO,CAAA;KACpB,CAAC;IAQI,SAAS,CAAC,UAAU,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IAQ1D,WAAW,IAAI,OAAO,CAAC,KAAK,CAAC;QACjC,EAAE,EAAE,MAAM,CAAA;QACV,UAAU,EAAE,GAAG,CAAA;QACf,cAAc,EAAE,MAAM,CAAA;QACtB,SAAS,EAAE,MAAM,CAAA;KAClB,CAAC,CAAC;IAIG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;CAKtE;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAA"}

package/dist/api/mixIdApi.js

@@ -0,0 +1,275 @@
+const MIX_ID_API_BASE = typeof window !== 'undefined' && window.__MIX_ID_API_BASE
+    ? window.__MIX_ID_API_BASE
+    : (typeof import.meta !== 'undefined' && import.meta.env?.VITE_MIX_ID_API_BASE)
+        ? import.meta.env.VITE_MIX_ID_API_BASE
+        : 'http://localhost:3000/api';
+class MixIdApi {
+    constructor() {
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    setConfig(config) {
+        this.config = config;
+        // Save config without tokens (tokens saved separately)
+        const { accessToken, refreshToken, ...configWithoutTokens } = config;
+        if (typeof window !== 'undefined' && window.localStorage) {
+            localStorage.setItem('mixId_config', JSON.stringify(configWithoutTokens));
+            if (config.accessToken) {
+                localStorage.setItem('mixId_accessToken', config.accessToken);
+            }
+            if (config.refreshToken) {
+                localStorage.setItem('mixId_refreshToken', config.refreshToken);
+            }
+            // Dispatch custom event for same-tab updates
+            window.dispatchEvent(new Event('mixid-config-changed'));
+        }
+    }
+    getConfig() {
+        if (!this.config) {
+            if (typeof window !== 'undefined' && window.localStorage) {
+                try {
+                    const accessToken = localStorage.getItem('mixId_accessToken');
+                    const refreshToken = localStorage.getItem('mixId_refreshToken');
+                    const stored = localStorage.getItem('mixId_config');
+                    if (stored) {
+                        const parsed = JSON.parse(stored);
+                        this.config = {
+                            ...parsed,
+                            accessToken: accessToken || undefined,
+                            refreshToken: refreshToken || undefined
+                        };
+                    }
+                    else if (accessToken || refreshToken) {
+                        // If we have tokens but no config, try to restore from tokens
+                        console.warn('MIX ID config missing but tokens found. Please reconfigure MIX ID.');
+                    }
+                }
+                catch (error) {
+                    console.error('Error loading MIX ID config:', error);
+                    this.config = null;
+                }
+            }
+        }
+        return this.config;
+    }
+    clearConfig() {
+        this.config = null;
+        if (typeof window !== 'undefined' && window.localStorage) {
+            localStorage.removeItem('mixId_config');
+            localStorage.removeItem('mixId_accessToken');
+            localStorage.removeItem('mixId_refreshToken');
+            // Dispatch custom event for same-tab updates
+            window.dispatchEvent(new Event('mixid-config-changed'));
+        }
+    }
+    async request(endpoint, options = {}) {
+        const config = this.getConfig();
+        if (!config) {
+            throw new Error('MIX ID not configured');
+        }
+        const token = config.accessToken || (typeof window !== 'undefined' && window.localStorage
+            ? localStorage.getItem('mixId_accessToken')
+            : null);
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(options.headers || {}),
+        };
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        const response = await fetch(`${config.apiBase || MIX_ID_API_BASE}${endpoint}`, {
+            ...options,
+            headers,
+        });
+        if (response.status === 401) {
+            // Try to refresh token
+            const refreshed = await this.refreshAccessToken();
+            if (refreshed) {
+                const retryHeaders = {
+                    ...headers,
+                    'Authorization': `Bearer ${refreshed}`,
+                };
+                const retryResponse = await fetch(`${config.apiBase || MIX_ID_API_BASE}${endpoint}`, {
+                    ...options,
+                    headers: retryHeaders,
+                });
+                if (!retryResponse.ok) {
+                    throw new Error(`HTTP ${retryResponse.status}`);
+                }
+                return retryResponse.json();
+            }
+        }
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        return response.json();
+    }
+    async refreshAccessToken() {
+        const config = this.getConfig();
+        const refreshToken = config?.refreshToken || (typeof window !== 'undefined' && window.localStorage
+            ? localStorage.getItem('mixId_refreshToken')
+            : null);
+        if (!refreshToken)
+            return null;
+        try {
+            const response = await fetch(`${config?.apiBase || MIX_ID_API_BASE}/auth/refresh`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ refreshToken }),
+            });
+            if (!response.ok)
+                return null;
+            const data = await response.json();
+            if (data.accessToken) {
+                if (typeof window !== 'undefined' && window.localStorage) {
+                    localStorage.setItem('mixId_accessToken', data.accessToken);
+                }
+                if (this.config) {
+                    this.config.accessToken = data.accessToken;
+                    // Save updated config
+                    const { accessToken: _, refreshToken: __, ...configWithoutTokens } = this.config;
+                    if (typeof window !== 'undefined' && window.localStorage) {
+                        localStorage.setItem('mixId_config', JSON.stringify(configWithoutTokens));
+                    }
+                }
+                // Dispatch custom event for same-tab updates
+                if (typeof window !== 'undefined') {
+                    window.dispatchEvent(new Event('mixid-config-changed'));
+                }
+                return data.accessToken;
+            }
+        }
+        catch (error) {
+            console.error('Failed to refresh token:', error);
+        }
+        return null;
+    }
+    // OAuth flow
+    async initiateOAuth(redirectUri, state) {
+        const config = this.getConfig();
+        if (!config) {
+            throw new Error('MIX ID not configured');
+        }
+        return this.request('/auth/oauth/authorize', {
+            method: 'POST',
+            body: JSON.stringify({
+                clientId: config.clientId,
+                redirectUri,
+                state,
+            }),
+        });
+    }
+    async exchangeCodeForToken(code, redirectUri) {
+        const config = this.getConfig();
+        if (!config) {
+            throw new Error('MIX ID not configured');
+        }
+        // Don't use this.request() here because we don't have a token yet
+        // Make direct fetch without Authorization header
+        const response = await fetch(`${config.apiBase || MIX_ID_API_BASE}/auth/oauth/token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                code,
+                clientId: config.clientId,
+                clientSecret: config.clientSecret,
+                redirectUri,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+            throw new Error(error.error || `HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        // Save tokens
+        this.setConfig({
+            ...config,
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token,
+        });
+        return data;
+    }
+    // Sync
+    async getSyncStatus() {
+        return this.request('/sync/status');
+    }
+    async updateSyncPreferences(syncSettings, syncData) {
+        return this.request('/sync/preferences', {
+            method: 'PUT',
+            body: JSON.stringify({ syncSettings, syncData }),
+        });
+    }
+    async uploadSettings(settings) {
+        return this.request('/sync/settings', {
+            method: 'POST',
+            body: JSON.stringify({ settings }),
+        });
+    }
+    async downloadSettings() {
+        return this.request('/sync/settings');
+    }
+    async uploadData(dataType, data) {
+        // Split large data into chunks to avoid 413 Payload Too Large
+        const CHUNK_SIZE = 100; // Number of items per chunk
+        const dataEntries = Object.entries(data);
+        if (dataEntries.length <= CHUNK_SIZE) {
+            // Small enough to send in one request
+            return this.request('/sync/data', {
+                method: 'POST',
+                body: JSON.stringify({ dataType, data }),
+            });
+        }
+        // Split into chunks
+        const chunks = [];
+        for (let i = 0; i < dataEntries.length; i += CHUNK_SIZE) {
+            const chunk = {};
+            for (let j = i; j < Math.min(i + CHUNK_SIZE, dataEntries.length); j++) {
+                chunk[dataEntries[j][0]] = dataEntries[j][1];
+            }
+            chunks.push(chunk);
+        }
+        // Upload chunks sequentially
+        for (const chunk of chunks) {
+            await this.request('/sync/data', {
+                method: 'POST',
+                body: JSON.stringify({ dataType, data: chunk }),
+            });
+        }
+        return { success: true };
+    }
+    async downloadData(dataType) {
+        return this.request(`/sync/data?dataType=${dataType}`);
+    }
+    async checkUpdates(settingsVersion, dataTypes) {
+        const params = new URLSearchParams();
+        if (settingsVersion)
+            params.append('settingsVersion', settingsVersion.toString());
+        if (dataTypes)
+            params.append('dataTypes', dataTypes.join(','));
+        return this.request(`/sync/check-updates?${params.toString()}`);
+    }
+    // Session heartbeat
+    async heartbeat(deviceInfo) {
+        return this.request('/sessions/heartbeat', {
+            method: 'POST',
+            body: JSON.stringify({ deviceInfo }),
+        });
+    }
+    // Session management
+    async getSessions() {
+        return this.request('/sessions');
+    }
+    async deleteSession(sessionId) {
+        return this.request(`/sessions/${sessionId}`, {
+            method: 'DELETE',
+        });
+    }
+}
+export const mixIdApi = new MixIdApi();

package/dist/api/offlineQueue.d.ts

@@ -0,0 +1,24 @@
+interface QueuedOperation {
+    id: string;
+    type: 'settings' | 'data';
+    dataType?: string;
+    data: any;
+    timestamp: number;
+    retries: number;
+}
+declare class OfflineQueue {
+    private queue;
+    constructor();
+    private loadQueue;
+    private saveQueue;
+    private cleanupOldOperations;
+    enqueue(type: 'settings' | 'data', data: any, dataType?: string): string;
+    processQueue(processFn: (operation: QueuedOperation) => Promise<void>): Promise<void>;
+    remove(id: string): void;
+    clear(): void;
+    getQueue(): QueuedOperation[];
+    getQueueSize(): number;
+}
+export declare const offlineQueue: OfflineQueue;
+export {};
+//# sourceMappingURL=offlineQueue.d.ts.map

package/dist/api/offlineQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offlineQueue.d.ts","sourceRoot":"","sources":["../../src/api/offlineQueue.ts"],"names":[],"mappings":"AAAA,UAAU,eAAe;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,UAAU,GAAG,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,GAAG,CAAA;IACT,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;CAChB;AAOD,cAAM,YAAY;IAChB,OAAO,CAAC,KAAK,CAAwB;;IAOrC,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,SAAS;IA8CjB,OAAO,CAAC,oBAAoB;IAW5B,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM;IAgBlE,YAAY,CAAC,SAAS,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC;IAqB3E,MAAM,CAAC,EAAE,EAAE,MAAM;IAKjB,KAAK;IAKL,QAAQ,IAAI,eAAe,EAAE;IAI7B,YAAY,IAAI,MAAM;CAGvB;AAED,eAAO,MAAM,YAAY,cAAqB,CAAA"}

package/dist/api/offlineQueue.js

@@ -0,0 +1,137 @@
+const QUEUE_STORAGE_KEY = 'mixId_offline_queue';
+const MAX_RETRIES = 3;
+const MAX_QUEUE_SIZE = 50; // Maximum number of operations in queue
+const MAX_QUEUE_AGE = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds
+class OfflineQueue {
+    constructor() {
+        Object.defineProperty(this, "queue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        this.loadQueue();
+        this.cleanupOldOperations();
+    }
+    loadQueue() {
+        if (typeof window === 'undefined' || !window.localStorage) {
+            return;
+        }
+        try {
+            const stored = localStorage.getItem(QUEUE_STORAGE_KEY);
+            if (stored) {
+                this.queue = JSON.parse(stored);
+            }
+        }
+        catch (error) {
+            console.error('Error loading offline queue:', error);
+            this.queue = [];
+        }
+    }
+    saveQueue() {
+        if (typeof window === 'undefined' || !window.localStorage) {
+            return;
+        }
+        try {
+            // Limit queue size before saving
+            if (this.queue.length > MAX_QUEUE_SIZE) {
+                // Keep only the most recent operations
+                this.queue = this.queue
+                    .sort((a, b) => b.timestamp - a.timestamp)
+                    .slice(0, MAX_QUEUE_SIZE);
+            }
+            const queueJson = JSON.stringify(this.queue);
+            // Check if data is too large (localStorage limit is ~5-10MB)
+            if (queueJson.length > 4 * 1024 * 1024) {
+                // If too large, keep only the most recent 20 operations
+                console.warn('Offline queue too large, keeping only most recent operations');
+                this.queue = this.queue
+                    .sort((a, b) => b.timestamp - a.timestamp)
+                    .slice(0, 20);
+                localStorage.setItem(QUEUE_STORAGE_KEY, JSON.stringify(this.queue));
+            }
+            else {
+                localStorage.setItem(QUEUE_STORAGE_KEY, queueJson);
+            }
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'QuotaExceededError') {
+                console.warn('localStorage quota exceeded, clearing old operations');
+                // Clear old operations and try again
+                this.queue = this.queue
+                    .sort((a, b) => b.timestamp - a.timestamp)
+                    .slice(0, 10);
+                try {
+                    localStorage.setItem(QUEUE_STORAGE_KEY, JSON.stringify(this.queue));
+                }
+                catch (e) {
+                    console.error('Failed to save queue after cleanup:', e);
+                    // Last resort: clear the queue
+                    this.queue = [];
+                    localStorage.removeItem(QUEUE_STORAGE_KEY);
+                }
+            }
+            else {
+                console.error('Error saving offline queue:', error);
+            }
+        }
+    }
+    cleanupOldOperations() {
+        const now = Date.now();
+        const initialLength = this.queue.length;
+        this.queue = this.queue.filter((op) => now - op.timestamp < MAX_QUEUE_AGE);
+        if (this.queue.length < initialLength) {
+            console.log(`Cleaned up ${initialLength - this.queue.length} old operations from queue`);
+            this.saveQueue();
+        }
+    }
+    enqueue(type, data, dataType) {
+        const id = `${type}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const operation = {
+            id,
+            type,
+            dataType,
+            data,
+            timestamp: Date.now(),
+            retries: 0,
+        };
+        this.queue.push(operation);
+        this.saveQueue();
+        return id;
+    }
+    async processQueue(processFn) {
+        const operations = [...this.queue];
+        for (const operation of operations) {
+            try {
+                await processFn(operation);
+                this.remove(operation.id);
+            }
+            catch (error) {
+                console.error(`Error processing queued operation ${operation.id}:`, error);
+                operation.retries++;
+                if (operation.retries >= MAX_RETRIES) {
+                    console.warn(`Operation ${operation.id} exceeded max retries, removing from queue`);
+                    this.remove(operation.id);
+                }
+                else {
+                    this.saveQueue();
+                }
+            }
+        }
+    }
+    remove(id) {
+        this.queue = this.queue.filter((op) => op.id !== id);
+        this.saveQueue();
+    }
+    clear() {
+        this.queue = [];
+        this.saveQueue();
+    }
+    getQueue() {
+        return [...this.queue];
+    }
+    getQueueSize() {
+        return this.queue.length;
+    }
+}
+export const offlineQueue = new OfflineQueue();

package/dist/api/websocket.d.ts

@@ -0,0 +1,28 @@
+export interface WebSocketMessage {
+    type: string;
+    [key: string]: any;
+}
+export type WebSocketEventHandler = (message: WebSocketMessage) => void;
+declare class WebSocketClient {
+    private ws;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private isConnecting;
+    private eventHandlers;
+    private messageQueue;
+    private isOnline;
+    constructor();
+    connect(): void;
+    private attemptReconnect;
+    private handleMessage;
+    send(message: WebSocketMessage): void;
+    private flushMessageQueue;
+    on(eventType: string, handler: WebSocketEventHandler): void;
+    off(eventType: string, handler: WebSocketEventHandler): void;
+    disconnect(): void;
+    isConnected(): boolean;
+}
+export declare const wsClient: WebSocketClient;
+export {};
+//# sourceMappingURL=websocket.d.ts.map

package/dist/api/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/api/websocket.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB;AAED,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAA;AAEvE,cAAM,eAAe;IACnB,OAAO,CAAC,EAAE,CAAyB;IACnC,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,cAAc,CAAO;IAC7B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,aAAa,CAAqD;IAC1E,OAAO,CAAC,YAAY,CAAyB;IAC7C,OAAO,CAAC,QAAQ,CAA6D;;IAkB7E,OAAO;IAkEP,OAAO,CAAC,gBAAgB;IAqBxB,OAAO,CAAC,aAAa;IAoBrB,IAAI,CAAC,OAAO,EAAE,gBAAgB;IAS9B,OAAO,CAAC,iBAAiB;IASzB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB;IAOpD,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB;IAOrD,UAAU;IAeV,WAAW,IAAI,OAAO;CAGvB;AAED,eAAO,MAAM,QAAQ,iBAAwB,CAAA"}