@plures/unum 0.2.2 → 0.3.0

package/dist/runes.d.ts

@@ -1,184 +1,40 @@
 /**
- * Creates a reactive connection to a PluresDB path
- * This is the primary API for Svelte 5 components to use PluresDB data
+ * pluresData() — reactive data bindings for Svelte.
  *
- * @example
- * ```svelte
- * <script>
- *   import { pluresData } from 'unum';
- *
- *   // Create a reactive connection to PluresDB data
- *   const todos = pluresData('todos');
- *
- *   // Access a specific todo by ID
- *   const todo = pluresData('todos', 'specific-id');
- *
- *   // Create a new todo
- *   function addTodo(text) {
- *     todos.add({ text, completed: false });
- *   }
- *
- *   // Toggle a todo's completed status
- *   function toggleTodo(id) {
- *     todo.update(id, current => ({ ...current, completed: !current.completed }));
- *   }
- *
- *   // Delete a todo
- *   function deleteTodo(id) {
- *     todos.remove(id);
- *   }
- * </script>
- *
- * <!-- Use the data directly in the template -->
- * <ul>
- *   {#each todos.list() as item}
- *     <li>{item.text}</li>
- *   {/each}
- * </ul>
- * ```
+ * Works with Svelte 4 (stores) and Svelte 5 (subscribe protocol).
+ * No polling. Pure subscription-based reactivity.
  */
-export function pluresData(path: any, id?: any): {
-    readonly state: {};
-    readonly value: {};
-    list: () => any[];
-    add: (data: any) => void;
-    update: (itemId: any, updater: any) => void;
-    remove: (itemId?: any) => void;
-    subscribe: (callback: any) => () => void;
-    destroy: () => void;
-};
+import type { DataRef } from './types.js';
 /**
- * Creates a derived state from PluresDB data - allows transforming/filtering PluresDB data
+ * Create a reactive binding to a PluresDB path.
  *
- * @example
- * ```svelte
- * <script>
- *   import { pluresData, pluresDerived } from 'unum';
- *
- *   const todos = pluresData('todos');
- *   const completedTodos = pluresDerived(todos, items => items.filter(item => item.completed));
- * </script>
- *
- * <h2>Completed Todos</h2>
- * <ul>
- *   {#each completedTodos.value as item}
- *     <li>{item.text}</li>
- *   {/each}
- * </ul>
- * ```
- */
-export function pluresDerived(pluresData: any, transformer: any): {
-    readonly value: any[];
-    destroy(): void;
-};
-/**
- * Creates a two-way binding between a form input and PluresDB data
+ * @param path - Collection/document path (e.g. 'todos', 'users/profile')
+ * @param id   - Optional item ID for single-document binding
  *
  * @example
  * ```svelte
  * <script>
- *   import { pluresBind } from 'unum';
- *
- *   const userProfile = pluresData('userProfile');
- *   const nameBinding = pluresBind(userProfile, 'name');
- * </script>
- *
- * <input type="text" bind:value={nameBinding.value} />
- * ```
- */
-export function pluresBind(pluresData: any, field: any): {
-    value: any;
-    destroy(): void;
-};
-/**
- * Creates a reactive connection to a PluresDB path
- * This is the primary API for Svelte 5 components to use PluresDB data
- *
- * @example
- * ```svelte
- * <script>
- *   import { pluresData } from 'unum';
- *
- *   // Create a reactive connection to PluresDB data
+ *   import { pluresData } from '@plures/unum';
  *   const todos = pluresData('todos');
- *
- *   // Access a specific todo by ID
- *   const todo = pluresData('todos', 'specific-id');
- *
- *   // Create a new todo
- *   function addTodo(text) {
- *     todos.add({ text, completed: false });
- *   }
- *
- *   // Toggle a todo's completed status
- *   function toggleTodo(id) {
- *     todo.update(id, current => ({ ...current, completed: !current.completed }));
- *   }
- *
- *   // Delete a todo
- *   function deleteTodo(id) {
- *     todos.remove(id);
- *   }
  * </script>
  *
- * <!-- Use the data directly in the template -->
- * <ul>
- *   {#each todos.list() as item}
- *     <li>{item.text}</li>
- *   {/each}
- * </ul>
+ * {#each todos.list() as todo}
+ *   <p>{todo.text}</p>
+ * {/each}
  * ```
  */
-export function gunData(path: any, id?: any): {
-    readonly state: {};
-    readonly value: {};
-    list: () => any[];
-    add: (data: any) => void;
-    update: (itemId: any, updater: any) => void;
-    remove: (itemId?: any) => void;
-    subscribe: (callback: any) => () => void;
-    destroy: () => void;
-};
+export declare function pluresData<T extends Record<string, any> = Record<string, any>>(path: string, id?: string | null): DataRef<T>;
 /**
- * Creates a derived state from PluresDB data - allows transforming/filtering PluresDB data
- *
- * @example
- * ```svelte
- * <script>
- *   import { pluresData, pluresDerived } from 'unum';
- *
- *   const todos = pluresData('todos');
- *   const completedTodos = pluresDerived(todos, items => items.filter(item => item.completed));
- * </script>
- *
- * <h2>Completed Todos</h2>
- * <ul>
- *   {#each completedTodos.value as item}
- *     <li>{item.text}</li>
- *   {/each}
- * </ul>
- * ```
+ * Derived view — subscription-based, no polling.
  */
-export function gunDerived(pluresData: any, transformer: any): {
-    readonly value: any[];
+export declare function pluresDerived<T = any>(source: DataRef, transform: (items: any[]) => T[]): {
+    readonly value: T[];
     destroy(): void;
 };
 /**
- * Creates a two-way binding between a form input and PluresDB data
- *
- * @example
- * ```svelte
- * <script>
- *   import { pluresBind } from 'unum';
- *
- *   const userProfile = pluresData('userProfile');
- *   const nameBinding = pluresBind(userProfile, 'name');
- * </script>
- *
- * <input type="text" bind:value={nameBinding.value} />
- * ```
+ * Two-way binding helper for form inputs.
  */
-export function gunBind(pluresData: any, field: any): {
+export declare function pluresBind(source: DataRef, field: string): {
     value: any;
     destroy(): void;
 };

package/dist/runes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runes.d.ts","sourceRoot":"","sources":["../src/runes.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;;;;;;;;;EA+MC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;EAiCC;AAED;;;;;;;;;;;;;;GAcG;AACH;;;EA4BC;AA1VD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;;;;;;;;;EA+MC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;;;EAiCC;AAED;;;;;;;;;;;;;;GAcG;AACH;;;EA4BC"}
+{"version":3,"file":"runes.d.ts","sourceRoot":"","sources":["../src/runes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,OAAO,EAA6B,MAAM,YAAY,CAAC;AAErE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC5E,IAAI,EAAE,MAAM,EACZ,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,GACjB,OAAO,CAAC,CAAC,CAAC,CAqGZ;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,GAAG,EACnC,MAAM,EAAE,OAAO,EACf,SAAS,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAC/B;IAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,OAAO,IAAI,IAAI,CAAA;CAAE,CAS1C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM;WAOxC,GAAG;;EAMnB"}

package/dist/runes.js

@@ -1,327 +1,158 @@
 /**
- * unum - Svelte 5 Runes API for PluresDB
+ * pluresData() — reactive data bindings for Svelte.
  *
- * This module provides a seamless binding between PluresDB and Svelte 5 components
- * using the new Runes reactivity system. Components can work with PluresDB data without
- * knowing about PluresDB specifics.
+ * Works with Svelte 4 (stores) and Svelte 5 (subscribe protocol).
+ * No polling. Pure subscription-based reactivity.
  */
-import { gun as dbStore } from './GunContext.js';
+import { getRoot } from './context.js';
 /**
- * Creates a reactive connection to a PluresDB path
- * This is the primary API for Svelte 5 components to use PluresDB data
+ * Create a reactive binding to a PluresDB path.
+ *
+ * @param path - Collection/document path (e.g. 'todos', 'users/profile')
+ * @param id   - Optional item ID for single-document binding
  *
  * @example
  * ```svelte
  * <script>
- *   import { pluresData } from 'unum';
- *
- *   // Create a reactive connection to PluresDB data
+ *   import { pluresData } from '@plures/unum';
  *   const todos = pluresData('todos');
- *
- *   // Access a specific todo by ID
- *   const todo = pluresData('todos', 'specific-id');
- *
- *   // Create a new todo
- *   function addTodo(text) {
- *     todos.add({ text, completed: false });
- *   }
- *
- *   // Toggle a todo's completed status
- *   function toggleTodo(id) {
- *     todo.update(id, current => ({ ...current, completed: !current.completed }));
- *   }
- *
- *   // Delete a todo
- *   function deleteTodo(id) {
- *     todos.remove(id);
- *   }
  * </script>
  *
- * <!-- Use the data directly in the template -->
- * <ul>
- *   {#each todos.list() as item}
- *     <li>{item.text}</li>
- *   {/each}
- * </ul>
+ * {#each todos.list() as todo}
+ *   <p>{todo.text}</p>
+ * {/each}
  * ```
  */
-export function pluresData(path, id = null) {
-    // Using a plain object, not $state since this isn't a .svelte file
+export function pluresData(path, id) {
     let state = {};
-    let listeners = [];
-    let db = null; // Reference to PluresDB instance
-    let unsubscribe = null; // Store unsubscription function
-    // Notify all listeners when state changes
-    function notifyListeners() {
-        for (const listener of listeners) {
-            listener(state);
+    let subs = [];
+    const unsubs = [];
+    const root = getRoot();
+    const ref = root.get(path);
+    function notify() {
+        for (const cb of subs) {
+            try {
+                cb(state);
+            }
+            catch (e) {
+                console.error('[pluresData]', e);
+            }
         }
     }
-    // Create the subscription to PluresDB data
-    function initialize() {
-        // Unsubscribe from any existing subscription
-        if (unsubscribe) {
-            unsubscribe();
-            unsubscribe = null;
-        }
-        // Subscribe to PluresDB instance
-        const storeUnsubscribe = dbStore.subscribe(dbInstance => {
-            if (!dbInstance)
+    if (id) {
+        // Single item binding
+        const u = ref.get(id).on((data) => {
+            if (data) {
+                state = { ...data };
+                notify();
+            }
+        });
+        unsubs.push(u);
+    }
+    else {
+        // Collection binding
+        const u = ref.map().on((data, key) => {
+            if (!key || key === '_')
                 return;
-            // Store PluresDB instance reference
-            db = dbInstance;
-            // Create reference to the PluresDB path
-            let ref = db.get(path);
-            // If an ID is provided, narrow to that specific item
-            if (id) {
-                ref = ref.get(id);
-                // Set up subscription to a single item
-                const itemUnsubscribe = ref.on((data) => {
-                    if (data) {
-                        // Update state
-                        state = { ...(data || {}) };
-                        notifyListeners();
-                    }
-                });
-                // Update unsubscribe function
-                unsubscribe = () => {
-                    ref.off();
-                    itemUnsubscribe();
-                    storeUnsubscribe();
-                };
+            if (data === null || data === undefined) {
+                const next = { ...state };
+                delete next[key];
+                state = next;
             }
             else {
-                // Set up subscription to a collection
-                const mapUnsubscribe = ref.map().on((data, key) => {
-                    if (key === '_')
-                        return; // Skip internal PluresDB keys
-                    if (data === null) {
-                        // Item was deleted - create a new object to trigger updates
-                        const newState = { ...state };
-                        delete newState[key];
-                        state = newState;
-                        notifyListeners();
-                    }
-                    else {
-                        // Item was added or updated 
-                        state = {
-                            ...state,
-                            [key]: { ...(data || {}), id: key, text: data.text || '' }
-                        };
-                        notifyListeners();
-                    }
-                });
-                // Update unsubscribe function
-                unsubscribe = () => {
-                    ref.map().off();
-                    mapUnsubscribe();
-                    storeUnsubscribe();
-                };
+                state = { ...state, [key]: { ...data, id: key } };
             }
+            notify();
         });
+        unsubs.push(u);
     }
-    // Start the initialization
-    initialize();
-    // For collections, get an array of items suitable for #each loops
-    function list() {
-        if (id)
-            return []; // Not applicable for single items
-        return Object.values(state)
-            .filter(item => item && typeof item === 'object')
-            .map(item => ({ ...item, text: item.text || '' }));
-    }
-    // Add a new item to a collection
-    function add(data) {
-        if (!db || id)
-            return; // Can't add to a single item reference
-        const itemId = data.id || Date.now().toString();
-        const newItem = {
-            ...data,
-            text: data.text || '' // Ensure text is never undefined
-        };
-        // Add to PluresDB directly
-        db.get(path).get(itemId).put(newItem);
-        // Also update local state for immediate UI updates
-        state = {
-            ...state,
-            [itemId]: { ...newItem, id: itemId }
-        };
-        notifyListeners();
-    }
-    // Update an item (or the current item if this is a single item reference)
-    function update(itemId, updater) {
-        if (!db)
-            return;
-        if (id) {
-            // This is a single item reference
-            const updatedData = typeof updater === 'function'
-                ? updater(state)
-                : updater;
-            db.get(path).get(id).put(updatedData);
-            // Update local state immediately
-            state = { ...state, ...updatedData };
-            notifyListeners();
-        }
-        else {
-            // This is a collection
-            const item = state[itemId];
-            if (!item)
-                return;
-            const updatedData = typeof updater === 'function'
-                ? updater(item)
-                : updater;
-            db.get(path).get(itemId).put(updatedData);
-            // Update local state immediately
-            state = {
-                ...state,
-                [itemId]: { ...item, ...updatedData }
-            };
-            notifyListeners();
-        }
-    }
-    // Remove an item (or all items if this is a collection and no id is provided)
-    function remove(itemId = null) {
-        if (!db)
-            return;
-        if (id) {
-            // This is a single item reference - null it out
-            db.get(path).get(id).put(null);
-            state = {};
-            notifyListeners();
-        }
-        else if (itemId) {
-            // Remove a specific item from the collection
-            db.get(path).get(itemId).put(null);
-            // Update local state immediately
-            const newState = { ...state };
-            delete newState[itemId];
-            state = newState;
-            notifyListeners();
-        }
-    }
-    // Subscribe to changes - this is needed for Svelte components to react
-    function subscribe(callback) {
-        listeners.push(callback);
-        callback(state); // Initial call with current state
-        // Return unsubscribe function
-        return () => {
-            listeners = listeners.filter(l => l !== callback);
-        };
-    }
-    // Cleanup function
-    function destroy() {
-        if (unsubscribe) {
-            unsubscribe();
-            unsubscribe = null;
-        }
-        listeners = [];
-    }
-    // Return methods and data
-    return {
-        // Data access
+    const dataRef = {
         get state() { return state; },
-        get value() { return id ? state : list(); },
-        // Methods
-        list,
-        add,
-        update,
-        remove,
-        subscribe,
-        destroy
+        get value() { return id ? state : this.list(); },
+        list() {
+            return Object.values(state).filter((v) => v != null && typeof v === 'object');
+        },
+        add(data) {
+            if (id)
+                return;
+            const itemId = data.id ?? crypto.randomUUID().slice(0, 8);
+            const { id: _strip, ...rest } = data;
+            ref.get(itemId).put(rest);
+            state = { ...state, [itemId]: { ...rest, id: itemId } };
+            notify();
+        },
+        update(idOrUpdater, updater) {
+            if (id) {
+                const updated = typeof idOrUpdater === 'function' ? idOrUpdater(state) : idOrUpdater;
+                ref.get(id).put(updated);
+                state = { ...state, ...updated };
+                notify();
+            }
+            else if (typeof idOrUpdater === 'string' && updater != null) {
+                const item = state[idOrUpdater];
+                if (!item)
+                    return;
+                const updated = typeof updater === 'function' ? updater(item) : updater;
+                ref.get(idOrUpdater).put(updated);
+                state = { ...state, [idOrUpdater]: { ...item, ...updated } };
+                notify();
+            }
+        },
+        remove(itemId) {
+            if (id) {
+                ref.get(id).put(null);
+                state = {};
+            }
+            else if (itemId) {
+                ref.get(itemId).put(null);
+                const next = { ...state };
+                delete next[itemId];
+                state = next;
+            }
+            notify();
+        },
+        subscribe(cb) {
+            subs.push(cb);
+            cb(state);
+            return () => { subs = subs.filter(s => s !== cb); };
+        },
+        destroy() {
+            for (const u of unsubs)
+                u();
+            unsubs.length = 0;
+            subs = [];
+        },
     };
+    return dataRef;
 }
 /**
- * Creates a derived state from PluresDB data - allows transforming/filtering PluresDB data
- *
- * @example
- * ```svelte
- * <script>
- *   import { pluresData, pluresDerived } from 'unum';
- *
- *   const todos = pluresData('todos');
- *   const completedTodos = pluresDerived(todos, items => items.filter(item => item.completed));
- * </script>
- *
- * <h2>Completed Todos</h2>
- * <ul>
- *   {#each completedTodos.value as item}
- *     <li>{item.text}</li>
- *   {/each}
- * </ul>
- * ```
+ * Derived view — subscription-based, no polling.
  */
-export function pluresDerived(pluresData, transformer) {
-    let $state = []; // Derived state
-    // Create a computed value that updates when the source data changes
-    function compute() {
-        const sourceData = pluresData.list ? pluresData.list() : pluresData.value;
-        $state = transformer(sourceData);
-    }
-    // Initial computation
-    compute();
-    // Set up a watcher to recompute when source data changes
-    // This would be cleaner with Svelte 5's createEffect, but for now we'll use a workaround
-    let previousSourceData = JSON.stringify(pluresData.list ? pluresData.list() : pluresData.value);
-    // Check periodically for changes (not ideal, but works until Svelte 5 effects are stable)
-    const interval = setInterval(() => {
-        const currentSourceData = JSON.stringify(pluresData.list ? pluresData.list() : pluresData.value);
-        if (previousSourceData !== currentSourceData) {
-            previousSourceData = currentSourceData;
-            compute();
-        }
-    }, 100);
-    // Return reactive state and methods
+export function pluresDerived(source, transform) {
+    let derived = [];
+    const unsub = source.subscribe(() => {
+        derived = transform(source.list());
+    });
     return {
-        get value() { return $state; },
-        destroy() {
-            clearInterval(interval);
-            if (pluresData.destroy)
-                pluresData.destroy();
-        }
+        get value() { return derived; },
+        destroy() { unsub(); },
     };
 }
 /**
- * Creates a two-way binding between a form input and PluresDB data
- *
- * @example
- * ```svelte
- * <script>
- *   import { pluresBind } from 'unum';
- *
- *   const userProfile = pluresData('userProfile');
- *   const nameBinding = pluresBind(userProfile, 'name');
- * </script>
- *
- * <input type="text" bind:value={nameBinding.value} />
- * ```
+ * Two-way binding helper for form inputs.
  */
-export function pluresBind(pluresData, field) {
-    let $value = pluresData.state && pluresData.state[field] || '';
-    // Set up a watcher for changes to the PluresDB data
-    let previousData = JSON.stringify(pluresData.state);
-    const interval = setInterval(() => {
-        const currentData = JSON.stringify(pluresData.state);
-        if (previousData !== currentData) {
-            previousData = currentData;
-            $value = pluresData.state && pluresData.state[field] || '';
-        }
-    }, 100);
+export function pluresBind(source, field) {
+    let _value = source.state?.[field] ?? '';
+    const unsub = source.subscribe((state) => {
+        _value = state?.[field] ?? '';
+    });
     return {
-        get value() { return $value; },
-        set value(newValue) {
-            $value = newValue;
-            // Update the PluresDB data
-            if (pluresData.update) {
-                pluresData.update({ [field]: newValue });
-            }
+        get value() { return _value; },
+        set value(v) {
+            _value = v;
+            source.update({ [field]: v });
         },
-        destroy() {
-            clearInterval(interval);
-        }
+        destroy() { unsub(); },
     };
 }
-// Legacy exports for backward compatibility
-export const gunData = pluresData;
-export const gunDerived = pluresDerived;
-export const gunBind = pluresBind;
 //# sourceMappingURL=runes.js.map