stunk 2.3.0 → 2.4.0

package/dist/core/computed.js

@@ -1,58 +0,0 @@
-import { chunk } from "./core";
-import { shallowEqual } from "../utils";
-export function computed(dependencies, computeFn) {
-    const dependencyValues = dependencies.map(dep => dep.get());
-    let cachedValue = computeFn(...dependencyValues);
-    const computedChunk = chunk(cachedValue);
-    const originalSet = computedChunk.set;
-    let isDirty = false;
-    // Direct synchronous recomputation
-    const recompute = () => {
-        let hasChanges = false;
-        for (let i = 0; i < dependencies.length; i++) {
-            const newValue = dependencies[i].get();
-            if (newValue !== dependencyValues[i]) {
-                dependencyValues[i] = newValue;
-                hasChanges = true;
-            }
-        }
-        if (hasChanges) {
-            const newValue = computeFn(...dependencyValues);
-            // Fast path for primitives only. Avoids shallowEqual for performance.
-            if (newValue !== cachedValue) {
-                // Only use shallowEqual for objects when needed
-                if (typeof newValue !== 'object' || typeof cachedValue !== 'object' || !shallowEqual(newValue, cachedValue)) {
-                    cachedValue = newValue;
-                    originalSet(newValue);
-                }
-            }
-            isDirty = false;
-        }
-    };
-    const unsubs = dependencies.map(dep => dep.subscribe(() => {
-        isDirty = true;
-        recompute();
-    }));
-    return {
-        ...computedChunk,
-        get: () => {
-            if (isDirty)
-                recompute();
-            return cachedValue;
-        },
-        recompute,
-        isDirty: () => isDirty,
-        set: () => { throw new Error('Cannot set values directly on computed. Modify the source chunk instead.'); },
-        reset: () => {
-            dependencies.forEach(dep => {
-                if (typeof dep.reset === 'function') {
-                    dep.reset();
-                }
-            });
-            isDirty = true;
-            recompute();
-            return cachedValue;
-        },
-        destroy: () => { unsubs.forEach(unsub => unsub()); computedChunk.destroy?.(); }
-    };
-}

package/dist/core/core.js

@@ -1,102 +0,0 @@
-import { processMiddleware } from "../utils";
-let isBatching = false;
-const dirtyChunks = new Set();
-const chunkRegistry = new Map();
-let chunkIdCounter = 0;
-/**
- * Batch multiple chunk updates into a single re-render.
- * Useful for updating multiple chunks at once without causing multiple re-renders.
- */
-export function batch(callback) {
-    const wasBatchingBefore = isBatching;
-    isBatching = true;
-    try {
-        callback();
-    }
-    finally {
-        if (!wasBatchingBefore) {
-            isBatching = false;
-            const chunks = Array.from(dirtyChunks); // Snapshot to avoid mutation issues
-            dirtyChunks.clear(); // Clear early to prevent re-adds
-            chunks.forEach(id => {
-                const chunk = chunkRegistry.get(id);
-                if (chunk)
-                    chunk.notify();
-            });
-        }
-    }
-}
-export function chunk(initialValue, middleware = []) {
-    if (initialValue === undefined || initialValue === null) {
-        throw new Error("Initial value cannot be undefined or null.");
-    }
-    let value = initialValue;
-    const subscribers = new Set();
-    const chunkId = chunkIdCounter++;
-    const notify = () => {
-        subscribers.forEach(subscriber => subscriber(value));
-    };
-    chunkRegistry.set(chunkId, { notify });
-    const notifySubscribers = () => {
-        if (subscribers.size === 0)
-            return; // Skip if no subscribers
-        if (isBatching) {
-            dirtyChunks.add(chunkId);
-        }
-        else {
-            notify();
-        }
-    };
-    const get = () => value;
-    const set = (newValueOrUpdater) => {
-        let newValue;
-        if (typeof newValueOrUpdater === 'function') {
-            newValue = newValueOrUpdater(value);
-        }
-        else {
-            newValue = newValueOrUpdater;
-        }
-        const processedValue = processMiddleware(newValue, middleware);
-        if (processedValue !== value) {
-            value = processedValue;
-            notifySubscribers();
-        }
-    };
-    const subscribe = (callback) => {
-        if (typeof callback !== "function") {
-            throw new Error("Callback must be a function.");
-        }
-        subscribers.add(callback);
-        callback(value);
-        return () => subscribers.delete(callback);
-    };
-    const reset = () => {
-        value = initialValue;
-        notifySubscribers();
-    };
-    const destroy = () => {
-        subscribers.clear();
-        value = initialValue;
-        dirtyChunks.delete(chunkId);
-        chunkRegistry.delete(chunkId);
-    };
-    const derive = (fn) => {
-        if (typeof fn !== "function") {
-            throw new Error("Derive function must be a function.");
-        }
-        const initialDerivedValue = fn(value);
-        const derivedChunk = chunk(initialDerivedValue);
-        const unsubscribe = subscribe(() => {
-            const newDerivedValue = fn(value);
-            derivedChunk.set(newDerivedValue);
-        });
-        // Add a cleanup method to the derived chunk
-        const originalDestroy = derivedChunk.destroy;
-        derivedChunk.destroy = () => {
-            unsubscribe();
-            originalDestroy();
-        };
-        return derivedChunk;
-    };
-    return { get, set, subscribe, derive, reset, destroy };
-}

package/dist/core/selector.d.ts

@@ -1,17 +0,0 @@
-import { Chunk } from "./core";
-export interface SelectOptions {
-    /**
-     * Configuration options for selector functions.
-     * @property {boolean} [useShallowEqual] - When true, performs a shallow equality check
-     * on the derived selector results to prevent unnecessary updates.
-     */
-    useShallowEqual?: boolean;
-}
-/**
- * Creates a derived read-only chunk based on a selector function.
- * @param sourceChunk The source chunk to derive from.
- * @param selector A function that extracts part of the source value.
- * @param options Optional settings for shallow equality comparison.
- * @returns A read-only derived chunk.
- */
-export declare function select<T, S>(sourceChunk: Chunk<T>, selector: (value: T) => S, options?: SelectOptions): Chunk<S>;

package/dist/core/selector.js

@@ -1,45 +0,0 @@
-import { shallowEqual } from "../utils";
-import { chunk } from "./core";
-/**
- * Creates a derived read-only chunk based on a selector function.
- * @param sourceChunk The source chunk to derive from.
- * @param selector A function that extracts part of the source value.
- * @param options Optional settings for shallow equality comparison.
- * @returns A read-only derived chunk.
- */
-export function select(sourceChunk, selector, options = {}) {
-    const { useShallowEqual = false } = options;
-    let prevSourceValue = sourceChunk.get();
-    let currentResult = selector(prevSourceValue);
-    const derivedChunk = chunk(currentResult);
-    const update = () => {
-        const newSourceValue = sourceChunk.get();
-        const newResult = selector(newSourceValue);
-        // Always update the reference to source value
-        prevSourceValue = newSourceValue;
-        // Check if the result has changed
-        const resultChanged = useShallowEqual
-            ? !shallowEqual(newResult, currentResult)
-            : newResult !== currentResult;
-        if (resultChanged) {
-            currentResult = newResult;
-            derivedChunk.set(newResult);
-        }
-    };
-    const unsubscribe = sourceChunk.subscribe(update);
-    return {
-        get: () => derivedChunk.get(),
-        set: () => {
-            throw new Error('Cannot set values directly on a selector. Modify the source chunk instead.');
-        },
-        subscribe: derivedChunk.subscribe,
-        derive: (fn) => select(derivedChunk, fn, options), // Pass options to nested selectors
-        reset: () => {
-            throw new Error('Cannot reset a selector chunk. Reset the source chunk instead.');
-        },
-        destroy: () => {
-            unsubscribe();
-            derivedChunk.destroy();
-        }
-    };
-}

package/dist/core/types.d.ts

@@ -1,16 +0,0 @@
-import { AsyncChunk } from "./asyncChunk";
-export type AsyncChunkOpt<T, E extends Error> = {
-    initialData?: T | null;
-    onError?: (error: E) => void;
-    retryCount?: number;
-    retryDelay?: number;
-};
-export type InferAsyncData<T> = T extends AsyncChunk<infer U, Error> ? U : never;
-export type CombinedData<T> = {
-    [K in keyof T]: InferAsyncData<T[K]> | null;
-};
-export type CombinedState<T> = {
-    loading: boolean;
-    error: Error | null;
-    data: CombinedData<T>;
-};

package/dist/core/types.js

@@ -1 +0,0 @@
-export {};

package/dist/middleware/history.d.ts

@@ -1,30 +0,0 @@
-import { Chunk } from "../core/core";
-export interface ChunkWithHistory<T> extends Chunk<T> {
-    /**
-   * Reverts to the previous state (if available).
-   */
-    undo: () => void;
-    /**
-     * Moves to the next state (if available).
-     */
-    redo: () => void;
-    /**
-     * Returns true if there is a previous state to revert to.
-     */
-    canUndo: () => boolean;
-    /**
-     * Returns true if there is a next state to move to.
-     */
-    canRedo: () => boolean;
-    /**
-     * Returns an array of all the values in the history.
-     */
-    getHistory: () => T[];
-    /**
-     * Clears the history, keeping only the current value.
-     */
-    clearHistory: () => void;
-}
-export declare function withHistory<T>(baseChunk: Chunk<T>, options?: {
-    maxHistory?: number;
-}): ChunkWithHistory<T>;

package/dist/middleware/history.js

@@ -1,68 +0,0 @@
-export function withHistory(baseChunk, options = {}) {
-    const { maxHistory = 100 } = options;
-    const history = [baseChunk.get()];
-    let currentIndex = 0;
-    let isHistoryAction = false;
-    const historyChunk = {
-        ...baseChunk,
-        set: (newValueOrUpdater) => {
-            if (isHistoryAction) {
-                baseChunk.set(newValueOrUpdater);
-                return;
-            }
-            // Process the value or updater function
-            let newValue;
-            if (typeof newValueOrUpdater === 'function') {
-                // Get current value and apply the updater function
-                const currentValue = baseChunk.get();
-                newValue = newValueOrUpdater(currentValue);
-            }
-            else {
-                // Use directly as the new value
-                newValue = newValueOrUpdater;
-            }
-            history.splice(currentIndex + 1);
-            history.push(newValue);
-            // Limit history size
-            if (history.length > maxHistory) {
-                console.warn("History limit reached. Removing oldest entries.");
-                const removeCount = history.length - maxHistory;
-                history.splice(0, removeCount);
-                currentIndex = Math.max(0, currentIndex - removeCount);
-            }
-            currentIndex = history.length - 1;
-            baseChunk.set(newValue);
-        },
-        undo: () => {
-            if (!historyChunk.canUndo())
-                return;
-            isHistoryAction = true;
-            currentIndex--;
-            historyChunk.set(history[currentIndex]);
-            isHistoryAction = false;
-        },
-        redo: () => {
-            if (!historyChunk.canRedo())
-                return;
-            isHistoryAction = true;
-            currentIndex++;
-            historyChunk.set(history[currentIndex]);
-            isHistoryAction = false;
-        },
-        canUndo: () => currentIndex > 0,
-        canRedo: () => currentIndex < history.length - 1,
-        getHistory: () => [...history],
-        clearHistory: () => {
-            const currentValue = baseChunk.get();
-            history.length = 0;
-            history.push(currentValue);
-            currentIndex = 0;
-        },
-        // Override destroy to clean up history
-        destroy: () => {
-            history.length = 0;
-            baseChunk.destroy();
-        }
-    };
-    return historyChunk;
-}

package/dist/middleware/logger.d.ts

@@ -1,2 +0,0 @@
-import { Middleware } from "../core/core";
-export declare const logger: Middleware<any>;

package/dist/middleware/logger.js

@@ -1,4 +0,0 @@
-export const logger = (value, next) => {
-    console.log("Setting value:", value);
-    next(value);
-};

package/dist/middleware/persistence.d.ts

@@ -1,8 +0,0 @@
-import { Chunk } from "../core/core";
-export interface PersistOptions<T> {
-    key: string;
-    storage?: Storage;
-    serialize?: (value: T) => string;
-    deserialize?: (value: string) => T;
-}
-export declare function withPersistence<T>(baseChunk: Chunk<T>, options: PersistOptions<T>): Chunk<T>;

package/dist/middleware/persistence.js

@@ -1,25 +0,0 @@
-export function withPersistence(baseChunk, options) {
-    const { key, storage = localStorage, serialize = JSON.stringify, deserialize = JSON.parse, } = options;
-    // Try to load initial state from storage
-    try {
-        const savedChunk = storage.getItem(key);
-        if (savedChunk) {
-            const parsed = deserialize(savedChunk);
-            baseChunk.set(parsed);
-        }
-    }
-    catch (error) {
-        console.error('Failed to load persisted state:', error);
-    }
-    // Save to storage
-    baseChunk.subscribe((newValue) => {
-        try {
-            const serialized = serialize(newValue);
-            storage.setItem(key, serialized);
-        }
-        catch (error) {
-            console.log('Failed to persist chunk', error);
-        }
-    });
-    return baseChunk;
-}

package/dist/middleware/validator.d.ts

@@ -1,2 +0,0 @@
-import { Middleware } from "../core/core";
-export declare const nonNegativeValidator: Middleware<number>;

package/dist/middleware/validator.js

@@ -1,6 +0,0 @@
-export const nonNegativeValidator = (value, next) => {
-    if (value < 0) {
-        throw new Error("Value must be non-negative!");
-    }
-    next(value); // If validation passes, proceed with the update
-};

package/dist/use-react/hooks/useAsyncChunk.d.ts

@@ -1,14 +0,0 @@
-import { AsyncChunk, AsyncState } from "../../core/asyncChunk";
-/**
- * A hook that handles asynchronous state with built-in reactivity.
- * Provides loading, error, and data states.
- */
-export declare function useAsyncChunk<T, E extends Error>(asyncChunk: AsyncChunk<T, E>): {
-    state: AsyncState<T, E>;
-    data: T | null;
-    loading: boolean;
-    error: E | null;
-    reload: () => Promise<void>;
-    mutate: (mutator: (currentData: T | null) => T) => void;
-    reset: () => void;
-};

package/dist/use-react/hooks/useAsyncChunk.js

@@ -1,27 +0,0 @@
-import { useState, useEffect, useCallback } from "react";
-/**
- * A hook that handles asynchronous state with built-in reactivity.
- * Provides loading, error, and data states.
- */
-export function useAsyncChunk(asyncChunk) {
-    const [state, setState] = useState(() => asyncChunk.get());
-    useEffect(() => {
-        const unsubscribe = asyncChunk.subscribe((newState) => {
-            setState(newState);
-        });
-        return () => unsubscribe();
-    }, [asyncChunk]);
-    const reload = useCallback(() => asyncChunk.reload(), [asyncChunk]);
-    const mutate = useCallback((mutator) => asyncChunk.mutate(mutator), [asyncChunk]);
-    const reset = useCallback(() => asyncChunk.reset(), [asyncChunk]);
-    const { data, loading, error } = state;
-    return {
-        state,
-        data,
-        loading,
-        error,
-        reload,
-        mutate,
-        reset,
-    };
-}

package/dist/use-react/hooks/useChunk.d.ts

@@ -1,6 +0,0 @@
-import type { Chunk } from "../../core/core";
-/**
- * A lightweight hook that subscribes to a chunk and returns its current value, along with setters, selector, reset and destroy.
- * Ensures reactivity and prevents unnecessary re-renders.
- */
-export declare function useChunk<T, S = T>(chunk: Chunk<T>, selector?: (value: T) => S): readonly [S, (valueOrUpdater: T | ((currentValue: T) => T)) => void, () => void, () => void];

package/dist/use-react/hooks/useChunk.js

@@ -1,26 +0,0 @@
-import { useState, useEffect, useCallback } from "react";
-import { select } from "../../core/selector";
-/**
- * A lightweight hook that subscribes to a chunk and returns its current value, along with setters, selector, reset and destroy.
- * Ensures reactivity and prevents unnecessary re-renders.
- */
-export function useChunk(chunk, selector) {
-    const selectedChunk = selector ? select(chunk, selector) : chunk;
-    const [state, setState] = useState(() => selectedChunk.get());
-    useEffect(() => {
-        const unsubscribe = selectedChunk.subscribe((newValue) => {
-            setState(() => newValue);
-        });
-        return () => unsubscribe();
-    }, [selectedChunk]);
-    const set = useCallback((valueOrUpdater) => {
-        chunk.set(valueOrUpdater);
-    }, [chunk]);
-    const reset = useCallback(() => {
-        chunk.reset();
-    }, [chunk]);
-    const destroy = useCallback(() => {
-        chunk.destroy();
-    }, [chunk]);
-    return [state, set, reset, destroy];
-}

package/dist/use-react/hooks/useChunkProperty.d.ts

@@ -1,6 +0,0 @@
-import type { Chunk } from "../../core/core";
-/**
- * A hook that subscribes to a specific property of a chunk.
- * This optimizes renders by only updating when the selected property changes.
- */
-export declare function useChunkProperty<T, K extends keyof T>(chunk: Chunk<T>, property: K): T[K];

package/dist/use-react/hooks/useChunkProperty.js

@@ -1,10 +0,0 @@
-import { useMemo } from "react";
-import { useChunkValue } from "./useChunkValue";
-/**
- * A hook that subscribes to a specific property of a chunk.
- * This optimizes renders by only updating when the selected property changes.
- */
-export function useChunkProperty(chunk, property) {
-    const selector = useMemo(() => (state) => state[property], [property]);
-    return useChunkValue(chunk, selector);
-}

package/dist/use-react/hooks/useChunkValue.d.ts

@@ -1,6 +0,0 @@
-import type { Chunk } from "../../core/core";
-/**
- * A lightweight hook that subscribes to a chunk and returns only its current value.
- * Useful for read-only components that don't need to update the chunk.
- */
-export declare function useChunkValue<T, S = T>(chunk: Chunk<T>, selector?: (value: T) => S): S;

package/dist/use-react/hooks/useChunkValue.js

@@ -1,9 +0,0 @@
-import { useChunk } from "./useChunk";
-/**
- * A lightweight hook that subscribes to a chunk and returns only its current value.
- * Useful for read-only components that don't need to update the chunk.
- */
-export function useChunkValue(chunk, selector) {
-    const [value] = useChunk(chunk, selector);
-    return value;
-}

package/dist/use-react/hooks/useChunkValues.d.ts

@@ -1,8 +0,0 @@
-import type { Chunk } from "../../core/core";
-/**
- * Hook to read values from multiple chunks at once.
- * Only re-renders when any of the chunk values change.
- */
-export declare function useChunkValues<T extends Chunk<any>[]>(chunks: [...T]): {
-    [K in keyof T]: T[K] extends Chunk<infer U> ? U : never;
-};

package/dist/use-react/hooks/useChunkValues.js

@@ -1,25 +0,0 @@
-import { useState, useEffect } from "react";
-/**
- * Hook to read values from multiple chunks at once.
- * Only re-renders when any of the chunk values change.
- */
-export function useChunkValues(chunks) {
-    const [values, setValues] = useState(() => {
-        return chunks.map(chunk => chunk.get());
-    });
-    useEffect(() => {
-        const unsubscribes = chunks.map((chunk, index) => {
-            return chunk.subscribe((newValue) => {
-                setValues(prev => {
-                    const newValues = [...prev];
-                    newValues[index] = newValue;
-                    return newValues;
-                });
-            });
-        });
-        return () => {
-            unsubscribes.forEach(unsubscribe => unsubscribe());
-        };
-    }, [chunks]);
-    return values;
-}

package/dist/use-react/hooks/useComputed.d.ts

@@ -1,7 +0,0 @@
-import { DependencyValues } from "../../core/computed";
-import type { Chunk } from "../../core/core";
-/**
- * A hook that computes a value based on multiple chunks.
- * Automatically re-computes when any dependency changes.
- */
-export declare function useComputed<TDeps extends Chunk<any>[], TResult>(dependencies: [...TDeps], computeFn: (...args: DependencyValues<TDeps>) => TResult): TResult;

package/dist/use-react/hooks/useComputed.js

@@ -1,22 +0,0 @@
-import { useState, useEffect, useMemo } from "react";
-import { computed } from "../../core/computed";
-/**
- * A hook that computes a value based on multiple chunks.
- * Automatically re-computes when any dependency changes.
- */
-export function useComputed(dependencies, computeFn) {
-    // Create the computed value - memoize it based on dependencies to prevent recreation
-    const computedValue = useMemo(() => computed(dependencies, computeFn), 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [...dependencies]);
-    const [state, setState] = useState(() => computedValue.get());
-    useEffect(() => {
-        const unsubscribe = computedValue.subscribe((newValue) => {
-            setState(newValue);
-        });
-        return () => {
-            unsubscribe();
-        };
-    }, [computedValue]);
-    return state;
-}

package/dist/use-react/hooks/useDerive.d.ts

@@ -1,6 +0,0 @@
-import type { Chunk } from "../../core/core";
-/**
- * A hook for creating a read-only derived value from a chunk.
- * Ensures reactivity and updates when the source chunk changes.
- */
-export declare function useDerive<T, D>(chunk: Chunk<T>, fn: (value: T) => D): D;

package/dist/use-react/hooks/useDerive.js

@@ -1,17 +0,0 @@
-import { useEffect, useMemo, useRef } from "react";
-import { useChunk } from "./useChunk";
-/**
- * A hook for creating a read-only derived value from a chunk.
- * Ensures reactivity and updates when the source chunk changes.
- */
-export function useDerive(chunk, fn) {
-    const fnRef = useRef(fn);
-    useEffect(() => {
-        fnRef.current = fn;
-    }, [fn]);
-    const derivedChunk = useMemo(() => {
-        return chunk.derive((value) => fnRef.current(value));
-    }, [chunk]);
-    const [derivedValue] = useChunk(derivedChunk);
-    return derivedValue;
-}

package/dist/utils.d.ts

@@ -1,15 +0,0 @@
-import { Chunk, Middleware } from "./core/core";
-import { AsyncChunk } from "./core/asyncChunk";
-import { InferAsyncData } from "./core/types";
-export declare function isValidChunkValue(value: any): boolean;
-export declare function isChunk<T>(value: any): value is Chunk<T>;
-export declare function once<T>(fn: () => T): () => T;
-export declare function combineAsyncChunks<T extends Record<string, AsyncChunk<any>>>(chunks: T): Chunk<{
-    loading: boolean;
-    error: Error | null;
-    data: {
-        [K in keyof T]: InferAsyncData<T[K]> | null;
-    };
-}>;
-export declare function processMiddleware<T>(initialValue: T, middleware?: Middleware<T>[]): T;
-export declare function shallowEqual<T>(a: T, b: T): boolean;