stunk 2.0.0 → 2.2.0

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

package/tests/async-chunk.test.ts

@@ -1,215 +0,0 @@
-import { asyncChunk } from '../src/core/asyncChunk';
-import { combineAsyncChunks } from '../src/utils';
-
-// Mock types for testing
-interface User {
-  id: number;
-  name: string;
-}
-
-interface Post {
-  id: number;
-  title: string;
-}
-
-describe('asyncChunk', () => {
-  // Helper to create a delayed response
-  const createDelayedResponse = <T>(data: T, delay = 50): Promise<T> => {
-    return new Promise((resolve) => setTimeout(() => resolve(data), delay));
-  };
-
-  it('should handle successful async operations', async () => {
-    const mockUser: User = { id: 1, name: 'Test User' };
-    const userChunk = asyncChunk<User>(async () => {
-      return createDelayedResponse(mockUser);
-    });
-
-    // Initial state
-    expect(userChunk.get()).toEqual({
-      loading: true,
-      error: null,
-      data: null
-    });
-
-    // Wait for async operation to complete
-    await new Promise(resolve => setTimeout(resolve, 100));
-
-    // Check final state
-    expect(userChunk.get()).toEqual({
-      loading: false,
-      error: null,
-      data: mockUser
-    });
-  });
-
-  it('should handle errors', async () => {
-    const errorMessage = 'Failed to fetch';
-    const userChunk = asyncChunk<User>(async () => {
-      throw new Error(errorMessage);
-    });
-
-    // Wait for async operation to complete
-    await new Promise(resolve => setTimeout(resolve, 100));
-
-    const state = userChunk.get();
-    expect(state.loading).toBe(false);
-    expect(state.error?.message).toBe(errorMessage);
-    expect(state.data).toBe(null);
-  });
-
-  it('should handle retries', async () => {
-    let attempts = 0;
-    const mockUser: User = { id: 1, name: 'Test User' };
-
-    const userChunk = asyncChunk<User>(
-      async () => {
-        attempts++;
-        if (attempts < 3) {
-          throw new Error('Temporary error');
-        }
-        return mockUser;
-      },
-      { retryCount: 2, retryDelay: 50 }
-    );
-
-    // Wait for all retries to complete
-    await new Promise(resolve => setTimeout(resolve, 200));
-
-    expect(attempts).toBe(3);
-    expect(userChunk.get().data).toEqual(mockUser);
-  });
-
-  it('should support optimistic updates via mutate', () => {
-    const mockUser: User = { id: 1, name: 'Test User' };
-    const userChunk = asyncChunk<User>(async () => mockUser);
-
-    userChunk.mutate(current => ({
-      ...current!,
-      name: 'Updated Name'
-    }));
-
-    const state = userChunk.get();
-    expect(state.data?.name).toBe('Updated Name');
-  });
-
-  it('should reload data when requested', async () => {
-    let counter = 0;
-    const userChunk = asyncChunk<User>(async () => {
-      counter++;
-      return { id: counter, name: `User ${counter}` };
-    });
-
-    // Wait for initial load
-    await new Promise(resolve => setTimeout(resolve, 100));
-    expect(userChunk.get().data?.id).toBe(1);
-
-    // Trigger reload
-    await userChunk.reload();
-    expect(userChunk.get().data?.id).toBe(2);
-  });
-});
-
-describe('combineAsyncChunks', () => {
-  it('should combine multiple async chunks', async () => {
-    const mockUser: User = { id: 1, name: 'Test User' };
-    const mockPosts: Post[] = [
-      { id: 1, title: 'Post 1' },
-      { id: 2, title: 'Post 2' }
-    ];
-
-    const userChunk = asyncChunk<User>(async () => {
-      return createDelayedResponse(mockUser, 50);
-    });
-
-    const postsChunk = asyncChunk<Post[]>(async () => {
-      return createDelayedResponse(mockPosts, 100);
-    });
-
-    const combined = combineAsyncChunks({
-      user: userChunk,
-      posts: postsChunk
-    });
-
-    // Initial state
-    expect(combined.get()).toEqual({
-      loading: true,
-      error: null,
-      data: {
-        user: null,
-        posts: null
-      }
-    });
-
-    // Wait for all async operations to complete
-    await new Promise(resolve => setTimeout(resolve, 150));
-
-    // Check final state
-    expect(combined.get()).toEqual({
-      loading: false,
-      error: null,
-      data: {
-        user: mockUser,
-        posts: mockPosts
-      }
-    });
-  });
-
-  it('should handle errors in combined chunks', async () => {
-    const mockUser: User = { id: 1, name: 'Test User' };
-    const errorMessage = 'Failed to fetch posts';
-
-    const userChunk = asyncChunk<User>(async () => {
-      return createDelayedResponse(mockUser, 50);
-    });
-
-    const postsChunk = asyncChunk<Post[]>(async () => {
-      throw new Error(errorMessage);
-    });
-
-    const combined = combineAsyncChunks({
-      user: userChunk,
-      posts: postsChunk
-    });
-
-    // Wait for all operations to complete
-    await new Promise(resolve => setTimeout(resolve, 150));
-
-    const state = combined.get();
-    expect(state.loading).toBe(false);
-    expect(state.error?.message).toBe(errorMessage);
-    expect(state.data.user).toEqual(mockUser);
-    expect(state.data.posts).toBe(null);
-  });
-
-  it('should update loading state correctly', async () => {
-    const loadingStates: boolean[] = [];
-    const userChunk = asyncChunk<User>(async () => {
-      return createDelayedResponse({ id: 1, name: 'Test User' }, 50);
-    });
-
-    const postsChunk = asyncChunk<Post[]>(async () => {
-      return createDelayedResponse([], 100);
-    });
-
-    const combined = combineAsyncChunks({
-      user: userChunk,
-      posts: postsChunk
-    });
-
-    combined.subscribe(state => {
-      loadingStates.push(state.loading);
-    });
-
-    // Wait for all operations
-    await new Promise(resolve => setTimeout(resolve, 150));
-
-    // Should start with loading true and end with false
-    expect(loadingStates[0]).toBe(true);
-    expect(loadingStates[loadingStates.length - 1]).toBe(false);
-  });
-});
-
-// Helper function
-function createDelayedResponse<T>(data: T, delay = 50): Promise<T> {
-  return new Promise((resolve) => setTimeout(() => resolve(data), delay));
-}

package/tests/batch-chunk.test.ts

@@ -1,108 +0,0 @@
-import { chunk, batch } from '../src/core/core';
-
-
-describe('Chunk batch updates', () => {
-  it('should batch multiple updates into a single notification', () => {
-    const countChunk = chunk(0);
-    const callback = jest.fn();
-
-    countChunk.subscribe(callback);
-    callback.mockClear(); // Clear initial subscription call
-
-    batch(() => {
-      countChunk.set(1);
-      countChunk.set(2);
-      countChunk.set(3); // Should only notify once
-    });
-
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenLastCalledWith(3);
-  });
-
-  it('should handle nested batch calls', () => {
-    const countChunk = chunk(0);
-    const callback = jest.fn();
-
-    countChunk.subscribe(callback);
-    callback.mockClear();
-
-    batch(() => {
-      countChunk.set(1); // Should not notify yet
-      batch(() => {
-        countChunk.set(2);
-        countChunk.set(3);
-      });
-      countChunk.set(4);
-    });
-
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenLastCalledWith(4);
-  });
-
-  it('should handle errors in batch without breaking state', () => {
-    const countChunk = chunk(0);
-    const callback = jest.fn();
-
-    countChunk.subscribe(callback);
-    callback.mockClear();
-
-    expect(() => {
-      batch(() => {
-        countChunk.set(1);
-        throw new Error('Test error');
-        // countChunk.set(2);
-      });
-    }).toThrow('Test error');
-
-    expect(callback).toHaveBeenCalledTimes(1);
-    expect(callback).toHaveBeenLastCalledWith(1);
-    expect(countChunk.get()).toBe(1);
-  });
-
-  it('should work with multiple chunks in the same batch', () => {
-    const chunk1 = chunk(0);
-    const chunk2 = chunk(0);
-    const callback1 = jest.fn();
-    const callback2 = jest.fn();
-
-    chunk1.subscribe(callback1);
-    chunk2.subscribe(callback2);
-    callback1.mockClear();
-    callback2.mockClear();
-
-    batch(() => {
-      chunk1.set(1);
-      chunk2.set(1);
-      chunk1.set(2);
-      chunk2.set(2);
-    });
-
-    expect(callback1).toHaveBeenCalledTimes(1);
-    expect(callback2).toHaveBeenCalledTimes(1);
-    expect(callback1).toHaveBeenLastCalledWith(2);
-    expect(callback2).toHaveBeenLastCalledWith(2);
-  });
-
-  it('should handle derived chunks in batch updates', () => {
-    const sourceChunk = chunk(0);
-    const derivedChunk = sourceChunk.derive(x => x * 2);
-    const sourceCallback = jest.fn();
-    const derivedCallback = jest.fn();
-
-    sourceChunk.subscribe(sourceCallback);
-    derivedChunk.subscribe(derivedCallback);
-    sourceCallback.mockClear();
-    derivedCallback.mockClear();
-
-    batch(() => {
-      sourceChunk.set(1);
-      sourceChunk.set(2);
-      sourceChunk.set(3);
-    });
-
-    expect(sourceCallback).toHaveBeenCalledTimes(1);
-    expect(derivedCallback).toHaveBeenCalledTimes(1);
-    expect(sourceCallback).toHaveBeenLastCalledWith(3);
-    expect(derivedCallback).toHaveBeenLastCalledWith(6);
-  });
-});