@feltdb/core 0.4.3 → 0.4.5

package/dist/react/useFeltDB.d.ts

@@ -0,0 +1,136 @@
+/**
+ * useFeltDB - React hook for FeltDB integration
+ *
+ * This module provides React hooks for easily integrating FeltDB
+ * into React applications with automatic state management.
+ *
+ * Usage:
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList() {
+ *   const users = useFeltDB("users");
+ *
+ *   const addUser = (name, email) => {
+ *     users.insert(name, email);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {users.records.map(user => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import type { JsDb } from '@feltdb/wasm';
+import type { Collection } from '@feltdb/core';
+interface UseFeltDBOptions {
+    /** Auto-refresh interval in milliseconds (0 to disable) */
+    refreshInterval?: number;
+    /** Callback when data updates */
+    onUpdate?: (records: any[]) => void;
+    /** Callback when error occurs */
+    onError?: (error: string) => void;
+}
+interface UseFeltDBResult<T = any> {
+    /** Array of records from the database */
+    records: T[];
+    /** Whether data is loading */
+    loading: boolean;
+    /** Error message if any */
+    error: string | null;
+    /** Insert a new record */
+    insert: (key: string, data: Record<string, any>) => boolean;
+    /** Get a single record by key */
+    get: (key: string) => any | null;
+    /** Refresh data manually */
+    refresh: () => void;
+    /** Update a record */
+    update: (id: string | number, changes: Partial<T>) => Promise<void>;
+    /** Delete a record */
+    delete: (id: string | number) => Promise<void>;
+}
+/**
+ * React hook for FeltDB state-first collections
+ *
+ * This is a thin adapter that bridges React state management with FeltDB's
+ * unified state model. All applications (React, Vue, Svelte) use the same
+ * underlying Collection semantics.
+ *
+ * @param collection A FeltDB Collection (live application state)
+ * @param options Configuration options
+ * @returns UseFeltDBResult with records and helper methods
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from 'feltdb/useFeltDB';
+ *
+ * function UserList({ collection }) {
+ *   const { records, loading, error, insert, update } = useFeltDB(collection);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user) => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useFeltDB<T = any>(collection: Collection<T> | null, options?: UseFeltDBOptions): UseFeltDBResult<T>;
+/**
+ * Legacy compatibility: React hook for FeltDB capability queries
+ * Uses the low-level JsDb API for backward compatibility.
+ *
+ * New code should use useFeltDB with Collections instead.
+ */
+export declare function useLegacyFeltDB(db: JsDb | null, capability: string, options?: UseFeltDBOptions): UseFeltDBResult;
+/**
+ * Higher-order component for wrapping components with FeltDB
+ *
+ * @param Component React component that receives db and useFeltDB hook
+ * @param dbPath Path to the database file
+ * @returns Wrapped component
+ *
+ * @example
+ * ```jsx
+ * const UserListWithDb = withFeltDB(UserList, "app.db");
+ * ```
+ */
+export declare function withFeltDB<P extends object>(Component: React.ComponentType<P & {
+    db: JsDb;
+}>, dbPath: string): React.FC<P>;
+/**
+ * Example component using useFeltDB
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList({ db }) {
+ *   const { records, loading, error, insert } = useFeltDB(db, "users", {
+ *     refreshInterval: 5000, // Refresh every 5 seconds
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user: any) => (
+ *         <div key={user.id}>{user.name} ({user.email})</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export default useFeltDB;
+//# sourceMappingURL=useFeltDB.d.ts.map

package/dist/react/useFeltDB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFeltDB.d.ts","sourceRoot":"","sources":["../src/useFeltDB.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,UAAU,gBAAgB;IACxB,2DAA2D;IAC3D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;IACpC,iCAAiC;IACjC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,UAAU,eAAe,CAAC,CAAC,GAAG,GAAG;IAC/B,yCAAyC;IACzC,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,8BAA8B;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,0BAA0B;IAC1B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC;IAC5D,iCAAiC;IACjC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,GAAG,GAAG,IAAI,CAAC;IACjC,4BAA4B;IAC5B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,sBAAsB;IACtB,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,sBAAsB;IACtB,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAC/B,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,EAChC,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CAAC,CAAC,CAAC,CAiJpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,IAAI,GAAG,IAAI,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CA8GjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,EAChD,MAAM,EAAE,MAAM,GACb,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CA4Bb;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAe,SAAS,CAAC"}

package/dist/react/useFeltDB.js

@@ -0,0 +1,350 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+/**
+ * useFeltDB - React hook for FeltDB integration
+ *
+ * This module provides React hooks for easily integrating FeltDB
+ * into React applications with automatic state management.
+ *
+ * Usage:
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList() {
+ *   const users = useFeltDB("users");
+ *
+ *   const addUser = (name, email) => {
+ *     users.insert(name, email);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {users.records.map(user => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import { useState, useEffect, useCallback, useRef } from 'react';
+/**
+ * React hook for FeltDB state-first collections
+ *
+ * This is a thin adapter that bridges React state management with FeltDB's
+ * unified state model. All applications (React, Vue, Svelte) use the same
+ * underlying Collection semantics.
+ *
+ * @param collection A FeltDB Collection (live application state)
+ * @param options Configuration options
+ * @returns UseFeltDBResult with records and helper methods
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from 'feltdb/useFeltDB';
+ *
+ * function UserList({ collection }) {
+ *   const { records, loading, error, insert, update } = useFeltDB(collection);
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user) => (
+ *         <div key={user.id}>{user.name}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export function useFeltDB(collection, options = {}) {
+    const [records, setRecords] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const unsubscribeRef = useRef(null);
+    // Subscribe to collection updates
+    useEffect(() => {
+        if (!collection) {
+            setLoading(false);
+            return;
+        }
+        let isMounted = true;
+        const subscribe = async () => {
+            try {
+                setLoading(true);
+                // Initial load
+                const data = await collection.all();
+                if (isMounted) {
+                    setRecords(data);
+                    setError(null);
+                    options.onUpdate?.(data);
+                }
+                // Subscribe to live updates
+                const unsubscribe = collection.subscribe((updatedData) => {
+                    if (isMounted) {
+                        setRecords(updatedData);
+                        setError(null);
+                        options.onUpdate?.(updatedData);
+                    }
+                }, options.refreshInterval);
+                unsubscribeRef.current = unsubscribe;
+            }
+            catch (err) {
+                const errorMsg = err instanceof Error ? err.message : "Failed to load collection";
+                if (isMounted) {
+                    setError(errorMsg);
+                    options.onError?.(errorMsg);
+                }
+            }
+            finally {
+                if (isMounted) {
+                    setLoading(false);
+                }
+            }
+        };
+        subscribe();
+        // Cleanup
+        return () => {
+            isMounted = false;
+            if (unsubscribeRef.current) {
+                unsubscribeRef.current();
+            }
+        };
+    }, [collection, options]);
+    // Insert a new record
+    const insert = useCallback((key, data) => {
+        if (!collection) {
+            setError("Collection not initialized");
+            return false;
+        }
+        try {
+            const [, id] = key.split(':');
+            collection.insert(data, id);
+            return true;
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Insert failed";
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+            return false;
+        }
+    }, [collection, options]);
+    // Get a single record
+    const get = useCallback((key) => {
+        if (!collection) {
+            return null;
+        }
+        try {
+            const [, id] = key.split(':');
+            // This would need to be async in a real implementation
+            // For now, return null since we can't await in a sync callback
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }, [collection]);
+    // Update a record
+    const update = useCallback(async (id, changes) => {
+        if (!collection) {
+            throw new Error("Collection not initialized");
+        }
+        await collection.update(id, changes);
+    }, [collection]);
+    // Delete a record
+    const deleteRecord = useCallback(async (id) => {
+        if (!collection) {
+            throw new Error("Collection not initialized");
+        }
+        await collection.delete(id);
+    }, [collection]);
+    // Manual refresh
+    const refresh = useCallback(async () => {
+        if (!collection) {
+            return;
+        }
+        await collection.refresh();
+    }, [collection]);
+    return {
+        records,
+        loading,
+        error,
+        insert,
+        get,
+        refresh,
+        update,
+        delete: deleteRecord,
+    };
+}
+/**
+ * Legacy compatibility: React hook for FeltDB capability queries
+ * Uses the low-level JsDb API for backward compatibility.
+ *
+ * New code should use useFeltDB with Collections instead.
+ */
+export function useLegacyFeltDB(db, capability, options = {}) {
+    const [records, setRecords] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const refreshIntervalRef = useRef(null);
+    // Fetch records from database
+    const fetchRecords = useCallback(() => {
+        if (!db) {
+            setLoading(false);
+            return;
+        }
+        try {
+            setLoading(true);
+            const result = db.query(capability);
+            if (result.success && result.data) {
+                const parsedRecords = JSON.parse(result.data);
+                setRecords(parsedRecords);
+                setError(null);
+                options.onUpdate?.(parsedRecords);
+            }
+            else {
+                setError(result.error || "Unknown error");
+                options.onError?.(result.error || "Unknown error");
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Failed to fetch records";
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [db, capability, options]);
+    // Initial fetch
+    useEffect(() => {
+        fetchRecords();
+    }, [fetchRecords]);
+    // Setup auto-refresh interval
+    useEffect(() => {
+        if (options.refreshInterval && options.refreshInterval > 0) {
+            refreshIntervalRef.current = setInterval(fetchRecords, options.refreshInterval);
+            return () => {
+                if (refreshIntervalRef.current) {
+                    clearInterval(refreshIntervalRef.current);
+                }
+            };
+        }
+    }, [fetchRecords, options.refreshInterval]);
+    // Insert a new record
+    const insert = useCallback((key, data) => {
+        if (!db) {
+            setError("Database not initialized");
+            return false;
+        }
+        try {
+            const result = db.insert(key, JSON.stringify(data));
+            if (result.success) {
+                fetchRecords(); // Refresh after insert
+                return true;
+            }
+            else {
+                setError(result.error || "Insert failed");
+                options.onError?.(result.error || "Insert failed");
+                return false;
+            }
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : "Insert failed";
+            setError(errorMsg);
+            options.onError?.(errorMsg);
+            return false;
+        }
+    }, [db, fetchRecords, options]);
+    // Get a single record
+    const get = useCallback((key) => {
+        if (!db) {
+            return null;
+        }
+        try {
+            const result = db.get(key);
+            if (result.success && result.data) {
+                return JSON.parse(result.data);
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }, [db]);
+    return {
+        records,
+        loading,
+        error,
+        insert,
+        get,
+        refresh: fetchRecords,
+        update: async () => { },
+        delete: async () => { },
+    };
+}
+/**
+ * Higher-order component for wrapping components with FeltDB
+ *
+ * @param Component React component that receives db and useFeltDB hook
+ * @param dbPath Path to the database file
+ * @returns Wrapped component
+ *
+ * @example
+ * ```jsx
+ * const UserListWithDb = withFeltDB(UserList, "app.db");
+ * ```
+ */
+export function withFeltDB(Component, dbPath) {
+    return (props) => {
+        const [db, setDb] = useState(null);
+        const [dbError, setDbError] = useState(null);
+        useEffect(() => {
+            try {
+                // Dynamically import feltdb module (WASM module)
+                import('@feltdb/wasm').then((feltdb) => {
+                    setDb(feltdb.open(dbPath));
+                }).catch((err) => {
+                    setDbError(`Failed to load FeltDB: ${err.message}`);
+                });
+            }
+            catch (err) {
+                setDbError(err instanceof Error ? err.message : "Unknown error");
+            }
+        }, []);
+        if (dbError) {
+            return _jsxs("div", { className: "error", children: ["Database Error: ", dbError] });
+        }
+        if (!db) {
+            return _jsx("div", { className: "loading", children: "Loading database..." });
+        }
+        return _jsx(Component, { ...props, db: db });
+    };
+}
+/**
+ * Example component using useFeltDB
+ *
+ * @example
+ * ```jsx
+ * import { useFeltDB } from './hooks/useFeltDB';
+ *
+ * function UserList({ db }) {
+ *   const { records, loading, error, insert } = useFeltDB(db, "users", {
+ *     refreshInterval: 5000, // Refresh every 5 seconds
+ *   });
+ *
+ *   if (loading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {records.map((user: any) => (
+ *         <div key={user.id}>{user.name} ({user.email})</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export default useFeltDB;

package/dist/studio/.gitkeep

@@ -0,0 +1 @@
+# Public assets for FeltDB Studio