♻️ use inline plugin

packages/core/src/entity/entity-methods-patch.ts

@@ -3,90 +3,68 @@
 // and the convenience of using methods. Type guards are used to ensure
 // that the methods are only called on entities.
 
-import { addTrait, getTrait, hasTrait, removeTrait, setTrait } from '../trait/trait';
-import { ConfigurableTrait, Trait } from '../trait/types';
+import { $internal } from '../common';
 import { setChanged } from '../query/modifiers/changed';
 import { getRelationTargets } from '../relation/relation';
 import { Relation } from '../relation/types';
-import { universe } from '../universe/universe';
-import { $internal } from '../common';
-import { destroyEntity } from './entity';
+import { addTrait, getTrait, hasTrait, removeTrait, setTrait } from '../trait/trait';
+import { ConfigurableTrait, Trait } from '../trait/types';
+import { destroyEntity, getEntityWorld } from './entity';
 import { Entity } from './types';
-import { ENTITY_ID_MASK, WORLD_ID_SHIFT } from './utils/pack-entity';
+import { getEntityId } from './utils/pack-entity';
 import { isEntityAlive } from './utils/entity-index';
 
 // @ts-expect-error
 Number.prototype.add = function (this: Entity, ...traits: ConfigurableTrait[]) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return addTrait(world, this, ...traits);
+	return addTrait(getEntityWorld(this), this, ...traits);
 };
 
 // @ts-expect-error
 Number.prototype.remove = function (this: Entity, ...traits: Trait[]) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return removeTrait(world, this, ...traits);
+	return removeTrait(getEntityWorld(this), this, ...traits);
 };
 
 // @ts-expect-error
 Number.prototype.has = function (this: Entity, trait: Trait) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return hasTrait(world, this, trait);
+	return hasTrait(getEntityWorld(this), this, trait);
 };
 
 // @ts-expect-error
 Number.prototype.destroy = function (this: Entity) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return destroyEntity(world, this);
+	return destroyEntity(getEntityWorld(this), this);
 };
 
 // @ts-expect-error
 Number.prototype.changed = function (this: Entity, trait: Trait) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return setChanged(world, this, trait);
+	return setChanged(getEntityWorld(this), this, trait);
 };
 
 // @ts-expect-error
 Number.prototype.get = function (this: Entity, trait: Trait) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return getTrait(world, this, trait);
+	return getTrait(getEntityWorld(this), this, trait);
 };
 
 // @ts-expect-error
 Number.prototype.set = function (this: Entity, trait: Trait, value: any, triggerChanged = true) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	setTrait(world, this, trait, value, triggerChanged);
+	setTrait(getEntityWorld(this), this, trait, value, triggerChanged);
 };
 
 //@ts-expect-error
 Number.prototype.targetsFor = function (this: Entity, relation: Relation<any>) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return getRelationTargets(world, relation, this);
+	return getRelationTargets(getEntityWorld(this), relation, this);
 };
 
 //@ts-expect-error
 Number.prototype.targetFor = function (this: Entity, relation: Relation<any>) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return getRelationTargets(world, relation, this)[0];
+	return getRelationTargets(getEntityWorld(this), relation, this)[0];
 };
 
 //@ts-expect-error
 Number.prototype.id = function (this: Entity) {
-	const id = this & ENTITY_ID_MASK;
-	return id;
+	return getEntityId(this);
 };
 
 //@ts-expect-error
 Number.prototype.isAlive = function (this: Entity) {
-	const worldId = this >>> WORLD_ID_SHIFT;
-	const world = universe.worlds[worldId]!.deref()!;
-	return isEntityAlive(world[$internal].entityIndex, this);
+	return isEntityAlive(getEntityWorld(this)[$internal].entityIndex, this);
 };

packages/core/src/entity/entity.ts

@@ -1,11 +1,12 @@
+import { $internal } from '../common';
+import { Pair, Wildcard } from '../relation/relation';
 import { addTrait, removeTrait } from '../trait/trait';
 import { ConfigurableTrait } from '../trait/types';
-import { Pair, Wildcard } from '../relation/relation';
-import { $internal } from '../common';
 import { World } from '../world/world';
 import { Entity } from './types';
 import { allocateEntity, releaseEntity } from './utils/entity-index';
-import { getEntityId } from './utils/pack-entity';
+import { universe } from '../universe/universe';
+import { getEntityId, getEntityWorldId } from './utils/pack-entity';
 
 // Ensure entity methods are patched.
 import './entity-methods-patch';
@@ -106,3 +107,8 @@ export function destroyEntity(world: World, entity: Entity) {
 		}
 	}
 }
+
+/* @inline @pure */ export function getEntityWorld(entity: Entity) {
+	const worldId = getEntityWorldId(entity);
+	return universe.worlds[worldId]!.deref()!;
+}

packages/core/src/entity/utils/pack-entity.ts

@@ -29,10 +29,9 @@ export function unpackEntity(entity: Entity) {
 	};
 }
 
-export const getEntityId = (entity: Entity) => entity & ENTITY_ID_MASK;
-export const getEntityWorldId = (entity: Entity) => entity >>> WORLD_ID_SHIFT;
-
-export const getEntityAndWorldId = (entity: Entity): [number, number] => [
+export const getEntityId = /* @inline @pure */ (entity: Entity) => entity & ENTITY_ID_MASK;
+export const getEntityWorldId = /* @inline @pure */ (entity: Entity) => entity >>> WORLD_ID_SHIFT;
+export const getEntityAndWorldId = /* @pure */ (entity: Entity): [number, number] => [
 	entity & ENTITY_ID_MASK,
 	entity >>> WORLD_ID_SHIFT,
 ];

packages/core/src/query/query-result.ts

@@ -47,29 +47,13 @@ export function createQueryResult<T extends QueryParameter[]>(
 				const trackedIndices: number[] = [];
 				const untrackedIndices: number[] = [];
 
-				// Get the traits that are being tracked for changes.
-				for (let i = 0; i < traits.length; i++) {
-					const trait = traits[i];
-					const hasTracked = world[$internal].trackedTraits.has(trait);
-					const hasChanged = query.hasChangedModifiers && query.changedTraits.has(trait);
-
-					if (hasTracked || hasChanged) trackedIndices.push(i);
-					else untrackedIndices.push(i);
-				}
+				getTrackedTraits(traits, world, query, trackedIndices, untrackedIndices);
 
 				for (let i = 0; i < entities.length; i++) {
 					const entity = entities[i];
 					const eid = getEntityId(entity);
 
-					// Create a snapshot for each trait in the order they appear in the query params.
-					for (let j = 0; j < traits.length; j++) {
-						const trait = traits[j];
-						const ctx = trait[$internal];
-						const value = ctx.get(eid, stores[j]);
-						state[j] = value;
-						atomicSnapshots[j] = ctx.type === 'aos' ? { ...value } : null;
-					}
-
+					createSnapshotsWithAtomic(eid, traits, stores, state, atomicSnapshots);
 					callback(state as any, entity, i);
 
 					// Skip if the entity has been destroyed.
@@ -120,15 +104,7 @@ export function createQueryResult<T extends QueryParameter[]>(
 					const entity = entities[i];
 					const eid = getEntityId(entity);
 
-					// Create a snapshot for each trait in the order they appear in the query params.
-					for (let j = 0; j < traits.length; j++) {
-						const trait = traits[j];
-						const ctx = trait[$internal];
-						const value = ctx.get(eid, stores[j]);
-						state[j] = value;
-						atomicSnapshots[j] = ctx.type === 'aos' ? { ...value } : null;
-					}
-
+					createSnapshotsWithAtomic(eid, traits, stores, state, atomicSnapshots);
 					callback(state as any, entity, i);
 
 					// Skip if the entity has been destroyed.
@@ -164,14 +140,7 @@ export function createQueryResult<T extends QueryParameter[]>(
 				for (let i = 0; i < entities.length; i++) {
 					const entity = entities[i];
 					const eid = getEntityId(entity);
-
-					// Create a snapshot for each trait in the order they appear in the query params.
-					for (let j = 0; j < traits.length; j++) {
-						const trait = traits[j];
-						const ctx = trait[$internal];
-						state[j] = ctx.get(eid, stores[j]);
-					}
-
+					createSnapshots(eid, traits, stores, state);
 					callback(state as any, entity, i);
 
 					// Skip if the entity has been destroyed.
@@ -212,7 +181,54 @@ export function createQueryResult<T extends QueryParameter[]>(
 	return results;
 }
 
-function getQueryStores<T extends QueryParameter[]>(
+/* @inline */ function getTrackedTraits(
+	traits: Trait[],
+	world: World,
+	query: Query,
+	trackedIndices: number[],
+	untrackedIndices: number[]
+) {
+	for (let i = 0; i < traits.length; i++) {
+		const trait = traits[i];
+		const hasTracked = world[$internal].trackedTraits.has(trait);
+		const hasChanged = query.hasChangedModifiers && query.changedTraits.has(trait);
+
+		if (hasTracked || hasChanged) trackedIndices.push(i);
+		else untrackedIndices.push(i);
+	}
+}
+
+/* @inline */ function createSnapshots(
+	entityId: number,
+	traits: Trait[],
+	stores: Store<any>[],
+	state: any[]
+) {
+	for (let i = 0; i < traits.length; i++) {
+		const trait = traits[i];
+		const ctx = trait[$internal];
+		const value = ctx.get(entityId, stores[i]);
+		state[i] = value;
+	}
+}
+
+/* @inline */ function createSnapshotsWithAtomic(
+	entityId: number,
+	traits: Trait[],
+	stores: Store<any>[],
+	state: any[],
+	atomicSnapshots: any[]
+) {
+	for (let j = 0; j < traits.length; j++) {
+		const trait = traits[j];
+		const ctx = trait[$internal];
+		const value = ctx.get(entityId, stores[j]);
+		state[j] = value;
+		atomicSnapshots[j] = ctx.type === 'aos' ? { ...value } : null;
+	}
+}
+
+/* @inline */ function getQueryStores<T extends QueryParameter[]>(
 	params: T,
 	traits: Trait[],
 	stores: Store<any>[],

packages/core/src/trait/trait.ts

@@ -1,6 +1,6 @@
 import { $internal } from '../common';
 import { Entity } from '../entity/types';
-import { ENTITY_ID_MASK, getEntityId } from '../entity/utils/pack-entity';
+import { getEntityId } from '../entity/utils/pack-entity';
 import { setChanged } from '../query/modifiers/changed';
 import { getRelationTargets, Pair, Wildcard } from '../relation/relation';
 import { incrementWorldBitflag } from '../world/utils/increment-world-bit-flag';
@@ -224,7 +224,7 @@ export function removeTrait(world: World, entity: Entity, ...traits: Trait[]) {
 	}
 }
 
-export function hasTrait(world: World, entity: Entity, trait: Trait): boolean {
+export /* @inline @pure */ function hasTrait(world: World, entity: Entity, trait: Trait): boolean {
 	const ctx = world[$internal];
 	const data = ctx.traitData.get(trait);
 	if (!data) return false;
@@ -236,12 +236,13 @@ export function hasTrait(world: World, entity: Entity, trait: Trait): boolean {
 	return (mask & bitflag) === bitflag;
 }
 
-export function getStore<C extends Trait = Trait>(world: World, trait: C): ExtractStore<C> {
+export /* @inline @pure */ function getStore<C extends Trait = Trait>(
+	world: World,
+	trait: C
+): ExtractStore<C> {
 	const ctx = world[$internal];
 	const data = ctx.traitData.get(trait)!;
-	const store = data.store as ExtractStore<C>;
-
-	return store;
+	return data.store as ExtractStore<C>;
 }
 
 export function setTrait(
@@ -252,8 +253,8 @@ export function setTrait(
 	triggerChanged = true
 ) {
 	const ctx = trait[$internal];
-	const index = entity & ENTITY_ID_MASK;
 	const store = getStore(world, trait);
+	const index = getEntityId(entity);
 
 	// A short circuit is more performance than an if statement which creates a new code statement.
 	value instanceof Function && (value = value(ctx.get(index, store)));
@@ -263,21 +264,10 @@ export function setTrait(
 }
 
 export function getTrait(world: World, entity: Entity, trait: Trait) {
-	const worldCtx = world[$internal];
-	const data = worldCtx.traitData.get(trait);
-
-	// If the trait does not exist on the world return undefined.
-	if (!data) return undefined;
-
-	// Get entity index/id.
-	const index = getEntityId(entity);
-
-	// If the entity does not have the trait return undefined.
-	const mask = worldCtx.entityMasks[data.generationId][index];
-	if ((mask & data.bitflag) !== data.bitflag) return undefined;
+	const result = hasTrait(world, entity, trait);
+	if (!result) return undefined;
 
-	// Return a snapshot of the trait state.
 	const traitCtx = trait[$internal];
 	const store = getStore(world, trait);
-	return traitCtx.get(index, store);
+	return traitCtx.get(getEntityId(entity), store);
 }

packages/core/src/utils/shallow-equal.ts

@@ -1,24 +1,20 @@
-export function shallowEqual(obj1: any, obj2: any): boolean {
-	if (obj1 === obj2) {
-		return true;
-	}
+// This shallow equal looks insane because it is optimized to use short circuiting
+// and the least amount of evaluations possible.
 
-	if (typeof obj1 !== 'object' || obj1 === null || typeof obj2 !== 'object' || obj2 === null) {
-		return false;
-	}
-
-	const keys1 = Object.keys(obj1);
-	const keys2 = Object.keys(obj2);
-
-	if (keys1.length !== keys2.length) {
-		return false;
-	}
-
-	for (const key of keys1) {
-		if (!obj2.hasOwnProperty(key) || obj1[key] !== obj2[key]) {
-			return false;
-		}
-	}
-
-	return true;
+export function /* @inline @pure */ shallowEqual(obj1: any, obj2: any): boolean {
+	return (
+		obj1 === obj2 ||
+		(typeof obj1 === 'object' &&
+			obj1 !== null &&
+			typeof obj2 === 'object' &&
+			obj2 !== null &&
+			(() => {
+				const keys1 = Object.keys(obj1);
+				const keys2 = Object.keys(obj2);
+				return (
+					keys1.length === keys2.length &&
+					keys1.every((key) => obj2.hasOwnProperty(key) && obj1[key] === obj2[key])
+				);
+			})())
+	);
 }

packages/publish/package.json

@@ -38,6 +38,7 @@
 	"devDependencies": {
 		"@koota/core": "workspace:*",
 		"@koota/react": "workspace:*",
+		"esbuild-plugin-inline-functions": "^0.1.0",
 		"react": ">=18.0.0",
 		"react-dom": ">=18.0.0",
 		"tsconfig": "workspace:*",

packages/publish/tsup.config.ts

@@ -1,4 +1,5 @@
 import { defineConfig } from 'tsup';
+import { inlineFunctionsPlugin } from 'esbuild-plugin-inline-functions';
 
 export default defineConfig({
 	entry: ['src/index.ts', 'src/react.ts'],
@@ -7,4 +8,5 @@ export default defineConfig({
 		resolve: true,
 	},
 	clean: true,
+	esbuildPlugins: [inlineFunctionsPlugin()],
 });