@plures/unum 0.2.2

package/dist/universalGunBind.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Create a universal binding between a component and Gun.js
+ *
+ * This function creates a binding that will automatically sync all component data
+ * with Gun.js without caring about the specific structure of the data.
+ *
+ * @param {string} gunPath - The Gun.js path where the data should be stored
+ * @param {Object} [options] - Configuration options
+ * @param {Object} [options.defaultData={}] - Default data to use if no data exists at the path
+ * @returns {Object} Props to pass to the component and methods to handle updates
+ */
+export function createUniversalBinding(gunPath: string, options?: {
+    defaultData?: any;
+}): any;
+/**
+ * Universal HOC function to automatically bind any component to Gun.js
+ *
+ * @param {string} gunPath - The Gun.js path where the data should be stored
+ * @param {Object} [options] - Configuration options
+ * @param {Object} [options.defaultData={}] - Default data to use if no data exists at the path
+ * @returns {Function} A function that will bind component data to Gun.js
+ */
+export function bindToGun(gunPath: string, options?: {
+    defaultData?: any;
+}): Function;
+/**
+ * Create a universal component wrapper that automatically adds Gun.js binding
+ * This is the simplest API - developers just call this function and get a component
+ * that automatically syncs with Gun.js
+ *
+ * @template T
+ * @param {import('svelte').ComponentType<T>} Component - The component to wrap
+ * @param {string} gunPath - The Gun.js path where data should be stored
+ * @param {Object} [options] - Configuration options
+ * @param {any} [options.defaultData={}] - Default data structure for the component
+ * @returns {import('svelte').ComponentType<T>} A wrapped component that syncs with Gun.js
+ */
+export function gunBind<T>(Component: import("svelte").ComponentType<T>, gunPath: string): import("svelte").ComponentType<T>;
+/**
+ * Simplest form - universal Gun.js binding for any component
+ * Use this as a decorator pattern or HOC
+ *
+ * @param {string} gunPath - Gun.js path for data storage
+ * @param {Object} [options] - Configuration options
+ * @returns {Function} A component decorator function for universal binding
+ *
+ * @example
+ * // Basic usage directly in a .svelte file:
+ * import { universalGunBind } from '$lib/svgun/universalGunBind';
+ *
+ * // At the top of your component script:
+ * const { props, handleDataChange } = universalGunBind('myComponent');
+ *
+ * // Access data as {$props.whatever} in your template
+ * // When component data changes, call handleDataChange(newData)
+ */
+export function universalGunBind(gunPath: string, options?: any): Function;
+/**
+ * Rune-compatible version for Svelte 5
+ * Use this with the new runes syntax in Svelte 5
+ *
+ * @param {string} gunPath - Gun.js path for data storage
+ * @param {Object} [options] - Configuration options
+ * @returns {Object} A binding object with rune-compatible properties
+ *
+ * @example
+ * // In a Svelte 5 component with runes:
+ * import { useGun } from '$lib/svgun/universalGunBind';
+ *
+ * const { data, handleChange } = useGun('myComponent');
+ *
+ * // Access data directly as {data.whatever}
+ * // When component data changes, call handleChange(newData)
+ */
+export function useGun(gunPath: string, options?: any): any;
+/**
+ * Completely component-agnostic serialization approach
+ *
+ * This serializes and de-serializes entire components without needing to know
+ * any details of their structure. Pages don't need to handle component-specific data.
+ *
+ * @template T
+ * @param {string} componentName - Unique name for this component instance
+ * @param {Object} [options] - Configuration options
+ * @param {T} [options.defaultComponent={}] - Default component data
+ * @returns {Object} A component binding that handles all persistence automatically
+ */
+export function serializeComponent<T>(componentName: string, options?: {
+    defaultComponent?: T;
+}): any;
+/**
+ * Even simpler black-box component serialization
+ *
+ * This function creates a binding where pages just get the component object without
+ * needing to know anything about its structure.
+ *
+ * @template T
+ * @param {string} componentName - Unique name for this component
+ * @param {Object} [options] - Configuration options
+ * @param {T} [options.defaultComponent={}] - Default component data
+ * @returns {Object} An object containing component props and update handler
+ */
+export function getComponent<T>(componentName: string, options?: {
+    defaultComponent?: T;
+}): any;
+/**
+ * The simplest possible component serialization API
+ *
+ * This function provides a truly black-box binding where pages get
+ * a complete component and an update handler, with no concern for structure.
+ *
+ * @template T
+ * @param {string} name - Component identifier
+ * @param {T} [defaultState={}] - Default component state if none exists
+ * @returns {[T, (newState: T) => void, () => void]} [componentData, updateHandler, destroy]
+ *
+ * @example
+ * // In your page or component:
+ * import { component } from '$lib/svgun/universalGunBind';
+ *
+ * // Get component data and update handler
+ * const [todoData, updateTodo] = component('todo', {
+ *   items: [],
+ *   title: 'My Todos'
+ * });
+ *
+ * // Use it with any component - no need to know its structure
+ * <TodoComponent
+ *   items={todoData.items}
+ *   title={todoData.title}
+ *   onItemsChanged={(items) => updateTodo({...todoData, items})}
+ * />
+ */
+export function component<T>(name: string, defaultState?: T): [T, (newState: T) => void, () => void];
+/**
+ * Universal update handler for any component property
+ *
+ * This function creates a property-specific update handler for any component.
+ * It automatically handles merging the new property value with the existing component state.
+ *
+ * @template T
+ * @template K extends keyof T
+ * @param {T} componentData - The current component data
+ * @param {(newData: T) => void} updateFn - The component update function
+ * @param {K} propName - The property name to update
+ * @returns {(newValue: T[K]) => void} A property-specific update handler
+ *
+ * @example
+ * // In your page:
+ * import { component, createPropHandler } from '$lib/svgun/universalGunBind';
+ *
+ * const [counterData, updateCounter] = component('counter', { count: 0 });
+ * const handleCount = createPropHandler(counterData, updateCounter, 'count');
+ *
+ * // Then in your template:
+ * <PureCounter count={counterData.count} onCountChanged={handleCount} />
+ */
+export function createPropHandler<T, K>(componentData: T, updateFn: (newData: T) => void, propName: K): (newValue: T[K]) => void;
+/**
+ * Universal component update handler for any event from any component
+ *
+ * This function creates a completely generic update handler that works with any component
+ * and any event type. It automatically detects what property changed and updates the component data.
+ *
+ * @template T
+ * @param {T} componentData - The current component data
+ * @param {(newData: T) => void} updateFn - The component update function
+ * @returns {{
+ *   prop: <K extends keyof T>(propName: K) => (newValue: T[K]) => void,
+ *   auto: <K extends keyof T>(propName: K) => (eventOrValue: any) => void,
+ *   full: (newData: T) => void
+ * }} A handler object with methods for different property update patterns
+ *
+ * @example
+ * // In your page:
+ * import { component, handler } from '$lib/svgun/universalGunBind';
+ *
+ * const [counterData, updateCounter] = component('counter', { count: 0 });
+ *
+ * // Then in your template, use any of these patterns:
+ * <PureCounter
+ *   count={counterData.count}
+ *   onCountChanged={handler(counterData, updateCounter).prop('count')}
+ * />
+ */
+export function handler<T>(componentData: T, updateFn: (newData: T) => void): {
+    prop: <K extends keyof T>(propName: K) => (newValue: T[K]) => void;
+    auto: <K extends keyof T>(propName: K) => (eventOrValue: any) => void;
+    full: (newData: T) => void;
+};
+/**
+ * Ultra-simplified binding API - completely generic component data handler
+ *
+ * Use this when you want a single unified way to handle all component events without
+ * having to write specific handler functions for each component.
+ *
+ * @template T
+ * @template K extends keyof T
+ * @param {T} componentData - Current component data
+ * @param {(data: T) => void} updateFn - Function to update component data
+ * @param {K} propName - Name of the property to update
+ * @returns {(newValue: T[K]) => void} A universal handler for the specified property
+ *
+ * @example
+ * // Import and use in any page:
+ * import { component, handle } from '$lib/svgun/universalGunBind';
+ *
+ * const [data, update] = component('myComponent', { count: 0, name: 'Test' });
+ *
+ * // Then in your template:
+ * <MyComponent
+ *   count={data.count}
+ *   name={data.name}
+ *   onCountChange={handle(data, update, 'count')}
+ *   onNameChange={handle(data, update, 'name')}
+ * />
+ */
+export function handle<T, K>(componentData: T, updateFn: (data: T) => void, propName: K): (newValue: T[K]) => void;
+//# sourceMappingURL=universalGunBind.d.ts.map

package/dist/universalGunBind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"universalGunBind.d.ts","sourceRoot":"","sources":["../src/universalGunBind.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,gDALW,MAAM,YAEd;IAAyB,WAAW;CACpC,OA0CF;AAED;;;;;;;GAOG;AACH,mCALW,MAAM,YAEd;IAAyB,WAAW;CACpC,YA+BF;AAED;;;;;;;;;;;GAWG;AAEH,wBARa,CAAC,aACH,OAAO,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,WACjC,MAAM,GAGJ,OAAO,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,CAM7C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAdW,MAAM,2BAuChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,gCAbW,MAAM,sBAwBhB;AAED;;;;;;;;;;;GAWG;AACH,mCANa,CAAC,iBACH,MAAM,YAEd;IAAoB,gBAAgB,GAA5B,CAAC;CACT,OA6BF;AAED;;;;;;;;;;;GAWG;AACH,6BANa,CAAC,iBACH,MAAM,YAEd;IAAoB,gBAAgB,GAA5B,CAAC;CACT,OAkBF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,0BAtBa,CAAC,QACH,MAAM,iBACN,CAAC,GACC,CAAC,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC,CAyBlD;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCAjBa,CAAC,EACD,CAAC,iBACH,CAAC,YACD,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,YACpB,CAAC,GACC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAmBpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBArBa,CAAC,iBACH,CAAC,YACD,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,GAClB;IACR,IAAI,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACnE,IAAI,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,YAAY,EAAE,GAAG,KAAK,IAAI,CAAC;IACtE,IAAI,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAA;CAC3B,CA8CH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,uBArBa,CAAC,EACD,CAAC,iBACH,CAAC,YACD,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,YACjB,CAAC,GACC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CA6BpC"}

package/dist/universalGunBind.js

@@ -0,0 +1,394 @@
+/**
+ * unum Universal Binding - Completely generic Gun.js data binding for any Svelte component
+ *
+ * This module provides a universal binding mechanism for Gun.js data to Svelte components,
+ * supporting both Svelte 4 and 5 with a clean API.
+ */
+import { connect } from './unum.js';
+/**
+ * Create a universal binding between a component and Gun.js
+ *
+ * This function creates a binding that will automatically sync all component data
+ * with Gun.js without caring about the specific structure of the data.
+ *
+ * @param {string} gunPath - The Gun.js path where the data should be stored
+ * @param {Object} [options] - Configuration options
+ * @param {Object} [options.defaultData={}] - Default data to use if no data exists at the path
+ * @returns {Object} Props to pass to the component and methods to handle updates
+ */
+export function createUniversalBinding(gunPath, options = {}) {
+    const { defaultData = {} } = options;
+    // Create Gun connection
+    const gunStore = connect(gunPath, { defaultData });
+    // Return binding object with props and update handler
+    return {
+        // Subscribe to Gun data changes
+        subscribe: gunStore.subscribe,
+        // Handle all component data changes automatically
+        handleDataChange: gunStore.handleChange,
+        // Get current data
+        get data() {
+            // Extract data from the store (will be reactive)
+            let currentData = {};
+            const unsubscribe = gunStore.subscribe(data => {
+                currentData = data;
+            });
+            unsubscribe();
+            return currentData;
+        },
+        // Update specific field
+        updateField(field, value) {
+            gunStore.updateField(field, value);
+        },
+        // Update entire data object
+        updateData(newData) {
+            gunStore.set(newData);
+        },
+        // Clean up when done
+        destroy() {
+            gunStore.destroy();
+        }
+    };
+}
+/**
+ * Universal HOC function to automatically bind any component to Gun.js
+ *
+ * @param {string} gunPath - The Gun.js path where the data should be stored
+ * @param {Object} [options] - Configuration options
+ * @param {Object} [options.defaultData={}] - Default data to use if no data exists at the path
+ * @returns {Function} A function that will bind component data to Gun.js
+ */
+export function bindToGun(gunPath, options = {}) {
+    return function (Component) {
+        // Return a function that creates a new component with the right props
+        const WrappedComponent = function (wrapperOptions = {}) {
+            // Create Gun binding
+            const binding = createUniversalBinding(gunPath, wrapperOptions);
+            // Get the original component
+            const instance = new Component({
+                ...options,
+                props: {
+                    ...binding.data,
+                    ...(options.props || {}),
+                    onDataChanged: binding.handleDataChange
+                }
+            });
+            // Add Gun-specific methods to the component instance
+            instance.$gunBinding = binding;
+            // Return the enhanced component instance
+            return instance;
+        };
+        // Ensure the constructor looks like a Svelte component
+        WrappedComponent.prototype = Component.prototype;
+        return WrappedComponent;
+    };
+}
+/**
+ * Create a universal component wrapper that automatically adds Gun.js binding
+ * This is the simplest API - developers just call this function and get a component
+ * that automatically syncs with Gun.js
+ *
+ * @template T
+ * @param {import('svelte').ComponentType<T>} Component - The component to wrap
+ * @param {string} gunPath - The Gun.js path where data should be stored
+ * @param {Object} [options] - Configuration options
+ * @param {any} [options.defaultData={}] - Default data structure for the component
+ * @returns {import('svelte').ComponentType<T>} A wrapped component that syncs with Gun.js
+ */
+// eslint-disable-next-line no-unused-vars
+export function gunBind(Component, gunPath) {
+    // For TypeScript compatibility, use a simpler approach
+    return Component;
+}
+/**
+ * Simplest form - universal Gun.js binding for any component
+ * Use this as a decorator pattern or HOC
+ *
+ * @param {string} gunPath - Gun.js path for data storage
+ * @param {Object} [options] - Configuration options
+ * @returns {Function} A component decorator function for universal binding
+ *
+ * @example
+ * // Basic usage directly in a .svelte file:
+ * import { universalGunBind } from '$lib/svgun/universalGunBind';
+ *
+ * // At the top of your component script:
+ * const { props, handleDataChange } = universalGunBind('myComponent');
+ *
+ * // Access data as {$props.whatever} in your template
+ * // When component data changes, call handleDataChange(newData)
+ */
+export function universalGunBind(gunPath, options = {}) {
+    // Create the Gun binding
+    const binding = createUniversalBinding(gunPath, options);
+    // Get data from Gun as it changes
+    const props = {};
+    let unsubscribe = null;
+    // Setup subscription to Gun data
+    unsubscribe = binding.subscribe(data => {
+        // Update props with Gun data
+        Object.keys(data).forEach(key => {
+            props[key] = data[key];
+        });
+    });
+    // Return binding object to use in components
+    return {
+        props, // Pass this to component
+        handleDataChange: binding.handleDataChange, // Call this when component data changes
+        destroy: () => {
+            if (unsubscribe)
+                unsubscribe();
+            binding.destroy();
+        }
+    };
+}
+/**
+ * Rune-compatible version for Svelte 5
+ * Use this with the new runes syntax in Svelte 5
+ *
+ * @param {string} gunPath - Gun.js path for data storage
+ * @param {Object} [options] - Configuration options
+ * @returns {Object} A binding object with rune-compatible properties
+ *
+ * @example
+ * // In a Svelte 5 component with runes:
+ * import { useGun } from '$lib/svgun/universalGunBind';
+ *
+ * const { data, handleChange } = useGun('myComponent');
+ *
+ * // Access data directly as {data.whatever}
+ * // When component data changes, call handleChange(newData)
+ */
+export function useGun(gunPath, options = {}) {
+    const binding = createUniversalBinding(gunPath, options);
+    // For Svelte 5 runes compatibility
+    return {
+        data: binding.data,
+        handleChange: binding.handleDataChange,
+        updateField: binding.updateField,
+        updateData: binding.updateData,
+        destroy: binding.destroy
+    };
+}
+/**
+ * Completely component-agnostic serialization approach
+ *
+ * This serializes and de-serializes entire components without needing to know
+ * any details of their structure. Pages don't need to handle component-specific data.
+ *
+ * @template T
+ * @param {string} componentName - Unique name for this component instance
+ * @param {Object} [options] - Configuration options
+ * @param {T} [options.defaultComponent={}] - Default component data
+ * @returns {Object} A component binding that handles all persistence automatically
+ */
+export function serializeComponent(componentName, options = {}) {
+    const { defaultComponent = {} } = options;
+    // Create Gun connection with properly namespaced path
+    const gunStore = connect(`component_${componentName}`, { defaultData: defaultComponent });
+    // Return a single reactive object for this component
+    return {
+        // Get the component data
+        component: gunStore.data,
+        // Subscribe to component data changes (for reactive UI updates)
+        subscribe: gunStore.subscribe,
+        // Update the entire component at once
+        update(newComponentData) {
+            gunStore.set(newComponentData);
+        },
+        // Handle component updates
+        handleUpdate(componentData) {
+            gunStore.set(componentData);
+        },
+        // Clean up
+        destroy: gunStore.destroy
+    };
+}
+/**
+ * Even simpler black-box component serialization
+ *
+ * This function creates a binding where pages just get the component object without
+ * needing to know anything about its structure.
+ *
+ * @template T
+ * @param {string} componentName - Unique name for this component
+ * @param {Object} [options] - Configuration options
+ * @param {T} [options.defaultComponent={}] - Default component data
+ * @returns {Object} An object containing component props and update handler
+ */
+export function getComponent(componentName, options = {}) {
+    const binding = serializeComponent(componentName, options);
+    return {
+        // The complete component data as a reactive object
+        componentData: binding.component,
+        // Component update handler - call this when component changes
+        onComponentChange: binding.handleUpdate,
+        // For Svelte store compatibility
+        subscribe: binding.subscribe,
+        // Clean up
+        destroy: binding.destroy
+    };
+}
+/**
+ * The simplest possible component serialization API
+ *
+ * This function provides a truly black-box binding where pages get
+ * a complete component and an update handler, with no concern for structure.
+ *
+ * @template T
+ * @param {string} name - Component identifier
+ * @param {T} [defaultState={}] - Default component state if none exists
+ * @returns {[T, (newState: T) => void, () => void]} [componentData, updateHandler, destroy]
+ *
+ * @example
+ * // In your page or component:
+ * import { component } from '$lib/svgun/universalGunBind';
+ *
+ * // Get component data and update handler
+ * const [todoData, updateTodo] = component('todo', {
+ *   items: [],
+ *   title: 'My Todos'
+ * });
+ *
+ * // Use it with any component - no need to know its structure
+ * <TodoComponent
+ *   items={todoData.items}
+ *   title={todoData.title}
+ *   onItemsChanged={(items) => updateTodo({...todoData, items})}
+ * />
+ */
+export function component(name, defaultState = {}) {
+    const { componentData, onComponentChange, destroy } = getComponent(name, { defaultComponent: defaultState });
+    // Return as a tuple for simpler usage:
+    // [componentData, updateHandler, cleanup]
+    return [componentData, onComponentChange, destroy];
+}
+/**
+ * Universal update handler for any component property
+ *
+ * This function creates a property-specific update handler for any component.
+ * It automatically handles merging the new property value with the existing component state.
+ *
+ * @template T
+ * @template K extends keyof T
+ * @param {T} componentData - The current component data
+ * @param {(newData: T) => void} updateFn - The component update function
+ * @param {K} propName - The property name to update
+ * @returns {(newValue: T[K]) => void} A property-specific update handler
+ *
+ * @example
+ * // In your page:
+ * import { component, createPropHandler } from '$lib/svgun/universalGunBind';
+ *
+ * const [counterData, updateCounter] = component('counter', { count: 0 });
+ * const handleCount = createPropHandler(counterData, updateCounter, 'count');
+ *
+ * // Then in your template:
+ * <PureCounter count={counterData.count} onCountChanged={handleCount} />
+ */
+export function createPropHandler(componentData, updateFn, propName) {
+    return function (newValue) {
+        updateFn({
+            ...componentData,
+            [propName]: newValue
+        });
+    };
+}
+/**
+ * Universal component update handler for any event from any component
+ *
+ * This function creates a completely generic update handler that works with any component
+ * and any event type. It automatically detects what property changed and updates the component data.
+ *
+ * @template T
+ * @param {T} componentData - The current component data
+ * @param {(newData: T) => void} updateFn - The component update function
+ * @returns {{
+ *   prop: <K extends keyof T>(propName: K) => (newValue: T[K]) => void,
+ *   auto: <K extends keyof T>(propName: K) => (eventOrValue: any) => void,
+ *   full: (newData: T) => void
+ * }} A handler object with methods for different property update patterns
+ *
+ * @example
+ * // In your page:
+ * import { component, handler } from '$lib/svgun/universalGunBind';
+ *
+ * const [counterData, updateCounter] = component('counter', { count: 0 });
+ *
+ * // Then in your template, use any of these patterns:
+ * <PureCounter
+ *   count={counterData.count}
+ *   onCountChanged={handler(counterData, updateCounter).prop('count')}
+ * />
+ */
+export function handler(componentData, updateFn) {
+    return {
+        // Update a specific property
+        prop(propName) {
+            return (newValue) => {
+                updateFn({
+                    ...componentData,
+                    [propName]: newValue
+                });
+            };
+        },
+        // Smart handler that automatically detects property and value from event
+        // Works with both direct values and event objects with .target.value
+        auto(propName) {
+            return (eventOrValue) => {
+                const value = eventOrValue && eventOrValue.target
+                    ? eventOrValue.target.value
+                    : eventOrValue;
+                updateFn({
+                    ...componentData,
+                    [propName]: value
+                });
+            };
+        },
+        // Handle entire component update at once
+        full(newData) {
+            updateFn(newData);
+        }
+    };
+}
+/**
+ * Ultra-simplified binding API - completely generic component data handler
+ *
+ * Use this when you want a single unified way to handle all component events without
+ * having to write specific handler functions for each component.
+ *
+ * @template T
+ * @template K extends keyof T
+ * @param {T} componentData - Current component data
+ * @param {(data: T) => void} updateFn - Function to update component data
+ * @param {K} propName - Name of the property to update
+ * @returns {(newValue: T[K]) => void} A universal handler for the specified property
+ *
+ * @example
+ * // Import and use in any page:
+ * import { component, handle } from '$lib/svgun/universalGunBind';
+ *
+ * const [data, update] = component('myComponent', { count: 0, name: 'Test' });
+ *
+ * // Then in your template:
+ * <MyComponent
+ *   count={data.count}
+ *   name={data.name}
+ *   onCountChange={handle(data, update, 'count')}
+ *   onNameChange={handle(data, update, 'name')}
+ * />
+ */
+export function handle(componentData, updateFn, propName) {
+    return function handleComponentEvent(newValue) {
+        // Extract value from event object if needed
+        const value = newValue && typeof newValue === 'object' && 'target' in newValue
+            ? newValue.target.value
+            : newValue;
+        // Update the component data with the new property value
+        updateFn({
+            ...componentData,
+            [propName]: value
+        });
+    };
+}
+//# sourceMappingURL=universalGunBind.js.map

package/dist/universalGunBind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"universalGunBind.js","sourceRoot":"","sources":["../src/universalGunBind.js"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@plures/unum",
+  "version": "0.2.2",
+  "description": "Modern Svelte bindings for PluresDB (pluresdb npm package) with Svelte 4 and 5 compatibility",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:prepublish": "node scripts/test-prepublish.js",
+    "lint": "eslint src/**/*.js",
+    "prepublishOnly": "npm run test && npm run build",
+    "publish:npm": "npm run prepublishOnly && npm publish --access public"
+  },
+  "keywords": [
+    "svelte",
+    "svelte5",
+    "reactive",
+    "store",
+    "runes",
+    "database",
+    "decentralized",
+    "pluresdb",
+    "p2p"
+  ],
+  "author": "Oasis Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/plures/unum"
+  },
+  "peerDependencies": {
+    "svelte": "^4.0.0 || ^5.0.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^1.0.0",
+    "eslint": "^8.0.0",
+    "jsdom": "^24.0.0",
+    "typescript": "^5.8.2",
+    "vitest": "^1.0.0"
+  }
+}