@localzet/data-connector 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMixIdStatus.d.ts","sourceRoot":"","sources":["../../src/hooks/useMixIdStatus.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,gBAAgB,GAAG,cAAc,GAAG,UAAU,CAAA;AAE7F,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,OAAO,CAAA;IACpB,UAAU,EAAE,eAAe,CAAA;IAC3B,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED,wBAAgB,cAAc,IAAI,oBAAoB,CAwFrD"}

package/dist/hooks/useMixIdStatus.js

@@ -0,0 +1,81 @@
+import { useState, useEffect, useCallback } from 'react';
+import { mixIdApi } from '../api/mixIdApi';
+import { wsClient } from '../api/websocket';
+export function useMixIdStatus() {
+    const [isConnected, setIsConnected] = useState(false);
+    const [syncStatus, setSyncStatus] = useState('checking');
+    const [hasConfig, setHasConfig] = useState(false);
+    const checkStatus = useCallback(async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            const hasConfigValue = !!(config && config.accessToken);
+            setHasConfig(hasConfigValue);
+            if (!hasConfigValue) {
+                setIsConnected(false);
+                setSyncStatus('disconnected');
+                return;
+            }
+            // Check WebSocket connection
+            const wsConnected = wsClient.isConnected();
+            if (wsConnected) {
+                setIsConnected(true);
+                setSyncStatus('connected-ws');
+            }
+            else {
+                // Check if we can use REST API (try to get sync status)
+                try {
+                    await mixIdApi.getSyncStatus();
+                    setIsConnected(true);
+                    setSyncStatus('connected-rest');
+                }
+                catch (error) {
+                    setIsConnected(false);
+                    setSyncStatus('disconnected');
+                }
+            }
+        }
+        catch (error) {
+            setIsConnected(false);
+            setSyncStatus('disconnected');
+        }
+    }, []);
+    useEffect(() => {
+        // Initial check
+        checkStatus();
+        // Check periodically
+        const interval = setInterval(checkStatus, 2000); // Check every 2 seconds
+        // Listen to storage changes (for cross-tab updates)
+        const handleStorageChange = (e) => {
+            if (e.key === 'mixId_config' || e.key === 'mixId_accessToken' || e.key === 'mixId_refreshToken') {
+                checkStatus();
+            }
+        };
+        if (typeof window !== 'undefined') {
+            window.addEventListener('storage', handleStorageChange);
+            // Listen to custom events for same-tab updates
+            const handleConfigChange = () => {
+                checkStatus();
+            };
+            const handleWsStatusChange = () => {
+                checkStatus();
+            };
+            window.addEventListener('mixid-config-changed', handleConfigChange);
+            window.addEventListener('mixid-ws-status-changed', handleWsStatusChange);
+            return () => {
+                clearInterval(interval);
+                window.removeEventListener('storage', handleStorageChange);
+                window.removeEventListener('mixid-config-changed', handleConfigChange);
+                window.removeEventListener('mixid-ws-status-changed', handleWsStatusChange);
+            };
+        }
+        return () => {
+            clearInterval(interval);
+        };
+    }, [checkStatus]);
+    return {
+        isConnected,
+        syncStatus,
+        hasConfig,
+        refresh: checkStatus,
+    };
+}

package/dist/hooks/useMixIdSync.d.ts

@@ -0,0 +1,16 @@
+export interface UseMixIdSyncOptions {
+    dataTypes?: string[];
+    onSettingsUpdate?: (settings: any) => void;
+    onDataUpdate?: (dataType: string, data: Record<string, any>) => void;
+    getLocalSettings?: () => any;
+    getLocalData?: (dataType: string) => Promise<Record<string, any>>;
+    saveLocalSettings?: (settings: any) => void | Promise<void>;
+    saveLocalData?: (dataType: string, data: Record<string, any>) => void | Promise<void>;
+    mergeStrategy?: 'remote-wins' | 'local-wins' | 'newer-wins';
+}
+export declare function useMixIdSync(options?: UseMixIdSyncOptions): {
+    performSync: () => Promise<void>;
+    uploadSettings: (settingsToUpload: any, version?: number) => Promise<void>;
+    uploadData: (dataType: string, data: Record<string, any>) => Promise<void>;
+};
+//# sourceMappingURL=useMixIdSync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMixIdSync.d.ts","sourceRoot":"","sources":["../../src/hooks/useMixIdSync.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;IACpB,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,CAAA;IAC1C,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,CAAA;IACpE,gBAAgB,CAAC,EAAE,MAAM,GAAG,CAAA;IAC5B,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;IACjE,iBAAiB,CAAC,EAAE,CAAC,QAAQ,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3D,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACrF,aAAa,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,YAAY,CAAA;CAC5D;AAED,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB;;uCA2CjC,GAAG,YAAY,MAAM;2BA6BA,MAAM,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;EAkOlF"}

package/dist/hooks/useMixIdSync.js

@@ -0,0 +1,263 @@
+import { useEffect, useRef, useCallback } from 'react';
+import { mixIdApi } from '../api/mixIdApi';
+import { wsClient } from '../api/websocket';
+import { offlineQueue } from '../api/offlineQueue';
+const SYNC_INTERVAL = 5 * 60 * 1000; // 5 minutes (fallback HTTP sync)
+const HEARTBEAT_INTERVAL = 30 * 1000; // 30 seconds
+export function useMixIdSync(options = {}) {
+    const { dataTypes = [], onSettingsUpdate, onDataUpdate, getLocalSettings, getLocalData, saveLocalSettings, saveLocalData, mergeStrategy = 'newer-wins', } = options;
+    const syncIntervalRef = useRef(null);
+    const heartbeatIntervalRef = useRef(null);
+    const lastSettingsVersionRef = useRef(0);
+    const lastSettingsUpdateRef = useRef(0);
+    // Handle conflict resolution
+    const mergeWithConflictResolution = useCallback((local, remote, remoteUpdatedAt) => {
+        const remoteTime = new Date(remoteUpdatedAt).getTime();
+        const localTime = lastSettingsUpdateRef.current;
+        switch (mergeStrategy) {
+            case 'remote-wins':
+                lastSettingsUpdateRef.current = remoteTime;
+                return { ...local, ...remote };
+            case 'local-wins':
+                return local;
+            case 'newer-wins':
+            default:
+                if (remoteTime > localTime) {
+                    lastSettingsUpdateRef.current = remoteTime;
+                    return { ...local, ...remote };
+                }
+                return local;
+        }
+    }, [mergeStrategy]);
+    // Upload settings
+    const uploadSettings = useCallback(async (settingsToUpload, version) => {
+        try {
+            const syncStatus = await mixIdApi.getSyncStatus();
+            if (!syncStatus.syncSettings)
+                return;
+            const result = await mixIdApi.uploadSettings(settingsToUpload);
+            lastSettingsVersionRef.current = result.version;
+            lastSettingsUpdateRef.current = Date.now();
+            // Send via WebSocket for real-time sync
+            if (wsClient.isConnected()) {
+                wsClient.send({
+                    type: 'sync:settings',
+                    settings: settingsToUpload,
+                    version: result.version,
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to upload settings:', error);
+            // Queue for offline sync
+            if (saveLocalSettings) {
+                offlineQueue.enqueue('settings', settingsToUpload);
+            }
+        }
+    }, [saveLocalSettings]);
+    // Upload data
+    const uploadData = useCallback(async (dataType, data) => {
+        try {
+            const syncStatus = await mixIdApi.getSyncStatus();
+            if (!syncStatus.syncData)
+                return;
+            await mixIdApi.uploadData(dataType, data);
+            // Send via WebSocket for real-time sync
+            if (wsClient.isConnected()) {
+                wsClient.send({
+                    type: 'sync:data',
+                    dataType,
+                    data,
+                });
+            }
+        }
+        catch (error) {
+            console.error(`Failed to upload ${dataType}:`, error);
+            // Queue for offline sync
+            offlineQueue.enqueue('data', data, dataType);
+        }
+    }, []);
+    // Process offline queue
+    const processOfflineQueue = useCallback(async () => {
+        await offlineQueue.processQueue(async (operation) => {
+            if (operation.type === 'settings') {
+                await uploadSettings(operation.data);
+            }
+            else if (operation.type === 'data' && operation.dataType) {
+                await uploadData(operation.dataType, operation.data);
+            }
+        });
+    }, [uploadSettings, uploadData]);
+    // Perform sync
+    const performSync = useCallback(async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return;
+            }
+            // Get sync status
+            const syncStatus = await mixIdApi.getSyncStatus();
+            // Check for updates
+            const updates = await mixIdApi.checkUpdates(lastSettingsVersionRef.current, syncStatus.syncData && dataTypes.length > 0 ? dataTypes : undefined);
+            // Download updates if available
+            if (updates.hasUpdates) {
+                if (updates.updates.settings && syncStatus.syncSettings && getLocalSettings && saveLocalSettings) {
+                    try {
+                        const remoteSettings = await mixIdApi.downloadSettings();
+                        const localSettings = getLocalSettings();
+                        const merged = mergeWithConflictResolution(localSettings, remoteSettings.settings, remoteSettings.updatedAt);
+                        await saveLocalSettings(merged);
+                        lastSettingsVersionRef.current = remoteSettings.version;
+                        onSettingsUpdate?.(merged);
+                    }
+                    catch (error) {
+                        console.error('Failed to download settings:', error);
+                    }
+                }
+                if (updates.updates.data && syncStatus.syncData && dataTypes.length > 0) {
+                    for (const dataType of dataTypes) {
+                        if (updates.updates.data[dataType] && getLocalData && saveLocalData) {
+                            try {
+                                const remoteData = await mixIdApi.downloadData(dataType);
+                                const localData = await getLocalData(dataType);
+                                // Merge with conflict resolution
+                                const merged = { ...localData, ...remoteData.data };
+                                await saveLocalData(dataType, merged);
+                                onDataUpdate?.(dataType, merged);
+                            }
+                            catch (error) {
+                                console.error(`Failed to download ${dataType}:`, error);
+                            }
+                        }
+                    }
+                }
+            }
+            // Upload local changes (only if not already synced via WebSocket)
+            if (syncStatus.syncSettings && getLocalSettings) {
+                const localSettings = getLocalSettings();
+                await uploadSettings(localSettings);
+            }
+            if (syncStatus.syncData && dataTypes.length > 0 && getLocalData) {
+                for (const dataType of dataTypes) {
+                    try {
+                        const localData = await getLocalData(dataType);
+                        if (localData && Object.keys(localData).length > 0) {
+                            await uploadData(dataType, localData);
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Failed to upload ${dataType}:`, error);
+                    }
+                }
+            }
+            // Process offline queue
+            await processOfflineQueue();
+        }
+        catch (error) {
+            console.error('Sync error:', error);
+        }
+    }, [
+        dataTypes,
+        getLocalSettings,
+        getLocalData,
+        saveLocalSettings,
+        saveLocalData,
+        mergeWithConflictResolution,
+        uploadSettings,
+        uploadData,
+        processOfflineQueue,
+        onSettingsUpdate,
+        onDataUpdate,
+    ]);
+    useEffect(() => {
+        const setupSync = () => {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                // Disconnect WebSocket if config is cleared
+                wsClient.disconnect();
+                return;
+            }
+            // Connect WebSocket
+            wsClient.connect();
+        };
+        // Initial setup
+        setupSync();
+        // Listen for config changes
+        const handleConfigChange = () => {
+            setupSync();
+        };
+        if (typeof window !== 'undefined') {
+            window.addEventListener('mixid-config-changed', handleConfigChange);
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return () => {
+                    window.removeEventListener('mixid-config-changed', handleConfigChange);
+                };
+            }
+            // Set up WebSocket event handlers
+            const handleSettingsUpdate = (message) => {
+                if (message.settings && message.updatedAt && getLocalSettings && saveLocalSettings) {
+                    const localSettings = getLocalSettings();
+                    const merged = mergeWithConflictResolution(localSettings, message.settings, message.updatedAt);
+                    saveLocalSettings(merged);
+                    lastSettingsVersionRef.current = message.version || lastSettingsVersionRef.current;
+                    onSettingsUpdate?.(merged);
+                }
+            };
+            const handleDataUpdate = async (message) => {
+                if (message.dataType && message.data && getLocalData && saveLocalData) {
+                    try {
+                        const localData = await getLocalData(message.dataType);
+                        const merged = { ...localData, ...message.data };
+                        await saveLocalData(message.dataType, merged);
+                        onDataUpdate?.(message.dataType, merged);
+                    }
+                    catch (error) {
+                        console.error(`Error merging ${message.dataType}:`, error);
+                    }
+                }
+            };
+            wsClient.on('sync:settings:update', handleSettingsUpdate);
+            wsClient.on('sync:data:update', handleDataUpdate);
+            // Initial sync
+            performSync();
+            // Set up periodic sync (fallback HTTP sync)
+            syncIntervalRef.current = setInterval(performSync, SYNC_INTERVAL);
+            // Set up heartbeat
+            heartbeatIntervalRef.current = setInterval(() => {
+                mixIdApi.heartbeat({
+                    platform: typeof navigator !== 'undefined' ? navigator.platform : 'unknown',
+                    userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'unknown',
+                }).catch(console.error);
+            }, HEARTBEAT_INTERVAL);
+            // Process offline queue when online
+            if (typeof navigator !== 'undefined' && navigator.onLine) {
+                processOfflineQueue();
+            }
+            return () => {
+                window.removeEventListener('mixid-config-changed', handleConfigChange);
+                wsClient.off('sync:settings:update', handleSettingsUpdate);
+                wsClient.off('sync:data:update', handleDataUpdate);
+                if (syncIntervalRef.current) {
+                    clearInterval(syncIntervalRef.current);
+                }
+                if (heartbeatIntervalRef.current) {
+                    clearInterval(heartbeatIntervalRef.current);
+                }
+            };
+        }
+    }, [
+        mergeWithConflictResolution,
+        uploadSettings,
+        uploadData,
+        processOfflineQueue,
+        performSync,
+        getLocalSettings,
+        getLocalData,
+        saveLocalSettings,
+        saveLocalData,
+        onSettingsUpdate,
+        onDataUpdate,
+    ]);
+    return { performSync, uploadSettings, uploadData };
+}

package/dist/hooks/useNotifications.d.ts

@@ -0,0 +1,17 @@
+export interface Notification {
+    id: string;
+    appId: string | null;
+    title: string;
+    message: string;
+    type: string;
+    read: boolean;
+    createdAt: string;
+}
+export declare function useNotifications(): {
+    notifications: Notification[];
+    unreadCount: number;
+    markAsRead: (notificationId: string) => Promise<void>;
+    markAllAsRead: () => Promise<void>;
+    refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useNotifications.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useNotifications.d.ts","sourceRoot":"","sources":["../../src/hooks/useNotifications.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;CAClB;AAID,wBAAgB,gBAAgB;;;iCAiDL,MAAM;;;EAiHhC"}

package/dist/hooks/useNotifications.js

@@ -0,0 +1,144 @@
+import { useState, useEffect, useCallback } from 'react';
+import { mixIdApi } from '../api/mixIdApi';
+import { wsClient } from '../api/websocket';
+const NOTIFICATIONS_STORAGE_KEY = 'mixId_notifications';
+export function useNotifications() {
+    const [notifications, setNotifications] = useState(() => {
+        if (typeof window === 'undefined' || !window.localStorage) {
+            return [];
+        }
+        try {
+            const stored = localStorage.getItem(NOTIFICATIONS_STORAGE_KEY);
+            return stored ? JSON.parse(stored) : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    const [unreadCount, setUnreadCount] = useState(0);
+    const saveNotifications = useCallback((newNotifications) => {
+        setNotifications(newNotifications);
+        if (typeof window !== 'undefined' && window.localStorage) {
+            localStorage.setItem(NOTIFICATIONS_STORAGE_KEY, JSON.stringify(newNotifications));
+        }
+        setUnreadCount(newNotifications.filter((n) => !n.read).length);
+    }, []);
+    const fetchNotifications = useCallback(async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return;
+            }
+            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 response = await fetch(`${apiBase}/notifications`, {
+                headers: {
+                    Authorization: `Bearer ${config.accessToken}`,
+                },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                saveNotifications(data);
+            }
+        }
+        catch (error) {
+            console.error('Failed to fetch notifications:', error);
+        }
+    }, [saveNotifications]);
+    const markAsRead = useCallback(async (notificationId) => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return;
+            }
+            // Update locally first
+            const updated = notifications.map((n) => (n.id === notificationId ? { ...n, read: true } : n));
+            saveNotifications(updated);
+            // Send via WebSocket for real-time sync
+            if (wsClient.isConnected()) {
+                wsClient.send({
+                    type: 'notification:read',
+                    notificationId,
+                });
+            }
+            // Also send via HTTP as fallback
+            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';
+            await fetch(`${apiBase}/notifications/${notificationId}/read`, {
+                method: 'PUT',
+                headers: {
+                    Authorization: `Bearer ${config.accessToken}`,
+                },
+            });
+        }
+        catch (error) {
+            console.error('Failed to mark notification as read:', error);
+        }
+    }, [notifications, saveNotifications]);
+    const markAllAsRead = useCallback(async () => {
+        try {
+            const config = mixIdApi.getConfig();
+            if (!config || !config.accessToken) {
+                return;
+            }
+            // Update locally first
+            const updated = notifications.map((n) => ({ ...n, read: true }));
+            saveNotifications(updated);
+            // Send via HTTP
+            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';
+            await fetch(`${apiBase}/notifications/read-all`, {
+                method: 'PUT',
+                headers: {
+                    Authorization: `Bearer ${config.accessToken}`,
+                },
+            });
+        }
+        catch (error) {
+            console.error('Failed to mark all notifications as read:', error);
+        }
+    }, [notifications, saveNotifications]);
+    useEffect(() => {
+        const config = mixIdApi.getConfig();
+        if (!config || !config.accessToken) {
+            // Clear notifications if MIX ID is not connected
+            saveNotifications([]);
+            return;
+        }
+        // Fetch initial notifications
+        fetchNotifications();
+        // Set up WebSocket handlers
+        const handleNewNotification = (message) => {
+            if (message.notification) {
+                const newNotification = message.notification;
+                const updated = [newNotification, ...notifications];
+                saveNotifications(updated);
+            }
+        };
+        const handleNotificationRead = (message) => {
+            if (message.notificationId) {
+                const updated = notifications.map((n) => n.id === message.notificationId ? { ...n, read: true } : n);
+                saveNotifications(updated);
+            }
+        };
+        wsClient.on('notification:new', handleNewNotification);
+        wsClient.on('notification:read', handleNotificationRead);
+        // Periodic refresh (every 5 minutes)
+        const interval = setInterval(fetchNotifications, 5 * 60 * 1000);
+        return () => {
+            wsClient.off('notification:new', handleNewNotification);
+            wsClient.off('notification:read', handleNotificationRead);
+            clearInterval(interval);
+        };
+    }, [fetchNotifications, notifications, saveNotifications]);
+    return {
+        notifications,
+        unreadCount,
+        markAsRead,
+        markAllAsRead,
+        refresh: fetchNotifications,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './hooks';
+export * from './components';
+export * from './ui';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,OAAO,CAAA;AAGrB,cAAc,SAAS,CAAA;AAGvB,cAAc,cAAc,CAAA;AAG5B,cAAc,MAAM,CAAA"}

package/dist/index.js

@@ -0,0 +1,8 @@
+// API
+export * from './api';
+// Hooks
+export * from './hooks';
+// Components
+export * from './components';
+// UI Components (for future framework)
+export * from './ui';

package/dist/ui/Button.d.ts

@@ -0,0 +1,5 @@
+import { ButtonProps as MantineButtonProps } from '@mantine/core';
+export interface ButtonProps extends MantineButtonProps {
+}
+export declare const Button: import("react").ForwardRefExoticComponent<ButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+//# sourceMappingURL=Button.d.ts.map

package/dist/ui/Button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Button.d.ts","sourceRoot":"","sources":["../../src/ui/Button.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA2B,WAAW,IAAI,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAG1F,MAAM,WAAW,WAAY,SAAQ,kBAAkB;CAEtD;AAED,eAAO,MAAM,MAAM,2GAEjB,CAAA"}

package/dist/ui/Button.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button as MantineButton } from '@mantine/core';
+import { forwardRef } from 'react';
+export const Button = forwardRef((props, ref) => {
+    return _jsx(MantineButton, { ref: ref, ...props });
+});
+Button.displayName = 'Button';

package/dist/ui/Card.d.ts

@@ -0,0 +1,5 @@
+import { PaperProps } from '@mantine/core';
+export interface CardProps extends PaperProps {
+}
+export declare const Card: import("react").ForwardRefExoticComponent<CardProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=Card.d.ts.map

package/dist/ui/Card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Card.d.ts","sourceRoot":"","sources":["../../src/ui/Card.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAS,UAAU,EAAE,MAAM,eAAe,CAAA;AAGjD,MAAM,WAAW,SAAU,SAAQ,UAAU;CAE5C;AAED,eAAO,MAAM,IAAI,sGAEf,CAAA"}

package/dist/ui/Card.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Paper } from '@mantine/core';
+import { forwardRef } from 'react';
+export const Card = forwardRef((props, ref) => {
+    return _jsx(Paper, { ref: ref, withBorder: true, p: "md", ...props });
+});
+Card.displayName = 'Card';

package/dist/ui/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ui/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,QAAQ,CAAA"}

package/dist/ui/index.js

@@ -0,0 +1,2 @@
+export * from './Button';
+export * from './Card';