stunk 2.1.0 → 2.2.0

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

@@ -0,0 +1,164 @@
+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

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

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

@@ -0,0 +1,89 @@
+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

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

package/dist/tests/chunk.test.js

@@ -0,0 +1,215 @@
+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

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

package/dist/tests/computed.test.js

@@ -0,0 +1,192 @@
+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

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