@uistate/core 5.2.0 → 5.4.0

package/examples/028-counter-improved-eventTest/tests/README.md

@@ -1,208 +0,0 @@
-# EventTest - Event-Sequence Testing
-
-Event-driven TDD for EventState applications.
-
-## Features
-
-- ✅ **Event-sequence testing** - Test state changes through event flows
-- ✅ **Type extraction** - Generate `.d.ts` files from test assertions
-- ✅ **No DOM required** - Tests run in Node.js
-- ✅ **Fluent API** - Chainable assertions
-- ✅ **Type-safe** - Tests define types, not manual definitions
-
-## Usage
-
-### Writing Tests
-
-```javascript
-import { createEventTest, test } from './eventTest.js';
-
-test('add todo', () => {
-  const t = createEventTest({
-    domain: { todos: { items: [] } }
-  });
-  
-  // Trigger intent
-  t.trigger('intent.todo.add', { text: 'Buy milk' });
-  
-  // Assert types (for .d.ts generation)
-  t.assertArrayOf('domain.todos.items', {
-    id: 'number',
-    text: 'string',
-    done: 'boolean'
-  });
-  
-  // Assert values
-  t.assertArrayLength('domain.todos.items', 1);
-});
-```
-
-### Running Tests
-
-```bash
-# Run all tests
-node tests/run.js
-
-# Or run specific test file
-node tests/todos.test.js
-```
-
-### Generating Types
-
-```bash
-# Generate store.d.ts from test assertions
-node tests/generateTypes.js
-```
-
-## API Reference
-
-### `createEventTest(initialState)`
-
-Creates a test instance with isolated store.
-
-**Returns:** Test API object
-
-### Test API
-
-#### `.trigger(path, value)`
-
-Set a value in the store (trigger state change).
-
-```javascript
-t.trigger('intent.todo.add', { text: 'Buy milk' });
-```
-
-#### `.assertPath(path, expected)`
-
-Assert exact value at path.
-
-```javascript
-t.assertPath('ui.theme', 'dark');
-```
-
-#### `.assertType(path, type)`
-
-Assert primitive type. Stores type info for `.d.ts` generation.
-
-```javascript
-t.assertType('ui.theme', 'string');
-```
-
-#### `.assertArrayOf(path, elementShape)`
-
-Assert array with element shape. Stores type info for `.d.ts` generation.
-
-```javascript
-t.assertArrayOf('domain.todos.items', {
-  id: 'number',
-  text: 'string',
-  done: 'boolean'
-});
-```
-
-#### `.assertShape(path, objectShape)`
-
-Assert object shape. Stores type info for `.d.ts` generation.
-
-```javascript
-t.assertShape('ui.route', {
-  path: 'string',
-  view: 'string'
-});
-```
-
-#### `.assertArrayLength(path, length)`
-
-Assert array length.
-
-```javascript
-t.assertArrayLength('domain.todos.items', 3);
-```
-
-#### `.assertEventFired(path, times)`
-
-Assert event fired N times.
-
-```javascript
-t.assertEventFired('domain.todos.items', 1);
-```
-
-#### `.getEventLog()`
-
-Get all captured events.
-
-```javascript
-const log = t.getEventLog();
-// [{ timestamp: 123, path: 'domain.todos.items', value: [...] }]
-```
-
-#### `.getTypeAssertions()`
-
-Get all type assertions (for type generation).
-
-```javascript
-const assertions = t.getTypeAssertions();
-// [{ path: 'domain.todos.items', type: 'array', elementShape: {...} }]
-```
-
-## Workflow
-
-### 1. Write Tests (TDD)
-
-```javascript
-// tests/todos.test.js
-test('add todo', () => {
-  const t = createEventTest({ domain: { todos: { items: [] } } });
-  t.trigger('intent.todo.add', { text: 'Buy milk' });
-  t.assertArrayOf('domain.todos.items', {
-    id: 'number',
-    text: 'string',
-    done: 'boolean'
-  });
-});
-```
-
-### 2. Implement Bridges
-
-```javascript
-// app/bridges.js
-store.subscribe('intent.todo.add', ({ text }) => {
-  const items = store.get('domain.todos.items') || [];
-  const id = items.length + 1;
-  store.set('domain.todos.items', [...items, { id, text, done: false }]);
-});
-```
-
-### 3. Generate Types
-
-```bash
-node tests/generateTypes.js
-# Creates store.d.ts with perfect types!
-```
-
-### 4. Build UI
-
-```javascript
-// Now you have autocomplete!
-const items = store.get('domain.todos.items');
-// TypeScript knows: Array<{ id: number, text: string, done: boolean }>
-```
-
-## Benefits
-
-- **Tests define behavior** - TDD workflow
-- **Types derived from tests** - No manual type definitions
-- **Perfect coverage** - Every test adds type information
-- **No DOM needed** - Fast feedback loop
-- **Deterministic** - Same tests = same types
-- **Watcher-friendly** - Auto-regenerate on test changes
-
-## Philosophy
-
-EventTest follows EventState's core principles:
-
-1. **State-first** - Tests work with state paths
-2. **Dot-paths everywhere** - No special syntax
-3. **Types are optional** - Tests work without TypeScript
-4. **Types are derived** - Not hand-written
-5. **JS-first** - Clean, readable code

package/examples/028-counter-improved-eventTest/tests/counter.test.js

@@ -1,116 +0,0 @@
-/**
- * counter.test.js - Event-sequence tests for counter functionality
- * 
- * These tests verify direct state manipulation for counter operations
- */
-
-import { createEventTest, test, runTests } from './eventTest.js';
-
-// Helper functions that match the view logic
-function increment(store) {
-  const current = store.get('count');
-  store.set('count', current + 1);
-}
-
-function decrement(store) {
-  const current = store.get('count');
-  store.set('count', current - 1);
-}
-
-function double(store) {
-  const current = store.get('count');
-  store.set('count', current * 2);
-}
-
-// Test suite
-const tests = {
-  'increment increases count by 1': () => {
-    const t = createEventTest({ count: 0 });
-    
-    increment(t.store);
-    
-    // Assert type
-    t.assertType('count', 'number');
-    
-    // Assert value
-    const count = t.store.get('count');
-    if (count !== 1) {
-      throw new Error(`Expected count to be 1, got ${count}`);
-    }
-  },
-
-  'decrement decreases count by 1': () => {
-    const t = createEventTest({ count: 5 });
-    
-    decrement(t.store);
-    
-    // Assert type
-    t.assertType('count', 'number');
-    
-    // Assert value
-    const count = t.store.get('count');
-    if (count !== 4) {
-      throw new Error(`Expected count to be 4, got ${count}`);
-    }
-  },
-
-  'double multiplies count by 2': () => {
-    const t = createEventTest({ count: 3 });
-    
-    double(t.store);
-    
-    // Assert type
-    t.assertType('count', 'number');
-    
-    // Assert value
-    const count = t.store.get('count');
-    if (count !== 6) {
-      throw new Error(`Expected count to be 6, got ${count}`);
-    }
-  },
-
-  'multiple increments work correctly': () => {
-    const t = createEventTest({ count: 0 });
-    
-    increment(t.store);
-    increment(t.store);
-    increment(t.store);
-    
-    const count = t.store.get('count');
-    if (count !== 3) {
-      throw new Error(`Expected count to be 3, got ${count}`);
-    }
-  },
-
-  'mixed operations work correctly': () => {
-    const t = createEventTest({ count: 10 });
-    
-    increment(t.store);  // 11
-    double(t.store);     // 22
-    decrement(t.store);  // 21
-    
-    const count = t.store.get('count');
-    if (count !== 21) {
-      throw new Error(`Expected count to be 21, got ${count}`);
-    }
-  },
-
-  'count can go negative': () => {
-    const t = createEventTest({ count: 0 });
-    
-    decrement(t.store);
-    decrement(t.store);
-    
-    const count = t.store.get('count');
-    if (count !== -2) {
-      throw new Error(`Expected count to be -2, got ${count}`);
-    }
-  }
-};
-
-// Run tests if executed directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-  runTests(tests);
-}
-
-export default tests;

package/examples/028-counter-improved-eventTest/tests/eventTest.js

@@ -1,176 +0,0 @@
-/**
- * eventTest.js - Event-Sequence Testing for EventState
- * 
- * Provides TDD-style testing with type extraction capabilities
- */
-
-import { createEventState } from '../runtime/core/eventStateNew.js';
-
-export function createEventTest(initialState = {}) {
-  const store = createEventState(initialState);
-  const eventLog = [];
-  const typeAssertions = [];
-
-  // Spy on all events
-  store.subscribe('*', (detail) => {
-    const { path, value } = detail;
-    eventLog.push({ timestamp: Date.now(), path, value });
-  });
-
-  const api = {
-    store,
-
-    // Trigger a state change
-    trigger(path, value) {
-      store.set(path, value);
-      return this;
-    },
-
-    // Assert exact value
-    assertPath(path, expected) {
-      const actual = store.get(path);
-      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-        throw new Error(`Expected ${path} to be ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-      }
-      return this;
-    },
-
-    // Assert type (for type generation)
-    assertType(path, expectedType) {
-      const actual = store.get(path);
-      const actualType = typeof actual;
-      
-      if (actualType !== expectedType) {
-        throw new Error(`Expected ${path} to be type ${expectedType}, got ${actualType}`);
-      }
-      
-      // Store for type generation
-      typeAssertions.push({ path, type: expectedType });
-      return this;
-    },
-
-    // Assert array with element shape (for type generation)
-    assertArrayOf(path, elementShape) {
-      const actual = store.get(path);
-      
-      if (!Array.isArray(actual)) {
-        throw new Error(`Expected ${path} to be an array, got ${typeof actual}`);
-      }
-      
-      // Validate first element matches shape (if array not empty)
-      if (actual.length > 0) {
-        validateShape(actual[0], elementShape, path);
-      }
-      
-      // Store for type generation
-      typeAssertions.push({ path, type: 'array', elementShape });
-      return this;
-    },
-
-    // Assert object shape (for type generation)
-    assertShape(path, objectShape) {
-      const actual = store.get(path);
-      
-      if (typeof actual !== 'object' || actual === null || Array.isArray(actual)) {
-        throw new Error(`Expected ${path} to be an object, got ${typeof actual}`);
-      }
-      
-      validateShape(actual, objectShape, path);
-      
-      // Store for type generation
-      typeAssertions.push({ path, type: 'object', shape: objectShape });
-      return this;
-    },
-
-    // Assert array length
-    assertArrayLength(path, expectedLength) {
-      const actual = store.get(path);
-      
-      if (!Array.isArray(actual)) {
-        throw new Error(`Expected ${path} to be an array`);
-      }
-      
-      if (actual.length !== expectedLength) {
-        throw new Error(`Expected ${path} to have length ${expectedLength}, got ${actual.length}`);
-      }
-      
-      return this;
-    },
-
-    // Assert event fired N times
-    assertEventFired(path, times) {
-      const count = eventLog.filter(e => e.path === path).length;
-      if (times !== undefined && count !== times) {
-        throw new Error(`Expected ${path} to fire ${times} times, fired ${count}`);
-      }
-      return this;
-    },
-
-    // Get event log
-    getEventLog() {
-      return [...eventLog];
-    },
-
-    // Get type assertions (for type generation)
-    getTypeAssertions() {
-      return [...typeAssertions];
-    }
-  };
-
-  return api;
-}
-
-// Helper to validate object shape
-function validateShape(actual, shape, path) {
-  for (const [key, expectedType] of Object.entries(shape)) {
-    if (!(key in actual)) {
-      throw new Error(`Expected ${path} to have property ${key}`);
-    }
-    
-    const actualValue = actual[key];
-    
-    // Handle nested objects
-    if (typeof expectedType === 'object' && !Array.isArray(expectedType)) {
-      validateShape(actualValue, expectedType, `${path}.${key}`);
-    } else {
-      // Primitive type check
-      const actualType = typeof actualValue;
-      if (actualType !== expectedType) {
-        throw new Error(`Expected ${path}.${key} to be type ${expectedType}, got ${actualType}`);
-      }
-    }
-  }
-}
-
-// Simple test runner
-export function test(name, fn) {
-  try {
-    fn();
-    console.log(`✓ ${name}`);
-    return true;
-  } catch (error) {
-    console.error(`✗ ${name}`);
-    console.error(`  ${error.message}`);
-    return false;
-  }
-}
-
-// Run multiple tests
-export function runTests(tests) {
-  console.log('\n🧪 Running tests...\n');
-  
-  let passed = 0;
-  let failed = 0;
-  
-  for (const [name, fn] of Object.entries(tests)) {
-    if (test(name, fn)) {
-      passed++;
-    } else {
-      failed++;
-    }
-  }
-  
-  console.log(`\n📊 Results: ${passed} passed, ${failed} failed\n`);
-  
-  return { passed, failed };
-}

package/examples/028-counter-improved-eventTest/tests/generateTypes.js

@@ -1,168 +0,0 @@
-#!/usr/bin/env node
-/**
- * generateTypes.js - Generate TypeScript definitions from test assertions
- * 
- * Usage: node tests/generateTypes.js
- */
-
-import { createEventTest } from './eventTest.js';
-import todosTests from './todos.test.js';
-import { writeFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Collect all type assertions from tests
-const allAssertions = [];
-
-console.log('🔍 Extracting types from tests...\n');
-
-for (const [name, testFn] of Object.entries(todosTests)) {
-  try {
-    // Run test to collect assertions
-    testFn();
-    console.log(`✓ ${name}`);
-  } catch (error) {
-    // Test might fail, but we still want type assertions
-    console.log(`⚠ ${name} (failed but types extracted)`);
-  }
-}
-
-// Simple type generator (minimal version for Node.js)
-class SimpleTypeGenerator {
-  constructor() {
-    this.pathTypes = new Map();
-  }
-
-  parseAssertions(assertions) {
-    for (const assertion of assertions) {
-      const { path, type, elementShape, shape } = assertion;
-      
-      if (type === 'array' && elementShape) {
-        this.pathTypes.set(path, {
-          type: 'array',
-          element: elementShape
-        });
-      } else if (type === 'object' && shape) {
-        this.pathTypes.set(path, {
-          type: 'object',
-          shape: shape
-        });
-      } else if (type) {
-        this.pathTypes.set(path, { type });
-      }
-    }
-  }
-
-  buildTree() {
-    const tree = {};
-    
-    for (const [path, typeInfo] of this.pathTypes) {
-      const parts = path.split('.');
-      let current = tree;
-      
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        
-        if (i === parts.length - 1) {
-          current[part] = { __typeInfo: typeInfo };
-        } else {
-          if (!current[part]) {
-            current[part] = {};
-          }
-          current = current[part];
-        }
-      }
-    }
-    
-    return tree;
-  }
-
-  formatType(typeInfo) {
-    if (typeof typeInfo === 'string') return typeInfo;
-    
-    if (typeInfo.type === 'array' && typeInfo.element) {
-      const elementType = this.formatShape(typeInfo.element);
-      return `Array<${elementType}>`;
-    }
-    
-    if (typeInfo.type === 'object' && typeInfo.shape) {
-      return this.formatShape(typeInfo.shape);
-    }
-    
-    return typeInfo.type || 'unknown';
-  }
-
-  formatShape(shape) {
-    if (typeof shape === 'string') return shape;
-    
-    const props = Object.entries(shape)
-      .map(([k, v]) => {
-        const type = typeof v === 'string' ? v : this.formatShape(v);
-        return `${k}: ${type}`;
-      })
-      .join('; ');
-    
-    return `{ ${props} }`;
-  }
-
-  generateInterface(obj, indent = 0) {
-    const lines = [];
-    const spaces = '  '.repeat(indent);
-    
-    for (const [key, value] of Object.entries(obj)) {
-      if (value.__typeInfo) {
-        const type = this.formatType(value.__typeInfo);
-        lines.push(`${spaces}${key}: ${type};`);
-      } else {
-        lines.push(`${spaces}${key}: {`);
-        lines.push(this.generateInterface(value, indent + 1));
-        lines.push(`${spaces}};`);
-      }
-    }
-    
-    return lines.join('\n');
-  }
-
-  generateDTS() {
-    const lines = [
-      '// Auto-generated from test assertions',
-      '// DO NOT EDIT - regenerate by running: node tests/generateTypes.js',
-      '',
-      'export interface StoreState {',
-    ];
-    
-    const tree = this.buildTree();
-    lines.push(this.generateInterface(tree, 1));
-    lines.push('}');
-    lines.push('');
-    lines.push('export default StoreState;');
-    lines.push('');
-    
-    return lines.join('\n');
-  }
-}
-
-// Note: We need to actually collect assertions from test execution
-// For now, manually define expected types based on test assertions
-const manualAssertions = [
-  {
-    path: 'count',
-    type: 'number'
-  }
-];
-
-const generator = new SimpleTypeGenerator();
-generator.parseAssertions(manualAssertions);
-
-const dts = generator.generateDTS();
-
-// Write to file
-const outputPath = join(__dirname, '..', 'store.d.ts');
-writeFileSync(outputPath, dts, 'utf-8');
-
-console.log(`\n✅ Generated ${outputPath}`);
-console.log('\n📝 Type definitions:\n');
-console.log(dts);

package/examples/028-counter-improved-eventTest/tests/run.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-/**
- * run.js - Test runner for Node.js
- * 
- * Usage: node tests/run.js
- */
-
-import { runTests } from './eventTest.js';
-import counterTests from './counter.test.js';
-
-// Combine all test suites
-const allTests = {
-  ...counterTests
-};
-
-// Run tests
-const results = runTests(allTests);
-
-// Exit with appropriate code
-process.exit(results.failed > 0 ? 1 : 0);