@perplexdotgg/mecs 0.3.0 → 0.3.2

package/README.md

@@ -192,9 +192,9 @@ const entity1 = Entity.create({
   },
 });
 
-// now entity1 is of the Entity class, and entity1.localTransform is of the Transform class
+// now entity1 is of the Entity class, and entity1.globalTransform is of the Transform class
 // so you can call methods on it like so:
-entity1.localTransform.composeMatrix();
+entity1.globalTransform.composeMatrix();
 
 const entity2 = Entity.create({
   projectile: {
@@ -203,7 +203,7 @@ const entity2 = Entity.create({
   },
 });
 
-// destroy() to return the entity to the pool, it will automatically be re-used later
+// you can use destroy() to return an entity to the pool, it will automatically be re-used later
 // this iterates on all components to remove them first, and triggers queries just
 // before the component(s) needed for the query are deleted
 // each destroyed component also gets recycled in its own component pool
@@ -248,7 +248,7 @@ const components = {
     // component config options here, see "Customizing Components" below
   },
 
-} as const satisfies ComponentMap;
+};
 
 const queries = {};
 
@@ -381,7 +381,7 @@ Entity.queries.projectiles.beforeEntityRemoved.removeListener(someListener);
 ```
 
 ### Components that reference Entities
-You can have components that reference other entities, by using Monomorph's `LazyReferenceType` and `LazyReferenceListType` along with MECS's `LazyComponent`. See the Typescript tests in [`tests/lazyComponents.test.ts`](https://codeberg.org/perplexdotgg/mecs/src/branch/main/tests/lazyComponents.test.ts) for examples. Below is a simple Javascript example:
+You can have components that reference other entities, by using Monomorph's `LazyReferenceType` and `LazyReferenceListType`. This will usually 'just work', but in some situations you may also need to use MECS's `LazyComponent`. See the Typescript tests in [`tests/componentsWithEntityReferences.test.ts`](https://codeberg.org/perplexdotgg/mecs/src/branch/main/tests/componentsWithEntityReferences.test.ts) and [`tests/lazyComponentsWithEntityReferences.test.ts`](https://codeberg.org/perplexdotgg/mecs/src/branch/main/tests/lazyComponentsWithEntityReferences.test.ts) for examples. Below is a simple Javascript example:
 
 ```js
 const turretProps = {
@@ -393,11 +393,15 @@ const turretProps = {
 class Turret extends createClass(turretProps) {}
 
 const components = {
-  turret: LazyComponent(() => Turret),
+  turret: Turret,
+  // or the lazy loaded version:
+  // turret: LazyComponent(() => Turret),
 
   // alternatively, you can use a component config object for further customization:
   turret: {
-    monomorphClass: LazyComponent(() => Turret),
+    monomorphClass: Turret,
+    // or the lazy loaded version:
+    // monomorphClass: LazyComponent(() => Turret),
 
     // other config options here, for example:
     afterComponentAdded: (turretInstance, entity, componentKey) => {
@@ -407,7 +411,7 @@ const components = {
     },
   },
 };
-class Entity extends createEntityClass()(components, {}) {}
+class Entity extends createEntityClass()(components, queries) {}
 ```
 
 

package/build/index.d.ts

@@ -43,13 +43,17 @@ declare type ComponentMapClassProperties<CM> = {
     [K in keyof CM as LowercaseFirstLetter<K>]?: ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? M : ExtractMonomorphClass<CM[K]>;
 };
 
-export declare function createEntityClass<C>(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<C, CM>, I extends EntityInput<CM> = EntityInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<C, CM, QM, I>;
+export declare type ComponentMapInput<CM extends ComponentMap> = Partial<{
+    [K in keyof CM as LowercaseFirstLetter<K>]: ComponentInput<ExtractMonomorphClass<CM[K]>>;
+}>;
+
+export declare function createEntityClass<C>(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<C, CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<C, CM, QM, I>;
 
-export declare type CreateEntityFunction<C, CM extends ComponentMap, I extends EntityInput<CM>> = (data?: I, pool?: EntityPoolClass<C>) => EntityInstanceWithPool<CM, I, C>;
+export declare type CreateEntityFunction<C, CM extends ComponentMap, I extends ComponentMapInput<CM>> = (data?: I, pool?: EntityPoolClass<C>) => EntityInstanceWithPool<CM, I, C>;
 
 declare type ElementOfArray<T> = T extends (infer E)[] ? E : never;
 
-declare interface EntityBaseProperties<CM extends ComponentMap, I extends EntityInput<CM>> {
+declare interface EntityBaseProperties<CM extends ComponentMap, I extends any = ComponentMapInput<CM>> {
     componentMap: CM;
     __typescriptOnlyInputType: I;
     addComponent: <CCK extends LowercaseFirstLetter<keyof CM>, CC extends CM[OriginalComponentKey<CCK, CM>] = CM[OriginalComponentKey<CCK, CM>]>(...a: (undefined extends ComponentInput<ExtractMonomorphClass<CC>> ? [key: CCK, data?: ComponentInput<ExtractMonomorphClass<CC>>] : [key: CCK, data: ComponentInput<ExtractMonomorphClass<CC>>])) => void;
@@ -60,9 +64,9 @@ declare interface EntityBaseProperties<CM extends ComponentMap, I extends Entity
     isDestroyed(): boolean;
 }
 
-export declare type EntityClass<CM extends ComponentMap, I extends EntityInput<CM> = EntityInput<CM>, QM extends QueryMap<any, CM> = QueryMap<any, CM>, E extends EntityInstance<CM, I> = EntityInstance<CM, I>> = EntityConstructor<QM, E, I, CM>;
+export declare type EntityClass<CM extends ComponentMap, I extends ComponentMapInput<CM> = ComponentMapInput<CM>, QM extends QueryMap<any, CM> = QueryMap<any, CM>, E extends EntityInstance<CM, I> = EntityInstance<CM, I>> = EntityConstructor<QM, E, I, CM>;
 
-export declare type EntityClassWithStatics<C, CM extends ComponentMap, QM extends QueryMap<C, CM>, I extends EntityInput<CM> = EntityInput<CM>> = EntityClass<CM, I, QM> & {
+export declare type EntityClassWithStatics<C, CM extends ComponentMap, QM extends QueryMap<C, CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>> = EntityClass<CM, I, QM> & {
     create: CreateEntityFunction<C, CM, I>;
     Pool: NoInfer<EntityPoolClass<C>>;
 };
@@ -88,7 +92,7 @@ declare type EntityCodeGenerationOptions = {
     skipSafetyChecks?: boolean;
 };
 
-export declare interface EntityConstructor<QM extends QueryMap<any, CM>, E extends EntityInstance<CM, I>, I extends EntityInput<CM>, CM extends ComponentMap> {
+export declare interface EntityConstructor<QM extends QueryMap<any, CM>, E extends EntityInstance<CM, I>, I extends any, CM extends ComponentMap> {
     new (data: I): E;
     componentMap: CM;
     __typescriptOnlyInputType: I;
@@ -118,13 +122,11 @@ export declare interface EntityConstructor<QM extends QueryMap<any, CM>, E exten
     };
 }
 
-export declare type EntityInput<CM extends ComponentMap> = Partial<{
-    [K in keyof CM as LowercaseFirstLetter<K>]: ComponentInput<ExtractMonomorphClass<CM[K]>>;
-}>;
+export declare type EntityInput<X extends ComponentMap | EntityClass<any, any, any, any> | EntityInstanceWithPool<any, any, any> | EntityInstance<any, any>> = X extends ComponentMap ? ComponentMapInput<X> : X extends EntityConstructor<infer QM, infer E, infer I, infer CM> ? I : X extends EntityInstanceWithPool<infer CM, infer I, infer E> ? I : X extends EntityInstance<infer CM, infer I> ? I : never;
 
-export declare type EntityInstance<CM extends ComponentMap, I extends EntityInput<CM>> = ComponentMapClassProperties<CM> & EntityBaseProperties<CM, I>;
+export declare type EntityInstance<CM extends ComponentMap, I extends any = ComponentMapInput<CM>> = ComponentMapClassProperties<CM> & EntityBaseProperties<CM, I>;
 
-export declare type EntityInstanceWithPool<CM extends ComponentMap, I extends EntityInput<CM>, E> = NoInfer<E & {
+export declare type EntityInstanceWithPool<CM extends ComponentMap, I extends ComponentMapInput<CM>, E> = NoInfer<E & {
     pool: EntityPoolClass<E> | null;
     createInPool(data?: I): EntityInstanceWithPool<CM, I, E>;
 }>;
@@ -148,7 +150,7 @@ export declare interface EntityPoolClass<M> {
     /** how many non-destroyed objects are in this pool, i.e. how many would be iterated on */
     length: number;
     [Symbol.iterator](): IterableIterator<WithPool<M>>;
-    create(data?: M extends EntityInstance<infer CM, infer I> ? EntityInput<CM> : undefined): M extends EntityInstanceWithPool<infer CM, infer I, any> ? EntityInstanceWithPool<CM, I, M> : never;
+    create(data?: M extends EntityInstance<infer CM, infer I> ? ComponentMapInput<CM> : undefined): M extends EntityInstanceWithPool<infer CM, infer I, any> ? EntityInstanceWithPool<CM, I, M> : never;
     toArray(array: NumberArray, startOffset?: number): number;
     fromArray(array: NumberArray, startOffset?: number, classConstructor?: new (...args: any[]) => M): number;
     fromArrayNoReferences(array: NumberArray, startOffset?: number, classConstructor?: new (...args: any[]) => M): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perplexdotgg/mecs",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "MECS - Monomorph ECS - A high-performance Entity Component System for TypeScript and JavaScript projects, designed for games and simulations.",
   "repository": {
     "type": "git",
@@ -28,7 +28,7 @@
     "bench": "vitest bench"
   },
   "peerDependencies": {
-    "monomorph": "^1.5.5"
+    "monomorph": "^1.5.6"
   },
   "peerDependenciesMeta": {
     "monomorph": {
@@ -37,7 +37,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.1",
-    "monomorph": "^1.5.5",
+    "monomorph": "^1.5.6",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",