@nerdalytics/beacon 1000.2.0 → 1000.2.2

package/dist/src/index.d.ts

@@ -1,4 +1,4 @@
-type Unsubscribe = () => void;
+export type Unsubscribe = () => void;
 export type ReadOnlyState<T> = () => T;
 export interface WriteableState<T> {
     set(value: T): void;
@@ -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.
- */
+const STATE_ID = Symbol('STATE_ID');
 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,173 +167,148 @@ 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];
+                    const effectsToRun = [
+                        ...StateImpl.deferredEffectCreations,
+                    ];
                     StateImpl.deferredEffectCreations.length = 0;
                     for (const effect of effectsToRun) {
                         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);
+        const container = {
+            cachedValue: undefined,
+            computeFn,
+            initialized: false,
+            valueState: StateImpl.createState(undefined),
+        };
+        StateImpl.createEffect(function deriveEffect() {
+            const newValue = container.computeFn();
+            if (!(container.initialized && Object.is(container.cachedValue, newValue))) {
+                container.cachedValue = newValue;
+                container.valueState.set(newValue);
             }
-            initialized = true;
+            container.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();
-                initialized = true;
-                valueState.set(cachedValue);
+        return function deriveGetter() {
+            if (!container.initialized) {
+                container.cachedValue = container.computeFn();
+                container.initialized = true;
+                container.valueState.set(container.cachedValue);
             }
-            return valueState();
+            return container.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)) {
+        const container = {
+            equalityFn,
+            initialized: false,
+            lastSelectedValue: undefined,
+            lastSourceValue: undefined,
+            selectorFn,
+            source,
+            valueState: StateImpl.createState(undefined),
+        };
+        StateImpl.createEffect(function selectEffect() {
+            const sourceValue = container.source();
+            if (container.initialized && Object.is(container.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)) {
+            container.lastSourceValue = sourceValue;
+            const newSelectedValue = container.selectorFn(sourceValue);
+            if (container.initialized &&
+                container.lastSelectedValue !== undefined &&
+                container.equalityFn(container.lastSelectedValue, newSelectedValue)) {
                 return;
             }
-            // Update cache and notify subscribers due the value has changed
-            lastSelectedValue = newSelectedValue;
-            valueState.set(newSelectedValue);
-            initialized = true;
+            container.lastSelectedValue = newSelectedValue;
+            container.valueState.set(newSelectedValue);
+            container.initialized = true;
         });
-        // Return function with eager initialization capability
-        return () => {
-            if (!initialized) {
-                lastSourceValue = source();
-                lastSelectedValue = selectorFn(lastSourceValue);
-                valueState.set(lastSelectedValue);
-                initialized = true;
+        return function selectGetter() {
+            if (!container.initialized) {
+                container.lastSourceValue = container.source();
+                container.lastSelectedValue = container.selectorFn(container.lastSourceValue);
+                container.valueState.set(container.lastSelectedValue);
+                container.initialized = true;
             }
-            return valueState();
+            return container.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 container = {
+            accessor,
+            isUpdating: false,
+            lensState: null,
+            originalSet: null,
+            path: [],
+            source,
+        };
         const extractPath = () => {
-            const path = [];
+            const pathCollector = [];
             const proxy = new Proxy({}, {
                 get: (_, prop) => {
                     if (typeof prop === 'string' || typeof prop === 'number') {
-                        path.push(prop);
+                        pathCollector.push(prop);
                     }
                     return proxy;
                 },
             });
             try {
-                accessor(proxy);
+                container.accessor(proxy);
             }
             catch {
-                // Ignore errors, we're just collecting the path
             }
-            return path;
+            return pathCollector;
         };
-        // 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) {
+        container.path = extractPath();
+        container.lensState = StateImpl.createState(container.accessor(container.source()));
+        container.originalSet = container.lensState.set;
+        StateImpl.createEffect(function lensEffect() {
+            if (container.isUpdating) {
                 return;
             }
-            isUpdating = true;
+            container.isUpdating = true;
             try {
-                lensState.set(accessor(source()));
+                container.lensState.set(container.accessor(container.source()));
             }
             finally {
-                isUpdating = false;
+                container.isUpdating = false;
             }
         });
-        // Override the lens state's set method to update the source
-        const originalSet = lensState.set;
-        lensState.set = (value) => {
-            if (isUpdating) {
+        container.lensState.set = function lensSet(value) {
+            if (container.isUpdating) {
                 return;
             }
-            isUpdating = true;
+            container.isUpdating = true;
             try {
-                // Update lens state
-                originalSet(value);
-                // Update source by modifying the value at path
-                source.update((current) => setValueAtPath(current, path, value));
+                container.originalSet(value);
+                container.source.update((current) => setValueAtPath(current, container.path, value));
             }
             finally {
-                isUpdating = false;
+                container.isUpdating = false;
             }
         };
-        // Add update method for completeness
-        lensState.update = (fn) => {
-            lensState.set(fn(lensState()));
+        container.lensState.update = function lensUpdate(fn) {
+            container.lensState.set(fn(container.lensState()));
         };
-        return lensState;
+        return container.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 +320,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 +332,62 @@ class StateImpl {
         }
     };
 }
-// Helper for array updates
 const updateArrayItem = (arr, index, value) => {
-    const copy = [...arr];
+    const copy = [
+        ...arr,
+    ];
     copy[index] = value;
     return copy;
 };
-// Helper for single-level updates (optimization)
 const updateShallowProperty = (obj, key, value) => {
-    const result = { ...obj };
+    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 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 };
+    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 +398,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 i=Symbol("STATE_ID"),a=(e,t=Object.is)=>l.createState(e,t);var e=e=>l.createEffect(e),t=e=>l.executeBatch(e),r=e=>l.createDerive(e),s=(e,t,r=Object.is)=>l.createSelect(e,t,r);let c=e=>()=>e();var n=(e,t=Object.is)=>{let r=a(e,t);return[()=>c(r)(),{set:e=>r.set(e),update:e=>r.update(e)}]},u=(e,t)=>l.createLens(e,t);class l{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 l(e,t);e=()=>r.get();return e.set=e=>r.set(e),e.update=e=>r.update(e),e[i]=r.stateId,e};get=()=>{var r=l.currentSubscriber;if(r){this.subscribers.add(r);let e=l.subscriberDependencies.get(r),t=(e||(e=new Set,l.subscriberDependencies.set(r,e)),e.add(this.subscribers),l.stateTracking.get(r));t||(t=new Set,l.stateTracking.set(r,t)),t.add(this.stateId)}return this.value};set=e=>{if(!this.equalityFn(this.value,e)){var t=l.currentSubscriber;if(t)if(l.stateTracking.get(t)?.has(this.stateId)&&!l.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)l.pendingSubscribers.add(r);0!==l.batchDepth||l.isNotifying||l.notifySubscribers()}}};update=e=>{this.set(e(this.value))};static createEffect=e=>{let r=()=>{if(!l.activeSubscribers.has(r)){l.activeSubscribers.add(r);var t=l.currentSubscriber;try{if(l.cleanupEffect(r),l.currentSubscriber=r,l.stateTracking.set(r,new Set),t){l.parentSubscriber.set(r,t);let e=l.childSubscribers.get(t);e||(e=new Set,l.childSubscribers.set(t,e)),e.add(r)}e()}finally{l.currentSubscriber=t,l.activeSubscribers.delete(r)}}};if(0===l.batchDepth)r();else{if(l.currentSubscriber){var t=l.currentSubscriber;l.parentSubscriber.set(r,t);let e=l.childSubscribers.get(t);e||(e=new Set,l.childSubscribers.set(t,e)),e.add(r)}l.deferredEffectCreations.push(r)}return()=>{l.cleanupEffect(r),l.pendingSubscribers.delete(r),l.activeSubscribers.delete(r),l.stateTracking.delete(r);var e=l.parentSubscriber.get(r),e=(e&&(e=l.childSubscribers.get(e))&&e.delete(r),l.parentSubscriber.delete(r),l.childSubscribers.get(r));if(e){for(var t of e)l.cleanupEffect(t);e.clear(),l.childSubscribers.delete(r)}}};static executeBatch=e=>{l.batchDepth++;try{return e()}catch(e){throw 1===l.batchDepth&&(l.pendingSubscribers.clear(),l.deferredEffectCreations.length=0),e}finally{if(l.batchDepth--,0===l.batchDepth){if(0<l.deferredEffectCreations.length){var t,e=[...l.deferredEffectCreations];l.deferredEffectCreations.length=0;for(t of e)t()}0<l.pendingSubscribers.size&&!l.isNotifying&&l.notifySubscribers()}}};static createDerive=e=>{let t={cachedValue:void 0,computeFn:e,initialized:!1,valueState:l.createState(void 0)};return l.createEffect(function(){var e=t.computeFn();t.initialized&&Object.is(t.cachedValue,e)||(t.cachedValue=e,t.valueState.set(e)),t.initialized=!0}),function(){return t.initialized||(t.cachedValue=t.computeFn(),t.initialized=!0,t.valueState.set(t.cachedValue)),t.valueState()}};static createSelect=(e,t,r=Object.is)=>{let i={equalityFn:r,initialized:!1,lastSelectedValue:void 0,lastSourceValue:void 0,selectorFn:t,source:e,valueState:l.createState(void 0)};return l.createEffect(function(){var e=i.source();i.initialized&&Object.is(i.lastSourceValue,e)||(i.lastSourceValue=e,e=i.selectorFn(e),i.initialized&&void 0!==i.lastSelectedValue&&i.equalityFn(i.lastSelectedValue,e))||(i.lastSelectedValue=e,i.valueState.set(e),i.initialized=!0)}),function(){return i.initialized||(i.lastSourceValue=i.source(),i.lastSelectedValue=i.selectorFn(i.lastSourceValue),i.valueState.set(i.lastSelectedValue),i.initialized=!0),i.valueState()}};static createLens=(e,t)=>{let a={accessor:t,isUpdating:!1,lensState:null,originalSet:null,path:[],source:e};return a.path=(()=>{let r=[],i=new Proxy({},{get:(e,t)=>("string"!=typeof t&&"number"!=typeof t||r.push(t),i)});try{a.accessor(i)}catch{}return r})(),a.lensState=l.createState(a.accessor(a.source())),a.originalSet=a.lensState.set,l.createEffect(function(){if(!a.isUpdating){a.isUpdating=!0;try{a.lensState.set(a.accessor(a.source()))}finally{a.isUpdating=!1}}}),a.lensState.set=function(t){if(!a.isUpdating){a.isUpdating=!0;try{a.originalSet(t),a.source.update(e=>p(e,a.path,t))}finally{a.isUpdating=!1}}},a.lensState.update=function(e){a.lensState.set(e(a.lensState()))},a.lensState};static notifySubscribers=()=>{if(!l.isNotifying){l.isNotifying=!0;try{for(;0<l.pendingSubscribers.size;){var e,t=Array.from(l.pendingSubscribers);l.pendingSubscribers.clear();for(e of t)e()}}finally{l.isNotifying=!1}}};static cleanupEffect=e=>{l.pendingSubscribers.delete(e);var t=l.subscriberDependencies.get(e);if(t){for(var r of t)r.delete(e);t.clear(),l.subscriberDependencies.delete(e)}}}let b=(e,t,r)=>{e=[...e];return e[t]=r,e},d=(e,t,r)=>{e={...e};return e[t]=r,e},f=e=>"number"==typeof e||!Number.isNaN(Number(e))?[]:{},S=(e,t,r)=>{var i=Number(t[0]);if(1===t.length)return b(e,i,r);var a=[...e],t=t.slice(1),s=t[0];let c=e[i];return null==c&&(c=void 0!==s?f(s):{}),a[i]=p(c,t,r),a},o=(e,t,r)=>{var i=t[0];if(void 0===i)return e;if(1===t.length)return d(e,i,r);var t=t.slice(1),a=t[0];let s=e[i];null==s&&(s=void 0!==a?f(a):{});a={...e};return a[i]=p(s,t,r),a},p=(e,t,r)=>0===t.length?r:null==e?p({},t,r):void 0===t[0]?e:(Array.isArray(e)?S:o)(e,t,r);export{a as state,e as effect,t as batch,r as derive,s as select,c as readonlyState,n as protectedState,u as lens};