stunk 2.0.0 → 2.1.0

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;
-}

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

@@ -1,35 +0,0 @@
-import { useState, useEffect } from "react";
-
-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 function useChunkValues<T extends Chunk<any>[]>(
-  chunks: [...T]
-): { [K in keyof T]: T[K] extends Chunk<infer U> ? U : never } {
-  type ReturnType = { [K in keyof T]: T[K] extends Chunk<infer U> ? U : never };
-
-  const [values, setValues] = useState<ReturnType>(() => {
-    return chunks.map(chunk => chunk.get()) as ReturnType;
-  });
-
-  useEffect(() => {
-    const unsubscribes = chunks.map((chunk, index) => {
-      return chunk.subscribe((newValue) => {
-        setValues(prev => {
-          const newValues = [...prev] as ReturnType;
-          newValues[index] = newValue;
-          return newValues;
-        });
-      });
-    });
-
-    return () => {
-      unsubscribes.forEach(unsubscribe => unsubscribe());
-    };
-  }, [chunks]);
-
-  return values;
-}

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

@@ -1,34 +0,0 @@
-import { useState, useEffect, useMemo } from "react";
-
-import { computed, 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 function useComputed<TDeps extends Chunk<any>[], TResult>(
-  dependencies: [...TDeps],
-  computeFn: (...args: DependencyValues<TDeps>) => TResult
-): TResult {
-  // 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<TResult>(() => computedValue.get());
-
-  useEffect(() => {
-    const unsubscribe = computedValue.subscribe((newValue) => {
-      setState(newValue);
-    });
-
-    return () => {
-      unsubscribe();
-    };
-  }, [computedValue]);
-
-  return state;
-}

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

@@ -1,15 +0,0 @@
-import { useMemo } from "react";
-
-import { useChunk } from "./useChunk";
-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 function useDerive<T, D>(chunk: Chunk<T>, fn: (value: T) => D): D {
-  const derivedChunk = useMemo(() => chunk.derive(fn), [chunk, fn]);
-  const [derivedValue] = useChunk(derivedChunk);
-
-  return derivedValue;
-}

package/src/use-react/index.ts

@@ -1,9 +0,0 @@
-export { useChunk } from './hooks/useChunk'
-export { useDerive } from './hooks/useDerive'
-export { useComputed } from './hooks/useComputed'
-
-export { useChunkValue } from './hooks/useChunkValue'
-export { useChunkProperty } from './hooks/useChunkProperty'
-export { useChunkValues } from './hooks/useChunkValues'
-
-export { useAsyncChunk } from './hooks/useAsyncChunk'

package/src/utils.ts

@@ -1,103 +0,0 @@
-import { chunk, Chunk, Middleware } from "./core/core";
-
-import { AsyncChunk } from "./core/asyncChunk";
-import { CombinedData, CombinedState, InferAsyncData } from "./core/types";
-
-export function isValidChunkValue(value: any): boolean {
-  return value !== null && value !== undefined;
-}
-
-export function isChunk<T>(value: any): value is Chunk<T> {
-  return value &&
-    typeof value.get === 'function' &&
-    typeof value.set === 'function' &&
-    typeof value.update === 'function' &&
-    typeof value.subscribe === 'function' &&
-    typeof value.derive === 'function' &&
-    typeof value.reset === 'function' &&
-    typeof value.destroy === 'function';
-}
-
-export function once<T>(fn: () => T): () => T {
-  let called = false;
-  let result: T;
-  return () => {
-    if (!called) {
-      result = fn();
-      called = true;
-    }
-    return result;
-  };
-};
-
-export 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 };
-}> {
-  // Create initial state with proper typing
-  const initialData = Object.keys(chunks).reduce((acc, key) => {
-    acc[key as keyof T] = null;
-    return acc;
-  }, {} as CombinedData<T>);
-
-  const initialState: CombinedState<T> = {
-    loading: true,
-    error: null,
-    data: initialData
-  };
-
-  const combined = chunk(initialState);
-
-  Object.entries(chunks).forEach(([key, asyncChunk]) => {
-    asyncChunk.subscribe((state) => {
-      const currentState = combined.get();
-
-      combined.set({
-        loading: Object.values(chunks).some(chunk => chunk.get().loading),
-        error: Object.values(chunks)
-          .map(chunk => chunk.get().error)
-          .find(error => error !== null) || null,
-        data: {
-          ...currentState.data,
-          [key]: state.data
-        },
-      });
-    });
-  });
-
-  return combined;
-}
-
-export function processMiddleware<T>(initialValue: T, middleware: Middleware<T>[] = []): T {
-  if (initialValue === null || initialValue === undefined) {
-    throw new Error("Value cannot be null or undefined.");
-  }
-
-  let currentValue = initialValue;
-  let index = 0;
-
-  while (index < middleware.length) {
-    const currentMiddleware = middleware[index];
-    let nextCalled = false;
-    let nextValue: T | null = null;
-
-    currentMiddleware(currentValue, (val) => {
-      nextCalled = true;
-      nextValue = val;
-    });
-
-    if (!nextCalled) break;
-
-    if (nextValue === null || nextValue === undefined) {
-      throw new Error("Value cannot be null or undefined.");
-    }
-
-    currentValue = nextValue;
-    index++;
-  }
-
-  return currentValue;
-}