stunk 2.0.0 → 2.2.0

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

package/tests/middleware.test.ts

@@ -1,37 +0,0 @@
-import { chunk } from "../src/core/core";
-import { logger } from "../src/middleware/logger";
-import { nonNegativeValidator } from "../src/middleware/validator";
-
-describe("Middleware Tests", () => {
-  let consoleSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    consoleSpy = jest.spyOn(console, "log").mockImplementation();
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();  // Restores all spies
-    jest.clearAllTimers();    // Clears any lingering timers
-  });
-
-  test("Logger middleware should log updates", () => {
-    const count = chunk(0, [logger]);
-
-    const unsubscribe = count.subscribe(() => { }); // Subscribe to capture updates
-
-    try {
-      count.set(5); // Should log: "Setting value: 5"
-      expect(consoleSpy).toHaveBeenCalledWith("Setting value:", 5);
-    } finally {
-      unsubscribe(); // Ensure cleanup after test
-      consoleSpy.mockRestore();
-    }
-  });
-
-  test("Non-negative validator middleware should prevent negative values", () => {
-    const count = chunk(0, [nonNegativeValidator]);
-
-    expect(() => count.set(-5)).toThrow("Value must be non-negative!");
-    expect(count.get()).toBe(0); // Value should remain unchanged
-  });
-});

package/tests/persist.test.ts

@@ -1,57 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { chunk } from '../src/core/core';
-import { withPersistence } from "../src/middleware/persistence";
-
-describe('withPersistence', () => {
-  beforeEach(() => {
-    localStorage.clear();
-    sessionStorage.clear();
-  });
-
-  it('should persist state to localStorage', () => {
-    const baseChunk = chunk({ count: 0 });
-    const persistedChunk = withPersistence(baseChunk, { key: 'test-key' });
-
-    persistedChunk.set({ count: 1 });
-    expect(JSON.parse(localStorage.getItem('test-key')!)).toEqual({ count: 1 });
-  });
-
-  it('should load persisted state on initialization', () => {
-    localStorage.setItem('test-key', JSON.stringify({ count: 5 }));
-
-    const baseChunk = chunk({ count: 0 });
-    const persistedChunk = withPersistence(baseChunk, { key: 'test-key' });
-
-    expect(persistedChunk.get()).toEqual({ count: 5 });
-  });
-
-  it('should use custom storage', () => {
-    const mockStorage = {
-      getItem: jest.fn(),
-      setItem: jest.fn(),
-    };
-
-    const baseChunk = chunk({ count: 0 });
-    withPersistence(baseChunk, {
-      key: 'test-key',
-      storage: mockStorage as unknown as Storage
-    });
-
-    expect(mockStorage.getItem).toHaveBeenCalledWith('test-key');
-  });
-
-  it('should use custom serializer/deserializer', () => {
-    const baseChunk = chunk({ count: 0 });
-    const persistedChunk = withPersistence(baseChunk, {
-      key: 'test-key',
-      serialize: value => btoa(JSON.stringify(value)),
-      deserialize: value => JSON.parse(atob(value))
-    });
-
-    persistedChunk.set({ count: 1 });
-    expect(localStorage.getItem('test-key')).toBe(btoa(JSON.stringify({ count: 1 })));
-  });
-});

package/tests/select-chunk.test.ts

@@ -1,133 +0,0 @@
-import { chunk } from '../src/core/core';
-import { select } from '../src/core/selector'
-
-describe('select', () => {
-  it('should create a selector that initially returns the correct value', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    expect(nameSelector.get()).toBe('John');
-  });
-
-  it('should update when selected value changes', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    source.set({ name: 'Jane', age: 25 });
-    expect(nameSelector.get()).toBe('Jane');
-  });
-
-  it('should not notify subscribers when non-selected values change', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    const subscriber = jest.fn();
-    nameSelector.subscribe(subscriber);
-
-    // Reset the mock to ignore initial call
-    subscriber.mockReset();
-
-    // Update age only
-    source.set({ name: 'John', age: 26 });
-
-    expect(subscriber).not.toHaveBeenCalled();
-  });
-
-  it('should notify subscribers when selected value changes', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    const subscriber = jest.fn();
-    nameSelector.subscribe(subscriber);
-
-    // Reset the mock to ignore initial call
-    subscriber.mockReset();
-
-    source.set({ name: 'Jane', age: 25 });
-
-    expect(subscriber).toHaveBeenCalledTimes(1);
-    expect(subscriber).toHaveBeenCalledWith('Jane');
-  });
-
-  it('should prevent direct modifications to selector', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    expect(() => {
-      nameSelector.set('Jane');
-    }).toThrow('Cannot set values directly on a selector');
-  });
-
-  it('should work with complex selectors', () => {
-    const source = chunk({ user: { profile: { name: 'John' } } });
-    const nameSelector = select(source, state => state.user.profile.name);
-
-    expect(nameSelector.get()).toBe('John');
-
-    source.set({ user: { profile: { name: 'Jane' } } });
-    expect(nameSelector.get()).toBe('Jane');
-  });
-
-  it('should handle array selectors', () => {
-    const source = chunk({ items: [1, 2, 3] });
-    const firstItemSelector = select(source, state => state.items[0]);
-
-    expect(firstItemSelector.get()).toBe(1);
-
-    source.set({ items: [4, 2, 3] });
-    expect(firstItemSelector.get()).toBe(4);
-  });
-
-  it('should work with computed values', () => {
-    const source = chunk({ numbers: [1, 2, 3, 4, 5] });
-    const sumSelector = select(source, state =>
-      state.numbers.reduce((sum, num) => sum + num, 0)
-    );
-
-    expect(sumSelector.get()).toBe(15);
-
-    source.set({ numbers: [1, 2, 3] });
-    expect(sumSelector.get()).toBe(6);
-  });
-
-  it('should properly clean up subscriptions on destroy', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    const subscriber = jest.fn();
-    const unsubscribe = nameSelector.subscribe(subscriber);
-
-    // Reset mock to ignore initial call
-    subscriber.mockReset();
-
-    unsubscribe();
-    nameSelector.destroy();
-    source.set({ name: 'Jane', age: 25 });
-
-    expect(subscriber).not.toHaveBeenCalled();
-  });
-
-  it('should work with multiple independent selectors', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-    const ageSelector = select(source, user => user.age);
-
-    const nameSubscriber = jest.fn();
-    const ageSubscriber = jest.fn();
-
-    nameSelector.subscribe(nameSubscriber);
-    ageSelector.subscribe(ageSubscriber);
-
-    // Reset mocks to ignore initial calls
-    nameSubscriber.mockReset();
-    ageSubscriber.mockReset();
-
-    source.set({ name: 'John', age: 26 });
-    expect(nameSubscriber).not.toHaveBeenCalled();
-    expect(ageSubscriber).toHaveBeenCalledWith(26);
-
-    source.set({ name: 'Jane', age: 26 });
-    expect(nameSubscriber).toHaveBeenCalledWith('Jane');
-    expect(ageSubscriber).toHaveBeenCalledTimes(1); // Still from previous update
-  });
-});

package/tests/update.test.ts

@@ -1,70 +0,0 @@
-import { chunk } from '../src/core/core';
-
-describe('chunk update', () => {
-  it('should update value using updater function', () => {
-    const store = chunk(5);
-    store.set(value => value + 1);
-    expect(store.get()).toBe(6);
-  });
-
-  it('should throw error if updater is not a function', () => {
-    const store = chunk(5);
-    // @ts-expect-error Testing invalid input
-    expect(() => store.update('not a function')).toThrow('Updater must be a function');
-  });
-
-  it('should throw error if updater returns null or undefined', () => {
-    const store = chunk(5);
-    // @ts-expect-error Testing invalid input
-    expect(() => store.update(() => null)).toThrow('Value cannot be null or undefined.');
-    // @ts-expect-error Testing invalid input
-    expect(() => store.update(() => undefined)).toThrow('Value cannot be null or undefined.');
-  });
-
-  it('should notify subscribers only if value changes', () => {
-    const store = chunk(5);
-    const subscriber = jest.fn();
-    store.subscribe(subscriber);
-
-    // Reset the mock to ignore initial subscription call
-    subscriber.mockReset();
-
-    // Update to same value
-    store.set(value => value);
-    expect(subscriber).not.toHaveBeenCalled();
-
-    // Update to new value
-    store.set(value => value + 1);
-    expect(subscriber).toHaveBeenCalledWith(6);
-    expect(subscriber).toHaveBeenCalledTimes(1);
-  });
-
-  it('should handle complex update logic', () => {
-    const store = chunk(5);
-    store.set(value => {
-      if (value > 3) {
-        return value * 2;
-      }
-      return value + 1;
-    });
-    expect(store.get()).toBe(10);
-  });
-
-  it('should maintain type safety', () => {
-    interface User {
-      name: string;
-      age: number;
-    }
-
-    const store = chunk<User>({ name: 'John', age: 30 });
-
-    store.set(user => ({
-      ...user,
-      age: user.age + 1
-    }));
-
-    const user = store.get();
-    expect(user.age).toBe(31);
-    expect(user.name).toBe('John');
-  });
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "baseUrl": "./src",
-    "paths": {
-      "stunk/middleware": ["middleware"],
-      "stunk/react": ["use-react"]
-    },
-    "typeRoots": ["./node_modules/@types", "./types"],
-    "strict": true,
-    "skipLibCheck": true,
-    "jsx": "react",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}