@nerdalytics/beacon 1000.2.0 → 1000.2.1

package/dist/src/index.d.ts

@@ -8,36 +8,12 @@ declare const STATE_ID: unique symbol;
 export type State<T> = ReadOnlyState<T> & WriteableState<T> & {
     [STATE_ID]?: symbol;
 };
-/**
- * Creates a reactive state container with the provided initial value.
- */
 export declare const state: <T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean) => State<T>;
-/**
- * Registers a function to run whenever its reactive dependencies change.
- */
 export declare const effect: (fn: () => void) => Unsubscribe;
-/**
- * Groups multiple state updates to trigger effects only once at the end.
- */
 export declare const batch: <T>(fn: () => T) => T;
-/**
- * Creates a read-only computed value that updates when its dependencies change.
- */
 export declare const derive: <T>(computeFn: () => T) => ReadOnlyState<T>;
-/**
- * Creates an efficient subscription to a subset of a state value.
- */
 export declare const select: <T, R>(source: ReadOnlyState<T>, selectorFn: (state: T) => R, equalityFn?: (a: R, b: R) => boolean) => ReadOnlyState<R>;
-/**
- * Creates a read-only view of a state, hiding mutation methods.
- */
 export declare const readonlyState: <T>(state: State<T>) => ReadOnlyState<T>;
-/**
- * Creates a state with access control, returning a tuple of reader and writer.
- */
 export declare const protectedState: <T>(initialValue: T, equalityFn?: (a: T, b: T) => boolean) => [ReadOnlyState<T>, WriteableState<T>];
-/**
- * Creates a lens for direct updates to nested properties of a state.
- */
 export declare const lens: <T, K>(source: State<T>, accessor: (state: T) => K) => State<K>;
 export {};

package/dist/src/index.js

@@ -1,32 +1,10 @@
-// Special symbol used for internal tracking
 const STATE_ID = Symbol();
-/**
- * Creates a reactive state container with the provided initial value.
- */
 export const state = (initialValue, equalityFn = Object.is) => StateImpl.createState(initialValue, equalityFn);
-/**
- * Registers a function to run whenever its reactive dependencies change.
- */
 export const effect = (fn) => StateImpl.createEffect(fn);
-/**
- * Groups multiple state updates to trigger effects only once at the end.
- */
 export const batch = (fn) => StateImpl.executeBatch(fn);
-/**
- * Creates a read-only computed value that updates when its dependencies change.
- */
 export const derive = (computeFn) => StateImpl.createDerive(computeFn);
-/**
- * Creates an efficient subscription to a subset of a state value.
- */
 export const select = (source, selectorFn, equalityFn = Object.is) => StateImpl.createSelect(source, selectorFn, equalityFn);
-/**
- * Creates a read-only view of a state, hiding mutation methods.
- */
 export const readonlyState = (state) => () => state();
-/**
- * Creates a state with access control, returning a tuple of reader and writer.
- */
 export const protectedState = (initialValue, equalityFn = Object.is) => {
     const fullState = state(initialValue, equalityFn);
     return [
@@ -37,26 +15,18 @@ export const protectedState = (initialValue, equalityFn = Object.is) => {
         },
     ];
 };
-/**
- * Creates a lens for direct updates to nested properties of a state.
- */
 export const lens = (source, accessor) => StateImpl.createLens(source, accessor);
 class StateImpl {
-    // Static fields track global reactivity state - this centralized approach allows
-    // for coordinated updates while maintaining individual state isolation
     static currentSubscriber = null;
     static pendingSubscribers = new Set();
     static isNotifying = false;
     static batchDepth = 0;
     static deferredEffectCreations = [];
     static activeSubscribers = new Set();
-    // WeakMaps enable automatic garbage collection when subscribers are no
-    // longer referenced, preventing memory leaks in long-running applications
     static stateTracking = new WeakMap();
     static subscriberDependencies = new WeakMap();
     static parentSubscriber = new WeakMap();
     static childSubscribers = new WeakMap();
-    // Instance state - each state has unique subscribers and ID
     value;
     subscribers = new Set();
     stateId = Symbol();
@@ -65,10 +35,6 @@ class StateImpl {
         this.value = initialValue;
         this.equalityFn = equalityFn;
     }
-    /**
-     * Creates a reactive state container with the provided initial value.
-     * Implementation of the public 'state' function.
-     */
     static createState = (initialValue, equalityFn = Object.is) => {
         const instance = new StateImpl(initialValue, equalityFn);
         const get = () => instance.get();
@@ -77,23 +43,16 @@ class StateImpl {
         get[STATE_ID] = instance.stateId;
         return get;
     };
-    // Auto-tracks dependencies when called within effects, creating a fine-grained
-    // reactivity graph that only updates affected components
     get = () => {
         const currentEffect = StateImpl.currentSubscriber;
         if (currentEffect) {
-            // Add this effect to subscribers for future notification
             this.subscribers.add(currentEffect);
-            // Maintain bidirectional dependency tracking to enable precise cleanup
-            // when effects are unsubscribed, preventing memory leaks
             let dependencies = StateImpl.subscriberDependencies.get(currentEffect);
             if (!dependencies) {
                 dependencies = new Set();
                 StateImpl.subscriberDependencies.set(currentEffect, dependencies);
             }
             dependencies.add(this.subscribers);
-            // Track read states to detect direct cyclical dependencies that
-            // could cause infinite loops
             let readStates = StateImpl.stateTracking.get(currentEffect);
             if (!readStates) {
                 readStates = new Set();
@@ -103,14 +62,10 @@ class StateImpl {
         }
         return this.value;
     };
-    // Handles value updates with built-in optimizations and safeguards
     set = (newValue) => {
-        // Skip updates for unchanged values to prevent redundant effect executions
         if (this.equalityFn(this.value, newValue)) {
             return;
         }
-        // Infinite loop detection prevents direct self-mutation within effects,
-        // while allowing nested effect patterns that would otherwise appear cyclical
         const effect = StateImpl.currentSubscriber;
         if (effect) {
             const states = StateImpl.stateTracking.get(effect);
@@ -119,16 +74,12 @@ class StateImpl {
             }
         }
         this.value = newValue;
-        // Skip updates when there are no subscribers, avoiding unnecessary processing
         if (this.subscribers.size === 0) {
             return;
         }
-        // Queue notifications instead of executing immediately to support batch operations
-        // and prevent redundant effect runs
         for (const sub of this.subscribers) {
             StateImpl.pendingSubscribers.add(sub);
         }
-        // Immediate execution outside of batches, deferred execution inside batches
         if (StateImpl.batchDepth === 0 && !StateImpl.isNotifying) {
             StateImpl.notifySubscribers();
         }
@@ -136,27 +87,17 @@ class StateImpl {
     update = (fn) => {
         this.set(fn(this.value));
     };
-    /**
-     * Registers a function to run whenever its reactive dependencies change.
-     * Implementation of the public 'effect' function.
-     */
     static createEffect = (fn) => {
         const runEffect = () => {
-            // Prevent re-entrance to avoid cascade updates during effect execution
             if (StateImpl.activeSubscribers.has(runEffect)) {
                 return;
             }
             StateImpl.activeSubscribers.add(runEffect);
             const parentEffect = StateImpl.currentSubscriber;
             try {
-                // Clean existing subscriptions before running to ensure only
-                // currently accessed states are tracked as dependencies
                 StateImpl.cleanupEffect(runEffect);
-                // Set current context for automatic dependency tracking
                 StateImpl.currentSubscriber = runEffect;
                 StateImpl.stateTracking.set(runEffect, new Set());
-                // Track parent-child relationships to handle nested effects correctly
-                // and enable hierarchical cleanup later
                 if (parentEffect) {
                     StateImpl.parentSubscriber.set(runEffect, parentEffect);
                     let children = StateImpl.childSubscribers.get(parentEffect);
@@ -166,22 +107,17 @@ class StateImpl {
                     }
                     children.add(runEffect);
                 }
-                // Execute the effect function, which will auto-track dependencies
                 fn();
             }
             finally {
-                // Restore previous context when done
                 StateImpl.currentSubscriber = parentEffect;
                 StateImpl.activeSubscribers.delete(runEffect);
             }
         };
-        // Run immediately unless we're in a batch operation
         if (StateImpl.batchDepth === 0) {
             runEffect();
         }
         else {
-            // Still track parent-child relationship even when deferred,
-            // ensuring proper hierarchical cleanup later
             if (StateImpl.currentSubscriber) {
                 const parent = StateImpl.currentSubscriber;
                 StateImpl.parentSubscriber.set(runEffect, parent);
@@ -192,17 +128,13 @@ class StateImpl {
                 }
                 children.add(runEffect);
             }
-            // Queue for execution when batch completes
             StateImpl.deferredEffectCreations.push(runEffect);
         }
-        // Return cleanup function to properly disconnect from reactivity graph
         return () => {
-            // Remove from dependency tracking to stop future notifications
             StateImpl.cleanupEffect(runEffect);
             StateImpl.pendingSubscribers.delete(runEffect);
             StateImpl.activeSubscribers.delete(runEffect);
             StateImpl.stateTracking.delete(runEffect);
-            // Clean up parent-child relationship bidirectionally
             const parent = StateImpl.parentSubscriber.get(runEffect);
             if (parent) {
                 const siblings = StateImpl.childSubscribers.get(parent);
@@ -211,8 +143,6 @@ class StateImpl {
                 }
             }
             StateImpl.parentSubscriber.delete(runEffect);
-            // Recursively clean up child effects to prevent memory leaks in
-            // nested effect scenarios
             const children = StateImpl.childSubscribers.get(runEffect);
             if (children) {
                 for (const child of children) {
@@ -223,19 +153,12 @@ class StateImpl {
             }
         };
     };
-    /**
-     * Groups multiple state updates to trigger effects only once at the end.
-     * Implementation of the public 'batch' function.
-     */
     static executeBatch = (fn) => {
-        // Increment depth counter to handle nested batches correctly
         StateImpl.batchDepth++;
         try {
             return fn();
         }
         catch (error) {
-            // Clean up on error to prevent stale subscribers from executing
-            // and potentially causing cascading errors
             if (StateImpl.batchDepth === 1) {
                 StateImpl.pendingSubscribers.clear();
                 StateImpl.deferredEffectCreations.length = 0;
@@ -244,10 +167,7 @@ class StateImpl {
         }
         finally {
             StateImpl.batchDepth--;
-            // Only process effects when exiting the outermost batch,
-            // maintaining proper execution order while avoiding redundant runs
             if (StateImpl.batchDepth === 0) {
-                // Process effects created during the batch
                 if (StateImpl.deferredEffectCreations.length > 0) {
                     const effectsToRun = [...StateImpl.deferredEffectCreations];
                     StateImpl.deferredEffectCreations.length = 0;
@@ -255,34 +175,24 @@ class StateImpl {
                         effect();
                     }
                 }
-                // Process state updates that occurred during the batch
                 if (StateImpl.pendingSubscribers.size > 0 && !StateImpl.isNotifying) {
                     StateImpl.notifySubscribers();
                 }
             }
         }
     };
-    /**
-     * Creates a read-only computed value that updates when its dependencies change.
-     * Implementation of the public 'derive' function.
-     */
     static createDerive = (computeFn) => {
         const valueState = StateImpl.createState(undefined);
         let initialized = false;
         let cachedValue;
-        // Internal effect automatically tracks dependencies and updates the derived value
         StateImpl.createEffect(() => {
             const newValue = computeFn();
-            // Only update if the value actually changed to preserve referential equality
-            // and prevent unnecessary downstream updates
             if (!(initialized && Object.is(cachedValue, newValue))) {
                 cachedValue = newValue;
                 valueState.set(newValue);
             }
             initialized = true;
         });
-        // Return function with lazy initialization - ensures value is available
-        // even when accessed before its dependencies have had a chance to update
         return () => {
             if (!initialized) {
                 cachedValue = computeFn();
@@ -292,35 +202,25 @@ class StateImpl {
             return valueState();
         };
     };
-    /**
-     * Creates an efficient subscription to a subset of a state value.
-     * Implementation of the public 'select' function.
-     */
     static createSelect = (source, selectorFn, equalityFn = Object.is) => {
         let lastSourceValue;
         let lastSelectedValue;
         let initialized = false;
         const valueState = StateImpl.createState(undefined);
-        // Internal effect to track the source and update only when needed
         StateImpl.createEffect(() => {
             const sourceValue = source();
-            // Skip computation if source reference hasn't changed
             if (initialized && Object.is(lastSourceValue, sourceValue)) {
                 return;
             }
             lastSourceValue = sourceValue;
             const newSelectedValue = selectorFn(sourceValue);
-            // Use custom equality function to determine if value semantically changed,
-            // allowing for deep equality comparisons with complex objects
             if (initialized && lastSelectedValue !== undefined && equalityFn(lastSelectedValue, newSelectedValue)) {
                 return;
             }
-            // Update cache and notify subscribers due the value has changed
             lastSelectedValue = newSelectedValue;
             valueState.set(newSelectedValue);
             initialized = true;
         });
-        // Return function with eager initialization capability
         return () => {
             if (!initialized) {
                 lastSourceValue = source();
@@ -331,12 +231,7 @@ class StateImpl {
             return valueState();
         };
     };
-    /**
-     * Creates a lens for direct updates to nested properties of a state.
-     * Implementation of the public 'lens' function.
-     */
     static createLens = (source, accessor) => {
-        // Extract the property path once during lens creation
         const extractPath = () => {
             const path = [];
             const proxy = new Proxy({}, {
@@ -351,17 +246,12 @@ class StateImpl {
                 accessor(proxy);
             }
             catch {
-                // Ignore errors, we're just collecting the path
             }
             return path;
         };
-        // Capture the path once
         const path = extractPath();
-        // Create a state with the initial value from the source
         const lensState = StateImpl.createState(accessor(source()));
-        // Prevent circular updates
         let isUpdating = false;
-        // Set up an effect to sync from source to lens
         StateImpl.createEffect(() => {
             if (isUpdating) {
                 return;
@@ -374,7 +264,6 @@ class StateImpl {
                 isUpdating = false;
             }
         });
-        // Override the lens state's set method to update the source
         const originalSet = lensState.set;
         lensState.set = (value) => {
             if (isUpdating) {
@@ -382,35 +271,25 @@ class StateImpl {
             }
             isUpdating = true;
             try {
-                // Update lens state
                 originalSet(value);
-                // Update source by modifying the value at path
                 source.update((current) => setValueAtPath(current, path, value));
             }
             finally {
                 isUpdating = false;
             }
         };
-        // Add update method for completeness
         lensState.update = (fn) => {
             lensState.set(fn(lensState()));
         };
         return lensState;
     };
-    // Processes queued subscriber notifications in a controlled, non-reentrant way
     static notifySubscribers = () => {
-        // Prevent reentrance to avoid cascading notification loops when
-        // effects trigger further state changes
         if (StateImpl.isNotifying) {
             return;
         }
         StateImpl.isNotifying = true;
         try {
-            // Process all pending effects in batches for better perf,
-            // ensuring topological execution order is maintained
             while (StateImpl.pendingSubscribers.size > 0) {
-                // Process in snapshot batches to prevent infinite loops
-                // when effects trigger further state changes
                 const subscribers = Array.from(StateImpl.pendingSubscribers);
                 StateImpl.pendingSubscribers.clear();
                 for (const effect of subscribers) {
@@ -422,11 +301,8 @@ class StateImpl {
             StateImpl.isNotifying = false;
         }
     };
-    // Removes effect from dependency tracking to prevent memory leaks
     static cleanupEffect = (effect) => {
-        // Remove from execution queue to prevent stale updates
         StateImpl.pendingSubscribers.delete(effect);
-        // Remove bidirectional dependency references to prevent memory leaks
         const deps = StateImpl.subscriberDependencies.get(effect);
         if (deps) {
             for (const subscribers of deps) {
@@ -437,72 +313,54 @@ class StateImpl {
         }
     };
 }
-// Helper for array updates
 const updateArrayItem = (arr, index, value) => {
     const copy = [...arr];
     copy[index] = value;
     return copy;
 };
-// Helper for single-level updates (optimization)
 const updateShallowProperty = (obj, key, value) => {
     const result = { ...obj };
     result[key] = value;
     return result;
 };
-// Helper to create the appropriate container type
 const createContainer = (key) => {
     const isArrayKey = typeof key === 'number' || !Number.isNaN(Number(key));
     return isArrayKey ? [] : {};
 };
-// Helper for handling array path updates
 const updateArrayPath = (array, pathSegments, value) => {
     const index = Number(pathSegments[0]);
     if (pathSegments.length === 1) {
-        // Simple array item update
         return updateArrayItem(array, index, value);
     }
-    // Nested path in array
     const copy = [...array];
     const nextPathSegments = pathSegments.slice(1);
     const nextKey = nextPathSegments[0];
-    // For null/undefined values in arrays, create appropriate containers
     let nextValue = array[index];
     if (nextValue === undefined || nextValue === null) {
-        // Use empty object as default if nextKey is undefined
         nextValue = nextKey !== undefined ? createContainer(nextKey) : {};
     }
     copy[index] = setValueAtPath(nextValue, nextPathSegments, value);
     return copy;
 };
-// Helper for handling object path updates
 const updateObjectPath = (obj, pathSegments, value) => {
-    // Ensure we have a valid key
     const currentKey = pathSegments[0];
     if (currentKey === undefined) {
-        // This shouldn't happen given our checks in the main function
         return obj;
     }
     if (pathSegments.length === 1) {
-        // Simple object property update
         return updateShallowProperty(obj, currentKey, value);
     }
-    // Nested path in object
     const nextPathSegments = pathSegments.slice(1);
     const nextKey = nextPathSegments[0];
-    // For null/undefined values, create appropriate containers
     let currentValue = obj[currentKey];
     if (currentValue === undefined || currentValue === null) {
-        // Use empty object as default if nextKey is undefined
         currentValue = nextKey !== undefined ? createContainer(nextKey) : {};
     }
-    // Create new object with updated property
     const result = { ...obj };
     result[currentKey] = setValueAtPath(currentValue, nextPathSegments, value);
     return result;
 };
-// Simplified function to update a nested value at a path
 const setValueAtPath = (obj, pathSegments, value) => {
-    // Handle base cases
     if (pathSegments.length === 0) {
         return value;
     }
@@ -513,7 +371,6 @@ const setValueAtPath = (obj, pathSegments, value) => {
     if (currentKey === undefined) {
         return obj;
     }
-    // Delegate to specialized handlers based on data type
     if (Array.isArray(obj)) {
         return updateArrayPath(obj, pathSegments, value);
     }

package/dist/src/index.min.js

@@ -0,0 +1 @@
+let s=Symbol(),i=(e,t=Object.is)=>u.createState(e,t);var e=e=>u.createEffect(e),t=e=>u.executeBatch(e),r=e=>u.createDerive(e),c=(e,t,r=Object.is)=>u.createSelect(e,t,r);let a=e=>()=>e();var n=(e,t=Object.is)=>{let r=i(e,t);return[()=>a(r)(),{set:e=>r.set(e),update:e=>r.update(e)}]},b=(e,t)=>u.createLens(e,t);class u{static currentSubscriber=null;static pendingSubscribers=new Set;static isNotifying=!1;static batchDepth=0;static deferredEffectCreations=[];static activeSubscribers=new Set;static stateTracking=new WeakMap;static subscriberDependencies=new WeakMap;static parentSubscriber=new WeakMap;static childSubscribers=new WeakMap;value;subscribers=new Set;stateId=Symbol();equalityFn;constructor(e,t=Object.is){this.value=e,this.equalityFn=t}static createState=(e,t=Object.is)=>{let r=new u(e,t);e=()=>r.get();return e.set=e=>r.set(e),e.update=e=>r.update(e),e[s]=r.stateId,e};get=()=>{var r=u.currentSubscriber;if(r){this.subscribers.add(r);let e=u.subscriberDependencies.get(r),t=(e||(e=new Set,u.subscriberDependencies.set(r,e)),e.add(this.subscribers),u.stateTracking.get(r));t||(t=new Set,u.stateTracking.set(r,t)),t.add(this.stateId)}return this.value};set=e=>{if(!this.equalityFn(this.value,e)){var t=u.currentSubscriber;if(t)if(u.stateTracking.get(t)?.has(this.stateId)&&!u.parentSubscriber.get(t))throw new Error("Infinite loop detected: effect() cannot update a state() it depends on!");if(this.value=e,0!==this.subscribers.size){for(var r of this.subscribers)u.pendingSubscribers.add(r);0!==u.batchDepth||u.isNotifying||u.notifySubscribers()}}};update=e=>{this.set(e(this.value))};static createEffect=e=>{let r=()=>{if(!u.activeSubscribers.has(r)){u.activeSubscribers.add(r);var t=u.currentSubscriber;try{if(u.cleanupEffect(r),u.currentSubscriber=r,u.stateTracking.set(r,new Set),t){u.parentSubscriber.set(r,t);let e=u.childSubscribers.get(t);e||(e=new Set,u.childSubscribers.set(t,e)),e.add(r)}e()}finally{u.currentSubscriber=t,u.activeSubscribers.delete(r)}}};if(0===u.batchDepth)r();else{if(u.currentSubscriber){var t=u.currentSubscriber;u.parentSubscriber.set(r,t);let e=u.childSubscribers.get(t);e||(e=new Set,u.childSubscribers.set(t,e)),e.add(r)}u.deferredEffectCreations.push(r)}return()=>{u.cleanupEffect(r),u.pendingSubscribers.delete(r),u.activeSubscribers.delete(r),u.stateTracking.delete(r);var e=u.parentSubscriber.get(r),e=(e&&(e=u.childSubscribers.get(e))&&e.delete(r),u.parentSubscriber.delete(r),u.childSubscribers.get(r));if(e){for(var t of e)u.cleanupEffect(t);e.clear(),u.childSubscribers.delete(r)}}};static executeBatch=e=>{u.batchDepth++;try{return e()}catch(e){throw 1===u.batchDepth&&(u.pendingSubscribers.clear(),u.deferredEffectCreations.length=0),e}finally{if(u.batchDepth--,0===u.batchDepth){if(0<u.deferredEffectCreations.length){var t,e=[...u.deferredEffectCreations];u.deferredEffectCreations.length=0;for(t of e)t()}0<u.pendingSubscribers.size&&!u.isNotifying&&u.notifySubscribers()}}};static createDerive=t=>{let r=u.createState(void 0),s=!1,i;return u.createEffect(()=>{var e=t();s&&Object.is(i,e)||(i=e,r.set(e)),s=!0}),()=>(s||(i=t(),s=!0,r.set(i)),r())};static createSelect=(t,r,s=Object.is)=>{let i,c,a=!1,n=u.createState(void 0);return u.createEffect(()=>{var e=t();a&&Object.is(i,e)||(i=e,e=r(e),a&&void 0!==c&&s(c,e))||(c=e,n.set(e),a=!0)}),()=>(a||(i=t(),c=r(i),n.set(c),a=!0),n())};static createLens=(e,t)=>{let r=(()=>{let r=[],s=new Proxy({},{get:(e,t)=>("string"!=typeof t&&"number"!=typeof t||r.push(t),s)});try{t(s)}catch{}return r})(),s=u.createState(t(e())),i=!1,c=(u.createEffect(()=>{if(!i){i=!0;try{s.set(t(e()))}finally{i=!1}}}),s.set);return s.set=t=>{if(!i){i=!0;try{c(t),e.update(e=>p(e,r,t))}finally{i=!1}}},s.update=e=>{s.set(e(s()))},s};static notifySubscribers=()=>{if(!u.isNotifying){u.isNotifying=!0;try{for(;0<u.pendingSubscribers.size;){var e,t=Array.from(u.pendingSubscribers);u.pendingSubscribers.clear();for(e of t)e()}}finally{u.isNotifying=!1}}};static cleanupEffect=e=>{u.pendingSubscribers.delete(e);var t=u.subscriberDependencies.get(e);if(t){for(var r of t)r.delete(e);t.clear(),u.subscriberDependencies.delete(e)}}}let f=(e,t,r)=>{e=[...e];return e[t]=r,e},l=(e,t,r)=>{e={...e};return e[t]=r,e},d=e=>"number"==typeof e||!Number.isNaN(Number(e))?[]:{},S=(e,t,r)=>{var s=Number(t[0]);if(1===t.length)return f(e,s,r);var i=[...e],t=t.slice(1),c=t[0];let a=e[s];return null==a&&(a=void 0!==c?d(c):{}),i[s]=p(a,t,r),i},h=(e,t,r)=>{var s=t[0];if(void 0===s)return e;if(1===t.length)return l(e,s,r);var t=t.slice(1),i=t[0];let c=e[s];null==c&&(c=void 0!==i?d(i):{});i={...e};return i[s]=p(c,t,r),i},p=(e,t,r)=>0===t.length?r:null==e?p({},t,r):void 0===t[0]?e:(Array.isArray(e)?S:h)(e,t,r);export{i as state,e as effect,t as batch,r as derive,c as select,a as readonlyState,n as protectedState,b as lens};

package/package.json

@@ -1,11 +1,17 @@
 {
 	"name": "@nerdalytics/beacon",
-	"version": "1000.2.0",
+	"version": "1000.2.1",
 	"description": "A lightweight reactive state library for Node.js backends. Enables reactive state management with automatic dependency tracking and efficient updates for server-side applications.",
 	"type": "module",
-	"main": "dist/src/index.js",
+	"main": "dist/src/index.min.js",
 	"types": "dist/src/index.d.ts",
 	"files": ["dist/src/index.js", "dist/src/index.d.ts", "src/index.ts", "LICENSE"],
+	"exports": {
+		".": {
+			"typescript": "./src/index.ts",
+			"default": "./dist/src/index.js"
+		}
+	},
 	"repository": {
 		"url": "git+https://github.com/nerdalytics/beacon.git",
 		"type": "git"
@@ -34,6 +40,7 @@
 		"build": "npm run build:lts",
 		"prebuild:lts": "rm -rf dist/",
 		"build:lts": "tsc -p tsconfig.lts.json",
+		"postbuild:lts": "npx uglify-js --compress --mangle --module --toplevel --v8 --warn --source-map \"content='dist/src/index.js.map'\" --output dist/src/index.min.js dist/src/index.js",
 		"prepublishOnly": "npm run build:lts",
 		"pretest:lts": "node scripts/run-lts-tests.js",
 		"test:lts:20": "node --test dist/tests/**.js",
@@ -63,7 +70,8 @@
 	"devDependencies": {
 		"@biomejs/biome": "1.9.4",
 		"@types/node": "22.14.1",
-		"typescript": "5.8.3"
+		"typescript": "5.8.3",
+		"uglify-js": "3.19.3"
 	},
 	"engines": {
 		"node": ">=20.0.0"