@perplexdotgg/mecs 0.4.2 → 0.5.1

package/README.md

@@ -16,7 +16,7 @@ MECS focuses on the developer's experience in their IDE, especially around auto-
 
 <details>
   <summary>Side note: Why not use SoA design?</summary>
-  While SoA can achieve better performance in the best cases, it tends to be unwieldy, especially for nested fields, and generally ECS implementations lack auto-complete for components and properties. For larger game projecting, remembering all component names and their properties is quite difficult. Using JS getters with SoA (to achieve auto complete) gives much worse overall performance than AoS.
+  While SoA can achieve better performance in the best cases, it tends to be unwieldy, especially for nested fields, and generally ECS implementations lack auto-complete for components and properties. For larger game projects, remembering all component names and their properties is quite difficult. Using JS getters with SoA (to achieve auto complete) gives much worse overall performance than AoS.
 </details>
 
 ---
@@ -142,6 +142,9 @@ const queries = {
     without: ['localTransform'],
 
     // listeners can added now, or later (see the Queries docs below)
+    // note that in this context, the entity type doesn't have Entity methods that you've added
+    // if you need those, either ts-ignore when calling them here, or add listeners later in your system code using:
+    // Entity.queries().yourQueryKey.afterEntityAdded.addListener((entity) => { /* your code here will get the right entity type */ }))
     afterEntityAdded: (entity) => {
       // this is called when an entity newly matches this query
     },
@@ -154,7 +157,7 @@ const queries = {
     with: ['localTransform', 'globalTransform'],
     without: [],
   },
-} as const satisfies QueryMap<Entity, typeof components>;
+} as const satisfies QueryMap<typeof components>;
 
 // additional Entity class options, see "Entity Class Options" below
 const extraOptions = {};

package/build/index.d.ts

@@ -4,10 +4,18 @@ import { MonomorphInstance } from 'monomorph';
 import { NumberArray } from 'monomorph';
 import { PartialRecursive } from 'monomorph';
 import { PoolClass } from 'monomorph';
+import { PropertyDefinitionClassProperties } from 'monomorph';
+import { PropertyDefinitionReference } from 'monomorph';
+import { PropertyDefinitionReferenceList } from 'monomorph';
+import { ReferenceListClass } from 'monomorph';
 import { WithPool } from 'monomorph';
 
+declare type BivariantCallback<T> = {
+    bivarianceHack(arg: T): void;
+}["bivarianceHack"];
+
 export declare type ComponentConfig<ComponentType, ComponentInputType extends any = InputType<ComponentType> extends never ? ComponentType : InputType<ComponentType>> = {
-    monomorphClass?: ComponentType extends MonomorphClass<any, any, any> ? ComponentType : ComponentType extends MonomorphInstance<infer P, infer I> ? MonomorphClass<P, I, ComponentType> : never;
+    monomorphClass?: ComponentType extends LazyWrapper<infer MC extends MonomorphClass<any, any, any>> ? LazyWrapper<MC> : ComponentType extends MonomorphClass<any, any, any> ? ComponentType : ComponentType extends MonomorphInstance<infer P, infer I> ? MonomorphClass<P, I, ComponentType> : never;
     afterComponentAdded?: (componentInstance: ComponentType extends abstract new (...args: any) => any ? InstanceType<ComponentType> : ComponentType, entity: any, componentKey: string) => void;
     afterComponentAddedCode?: string | ComponentConfigFunction<ComponentType, ComponentInputType>;
     beforeComponentRemoved?: (componentInstance: ComponentType extends abstract new (...args: any) => any ? InstanceType<ComponentType> : ComponentType, entity: any, componentKey: string) => void;
@@ -40,37 +48,59 @@ export declare type ComponentConfigFunction<ComponentType, ComponentInputType> =
 
 export declare type ComponentInput<X> = X extends MonomorphClass<infer P, infer I, infer M> ? M extends MonomorphInstance<infer iP, infer iI> ? InputType<M> : never : X extends ComponentConfig<infer CT, infer I> ? I : X;
 
+declare type ComponentInputResolved<CC, CM extends ComponentMap> = ResolveEntityInputListItems<ComponentInput<ExtractMonomorphClass<CC>>, CM>;
+
 export declare type ComponentMap = Record<string, ComponentConfig<any, any> | MonomorphClass<any, any, any> | LazyWrapper<MonomorphClass<any, any, any>> | ComponentConfig<MonomorphClass<any, any, any>, any> | ComponentConfig<LazyWrapper<MonomorphClass<any, any, any>>, any>>;
 
-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]>;
+declare type ComponentMapClassProperties<CM extends ComponentMap> = {
+    [K in keyof CM as LowercaseFirstLetter<K>]?: ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? ResolveEntityRefs<M, CM> : ExtractMonomorphClass<CM[K]>;
 };
 
 export declare type ComponentMapInput<CM extends ComponentMap> = Partial<{
-    [K in keyof CM as LowercaseFirstLetter<K>]: ComponentInput<ExtractMonomorphClass<CM[K]>>;
+    [K in keyof CM as LowercaseFirstLetter<K>]: ResolveEntityInput<ComponentInput<ExtractMonomorphClass<CM[K]>>, CM>;
+}>;
+
+declare type ComponentMapInputListItems<CM extends ComponentMap> = Partial<{
+    [K in keyof CM as LowercaseFirstLetter<K>]: ResolveEntityInputListItems<ComponentInput<ExtractMonomorphClass<CM[K]>>, CM>;
 }>;
 
-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>;
+declare type ComponentsWithEntities<E, CM extends ComponentMap> = {
+    [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: {
+        [Symbol.iterator](): IterableIterator<[WithPool<InstanceType<ExtractMonomorphClass<CM[K]>>>, E]>;
+    };
+};
+
+declare type ComponentsWithEntitiesCallable<E, CM extends ComponentMap> = ComponentsWithEntities<E, CM> & {
+    <Self extends abstract new (...args: any) => any>(this: Self): ComponentsWithEntities<InstanceType<Self>, CM>;
+};
 
-export declare type CreateEntityFunction<C, CM extends ComponentMap, I extends ComponentMapInput<CM>> = (data?: I, updateQueryMemberships?: boolean, pool?: EntityPoolClass<C>) => EntityInstanceWithPool<CM, I, C>;
+declare type ComponentTypeFromMonomorphClass<T> = T extends MonomorphClass<infer P, any, any> ? PropertyDefinitionClassProperties<P> : never;
 
-declare type ElementOfArray<T> = T extends (infer E)[] ? E : never;
+export declare function createEntityClass<C>(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<C, CM, QM, I>;
+
+export declare function createEntityClass(options?: EntityCodeGenerationOptions): <CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>>(componentMap: CM, queries?: QM) => EntityClassWithStatics<EntityInstance<CM, I>, CM, QM, I>;
+
+export declare type CreateEntityFunction<C, CM extends ComponentMap, I extends ComponentMapInput<CM>> = <T extends EntityConstructor<any, any, I, CM>>(this: T, data?: I, updateQueryMemberships?: boolean, pool?: EntityPoolClass<InstanceType<T>>) => EntityInstanceWithPool<CM, I, InstanceType<T>>;
+
+declare type ElementOfReadonlyArray<T> = T extends ReadonlyArray<infer E> ? E : never;
 
 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>>, updateQueryMemberships?: boolean] : [key: CCK, data: ComponentInput<ExtractMonomorphClass<CC>>, updateQueryMemberships?: boolean])) => void;
+    addComponent: <CCK extends LowercaseFirstLetter<keyof CM>, CC extends CM[OriginalComponentKey<CCK, CM>] = CM[OriginalComponentKey<CCK, CM>]>(...a: (undefined extends NoInfer<ComponentInputResolved<CC, CM>> ? [key: CCK, data?: NoInfer<ComponentInputResolved<CC, CM>>, updateQueryMemberships?: boolean] : [key: CCK, data: NoInfer<ComponentInputResolved<CC, CM>>, updateQueryMemberships?: boolean])) => void;
     removeComponent: <CCK extends LowercaseFirstLetter<keyof CM>>(key: CCK, updateQueryMemberships?: boolean) => void;
     hasComponent: <CCK extends LowercaseFirstLetter<keyof CM>>(key: CCK) => boolean;
     clone(): this;
     reset(data?: PartialRecursive<I>, updateQueryMemberships?: boolean, pool?: EntityPoolClass<this>): void;
     destroy(updateQueryMemberships?: boolean): void;
     isDestroyed(): boolean;
+    poolIndex: number;
+    pool: EntityPoolClass<this>;
 }
 
-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 EntityClass<CM extends ComponentMap, I extends ComponentMapInput<CM> = ComponentMapInput<CM>, QM extends QueryMap<CM> = QueryMap<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 ComponentMapInput<CM> = ComponentMapInput<CM>> = EntityClass<CM, I, QM> & {
+export declare type EntityClassWithStatics<C, CM extends ComponentMap, QM extends QueryMap<CM>, I extends ComponentMapInput<CM> = ComponentMapInput<CM>> = EntityClass<CM, I, QM> & {
     create: CreateEntityFunction<C, CM, I>;
     Pool: NoInfer<EntityPoolClass<C>>;
 };
@@ -96,37 +126,28 @@ declare type EntityCodeGenerationOptions = {
     skipSafetyChecks?: boolean;
 };
 
-export declare interface EntityConstructor<QM extends QueryMap<any, CM>, E extends EntityInstance<CM, I>, I extends any, CM extends ComponentMap> {
-    new (data: I, index?: number, pool?: EntityPoolClass<E>, updateQueryMemberships?: boolean): E;
+export declare interface EntityConstructor<QM extends QueryMap<CM>, E extends EntityInstance<CM, I>, I extends any, CM extends ComponentMap> {
+    new (data: I, poolIndex?: number, pool?: EntityPoolClass<E>, updateQueryMemberships?: boolean): E;
     componentMap: CM;
+    __lazyReferenceTarget?: E;
     __typescriptOnlyInputType: I;
-    pool: EntityPoolClass<E>;
-    componentsWithEntities: {
-        [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: {
-            [Symbol.iterator](): IterableIterator<[WithPool<InstanceType<ExtractMonomorphClass<CM[K]>>>, E]>;
-        };
-    };
+    pool: PoolCallable<E>;
+    queries: QueriesCallable<E, QM, CM>;
+    componentsWithEntities: ComponentsWithEntitiesCallable<E, CM>;
     components: {
         [K in keyof CM as ExtractMonomorphClass<CM[K]> extends MonomorphClass<infer P, infer I, infer M> ? LowercaseFirstLetter<K> : never]: PoolClass<ExtractMonomorphClass<CM[K]>>;
     };
-    queries: {
-        [K in keyof QM]: {
-            afterEntityAdded: {
-                addListener(listener: (entity: E) => void): void;
-                removeListener(listener: (entity: E) => void): void;
-            };
-            beforeEntityRemoved: {
-                addListener(listener: (entity: E) => void): void;
-                removeListener(listener: (entity: E) => void): void;
-            };
-            [Symbol.iterator](): IterableIterator<WithComponent<E, ElementOfArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfArray<QM[K]['with']> : never>>;
-        };
-    };
 }
 
+declare type EntityConstructorLike = abstract new (...args: any[]) => any;
+
+declare type EntityFor<CM extends ComponentMap> = EntityInstance<CM, any>;
+
 export declare type EntityInput<X extends ComponentMap | EntityClass<any, any, any, any> | EntityInstanceWithPool<any, any, any> | EntityInstance<any, any>> = Writeable<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 any = ComponentMapInput<CM>> = ComponentMapClassProperties<CM> & EntityBaseProperties<CM, I>;
+declare type EntityInputListItems<E> = E extends ComponentMap ? ComponentMapInputListItems<E> : E extends EntityConstructor<any, any, any, infer CM> ? ComponentMapInputListItems<CM> : E extends EntityInstance<infer CM, any> ? ComponentMapInputListItems<CM> : E extends EntityInstanceWithPool<infer CM, any, any> ? ComponentMapInputListItems<CM> : EntityInput<NoInfer<E>>;
+
+export declare type EntityInstance<CM extends ComponentMap, I extends any = ComponentMapInput<CM>> = ComponentMapClassProperties<NoInfer<CM>> & EntityBaseProperties<CM, I>;
 
 export declare type EntityInstanceWithPool<CM extends ComponentMap, I extends ComponentMapInput<CM>, E> = NoInfer<E & {
     pool: EntityPoolClass<E> | null;
@@ -159,6 +180,65 @@ export declare interface EntityPoolClass<M> {
     fromArrayOnlyReferences(array: NumberArray, references?: any, startOffset?: number, classConstructor?: new (...args: any[]) => M): number;
 }
 
+declare type EntityPoolInput = {
+    array: unknown[];
+    freeIndices: number[];
+    maxLength: number;
+    length: number;
+    [Symbol.iterator](): IterableIterator<any>;
+    create?(data?: any): any;
+};
+
+declare type EntityQueries<E, QM extends QueryMap<CM>, CM extends ComponentMap> = E extends {
+    componentMap: any;
+} ? ({
+    [K in keyof QM]: {
+        afterEntityAdded: {
+            addListener(listener: BivariantCallback<WithComponent<E, ElementOfReadonlyArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfReadonlyArray<QM[K]['with']> : never>>): void;
+            removeListener(listener: BivariantCallback<E>): void;
+        };
+        beforeEntityRemoved: {
+            addListener(listener: BivariantCallback<WithComponent<E, ElementOfReadonlyArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfReadonlyArray<QM[K]['with']> : never>>): void;
+            removeListener(listener: BivariantCallback<E>): void;
+        };
+        [Symbol.iterator](): IterableIterator<WithComponent<E, ElementOfReadonlyArray<QM[K]['with']> extends LowercaseFirstLetter<keyof E["componentMap"]> ? ElementOfReadonlyArray<QM[K]['with']> : never>>;
+    };
+} & {
+    [key: string]: any;
+}) : never;
+
+declare const EntityRefBrand: unique symbol;
+
+export declare function EntityReference(fn: () => any): PropertyDefinitionReference<EntitySelfRef | null, true>;
+
+export declare function EntityReference<E>(fn: () => any): PropertyDefinitionReference<LazyEntityReferenceTarget<E> | null, true>;
+
+export declare function EntityReference<C extends EntityConstructorLike>(fn: () => C): PropertyDefinitionReference<LazyEntityReferenceTarget<C> | null, true>;
+
+export declare function EntityReferenceList(fn: () => any): PropertyDefinitionReferenceList<EntitySelfRef, EntitySelfRefListInput>;
+
+export declare function EntityReferenceList<E>(fn: () => any): PropertyDefinitionReferenceList<LazyEntityReferenceTarget<E>, EntitySelfRefListInput>;
+
+export declare function EntityReferenceList<C extends EntityConstructorLike>(fn: () => C): PropertyDefinitionReferenceList<LazyEntityReferenceTarget<C>, EntitySelfRefListInput>;
+
+export declare type EntityReferenceListInput<E> = EntityReferenceListInputBase<EntityInputListItems<NoInfer<E>>>;
+
+declare type EntityReferenceListInputBase<TItems = unknown> = {
+    pool: EntityPoolInput;
+    items?: TItems[];
+    maxLength?: number;
+};
+
+declare const EntityRefListBrand: unique symbol;
+
+declare type EntitySelfRef = {
+    [EntityRefBrand]?: true;
+};
+
+declare type EntitySelfRefListInput = {
+    [EntityRefListBrand]?: true;
+};
+
 export declare type ExtractMonomorphClass<CC> = CC extends {
     monomorphClass?: infer MC extends MonomorphClass<any, any, any>;
 } ? MC : CC extends ({
@@ -169,9 +249,20 @@ export declare type ExtractMonomorphClass<CC> = CC extends {
     fnInArray: [() => infer MC extends MonomorphClass<any, any, any>];
 } ? MC : CC;
 
-export declare function getEntityClassCode<C, CM extends ComponentMap>(componentMap: CM, queries?: QueryMap<C, CM>, options?: EntityCodeGenerationOptions): string;
+export declare function getEntityClassCode<C, CM extends ComponentMap>(componentMap: CM, queries?: QueryMap<CM>, options?: EntityCodeGenerationOptions): string;
+
+export declare function LazyComponent<CT = undefined, MC extends MonomorphClass<any, any, any> = MonomorphClass<any, any, any>>(componentFn: () => MC): LazyComponentWrapper<MC, CT>;
+
+declare type LazyComponentResolvedType<MC extends MonomorphClass<any, any, any>, CT> = CT extends undefined ? ComponentTypeFromMonomorphClass<MC> : CT;
 
-export declare function LazyComponent<F extends () => T, T>(componentFn: F): LazyWrapper<ReturnType<F>>;
+declare type LazyComponentWrapper<MC extends MonomorphClass<any, any, any>, CT> = {
+    fnInArray: [() => MC];
+    componentType: Writeable<LazyComponentResolvedType<MC, CT>>;
+};
+
+export declare type LazyEntityReferenceTarget<T> = {
+    __lazyReferenceTarget?: NoInfer<T>;
+};
 
 export declare type LazyMonomorphComponentConfig<MC extends MonomorphClass<any, any, any>> = ComponentConfig<LazyWrapper<MC>, InputType<InstanceType<MC>>>;
 
@@ -185,21 +276,53 @@ export declare type MonomorphComponentConfig<MC extends MonomorphClass<any, any,
 
 declare type OriginalComponentKey<CCK extends LowercaseFirstLetter<keyof CM>, CM extends ComponentMap> = CCK extends keyof CM ? CCK : UppercaseFirstLetter<CCK>;
 
-export declare type QueryConfig<C, CM extends ComponentMap> = {
-    with?: LowercaseFirstLetter<keyof CM>[];
-    without?: LowercaseFirstLetter<keyof CM>[];
-    afterEntityAdded?: (entity: C) => void;
-    beforeEntityRemoved?: (entity: C) => void;
+declare type PoolCallable<E> = EntityPoolClass<E> & {
+    <Self extends abstract new (...args: any) => any>(this: Self): EntityPoolClass<InstanceType<Self>>;
+};
+
+declare type QueriesCallable<E, QM extends QueryMap<CM>, CM extends ComponentMap> = EntityQueries<E, QM, CM> & {
+    <Self extends abstract new (...args: any) => any>(this: Self): EntityQueries<InstanceType<Self>, QM, CM>;
+};
+
+export declare type QueryConfig<CM extends ComponentMap> = {
+    with?: ReadonlyArray<LowercaseFirstLetter<keyof CM>>;
+    without?: ReadonlyArray<LowercaseFirstLetter<keyof CM>>;
+    afterEntityAdded?: (entity: EntityInstance<CM>) => void;
+    beforeEntityRemoved?: (entity: EntityInstance<CM>) => void;
 };
 
-export declare type QueryMap<C, CM extends ComponentMap> = Record<string, QueryConfig<C, CM>>;
+export declare type QueryMap<CM extends ComponentMap> = Record<string, QueryConfig<CM>>;
+
+declare type ResolveEntityInput<T, CM extends ComponentMap> = T extends object ? {
+    [K in keyof T]: ResolveEntityInputValue<T[K], CM>;
+} : ResolveEntityInputValue<T, CM>;
+
+declare type ResolveEntityInputListItems<T, CM extends ComponentMap> = T extends object ? {
+    [K in keyof T]: ResolveEntityInputValueListItems<T[K], CM>;
+} : ResolveEntityInputValueListItems<T, CM>;
+
+declare type ResolveEntityInputValue<T, CM extends ComponentMap> = T extends any ? (UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRef ? EntityFor<CM> : UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRefListInput ? EntityReferenceListInput<EntityFor<CM>> : UnwrapEntityTarget<T> extends ReferenceListClass<infer M> ? EntityReferenceListInput<UnwrapEntityTarget<M>> : UnwrapEntityTarget<T>) : never;
+
+declare type ResolveEntityInputValueListItems<T, CM extends ComponentMap> = T extends any ? (UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRef ? EntityFor<CM> : UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRefListInput ? EntityReferenceListInputBase : T extends EntityReferenceListInputBase<any> ? EntityReferenceListInputBase : UnwrapEntityTarget<T> extends ReferenceListClass<any> ? EntityReferenceListInputBase : UnwrapEntityTarget<T>) : never;
+
+declare type ResolveEntityRefs<T, CM extends ComponentMap> = T extends object ? {
+    [K in keyof T]: ResolveEntityRefValue<T[K], CM>;
+} : ResolveEntityRefValue<T, CM>;
+
+declare type ResolveEntityRefValue<T, CM extends ComponentMap> = [
+T
+] extends [any] ? (UnwrapLazyEntityReferenceTarget<T> extends EntitySelfRef ? EntityFor<CM> : T extends ReferenceListClass<infer M> ? (UnwrapLazyEntityReferenceTarget<M> extends EntitySelfRef ? ReferenceListClass<EntityFor<CM>> : ReferenceListClass<UnwrapEntityTarget<M>>) : UnwrapEntityTarget<T>) : never;
+
+declare type UnwrapEntityTarget<T> = UnwrapLazyEntityReferenceTarget<T> extends EntityConstructor<any, infer E, any, any> ? E : UnwrapLazyEntityReferenceTarget<T> extends EntityConstructor<any, any, any, any> ? InstanceType<UnwrapLazyEntityReferenceTarget<T>> : UnwrapLazyEntityReferenceTarget<T>;
+
+declare type UnwrapLazyEntityReferenceTarget<T> = T extends LazyEntityReferenceTarget<infer U> ? U : T;
 
 declare type UppercaseFirstLetter<S> = S extends `${infer FirstLetter}${infer Rest}` ? `${Uppercase<FirstLetter>}${Rest}` : S;
 
 export declare type WithComponent<C extends {
     componentMap: any;
-}, KCM extends LowercaseFirstLetter<keyof C['componentMap']>> = Writeable<Omit<C, KCM> & {
-    [K in KCM as LowercaseFirstLetter<K>]-?: Exclude<C[K extends keyof C ? K : never], undefined | null>;
+}, KCM extends LowercaseFirstLetter<keyof C['componentMap']>> = Writeable<C & {
+    [K in KCM]-?: NonNullable<C[K extends keyof C ? K : never]>;
 }>;
 
 declare type Writeable<T> = {

package/build/mecs.js

@@ -1,5 +1,43 @@
+// @__NO_SIDE_EFFECTS__
+function LazyReferenceType(fn, readOnly) {
+  return {
+    monomorph: {
+      serializedSize: 2,
+      fnInArray: [fn],
+      theClass: null
+    },
+    propertyType: 4,
+    optional: true,
+    defaultValue: null,
+    readOnly
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function LazyReferenceListType(fn, readOnly) {
+  return {
+    monomorph: {
+      serializedSize: 2,
+      // @ts-ignore
+      fnInArray: [fn],
+      theClass: null
+    },
+    propertyType: 7,
+    optional: true,
+    defaultValue: void 0,
+    readOnly
+  };
+}
 function LazyComponent(componentFn) {
-  return { fnInArray: [componentFn] };
+  return {
+    fnInArray: [componentFn],
+    componentType: void 0
+  };
+}
+function EntityReference(fn) {
+  return /* @__PURE__ */ LazyReferenceType(fn ?? (() => null));
+}
+function EntityReferenceList(fn) {
+  return /* @__PURE__ */ LazyReferenceListType(fn ?? (() => null));
 }
 function lowercaseFirstLetter(str) {
   return str.charAt(0).toLowerCase() + str.slice(1);
@@ -182,7 +220,7 @@ function getEntityClassCode(componentMap, queries, options) {
             return {
               next() {
                 ${""}
-                while (index < (${componentKey}Pool.length + ${componentKey}Pool.freeIndices.length) && (!${componentKey}PoolArray[index] || (${componentKey}PoolArray[index].version & 1) === 1)) {
+                while (index < (${componentKey}Pool.length + ${componentKey}Pool.freeIndices.length) && (!${componentKey}PoolArray[index] || (${componentKey}PoolArray[index].poolVersion & 1) === 1)) {
                   index++;
                 }
 
@@ -208,7 +246,7 @@ function getEntityClassCode(componentMap, queries, options) {
         (data, entity, componentKey, updateQueryMemberships) => {
           entity.componentFlags |= ${componentFlagValue}n;
           entity.${componentKey} = ${resolvedMonomorphClass}.create(${processedDataCode}, ${componentKey}Pool);
-          ${componentKey}ComponentToEntity[entity.${componentKey}.index] = entity;
+          ${componentKey}ComponentToEntity[entity.${componentKey}.poolIndex] = entity;
 
           ${afterComponentAddedCode}
 
@@ -225,7 +263,7 @@ function getEntityClassCode(componentMap, queries, options) {
 
           ${beforeComponentRemovedCode}
 
-          ${componentKey}ComponentToEntity[instance.index] = null;
+          ${componentKey}ComponentToEntity[instance.poolIndex] = null;
           instance.destroy();
 
           ${""}
@@ -323,12 +361,8 @@ function getEntityClassCode(componentMap, queries, options) {
       }
     }
     queryListenerCode += `
-      const queryEntityAddedListeners${queryIndex} = [
-        ${queryConfig.afterEntityAdded ? "queryMap." + queryName + ".afterEntityAdded" : ""}
-      ];
-      const queryEntityRemovedListeners${queryIndex} = [
-        ${queryConfig.beforeEntityRemoved ? "queryMap." + queryName + ".beforeEntityRemoved" : ""}
-      ];
+      const queryEntityAddedListeners${queryIndex} = [];
+      const queryEntityRemovedListeners${queryIndex} = [];
 
       function afterEntityAdded${queryIndex} (entity) {
         for (const listener of queryEntityAddedListeners${queryIndex}) {
@@ -499,7 +533,7 @@ function getEntityClassCode(componentMap, queries, options) {
       return {
         next() {
           ${""}
-          while (index < (pool.length + pool.freeIndices.length) && (!array[index] || (array[index].version & 1) === 1)) {
+          while (index < (pool.length + pool.freeIndices.length) && (!array[index] || (array[index].poolVersion & 1) === 1)) {
             index++;
           }
 
@@ -544,7 +578,7 @@ function getEntityClassCode(componentMap, queries, options) {
           poolItem = poolArray[arrayOfIndices[index]];
 
           ${""}
-          while (index < arrayOfIndices.length && (((poolItem.version & 1) === 1) || poolItem.version !== arrayOfVersions[index])) {
+          while (index < arrayOfIndices.length && (((poolItem.poolVersion & 1) === 1) || poolItem.poolVersion !== arrayOfVersions[index])) {
             if (fixDestroyed) {
               if (index < arrayOfIndices.length - 1) {
                 arrayOfIndices[index] = arrayOfIndices[arrayOfIndices.length - 1];
@@ -576,9 +610,9 @@ function getEntityClassCode(componentMap, queries, options) {
     }
 
     const theClass = class {
-      constructor(data, index = 0, updateQueryMemberships = true, pool = this.constructor.pool) {
-        this.index = index;
-        this.version = 0; ${""}
+      constructor(data, poolIndex = 0, updateQueryMemberships = true, pool = this.constructor.pool) {
+        this.poolIndex = poolIndex;
+        this.poolVersion = 0; ${""}
         this.pool = pool;
         this.queryIndices = new Array(${queryIndex}).fill(-1);
         this.componentFlags = 0n; ${""}
@@ -637,14 +671,14 @@ function getEntityClassCode(componentMap, queries, options) {
 
       destroy(updateQueryMemberships = true) {
         ${destroyCode}
-        if (this.version & 1 === 1) {
+        if (this.poolVersion & 1 === 1) {
           ${""}
           return;
         }
-        this.version++; // becomes odd, meaning deleted
+        this.poolVersion++; // becomes odd, meaning deleted
         if (this.pool) {
           this.pool.length--;
-          this.pool.freeIndices.push(this.index);
+          this.pool.freeIndices.push(this.poolIndex);
         }
       }
 
@@ -691,8 +725,8 @@ function getEntityClassCode(componentMap, queries, options) {
                 throw new Error("Could not add instance to reference list, instance does not belong to the same pool as the reference list");
               }
               const length = this.length;
-              this.arrayOfIndices[length] = instance.index;
-              this.arrayOfVersions[length] = instance.version;
+              this.arrayOfIndices[length] = instance.poolIndex;
+              this.arrayOfVersions[length] = instance.poolVersion;
               return length;
             }
 
@@ -703,7 +737,7 @@ function getEntityClassCode(componentMap, queries, options) {
               let poolItem = this.pool.array[this.arrayOfIndices[index]];
 
               if (fixDestroyed) {
-                while (index < this.arrayOfIndices.length && ((poolItem.version & 1) === 1 || poolItem.version !== this.arrayOfVersions[index])) {
+                while (index < this.arrayOfIndices.length && ((poolItem.poolVersion & 1) === 1 || poolItem.poolVersion !== this.arrayOfVersions[index])) {
                   if (index < this.arrayOfIndices.length - 1) {
                     this.arrayOfIndices[index] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
                     this.arrayOfVersions[index] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
@@ -717,7 +751,7 @@ function getEntityClassCode(componentMap, queries, options) {
                     return null;
                   }
                 }
-              } else if ((poolItem.version & 1) === 1 || poolItem.version !== this.arrayOfVersions[index]) {
+              } else if ((poolItem.poolVersion & 1) === 1 || poolItem.poolVersion !== this.arrayOfVersions[index]) {
                 return null;
               }
 
@@ -726,7 +760,7 @@ function getEntityClassCode(componentMap, queries, options) {
 
             remove(instance) {
               for (let i = 0; i < this.arrayOfIndices.length; i++) {
-                if (this.arrayOfIndices[i] === instance.index && this.arrayOfVersions[i] === instance.version) {
+                if (this.arrayOfIndices[i] === instance.poolIndex && this.arrayOfVersions[i] === instance.poolVersion) {
                   if (i < this.arrayOfIndices.length - 1) {
                     this.arrayOfIndices[i] = this.arrayOfIndices[this.arrayOfIndices.length - 1];
                     this.arrayOfVersions[i] = this.arrayOfVersions[this.arrayOfVersions.length - 1];
@@ -757,8 +791,8 @@ function getEntityClassCode(componentMap, queries, options) {
             create(data) {
               const instance = this.classConstructor.create(data, this.pool);
               const length = this.length;
-              this.arrayOfIndices[length] = instance.index;
-              this.arrayOfVersions[length] = instance.version;
+              this.arrayOfIndices[length] = instance.poolIndex;
+              this.arrayOfVersions[length] = instance.poolVersion;
               return instance;
             }
 
@@ -784,7 +818,23 @@ function getEntityClassCode(componentMap, queries, options) {
         if (!this.dynamicPoolInstance) {
           this.dynamicPoolInstance = new this.Pool();
         }
-        return this.dynamicPoolInstance;
+        if (!this.dynamicPoolCallable) {
+          const poolInstance = this.dynamicPoolInstance;
+          const callable = new Proxy(function () { return poolInstance; }, {
+            get(_target, prop) {
+              if (prop in poolInstance) {
+                return poolInstance[prop];
+              }
+              return undefined;
+            },
+            set(_target, prop, value) {
+              poolInstance[prop] = value;
+              return true;
+            },
+          });
+          this.dynamicPoolCallable = callable;
+        }
+        return this.dynamicPoolCallable;
       }
 
       static get Pool() {
@@ -829,8 +879,8 @@ function getEntityClassCode(componentMap, queries, options) {
                   array[offset++] = -1;
                   continue;
                 }
-                array[offset++] = instance.version;
-                if (instance.version & 1) {${""}
+                array[offset++] = instance.poolVersion;
+                if (instance.poolVersion & 1) {${""}
                   continue;
                 }
                 offset = instance.toArray(array, offset, skipPoolReferences);
@@ -857,11 +907,11 @@ function getEntityClassCode(componentMap, queries, options) {
 
 
               for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
+                const poolVersion = arrayOfData[offset++];
 
-                if (version & 1) {
+                if (poolVersion & 1) {
                   if (this.array[i]) {
-                    this.array[i].version = version;
+                    this.array[i].poolVersion = poolVersion;
                   }
                   continue;
                 }
@@ -872,7 +922,7 @@ function getEntityClassCode(componentMap, queries, options) {
                   this.array[i] = new classConstructor(undefined, i, this);
                 }
 
-                this.array[i].version = version;
+                this.array[i].poolVersion = poolVersion;
 
                 offset = this.array[i].fromArray(arrayOfData, references, offset);
               }
@@ -897,11 +947,11 @@ function getEntityClassCode(componentMap, queries, options) {
               }
 
               for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
+                const poolVersion = arrayOfData[offset++];
 
-                if (version & 1) {
+                if (poolVersion & 1) {
                   if (this.array[i]) {
-                    this.array[i].version = version;
+                    this.array[i].poolVersion = poolVersion;
                   }
                   continue;
                 }
@@ -912,7 +962,7 @@ function getEntityClassCode(componentMap, queries, options) {
                   this.array[i] = new classConstructor(undefined, i, this);
                 }
 
-                this.array[i].version = version;
+                this.array[i].poolVersion = poolVersion;
 
                 offset = this.array[i].fromArrayNoReferences(arrayOfData, offset);
               }
@@ -937,11 +987,11 @@ function getEntityClassCode(componentMap, queries, options) {
               }
 
               for (let i = 0; i < usedLength; i++) {
-                const version = arrayOfData[offset++];
+                const poolVersion = arrayOfData[offset++];
 
-                if (version & 1) {
+                if (poolVersion & 1) {
                   if (this.array[i]) {
-                    this.array[i].version = version;
+                    this.array[i].poolVersion = poolVersion;
                   }
                   continue;
                 }
@@ -952,7 +1002,7 @@ function getEntityClassCode(componentMap, queries, options) {
                   this.array[i] = new classConstructor(undefined, i, this);
                 }
 
-                this.array[i].version = version;
+                this.array[i].poolVersion = poolVersion;
 
                 offset = this.array[i].fromArrayOnlyReferences(arrayOfData, references, offset);
               }
@@ -967,20 +1017,46 @@ function getEntityClassCode(componentMap, queries, options) {
 
     }
 
-    theClass.queries = queries;
+    const queriesCallable = new Proxy(function () { return queriesCallable; }, {
+      get(_target, prop) {
+        if (prop in queries) {
+          return queries[prop];
+        }
+        return undefined;
+      },
+      set(_target, prop, value) {
+        queries[prop] = value;
+        return true;
+      },
+    });
+    theClass.queries = queriesCallable;
     theClass.componentToEntity = componentToEntity;
     theClass.componentIndices = componentIndices;
     theClass.components = componentPools;
-    theClass.componentsWithEntities = {
+
+    const componentsWithEntities = {
       ${componentWithEntityIteratorFunctionsCode}
     };
+    const componentsWithEntityCallable = new Proxy(function () { return componentsWithEntityCallable; }, {
+      get(_target, prop) {
+        if (prop in componentsWithEntities) {
+          return componentsWithEntities[prop];
+        }
+        return undefined;
+      },
+      set(_target, prop, value) {
+        componentsWithEntities[prop] = value;
+        return true;
+      },
+    });
+    theClass.componentsWithEntities = componentsWithEntityCallable;
 
     theClass.create = function(data, updateQueryMemberships = true, pool = this.pool) {
       if (pool.freeIndices.length) {
         const index = pool.freeIndices.pop();
         pool.length++;
         const instance = pool.array[index];
-        instance.version++; ${""}
+        instance.poolVersion++; ${""}
         instance.reset(data, updateQueryMemberships, pool);
         return instance;
       } else {
@@ -993,12 +1069,12 @@ function getEntityClassCode(componentMap, queries, options) {
 
     theClass.Reference = class {
       constructor(reference) {
-        if (reference && !(reference.version & 1)) {
+        if (reference && !(reference.poolVersion & 1)) {
           this.reference = reference;
-          this.version = reference.version;
+          this.poolVersion = reference.poolVersion;
         } else {
           this.reference = null;
-          this.version = -1;
+          this.poolVersion = -1;
         }
       }
     }
@@ -1014,6 +1090,8 @@ function createEntityClass(options) {
   return (componentMap, queries) => new Function("componentMap", "queryMap", getEntityClassCode(componentMap, queries, options))(componentMap, queries);
 }
 export {
+  EntityReference,
+  EntityReferenceList,
   LazyComponent,
   createEntityClass,
   getEntityClassCode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perplexdotgg/mecs",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "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.6"
+    "monomorph": "^2.1.0"
   },
   "peerDependenciesMeta": {
     "monomorph": {
@@ -37,7 +37,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.1",
-    "monomorph": "^1.5.6",
+    "monomorph": "^2.1.0",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",