@everystate/test 1.0.0 → 1.0.2

package/README.md

@@ -35,6 +35,21 @@ test('counter increments', () => {
 - **Type extraction** Infer types from state
 - **Fast** 100 tests in ~0.5ms
 
+## Ecosystem
+
+| Package | Description | License |
+|---|---|---|
+| [@everystate/aliases](https://www.npmjs.com/package/@everystate/aliases) | Ergonomic single-character and short-name DOM aliases for vanilla JS | MIT |
+| [@everystate/core](https://www.npmjs.com/package/@everystate/core) | Path-based state management with wildcard subscriptions and async support. Core state engine (you are here). | MIT |
+| [@everystate/css](https://www.npmjs.com/package/@everystate/css) | Reactive CSSOM engine: design tokens, typed validation, WCAG enforcement, all via path-based state | MIT |
+| [@everystate/examples](https://www.npmjs.com/package/@everystate/examples) | Example applications and patterns | MIT |
+| [@everystate/perf](https://www.npmjs.com/package/@everystate/perf) | Performance monitoring overlay | MIT |
+| [@everystate/react](https://www.npmjs.com/package/@everystate/react) | React hooks adapter: `usePath`, `useIntent`, `useAsync` hooks and `EveryStateProvider` | MIT |
+| [@everystate/renderer](https://www.npmjs.com/package/@everystate/renderer) | Direct-binding reactive renderer: `bind-*`, `set`, `each` attributes. Zero build step | Proprietary |
+| [@everystate/router](https://www.npmjs.com/package/@everystate/router) | SPA routing as state | MIT |
+| [@everystate/test](https://www.npmjs.com/package/@everystate/test) | Event-sequence testing for EveryState stores. Zero dependency. | Proprietary |
+| [@everystate/view](https://www.npmjs.com/package/@everystate/view) | State-driven view: DOMless resolve + surgical DOM projector. View tree as first-class state | MIT |
+
 ## License
 
 Proprietary - See LICENSE.md for details.

package/eventTest.js

@@ -0,0 +1,178 @@
+/**
+ * @everystate/test: Event-Sequence Testing for EveryState
+ *
+ * Copyright (c) 2026 Ajdin Imsirovic. MIT License.
+ *
+ * Provides TDD-style testing with type extraction capabilities.
+ */
+
+import { createEveryState } from '@everystate/core';
+
+export function createEventTest(initialState = {}) {
+  const store = createEveryState(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(`\u2713 ${name}`);
+    return true;
+  } catch (error) {
+    console.error(`\u2717 ${name}`);
+    console.error(`  ${error.message}`);
+    return false;
+  }
+}
+
+// Run multiple tests
+export function runTests(tests) {
+  console.log('\n\uD83E\uDDEA 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\uD83D\uDCCA Results: ${passed} passed, ${failed} failed\n`);
+
+  return { passed, failed };
+}

package/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @everystate/test
+ *
+ * Event-sequence testing for EveryState.
+ * TDD-style testing with type extraction capabilities.
+ */
+
+import type { EveryStateStore } from '@everystate/core';
+
+export interface TestCase {
+  name: string;
+  fn: (store: EveryStateStore) => void | Promise<void>;
+}
+
+export interface TestResult {
+  name: string;
+  passed: boolean;
+  error?: Error;
+  duration: number;
+}
+
+export interface TestSuite {
+  /** Add a test case */
+  add(name: string, fn: (store: EveryStateStore) => void | Promise<void>): void;
+  /** Run all registered tests */
+  run(): Promise<TestResult[]>;
+  /** Get results summary */
+  results(): TestResult[];
+}
+
+/**
+ * Create a test suite for event-sequence testing.
+ */
+export function createEventTest(store: EveryStateStore): TestSuite;
+
+/**
+ * Define a single test case (shorthand).
+ */
+export function test(name: string, fn: (store: EveryStateStore) => void | Promise<void>): TestCase;
+
+/**
+ * Run an array of test cases against a store.
+ */
+export function runTests(store: EveryStateStore, tests: TestCase[]): Promise<TestResult[]>;

package/index.js

@@ -1,8 +1,8 @@
 /**
  * @everystate/test
  *
- * EveryState wrapper for @uistate/event-test
- * Re-exports all functionality from the underlying @uistate/event-test package
+ * Event-sequence testing for EveryState.
+ * TDD-style testing with type extraction capabilities.
  */
 
-export * from '@uistate/event-test';
+export { createEventTest, test, runTests } from './eventTest.js';

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@everystate/test",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "EveryState Test: Testing library with TDD-style assertions and event-sequence tracking",
   "type": "module",
   "main": "index.js",
+  "types": "index.d.ts",
   "keywords": [
     "everystate",
     "testing",
@@ -25,10 +26,9 @@
   },
   "files": [
     "index.js",
+    "eventTest.js",
+    "index.d.ts",
     "README.md",
     "LICENSE.md"
-  ],
-  "dependencies": {
-    "@uistate/event-test": "^1.0.1"
-  }
+  ]
 }