@inglorious/store 8.0.0 → 8.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/store",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "description": "A state manager for real-time, collaborative apps, inspired by game development patterns and compatible with Redux.",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -42,17 +42,19 @@
     }
   },
   "files": [
-    "src"
+    "src",
+    "!src/**/*.test.js",
+    "types"
   ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "mutative": "^1.3.0",
-    "@inglorious/utils": "3.7.0"
+    "@inglorious/utils": "3.7.1"
   },
   "peerDependencies": {
-    "@inglorious/utils": "3.7.0"
+    "@inglorious/utils": "3.7.1"
   },
   "devDependencies": {
     "prettier": "^3.6.2",

package/types/client/devtools.d.ts

@@ -0,0 +1,10 @@
+import type { BaseEntity, EntitiesState, Middleware } from "../store"
+
+export function createDevtools<
+  T extends BaseEntity = BaseEntity,
+  S extends EntitiesState<T> = EntitiesState<T>,
+>(
+  config?: any,
+): {
+  middleware: Middleware<T, S>
+}

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./select"
+export * from "./store"
+export * from "./test"

package/types/select.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Input selector function that takes state and returns a value
+ */
+export type InputSelector<TState = any, TResult = any> = (
+  state: TState,
+) => TResult
+
+/**
+ * Output selector function (memoized)
+ */
+export type OutputSelector<TState = any, TResult = any> = (
+  state: TState,
+) => TResult
+
+/**
+ * Creates a memoized selector function.
+ * @param inputSelectors - An array of input selector functions.
+ * @param resultFunc - A function that receives the results of the input selectors and returns a computed value.
+ * @returns A memoized selector function that, when called, returns the selected state.
+ */
+export function createSelector<TState = any, TResult = any>(
+  inputSelectors: InputSelector<TState, any>[],
+  resultFunc: (...args: any[]) => TResult,
+): OutputSelector<TState, TResult>

package/types/store.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Base entity structure
+ */
+export interface BaseEntity {
+  type: string
+  [key: string]: any
+}
+
+/**
+ * Event structure
+ */
+export interface Event<T = any> {
+  type: string
+  payload?: T
+}
+
+/**
+ * Entity type definition with event handlers
+ */
+export type EntityType<TEntity extends BaseEntity = BaseEntity> = {
+  [K: string]: (entity: TEntity, payload: any, api: Api) => void
+}
+
+/**
+ * System definition with event handlers
+ */
+export type System<TState extends EntitiesState = EntitiesState> = {
+  [K: string]: (state: TState, payload: any, api: Api) => void
+}
+
+/**
+ * State structure (entities indexed by ID)
+ */
+export type EntitiesState<TEntity extends BaseEntity = BaseEntity> = {
+  [id: string]: TEntity
+}
+
+/**
+ * Types configuration
+ */
+export type TypesConfig<TEntity extends BaseEntity = BaseEntity> = {
+  [typeName: string]: EntityType<TEntity>
+}
+
+/**
+ * Store configuration
+ */
+export interface StoreConfig<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+> {
+  types?: TypesConfig<TEntity>
+  entities?: TState
+  systems?: System<TState>[]
+  middlewares?: Middleware<TEntity, TState>[]
+  mode?: "eager" | "batched"
+}
+
+/**
+ * Listener function for state updates
+ */
+export type Listener = () => void
+
+/**
+ * Unsubscribe function
+ */
+export type Unsubscribe = () => void
+
+/**
+ * API object exposed to handlers
+ */
+export interface Api<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+> {
+  getTypes: () => TypesConfig<TEntity>
+  getType: (typeName: string) => EntityType<TEntity>
+  getEntities: () => TState
+  getEntity: (id: string) => TEntity | undefined
+  dispatch: (event: Event) => void
+  notify: (type: string, payload?: any) => void
+  [key: string]: any // For middleware extras
+}
+
+/**
+ * Base store interface
+ */
+export interface Store<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+> {
+  subscribe: (listener: Listener) => Unsubscribe
+  update: () => Event[]
+  notify: (type: string, payload?: any) => void
+  dispatch: (event: Event) => void
+  getTypes: () => TypesConfig<TEntity>
+  getType: (typeName: string) => EntityType<TEntity>
+  getState: () => TState
+  setState: (nextState: TState) => void
+  reset: () => void
+  _api?: Api<TEntity, TState>
+  extras?: Record<string, any>
+}
+
+/**
+ * Middleware function type
+ */
+export type Middleware<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+> = (store: Store<TEntity, TState>) => Store<TEntity, TState>
+
+/**
+ * Built-in event payloads
+ */
+export interface MorphEventPayload {
+  id: string
+  type: string
+}
+
+export type AddEventPayload<TEntity extends BaseEntity = BaseEntity> =
+  TEntity & {
+    id: string
+  }
+
+export type RemoveEventPayload = string
+
+/**
+ * Creates a store to manage state and events
+ */
+export function createStore<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+>(config: StoreConfig<TEntity, TState>): Store<TEntity, TState>
+
+/**
+ * Creates an API object
+ */
+export function createApi<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+>(
+  store: Store<TEntity, TState>,
+  extras?: Record<string, any>,
+): Api<TEntity, TState>

package/types/test.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Mock API for testing (subset of full API)
+ */
+export interface MockApi<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+> {
+  getEntities: () => TState
+  getEntity: (id: string) => TEntity | undefined
+  dispatch: (event: Event) => void
+  notify: (type: string, payload?: any) => void
+  getEvents: () => Event[]
+}
+
+/**
+ * Result of trigger function
+ */
+export interface TriggerResult<TState extends EntitiesState = EntitiesState> {
+  entities: TState
+  events: Event[]
+}
+
+/**
+ * Creates a mock API for testing event handlers
+ */
+export function createMockApi<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+>(entities: TState): MockApi<TEntity, TState>
+
+/**
+ * Triggers an event handler in isolation for testing
+ */
+export function trigger<
+  TEntity extends BaseEntity = BaseEntity,
+  TState extends EntitiesState<TEntity> = EntitiesState<TEntity>,
+  TPayload = any,
+>(
+  entities: TState,
+  eventHandler: (
+    state: TState,
+    payload: TPayload,
+    api: MockApi<TEntity, TState>,
+  ) => void,
+  eventPayload: TPayload,
+  api?: MockApi<TEntity, TState>,
+): TriggerResult<TState>

package/src/entities.test.js

@@ -1,51 +0,0 @@
-import { expect, test } from "vitest"
-
-import { augmentEntities, augmentEntity } from "./entities.js"
-
-test("augmentEntity should add an id to an entity", () => {
-  const entity = { type: "player", health: 100 }
-  const result = augmentEntity("player1", entity)
-
-  expect(result).toStrictEqual({ id: "player1", type: "player", health: 100 })
-})
-
-test("augmentEntity should not mutate the original entity", () => {
-  const entity = { type: "player" }
-  augmentEntity("player1", entity)
-
-  expect(entity).toStrictEqual({ type: "player" })
-  expect(entity).not.toHaveProperty("id")
-})
-
-test("augmentEntity should overwrite an existing id property", () => {
-  const entity = { id: "oldId", type: "player" }
-  const result = augmentEntity("newId", entity)
-
-  expect(result).toStrictEqual({ id: "newId", type: "player" })
-})
-
-test("augmentEntities should augment a collection of entities", () => {
-  const entities = {
-    player1: { type: "player", health: 100 },
-    enemy1: { type: "enemy", damage: 10 },
-  }
-  const result = augmentEntities(entities)
-
-  expect(result).toStrictEqual({
-    player1: { id: "player1", type: "player", health: 100 },
-    enemy1: { id: "enemy1", type: "enemy", damage: 10 },
-  })
-})
-
-test("augmentEntities should handle an empty collection", () => {
-  const result = augmentEntities({})
-
-  expect(result).toStrictEqual({})
-})
-
-test("augmentEntities should not mutate the original entities object", () => {
-  const entities = { player1: { type: "player" } }
-  augmentEntities(entities)
-
-  expect(entities.player1).not.toHaveProperty("id")
-})

package/src/event-map.test.js

@@ -1,214 +0,0 @@
-import { performance } from "node:perf_hooks"
-
-import { expect, test, vi } from "vitest"
-
-import { EventMap } from "./event-map.js"
-
-test("constructor should initialize the event map from types and entities", () => {
-  const types = {
-    player: {
-      update: () => {},
-      fire: () => {},
-    },
-    enemy: {
-      update: () => {},
-    },
-    item: {}, // Type with no events
-  }
-  const entities = {
-    player1: { type: "player" },
-    player2: { type: "player" },
-    enemy1: { type: "enemy" },
-    item1: { type: "item" },
-    ghost1: { type: "ghost" }, // Type that doesn't exist
-  }
-
-  const eventMap = new EventMap(types, entities)
-
-  expect(eventMap.getEntitiesForEvent("update")).toStrictEqual([
-    "player1",
-    "player2",
-    "enemy1",
-  ])
-  expect(eventMap.getEntitiesForEvent("fire")).toStrictEqual([
-    "player1",
-    "player2",
-  ])
-
-  // 'item' type has no events, so it shouldn't be in the map
-  expect(eventMap.getEntitiesForEvent("item")).toStrictEqual([])
-  // 'ghost' type doesn't exist, so it should be ignored
-  expect(eventMap.getEntitiesForEvent("ghost")).toStrictEqual([])
-})
-
-test("addEntity should add an entity to the correct event sets", () => {
-  const types = {
-    player: {
-      update: () => {},
-      jump: () => {},
-    },
-  }
-  const eventMap = new EventMap(types, {})
-
-  eventMap.addEntity("player1", types.player, "player")
-
-  expect(eventMap.getEntitiesForEvent("update")).toStrictEqual(["player1"])
-  expect(eventMap.getEntitiesForEvent("jump")).toStrictEqual(["player1"])
-
-  // Add another entity of the same type
-  eventMap.addEntity("player2", types.player, "player")
-  expect(eventMap.getEntitiesForEvent("update")).toStrictEqual([
-    "player1",
-    "player2",
-  ])
-  expect(eventMap.getEntitiesForEvent("jump")).toStrictEqual([
-    "player1",
-    "player2",
-  ])
-})
-
-test("removeEntity should remove an entity from its event sets", () => {
-  const types = {
-    player: {
-      update: () => {},
-      fire: () => {},
-    },
-  }
-  const entities = {
-    player1: { type: "player" },
-    player2: { type: "player" },
-  }
-  const eventMap = new EventMap(types, entities)
-
-  eventMap.removeEntity("player1", types.player, "player")
-
-  expect(eventMap.getEntitiesForEvent("update")).toStrictEqual(["player2"])
-  expect(eventMap.getEntitiesForEvent("fire")).toStrictEqual(["player2"])
-
-  // Removing a non-existent entity should not throw an error
-  expect(() =>
-    eventMap.removeEntity("player3", types.player, "player"),
-  ).not.toThrow()
-})
-
-test("getEntitiesForEvent should return the correct set of entities for an event", () => {
-  const types = {
-    player: { update: () => {} },
-    enemy: { update: () => {} },
-  }
-  const entities = {
-    player1: { type: "player" },
-    enemy1: { type: "enemy" },
-  }
-  const eventMap = new EventMap(types, entities)
-
-  const updateEntities = eventMap.getEntitiesForEvent("update")
-  expect(updateEntities).toStrictEqual(["player1", "enemy1"])
-
-  const fireEntities = eventMap.getEntitiesForEvent("fire")
-  expect(fireEntities).toStrictEqual([])
-})
-
-test("getEntitiesForEvent should handle scoped events correctly", () => {
-  const types = {
-    form: { submit: () => {} },
-    button: { submit: () => {} },
-  }
-  const entities = {
-    loginForm: { type: "form" },
-    signupForm: { type: "form" },
-    submitButton: { type: "button" },
-  }
-  const eventMap = new EventMap(types, entities)
-
-  // Scoped to a type: 'form:submit' should only return form entities
-  expect(eventMap.getEntitiesForEvent("form:submit")).toStrictEqual([
-    "loginForm",
-    "signupForm",
-  ])
-
-  // Scoped to a specific entity by ID: '#loginForm:submit'
-  expect(eventMap.getEntitiesForEvent("#loginForm:submit")).toStrictEqual([
-    "loginForm",
-  ])
-
-  // Scoped to a specific entity by type and ID: 'form#loginForm:submit'
-  expect(eventMap.getEntitiesForEvent("form#loginForm:submit")).toStrictEqual([
-    "loginForm",
-  ])
-
-  // Scoped to a non-existent entity ID
-  expect(eventMap.getEntitiesForEvent("#nonExistent:submit")).toStrictEqual([])
-
-  // Scoped to an entity that exists but doesn't handle the event
-  expect(eventMap.getEntitiesForEvent("#loginForm:click")).toStrictEqual([])
-
-  // Scoped to an entity ID, but with the wrong type specified
-  expect(eventMap.getEntitiesForEvent("button#loginForm:submit")).toStrictEqual(
-    [],
-  )
-
-  // Broadcast event should return all entities with the handler
-  expect(eventMap.getEntitiesForEvent("submit")).toStrictEqual([
-    "loginForm",
-    "signupForm",
-    "submitButton",
-  ])
-})
-
-test("EventMap provides a significant performance benefit for event handling", async () => {
-  const ENTITY_COUNT = 10000
-  const { entities, types } = createTestEntities(ENTITY_COUNT)
-  const eventMap = new EventMap(types, entities)
-
-  // We'll use a mock function to ensure the "work" is consistent
-  const updateHandler = vi.fn()
-  types.updater.update = updateHandler
-
-  // --- Simulation A: The Old Way (iterating all entities) ---
-  const oldWayStartTime = performance.now()
-  for (const id in entities) {
-    const entity = entities[id]
-    const type = types[entity.type]
-    if (type.update) {
-      type.update()
-    }
-  }
-  const oldWayTime = performance.now() - oldWayStartTime
-
-  // Reset the mock for the next simulation
-  updateHandler.mockClear()
-
-  // --- Simulation B: The New Way (using EventMap) ---
-  const newWayStartTime = performance.now()
-  const updaterIds = eventMap.getEntitiesForEvent("update")
-  for (const id of updaterIds) {
-    const entity = entities[id]
-    const type = types[entity.type]
-    type.update()
-  }
-  const newWayTime = performance.now() - newWayStartTime
-
-  // Assertions to verify correctness
-  expect(oldWayTime).toBeGreaterThan(newWayTime)
-  expect(updateHandler).toHaveBeenCalledTimes(updaterIds.length)
-})
-
-// Helper function to create a large set of test entities
-function createTestEntities(count) {
-  const entities = {}
-  const types = {}
-  // 10% of entities will have a mock 'update' handler
-  const updaterType = { update: vi.fn() }
-  const staticType = {}
-
-  for (let i = 0; i < count; i++) {
-    const isUpdater = Math.random() < 0.1
-    const typeId = isUpdater ? "updater" : "static"
-    entities[`entity-${i}`] = { id: `entity-${i}`, type: typeId }
-  }
-  types["updater"] = updaterType
-  types["static"] = staticType
-
-  return { entities, types }
-}

package/src/store.test.js

@@ -1,178 +0,0 @@
-import { expect, test } from "vitest"
-
-import { createStore } from "./store.js"
-
-test("it should process events by mutating state inside handlers", () => {
-  const config = {
-    types: {
-      kitty: {
-        feed(entity) {
-          entity.isFed = true
-        },
-      },
-    },
-    entities: {
-      kitty1: { type: "kitty" },
-    },
-  }
-  const afterState = {
-    kitty1: {
-      id: "kitty1",
-      type: "kitty",
-      isFed: true,
-    },
-  }
-
-  const store = createStore(config)
-  store.notify("feed")
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should process an event queue in the same update cycle", () => {
-  const config = {
-    types: {
-      kitty: {
-        feed(entity) {
-          entity.isFed = true
-        },
-        update(entity) {
-          entity.isMeowing = true
-        },
-      },
-    },
-
-    entities: {
-      kitty1: { type: "kitty" },
-    },
-  }
-  const afterState = {
-    kitty1: {
-      id: "kitty1",
-      type: "kitty",
-      isFed: true,
-      isMeowing: true,
-    },
-  }
-
-  const store = createStore(config)
-  store.notify("feed")
-  store.notify("update")
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should send an event from an entity and process it in the same update cycle in batched mode", () => {
-  const config = {
-    types: {
-      doggo: {
-        update(entity, dt, api) {
-          api.notify("bark")
-        },
-      },
-      kitty: {
-        bark(entity) {
-          entity.position = "far"
-        },
-      },
-    },
-
-    entities: {
-      doggo1: { type: "doggo" },
-      kitty1: { type: "kitty", position: "near" },
-    },
-
-    updateMode: "manual",
-  }
-  const afterState = {
-    doggo1: { id: "doggo1", type: "doggo" },
-    kitty1: { id: "kitty1", type: "kitty", position: "far" },
-  }
-
-  const store = createStore(config)
-  const api = { notify: store.notify }
-  store.notify("update")
-  store.update(api)
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should add an entity via an 'add' event", () => {
-  const config = {
-    types: {
-      kitty: {},
-    },
-    entities: {},
-  }
-  const newEntity = { id: "kitty1", type: "kitty" }
-  const afterState = {
-    kitty1: { id: "kitty1", type: "kitty" },
-  }
-
-  const store = createStore(config)
-  store.notify("add", newEntity)
-  store.update()
-
-  const state = store.getState()
-  expect(state).toStrictEqual(afterState)
-})
-
-test("it should remove an entity via a 'remove' event", () => {
-  const config = {
-    types: {},
-    entities: {
-      kitty1: { type: "kitty" },
-    },
-  }
-  const store = createStore(config)
-
-  store.notify("remove", "kitty1")
-  store.update()
-
-  const state = store.getState()
-  expect(state.kitty1).toBeUndefined()
-})
-
-test("it should change an entity's behavior via a 'morph' event", () => {
-  const Caterpillar = {
-    eat(entity) {
-      entity.isFull = true
-    },
-  }
-  const Butterfly = {
-    fly(entity) {
-      entity.hasFlown = true
-    },
-  }
-
-  const config = {
-    types: {
-      bug: Caterpillar,
-    },
-
-    entities: {
-      bug: { type: "bug" },
-    },
-  }
-
-  const store = createStore(config)
-
-  store.notify("eat")
-  store.update()
-
-  expect(store.getState()).toStrictEqual({
-    bug: { id: "bug", type: "bug", isFull: true },
-  })
-
-  store.notify("morph", { name: "bug", type: [Caterpillar, Butterfly] })
-  store.notify("fly")
-  store.update()
-  expect(store.getState()).toStrictEqual({
-    bug: { id: "bug", type: "bug", isFull: true, hasFlown: true },
-  })
-})

package/src/test.test.js

@@ -1,272 +0,0 @@
-import { describe, expect, it } from "vitest"
-
-import { createMockApi, trigger } from "./test"
-
-describe("createMockApi", () => {
-  it("should create a mock API with all required methods", () => {
-    const entities = { counter1: { type: "counter", value: 0 } }
-
-    const api = createMockApi(entities)
-
-    expect(api.getEntities).toBeDefined()
-    expect(api.getEntity).toBeDefined()
-    expect(api.dispatch).toBeDefined()
-    expect(api.notify).toBeDefined()
-    expect(api.getEvents).toBeDefined()
-  })
-
-  it("should return all entities via getEntities()", () => {
-    const entities = {
-      counter1: { type: "counter", value: 5 },
-      counter2: { type: "counter", value: 10 },
-    }
-
-    const api = createMockApi(entities)
-
-    expect(api.getEntities()).toEqual(entities)
-  })
-
-  it("should return a specific entity via getEntity()", () => {
-    const entities = {
-      counter1: { type: "counter", value: 5 },
-      counter2: { type: "counter", value: 10 },
-    }
-
-    const api = createMockApi(entities)
-
-    expect(api.getEntity("counter1")).toEqual({ type: "counter", value: 5 })
-    expect(api.getEntity("counter2")).toEqual({ type: "counter", value: 10 })
-  })
-
-  it("should return undefined for non-existent entity", () => {
-    const entities = {
-      counter1: { type: "counter", value: 5 },
-    }
-
-    const api = createMockApi(entities)
-
-    expect(api.getEntity("nonexistent")).toBeUndefined()
-  })
-
-  it("should track dispatched events", () => {
-    const entities = {
-      counter1: { type: "counter", value: 0 },
-    }
-
-    const api = createMockApi(entities)
-
-    api.dispatch({ type: "increment", payload: { id: "counter1" } })
-    api.dispatch({ type: "decrement", payload: { id: "counter1" } })
-
-    expect(api.getEvents()).toEqual([
-      { type: "increment", payload: { id: "counter1" } },
-      { type: "decrement", payload: { id: "counter1" } },
-    ])
-  })
-
-  it("should track events dispatched via notify()", () => {
-    const entities = {
-      counter1: { type: "counter", value: 0 },
-    }
-
-    const api = createMockApi(entities)
-
-    api.notify("increment", { id: "counter1", amount: 5 })
-    api.notify("overflow")
-
-    expect(api.getEvents()).toEqual([
-      { type: "increment", payload: { id: "counter1", amount: 5 } },
-      { type: "overflow", payload: undefined },
-    ])
-  })
-
-  it("should freeze entities to prevent mutations", () => {
-    const entities = {
-      counter1: { type: "counter", value: 0 },
-    }
-
-    const api = createMockApi(entities)
-    const allEntities = api.getEntities()
-
-    expect(() => {
-      allEntities.counter1 = { type: "counter", value: 999 }
-    }).toThrow()
-  })
-
-  it("should start with empty events array", () => {
-    const entities = {
-      counter1: { type: "counter", value: 0 },
-    }
-
-    const api = createMockApi(entities)
-
-    expect(api.getEvents()).toEqual([])
-  })
-})
-
-describe("trigger", () => {
-  it("should execute handler and return new entity", () => {
-    const entityBefore = { type: "counter", value: 0 }
-    const entityAfter = { type: "counter", value: 5 }
-
-    function increment(entity, amount) {
-      entity.value += amount
-    }
-
-    const { entity } = trigger(entityBefore, increment, 5)
-
-    expect(entity).toStrictEqual(entityAfter)
-  })
-
-  it("should not mutate original entity", () => {
-    const entityBefore = { type: "counter", value: 0 }
-
-    function increment(entity, amount) {
-      entity.value += amount
-    }
-
-    trigger(entityBefore, increment, 5)
-
-    expect(entityBefore.value).toBe(0)
-  })
-
-  it("should capture events dispatched during handler execution", () => {
-    const entityBefore = { type: "counter", value: 99 }
-    const entityAfter = { type: "counter", value: 104 }
-    const eventsAfter = [{ type: "overflow", payload: 104 }]
-
-    function increment(entity, amount, api) {
-      entity.value += amount
-
-      if (entity.value > 100) {
-        api.notify("overflow", entity.value)
-      }
-    }
-
-    const { entity, events } = trigger(entityBefore, increment, 5)
-
-    expect(entity).toStrictEqual(entityAfter)
-    expect(events).toStrictEqual(eventsAfter)
-  })
-
-  it("should work with handlers that do not dispatch events", () => {
-    const entityBefore = { type: "todo", text: "Buy milk", completed: false }
-    const entityAfter = { type: "todo", text: "Buy milk", completed: true }
-    const eventsAfter = []
-
-    function toggle(entity) {
-      entity.completed = !entity.completed
-    }
-
-    const { entity, events } = trigger(entityBefore, toggle)
-
-    expect(entity).toStrictEqual(entityAfter)
-    expect(events).toStrictEqual(eventsAfter)
-  })
-
-  it("should allow handler to read other entities via API", () => {
-    const entityBefore = { id: "counter2", type: "counter", value: 20 }
-    const entityAfter = { id: "counter2", type: "counter", value: 30 }
-
-    const mockApi = createMockApi({
-      counter1: { id: "counter1", type: "counter", value: 10 },
-      counter2: { id: "counter2", type: "counter", value: 20 },
-    })
-
-    function addFromSource(entity, sourceId, api) {
-      const source = api.getEntity(sourceId)
-      if (source) {
-        entity.value += source.value
-      }
-    }
-
-    const { entity } = trigger(entityBefore, addFromSource, "counter1", mockApi)
-
-    expect(entity).toStrictEqual(entityAfter)
-  })
-
-  it("should accept custom mock API", () => {
-    const entityBefore = { type: "counter", value: 0 }
-    const entityAfter = { type: "counter", value: 5 }
-    const eventsAfter = [{ type: "incremented", payload: undefined }]
-
-    const customApi = createMockApi(entityBefore)
-
-    function increment(entity, amount, api) {
-      entity.value += amount
-      api.notify("incremented")
-    }
-
-    const { entity } = trigger(entityBefore, increment, 5, customApi)
-
-    expect(entity).toStrictEqual(entityAfter)
-    expect(customApi.getEvents()).toStrictEqual(eventsAfter)
-  })
-
-  it("should handle multiple dispatched events", () => {
-    const entityBefore = { type: "counter", value: 50 }
-    const entityAfter = { type: "counter", value: 110 }
-    const eventsAfter = [
-      { type: "increment:start", payload: undefined },
-      { type: "milestone:hundred", payload: undefined },
-      { type: "increment:complete", payload: 110 },
-    ]
-
-    function increment(entity, amount, api) {
-      api.notify("increment:start")
-
-      entity.value += amount
-
-      if (entity.value >= 100) {
-        api.notify("milestone:hundred")
-      }
-
-      api.notify("increment:complete", entity.value)
-    }
-
-    const { entity, events } = trigger(entityBefore, increment, 60)
-
-    expect(entity).toStrictEqual(entityAfter)
-    expect(events).toStrictEqual(eventsAfter)
-  })
-
-  it("should work without payload", () => {
-    const entityBefore = { type: "counter", value: 5 }
-    const entityAfter = { type: "counter", value: 0 }
-
-    function reset(entity) {
-      entity.value = 0
-    }
-
-    const { entity } = trigger(entityBefore, reset)
-
-    expect(entity).toStrictEqual(entityAfter)
-  })
-
-  it("should work with complex entity mutations", () => {
-    const entityBefore = {
-      type: "player",
-      name: "Alice",
-      inventory: ["sword", "shield"],
-      stats: { health: 100, mana: 50 },
-    }
-    const entityAfter = {
-      type: "player",
-      name: "Alice",
-      inventory: ["sword", "shield", "potion"],
-      stats: { health: 100, mana: 50 },
-    }
-
-    function addItem(entity, item, api) {
-      entity.inventory.push(item)
-      api.notify("item:added", { item })
-    }
-
-    const { entity, events } = trigger(entityBefore, addItem, "potion")
-
-    expect(entity).toStrictEqual(entityAfter)
-    expect(events).toEqual([
-      { type: "item:added", payload: { item: "potion" } },
-    ])
-  })
-})

package/src/types.test.js

@@ -1,87 +0,0 @@
-import { expect, test } from "vitest"
-
-import { augmentType, augmentTypes } from "./types.js"
-
-test("should handle a single behavior object (mixin)", () => {
-  const behavior = { onFire: () => "bang" }
-  const result = augmentType(behavior)
-
-  expect(result).toStrictEqual(behavior)
-  // Ensure it's a new object, not the same reference
-  expect(result).not.toBe(behavior)
-})
-
-test("should compose an array of behavior objects (mixins)", () => {
-  const behavior1 = { onFire: () => "bang", onMove: () => "vroom" }
-  const behavior2 = { onJump: () => "boing", onFire: () => "pow" } // onFire overwrites
-  const result = augmentType([behavior1, behavior2])
-
-  expect(result).toHaveProperty("onMove")
-  expect(result).toHaveProperty("onJump")
-  expect(result).toHaveProperty("onFire")
-  expect(result.onFire()).toBe("pow")
-})
-
-test("should handle a single behavior function", () => {
-  const behavior = (type) => ({ ...type, onJump: () => "boing" })
-  const result = augmentType(behavior)
-
-  expect(result).toHaveProperty("onJump")
-  expect(result.onJump()).toBe("boing")
-})
-
-test("should compose an array of behavior functions (pipe)", () => {
-  const behavior1 = (type) => ({ ...type, onMove: () => "vroom" })
-  const behavior2 = (type) => ({ ...type, onJump: () => "boing" })
-  const result = augmentType([behavior1, behavior2])
-
-  expect(result).toHaveProperty("onMove")
-  expect(result).toHaveProperty("onJump")
-  expect(result.onMove()).toBe("vroom")
-  expect(result.onJump()).toBe("boing")
-})
-
-test("should compose a mixed array of objects and functions", () => {
-  const mixin1 = { onFire: () => "bang" }
-  const behavior1 = (type) => ({ ...type, onJump: () => "boing" })
-  const mixin2 = { onMove: () => "vroom", onFire: () => "pow" } // onFire overwrites
-
-  const result = augmentType([mixin1, behavior1, mixin2])
-
-  expect(result).toHaveProperty("onFire")
-  expect(result).toHaveProperty("onJump")
-  expect(result).toHaveProperty("onMove")
-  expect(result.onFire()).toBe("pow")
-  expect(result.onJump()).toBe("boing")
-  expect(result.onMove()).toBe("vroom")
-})
-
-test("should return an empty object for an empty array", () => {
-  const result = augmentType([])
-  expect(result).toStrictEqual({})
-})
-
-test("should handle undefined or null input gracefully", () => {
-  expect(augmentType(undefined)).toStrictEqual({})
-  expect(augmentType(null)).toStrictEqual({})
-})
-
-test("should augment a map of types correctly", () => {
-  const types = {
-    player: { onJump: () => "boing" },
-    enemy: [
-      { onMove: () => "stomp" },
-      (type) => ({ ...type, onAttack: () => "bite" }),
-    ],
-    item: [],
-  }
-
-  const result = augmentTypes(types)
-
-  expect(result.player).toStrictEqual({ onJump: expect.any(Function) })
-  expect(result.enemy).toStrictEqual({
-    onMove: expect.any(Function),
-    onAttack: expect.any(Function),
-  })
-  expect(result.item).toStrictEqual({})
-})