react-embed-docs 0.1.0

package/dist/client/hooks/useDocsQuery.d.ts

@@ -0,0 +1,84 @@
+import type { Document, DocumentSummary, ListDocumentsFilters, ListDocumentsOptions, ListDocumentsResult, UpdateDocument } from '../../shared/types.js';
+/**
+ * Query key factory for documents
+ * Provides consistent query keys for caching and invalidation
+ */
+export declare const docsQueryKeys: {
+    all: readonly ["docs"];
+    lists: () => readonly ["docs", "list"];
+    list: (filters?: ListDocumentsFilters) => readonly ["docs", "list", ListDocumentsFilters];
+    trees: () => readonly ["docs", "tree"];
+    tree: () => readonly ["docs", "tree"];
+    details: () => readonly ["docs", "detail"];
+    detail: (id: string) => readonly ["docs", "detail", string];
+    slug: (slug: string) => readonly ["docs", "detail", "slug", string];
+    children: (parentId: string) => readonly ["docs", "children", string];
+    search: (query: string) => readonly ["docs", "search", string];
+};
+/**
+ * Hook to list/search documents with filters
+ * Supports pagination, sorting, and filtering by parent, published status, and search query
+ */
+export declare function useDocumentsQuery(filters?: ListDocumentsFilters, options?: ListDocumentsOptions, queryOptions?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<ListDocumentsResult, Error>;
+/**
+ * Hook to get a single document by ID
+ */
+export declare function useDocumentQuery(id: string | null | undefined, options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<Document, Error>;
+/**
+ * Hook to get a document by slug
+ */
+export declare function useDocumentBySlugQuery(slug: string, options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<Document, Error>;
+/**
+ * Hook to create a new document
+ * Invalidates list queries on success
+ */
+export declare function useCreateDocumentMutation(): import("@tanstack/react-query").UseMutationResult<Document, Error, {
+    slug: string;
+    title: string;
+    isPublished: boolean;
+    content?: any;
+    emoji?: string | undefined;
+    cover?: string | null | undefined;
+    authorId?: number | undefined;
+    parentSlugs?: string[] | undefined;
+}, unknown>;
+/**
+ * Hook to update an existing document
+ * Invalidates the specific document and list queries on success
+ */
+export declare function useUpdateDocumentMutation(): import("@tanstack/react-query").UseMutationResult<Document, Error, {
+    id: string;
+    data: UpdateDocument;
+}, unknown>;
+/**
+ * Hook to soft delete a document
+ * Removes from cache and invalidates lists on success
+ */
+export declare function useDeleteDocumentMutation(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * Hook to reorder a document (move to new parent and/or position)
+ * Implements optimistic updates for immediate UI feedback
+ */
+export declare function useReorderDocumentMutation(): import("@tanstack/react-query").UseMutationResult<DocumentSummary, Error, {
+    id: string;
+    parentId: string | null;
+    order: number;
+}, {
+    previousLists: [unknown, ListDocumentsResult | undefined][];
+    previousTrees: [unknown, DocumentSummary[] | undefined][];
+}>;
+/**
+ * Hook to update just the order field of a document
+ * Useful for drag-and-drop sorting within the same parent
+ */
+export declare function useUpdateOrderMutation(): import("@tanstack/react-query").UseMutationResult<DocumentSummary, Error, {
+    id: string;
+    order: number;
+}, unknown>;
+//# sourceMappingURL=useDocsQuery.d.ts.map

package/dist/client/hooks/useDocsQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocsQuery.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useDocsQuery.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,QAAQ,EACR,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACf,MAAM,uBAAuB,CAAA;AAqF9B;;;GAGG;AACH,eAAO,MAAM,aAAa;;;qBAGR,oBAAoB;;;;iBAIvB,MAAM;iBACN,MAAM;yBACE,MAAM;oBACX,MAAM;CACvB,CAAA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,oBAAyB,EAClC,OAAO,GAAE,oBAAyB,EAClC,YAAY,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,8EAOzC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,mEAMlG;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,mEAMvF;AAED;;;GAGG;AACH,wBAAgB,yBAAyB;;;;;;;;;YAUxC;AAED;;;GAGG;AACH,wBAAgB,yBAAyB;QAKS,MAAM;UAAQ,cAAc;YAM7E;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,oFAUxC;AAED;;;GAGG;AACH,wBAAgB,0BAA0B;QAgClB,MAAM;cAAY,MAAM,GAAG,IAAI;WAAS,MAAM;;mBACtC,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAAC,EAAE;mBAAiB,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,SAAS,CAAC,EAAE;GAkBtI;AAED;;;GAGG;AACH,wBAAgB,sBAAsB;QAKmB,MAAM;WAAS,MAAM;YAM7E"}

package/dist/client/hooks/useDocsQuery.js

@@ -0,0 +1,241 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+/**
+ * API client for documents
+ */
+const api = {
+    list: async (filters, options) => {
+        const params = new URLSearchParams();
+        if (filters?.search)
+            params.set('search', filters.search);
+        if (filters?.parentId !== undefined)
+            params.set('parentId', filters.parentId ?? 'null');
+        if (filters?.isPublished !== undefined)
+            params.set('isPublished', String(filters.isPublished));
+        if (options?.offset)
+            params.set('offset', String(options.offset));
+        if (options?.limit)
+            params.set('limit', String(options.limit));
+        if (options?.sortBy)
+            params.set('sortBy', String(options.sortBy));
+        if (options?.sortDir)
+            params.set('sortDir', options.sortDir);
+        const res = await fetch(`/api/docs?${params}`);
+        if (!res.ok)
+            throw new Error('Failed to fetch documents');
+        const data = await res.json();
+        return {
+            documents: data.items,
+            total: data.total,
+        };
+    },
+    getById: async (id) => {
+        const res = await fetch(`/api/docs/${id}`);
+        if (!res.ok)
+            throw new Error('Failed to fetch document');
+        return res.json();
+    },
+    getBySlug: async (slug) => {
+        const res = await fetch(`/api/docs/slug/${slug}`);
+        if (!res.ok)
+            throw new Error('Failed to fetch document');
+        return res.json();
+    },
+    create: async (data) => {
+        const res = await fetch('/api/docs', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data),
+        });
+        if (!res.ok)
+            throw new Error('Failed to create document');
+        return res.json();
+    },
+    update: async (id, data) => {
+        const res = await fetch(`/api/docs/${id}`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(data),
+        });
+        if (!res.ok)
+            throw new Error('Failed to update document');
+        return res.json();
+    },
+    delete: async (id) => {
+        const res = await fetch(`/api/docs/${id}`, {
+            method: 'DELETE',
+        });
+        if (!res.ok)
+            throw new Error('Failed to delete document');
+    },
+    reorder: async (id, parentId, order) => {
+        const res = await fetch(`/api/docs/${id}/reorder`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ parentId, order }),
+        });
+        if (!res.ok)
+            throw new Error('Failed to reorder document');
+        return res.json();
+    },
+    updateOrder: async (id, order) => {
+        const res = await fetch(`/api/docs/${id}/order`, {
+            method: 'PATCH',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ order }),
+        });
+        if (!res.ok)
+            throw new Error('Failed to update document order');
+        return res.json();
+    },
+};
+/**
+ * Query key factory for documents
+ * Provides consistent query keys for caching and invalidation
+ */
+export const docsQueryKeys = {
+    all: ['docs'],
+    lists: () => [...docsQueryKeys.all, 'list'],
+    list: (filters = {}) => [...docsQueryKeys.lists(), filters],
+    trees: () => [...docsQueryKeys.all, 'tree'],
+    tree: () => [...docsQueryKeys.trees()],
+    details: () => [...docsQueryKeys.all, 'detail'],
+    detail: (id) => [...docsQueryKeys.details(), id],
+    slug: (slug) => [...docsQueryKeys.details(), 'slug', slug],
+    children: (parentId) => [...docsQueryKeys.all, 'children', parentId],
+    search: (query) => [...docsQueryKeys.all, 'search', query],
+};
+/**
+ * Hook to list/search documents with filters
+ * Supports pagination, sorting, and filtering by parent, published status, and search query
+ */
+export function useDocumentsQuery(filters = {}, options = {}, queryOptions = {}) {
+    return useQuery({
+        queryKey: docsQueryKeys.list(filters),
+        queryFn: () => api.list(filters, options),
+        ...queryOptions,
+    });
+}
+/**
+ * Hook to get a single document by ID
+ */
+export function useDocumentQuery(id, options = {}) {
+    return useQuery({
+        queryKey: docsQueryKeys.detail(id),
+        queryFn: () => api.getById(id),
+        enabled: !!id && options.enabled !== false,
+    });
+}
+/**
+ * Hook to get a document by slug
+ */
+export function useDocumentBySlugQuery(slug, options = {}) {
+    return useQuery({
+        queryKey: docsQueryKeys.slug(slug),
+        queryFn: () => api.getBySlug(slug),
+        enabled: !!slug && options.enabled !== false,
+    });
+}
+/**
+ * Hook to create a new document
+ * Invalidates list queries on success
+ */
+export function useCreateDocumentMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: api.create,
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.trees() });
+        },
+    });
+}
+/**
+ * Hook to update an existing document
+ * Invalidates the specific document and list queries on success
+ */
+export function useUpdateDocumentMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, data }) => api.update(id, data),
+        onSuccess: (_data, variables) => {
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.detail(variables.id) });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.trees() });
+        },
+    });
+}
+/**
+ * Hook to soft delete a document
+ * Removes from cache and invalidates lists on success
+ */
+export function useDeleteDocumentMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: api.delete,
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.trees() });
+        },
+    });
+}
+/**
+ * Hook to reorder a document (move to new parent and/or position)
+ * Implements optimistic updates for immediate UI feedback
+ */
+export function useReorderDocumentMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, parentId, order }) => api.reorder(id, parentId, order),
+        onMutate: async (variables) => {
+            const { id, parentId, order } = variables;
+            // Cancel outgoing refetches
+            await queryClient.cancelQueries({ queryKey: docsQueryKeys.lists() });
+            await queryClient.cancelQueries({ queryKey: docsQueryKeys.trees() });
+            // Snapshot previous values
+            const previousLists = queryClient.getQueriesData({ queryKey: docsQueryKeys.lists() });
+            const previousTrees = queryClient.getQueriesData({ queryKey: docsQueryKeys.trees() });
+            // Optimistically update all list caches
+            queryClient.setQueriesData({ queryKey: docsQueryKeys.lists() }, (old) => {
+                if (!old)
+                    return old;
+                return {
+                    ...old,
+                    documents: old.documents.map((doc) => doc.id === id ? { ...doc, parentId, order } : doc),
+                };
+            });
+            // Return context for rollback
+            return { previousLists, previousTrees };
+        },
+        onError: (_err, _variables, context) => {
+            // Rollback on error
+            if (context) {
+                context.previousLists.forEach(([key, value]) => {
+                    queryClient.setQueryData(key, value);
+                });
+                context.previousTrees.forEach(([key, value]) => {
+                    queryClient.setQueryData(key, value);
+                });
+            }
+        },
+        onSettled: () => {
+            // Always refetch after error or success
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.trees() });
+        },
+    });
+}
+/**
+ * Hook to update just the order field of a document
+ * Useful for drag-and-drop sorting within the same parent
+ */
+export function useUpdateOrderMutation() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: ({ id, order }) => api.updateOrder(id, order),
+        onSuccess: (_data, variables) => {
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.detail(variables.id) });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.lists() });
+            queryClient.invalidateQueries({ queryKey: docsQueryKeys.trees() });
+        },
+    });
+}

package/dist/client/hooks/useExport.d.ts

@@ -0,0 +1,31 @@
+export type ExportFormat = 'docx' | 'pdf' | 'html' | 'markdown';
+export interface UseExportOptions {
+    /** Base URL for API requests (default: '/api') */
+    baseUrl?: string;
+}
+export interface UseExportReturn {
+    exportDocument: (documentId: string, format: ExportFormat, filename?: string) => Promise<void>;
+    isExporting: boolean;
+    error: Error | null;
+}
+/**
+ * Hook for exporting documents to various formats
+ *
+ * @example
+ * ```tsx
+ * function DocumentView({ docId }: { docId: string }) {
+ *   const { exportDocument, isExporting } = useExport()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => exportDocument(docId, 'docx')}
+ *       disabled={isExporting}
+ *     >
+ *       Export to Word
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare function useExport(options?: UseExportOptions): UseExportReturn;
+//# sourceMappingURL=useExport.d.ts.map

package/dist/client/hooks/useExport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExport.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useExport.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,UAAU,CAAA;AAE/D,MAAM,WAAW,gBAAgB;IAC/B,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9F,WAAW,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG,eAAe,CAwDzE"}

package/dist/client/hooks/useExport.js

@@ -0,0 +1,66 @@
+import { useState, useCallback } from 'react';
+/**
+ * Hook for exporting documents to various formats
+ *
+ * @example
+ * ```tsx
+ * function DocumentView({ docId }: { docId: string }) {
+ *   const { exportDocument, isExporting } = useExport()
+ *
+ *   return (
+ *     <button
+ *       onClick={() => exportDocument(docId, 'docx')}
+ *       disabled={isExporting}
+ *     >
+ *       Export to Word
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export function useExport(options = {}) {
+    const { baseUrl = '/api' } = options;
+    const [isExporting, setIsExporting] = useState(false);
+    const [error, setError] = useState(null);
+    const exportDocument = useCallback(async (documentId, format, filename) => {
+        setIsExporting(true);
+        setError(null);
+        try {
+            const response = await fetch(`${baseUrl}/docs/${documentId}/export?format=${format}`);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                throw new Error(errorData.message || `Export failed: ${response.statusText}`);
+            }
+            // Get the blob
+            const blob = await response.blob();
+            // Determine filename from Content-Disposition header or use default
+            const contentDisposition = response.headers.get('Content-Disposition');
+            const downloadedFilename = contentDisposition
+                ?.match(/filename="([^"]+)"/)?.[1]
+                || filename
+                || `document.${format === 'markdown' ? 'md' : format}`;
+            // Create download link
+            const url = window.URL.createObjectURL(blob);
+            const link = document.createElement('a');
+            link.href = url;
+            link.download = downloadedFilename;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            window.URL.revokeObjectURL(url);
+        }
+        catch (err) {
+            const exportError = err instanceof Error ? err : new Error('Export failed');
+            setError(exportError);
+            throw exportError;
+        }
+        finally {
+            setIsExporting(false);
+        }
+    }, [baseUrl]);
+    return {
+        exportDocument,
+        isExporting,
+        error,
+    };
+}

package/dist/client/hooks/useFileUpload.d.ts

@@ -0,0 +1,44 @@
+export interface FileUploadOptions {
+    maxSize?: number;
+    acceptedTypes?: string[];
+    onProgress?: (progress: number) => void;
+}
+export interface FileUploadState {
+    isUploading: boolean;
+    progress: number;
+    error: Error | null;
+}
+export interface UploadResult {
+    id: string;
+    filename: string;
+    mimeType: string;
+    size: number;
+    url: string;
+}
+/**
+ * Hook for handling file uploads with base64 conversion
+ * Features:
+ * - File size and type validation
+ * - Upload progress tracking
+ * - Error handling
+ * - Base64 conversion
+ */
+export declare function useFileUpload(options?: FileUploadOptions): {
+    isUploading: boolean;
+    progress: number;
+    error: Error | null;
+    uploadFile: (file: File) => Promise<UploadResult>;
+    reset: () => void;
+};
+/**
+ * Hook for handling multiple file uploads
+ */
+export declare function useMultiFileUpload(options?: FileUploadOptions): {
+    isUploading: boolean;
+    progress: Record<string, number>;
+    errors: Record<string, Error>;
+    results: Record<string, UploadResult>;
+    uploadFiles: (files: File[]) => Promise<UploadResult[]>;
+    reset: () => void;
+};
+//# sourceMappingURL=useFileUpload.d.ts.map

package/dist/client/hooks/useFileUpload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFileUpload.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useFileUpload.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CACxC;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ;AAuCD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,iBAAsB;;;;uBAQ5C,IAAI,KAAG,OAAO,CAAC,YAAY,CAAC;;EA+E5C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,iBAAsB;;;;;yBAShD,IAAI,EAAE,KAAG,OAAO,CAAC,YAAY,EAAE,CAAC;;EA8EjD"}

package/dist/client/hooks/useFileUpload.js

@@ -0,0 +1,193 @@
+import { useCallback, useState } from 'react';
+/**
+ * Converts a File to base64 string
+ */
+function fileToBase64(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            const result = reader.result;
+            const base64 = result.split(',')[1];
+            resolve(base64);
+        };
+        reader.onerror = reject;
+        reader.readAsDataURL(file);
+    });
+}
+/**
+ * Validates file size
+ */
+function validateFileSize(file, maxSize) {
+    return file.size <= maxSize;
+}
+/**
+ * Validates file type
+ */
+function validateFileType(file, acceptedTypes) {
+    if (!acceptedTypes || acceptedTypes.length === 0)
+        return true;
+    return acceptedTypes.some((type) => {
+        if (type.includes('*')) {
+            const [category] = type.split('/');
+            return file.type.startsWith(`${category}/`);
+        }
+        return file.type === type;
+    });
+}
+/**
+ * Hook for handling file uploads with base64 conversion
+ * Features:
+ * - File size and type validation
+ * - Upload progress tracking
+ * - Error handling
+ * - Base64 conversion
+ */
+export function useFileUpload(options = {}) {
+    const { maxSize = 5 * 1024 * 1024, acceptedTypes, onProgress } = options;
+    const [isUploading, setIsUploading] = useState(false);
+    const [progress, setProgress] = useState(0);
+    const [error, setError] = useState(null);
+    const uploadFile = useCallback(async (file) => {
+        setIsUploading(true);
+        setProgress(0);
+        setError(null);
+        try {
+            // Validate file size
+            if (!validateFileSize(file, maxSize)) {
+                throw new Error(`File too large (max ${(maxSize / 1024 / 1024).toFixed(1)}MB)`);
+            }
+            // Validate file type
+            if (!validateFileType(file, acceptedTypes)) {
+                throw new Error(`File type not accepted. Allowed: ${acceptedTypes?.join(', ') ?? 'all'}`);
+            }
+            // Simulate progress updates
+            const progressInterval = setInterval(() => {
+                setProgress((prev) => {
+                    const next = prev + Math.random() * 20;
+                    if (next >= 90) {
+                        clearInterval(progressInterval);
+                        return 90;
+                    }
+                    onProgress?.(next);
+                    return next;
+                });
+            }, 100);
+            // Convert to base64
+            const base64Content = await fileToBase64(file);
+            // Upload to server
+            const res = await fetch('/api/docs/files', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    filename: file.name,
+                    mimeType: file.type,
+                    content: base64Content,
+                }),
+            });
+            clearInterval(progressInterval);
+            if (!res.ok) {
+                const errorData = await res.json().catch(() => ({ message: 'Upload failed' }));
+                throw new Error(errorData.message || `Upload failed: ${res.statusText}`);
+            }
+            setProgress(100);
+            onProgress?.(100);
+            const result = await res.json();
+            return result;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, [maxSize, acceptedTypes, onProgress]);
+    const reset = useCallback(() => {
+        setIsUploading(false);
+        setProgress(0);
+        setError(null);
+    }, []);
+    return {
+        isUploading,
+        progress,
+        error,
+        uploadFile,
+        reset,
+    };
+}
+/**
+ * Hook for handling multiple file uploads
+ */
+export function useMultiFileUpload(options = {}) {
+    const { maxSize = 5 * 1024 * 1024, acceptedTypes } = options;
+    const [isUploading, setIsUploading] = useState(false);
+    const [progress, setProgress] = useState({});
+    const [errors, setErrors] = useState({});
+    const [results, setResults] = useState({});
+    const uploadFiles = useCallback(async (files) => {
+        setIsUploading(true);
+        setProgress({});
+        setErrors({});
+        setResults({});
+        const uploadPromises = files.map(async (file) => {
+            try {
+                // Validate file size
+                if (file.size > maxSize) {
+                    throw new Error(`File "${file.name}" too large (max ${(maxSize / 1024 / 1024).toFixed(1)}MB)`);
+                }
+                // Validate file type
+                if (acceptedTypes && !validateFileType(file, acceptedTypes)) {
+                    throw new Error(`File "${file.name}" type not accepted`);
+                }
+                setProgress((prev) => ({ ...prev, [file.name]: 0 }));
+                // Convert to base64
+                const base64Content = await fileToBase64(file);
+                setProgress((prev) => ({ ...prev, [file.name]: 50 }));
+                // Upload to server
+                const res = await fetch('/api/files', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        filename: file.name,
+                        mimeType: file.type,
+                        content: base64Content,
+                    }),
+                });
+                if (!res.ok) {
+                    throw new Error(`Failed to upload "${file.name}"`);
+                }
+                const result = await res.json();
+                setProgress((prev) => ({ ...prev, [file.name]: 100 }));
+                setResults((prev) => ({ ...prev, [file.name]: result }));
+                return result;
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                setErrors((prev) => ({ ...prev, [file.name]: error }));
+                throw error;
+            }
+        });
+        try {
+            const allResults = await Promise.all(uploadPromises);
+            return allResults;
+        }
+        finally {
+            setIsUploading(false);
+        }
+    }, [maxSize, acceptedTypes]);
+    const reset = useCallback(() => {
+        setIsUploading(false);
+        setProgress({});
+        setErrors({});
+        setResults({});
+    }, []);
+    return {
+        isUploading,
+        progress,
+        errors,
+        results,
+        uploadFiles,
+        reset,
+    };
+}

package/dist/client/hooks/useSystemTheme.d.ts

@@ -0,0 +1,2 @@
+export declare const useSystemTheme: () => "light" | "dark";
+//# sourceMappingURL=useSystemTheme.d.ts.map

package/dist/client/hooks/useSystemTheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSystemTheme.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useSystemTheme.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,wBAqB1B,CAAA"}