stunk 2.1.0 → 2.2.0

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

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

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

package/dist/tests/history.test.js

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

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

package/dist/tests/middleware.test.js

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

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

package/dist/tests/persist.test.js

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

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

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

@@ -0,0 +1,167 @@
+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();
+    });
+});

package/package.json

@@ -1,91 +1,97 @@
-{
-  "name": "stunk",
-  "version": "2.1.0",
-  "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",
-    "prepublishOnly": "vitest && tsc",
-    "prepare": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/I-am-abdulazeez/stunk"
-  },
-  "homepage": "https://stunk.vercel.app/",
-  "bugs": {
-    "url": "https://github.com/I-am-abdulazeez/stunk/issues"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./middleware": {
-      "import": "./dist/middleware/index.js",
-      "types": "./dist/types/middleware/index.d.ts"
-    },
-    "./react": {
-      "import": "./dist/use-react/index.js",
-      "types": "./dist/types/use-react/index.d.ts"
-    },
-    "./vue": {
-      "import": "./dist/use-vue/index.js",
-      "types": "./dist/types/use-vue/index.d.ts"
-    }
-  },
-  "keywords": [
-    "state-management",
-    "atomic-state",
-    "chunk-based state",
-    "framework-agnostic",
-    "reactive state library",
-    "frontend state management",
-    "JavaScript state management",
-    "TypeScript state management",
-    "React state management",
-    "Vue state management",
-    "Svelte state management",
-    "recoil alternative",
-    "jotai alternative",
-    "zustand alternative",
-    "lightweight state management",
-    "state container",
-    "reusable state",
-    "efficient state updates",
-    "performance optimization",
-    "stunk",
-    "chunk"
-  ],
-  "author": "AbdulAzeez",
-  "contributors": [
-    {
-      "name": "AbdulAzeez",
-      "url": "https://github.com/I-am-abdulazeez"
-    }
-  ],
-  "license": "MIT",
-  "devDependencies": {
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/react": "^16.2.0",
-    "@testing-library/vue": "^8.1.0",
-    "@types/react": "^19.0.10",
-    "@vitejs/plugin-react": "^4.3.4",
-    "@vitejs/plugin-vue": "^5.2.1",
-    "jsdom": "^26.0.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^3.0.8",
-    "vue": "^3.5.13"
-  },
-  "peerDependencies": {
-    "react": "^19.0.0",
-    "vue": "^3.5.13"
-  }
-}
+{
+  "name": "stunk",
+  "version": "2.2.0",
+  "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",
+    "prepublishOnly": "vitest && tsc",
+    "prepare": "npm run build",
+    "lint": "eslint . --ext .js,.ts,.tsx,.vue"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/I-am-abdulazeez/stunk"
+  },
+  "homepage": "https://stunk.vercel.app/",
+  "bugs": {
+    "url": "https://github.com/I-am-abdulazeez/stunk/issues"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./middleware": {
+      "import": "./dist/middleware/index.js",
+      "types": "./dist/types/middleware/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/use-react/index.js",
+      "types": "./dist/types/use-react/index.d.ts"
+    },
+    "./vue": {
+      "import": "./dist/use-vue/index.js",
+      "types": "./dist/types/use-vue/index.d.ts"
+    }
+  },
+  "keywords": [
+    "state-management",
+    "atomic-state",
+    "chunk-based state",
+    "framework-agnostic",
+    "reactive state library",
+    "frontend state management",
+    "JavaScript state management",
+    "TypeScript state management",
+    "React state management",
+    "Vue state management",
+    "Svelte state management",
+    "recoil alternative",
+    "jotai alternative",
+    "zustand alternative",
+    "lightweight state management",
+    "state container",
+    "reusable state",
+    "efficient state updates",
+    "performance optimization",
+    "stunk",
+    "chunk"
+  ],
+  "author": "AbdulAzeez",
+  "contributors": [
+    {
+      "name": "AbdulAzeez",
+      "url": "https://github.com/I-am-abdulazeez"
+    }
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.2.0",
+    "@testing-library/vue": "^8.1.0",
+    "@types/react": "^19.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.26.1",
+    "@typescript-eslint/parser": "^8.27.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "@vitejs/plugin-vue": "^5.2.1",
+    "eslint": "^9.22.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "jsdom": "^26.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.8",
+    "vue": "^3.5.13"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "vue": "^3.5.13"
+  }
+}

package/dist/core/computed.js

@@ -1,54 +0,0 @@
-import { chunk } from "./core";
-export function computed(dependencies, computeFn) {
-    const initialValues = dependencies.map(dep => dep.get());
-    let cachedValue = computeFn(...initialValues);
-    let isDirty = false;
-    let lastDependencyValues = [...initialValues];
-    const computedChunk = chunk(cachedValue);
-    const originalSet = computedChunk.set;
-    const recalculate = () => {
-        if (!isDirty)
-            return;
-        const currentValues = dependencies.map(dep => dep.get());
-        const hasChanges = currentValues.some((val, i) => val !== lastDependencyValues[i]);
-        if (hasChanges) {
-            lastDependencyValues = [...currentValues];
-            const newValue = computeFn(...currentValues);
-            if (newValue !== cachedValue) {
-                cachedValue = newValue;
-                originalSet(newValue);
-            }
-        }
-        // Always clear the dirty flag after recalculation
-        isDirty = false;
-    };
-    computedChunk.get = () => {
-        if (isDirty) {
-            recalculate();
-        }
-        return cachedValue;
-    };
-    const unsub = dependencies.map(dep => dep.subscribe(() => {
-        if (!isDirty) {
-            isDirty = true;
-            recalculate();
-        }
-    }));
-    return {
-        ...computedChunk,
-        isDirty: () => isDirty,
-        recompute: () => {
-            isDirty = true;
-            recalculate();
-        },
-        set: () => {
-            throw new Error('Cannot set values directly on computed. Modify the source chunk instead.');
-        },
-        destroy: () => {
-            unsub.forEach(cleanup => cleanup());
-            if (computedChunk.destroy) {
-                computedChunk.destroy();
-            }
-        }
-    };
-}

package/dist/core/selector.d.ts

@@ -1,2 +0,0 @@
-import { Chunk } from "./core";
-export declare function select<T, S>(sourceChunk: Chunk<T>, selector: (value: T) => S): Chunk<S>;

package/dist/core/selector.js

@@ -1,9 +0,0 @@
-import { computed } from "./computed";
-export function select(sourceChunk, selector) {
-    return {
-        ...computed([sourceChunk], (value) => selector(value)),
-        set: () => {
-            throw new Error('Cannot set values directly on a selector. Modify the source chunk instead.');
-        },
-    };
-}