stunk 2.0.0 → 2.1.0

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

package/tests/chunk.test.ts

@@ -1,189 +0,0 @@
-import { chunk } from "../src/core/core";
-
-test("Chunk should get and set values correctly", () => {
-  const chunky = chunk<number>(0);
-  expect(chunky.get()).toBe(0);
-  chunky.set(10);
-  expect(chunky.get()).toBe(10);
-  chunky.set((prev) => prev + 1);
-  expect(chunky.get()).toBe(11);
-});
-
-test("Chunk should notify subscribers on value change", () => {
-  const chunky = chunk<number>(0);
-  const callback = jest.fn();
-  const unsubscribe = chunky.subscribe(callback); // Store unsubscribe function
-
-  chunky.set(5);
-  expect(callback).toHaveBeenCalledWith(5);
-
-  chunky.set(10);
-  expect(callback).toHaveBeenCalledWith(10);
-
-  unsubscribe(); // Ensure cleanup after test
-});
-
-test("Chunk should notify multiple subscribers correctly", () => {
-  const chunky = chunk<number>(0);
-  const callback1 = jest.fn();
-  const callback2 = jest.fn();
-
-  const unsubscribe1 = chunky.subscribe(callback1);
-  const unsubscribe2 = chunky.subscribe(callback2);
-
-
-  chunky.set(10);
-
-  expect(callback1).toHaveBeenCalledWith(10);
-  expect(callback2).toHaveBeenCalledWith(10);
-
-  unsubscribe1();
-  unsubscribe2();
-});
-
-
-test("Chunk should allow unsubscribing from updates", () => {
-  const chunky = chunk<number>(0);
-  const callback = jest.fn();
-  const unsubscribe = chunky.subscribe(callback);
-
-  // Initial subscription call
-  expect(callback).toHaveBeenCalledWith(0);
-  expect(callback).toHaveBeenCalledTimes(1);
-
-  chunky.set(5);
-  expect(callback).toHaveBeenCalledWith(5);
-  expect(callback).toHaveBeenCalledTimes(2);
-
-  unsubscribe();
-  chunky.set(10);
-  expect(callback).toHaveBeenCalledTimes(2); // Still called only twice
-});
-
-describe("Chunk Derivation", () => {
-  it("should create a derived chunk and update it when the original chunk changes", () => {
-    const count = chunk(5);
-    const doubleCount = count.derive((value) => value * 2);
-
-    const countSpy = jest.fn();
-    const doubleCountSpy = jest.fn();
-
-    // Subscribe to both chunks
-    count.subscribe(countSpy);
-    doubleCount.subscribe(doubleCountSpy);
-
-    // Initial values
-    expect(count.get()).toBe(5);
-    expect(doubleCount.get()).toBe(10);
-    expect(countSpy).toHaveBeenCalledWith(5);
-    expect(doubleCountSpy).toHaveBeenCalledWith(10);
-
-    // Update count and verify updates
-    count.set(10);
-    expect(count.get()).toBe(10);
-    expect(doubleCount.get()).toBe(20);
-    expect(countSpy).toHaveBeenCalledWith(10);
-    expect(doubleCountSpy).toHaveBeenCalledWith(20);
-  });
-
-  it("should not update the derived chunk if the original chunk value does not change", () => {
-    const count = chunk(5);
-    const doubleCount = count.derive((value) => value * 2);
-
-    const doubleCountSpy = jest.fn();
-
-    // Subscribe to the derived chunk
-    doubleCount.subscribe(doubleCountSpy);
-
-    // Setting the same value
-    count.set(5);
-    expect(doubleCount.get()).toBe(10); // Derived value should remain the same
-    expect(doubleCountSpy).toHaveBeenCalledTimes(1); // Only initial value
-  });
-});
-
-
-test("Chunk should reset to initial value", () => {
-  const count = chunk(5);
-  count.set(10);
-  expect(count.get()).toBe(10);
-  count.reset();
-  expect(count.get()).toBe(5);
-});
-
-
-describe('Chunk destroy', () => {
-  const countChunk = chunk(0);
-  const anotherChunk = chunk(0);
-  const countCallback = jest.fn();
-  const anotherCallback = jest.fn();
-
-  beforeEach(() => {
-    // Reset the mocks
-    countCallback.mockClear();
-    anotherCallback.mockClear();
-  });
-
-  it('should stop notifying subscribers after destroy is called', () => {
-    // Subscribe to the chunks
-    const countUnsubscribe = countChunk.subscribe(countCallback);
-    const anotherUnsubscribe = anotherChunk.subscribe(anotherCallback);
-
-    // Verify initial subscription calls
-    expect(countCallback).toHaveBeenCalledTimes(1);
-    expect(countCallback).toHaveBeenCalledWith(0);
-    expect(anotherCallback).toHaveBeenCalledTimes(1);
-    expect(anotherCallback).toHaveBeenCalledWith(0);
-
-    // Clear the mocks to start fresh
-    countCallback.mockClear();
-    anotherCallback.mockClear();
-
-    // Cleanup subscriptions before destroy
-    countUnsubscribe();
-    anotherUnsubscribe();
-
-    // Now destroy the chunks - no warning should appear
-    countChunk.destroy();
-    anotherChunk.destroy();
-
-    // Try setting new values after destruction
-    countChunk.set(30);
-    anotherChunk.set(40);
-
-    // Ensure that the subscribers were not notified after destroy
-    expect(countCallback).toHaveBeenCalledTimes(0);
-    expect(anotherCallback).toHaveBeenCalledTimes(0);
-  });
-
-  it('should reset to initial value after destroy', () => {
-    // Set some values
-    countChunk.set(10);
-    anotherChunk.set(20);
-
-    // Destroy the chunks (no subscribers at this point, so no warning)
-    countChunk.destroy();
-    anotherChunk.destroy();
-
-    // Subscribe new callbacks after destroy
-    const newCountCallback = jest.fn();
-    const newAnotherCallback = jest.fn();
-
-    const newCountUnsubscribe = countChunk.subscribe(newCountCallback);
-    const newAnotherUnsubscribe = anotherChunk.subscribe(newAnotherCallback);
-
-    // Should receive initial values
-    expect(newCountCallback).toHaveBeenCalledWith(0);
-    expect(newAnotherCallback).toHaveBeenCalledWith(0);
-
-    // Cleanup
-    newCountUnsubscribe();
-    newAnotherUnsubscribe();
-  });
-
-  // Clean up after all tests
-  afterAll(() => {
-    countChunk.destroy();
-    anotherChunk.destroy();
-  });
-});

package/tests/computed.test.ts

@@ -1,93 +0,0 @@
-import { chunk } from '../src/core/core';
-import { computed } from '../src/core/computed';
-
-describe('computed', () => {
-  it('should compute the value based on dependencies', () => {
-    const num1 = chunk(2);
-    const num2 = chunk(3);
-
-    const sum = computed([num1, num2], (a, b) => a + b);
-
-    expect(sum.get()).toBe(5);
-  });
-
-  it('should recompute when a dependency changes', () => {
-    const num1 = chunk(4);
-    const num2 = chunk(5);
-
-    const product = computed([num1, num2], (a, b) => a * b);
-
-    expect(product.get()).toBe(20);
-
-    num1.set(10);
-
-    // Trigger recomputation
-    expect(product.get()).toBe(50);
-  });
-
-  it('should cache the computed value until a dependency changes', () => {
-    const num1 = chunk(1);
-    const num2 = chunk(2);
-
-    const sum = computed([num1, num2], (a, b) => a + b);
-
-    const initialValue = sum.get();
-    expect(initialValue).toBe(3);
-
-    num1.set(1); // Setting to the same value, should not trigger recompute
-    const cachedValue = sum.get();
-    expect(cachedValue).toBe(3); // Cached value should be returned
-  });
-
-  it('should mark as dirty when a dependency changes', () => {
-    const num1 = chunk(7);
-    const num2 = chunk(8);
-
-    const diff = computed([num1, num2], (a, b) => b - a);
-
-    expect(diff.isDirty()).toBe(false);
-
-    num2.set(10);
-
-    expect(diff.isDirty()).toBe(true);
-  });
-
-  it('should throw error when attempting to set computed value', () => {
-    const num1 = chunk(10);
-    const num2 = chunk(20);
-
-    const sum = computed([num1, num2], (a, b) => a + b);
-
-    expect(() => sum.set(100)).toThrow('Cannot directly set a computed value');
-  });
-
-  it('should manually recompute the value', () => {
-    const num1 = chunk(1);
-    const num2 = chunk(2);
-
-    const sum = computed([num1, num2], (a, b) => a + b);
-
-    expect(sum.get()).toBe(3);
-
-    num1.set(4);
-    expect(sum.isDirty()).toBe(true);
-
-    sum.recompute(); // Manually recompute
-    expect(sum.get()).toBe(6);
-    expect(sum.isDirty()).toBe(false);
-  });
-
-  it('should support multiple dependencies', () => {
-    const a = chunk(2);
-    const b = chunk(3);
-    const c = chunk(4);
-
-    const result = computed([a, b, c], (x, y, z) => x * y + z);
-
-    expect(result.get()).toBe(10);
-
-    b.set(5);
-
-    expect(result.get()).toBe(14);
-  });
-});

package/tests/history.test.ts

@@ -1,99 +0,0 @@
-import { chunk } from "../src/core/core";
-import { withHistory } from "../src/middleware/history";
-
-
-describe('Chunk with History', () => {
-  it('should maintain history of changes', () => {
-    const baseChunk = chunk(0);
-    const historyChunk = withHistory(baseChunk);
-
-    historyChunk.set(1);
-    historyChunk.set(2);
-    historyChunk.set(3);
-
-    expect(historyChunk.getHistory()).toEqual([0, 1, 2, 3]);
-  });
-
-  it('should handle undo and redo operations', () => {
-    const baseChunk = chunk(0);
-    const historyChunk = withHistory(baseChunk);
-    const callback = jest.fn();
-
-    historyChunk.subscribe(callback);
-    callback.mockClear(); // Clear initial subscription call
-
-    historyChunk.set(1);
-    historyChunk.set(2);
-
-    expect(historyChunk.get()).toBe(2);
-
-    historyChunk.undo();
-    expect(historyChunk.get()).toBe(1);
-
-    historyChunk.undo();
-    expect(historyChunk.get()).toBe(0);
-
-    historyChunk.redo();
-    expect(historyChunk.get()).toBe(1);
-
-    historyChunk.redo();
-    expect(historyChunk.get()).toBe(2);
-
-    expect(callback).toHaveBeenCalledTimes(6); // 2 sets + 2 undos + 2 redos
-  });
-
-  it('should handle branching history', () => {
-    const baseChunk = chunk(0);
-    const historyChunk = withHistory(baseChunk);
-
-    historyChunk.set(1);
-    historyChunk.set(2);
-    historyChunk.undo();
-    historyChunk.set(3); // This should create a new branch
-
-    expect(historyChunk.getHistory()).toEqual([0, 1, 3]);
-    expect(historyChunk.get()).toBe(3);
-  });
-
-  it('should respect maxHistory limit', () => {
-    const baseChunk = chunk(0);
-    const historyChunk = withHistory(baseChunk, { maxHistory: 3 });
-
-    historyChunk.set(1);
-    historyChunk.set(2);
-    historyChunk.set(3);
-    historyChunk.set(4);
-
-    expect(historyChunk.getHistory()).toEqual([2, 3, 4]);
-  });
-
-  it('should handle canUndo and canRedo correctly', () => {
-    const baseChunk = chunk(0);
-    const historyChunk = withHistory(baseChunk);
-
-    expect(historyChunk.canUndo()).toBe(false);
-    expect(historyChunk.canRedo()).toBe(false);
-
-    historyChunk.set(1);
-    expect(historyChunk.canUndo()).toBe(true);
-    expect(historyChunk.canRedo()).toBe(false);
-
-    historyChunk.undo();
-    expect(historyChunk.canUndo()).toBe(false);
-    expect(historyChunk.canRedo()).toBe(true);
-  });
-
-  it('should clear history properly', () => {
-    const baseChunk = chunk(0);
-    const historyChunk = withHistory(baseChunk);
-
-    historyChunk.set(1);
-    historyChunk.set(2);
-
-    historyChunk.clearHistory();
-
-    expect(historyChunk.getHistory()).toEqual([2]);
-    expect(historyChunk.canUndo()).toBe(false);
-    expect(historyChunk.canRedo()).toBe(false);
-  });
-});