stunk 2.2.0 → 2.2.2

package/dist/index.cjs

@@ -0,0 +1 @@
+module.exports = require("./index.js");

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "stunk",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Stunk is a lightweight, framework-agnostic state management library for JavaScript and TypeScript. It uses chunk-based state units for efficient updates, reactivity, and performance optimization in React, Vue, Svelte, and Vanilla JS/TS applications.",
   "scripts": {
-    "build": "tsc",
-    "test": "vitest",
+    "build": "tsc --project tsconfig.json && npm run build:cjs",
+    "build:cjs": "echo 'module.exports = require(\"./index.js\");' > dist/index.cjs",
+    "test": "tsc --project tsconfig.test.json && vitest",
     "prepublishOnly": "vitest && tsc",
     "prepare": "npm run build",
     "lint": "eslint . --ext .js,.ts,.tsx,.vue"
@@ -26,6 +27,7 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     },
     "./middleware": {
@@ -39,7 +41,8 @@
     "./vue": {
       "import": "./dist/use-vue/index.js",
       "types": "./dist/types/use-vue/index.d.ts"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "keywords": [
     "state-management",

package/dist/tests/async-chunk.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/async-chunk.test.js

@@ -1,164 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { asyncChunk } from '../src/core/asyncChunk';
-import { combineAsyncChunks } from '../src/utils';
-describe('asyncChunk', () => {
-    // Helper to create a delayed response
-    const createDelayedResponse = (data, delay = 50) => {
-        return new Promise((resolve) => setTimeout(() => resolve(data), delay));
-    };
-    it('should handle successful async operations', async () => {
-        const mockUser = { id: 1, name: 'Test User' };
-        const userChunk = asyncChunk(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(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 = { id: 1, name: 'Test User' };
-        const userChunk = asyncChunk(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 = { id: 1, name: 'Test User' };
-        const userChunk = asyncChunk(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(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 = { id: 1, name: 'Test User' };
-        const mockPosts = [
-            { id: 1, title: 'Post 1' },
-            { id: 2, title: 'Post 2' }
-        ];
-        const userChunk = asyncChunk(async () => {
-            return createDelayedResponse(mockUser, 50);
-        });
-        const postsChunk = asyncChunk(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 = { id: 1, name: 'Test User' };
-        const errorMessage = 'Failed to fetch posts';
-        const userChunk = asyncChunk(async () => {
-            return createDelayedResponse(mockUser, 50);
-        });
-        const postsChunk = asyncChunk(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 = [];
-        const userChunk = asyncChunk(async () => {
-            return createDelayedResponse({ id: 1, name: 'Test User' }, 50);
-        });
-        const postsChunk = asyncChunk(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(data, delay = 50) {
-    return new Promise((resolve) => setTimeout(() => resolve(data), delay));
-}

package/dist/tests/batch-chunk.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/batch-chunk.test.js

@@ -1,89 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-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 = vi.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 = vi.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 = vi.fn();
-        countChunk.subscribe(callback);
-        callback.mockClear();
-        expect(() => {
-            batch(() => {
-                countChunk.set(1); // Should trigger callback
-                throw new Error('Test error');
-                // countChunk.set(2); // Unreachable
-            });
-        }).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 = vi.fn();
-        const callback2 = vi.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 = vi.fn();
-        const derivedCallback = vi.fn();
-        sourceChunk.subscribe(sourceCallback);
-        derivedChunk.subscribe(derivedCallback);
-        // Clear mocks after initial calls
-        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/dist/tests/chunk.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/chunk.test.js

@@ -1,215 +0,0 @@
-import { test, expect, describe, it, beforeEach, afterAll, vi } from "vitest";
-import { batch, chunk } from "../src/core/core";
-test("Chunk should get and set values correctly", () => {
-    const chunky = chunk(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(0);
-    const callback = vi.fn();
-    const unsubscribe = chunky.subscribe(callback);
-    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(0);
-    const callback1 = vi.fn();
-    const callback2 = vi.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(0);
-    const callback = vi.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);
-});
-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 = vi.fn();
-        const doubleCountSpy = vi.fn();
-        // Subscribe to both chunks
-        count.subscribe(countSpy);
-        doubleCount.subscribe(doubleCountSpy);
-        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 = vi.fn();
-        doubleCount.subscribe(doubleCountSpy);
-        // Setting the same value
-        count.set(5);
-        expect(doubleCount.get()).toBe(10);
-        expect(doubleCountSpy).toHaveBeenCalledTimes(1);
-    });
-});
-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 = vi.fn();
-    const anotherCallback = vi.fn();
-    beforeEach(() => {
-        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 = vi.fn();
-        const newAnotherCallback = vi.fn();
-        const newCountUnsubscribe = countChunk.subscribe(newCountCallback);
-        const newAnotherUnsubscribe = anotherChunk.subscribe(newAnotherCallback);
-        // Should receive initial values
-        expect(newCountCallback).toHaveBeenCalledWith(0);
-        expect(newAnotherCallback).toHaveBeenCalledWith(0);
-        newCountUnsubscribe();
-        newAnotherUnsubscribe();
-    });
-    afterAll(() => {
-        countChunk.destroy();
-        anotherChunk.destroy();
-    });
-});
-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 notify subscribers only if value changes', () => {
-        const store = chunk(5);
-        const subscriber = vi.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();
-        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', () => {
-        const store = chunk({ 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');
-    });
-});
-describe("Chunk Shallow Check", () => {
-    it('should not notify on same primitive', () => {
-        const numChunk = chunk(1);
-        const callback = vi.fn();
-        numChunk.subscribe(callback);
-        callback.mockClear();
-        batch(() => {
-            numChunk.set(1);
-        });
-        expect(callback).not.toHaveBeenCalled();
-    });
-    it('should notify on primitive change', () => {
-        const numChunk = chunk(1);
-        const callback = vi.fn();
-        numChunk.subscribe(callback);
-        callback.mockClear();
-        batch(() => {
-            numChunk.set(2);
-        });
-        expect(callback).toHaveBeenCalledTimes(1);
-        expect(callback).toHaveBeenLastCalledWith(2);
-    });
-    it('should notify on shallow different objects', () => {
-        const objChunk = chunk({ a: 1 });
-        const callback = vi.fn();
-        objChunk.subscribe(callback);
-        callback.mockClear();
-        batch(() => {
-            objChunk.set({ a: 2 });
-        });
-        expect(callback).toHaveBeenCalledTimes(1);
-        expect(callback).toHaveBeenLastCalledWith({ a: 2 });
-    });
-});

package/dist/tests/computed.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/computed.test.js

@@ -1,192 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { batch, chunk } from '../src/core/core';
-import { computed } from '../src/core/computed';
-function createSubscriber(chunk) {
-    const fn = vi.fn();
-    const cleanup = chunk.subscribe(() => fn(chunk.get()));
-    return { fn, cleanup };
-}
-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);
-        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);
-        expect(sum.get()).toBe(3);
-        num1.set(1);
-        expect(sum.get()).toBe(3);
-    });
-    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 set values directly on computed. Modify the source chunk instead.');
-    });
-    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);
-        sum.recompute(); // Manually recompute
-        expect(sum.get()).toBe(6);
-    });
-    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);
-    });
-    it('should handle nested computed values correctly', () => {
-        const a = chunk(2);
-        const b = chunk(3);
-        const sum = computed([a, b], (x, y) => x + y);
-        const doubled = computed([sum], (s) => s * 2);
-        expect(sum.get()).toBe(5);
-        expect(doubled.get()).toBe(10);
-        a.set(5);
-        expect(sum.get()).toBe(8);
-        expect(doubled.get()).toBe(16);
-        b.set(7);
-        expect(sum.get()).toBe(12);
-        expect(doubled.get()).toBe(24);
-    });
-    it('should notify subscribers when dependencies change', () => {
-        const a = chunk(5);
-        const b = chunk(10);
-        const sum = computed([a, b], (aVal, bVal) => aVal + bVal);
-        const { fn: subscriber, cleanup } = createSubscriber(sum);
-        expect(subscriber).toHaveBeenCalledWith(15);
-        subscriber.mockReset();
-        a.set(7);
-        expect(subscriber).toHaveBeenCalledWith(17);
-        cleanup();
-    });
-    it("should mark computed as dirty when dependencies change", () => {
-        const a = chunk(5);
-        const b = chunk(10);
-        const sum = computed([a, b], (aVal, bVal) => aVal + bVal);
-        expect(sum.isDirty()).toBe(true);
-        a.set(7);
-        expect(sum.isDirty()).toBe(false);
-        expect(sum.get()).toBe(17);
-        expect(sum.isDirty()).toBe(false);
-    });
-    it('should handle notifications properly even when computed value does not change', () => {
-        const a = chunk(5);
-        const b = chunk(10);
-        const alwaysFifteen = computed([a, b], () => 15);
-        const { fn: subscriber, cleanup } = createSubscriber(alwaysFifteen);
-        subscriber.mockReset();
-        a.set(7);
-        expect(alwaysFifteen.get()).toBe(15);
-        cleanup();
-    });
-    it("should not recompute unnecessarily", () => {
-        const a = chunk(4);
-        const b = chunk(6);
-        const computeFn = vi.fn((x, y) => x + y);
-        const sum = computed([a, b], computeFn);
-        expect(sum.get()).toBe(10);
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        batch(() => {
-            a.set(4); // No real change
-            b.set(6); // No real change
-        });
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        batch(() => {
-            a.set(5);
-        });
-        expect(computeFn).toHaveBeenCalledTimes(2);
-    });
-    it('should only compute once on initialization', () => {
-        const a = chunk(1);
-        const b = chunk(2);
-        const computeFn = vi.fn((x, y) => x + y);
-        const sum = computed([a, b], computeFn);
-        expect(sum.get()).toBe(3);
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        sum.get();
-        expect(computeFn).toHaveBeenCalledTimes(1);
-    });
-    it('should not recompute when dependencies change but values stay the same', () => {
-        const a = chunk(4);
-        const b = chunk(6);
-        const computeFn = vi.fn((x, y) => x + y);
-        const sum = computed([a, b], computeFn);
-        expect(sum.get()).toBe(10);
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        a.set(4); // Setting to same value
-        expect(computeFn).toHaveBeenCalledTimes(1); // Should not recompute
-        b.set(6); // Setting to same value
-        expect(computeFn).toHaveBeenCalledTimes(1); // Should not recompute
-    });
-    it('should recompute when dependencies actually change values', () => {
-        const a = chunk(4);
-        const b = chunk(6);
-        const computeFn = vi.fn((x, y) => x + y);
-        const sum = computed([a, b], computeFn);
-        expect(sum.get()).toBe(10);
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        a.set(5); // Real change
-        expect(computeFn).toHaveBeenCalledTimes(2);
-        expect(sum.get()).toBe(11);
-    });
-    it('should work with batched operations', () => {
-        const a = chunk(4);
-        const b = chunk(6);
-        const computeFn = vi.fn((x, y) => x + y);
-        const sum = computed([a, b], computeFn);
-        expect(sum.get()).toBe(10);
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        computeFn.mockClear();
-        batch(() => {
-            a.set(5);
-            b.set(7);
-        });
-        // Only one computation should happen, not two
-        expect(computeFn).toHaveBeenCalledTimes(1);
-        expect(sum.get()).toBe(12);
-    });
-    it('should notify subscribers when dependencies change values', () => {
-        const a = chunk(5);
-        const b = chunk(10);
-        const sum = computed([a, b], (aVal, bVal) => aVal + bVal);
-        const { fn: subscriber, cleanup } = createSubscriber(sum);
-        // Initial notification
-        expect(subscriber).toHaveBeenCalledWith(15);
-        subscriber.mockReset();
-        a.set(7);
-        expect(subscriber).toHaveBeenCalledWith(17);
-        subscriber.mockReset();
-        a.set(7);
-        expect(subscriber).not.toHaveBeenCalled();
-        cleanup();
-    });
-    it('should correctly handle the isDirty state', () => {
-        const a = chunk(5);
-        const b = chunk(10);
-        const sum = computed([a, b], (aVal, bVal) => aVal + bVal);
-        expect(sum.isDirty()).toBe(true);
-        a.set(7);
-        expect(sum.isDirty()).toBe(false);
-        sum.recompute();
-        expect(sum.isDirty()).toBe(false);
-    });
-});

package/dist/tests/diamond-dep.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/diamond-dep.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { chunk } from '../src/core/core';
-import { computed } from '../src/core/computed';
-describe('computed > diamond dependency pattern', () => {
-    it('should handle diamond dependency pattern correctly', () => {
-        // Create the root chunk (A)
-        const root = chunk(1);
-        // Create two intermediate chunks (B and C) that depend on root
-        const left = computed([root], value => value * 2);
-        const right = computed([root], value => value + 5);
-        // Create a final computed chunk (D) that depends on both B and C
-        const final = computed([left, right], (leftValue, rightValue) => `${leftValue}-${rightValue}`);
-        // Verify initial computed values before subscribing
-        expect(root.get()).toBe(1);
-        expect(left.get()).toBe(2); // 1 * 2
-        expect(right.get()).toBe(6); // 1 + 5
-        expect(final.get()).toBe('2-6');
-        // Setup a spy to track updates
-        const subscriber = vi.fn();
-        const unsubscribe = final.subscribe(subscriber);
-        expect(subscriber).toHaveBeenCalledWith('2-6');
-        subscriber.mockClear();
-        // Update the root
-        root.set(4);
-        expect(root.get()).toBe(4);
-        expect(left.get()).toBe(8); // 4 * 2
-        expect(right.get()).toBe(9); // 4 + 5
-        expect(final.get()).toBe('8-9');
-        expect(subscriber).toHaveBeenCalledWith('8-9');
-        // Clean up
-        unsubscribe();
-    });
-    it('should handle complex update chains in diamond patterns', () => {
-        const root = chunk(10);
-        // First level of dependencies
-        const pathA = computed([root], val => val + 5);
-        const pathB = computed([root], val => val * 2);
-        // Second level - depends on both branches
-        const merged = computed([pathA, pathB], (a, b) => ({ sum: a + b, product: a * b }));
-        // Verify initial values before subscribing
-        expect(pathA.get()).toBe(15); // 10 + 5
-        expect(pathB.get()).toBe(20); // 10 * 2
-        expect(merged.get()).toEqual({ sum: 35, product: 300 });
-        // Set up capture for last values only
-        let lastUpdate = null;
-        const updates = [];
-        const unsubscribe = merged.subscribe(val => {
-            lastUpdate = { ...val };
-        });
-        // First update
-        root.set(20);
-        if (lastUpdate)
-            updates.push(lastUpdate);
-        // Verify values after first update
-        expect(pathA.get()).toBe(25); // 20 + 5
-        expect(pathB.get()).toBe(40); // 20 * 2
-        expect(merged.get()).toEqual({ sum: 65, product: 1000 });
-        // Second update
-        root.set(0);
-        if (lastUpdate)
-            updates.push(lastUpdate);
-        // Verify values after second update
-        expect(pathA.get()).toBe(5); // 0 + 5
-        expect(pathB.get()).toBe(0); // 0 * 2
-        expect(merged.get()).toEqual({ sum: 5, product: 0 });
-        // Check that we received both values, ignoring intermediate ones
-        expect(updates).toEqual([
-            { sum: 65, product: 1000 },
-            { sum: 5, product: 0 }
-        ]);
-        // Clean up
-        unsubscribe();
-    });
-});

package/dist/tests/history.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/history.test.js

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-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 = vi.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/dist/tests/middleware.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/middleware.test.js

@@ -1,30 +0,0 @@
-import { describe, beforeEach, vi, afterEach, test, expect } from "vitest";
-import { chunk } from "../src/core/core";
-import { logger } from "../src/middleware/logger";
-import { nonNegativeValidator } from "../src/middleware/validator";
-describe("Middleware Tests", () => {
-    let consoleSpy;
-    beforeEach(() => {
-        consoleSpy = vi.spyOn(console, "log");
-    });
-    afterEach(() => {
-        vi.restoreAllMocks(); // Restores all spies
-        vi.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
-        }
-    });
-    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/dist/tests/persist.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/persist.test.js

@@ -1,43 +0,0 @@
-import { describe, beforeEach, it, expect, vi } from 'vitest';
-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: vi.fn(),
-            setItem: vi.fn(),
-        };
-        const baseChunk = chunk({ count: 0 });
-        withPersistence(baseChunk, {
-            key: 'test-key',
-            storage: mockStorage
-        });
-        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/dist/tests/select-chunk.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/select-chunk.test.js

@@ -1,167 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-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 = vi.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 = vi.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 = vi.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 = vi.fn();
-        const ageSubscriber = vi.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
-    });
-    it("should not update if selected object has the same values (shallow equal)", () => {
-        const source = chunk({ name: "John", details: { age: 25, city: "Lagos" } });
-        const detailsSelector = select(source, (user) => user.details, { useShallowEqual: true });
-        const callback = vi.fn();
-        detailsSelector.subscribe(callback);
-        callback.mockReset();
-        // Setting a new object with the same values
-        source.set({ name: "John", details: { age: 25, city: "Lagos" } });
-        expect(callback).not.toHaveBeenCalled();
-    });
-    // Test without shallow equality
-    it("should update if selected object is new but has same values (without shallow equal)", () => {
-        const source = chunk({ name: "John", details: { age: 25, city: "Lagos" } });
-        // Not using shallow equality here
-        const detailsSelector = select(source, (user) => user.details);
-        const callback = vi.fn();
-        detailsSelector.subscribe(callback);
-        // Reset mock to clear initial call
-        callback.mockReset();
-        // Setting a new object with the same values
-        source.set({ name: "John", details: { age: 25, city: "Lagos" } });
-        expect(callback).toHaveBeenCalledTimes(1);
-    });
-    // Test nested derivation
-    it('should support nested derivation', () => {
-        const source = chunk({ user: { profile: { name: 'John' } } });
-        const profileSelector = select(source, (data) => data.user.profile);
-        const nameSelector = profileSelector.derive(profile => profile.name);
-        expect(nameSelector.get()).toBe('John');
-        source.set({ user: { profile: { name: 'Alice' } } });
-        expect(nameSelector.get()).toBe('Alice');
-    });
-    it('should pass options to nested selectors', () => {
-        const source = chunk({
-            user: {
-                profile: { details: { age: 30, city: 'New York' } }
-            }
-        });
-        const profileSelector = select(source, (data) => data.user.profile, { useShallowEqual: true });
-        const detailsSelector = profileSelector.derive(profile => profile.details);
-        const callback = vi.fn();
-        detailsSelector.subscribe(callback);
-        // Reset mock to clear initial call
-        callback.mockReset();
-        // Update with new object but same values
-        source.set({
-            user: {
-                profile: { details: { age: 30, city: 'New York' } }
-            }
-        });
-        expect(callback).not.toHaveBeenCalled(); // Should NOT trigger due to shallow equality
-    });
-    // Test that set and reset throw errors
-    it('should throw error when trying to set or reset a selector', () => {
-        const source = chunk({ name: 'John' });
-        const nameSelector = select(source, (user) => user.name);
-        expect(() => nameSelector.set('Alice')).toThrow();
-        expect(() => nameSelector.reset()).toThrow();
-    });
-    // Test cleanup
-    it('should unsubscribe from source when destroyed', () => {
-        const source = chunk({ name: 'John' });
-        const nameSelector = select(source, (user) => user.name);
-        const callback = vi.fn();
-        nameSelector.subscribe(callback);
-        // Reset mock to clear initial call
-        callback.mockReset();
-        nameSelector.destroy();
-        source.set({ name: 'Alice' });
-        expect(callback).not.toHaveBeenCalled();
-    });
-});