@inglorious/engine 0.3.0 → 0.4.0

package/README.md

@@ -1,5 +1,6 @@
 # Inglorious Engine
 
+[![NPM version](https://img.shields.io/npm/v/@inglorious/engine.svg)](https://www.npmjs.com/package/@inglorious/engine)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 A JavaScript game engine written with global state, immutability, and pure functions in mind. Have fun(ctional programming) with it!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inglorious/engine",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A JavaScript game engine written with global state, immutability, and pure functions in mind. Have fun(ctional programming) with it!",
   "author": "IceOnFire <antony.mistretta@gmail.com> (https://ingloriouscoderz.it)",
   "license": "MIT",
@@ -32,11 +32,10 @@
     "access": "public"
   },
   "dependencies": {
-    "immer": "^10.1.1",
+    "@inglorious/store": "1.0.0",
     "@inglorious/utils": "1.1.0"
   },
   "devDependencies": {
-    "husky": "^9.1.7",
     "prettier": "^3.5.3",
     "vite": "^7.1.3",
     "vitest": "^1.6.0"

package/src/behaviors/fsm.test.js

@@ -1,6 +1,6 @@
+import { createStore } from "@inglorious/store/store.js"
 import { expect, test } from "vitest"
 
-import { createStore } from "../core/store.js"
 import { fsm } from "./fsm.js"
 
 test("it should add a finite state machine", () => {

package/src/core/engine.js

@@ -1,7 +1,8 @@
 import { game } from "@inglorious/engine/behaviors/game.js"
+import { createApi } from "@inglorious/store/api.js"
+import { createStore } from "@inglorious/store/store.js"
 import { extend } from "@inglorious/utils/data-structures/objects.js"
 
-import { createApi } from "./api.js"
 import {
   ACTION_BLACKLIST,
   disconnectDevTools,
@@ -9,7 +10,6 @@ import {
   sendAction,
 } from "./dev-tools.js"
 import Loop from "./loop.js"
-import { createStore } from "./store.js"
 
 // Default game configuration
 // loop.type specifies the type of loop to use (defaults to "animationFrame").

package/src/core/api.js

@@ -1,34 +0,0 @@
-import { createSelector as _createSelector } from "./select.js"
-
-export function createApi(store) {
-  const createSelector = (inputSelectors, resultFunc) => {
-    const selector = _createSelector(inputSelectors, resultFunc)
-    return () => selector(store.getState())
-  }
-
-  const getTypes = () => store.getTypes()
-
-  const getEntities = () => store.getState().entities
-
-  const getEntity = (id) => getEntities()[id]
-
-  const notify = (type, payload) => {
-    store.notify(type, payload)
-  }
-
-  const dispatch = (action) => {
-    store.dispatch(action)
-  }
-
-  const getType = (id) => store.getOriginalTypes()?.[id]
-
-  return {
-    createSelector,
-    getTypes,
-    getEntities,
-    getEntity,
-    getType,
-    notify,
-    dispatch,
-  }
-}

package/src/core/select.js

@@ -1,26 +0,0 @@
-/**
- * Creates a memoized selector function.
- * NB: this implementation does not support spreading the input selectors for clarity, please just put them in an array.
- * @param {Array<Function>} inputSelectors - An array of input selector functions.
- * @param {Function} resultFunc - A function that receives the results of the input selectors and returns a computed value.
- * @returns {Function} A memoized selector function that, when called, returns the selected state.
- */
-export function createSelector(inputSelectors, resultFunc) {
-  let lastInputs = []
-  let lastResult = null
-
-  return (state) => {
-    const nextInputs = inputSelectors.map((selector) => selector(state))
-    const inputsChanged =
-      lastInputs.length !== nextInputs.length ||
-      nextInputs.some((input, index) => input !== lastInputs[index])
-
-    if (!inputsChanged) {
-      return lastResult
-    }
-
-    lastInputs = nextInputs
-    lastResult = resultFunc(...nextInputs)
-    return lastResult
-  }
-}

package/src/core/store.js

@@ -1,178 +0,0 @@
-import { map } from "@inglorious/utils/data-structures/object.js"
-import { extend } from "@inglorious/utils/data-structures/objects.js"
-import { pipe } from "@inglorious/utils/functions/functions.js"
-import { produce } from "immer"
-
-/**
- * Creates a store to manage state and events.
- * @param {Object} config - Configuration options for the store.
- * @param {Object} [config.types] - The initial types configuration.
- * @param {Object} [config.entities] - The initial entities configuration.
- * @returns {Object} The store with methods to interact with state and events.
- */
-export function createStore({
-  types: originalTypes,
-  entities: originalEntities,
-  systems = [],
-}) {
-  const listeners = new Set()
-  let incomingEvents = []
-
-  let types = augmentTypes(originalTypes)
-  let entities = augmentEntities(originalEntities)
-
-  const initialState = { entities }
-  let state = initialState
-
-  return {
-    subscribe,
-    update,
-    notify,
-    dispatch, // needed for compatibility with Redux
-    getTypes,
-    getOriginalTypes,
-    getState,
-    setState,
-    reset,
-  }
-
-  /**
-   * Subscribes a listener to state updates.
-   * @param {Function} listener - The listener function to call on updates.
-   * @returns {Function} A function to unsubscribe the listener.
-   */
-  function subscribe(listener) {
-    listeners.add(listener)
-
-    return function unsubscribe() {
-      listeners.delete(listener)
-    }
-  }
-
-  /**
-   * Updates the state based on elapsed time and processes events.
-   * @param {number} dt - The delta time since the last update in milliseconds.
-   * @param {Object} api - The engine's public API.
-   */
-  function update(dt, api) {
-    const processedEvents = []
-
-    state = produce(state, (state) => {
-      incomingEvents.push({ type: "update", payload: dt })
-
-      while (incomingEvents.length) {
-        const event = incomingEvents.shift()
-        processedEvents.push(event)
-
-        if (event.type === "morph") {
-          const { id, type } = event.payload
-          originalTypes[id] = type
-          types = augmentTypes(originalTypes)
-        }
-
-        if (event.type === "add") {
-          const { id, ...entity } = event.payload
-          state.entities[id] = augmentEntity(id, entity)
-        }
-
-        if (event.type === "remove") {
-          const id = event.payload
-          delete state.entities[id]
-        }
-
-        for (const id in state.entities) {
-          const entity = state.entities[id]
-          const type = types[entity.type]
-          const handle = type[event.type]
-          handle?.(entity, event.payload, api)
-        }
-
-        systems.forEach((system) => {
-          const handle = system[event.type]
-          handle?.(state, event.payload, api)
-        })
-      }
-    })
-
-    listeners.forEach((onUpdate) => onUpdate())
-
-    return processedEvents
-  }
-
-  /**
-   * Notifies the store of a new event.
-   * @param {string} type - The event object type to notify.
-   * @param {any} payload - The event object payload to notify.
-   */
-  function notify(type, payload) {
-    dispatch({ type, payload })
-  }
-
-  /**
-   * Dispatches an event to be processed in the next update cycle.
-   * @param {Object} event - The event object.
-   * @param {string} event.type - The type of the event.
-   * @param {any} [event.payload] - The payload of the event.
-   */
-  function dispatch(event) {
-    incomingEvents.push(event)
-  }
-
-  /**
-   * Retrieves the augmented types configuration.
-   * This includes composed behaviors and event handlers wrapped for immutability.
-   * @returns {Object} The augmented types configuration.
-   */
-  function getTypes() {
-    return types
-  }
-
-  /**
-   * Retrieves the original, un-augmented types configuration.
-   * @returns {Object} The original types configuration.
-   */
-  function getOriginalTypes() {
-    return originalTypes
-  }
-
-  /**
-   * Retrieves the current state.
-   * @returns {Object} The current state.
-   */
-  function getState() {
-    return state
-  }
-
-  function setState(newState) {
-    state = newState
-  }
-
-  function reset() {
-    state = initialState // Reset state to its originally computed value
-  }
-}
-
-function augmentTypes(types) {
-  return pipe(applyBehaviors)(types)
-}
-
-function applyBehaviors(types) {
-  return map(types, (_, type) => {
-    if (!Array.isArray(type)) {
-      return type
-    }
-
-    const behaviors = type.map((fn) =>
-      typeof fn !== "function" ? (type) => extend(type, fn) : fn,
-    )
-    return pipe(...behaviors)({})
-  })
-}
-
-function augmentEntities(entities) {
-  return map(entities, augmentEntity)
-}
-
-function augmentEntity(id, entity) {
-  return { ...entity, id }
-}

package/src/core/store.test.js

@@ -1,110 +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
-        },
-        update(entity) {
-          entity.isMeowing = true
-        },
-      },
-    },
-    entities: {
-      kitty1: { type: "kitty" },
-    },
-  }
-  const afterState = {
-    entities: {
-      kitty1: {
-        id: "kitty1",
-        type: "kitty",
-        isFed: true,
-        isMeowing: true,
-      },
-    },
-  }
-
-  const store = createStore(config)
-  store.notify("feed")
-  store.update(0, {})
-
-  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", () => {
-  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" },
-    },
-  }
-  const afterState = {
-    entities: {
-      doggo1: { id: "doggo1", type: "doggo" },
-      kitty1: { id: "kitty1", type: "kitty", position: "far" },
-    },
-  }
-
-  const store = createStore(config)
-  const api = { notify: store.notify }
-  store.update(0, 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 store = createStore(config)
-  store.notify("add", newEntity)
-  store.update(0, {})
-
-  const state = store.getState()
-  expect(state).toStrictEqual({
-    entities: {
-      kitty1: { id: "kitty1", type: "kitty" },
-    },
-  })
-})
-
-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(0, {})
-
-  const state = store.getState()
-  expect(state.entities.kitty1).toBeUndefined()
-})