Merge branch 'main' into refactor/remove-query-class

Author: krispya

packages/core/src/entity/entity.ts

@@ -110,5 +110,5 @@ export function destroyEntity(world: World, entity: Entity) {
 
 /* @inline @pure */ export function getEntityWorld(entity: Entity) {
 	const worldId = getEntityWorldId(entity);
-	return universe.worlds[worldId]!.deref()!;
+	return universe.worlds[worldId]!;
 }

packages/core/src/query/modifiers/added.ts

@@ -8,7 +8,7 @@ export function createAdded() {
 
 	for (const world of universe.worlds) {
 		if (!world) continue;
-		setTrackingMasks(world.deref()!, id);
+		setTrackingMasks(world, id);
 	}
 
 	return <T extends Trait[] = Trait[]>(...traits: T) => {

packages/core/src/query/modifiers/changed.ts

@@ -13,7 +13,7 @@ export function createChanged() {
 
 	for (const world of universe.worlds) {
 		if (!world) continue;
-		setTrackingMasks(world.deref()!, id);
+		setTrackingMasks(world, id);
 	}
 
 	return <T extends Trait[] = Trait[]>(...traits: T) => {

packages/core/src/query/modifiers/removed.ts

@@ -8,7 +8,7 @@ export function createRemoved() {
 
 	for (const world of universe.worlds) {
 		if (!world) continue;
-		setTrackingMasks(world.deref()!, id);
+		setTrackingMasks(world, id);
 	}
 
 	return <T extends Trait[] = Trait[]>(...traits: T) => {

packages/core/src/query/utils/cache-query.ts

@@ -7,10 +7,9 @@ import { createQueryHash } from './create-query-hash';
 export function cacheQuery<T extends QueryParameter[]>(...parameters: T): QueryHash<T> {
 	const hash = createQueryHash(parameters);
 
-	for (const worldRef of universe.worlds) {
-		if (!worldRef) continue;
+	for (const world of universe.worlds) {
+		if (!world) continue;
 
-		const world = worldRef.deref()!;
 		const ctx = world[$internal];
 
 		if (!ctx.queriesHashMap.has(hash)) {

packages/core/src/universe/universe.ts

@@ -1,17 +1,13 @@
-import { WORLD_ID_BITS } from '../entity/utils/pack-entity';
 import type { QueryParameter } from '../query/types';
 import { createWorldIndex } from '../world/utils/world-index';
 import type { World } from '../world/world';
 
 export const universe = {
-	worlds: Array.from({ length: WORLD_ID_BITS ** 2 }, () => null as WeakRef<World> | null),
+	worlds: [] as (World | null)[],
 	cachedQueries: new Map<string, QueryParameter[]>(),
 	worldIndex: createWorldIndex(),
 	reset: () => {
-		universe.worlds = Array.from(
-			{ length: WORLD_ID_BITS ** 2 },
-			() => null as WeakRef<World> | null
-		);
+		universe.worlds = [];
 		universe.cachedQueries = new Map();
 		universe.worldIndex = createWorldIndex();
 	},

packages/core/src/world/world.ts

@@ -27,6 +27,11 @@ import type {
 import { universe } from '../universe/universe';
 import { allocateWorldId, releaseWorldId } from './utils/world-index';
 
+type Options = {
+	traits?: ConfigurableTrait[];
+	lazy?: boolean;
+};
+
 export class World {
 	#id = allocateWorldId(universe.worldIndex);
 
@@ -64,16 +69,21 @@ export class World {
 
 	traits = new Set<Trait>();
 
-	constructor(...traits: ConfigurableTrait[]) {
-		this.init(...traits);
+	constructor(polyArg?: Options | ConfigurableTrait, ...traits: ConfigurableTrait[]) {
+		if (polyArg && typeof polyArg === 'object' && !Array.isArray(polyArg)) {
+			const { traits: optionTraits = [], lazy = false } = polyArg as Options;
+			if (!lazy) this.init(...optionTraits);
+		} else {
+			this.init(...(polyArg ? [polyArg, ...traits] : traits));
+		}
 	}
 
 	init(...traits: ConfigurableTrait[]) {
 		const ctx = this[$internal];
 		if (this.#isInitialized) return;
 
 		this.#isInitialized = true;
-		universe.worlds[this.#id] = new WeakRef(this);
+		universe.worlds[this.#id] = this;
 
 		// Create uninitialized added masks.
 		const cursor = getTrackingCursor();
@@ -127,8 +137,6 @@ export class World {
 		destroyEntity(this, this[$internal].worldEntity);
 		this[$internal].worldEntity = null!;
 
-		// Destroy itself and all entities.
-		this.entities.forEach((entity) => destroyEntity(this, entity));
 		this.reset();
 		this.#isInitialized = false;
 
@@ -318,14 +326,11 @@ export class World {
 	}
 }
 
-// Clean up the world ID when it is garbage collected.
-const worldFinalizer = new FinalizationRegistry((worldId: number) => {
-	universe.worlds[worldId] = null;
-	releaseWorldId(universe.worldIndex, worldId);
-});
-
-export function createWorld(...traits: ConfigurableTrait[]) {
-	const world = new World(...traits);
-	worldFinalizer.register(world, world.id);
-	return world;
+export function createWorld(options: Options): World;
+export function createWorld(...traits: ConfigurableTrait[]): World;
+export function createWorld(
+	optionsOrFirstTrait?: Options | ConfigurableTrait,
+	...traits: ConfigurableTrait[]
+) {
+	return new World(optionsOrFirstTrait, ...traits);
 }

packages/core/tests/world.test.ts

@@ -12,10 +12,17 @@ describe('World', () => {
 
 		expect(world.isInitialized).toBe(true);
 		expect(world.id).toBe(0);
-		expect(universe.worlds[0]!.deref()!).toBe(world);
+		expect(universe.worlds[0]!).toBe(world);
 		expect(universe.worldIndex.worldCursor).toBe(1);
 	});
 
+	it('should optionaly init lazily', () => {
+		const world = createWorld({ lazy: true });
+		expect(world.isInitialized).toBe(false);
+		world.init();
+		expect(world.isInitialized).toBe(true);
+	});
+
 	it('should reset the world', () => {
 		const world = createWorld();
 		world.reset();
@@ -42,6 +49,22 @@ describe('World', () => {
 		expect(world.entities.length).toBe(1);
 	});
 
+	it('destroy should lead to entities with auto-remove relations being removed as well', () => {
+		const Node = trait();
+		const ChildOf = relation({ autoRemoveTarget: true, exclusive: true });
+
+		const world = createWorld();
+
+		// Create a parent node and two child nodes
+		const parentNode = world.spawn(Node);
+		world.spawn(Node, ChildOf(parentNode));
+		world.spawn(Node, ChildOf(parentNode));
+
+		// Expect this to not throw, since the ChildOf relation will automatically
+		// remove the child node when the parent node is destroyed first
+		expect(() => world.destroy()).not.toThrow();
+	});
+
 	it('errors if more than 16 worlds are created', () => {
 		for (let i = 0; i < 16; i++) {
 			createWorld();

packages/publish/tests/core/world.test.ts

@@ -42,6 +42,22 @@ describe('World', () => {
 		expect(world.entities.length).toBe(1);
 	});
 
+	it('destroy should lead to entities with auto-remove relations being removed as well', () => {
+		const Node = trait();
+		const ChildOf = relation({ autoRemoveTarget: true, exclusive: true });
+
+		const world = createWorld();
+
+		// Create a parent node and two child nodes
+		const parentNode = world.spawn(Node);
+		world.spawn(Node, ChildOf(parentNode));
+		world.spawn(Node, ChildOf(parentNode));
+
+		// Expect this to not throw, since the ChildOf relation will automatically
+		// remove the child node when the parent node is destroyed first
+		expect(() => world.destroy()).not.toThrow();
+	});
+
 	it('errors if more than 16 worlds are created', () => {
 		for (let i = 0; i < 16; i++) {
 			createWorld();

packages/react/tests/world.test.tsx

@@ -1,6 +1,6 @@
 import { createWorld, universe, type World } from '@koota/core';
 import { render } from '@testing-library/react';
-import { act, StrictMode } from 'react';
+import { act, StrictMode, useEffect, useMemo } from 'react';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { useWorld, WorldProvider } from '../src';
 
@@ -39,4 +39,31 @@ describe('World', () => {
 
 		expect(worldTest).toBe(world);
 	});
+
+	it('can lazy init to create a world in useMemo', () => {
+		universe.reset();
+
+		let worldTest: World = null!;
+
+		function Test() {
+			worldTest = useMemo(() => createWorld({ lazy: true }), []);
+
+			useEffect(() => {
+				worldTest.init();
+				return () => worldTest.destroy();
+			}, [worldTest]);
+
+			return null;
+		}
+
+		render(
+			<StrictMode>
+				<Test />
+			</StrictMode>
+		);
+
+		expect(worldTest).toBeDefined();
+		expect(worldTest!.isInitialized).toBe(true);
+		expect(universe.worlds.length).toBe(1);
+	});
 });