stunk 0.2.0 → 0.6.0

package/README.md

@@ -1,18 +1,27 @@
 # Stunk
 
-**Stunk** is a framework-agnostic state management library implementing the **Atomic State technique**, utilizing chunk-based units for efficient state management. Whether you're building applications in plain JavaScript/TypeScript, React, Vue, Svelte, or any other modern framework, **Stunk** can seamlessly fit into your project.
+**Stunk** is a **framework-agnostic** state management library that helps you manage your application's state in a clean and simple way. It uses a technique called **Atomic State**, breaking down state into smaller **chunks** that are easy to update, subscribe to, and manage.
+
+---
 
 ## Pronunciation and Meaning
 
 - **Pronunciation**: _Stunk_ (A playful blend of "state" and "chunk")
 - **Meaning**: "Stunk" represents the combination of state management with chunk-based atomic units. The term captures the essence of atomic state management while using "chunk" to refer to these discrete units of state.
 
-## Features
+## What is Stunk?
+
+Think of your application's state as a big jar of data. In traditional state management, you keep everything in one big jar, and every time you want to change something, you have to dig through the whole jar.
+
+**Stunk** is like dividing your jar into many smaller containers, each holding a single piece of state. These smaller containers are called **chunks**. Each **chunk** can be updated and accessed easily, and any part of your app can subscribe to changes in a chunk so it gets updated automatically.
+
+### Why Stunk
+
+- lightweight, framework-agnostic state management.
+- granular control over state updates and subscriptions.
+- modular and composable state architecture.
 
-- **Framework-agnostic**: Use it in any JavaScript/TypeScript application, regardless of framework.
-- **Atomic State technique**: Implements state management using atomic units (chunks) that are discrete and easily manageable.
-- **TypeScript support**: Fully typed for better developer experience and type safety.
-- **Easy to use**: Simple API for creating, getting, and updating state.
+---
 
 ## Installation
 
@@ -21,3 +30,174 @@ You can install **Stunk** from NPM:
 ```bash
 npm install stunk
 ```
+
+## 1 Features
+
+### 1.0 **Chunks**
+
+A **chunk** is a small container of state. It holds a value, and you can do three things with it:
+
+- **Get** the current value of the chunk
+- **Set** a new value for the chunk
+- **Subscribe** to the chunk to get notified whenever the value changes
+
+### Usage:
+
+```ts
+import { chunk } from "stunk";
+
+const count = chunk(0);
+
+console.log(count.get()); // 0
+
+count.set(5);
+
+console.log(count.get()); // 5
+```
+
+### 1.1. **Subscription**
+
+You can **subscribe** to a **chunk**. This means you get notified whenever the value inside the chunk changes. This is super useful for updating your app automatically when **state** changes.
+
+### Usage
+
+```ts
+const count = chunk(0);
+const callback = (newValue: number) => console.log("Updated value:", newValue);
+
+count.subscribe(callback);
+
+count.set(10); // Will log: "Updated value: 10"
+```
+
+### 1.2. **Deriving New Chunks**
+
+With Stunk, you can create **derived chunks**. This means you can create a new **chunk** based on the value of another **chunk**. When the original **chunk** changes, the **derived chunk** will automatically update.
+
+### Usage
+
+```ts
+const count = chunk(5);
+
+// Create a derived chunk that doubles the count
+const doubleCount = count.derive((value) => value * 2);
+
+count.subscribe((newValue) => console.log("Count:", newValue));
+doubleCount.subscribe((newValue) => console.log("Double count:", newValue));
+
+count.set(10);
+// Will log:
+// "Count: 10"
+// "Double count: 20"
+```
+
+### 1.3. **Unsubscribing**
+
+You can **unsubscribe** from a **chunk**, which means you stop getting notifications when the **value changes**. You can do this by calling the function that's returned when you **subscribe..** Well, would you wanna do that? 😂
+
+### Usage
+
+```ts
+const count = chunk(0);
+const callback = (newValue: number) => console.log("Updated value:", newValue);
+
+const unsubscribe = count.subscribe(callback);
+
+count.set(10); // Will log: "Updated value: 10"
+
+unsubscribe(); // Unsubscribe
+
+count.set(20); // Nothing will happen now, because you unsubscribed
+```
+
+### 1.4. **Batch Updates**
+
+Batch updates allow you to group multiple **state changes** together and notify **subscribers** only once at the end of the **batch**. This is particularly useful for **optimizing performance** when you need to **update multiple** chunks at the same time.
+
+### Usage
+
+```ts
+import { chunk, batch } from "stunk";
+
+const firstName = chunk("John");
+const lastName = chunk("Doe");
+const age = chunk(25);
+
+// Subscribe to changes
+firstName.subscribe((name) => console.log("First name changed:", name));
+lastName.subscribe((name) => console.log("Last name changed:", name));
+age.subscribe((age) => console.log("Age changed:", age));
+
+// Without batch - triggers three separate updates
+firstName.set("Jane"); // Logs immediately
+lastName.set("Smith"); // Logs immediately
+age.set(26); // Logs immediately
+
+// With batch - triggers only one update per chunk at the end
+batch(() => {
+  firstName.set("Jane"); // Doesn't log yet
+  lastName.set("Smith"); // Doesn't log yet
+  age.set(26); // Doesn't log yet
+}); // All logs happen here at once
+
+// Nested batches are also supported
+batch(() => {
+  firstName.set("Jane");
+  batch(() => {
+    lastName.set("Smith");
+    age.set(26);
+  });
+});
+```
+
+Looks intresting right? There's more!
+
+Batching is particularly useful when:
+
+- Updating multiple related pieces of state at once
+- Performing form updates
+- Handling complex state transitions
+- Optimizing performance in data-heavy applications
+
+The batch function ensures that:
+
+- All updates within the batch are processed together
+- Subscribers are notified only once with the final value
+- Nested batches are handled correctly
+- Updates are processed even if an error occurs (using try/finally)
+
+### 1.5. **Middleware**
+
+Middleware allows you to customize how values are set in a **chunk**. For example, you can add **logging**, **validation**, or any custom behavior when a chunk's value changes.
+
+A middleware is a function with the following structure:
+
+```ts
+export type Middleware<T> = (value: T, next: (newValue: T) => void) => void;
+```
+
+- value: The value that is about to be set to the chunk.
+- next(value): A function you must call with the processed (or unaltered) value to continue the chain of middleware and eventually update the chunk's state.
+
+### Usage
+
+```ts
+import { chunk } from "stunk";
+import { logger } from "stunk/middleware"; // native to stunk
+import { nonNegativeValidator } from "stunk/middleware"; // native to stunk
+// You can also create yours and pass it []
+
+// Use middleware for logging and validation
+const age = chunk(25, [logger, nonNegativeValidator]);
+
+age.set(30); // Logs: "Setting value: 30"
+age.set(-5); // Throws an error: "Value must be non-negative!"
+```
+
+## 2. **Atomic State Technique**
+
+The **Atomic State** technique is all about breaking down your state into small, manageable chunks. This allows you to:
+
+- Keep state changes focused and efficient
+- Update only the parts of your app that need to change
+- Easily manage and subscribe to state changes

package/dist/core.js

@@ -1,23 +1,106 @@
-export function createChunk(initialValue) {
+let batchDepth = 0;
+const batchQueue = new Set();
+export function batch(callback) {
+    batchDepth++;
+    try {
+        callback();
+    }
+    finally {
+        batchDepth--;
+        if (batchDepth === 0) {
+            // Execute all queued updates
+            batchQueue.forEach(update => update());
+            batchQueue.clear();
+        }
+    }
+}
+export function chunk(initialValue, middleware = []) {
+    if (initialValue === undefined || initialValue === null) {
+        throw new Error("Initial value cannot be undefined or null.");
+    }
     let value = initialValue;
-    const subscribers = [];
+    const subscribers = new Set();
+    let isDirty = false;
     const get = () => value;
+    const notifySubscribers = () => {
+        if (batchDepth > 0) {
+            if (!isDirty) {
+                isDirty = true;
+                batchQueue.add(() => {
+                    if (isDirty) {
+                        subscribers.forEach((subscriber) => subscriber(value));
+                        isDirty = false;
+                    }
+                });
+            }
+        }
+        else {
+            subscribers.forEach((subscriber) => subscriber(value));
+        }
+    };
     const set = (newValue) => {
-        if (newValue !== value) {
-            value = newValue;
-            subscribers.forEach((subscriber) => subscriber(value)); // Notify all subscribers
+        if (newValue === null || newValue === undefined) {
+            throw new Error("Value cannot be null or undefined.");
+        }
+        let currentValue = newValue;
+        let index = 0;
+        while (index < middleware.length) {
+            const currentMiddleware = middleware[index];
+            let nextCalled = false;
+            let nextValue = null;
+            currentMiddleware(currentValue, (val) => {
+                nextCalled = true;
+                nextValue = val;
+            });
+            if (!nextCalled)
+                break;
+            if (nextValue === null || nextValue === undefined) {
+                throw new Error("Value cannot be null or undefined.");
+            }
+            currentValue = nextValue;
+            index++;
+        }
+        if (currentValue !== value) {
+            value = currentValue;
+            notifySubscribers();
         }
     };
     const subscribe = (callback) => {
-        subscribers.push(callback);
-        callback(value); // Immediately notify on subscription
-        // Return unsubscribe function
+        if (typeof callback !== "function") {
+            throw new Error("Callback must be a function.");
+        }
+        if (subscribers.has(callback)) {
+            console.warn("Callback is already subscribed. This may lead to duplicate updates.");
+        }
+        subscribers.add(callback);
+        callback(value);
         return () => {
-            const index = subscribers.indexOf(callback);
-            if (index >= 0) {
-                subscribers.splice(index, 1);
-            }
+            subscribers.delete(callback);
         };
     };
-    return { get, set, subscribe };
+    const reset = () => {
+        value = initialValue;
+        subscribers.forEach((subscriber) => subscriber(value));
+    };
+    const destroy = () => {
+        if (subscribers.size > 0) {
+            console.warn("Destroying chunk with active subscribers. This may lead to memory leaks.");
+        }
+        // Just clear subscribers without calling unsubscribe
+        subscribers.clear();
+        value = initialValue;
+    };
+    const derive = (fn) => {
+        if (typeof fn !== "function") {
+            throw new Error("Derive function must be a function.");
+        }
+        const derivedValue = fn(value);
+        const derivedChunk = chunk(derivedValue);
+        subscribe(() => {
+            const newDerivedValue = fn(value);
+            derivedChunk.set(newDerivedValue);
+        });
+        return derivedChunk;
+    };
+    return { get, set, subscribe, derive, reset, destroy };
 }

package/dist/index.js

@@ -1,2 +1,3 @@
-// src/index.ts
-export { createChunk } from './core';
+export { chunk } from './core';
+export { logger } from "./middleware/logger";
+export { nonNegativeValidator } from "./middleware/validator";

package/dist/middleware/logger.js

@@ -0,0 +1,4 @@
+export const logger = (value, next) => {
+    console.log("Setting value:", value);
+    next(value);
+};

package/dist/middleware/validator.js

@@ -0,0 +1,6 @@
+export const nonNegativeValidator = (value, next) => {
+    if (value < 0) {
+        throw new Error("Value must be non-negative!");
+    }
+    next(value); // If validation passes, proceed with the update
+};

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "stunk",
-  "version": "0.2.0",
+  "version": "0.6.0",
   "description": "Stunk - A framework-agnostic state management library implementing the Atomic State technique, utilizing chunk-based units for efficient state management.",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "test": "jest",
+    "test": "jest --runInBand",
     "prepare": "npm run build"
   },
   "keywords": [
     "state-management",
     "atomic-state",
     "framework-agnostic",
-    "dàrá"
+    "stunk",
+    "state",
+    "chunk"
   ],
   "author": "AbdulAzeez",
   "license": "MIT",

package/src/core.ts

@@ -1,36 +1,144 @@
 export type Subscriber<T> = (newValue: T) => void;
+export type Middleware<T> = (value: T, next: (newValue: T) => void) => void;
 
 export interface Chunk<T> {
+  /** Get the current value of the chunk. */
   get: () => T;
+  /** Set a new value for the chunk. */
   set: (value: T) => void;
+  /** Subscribe to changes in the chunk. Returns an unsubscribe function. */
   subscribe: (callback: Subscriber<T>) => () => void;
+  /** Create a derived chunk based on this chunk's value. */
+  derive: <D>(fn: (value: T) => D) => Chunk<D>;
+  /** Reset the chunk to its initial value. */
+  reset: () => void;
+  /** Destroy the chunk and all its subscribers. */
+  destroy: () => void;
 }
 
-export function createChunk<T>(initialValue: T): Chunk<T> {
+let batchDepth = 0;
+const batchQueue = new Set<() => void>();
+
+export function batch(callback: () => void) {
+  batchDepth++;
+  try {
+    callback();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      // Execute all queued updates
+      batchQueue.forEach(update => update());
+      batchQueue.clear();
+    }
+  }
+}
+
+
+export function chunk<T>(initialValue: T, middleware: Middleware<T>[] = []): Chunk<T> {
+  if (initialValue === undefined || initialValue === null) {
+    throw new Error("Initial value cannot be undefined or null.");
+  }
+
   let value = initialValue;
-  const subscribers: Subscriber<T>[] = [];
+  const subscribers = new Set<Subscriber<T>>();
+  let isDirty = false;
 
   const get = () => value;
 
+  const notifySubscribers = () => {
+    if (batchDepth > 0) {
+      if (!isDirty) {
+        isDirty = true;
+        batchQueue.add(() => {
+          if (isDirty) {
+            subscribers.forEach((subscriber) => subscriber(value));
+            isDirty = false;
+          }
+        });
+      }
+    } else {
+      subscribers.forEach((subscriber) => subscriber(value));
+    }
+  }
+
   const set = (newValue: T) => {
-    if (newValue !== value) {
-      value = newValue;
-      subscribers.forEach((subscriber) => subscriber(value)); // Notify all subscribers
+    if (newValue === null || newValue === undefined) {
+      throw new Error("Value cannot be null or undefined.");
+    }
+
+    let currentValue = newValue;
+    let index = 0;
+
+    while (index < middleware.length) {
+      const currentMiddleware = middleware[index];
+      let nextCalled = false;
+      let nextValue: T | null = null;
+
+      currentMiddleware(currentValue, (val) => {
+        nextCalled = true;
+        nextValue = val;
+      });
+
+      if (!nextCalled) break;
+
+      if (nextValue === null || nextValue === undefined) {
+        throw new Error("Value cannot be null or undefined.");
+      }
+
+      currentValue = nextValue;
+      index++;
+    }
+
+    if (currentValue !== value) {
+      value = currentValue;
+      notifySubscribers();
     }
   };
 
   const subscribe = (callback: Subscriber<T>) => {
-    subscribers.push(callback);
-    callback(value); // Immediately notify on subscription
+    if (typeof callback !== "function") {
+      throw new Error("Callback must be a function.");
+    }
+    if (subscribers.has(callback)) {
+      console.warn("Callback is already subscribed. This may lead to duplicate updates.");
+    }
+    subscribers.add(callback);
+    callback(value);
 
-    // Return unsubscribe function
     return () => {
-      const index = subscribers.indexOf(callback);
-      if (index >= 0) {
-        subscribers.splice(index, 1);
-      }
+      subscribers.delete(callback);
     };
   };
 
-  return { get, set, subscribe };
+  const reset = () => {
+    value = initialValue;
+    subscribers.forEach((subscriber) => subscriber(value));
+  };
+
+  const destroy = () => {
+    if (subscribers.size > 0) {
+      console.warn("Destroying chunk with active subscribers. This may lead to memory leaks.");
+    }
+    // Just clear subscribers without calling unsubscribe
+    subscribers.clear();
+    value = initialValue;
+  };
+
+
+  const derive = <D>(fn: (value: T) => D) => {
+    if (typeof fn !== "function") {
+      throw new Error("Derive function must be a function.");
+    }
+    const derivedValue = fn(value);
+    const derivedChunk = chunk(derivedValue);
+
+    subscribe(() => {
+      const newDerivedValue = fn(value);
+      derivedChunk.set(newDerivedValue);
+    });
+
+    return derivedChunk;
+  };
+
+  return { get, set, subscribe, derive, reset, destroy };
 }

package/src/index.ts

@@ -1,4 +1,5 @@
-// src/index.ts
-
-export { createChunk } from './core';
+export { chunk } from './core';
 export type { Chunk } from './core';
+
+export { logger } from "./middleware/logger";
+export { nonNegativeValidator } from "./middleware/validator";

package/src/middleware/logger.ts

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

package/src/middleware/validator.ts

@@ -0,0 +1,8 @@
+import { Middleware } from "../core";
+
+export const nonNegativeValidator: Middleware<number> = (value, next) => {
+  if (value < 0) {
+    throw new Error("Value must be non-negative!");
+  }
+  next(value); // If validation passes, proceed with the update
+};

package/tests/batch-chunk.test.ts

@@ -0,0 +1,108 @@
+import { chunk, batch } from '../src/core';
+
+
+describe('Chunk batch updates', () => {
+  it('should batch multiple updates into a single notification', () => {
+    const countChunk = chunk(0);
+    const callback = jest.fn();
+
+    countChunk.subscribe(callback);
+    callback.mockClear(); // Clear initial subscription call
+
+    batch(() => {
+      countChunk.set(1);
+      countChunk.set(2);
+      countChunk.set(3); // Should only notify once
+    });
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenLastCalledWith(3);
+  });
+
+  it('should handle nested batch calls', () => {
+    const countChunk = chunk(0);
+    const callback = jest.fn();
+
+    countChunk.subscribe(callback);
+    callback.mockClear();
+
+    batch(() => {
+      countChunk.set(1); // Should not notify yet
+      batch(() => {
+        countChunk.set(2);
+        countChunk.set(3);
+      });
+      countChunk.set(4);
+    });
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenLastCalledWith(4);
+  });
+
+  it('should handle errors in batch without breaking state', () => {
+    const countChunk = chunk(0);
+    const callback = jest.fn();
+
+    countChunk.subscribe(callback);
+    callback.mockClear();
+
+    expect(() => {
+      batch(() => {
+        countChunk.set(1);
+        throw new Error('Test error');
+        // countChunk.set(2);
+      });
+    }).toThrow('Test error');
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenLastCalledWith(1);
+    expect(countChunk.get()).toBe(1);
+  });
+
+  it('should work with multiple chunks in the same batch', () => {
+    const chunk1 = chunk(0);
+    const chunk2 = chunk(0);
+    const callback1 = jest.fn();
+    const callback2 = jest.fn();
+
+    chunk1.subscribe(callback1);
+    chunk2.subscribe(callback2);
+    callback1.mockClear();
+    callback2.mockClear();
+
+    batch(() => {
+      chunk1.set(1);
+      chunk2.set(1);
+      chunk1.set(2);
+      chunk2.set(2);
+    });
+
+    expect(callback1).toHaveBeenCalledTimes(1);
+    expect(callback2).toHaveBeenCalledTimes(1);
+    expect(callback1).toHaveBeenLastCalledWith(2);
+    expect(callback2).toHaveBeenLastCalledWith(2);
+  });
+
+  it('should handle derived chunks in batch updates', () => {
+    const sourceChunk = chunk(0);
+    const derivedChunk = sourceChunk.derive(x => x * 2);
+    const sourceCallback = jest.fn();
+    const derivedCallback = jest.fn();
+
+    sourceChunk.subscribe(sourceCallback);
+    derivedChunk.subscribe(derivedCallback);
+    sourceCallback.mockClear();
+    derivedCallback.mockClear();
+
+    batch(() => {
+      sourceChunk.set(1);
+      sourceChunk.set(2);
+      sourceChunk.set(3);
+    });
+
+    expect(sourceCallback).toHaveBeenCalledTimes(1);
+    expect(derivedCallback).toHaveBeenCalledTimes(1);
+    expect(sourceCallback).toHaveBeenLastCalledWith(3);
+    expect(derivedCallback).toHaveBeenLastCalledWith(6);
+  });
+});

package/tests/chunk.test.ts

@@ -1,35 +1,187 @@
-// tests/chunk.test.ts
-
-import { createChunk } from "../src/core";
+import { chunk } from "../src/core";
 
 test("Chunk should get and set values correctly", () => {
-  const chunk = createChunk<number>(0);
-  expect(chunk.get()).toBe(0);
-  chunk.set(10);
-  expect(chunk.get()).toBe(10);
+  const chunky = chunk<number>(0);
+  expect(chunky.get()).toBe(0);
+  chunky.set(10);
+  expect(chunky.get()).toBe(10);
 });
 
 test("Chunk should notify subscribers on value change", () => {
-  const chunk = createChunk<number>(0);
+  const chunky = chunk<number>(0);
   const callback = jest.fn();
-  chunk.subscribe(callback);
+  const unsubscribe = chunky.subscribe(callback); // Store unsubscribe function
 
-  chunk.set(5);
+  chunky.set(5);
   expect(callback).toHaveBeenCalledWith(5);
 
-  chunk.set(10);
+  chunky.set(10);
   expect(callback).toHaveBeenCalledWith(10);
+
+  unsubscribe(); // Ensure cleanup after test
 });
 
+test("Chunk should notify multiple subscribers correctly", () => {
+  const chunky = chunk<number>(0);
+  const callback1 = jest.fn();
+  const callback2 = jest.fn();
+
+  const unsubscribe1 = chunky.subscribe(callback1);
+  const unsubscribe2 = chunky.subscribe(callback2);
+
+
+  chunky.set(10);
+
+  expect(callback1).toHaveBeenCalledWith(10);
+  expect(callback2).toHaveBeenCalledWith(10);
+
+  unsubscribe1();
+  unsubscribe2();
+});
+
+
 test("Chunk should allow unsubscribing from updates", () => {
-  const chunk = createChunk<number>(0);
+  const chunky = chunk<number>(0);
   const callback = jest.fn();
-  const unsubscribe = chunk.subscribe(callback);
+  const unsubscribe = chunky.subscribe(callback);
+
+  // Initial subscription call
+  expect(callback).toHaveBeenCalledWith(0);
+  expect(callback).toHaveBeenCalledTimes(1);
 
-  chunk.set(5);
+  chunky.set(5);
   expect(callback).toHaveBeenCalledWith(5);
+  expect(callback).toHaveBeenCalledTimes(2);
 
   unsubscribe();
-  chunk.set(10); // No callback should be called now
-  expect(callback).toHaveBeenCalledTimes(1);
+  chunky.set(10);
+  expect(callback).toHaveBeenCalledTimes(2); // Still called only twice
+});
+
+describe("Chunk Derivation", () => {
+  it("should create a derived chunk and update it when the original chunk changes", () => {
+    const count = chunk(5);
+    const doubleCount = count.derive((value) => value * 2);
+
+    const countSpy = jest.fn();
+    const doubleCountSpy = jest.fn();
+
+    // Subscribe to both chunks
+    count.subscribe(countSpy);
+    doubleCount.subscribe(doubleCountSpy);
+
+    // Initial values
+    expect(count.get()).toBe(5);
+    expect(doubleCount.get()).toBe(10);
+    expect(countSpy).toHaveBeenCalledWith(5);
+    expect(doubleCountSpy).toHaveBeenCalledWith(10);
+
+    // Update count and verify updates
+    count.set(10);
+    expect(count.get()).toBe(10);
+    expect(doubleCount.get()).toBe(20);
+    expect(countSpy).toHaveBeenCalledWith(10);
+    expect(doubleCountSpy).toHaveBeenCalledWith(20);
+  });
+
+  it("should not update the derived chunk if the original chunk value does not change", () => {
+    const count = chunk(5);
+    const doubleCount = count.derive((value) => value * 2);
+
+    const doubleCountSpy = jest.fn();
+
+    // Subscribe to the derived chunk
+    doubleCount.subscribe(doubleCountSpy);
+
+    // Setting the same value
+    count.set(5);
+    expect(doubleCount.get()).toBe(10); // Derived value should remain the same
+    expect(doubleCountSpy).toHaveBeenCalledTimes(1); // Only initial value
+  });
+});
+
+
+test("Chunk should reset to initial value", () => {
+  const count = chunk(5);
+  count.set(10);
+  expect(count.get()).toBe(10);
+  count.reset();
+  expect(count.get()).toBe(5);
+});
+
+
+describe('Chunk destroy', () => {
+  const countChunk = chunk(0);
+  const anotherChunk = chunk(0);
+  const countCallback = jest.fn();
+  const anotherCallback = jest.fn();
+
+  beforeEach(() => {
+    // Reset the mocks
+    countCallback.mockClear();
+    anotherCallback.mockClear();
+  });
+
+  it('should stop notifying subscribers after destroy is called', () => {
+    // Subscribe to the chunks
+    const countUnsubscribe = countChunk.subscribe(countCallback);
+    const anotherUnsubscribe = anotherChunk.subscribe(anotherCallback);
+
+    // Verify initial subscription calls
+    expect(countCallback).toHaveBeenCalledTimes(1);
+    expect(countCallback).toHaveBeenCalledWith(0);
+    expect(anotherCallback).toHaveBeenCalledTimes(1);
+    expect(anotherCallback).toHaveBeenCalledWith(0);
+
+    // Clear the mocks to start fresh
+    countCallback.mockClear();
+    anotherCallback.mockClear();
+
+    // Cleanup subscriptions before destroy
+    countUnsubscribe();
+    anotherUnsubscribe();
+
+    // Now destroy the chunks - no warning should appear
+    countChunk.destroy();
+    anotherChunk.destroy();
+
+    // Try setting new values after destruction
+    countChunk.set(30);
+    anotherChunk.set(40);
+
+    // Ensure that the subscribers were not notified after destroy
+    expect(countCallback).toHaveBeenCalledTimes(0);
+    expect(anotherCallback).toHaveBeenCalledTimes(0);
+  });
+
+  it('should reset to initial value after destroy', () => {
+    // Set some values
+    countChunk.set(10);
+    anotherChunk.set(20);
+
+    // Destroy the chunks (no subscribers at this point, so no warning)
+    countChunk.destroy();
+    anotherChunk.destroy();
+
+    // Subscribe new callbacks after destroy
+    const newCountCallback = jest.fn();
+    const newAnotherCallback = jest.fn();
+
+    const newCountUnsubscribe = countChunk.subscribe(newCountCallback);
+    const newAnotherUnsubscribe = anotherChunk.subscribe(newAnotherCallback);
+
+    // Should receive initial values
+    expect(newCountCallback).toHaveBeenCalledWith(0);
+    expect(newAnotherCallback).toHaveBeenCalledWith(0);
+
+    // Cleanup
+    newCountUnsubscribe();
+    newAnotherUnsubscribe();
+  });
+
+  // Clean up after all tests
+  afterAll(() => {
+    countChunk.destroy();
+    anotherChunk.destroy();
+  });
 });

package/tests/middleware.test.ts

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

package/types/stunk.d.ts

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