ui-svelte 0.1.0

package/dist/form/js/phone-examples.js

@@ -0,0 +1,247 @@
+export default {
+    AC: '40123',
+    AD: '312345',
+    AE: '501234567',
+    AF: '701234567',
+    AG: '2684641234',
+    AI: '2642351234',
+    AL: '672123456',
+    AM: '77123456',
+    AO: '923123456',
+    AR: '91123456789',
+    AS: '6847331234',
+    AT: '664123456',
+    AU: '412345678',
+    AW: '5601234',
+    AX: '412345678',
+    AZ: '401234567',
+    BA: '61123456',
+    BB: '2462501234',
+    BD: '1812345678',
+    BE: '470123456',
+    BF: '70123456',
+    BG: '43012345',
+    BH: '36001234',
+    BI: '79561234',
+    BJ: '90011234',
+    BL: '690001234',
+    BM: '4413701234',
+    BN: '7123456',
+    BO: '71234567',
+    BQ: '3181234',
+    BR: '11961234567',
+    BS: '2423591234',
+    BT: '17123456',
+    BW: '71123456',
+    BY: '294911911',
+    BZ: '6221234',
+    CA: '5062345678',
+    CC: '412345678',
+    CD: '991234567',
+    CF: '70012345',
+    CG: '061234567',
+    CH: '781234567',
+    CI: '0123456789',
+    CK: '71234',
+    CL: '221234567',
+    CM: '671234567',
+    CN: '13123456789',
+    CO: '3211234567',
+    CR: '83123456',
+    CU: '51234567',
+    CV: '9911234',
+    CW: '95181234',
+    CX: '412345678',
+    CY: '96123456',
+    CZ: '601123456',
+    DE: '15123456789',
+    DJ: '77831001',
+    DK: '32123456',
+    DM: '7672251234',
+    DO: '8092345678',
+    DZ: '551234567',
+    EC: '991234567',
+    EE: '51234567',
+    EG: '1001234567',
+    EH: '650123456',
+    ER: '7123456',
+    ES: '612345678',
+    ET: '911234567',
+    FI: '412345678',
+    FJ: '7012345',
+    FK: '51234',
+    FM: '3501234',
+    FO: '211234',
+    FR: '612345678',
+    GA: '06031234',
+    GB: '7400123456',
+    GD: '4734031234',
+    GE: '555123456',
+    GF: '694201234',
+    GG: '7781123456',
+    GH: '231234567',
+    GI: '57123456',
+    GL: '221234',
+    GM: '3012345',
+    GN: '601123456',
+    GP: '690001234',
+    GQ: '222123456',
+    GR: '6912345678',
+    GT: '51234567',
+    GU: '6713001234',
+    GW: '955012345',
+    GY: '6091234',
+    HK: '51234567',
+    HN: '91234567',
+    HR: '921234567',
+    HT: '34101234',
+    HU: '201234567',
+    ID: '812345678',
+    IE: '850123456',
+    IL: '502345678',
+    IM: '7924123456',
+    IN: '8123456789',
+    IO: '3801234',
+    IQ: '7912345678',
+    IR: '9123456789',
+    IS: '6111234',
+    IT: '3123456789',
+    JE: '7797712345',
+    JM: '8762101234',
+    JO: '790123456',
+    JP: '9012345678',
+    KE: '712123456',
+    KG: '700123456',
+    KH: '91234567',
+    KI: '72001234',
+    KM: '3212345',
+    KN: '8697652917',
+    KP: '1921234567',
+    KR: '1020000000',
+    KW: '50012345',
+    KY: '3453231234',
+    KZ: '7710009998',
+    LA: '2023123456',
+    LB: '71123456',
+    LC: '7582845678',
+    LI: '660234567',
+    LK: '712345678',
+    LR: '770123456',
+    LS: '50123456',
+    LT: '61234567',
+    LU: '628123456',
+    LV: '21234567',
+    LY: '912345678',
+    MA: '650123456',
+    MC: '612345678',
+    MD: '62112345',
+    ME: '67622901',
+    MF: '690001234',
+    MG: '321234567',
+    MH: '2351234',
+    MK: '72345678',
+    ML: '65012345',
+    MM: '92123456',
+    MN: '88123456',
+    MO: '66123456',
+    MP: '6702345678',
+    MQ: '696201234',
+    MR: '22123456',
+    MS: '6644923456',
+    MT: '96961234',
+    MU: '52512345',
+    MV: '7712345',
+    MW: '991234567',
+    MX: '12221234567',
+    MY: '123456789',
+    MZ: '821234567',
+    NA: '811234567',
+    NC: '751234',
+    NE: '93123456',
+    NF: '381234',
+    NG: '8021234567',
+    NI: '81234567',
+    NL: '612345678',
+    NO: '40612345',
+    NP: '9841234567',
+    NR: '5551234',
+    NU: '8884012',
+    NZ: '211234567',
+    OM: '92123456',
+    PA: '61234567',
+    PE: '912345678',
+    PF: '87123456',
+    PG: '70123456',
+    PH: '9051234567',
+    PK: '3012345678',
+    PL: '512345678',
+    PM: '551234',
+    PR: '7872345678',
+    PS: '599123456',
+    PT: '912345678',
+    PW: '6201234',
+    PY: '961456789',
+    QA: '33123456',
+    RE: '692123456',
+    RO: '712034567',
+    RS: '601234567',
+    RU: '9123456789',
+    RW: '720123456',
+    SA: '512345678',
+    SB: '7421234',
+    SC: '2510123',
+    SD: '911231234',
+    SE: '701234567',
+    SG: '81234567',
+    SH: '51234',
+    SI: '31234567',
+    SJ: '41234567',
+    SK: '912123456',
+    SL: '25123456',
+    SM: '66661212',
+    SN: '701234567',
+    SO: '71123456',
+    SR: '7412345',
+    SS: '977123456',
+    ST: '9812345',
+    SV: '70123456',
+    SX: '7215205678',
+    SY: '944567890',
+    SZ: '76123456',
+    TA: '8999',
+    TC: '6492311234',
+    TD: '63012345',
+    TG: '90112345',
+    TH: '812345678',
+    TJ: '917123456',
+    TK: '7290',
+    TL: '77212345',
+    TM: '66123456',
+    TN: '20123456',
+    TO: '7715123',
+    TR: '5012345678',
+    TT: '8682911234',
+    TV: '901234',
+    TW: '912345678',
+    TZ: '621234567',
+    UA: '501234567',
+    UG: '712345678',
+    US: '2015550123',
+    UY: '94231234',
+    UZ: '912345678',
+    VA: '3123456789',
+    VC: '7844301234',
+    VE: '4121234567',
+    VG: '2843001234',
+    VI: '3406421234',
+    VN: '912345678',
+    VU: '5912345',
+    WF: '821234',
+    WS: '7212345',
+    XK: '43201234',
+    YE: '712345678',
+    YT: '639012345',
+    ZA: '711234567',
+    ZM: '955123456',
+    ZW: '712345678'
+};

package/dist/hooks/use-auth.svelte.d.ts

@@ -0,0 +1,11 @@
+type Config = {
+    endpoint: string;
+    routeAccess?: string;
+    urlSuccess?: string;
+    urlError?: string;
+};
+export declare const useAuth: (config: Config) => {
+    readonly isLoading: boolean;
+    readonly isAuthorized: boolean;
+};
+export {};

package/dist/hooks/use-auth.svelte.js

@@ -0,0 +1,59 @@
+import { goto } from '$app/navigation';
+import { onMount } from 'svelte';
+export const useAuth = (config) => {
+    let isLoading = $state(true);
+    let isAuthorized = $state(false);
+    onMount(async () => {
+        try {
+            const token = localStorage.getItem('token');
+            if (!token) {
+                isAuthorized = false;
+                if (config.urlError) {
+                    await goto(config.urlError);
+                }
+                isLoading = false;
+                return;
+            }
+            let url = config.endpoint;
+            if (config.routeAccess) {
+                const separator = url.includes('?') ? '&' : '?';
+                url = `${url}${separator}routeAccess=${encodeURIComponent(config.routeAccess)}`;
+            }
+            const res = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${token}`
+                }
+            });
+            if (!res.ok) {
+                throw new Error(`Error de autenticación: ${res.status}`);
+            }
+            const data = await res.json();
+            if (!data || !data.user) {
+                throw new Error('Respuesta inválida del servidor');
+            }
+            isAuthorized = true;
+            if (config.urlSuccess) {
+                await goto(config.urlSuccess);
+            }
+            isLoading = false;
+        }
+        catch {
+            if (config.urlError) {
+                localStorage.removeItem('token');
+                await goto(config.urlError);
+            }
+            isAuthorized = false;
+            isLoading = false;
+        }
+    });
+    return {
+        get isLoading() {
+            return isLoading;
+        },
+        get isAuthorized() {
+            return isAuthorized;
+        }
+    };
+};

package/dist/hooks/use-chat.svelte.d.ts

@@ -0,0 +1,40 @@
+export interface Message {
+    id: string;
+    content: string;
+    senderId: string;
+    timestamp: Date | string;
+    status?: 'sending' | 'sent' | 'delivered' | 'read' | 'error';
+    type?: 'text' | 'image' | 'file';
+    metadata?: Record<string, any>;
+}
+export interface ChatConfig {
+    chatId: string;
+    userId: string;
+    apiUrl: string;
+    wsUrl: string;
+    headers?: Record<string, string>;
+    initialLimit?: number;
+    onMessageReceived?: (message: Message) => void;
+    onMessageSent?: (message: Message) => void;
+    onError?: (error: any) => void;
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+    transformMessage?: (data: any) => Message;
+    autoConnect?: boolean;
+    reconnectInterval?: number;
+    maxReconnectAttempts?: number;
+}
+export interface ChatState {
+    messages: Message[];
+    isLoading: boolean;
+    isConnected: boolean;
+    error: any;
+    sendMessage: (content: string, type?: string, metadata?: Record<string, any>) => Promise<void>;
+    loadMore: () => Promise<void>;
+    markAsRead: (messageId: string) => void;
+    connect: () => void;
+    disconnect: () => void;
+    hasMore: boolean;
+    isSending: boolean;
+}
+export declare const useChat: (config: ChatConfig) => ChatState;

package/dist/hooks/use-chat.svelte.js

@@ -0,0 +1,265 @@
+export const useChat = (config) => {
+    let messages = $state([]);
+    let isLoading = $state(false);
+    let isConnected = $state(false);
+    let error = $state(null);
+    let hasMore = $state(true);
+    let isSending = $state(false);
+    let ws = null;
+    let reconnectAttempts = 0;
+    let reconnectTimeout;
+    let oldestMessageId = null;
+    const maxReconnectAttempts = config.maxReconnectAttempts ?? 5;
+    const reconnectInterval = config.reconnectInterval ?? 3000;
+    const loadInitialMessages = async () => {
+        isLoading = true;
+        error = null;
+        try {
+            const token = localStorage.getItem('token');
+            const headers = {
+                'Content-Type': 'application/json',
+                ...config.headers
+            };
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            const limit = config.initialLimit ?? 50;
+            const response = await fetch(`${config.apiUrl}/chats/${config.chatId}/messages?limit=${limit}`, {
+                method: 'GET',
+                headers
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            const loadedMessages = config.transformMessage
+                ? data.messages.map(config.transformMessage)
+                : data.messages;
+            messages = loadedMessages.reverse(); // Asumiendo que vienen del más reciente al más antiguo
+            hasMore = data.hasMore ?? false;
+            if (messages.length > 0) {
+                oldestMessageId = messages[0].id;
+            }
+        }
+        catch (err) {
+            error = err;
+            config.onError?.(err);
+        }
+        finally {
+            isLoading = false;
+        }
+    };
+    const loadMore = async () => {
+        if (!hasMore || isLoading)
+            return;
+        isLoading = true;
+        try {
+            const token = localStorage.getItem('token');
+            const headers = {
+                'Content-Type': 'application/json',
+                ...config.headers
+            };
+            if (token) {
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            const limit = config.initialLimit ?? 50;
+            const response = await fetch(`${config.apiUrl}/chats/${config.chatId}/messages?limit=${limit}&before=${oldestMessageId}`, {
+                method: 'GET',
+                headers
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const data = await response.json();
+            const loadedMessages = config.transformMessage
+                ? data.messages.map(config.transformMessage)
+                : data.messages;
+            messages = [...loadedMessages.reverse(), ...messages];
+            hasMore = data.hasMore ?? false;
+            if (loadedMessages.length > 0) {
+                oldestMessageId = loadedMessages[0].id;
+            }
+        }
+        catch (err) {
+            error = err;
+            config.onError?.(err);
+        }
+        finally {
+            isLoading = false;
+        }
+    };
+    const connect = () => {
+        if (ws && (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING)) {
+            return;
+        }
+        try {
+            const token = localStorage.getItem('token');
+            const wsUrl = token
+                ? `${config.wsUrl}?token=${token}&chatId=${config.chatId}&userId=${config.userId}`
+                : `${config.wsUrl}?chatId=${config.chatId}&userId=${config.userId}`;
+            ws = new WebSocket(wsUrl);
+            ws.onopen = () => {
+                isConnected = true;
+                reconnectAttempts = 0;
+                config.onConnected?.();
+            };
+            ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data);
+                    switch (data.type) {
+                        case 'message':
+                            const newMessage = config.transformMessage
+                                ? config.transformMessage(data.message)
+                                : data.message;
+                            if (!messages.some((m) => m.id === newMessage.id)) {
+                                messages = [...messages, newMessage];
+                                config.onMessageReceived?.(newMessage);
+                            }
+                            break;
+                        case 'status':
+                            messages = messages.map((m) => m.id === data.messageId ? { ...m, status: data.status } : m);
+                            break;
+                        case 'typing':
+                            break;
+                    }
+                }
+                catch (err) {
+                    console.error('Error parsing WebSocket message:', err);
+                }
+            };
+            ws.onerror = (event) => {
+                error = event;
+                config.onError?.(event);
+            };
+            ws.onclose = () => {
+                isConnected = false;
+                config.onDisconnected?.();
+                if (reconnectAttempts < maxReconnectAttempts) {
+                    reconnectAttempts++;
+                    reconnectTimeout = setTimeout(() => {
+                        connect();
+                    }, reconnectInterval);
+                }
+            };
+        }
+        catch (err) {
+            error = err;
+            config.onError?.(err);
+        }
+    };
+    const disconnect = () => {
+        clearTimeout(reconnectTimeout);
+        reconnectAttempts = maxReconnectAttempts;
+        if (ws) {
+            ws.close();
+            ws = null;
+        }
+        isConnected = false;
+    };
+    const sendMessage = async (content, type = 'text', metadata) => {
+        if (!content.trim() || isSending)
+            return;
+        const tempId = `temp-${Date.now()}`;
+        const tempMessage = {
+            id: tempId,
+            content,
+            senderId: config.userId,
+            timestamp: new Date(),
+            status: 'sending',
+            type: type,
+            metadata
+        };
+        messages = [...messages, tempMessage];
+        isSending = true;
+        try {
+            if (ws && ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'message',
+                    chatId: config.chatId,
+                    content,
+                    messageType: type,
+                    metadata
+                }));
+            }
+            else {
+                const token = localStorage.getItem('token');
+                const headers = {
+                    'Content-Type': 'application/json',
+                    ...config.headers
+                };
+                if (token) {
+                    headers['Authorization'] = `Bearer ${token}`;
+                }
+                const response = await fetch(`${config.apiUrl}/chats/${config.chatId}/messages`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        content,
+                        type,
+                        metadata
+                    })
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                const data = await response.json();
+                const sentMessage = config.transformMessage
+                    ? config.transformMessage(data.message)
+                    : data.message;
+                messages = messages.map((m) => (m.id === tempId ? sentMessage : m));
+                config.onMessageSent?.(sentMessage);
+            }
+        }
+        catch (err) {
+            messages = messages.map((m) => (m.id === tempId ? { ...m, status: 'error' } : m));
+            error = err;
+            config.onError?.(err);
+        }
+        finally {
+            isSending = false;
+        }
+    };
+    const markAsRead = (messageId) => {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                type: 'read',
+                messageId,
+                chatId: config.chatId
+            }));
+        }
+    };
+    $effect(() => {
+        loadInitialMessages();
+        if (config.autoConnect !== false) {
+            connect();
+        }
+        return () => {
+            disconnect();
+        };
+    });
+    return {
+        get messages() {
+            return messages;
+        },
+        get isLoading() {
+            return isLoading;
+        },
+        get isConnected() {
+            return isConnected;
+        },
+        get error() {
+            return error;
+        },
+        get hasMore() {
+            return hasMore;
+        },
+        get isSending() {
+            return isSending;
+        },
+        sendMessage,
+        loadMore,
+        markAsRead,
+        connect,
+        disconnect
+    };
+};

package/dist/hooks/use-clipboard.svelte.d.ts

@@ -0,0 +1,9 @@
+type Config = {
+    delay?: number;
+};
+type ValidCopy = string | number;
+export declare const useClipboard: (config?: Config) => {
+    readonly copied: boolean;
+    copy: (newCopyString: ValidCopy | undefined) => Promise<void>;
+};
+export {};

package/dist/hooks/use-clipboard.svelte.js

@@ -0,0 +1,52 @@
+const copyMethods = [
+    async (str) => {
+        await navigator.clipboard.writeText(str);
+    },
+    async (str) => {
+        const textarea = document.createElement('textarea');
+        textarea.value = str;
+        textarea.style.position = 'fixed';
+        textarea.style.opacity = '0';
+        document.body.appendChild(textarea);
+        textarea.focus();
+        textarea.select();
+        document.execCommand('copy');
+        document.body.removeChild(textarea);
+    }
+];
+export const useClipboard = (config = {}) => {
+    const { delay = 6000 } = config;
+    let lastCopied = $state(null);
+    let copied = $derived(lastCopied !== null);
+    const copyToClipboard = async (overwriteCopyStr) => {
+        const strToCopy = String(overwriteCopyStr);
+        for (const method of copyMethods) {
+            try {
+                await method(strToCopy);
+                return;
+            }
+            catch (error) {
+                console.error('Copy method failed:', error);
+            }
+        }
+        throw new Error('Copy failed, browser not supported.');
+    };
+    const copy = async (newCopyString) => {
+        if (!['string', 'number'].includes(typeof newCopyString)) {
+            throw new Error('Invalid copy type: Only string and number are supported.');
+        }
+        const time = Date.now();
+        lastCopied = time;
+        await copyToClipboard(newCopyString);
+        await new Promise((res) => setTimeout(res, delay));
+        if (time !== lastCopied)
+            return;
+        lastCopied = null;
+    };
+    return {
+        get copied() {
+            return copied;
+        },
+        copy
+    };
+};

package/dist/hooks/use-fetch.svelte.d.ts

@@ -0,0 +1,11 @@
+export interface FetchConfig {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    headers?: Record<string, string>;
+    onSuccess?: (data: Object) => void;
+    onError?: (error: string) => void;
+}
+export declare const useFetch: (config: FetchConfig) => {
+    readonly loading: boolean;
+    request: (body: Object) => Promise<void>;
+};