@daneren2005/shared-memory-ecs 1.6.0 → 1.7.1

package/dist/entity-class.d.ts

@@ -0,0 +1,51 @@
+import type { ComponentDefinitionMap, EntityConfigOf } from './component-definition';
+export type EntityClassConstructor = abstract new (...args: never[]) => {
+    readonly eid: number;
+};
+export interface EntityClassDefinition {
+    entity: EntityClassConstructor;
+    components: ReadonlyArray<string>;
+}
+export type EntityClassRegistry = Record<string, EntityClassDefinition>;
+declare const ENTITY_CLASSES_TYPE: unique symbol;
+export type DefinedEntityClasses<R extends ComponentDefinitionMap, Classes extends EntityClassRegistry> = Classes & {
+    readonly [ENTITY_CLASSES_TYPE]: R;
+};
+export type EntityInstancesOf<Classes extends EntityClassRegistry> = InstanceType<Classes[keyof Classes & string]['entity']>;
+type RegistryOf<Classes extends EntityClassRegistry> = Classes extends DefinedEntityClasses<infer R, EntityClassRegistry> ? R : never;
+type ComponentKeysOf<Definition> = Definition extends {
+    components: ReadonlyArray<infer K>;
+} ? K : never;
+export type EntityClassTemplateConfig<Classes extends EntityClassRegistry, ClassName extends keyof Classes & string, R extends ComponentDefinitionMap = RegistryOf<Classes>> = EntityConfigOf<Pick<R, Extract<ComponentKeysOf<Classes[ClassName]>, keyof R>>> & {
+    type: string;
+    class: ClassName;
+};
+export type EntityTemplateConfigOf<Classes extends EntityClassRegistry> = {
+    [ClassName in keyof Classes & string]: EntityClassTemplateConfig<Classes, ClassName>;
+}[keyof Classes & string];
+export type EntityInstanceConfigOf<Classes extends EntityClassRegistry> = EntityTemplateConfigOf<Classes> extends infer Config ? Config extends object ? Omit<Config, 'class'> & {
+    class?: never;
+} : never : never;
+type EntityClassInput<R extends ComponentDefinitionMap> = Record<string, {
+    entity: EntityClassConstructor;
+    components: ReadonlyArray<keyof R & string>;
+}>;
+type ExactEntityConfig<Classes extends EntityClassRegistry, ClassName extends keyof Classes & string, Type, Config> = Config & EntityClassTemplateConfig<Classes, ClassName> & {
+    type: Type;
+} & Record<Exclude<keyof Config, keyof EntityClassTemplateConfig<Classes, ClassName>>, never>;
+type CheckedEntityConfig<Classes extends EntityClassRegistry, Type, Config> = Config extends {
+    class: infer ClassName;
+} ? ClassName extends keyof Classes & string ? ExactEntityConfig<Classes, ClassName, Type, Config> : never : never;
+type CheckedEntityConfigs<Classes extends EntityClassRegistry, Configs> = {
+    [K in keyof Configs]: CheckedEntityConfig<Classes, K, Configs[K]>;
+};
+export declare function defineEntityClasses<R extends ComponentDefinitionMap, const Classes extends EntityClassInput<R>>(_registry: R, classes: Classes): DefinedEntityClasses<R, Classes>;
+export declare function defineEntityConfigs<Classes extends EntityClassRegistry, const Configs extends Record<string, {
+    type: string;
+    class: keyof Classes & string;
+}>>(_classes: Classes, configs: Configs & CheckedEntityConfigs<Classes, Configs>): Configs;
+export interface WorkerEntityClassDefinition {
+    components: Array<string>;
+}
+export type WorkerEntityClassRegistry = Record<string, WorkerEntityClassDefinition>;
+export {};

package/dist/entity-component.d.ts

@@ -1,7 +1,8 @@
 import type { ComponentDefinition } from './component-definition';
 export interface EntityComponent {
     index: number;
-    type: string;
+    readonly type: string;
+    readonly class: string;
     dead: boolean;
     isStatic: boolean;
 }
@@ -9,6 +10,9 @@ export interface EntityComponentConfig {
     type: string;
     isStatic?: boolean;
 }
+export interface EntityClassConfig {
+    readonly class: string;
+}
 export interface EntityComponentSerialization {
     type?: string;
     dead?: boolean;
@@ -16,4 +20,5 @@ export interface EntityComponentSerialization {
 export declare const DEAD_INDEX = 0;
 export declare const STATIC_INDEX = 1;
 export declare const TYPE_INDEX = 2;
-export declare const entityDefinition: ComponentDefinition<EntityComponent, Uint32Array, EntityComponentConfig, EntityComponentSerialization>;
+export declare const CLASS_INDEX = 3;
+export declare const entityDefinition: ComponentDefinition<EntityComponent, Uint32Array, EntityComponentConfig & Partial<EntityClassConfig>, EntityComponentSerialization>;

package/dist/entity-factory.d.ts

@@ -1,16 +1,32 @@
 import BaseEntity from './entity';
 import type BaseWorld from './world';
 import type { ComponentDefinitionMap, ComponentMap } from './component-definition';
-export default class EntityFactory<C extends ComponentMap = ComponentMap, Cfg = any> {
-    world: BaseWorld<ComponentDefinitionMap, C, Cfg>;
+import type { EntityClassRegistry, WorkerEntityClassRegistry } from './entity-class';
+export default class EntityFactory<C extends ComponentMap = ComponentMap, Cfg = any, E extends BaseEntity<C, Cfg> = BaseEntity<C, Cfg>> {
+    world: BaseWorld<ComponentDefinitionMap, C, Cfg, E>;
     configs: {
         [type: string]: Cfg;
     };
+    classes: EntityClassRegistry;
+    private allowedComponents;
     constructor(configs?: {
         [type: string]: Cfg;
-    });
+    }, classes?: EntityClassRegistry);
     register(type: string, config: Cfg): void;
+    setWorld(world: BaseWorld<ComponentDefinitionMap, C, Cfg, E>): void;
     getConfig(config: Cfg): Cfg;
-    loadEntity(config: Cfg, created?: boolean): BaseEntity<C, Cfg>;
-    protected createEntity(config: Cfg): BaseEntity<C, Cfg>;
+    loadEntity(config: Cfg, created?: boolean): E;
+    createAdoptedEntity(type: string, entityClass: string | undefined, eid: number): E;
+    isComponentAllowed(entityClass: string | undefined, component: string): boolean;
+    getWorkerClasses(): WorkerEntityClassRegistry | undefined;
+    getAllowedComponentsForConfig(config: Cfg | undefined): ReadonlySet<string> | undefined;
+    protected createEntity(config: Cfg): E;
+    private get hasClasses();
+    private getClassDefinition;
+    private getAllowedComponents;
+    private constructEntity;
+    private validateTemplate;
+    private validateResolvedConfig;
+    private validateTypeClass;
+    private validateComponentTriggers;
 }

package/dist/entity.d.ts

@@ -7,12 +7,16 @@ export default class BaseEntity<C extends ComponentMap = ComponentMap, Cfg = any
     config?: Cfg;
     world: BaseWorld<ComponentDefinitionMap, C, Cfg>;
     private componentMemoryDeletionScheduled;
+    private allowedComponents?;
     components: Partial<C> & {
         entity: EntityComponent;
     };
-    constructor(world: BaseWorld<ComponentDefinitionMap, C, Cfg>, config?: Cfg, adoptEid?: number);
+    constructor(world: BaseWorld<ComponentDefinitionMap, C, Cfg>, config?: Cfg, adoptEid?: number, allowedComponents?: ReadonlySet<string>);
+    get id(): number;
+    get dead(): boolean;
+    get type(): string;
     loadComponent<K extends keyof C>(name: K, config: any, emitAdded?: boolean): C[K];
-    attachComponent<K extends keyof C>(name: K, index: number): C[K];
+    attachComponent<K extends keyof C>(name: K, index: number, emitAdded?: boolean): 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;
     /**
@@ -24,4 +28,8 @@ export default class BaseEntity<C extends ComponentMap = ComponentMap, Cfg = any
     load(config: Cfg): void;
     save(): Cfg;
     finishLoading(): void;
+    private isComponentAllowed;
+    setAllowedComponents(allowedComponents: ReadonlySet<string> | undefined): void;
+    private assertComponentAllowed;
+    private assertComponentPropertyMutable;
 }

package/dist/index.d.ts

@@ -2,12 +2,16 @@ export { default as BaseWorld } from './world';
 export type { WorldOptions, WorldConfig } from './world';
 export { default as BaseEntity } from './entity';
 export { default as EntityFactory } from './entity-factory';
-export { entityDefinition, DEAD_INDEX, STATIC_INDEX, TYPE_INDEX } from './entity-component';
+export { defineEntityClasses, defineEntityConfigs } from './entity-class';
+export type { DefinedEntityClasses, EntityClassConstructor, EntityClassDefinition, EntityClassRegistry, EntityClassTemplateConfig, EntityInstanceConfigOf, EntityInstancesOf, EntityTemplateConfigOf, } from './entity-class';
+export { entityDefinition, CLASS_INDEX, DEAD_INDEX, STATIC_INDEX, TYPE_INDEX } from './entity-component';
 export { default as ConstantStringCache } from './constant-string-cache';
-export type { EntityComponent, EntityComponentConfig, EntityComponentSerialization, } from './entity-component';
+export type { EntityComponent, EntityClassConfig, EntityComponentConfig, EntityComponentSerialization, } from './entity-component';
 export { default as killEntity } from './actions/kill-entity';
 export { default as killEntityWorker } from './actions/kill-entity-worker';
 export { default as createEntityWorker } from './actions/create-entity-worker';
+export { default as addComponentWorker } from './actions/add-component-worker';
+export { default as removeComponentWorker } from './actions/remove-component-worker';
 export { default as PerformanceTiming, DEFAULT_TICKS_BETWEEN_UPDATES } from './performance-timing';
 export type { TimingStats, SystemTimingStats, PerformanceStats, PerformanceTimingOptions, } from './performance-timing';
 export { default as MemoryComponent } from './memory-component';
@@ -23,7 +27,7 @@ export type { EntitySystemConfig } from './systems/entity-system';
 export { default as EntityWorkerSystem } from './systems/entity-worker-system';
 export { default as WorkerSystem } from './systems/worker-system';
 export type { WorkerSystemConfig, WorkerSystemRunFunction } from './systems/worker-system';
-export type { EntityWorkerSystemConfig, EntityWorkerSystemQuery, EntityWorkerSystemWorld, EntityWorkerSystemCallbacks, WorkerAllocator, WorkerCreateEntityConfig, WorkerCreatedEntity, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdateInitFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfig, UpdateEntityConfigObject, } from './systems/entity-worker-system';
+export type { EntityWorkerSystemConfig, EntityWorkerSystemQuery, EntityWorkerSystemWorld, EntityWorkerSystemCallbacks, WorkerAllocator, WorkerCreateEntityConfig, WorkerCreatedEntity, WorkerCreatedComponent, WorkerComponentChange, EntityUpdateComponents, EntityQueryComponents, EntityUpdateFunction, EntityUpdateInitFunction, EntityUpdatePreRunFunction, EntityRemovedFunction, UpdateEntityConfig, UpdateEntityConfigObject, } from './systems/entity-worker-system';
 export { default as WebWorker } from './systems/workers/web-worker';
 export { default as EntitySystemWebWorker } from './systems/workers/entity-system-web-worker';
 export { default as createEntitySystemWorker } from './systems/workers/create-entity-system-worker';