stunk 2.0.0 → 2.2.0

package/dist/core/selector.js

@@ -1,23 +0,0 @@
-import { chunk } from "./core";
-export function select(sourceChunk, selector) {
-    const initialValue = selector(sourceChunk.get());
-    const selectedChunk = chunk(initialValue);
-    let previousSelected = initialValue;
-    // Subscribe to source changes with equality checking
-    sourceChunk.subscribe((newValue) => {
-        const newSelected = selector(newValue);
-        // Only update if the selected value actually changed
-        if (!Object.is(newSelected, previousSelected)) {
-            previousSelected = newSelected;
-            selectedChunk.set(newSelected);
-        }
-    });
-    // Return read-only version of the chunk
-    return {
-        ...selectedChunk,
-        // Prevent setting values directly on the selector
-        set: () => {
-            throw new Error('Cannot set values directly on a selector. Modify the source chunk instead.');
-        }
-    };
-}

package/jest.config.js

@@ -1,4 +0,0 @@
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-};

package/src/core/asyncChunk.ts

@@ -1,83 +0,0 @@
-import { chunk, Chunk } from "./core";
-import { AsyncChunkOpt } from "./types";
-
-export interface AsyncState<T> {
-  loading: boolean;
-  error: Error | null;
-  data: T | null;
-}
-
-export interface AsyncChunk<T> extends Chunk<AsyncState<T>> {
-  /**
-   * Reload the data from the source.
-   */
-  reload: () => Promise<void>;
-  /**
-   * Mutate the data directly.
-   */
-  mutate: (mutator: (currentData: T | null) => T) => void;
-  /**
-   * Reset the state to the initial value.
-   */
-  reset: () => void;
-}
-
-export function asyncChunk<T>(fetcher: () => Promise<T>, options: AsyncChunkOpt<T> = {}): AsyncChunk<T> {
-  const {
-    initialData = null,
-    onError,
-    retryCount = 0,
-    retryDelay = 1000,
-  } = options;
-
-  const initialState: AsyncState<T> = {
-    loading: true,
-    error: null,
-    data: initialData,
-  };
-
-  const baseChunk = chunk(initialState);
-
-  const fetchData = async (retries = retryCount): Promise<void> => {
-    baseChunk.set({ ...baseChunk.get(), loading: true, error: null });
-
-    try {
-      const data = await fetcher();
-      baseChunk.set({ loading: false, error: null, data });
-    } catch (error) {
-      if (retries > 0) {
-        await new Promise(resolve => setTimeout(resolve, retryDelay));
-        return fetchData(retries - 1);
-      }
-
-      const errorObj = error instanceof Error ? error : new Error(String(error));
-      baseChunk.set({ loading: false, error: errorObj, data: baseChunk.get().data });
-
-      if (onError) {
-        onError(errorObj);
-      }
-
-    }
-  }
-
-  // Initial fetch
-  fetchData();
-
-  const asyncChunkInstance: AsyncChunk<T> = {
-    ...baseChunk,
-    reload: async () => {
-      await fetchData();
-    },
-    mutate: (mutator: (currentData: T | null) => T) => {
-      const currentState = baseChunk.get();
-      const newData = mutator(currentState.data);
-      baseChunk.set({ ...currentState, data: newData });
-    },
-    reset: () => {
-      baseChunk.set(initialState);
-      fetchData();
-    },
-  }
-
-  return asyncChunkInstance;
-}

package/src/core/computed.ts

@@ -1,65 +0,0 @@
-import { Chunk, chunk } from "./core";
-
-// Helper type to extract the value type from a Chunk
-export type ChunkValue<T> = T extends Chunk<infer U> ? U : never;
-
-// Helper type to transform an array of Chunks into an array of their value types
-export type DependencyValues<T extends Chunk<any>[]> = {
-  [K in keyof T]: T[K] extends Chunk<any> ? ChunkValue<T[K]> : never;
-};
-
-export interface Computed<T> extends Chunk<T> {
-  isDirty: () => boolean;
-  recompute: () => void;
-}
-
-export function computed<TDeps extends Chunk<any>[], TResult>(
-  dependencies: [...TDeps],
-  computeFn: (...args: DependencyValues<TDeps>) => TResult
-): Computed<TResult> {
-  let isDirty = false; // Initialized to false
-  let cachedValue: TResult = computeFn(...dependencies.map(d => d.get()) as DependencyValues<TDeps>);
-
-  const recalculate = () => {
-    const values = dependencies.map(dep => dep.get()) as DependencyValues<TDeps>;
-    cachedValue = computeFn(...values);
-    isDirty = false; // Reset to false after recomputation
-  };
-
-  const computedChunk = chunk(cachedValue);
-
-  const originalGet = computedChunk.get;
-  computedChunk.get = () => {
-    if (isDirty) {
-      recalculate();
-      computedChunk.set(cachedValue); // Update the chunk value after recomputation
-    }
-    return cachedValue; // Return the cached value directly
-  };
-
-  const lastValues = dependencies.map(dep => dep.get());
-
-  dependencies.forEach((dep, index) => {
-    dep.subscribe(() => {
-      const newValue = dep.get();
-      if (newValue !== lastValues[index] && !isDirty) {
-        lastValues[index] = newValue;
-        isDirty = true;
-      }
-    });
-  });
-
-  return {
-    ...computedChunk,
-    isDirty: () => isDirty,
-    recompute: () => {
-      if (isDirty) {
-        recalculate();
-        computedChunk.set(cachedValue); // Update the chunk value after manual recomputation
-      }
-    },
-    set: () => {
-      throw new Error('Cannot directly set a computed value');
-    }
-  };
-}

package/src/core/core.ts

@@ -1,128 +0,0 @@
-import { processMiddleware } from "../utils";
-
-export type Subscriber<T> = (newValue: T) => void;
-export type Middleware<T> = (value: T, next: (newValue: T) => void) => void;
-
-export interface Chunk<T> {
-  /** Get the current value of the chunk. */
-  get: () => T;
-  /** Set a new value for the chunk & Update existing value efficiently. */
-  set: (newValueOrUpdater: T | ((currentValue: T) => T)) => void;
-  /** Subscribe to changes in the chunk. Returns an unsubscribe function. */
-  subscribe: (callback: Subscriber<T>) => () => void;
-  /** Create a derived chunk based on this chunk's value. */
-  derive: <D>(fn: (value: T) => D) => Chunk<D>;
-  /** Reset the chunk to its initial value. */
-  reset: () => void;
-  /** Destroy the chunk and all its subscribers. */
-  destroy: () => void;
-}
-
-let batchDepth = 0;
-const batchQueue = new Set<() => void>();
-
-export function batch(callback: () => void) {
-  batchDepth++;
-  try {
-    callback();
-  } finally {
-    batchDepth--;
-    if (batchDepth === 0) {
-      // Execute all queued updates
-      batchQueue.forEach(update => update());
-      batchQueue.clear();
-    }
-  }
-}
-
-export function chunk<T>(initialValue: T, middleware: Middleware<T>[] = []): Chunk<T> {
-  if (initialValue === undefined || initialValue === null) {
-    throw new Error("Initial value cannot be undefined or null.");
-  }
-
-  let value = initialValue;
-  const subscribers = new Set<Subscriber<T>>();
-  let isDirty = false;
-
-  const notifySubscribers = () => {
-    if (batchDepth > 0) {
-      if (!isDirty) {
-        isDirty = true;
-        batchQueue.add(() => {
-          if (isDirty) {
-            subscribers.forEach((subscriber) => subscriber(value));
-            isDirty = false;
-          }
-        });
-      }
-    } else {
-      subscribers.forEach((subscriber) => subscriber(value));
-    }
-  }
-
-  const get = () => value;
-
-  const set = (newValueOrUpdater: T | ((currentValue: T) => T)) => {
-    let newValue: T;
-
-    if (typeof newValueOrUpdater === 'function') {
-      // Handle updater function
-      newValue = (newValueOrUpdater as (currentValue: T) => T)(value);
-    } else {
-      // Handle direct value assignment
-      newValue = newValueOrUpdater;
-    }
-
-    const processedValue = processMiddleware(newValue, middleware);
-
-    if (processedValue !== value) {
-      value = processedValue as T & {};
-      notifySubscribers();
-    }
-  };
-
-  const subscribe = (callback: Subscriber<T>) => {
-    if (typeof callback !== "function") {
-      throw new Error("Callback must be a function.");
-    }
-    if (subscribers.has(callback)) {
-      console.warn("Callback is already subscribed. This may lead to duplicate updates.");
-    }
-    subscribers.add(callback);
-    callback(value);
-
-    return () => subscribers.delete(callback);
-  };
-
-  const reset = () => {
-    value = initialValue;
-    subscribers.forEach((subscriber) => subscriber(value));
-  };
-
-  const destroy = () => {
-    if (subscribers.size > 0) {
-      console.warn("Destroying chunk with active subscribers. This may lead to memory leaks.");
-    }
-    // Just clear subscribers without calling unsubscribe
-    subscribers.clear();
-    value = initialValue;
-  };
-
-
-  const derive = <D>(fn: (value: T) => D) => {
-    if (typeof fn !== "function") {
-      throw new Error("Derive function must be a function.");
-    }
-    const derivedValue = fn(value);
-    const derivedChunk = chunk(derivedValue);
-
-    subscribe(() => {
-      const newDerivedValue = fn(value);
-      derivedChunk.set(newDerivedValue);
-    });
-
-    return derivedChunk;
-  };
-
-  return { get, set, subscribe, derive, reset, destroy };
-}

package/src/core/selector.ts

@@ -1,27 +0,0 @@
-import { chunk, Chunk } from "./core";
-
-export function select<T, S>(sourceChunk: Chunk<T>, selector: (value: T) => S): Chunk<S> {
-  const initialValue = selector(sourceChunk.get());
-  const selectedChunk = chunk(initialValue);
-  let previousSelected = initialValue;
-
-  // Subscribe to source changes with equality checking
-  sourceChunk.subscribe((newValue) => {
-    const newSelected = selector(newValue);
-
-    // Only update if the selected value actually changed
-    if (!Object.is(newSelected, previousSelected)) {
-      previousSelected = newSelected;
-      selectedChunk.set(newSelected);
-    }
-  });
-
-  // Return read-only version of the chunk
-  return {
-    ...selectedChunk,
-    // Prevent setting values directly on the selector
-    set: () => {
-      throw new Error('Cannot set values directly on a selector. Modify the source chunk instead.');
-    }
-  };
-}

package/src/core/types.ts

@@ -1,17 +0,0 @@
-import { AsyncChunk } from "./asyncChunk";
-
-export type AsyncChunkOpt<T> = {
-  initialData?: T | null;
-  onError?: (error: Error) => void;
-  retryCount?: number;
-  retryDelay?: number;
-}
-
-export type InferAsyncData<T> = T extends AsyncChunk<infer U> ? 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/src/index.ts

@@ -1,10 +0,0 @@
-export { chunk, batch } from './core/core';
-export { asyncChunk } from './core/asyncChunk';
-export { computed } from './core/computed';
-export { select } from './core/selector'
-
-export { combineAsyncChunks, once, isChunk, isValidChunkValue } from './utils';
-
-export type { Chunk, Middleware } from './core/core';
-
-export * as middleware from "./middleware";

package/src/middleware/history.ts

@@ -1,113 +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 function withHistory<T>(
-  baseChunk: Chunk<T>,
-  options: { maxHistory?: number } = {}
-): ChunkWithHistory<T> {
-  const { maxHistory = 100 } = options;
-  const history: T[] = [baseChunk.get()];
-  let currentIndex = 0;
-  let isHistoryAction = false;
-
-  const historyChunk: ChunkWithHistory<T> = {
-    ...baseChunk,
-
-    set: (newValueOrUpdater: T | ((currentValue: T) => T)) => {
-      if (isHistoryAction) {
-        baseChunk.set(newValueOrUpdater);
-        return;
-      }
-
-      // Process the value or updater function
-      let newValue: T;
-      if (typeof newValueOrUpdater === 'function') {
-        // Get current value and apply the updater function
-        const currentValue = baseChunk.get();
-        newValue = (newValueOrUpdater as ((currentValue: T) => T))(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/src/middleware/index.ts

@@ -1,7 +0,0 @@
-// Middleware passed to chunks
-export { logger } from "./logger";
-export { nonNegativeValidator } from "./validator";
-
-// Middleware used with chunks
-export { withHistory } from "./history";
-export { withPersistence } from './persistence';

package/src/middleware/logger.ts

@@ -1,6 +0,0 @@
-import { Middleware } from "../core/core";
-
-export const logger: Middleware<any> = (value, next) => {
-  console.log("Setting value:", value);
-  next(value);
-};

package/src/middleware/persistence.ts

@@ -1,45 +0,0 @@
-import { Chunk } from "../core/core";
-
-export interface PersistOptions<T> {
-  key: string;
-  storage?: Storage;
-  serialize?: (value: T) => string;
-  deserialize?: (value: string) => T;
-}
-
-export function withPersistence<T>(
-  baseChunk: Chunk<T>,
-  options: PersistOptions<T>
-): Chunk<T> {
-  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/src/middleware/validator.ts

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

package/src/use-react/hooks/useAsyncChunk.ts

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

package/src/use-react/hooks/useChunk.ts

@@ -1,40 +0,0 @@
-import { useState, useEffect, useCallback } from "react";
-
-import { select } from "../../core/selector";
-
-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 function useChunk<T, S = T>(
-  chunk: Chunk<T>,
-  selector?: (value: T) => S
-) {
-  const selectedChunk = selector ? select(chunk, selector) : chunk;
-
-  const [state, setState] = useState<S>(() => selectedChunk.get() as S);
-
-  useEffect(() => {
-    const unsubscribe = selectedChunk.subscribe((newValue) => {
-      setState(() => newValue as S);
-    });
-    return () => unsubscribe();
-  }, [selectedChunk]);
-
-  const set = useCallback((valueOrUpdater: T | ((currentValue: T) => T)) => {
-    chunk.set(valueOrUpdater);
-  }, [chunk]);
-
-  const reset = useCallback(() => {
-    chunk.reset();
-  }, [chunk]);
-
-  const destroy = useCallback(() => {
-    chunk.destroy();
-  }, [chunk]);
-
-  return [state, set, reset, destroy] as const;
-}

package/src/use-react/hooks/useChunkProperty.ts

@@ -1,21 +0,0 @@
-import { useMemo } from "react";
-
-import { useChunkValue } from "./useChunkValue";
-
-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 function useChunkProperty<T, K extends keyof T>(
-  chunk: Chunk<T>,
-  property: K
-): T[K] {
-  const selector = useMemo(
-    () => (state: T) => state[property],
-    [property]
-  );
-
-  return useChunkValue(chunk, selector);
-}

package/src/use-react/hooks/useChunkValue.ts

@@ -1,15 +0,0 @@
-import { useChunk } from "./useChunk";
-
-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 function useChunkValue<T, S = T>(
-  chunk: Chunk<T>,
-  selector?: (value: T) => S
-): S {
-  const [value] = useChunk(chunk, selector);
-  return value;
-}