stunk 0.3.0 → 0.7.0

package/src/middleware/history.ts

@@ -0,0 +1,86 @@
+import { Chunk } from "../core/core";
+
+export interface ChunkWithHistory<T> extends Chunk<T> {
+  undo: () => void;
+  redo: () => void;
+  canUndo: () => boolean;
+  canRedo: () => boolean;
+  getHistory: () => T[];
+  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: (newValue: T) => {
+      if (isHistoryAction) {
+        baseChunk.set(newValue);
+        return;
+      }
+
+      // Remove any future history when setting a new value
+      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

@@ -0,0 +1,3 @@
+export { logger } from "./logger";
+export { nonNegativeValidator } from "./validator";
+export { withHistory } from "./history";

package/src/middleware/logger.ts

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

package/src/middleware/validator.ts

@@ -0,0 +1,8 @@
+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/tests/batch-chunk.test.ts

@@ -0,0 +1,108 @@
+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,35 +1,187 @@
-// tests/chunk.test.ts
-
-import { createChunk } from "../src/core";
+import { chunk } from "../src/core/core";
 
 test("Chunk should get and set values correctly", () => {
-  const chunk = createChunk<number>(0);
-  expect(chunk.get()).toBe(0);
-  chunk.set(10);
-  expect(chunk.get()).toBe(10);
+  const chunky = chunk<number>(0);
+  expect(chunky.get()).toBe(0);
+  chunky.set(10);
+  expect(chunky.get()).toBe(10);
 });
 
 test("Chunk should notify subscribers on value change", () => {
-  const chunk = createChunk<number>(0);
+  const chunky = chunk<number>(0);
   const callback = jest.fn();
-  chunk.subscribe(callback);
+  const unsubscribe = chunky.subscribe(callback); // Store unsubscribe function
 
-  chunk.set(5);
+  chunky.set(5);
   expect(callback).toHaveBeenCalledWith(5);
 
-  chunk.set(10);
+  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 chunk = createChunk<number>(0);
+  const chunky = chunk<number>(0);
   const callback = jest.fn();
-  const unsubscribe = chunk.subscribe(callback);
+  const unsubscribe = chunky.subscribe(callback);
+
+  // Initial subscription call
+  expect(callback).toHaveBeenCalledWith(0);
+  expect(callback).toHaveBeenCalledTimes(1);
 
-  chunk.set(5);
+  chunky.set(5);
   expect(callback).toHaveBeenCalledWith(5);
+  expect(callback).toHaveBeenCalledTimes(2);
 
   unsubscribe();
-  chunk.set(10); // No callback should be called now
-  expect(callback).toHaveBeenCalledTimes(1);
+  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/history.test.ts

@@ -0,0 +1,99 @@
+import { batch, 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

@@ -0,0 +1,37 @@
+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/select-chunk.test.ts

@@ -0,0 +1,132 @@
+import { chunk, select } from '../src/core/core';
+
+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/types/stunk.d.ts

@@ -5,7 +5,8 @@ declare module 'stunk' {
     get: () => T;
     set: (value: T) => void;
     subscribe: (callback: Subscriber<T>) => () => void;
+    derive?: <D>(fn: (value: T) => D) => Chunk<D>;
   }
 
-  export function createChunk<T>(initialValue: T): Chunk<T>;
+  export function chunk<T>(initialValue: T): Chunk<T>;
 }