stunk 2.0.0 → 2.1.0

package/tests/middleware.test.ts

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

package/tests/persist.test.ts

@@ -1,57 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-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: jest.fn(),
-      setItem: jest.fn(),
-    };
-
-    const baseChunk = chunk({ count: 0 });
-    withPersistence(baseChunk, {
-      key: 'test-key',
-      storage: mockStorage as unknown as Storage
-    });
-
-    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/tests/select-chunk.test.ts

@@ -1,133 +0,0 @@
-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 = jest.fn();
-    nameSelector.subscribe(subscriber);
-
-    // Reset the mock to ignore initial call
-    subscriber.mockReset();
-
-    // Update age only
-    source.set({ name: 'John', age: 26 });
-
-    expect(subscriber).not.toHaveBeenCalled();
-  });
-
-  it('should notify subscribers when selected value changes', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    const subscriber = jest.fn();
-    nameSelector.subscribe(subscriber);
-
-    // Reset the mock to ignore initial call
-    subscriber.mockReset();
-
-    source.set({ name: 'Jane', age: 25 });
-
-    expect(subscriber).toHaveBeenCalledTimes(1);
-    expect(subscriber).toHaveBeenCalledWith('Jane');
-  });
-
-  it('should prevent direct modifications to selector', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    expect(() => {
-      nameSelector.set('Jane');
-    }).toThrow('Cannot set values directly on a selector');
-  });
-
-  it('should work with complex selectors', () => {
-    const source = chunk({ user: { profile: { name: 'John' } } });
-    const nameSelector = select(source, state => state.user.profile.name);
-
-    expect(nameSelector.get()).toBe('John');
-
-    source.set({ user: { profile: { name: 'Jane' } } });
-    expect(nameSelector.get()).toBe('Jane');
-  });
-
-  it('should handle array selectors', () => {
-    const source = chunk({ items: [1, 2, 3] });
-    const firstItemSelector = select(source, state => state.items[0]);
-
-    expect(firstItemSelector.get()).toBe(1);
-
-    source.set({ items: [4, 2, 3] });
-    expect(firstItemSelector.get()).toBe(4);
-  });
-
-  it('should work with computed values', () => {
-    const source = chunk({ numbers: [1, 2, 3, 4, 5] });
-    const sumSelector = select(source, state =>
-      state.numbers.reduce((sum, num) => sum + num, 0)
-    );
-
-    expect(sumSelector.get()).toBe(15);
-
-    source.set({ numbers: [1, 2, 3] });
-    expect(sumSelector.get()).toBe(6);
-  });
-
-  it('should properly clean up subscriptions on destroy', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-
-    const subscriber = jest.fn();
-    const unsubscribe = nameSelector.subscribe(subscriber);
-
-    // Reset mock to ignore initial call
-    subscriber.mockReset();
-
-    unsubscribe();
-    nameSelector.destroy();
-    source.set({ name: 'Jane', age: 25 });
-
-    expect(subscriber).not.toHaveBeenCalled();
-  });
-
-  it('should work with multiple independent selectors', () => {
-    const source = chunk({ name: 'John', age: 25 });
-    const nameSelector = select(source, user => user.name);
-    const ageSelector = select(source, user => user.age);
-
-    const nameSubscriber = jest.fn();
-    const ageSubscriber = jest.fn();
-
-    nameSelector.subscribe(nameSubscriber);
-    ageSelector.subscribe(ageSubscriber);
-
-    // Reset mocks to ignore initial calls
-    nameSubscriber.mockReset();
-    ageSubscriber.mockReset();
-
-    source.set({ name: 'John', age: 26 });
-    expect(nameSubscriber).not.toHaveBeenCalled();
-    expect(ageSubscriber).toHaveBeenCalledWith(26);
-
-    source.set({ name: 'Jane', age: 26 });
-    expect(nameSubscriber).toHaveBeenCalledWith('Jane');
-    expect(ageSubscriber).toHaveBeenCalledTimes(1); // Still from previous update
-  });
-});

package/tests/update.test.ts

@@ -1,70 +0,0 @@
-import { chunk } from '../src/core/core';
-
-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 throw error if updater is not a function', () => {
-    const store = chunk(5);
-    // @ts-expect-error Testing invalid input
-    expect(() => store.update('not a function')).toThrow('Updater must be a function');
-  });
-
-  it('should throw error if updater returns null or undefined', () => {
-    const store = chunk(5);
-    // @ts-expect-error Testing invalid input
-    expect(() => store.update(() => null)).toThrow('Value cannot be null or undefined.');
-    // @ts-expect-error Testing invalid input
-    expect(() => store.update(() => undefined)).toThrow('Value cannot be null or undefined.');
-  });
-
-  it('should notify subscribers only if value changes', () => {
-    const store = chunk(5);
-    const subscriber = jest.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();
-
-    // Update to new value
-    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', () => {
-    interface User {
-      name: string;
-      age: number;
-    }
-
-    const store = chunk<User>({ 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');
-  });
-});

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "Node",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "baseUrl": "./src",
-    "paths": {
-      "stunk/middleware": ["middleware"],
-      "stunk/react": ["use-react"]
-    },
-    "typeRoots": ["./node_modules/@types", "./types"],
-    "strict": true,
-    "skipLibCheck": true,
-    "jsx": "react",
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}