@daneren2005/shared-memory-ecs 1.0.0 → 1.0.1

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@daneren2005/shared-memory-ecs",
 	"description": "A small, reusable Entity/Component/System core backed by shared memory.",
 	"author": "Scott Jackson",
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"type": "module",
 	"repository": {
 		"type": "git",
@@ -27,7 +27,7 @@
 	],
 	"scripts": {
 		"build": "vite build && tsc --emitDeclarationOnly",
-		"type-check": "tsc --noEmit -p tsconfig.test.json",
+		"type-check": "tsc --noEmit",
 		"lint": "cross-env NODE_ENV=production oxlint .",
 		"lint:fix": "cross-env NODE_ENV=production oxlint --fix .",
 		"test": "vitest run",
@@ -39,7 +39,6 @@
 		"eventemitter3": "^3.1.2"
 	},
 	"devDependencies": {
-		"@semantic-release/changelog": "^6.0.3",
 		"@semantic-release/git": "^10.0.1",
 		"@stylistic/eslint-plugin": "^5.10.0",
 		"@types/node": "^26.1.1",

package/dist/component-definition.d.ts

@@ -1,17 +0,0 @@
-import type { TypedArrayConstructor } from '@daneren2005/shared-memory-objects';
-import type MemoryComponent from './memory-component';
-import type { ComponentTypedArray } from './memory-component';
-import type BaseEntity from './entity';
-export interface BaseComponent {
-    index: number;
-}
-export type ComponentMap = Record<string, BaseComponent>;
-export interface ComponentDefinition<Component extends BaseComponent, T extends ComponentTypedArray = ComponentTypedArray, Config = any, Serialization = any> {
-    type: TypedArrayConstructor<T>;
-    size: number;
-    load(entity: BaseEntity, memory: MemoryComponent<T>, config: Config): Component;
-    save?(component: Component): Serialization;
-}
-export type ComponentRegistry<C extends ComponentMap> = {
-    [K in keyof C]: ComponentDefinition<C[K]>;
-};

package/dist/entity.d.ts

@@ -1,28 +0,0 @@
-import { EventEmitter } from 'eventemitter3';
-import type BaseWorld from './world';
-import type { ComponentMap } from './component-definition';
-export default class BaseEntity<C extends ComponentMap = ComponentMap> extends EventEmitter {
-    static eidCounter: number;
-    readonly eid: number;
-    id?: string;
-    config?: any;
-    world: BaseWorld<C>;
-    components: Partial<C>;
-    dead: boolean;
-    isStatic: boolean;
-    constructor(world: BaseWorld<C>, config?: any);
-    loadComponent<K extends keyof C>(name: K, config: any): C[K];
-    removeComponent<K extends keyof C>(name: K): void;
-    setComponent<K extends keyof C, P extends keyof C[K]>(componentName: K, prop: P, value: C[K][P]): void;
-    /**
-     * NOTE: Does not emit component-property-updated!
-     */
-    setComponentBulk<K extends keyof C>(componentName: K, values: Partial<C[K]>): void;
-    deleteComponent<K extends keyof C>(componentName: K, prop: keyof C[K]): void;
-    deleteAllComponentMemory(): void;
-    load(config: any): void;
-    save(): {
-        [key: string]: any;
-    };
-    finishLoading(): void;
-}

package/dist/index.d.ts

@@ -1,18 +0,0 @@
-export { default as BaseWorld } from './world';
-export type { WorldOptions } from './world';
-export { default as BaseEntity } from './entity';
-export { default as MemoryComponent } from './memory-component';
-export type { ComponentTypedArray } from './memory-component';
-export type { BaseComponent, ComponentMap, ComponentDefinition, ComponentRegistry, } from './component-definition';
-export { default as System } from './systems/system';
-export type { SystemConfig } from './systems/system';
-export { default as IterableSystem } from './systems/iterable-system';
-export type { IterableSystemConfig } from './systems/iterable-system';
-export { default as EntitySystem } from './systems/entity-system';
-export type { EntitySystemConfig } from './systems/entity-system';
-export { default as ComponentSystem } from './systems/component-system';
-export type { ComponentSystemConfig, ComponentSystemQuery, ComponentSystemWorld, ComponentSystemCallbacks, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfig, UpdateEntityConfigObject, } from './systems/component-system';
-export { default as WebWorker } from './systems/workers/web-worker';
-export { default as ComponentWebWorker } from './systems/workers/component-web-worker';
-export { default as createComponentWorker } from './systems/workers/create-component-worker';
-export type { default as ComponentWorkerMessage } from './systems/workers/component-worker-message';

package/dist/memory-component.d.ts

@@ -1,15 +0,0 @@
-import { LocalPool, type MemoryHeap, type TypedArrayConstructor } from '@daneren2005/shared-memory-objects';
-export type ComponentTypedArray = Uint32Array | Int32Array | Float32Array | Float64Array;
-export default class MemoryComponent<T extends ComponentTypedArray = ComponentTypedArray> {
-    heap: MemoryHeap;
-    pool: LocalPool<T>;
-    constructor(heap: MemoryHeap, type: TypedArrayConstructor<T>, dataLength: number);
-    get length(): number;
-    get rawLength(): number;
-    create(values: Array<number>): number;
-    getBlock(index: number): T;
-    get(index: number, dataIndex: number): number;
-    set(index: number, dataIndex: number, value: number): void;
-    delete(index: number): void;
-    clear(): void;
-}

package/dist/systems/component-system.d.ts

@@ -1,76 +0,0 @@
-import type BaseWorld from '../world';
-import type BaseEntity from '../entity';
-import type { BaseComponent, ComponentMap } from '../component-definition';
-import type { ComponentTypedArray } from '../memory-component';
-import System, { type SystemConfig } from './system';
-import ComponentWebWorker from './workers/component-web-worker';
-export default abstract class ComponentSystem<C extends ComponentMap = ComponentMap, T extends EntityUpdateComponents<C> = EntityUpdateComponents<C>> extends System<C> {
-    entities: Array<BaseEntity<C>>;
-    options: ComponentSystemConfig<C, T>;
-    worker: Worker | ComponentWebWorker<C, T>;
-    isWorkerThread: boolean;
-    private loaded;
-    private loadingPromise;
-    private isRunning;
-    private queryEntityComponentCache;
-    private queryEntities;
-    private removedEntityBuffer;
-    addDataToWorld?(world: ComponentSystemWorld): void;
-    constructor(world: BaseWorld<C>, options: ComponentSystemConfig<C, T>);
-    private initWorker;
-    init(): Promise<void> | void;
-    update(elapsedTime: number): boolean;
-    run(elapsedTime: number): void;
-    runQuery(queryName: string, entities: Array<BaseEntity<C>>, query: ComponentSystemQuery<C>): Array<UpdateEntityConfig<T>>;
-    isEntityInSystem(entity: BaseEntity<C>): boolean;
-    private matchesQuery;
-    private updateEntityList;
-    checkAddEntity(entity: BaseEntity<C>): boolean;
-    removeEntity(entity: BaseEntity<C>): void;
-    shouldRun(): boolean;
-    destroy(): void;
-}
-export type EntityUpdateComponents<C extends ComponentMap = ComponentMap> = {
-    [K in keyof C]?: ComponentTypedArray;
-};
-export type EntityQueryComponents<C extends ComponentMap = ComponentMap> = {
-    [key: string]: Array<{
-        entityId: number;
-        components: EntityUpdateComponents<C>;
-    }>;
-};
-type EntityUpdateFunctionImpl<C extends ComponentMap, T extends EntityUpdateComponents<C>> = (world: ComponentSystemWorld, entityId: number, components: T, queries: EntityQueryComponents<C>, callbacks: ComponentSystemCallbacks<C>) => void;
-export type EntityUpdateFunction<C extends ComponentMap, T extends EntityUpdateComponents<C> = EntityUpdateComponents<C>> = EntityUpdateFunctionImpl<C, T> & {
-    preRun?: EntityUpdatePreRunFunction<C, T>;
-    entityRemoved?: EntityRemovedFunction<C>;
-};
-export type EntityUpdatePreRunFunction<C extends ComponentMap, T extends EntityUpdateComponents<C>> = (world: ComponentSystemWorld, entities: Array<UpdateEntityConfigObject<T>>, queries: EntityQueryComponents<C>, callbacks: ComponentSystemCallbacks<C>) => void;
-export type EntityRemovedFunction<C extends ComponentMap = ComponentMap> = (world: ComponentSystemWorld, entityId: number, callbacks: ComponentSystemCallbacks<C>) => void;
-export type UpdateEntityConfig<T extends EntityUpdateComponents = EntityUpdateComponents> = number | UpdateEntityConfigObject<T>;
-export type UpdateEntityConfigObject<T extends EntityUpdateComponents> = {
-    entityId: number;
-    components: T;
-};
-export interface ComponentSystemWorld {
-    gameTime: number;
-    elapsedTime: number;
-    [key: string]: unknown;
-}
-export interface ComponentSystemCallbacks<C extends ComponentMap = ComponentMap> {
-    entityComponentChanged<K extends keyof C, P extends keyof C[K]>(entityId: number, componentName: K, prop: P, value: C[K][P]): void;
-}
-export interface ComponentSystemQuery<C extends ComponentMap = ComponentMap> {
-    required: Array<keyof C>;
-    optional?: Array<keyof C>;
-    not?: Array<keyof C>;
-    filter?: (entity: BaseEntity<C>) => boolean;
-}
-export interface ComponentSystemConfig<C extends ComponentMap, T extends EntityUpdateComponents<C>> extends SystemConfig, ComponentSystemQuery<C> {
-    updateFunction: EntityUpdateFunction<C, T>;
-    getWorker: () => Worker;
-    forceMainThread?: boolean;
-    queries?: {
-        [key: string]: ComponentSystemQuery<C>;
-    };
-}
-export type { BaseComponent };

package/dist/systems/entity-system.d.ts

@@ -1,21 +0,0 @@
-import type BaseWorld from '../world';
-import type BaseEntity from '../entity';
-import type { ComponentMap } from '../component-definition';
-import IterableSystem, { type IterableSystemConfig } from './iterable-system';
-export default abstract class EntitySystem<C extends ComponentMap, T extends BaseEntity<C> = BaseEntity<C>> extends IterableSystem<C, T> {
-    entities: Array<T>;
-    options: EntitySystemConfig<C>;
-    constructor(world: BaseWorld<C>, options?: EntitySystemConfig<C>);
-    getIterables(): Array<T>;
-    updateIterable(entity: T, elapsedTime: number): void;
-    filterEntity(entity: BaseEntity<C>): boolean;
-    isEntityInSystem(entity: BaseEntity<C>): boolean;
-    abstract updateEntity(entity: T, elapsedTime: number): void;
-    checkAddEntity(entity: BaseEntity<C>): boolean;
-    removeEntity(entity: BaseEntity<C>): void;
-    shouldRun(): boolean;
-}
-export interface EntitySystemConfig<C extends ComponentMap> extends IterableSystemConfig {
-    components?: Array<keyof C>;
-    updateEntityOnAdd?: boolean;
-}

package/dist/systems/iterable-system.d.ts

@@ -1,21 +0,0 @@
-import type BaseWorld from '../world';
-import type { ComponentMap } from '../component-definition';
-import System, { type SystemConfig } from './system';
-export default abstract class IterableSystem<C extends ComponentMap, T> extends System<C> {
-    remainingInstancesToRun: Array<T>;
-    remainingInstancesStartTime: number | null;
-    iterationsPerCheck: number;
-    maxMsPerFrame: number;
-    constructor(world: BaseWorld<C>, options: IterableSystemConfig);
-    clear(): void;
-    update(elapsedTime: number): boolean;
-    run(elapsedTime: number): void;
-    runIterables(iterables: Array<T>, elapsedTime: number): void;
-    beforeRunIterables(): void;
-    abstract getIterables(): Array<T>;
-    abstract updateIterable(iterable: T, elapsedTime: number): void;
-}
-export interface IterableSystemConfig extends SystemConfig {
-    iterationsPerCheck?: number;
-    maxMsPerFrame?: number;
-}

package/dist/systems/system.d.ts

@@ -1,22 +0,0 @@
-import type BaseWorld from '../world';
-import type { ComponentMap } from '../component-definition';
-export default abstract class System<C extends ComponentMap = ComponentMap> {
-    world: BaseWorld<C>;
-    name: string;
-    currentDelta: number;
-    deltaBetweenRuns: number;
-    firstRun: boolean;
-    constructor(world: BaseWorld<C>, options?: SystemConfig);
-    init(): void | Promise<void>;
-    clear(): void;
-    finishLoading(): void;
-    update(elapsedTime: number): boolean;
-    abstract run(elapsedTime: number): void;
-    shouldRun(): boolean;
-    destroy(): void;
-}
-export interface SystemConfig {
-    name: string;
-    deltaBetweenRuns?: number;
-    firstRun?: boolean;
-}

package/dist/systems/workers/component-web-worker.d.ts

@@ -1,10 +0,0 @@
-import WebWorker from './web-worker';
-import type ComponentWorkerMessage from './component-worker-message';
-import type { ComponentMap } from '../../component-definition';
-import type { EntityUpdateComponents, EntityUpdateFunction } from '../component-system';
-export default class ComponentWebWorker<C extends ComponentMap, T extends EntityUpdateComponents<C>> extends WebWorker {
-    private updateFunction;
-    constructor(updateFunction: EntityUpdateFunction<C, T>);
-    postMessage(message: ComponentWorkerMessage): void;
-    onMessageTyped(message: ComponentWorkerMessage): void;
-}

package/dist/systems/workers/component-worker-message.d.ts

@@ -1,27 +0,0 @@
-import type { ComponentSystemWorld, UpdateEntityConfig } from '../component-system';
-interface InitMessage {
-    type: 'init';
-}
-interface LoadedMessage {
-    type: 'loaded';
-}
-interface RunUpdateMessage {
-    type: 'run';
-    world: ComponentSystemWorld;
-    entities: Array<UpdateEntityConfig>;
-    queries: {
-        [key: string]: Array<UpdateEntityConfig>;
-    };
-    removed: Array<number>;
-}
-interface EntityEventsMessage {
-    type: 'run-complete';
-    runTime: number;
-    events: Array<{
-        entityId: number;
-        event: string;
-        args: Array<any>;
-    }>;
-}
-type ComponentWorkerMessage = InitMessage | LoadedMessage | RunUpdateMessage | EntityEventsMessage;
-export default ComponentWorkerMessage;

package/dist/systems/workers/create-component-worker.d.ts

@@ -1,3 +0,0 @@
-import type { ComponentMap } from '../../component-definition';
-import type { EntityUpdateComponents, EntityUpdateFunction } from '../component-system';
-export default function createComponentWorker<C extends ComponentMap, T extends EntityUpdateComponents<C>>(updateFunction: EntityUpdateFunction<C, T>): void;

package/dist/systems/workers/web-worker.d.ts

@@ -1,4 +0,0 @@
-export default abstract class WebWorker {
-    abstract postMessage(message: any): void | Promise<void>;
-    onmessage(message: any, transferrables?: Array<any>): void;
-}

package/dist/world.d.ts

@@ -1,39 +0,0 @@
-import { EventEmitter } from 'eventemitter3';
-import { MemoryHeap } from '@daneren2005/shared-memory-objects';
-import MemoryComponent from './memory-component';
-import BaseEntity from './entity';
-import type System from './systems/system';
-import type { ComponentMap, ComponentRegistry } from './component-definition';
-export interface WorldOptions {
-    heapSize?: number;
-}
-export default class BaseWorld<C extends ComponentMap = ComponentMap> extends EventEmitter {
-    heap: MemoryHeap;
-    registry: ComponentRegistry<C>;
-    components: {
-        [K in keyof C]: MemoryComponent;
-    };
-    entities: Array<BaseEntity<C>>;
-    entitiesByEid: {
-        [eid: number]: BaseEntity<C>;
-    };
-    systems: Array<System<C>>;
-    gameTime: number;
-    destroyed: boolean;
-    constructor(registry: ComponentRegistry<C>, options?: WorldOptions);
-    init(): Promise<void>;
-    addEntity(entity: BaseEntity<C>, created?: boolean): BaseEntity<C>;
-    loadEntity(config: any, created?: boolean): BaseEntity<C>;
-    removeEntity(entity: BaseEntity<C>): void;
-    getEntityByEid(eid: number): BaseEntity<C> | undefined;
-    addSystem<T extends System<C>>(system: T): T;
-    addSystemIfNotExists(system: System<C>): void;
-    removeSystem(name: string): void;
-    update(elapsedTime: number): {
-        lastSystemError?: Error | null;
-    };
-    addEntityToComponentSystem(entity: BaseEntity<C>, component: keyof C): void;
-    removeEntityFromComponentSystem(entity: BaseEntity<C>, component: keyof C): void;
-    private componentAffectsComponentSystem;
-    destroy(): void;
-}