mtrl 0.3.1 → 0.3.3

package/test/core/state.store.test.ts

@@ -1,189 +0,0 @@
-// test/core/state.store.test.ts
-import { describe, test, expect, mock, spyOn } from 'bun:test';
-import { createStore, loggingMiddleware } from '../../src/core/state/store';
-
-describe('State Store', () => {
-  test('should create a store with initial state', () => {
-    const initialState = { count: 0, name: 'test' };
-    const store = createStore(initialState);
-    
-    expect(store.getState()).toEqual(initialState);
-  });
-  
-  test('should update state with partial object', () => {
-    const store = createStore({ count: 0, name: 'test' });
-    
-    store.setState({ count: 5 });
-    
-    expect(store.getState()).toEqual({ count: 5, name: 'test' });
-  });
-  
-  test('should update state with updater function', () => {
-    const store = createStore({ count: 0, name: 'test' });
-    
-    store.setState(state => ({
-      ...state,
-      count: state.count + 1
-    }));
-    
-    expect(store.getState()).toEqual({ count: 1, name: 'test' });
-  });
-  
-  test('should notify subscribers of state changes', () => {
-    const store = createStore({ count: 0 });
-    const listener = mock((state, oldState) => {});
-    
-    store.subscribe(listener);
-    store.setState({ count: 1 });
-    
-    expect(listener).toHaveBeenCalledTimes(1);
-    expect(listener).toHaveBeenCalledWith({ count: 1 }, { count: 0 });
-  });
-  
-  test('should return unsubscribe function', () => {
-    const store = createStore({ count: 0 });
-    const listener = mock((state, oldState) => {});
-    
-    const unsubscribe = store.subscribe(listener);
-    unsubscribe();
-    
-    store.setState({ count: 1 });
-    expect(listener).toHaveBeenCalledTimes(0);
-  });
-  
-  test('should create derived state', () => {
-    const store = createStore({ count: 0 });
-    
-    store.derive('doubleCount', state => state.count * 2);
-    store.setState({ count: 3 });
-    
-    const state = store.getState();
-    expect(state.count).toBe(3);
-    expect(state.doubleCount).toBe(6);
-  });
-  
-  test('should remove derived state when returned function is called', () => {
-    const store = createStore({ count: 0 });
-    
-    const removeDerived = store.derive('doubleCount', state => state.count * 2);
-    expect(store.getState().doubleCount).toBe(0);
-    
-    removeDerived();
-    expect(store.getState().doubleCount).toBeUndefined();
-  });
-  
-  test('should select a slice of state', () => {
-    const store = createStore({ user: { name: 'Alice', age: 30 }, count: 0 });
-    
-    const userName = store.select(state => state.user.name);
-    expect(userName).toBe('Alice');
-  });
-  
-  test('should reset state to initial values', () => {
-    const initialState = { count: 0, name: 'test' };
-    const store = createStore(initialState);
-    
-    store.setState({ count: 5, name: 'updated' });
-    expect(store.getState()).toEqual({ count: 5, name: 'updated' });
-    
-    store.reset();
-    expect(store.getState()).toEqual(initialState);
-  });
-  
-  test('should apply middleware to state changes', () => {
-    const middlewareFn = mock((newState, oldState) => ({ ...newState, processed: true }));
-    const store = createStore(
-      { count: 0 },
-      { middleware: [middlewareFn] }
-    );
-    
-    store.setState({ count: 1 });
-    
-    expect(middlewareFn).toHaveBeenCalledTimes(1);
-    expect(middlewareFn).toHaveBeenCalledWith({ count: 1 }, { count: 0 });
-    expect(store.getState()).toEqual({ count: 1, processed: true });
-  });
-  
-  test('should apply multiple middleware in order', () => {
-    const middleware1 = (newState: any, oldState: any) => ({ ...newState, m1: true });
-    const middleware2 = (newState: any, oldState: any) => ({ ...newState, m2: true });
-    
-    const store = createStore(
-      { count: 0 },
-      { middleware: [middleware1, middleware2] }
-    );
-    
-    store.setState({ count: 1 });
-    
-    expect(store.getState()).toEqual({ count: 1, m1: true, m2: true });
-  });
-  
-  test('should support logging middleware', () => {
-    // Mock console.log
-    const originalConsoleLog = console.log;
-    console.log = mock(() => {});
-    
-    const store = createStore(
-      { count: 0 },
-      { middleware: [loggingMiddleware] }
-    );
-    
-    store.setState({ count: 1 });
-    
-    expect(console.log).toHaveBeenCalledTimes(1);
-    
-    // Restore console.log
-    console.log = originalConsoleLog;
-  });
-  
-  test('should handle complex state structures', () => {
-    interface ComplexState {
-      user: {
-        name: string;
-        settings: {
-          theme: string;
-          notifications: boolean;
-        };
-      };
-      posts: string[];
-      meta: Record<string, any>;
-    }
-    
-    const initialState: ComplexState = {
-      user: {
-        name: 'Alice',
-        settings: {
-          theme: 'dark',
-          notifications: true
-        }
-      },
-      posts: ['Hello', 'World'],
-      meta: { version: '1.0' }
-    };
-    
-    const store = createStore(initialState);
-    
-    // Update nested property
-    store.setState(state => ({
-      ...state,
-      user: {
-        ...state.user,
-        settings: {
-          ...state.user.settings,
-          theme: 'light'
-        }
-      }
-    }));
-    
-    expect(store.getState().user.settings.theme).toBe('light');
-    expect(store.getState().user.settings.notifications).toBe(true);
-    
-    // Add to array
-    store.setState(state => ({
-      ...state,
-      posts: [...state.posts, 'New Post']
-    }));
-    
-    expect(store.getState().posts).toEqual(['Hello', 'World', 'New Post']);
-  });
-});

package/test/core/utils.normalize.test.ts

@@ -1,61 +0,0 @@
-// test/core/utils.normalize.test.ts
-import { describe, test, expect } from 'bun:test';
-import { normalizeClasses, classNames } from '../../src/core/utils';
-
-describe('normalizeClasses Utility', () => {
-  test('should return an empty array for no classes', () => {
-    expect(normalizeClasses()).toEqual([]);
-  });
-
-  test('should return an array with a single class', () => {
-    expect(normalizeClasses('test')).toEqual(['test']);
-  });
-
-  test('should split space-separated classes', () => {
-    expect(normalizeClasses('test1 test2')).toEqual(['test1', 'test2']);
-  });
-
-  test('should flatten array of classes', () => {
-    expect(normalizeClasses(['test1', 'test2'])).toEqual(['test1', 'test2']);
-  });
-
-  test('should flatten nested arrays of classes', () => {
-    // Since the actual implementation doesn't support nested arrays,
-    // adjust the test to match the actual behavior
-    expect(normalizeClasses(['test1'])).toEqual(['test1']);
-  });
-
-  test('should remove duplicate classes', () => {
-    expect(normalizeClasses('test', 'test')).toEqual(['test']);
-    expect(normalizeClasses(['test', 'test'])).toEqual(['test']);
-    expect(normalizeClasses('test1 test2', 'test2')).toEqual(['test1', 'test2']);
-  });
-
-  test('should filter out empty classes', () => {
-    expect(normalizeClasses('', 'test')).toEqual(['test']);
-    expect(normalizeClasses('  ', 'test')).toEqual(['test']);
-  });
-
-  test('should handle mixed input types', () => {
-    expect(normalizeClasses('test1', ['test2 test3', 'test4'])).toEqual(['test1', 'test2', 'test3', 'test4']);
-  });
-});
-
-describe('classNames Utility', () => {
-  test('should return an empty string for no classes', () => {
-    expect(classNames()).toBe('');
-  });
-
-  test('should join classes with spaces', () => {
-    expect(classNames('test1', 'test2')).toBe('test1 test2');
-  });
-
-  test('should filter out falsy values', () => {
-    expect(classNames('test1', null, 'test2', undefined, false, 'test3')).toBe('test1 test2 test3');
-  });
-
-  test('should handle empty strings', () => {
-    // The implementation filters out empty strings
-    expect(classNames('test1', '', 'test2')).toBe('test1 test2');
-  });
-});

package/test/core/utils.object.test.ts

@@ -1,120 +0,0 @@
-// test/core/utils.object.test.ts
-import { describe, test, expect } from 'bun:test';
-import { isObject, byString } from '../../src/core/utils/object';
-
-describe('isObject Utility', () => {
-  test('should return true for plain objects', () => {
-    expect(isObject({})).toBe(true);
-    expect(isObject({ a: 1, b: 2 })).toBe(true);
-    expect(isObject(Object.create(null))).toBe(false); // Different prototype
-  });
-
-  test('should return false for non-objects', () => {
-    expect(isObject(null)).toBe(false);
-    expect(isObject(undefined)).toBe(false);
-    expect(isObject(42)).toBe(false);
-    expect(isObject('string')).toBe(false);
-    expect(isObject(true)).toBe(false);
-    expect(isObject(Symbol('symbol'))).toBe(false);
-  });
-
-  test('should return false for arrays', () => {
-    expect(isObject([])).toBe(false);
-    expect(isObject([1, 2, 3])).toBe(false);
-  });
-
-  test('should return false for functions', () => {
-    expect(isObject(() => {})).toBe(false);
-    expect(isObject(function() {})).toBe(false);
-  });
-
-  test('should return false for class instances', () => {
-    class TestClass {}
-    expect(isObject(new TestClass())).toBe(false);
-  });
-
-  test('should return false for built-in objects', () => {
-    expect(isObject(new Date())).toBe(false);
-    expect(isObject(/regex/)).toBe(false);
-    expect(isObject(new Map())).toBe(false);
-    expect(isObject(new Set())).toBe(false);
-  });
-});
-
-describe('byString Utility', () => {
-  const testObj = {
-    a: 1,
-    b: {
-      c: 2,
-      d: {
-        e: 3
-      }
-    },
-    f: [4, 5, 6],
-    'g.h': 7
-  };
-
-  test('should access top-level properties', () => {
-    expect(byString(testObj, 'a')).toBe(1);
-  });
-
-  test('should access nested properties with dot notation', () => {
-    expect(byString(testObj, 'b.c')).toBe(2);
-    expect(byString(testObj, 'b.d.e')).toBe(3);
-  });
-
-  test('should access array elements with bracket notation', () => {
-    expect(byString(testObj, 'f[0]')).toBe(4);
-    expect(byString(testObj, 'f[1]')).toBe(5);
-    expect(byString(testObj, 'f[2]')).toBe(6);
-  });
-
-  test('should access array elements with dot notation', () => {
-    expect(byString(testObj, 'f.0')).toBe(4);
-    expect(byString(testObj, 'f.1')).toBe(5);
-    expect(byString(testObj, 'f.2')).toBe(6);
-  });
-
-  test('should handle properties containing dots', () => {
-    expect(byString(testObj, 'g.h')).toBe(undefined); // Can't access properties with dots directly
-  });
-
-  test('should return undefined for non-existent properties', () => {
-    expect(byString(testObj, 'z')).toBe(undefined);
-    expect(byString(testObj, 'b.z')).toBe(undefined);
-    expect(byString(testObj, 'b.d.z')).toBe(undefined);
-  });
-
-  test('should handle problematic paths', () => {
-    // This would actually cause an error, but that's expected behavior
-    try {
-      byString(testObj, 'b.c.d'); // b.c is a number, not an object
-    } catch (error) {
-      expect(error).toBeDefined();
-    }
-    
-    try {
-      byString(testObj, 'f[10]'); // Index out of bounds
-    } catch (error) {
-      expect(error).toBeDefined();
-    }
-  });
-
-  test('should handle edge cases defensively', () => {
-    // Empty path is treated as an empty key, not returning the object itself
-    const result = byString(testObj, '');
-    expect(result).toBeUndefined();
-    
-    // For type safety, let's check only that these don't throw
-    try {
-      // @ts-ignore - Testing with non-object value
-      byString(null, 'a');
-      // @ts-ignore - Testing with non-object value
-      byString(undefined, 'a');
-      expect(true).toBe(true); // If we get here, no exception was thrown
-    } catch (error) {
-      // This is also an acceptable outcome
-      expect(error).toBeDefined();
-    }
-  });
-});