Merge branch 'main' into chore/add-exports

Author: krispya

README.md

@@ -447,7 +447,7 @@ These are more like notes for docs. Take a look around, ask questions. Eventuall
 
 This is where all data is stored. We have methods on entities but this is a bit of a trick, entities don't actually store any data and instead it is operating on the connected world. Each world has its own set of entities that do not overlap with another. Typically you only need one world.
 
-Worlds can have traits, which is our version of a singleton. Use these for global resources like a clock. Each world gets its own entity used for world traits. This entity is no queryable but will show up in the list of active entities making the only way to retrieve a world trait with its API.
+Worlds can have traits, which is our version of a singleton. Use these for global resources like a clock. Each world gets its own entity used for world traits. This entity is not queryable but will show up in the list of active entities making the only way to retrieve a world trait with its API.
 
 ```js
 // Spawns an entity
@@ -533,7 +533,7 @@ entity.remove(Position)
 
 // Checks if the entity has the trait
 // Return boolean
-const result = enttiy.has(Position) 
+const result = entity.has(Position) 
 
 // Gets a snapshot instance of the trait
 // Return TraitInstance

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

@@ -43,6 +43,8 @@ export function setChanged(world: World, entity: Entity, trait: Trait) {
 	for (const query of data.queries) {
 		// If the query has no changed modifiers, continue.
 		if (!query.hasChangedModifiers) continue;
+		// If the trait is not part of a Changed modifier in this query, continue.
+		if (!query.changedTraits.has(trait)) continue;
 
 		// Check if the entity matches the query.
 		let match = query.check(world, entity, { type: 'change', traitData: data });

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

@@ -23,8 +23,16 @@ export function createQueryResult<T extends QueryParameter[]>(
 ): QueryResult<T> {
 	query.commitRemovals(world);
 	const entities = query.entities.dense.slice() as Entity[];
+
 	// Clear so it can accumulate again.
-	if (query.isTracking) query.entities.clear();
+	if (query.isTracking) {
+		query.entities.clear();
+
+		// @todo: Need to improve the performance of this loop.
+		for (const eid of entities) {
+			query.resetTrackingBitmasks(eid);
+		}
+	}
 
 	const stores: Store<any>[] = [];
 	const traits: Trait[] = [];

packages/core/src/query/query.ts

@@ -290,7 +290,13 @@ export class Query {
 		const result = this.entities.dense.slice();
 
 		// Clear so it can accumulate again.
-		if (this.isTracking) this.entities.clear();
+		if (this.isTracking) {
+			this.entities.clear();
+
+			for (const eid of result) {
+				this.resetTrackingBitmasks(eid);
+			}
+		}
 
 		return result as Entity[];
 	}

packages/core/src/world/world.ts

@@ -128,7 +128,13 @@ export class World {
 		const ctx = this[$internal];
 
 		// Destroy all entities so any cleanup is done.
-		this.entities.forEach((entity) => destroyEntity(this, entity));
+		this.entities.forEach((entity) => {
+			// Some relations may have caused the entity to be destroyed before
+			// we get to them in the loop.
+			if (this.has(entity)) {
+				destroyEntity(this, entity)
+			}
+		});
 
 		ctx.entityIndex = createEntityIndex(this.#id);
 		ctx.entityTraits.clear();

packages/core/tests/query-modifiers.test.ts

@@ -11,7 +11,6 @@ import {
 } from '../src';
 
 const Position = trait({ x: 0, y: 0 });
-const Name = trait({ name: 'name' });
 const IsActive = trait();
 const Foo = trait({});
 const Bar = trait({});
@@ -382,7 +381,7 @@ describe('Query modifiers', () => {
 		entityA.remove(Foo);
 		entityA.add(Foo);
 		entities = world.query(Added(Foo), Removed(Bar));
-		expect(entities[0]).toBe(entityA);
+		expect(entities.length).toBe(0);
 
 		// Add Foo to entityB and remove Bar.
 		// This entity should now match the query.
@@ -463,4 +462,40 @@ describe('Query modifiers', () => {
 		expect(entities.length).toBe(1);
 		expect(entities2.length).toBe(1);
 	});
+
+	it('should only update a Changed query when the tracked trait is changed', () => {
+		const entity = world.spawn(Foo, Bar);
+
+		const Changed = createChanged();
+
+		expect(world.queryFirst(Changed(Foo), Changed(Bar))).toBeUndefined();
+
+		entity.changed(Foo);
+		entity.changed(Bar);
+		expect(world.queryFirst(Changed(Foo), Changed(Bar))).toBe(entity);
+
+		entity.changed(Foo);
+		expect(world.queryFirst(Changed(Foo), Changed(Bar))).toBeUndefined();
+	});
+
+	// @see https://github.com/pmndrs/koota/issues/115
+	it('should not trigger Changed query when removing a different trait', () => {
+		const Changed = createChanged();
+		const entity = world.spawn(Position);
+
+		// Initial state - no changes
+		expect(world.queryFirst(Changed(Position), Not(Foo))).toBeUndefined();
+
+		// Change Position
+		entity.changed(Position);
+		expect(world.queryFirst(Changed(Position), Not(Foo))).toBe(entity);
+
+		// Query again - should be empty
+		expect(world.queryFirst(Changed(Position), Not(Foo))).toBeUndefined();
+
+		// Add and remove Foo - should be empty
+		entity.add(Foo);
+		entity.remove(Foo);
+		expect(world.queryFirst(Changed(Position), Not(Foo))).toBeUndefined();
+	});
 });

packages/core/tests/world.test.ts

@@ -1,5 +1,5 @@
 import { beforeEach, describe, expect, it } from 'vitest';
-import { createWorld, trait, TraitInstance, universe } from '../src';
+import { createWorld, relation, trait, TraitInstance, universe } from '../src';
 
 describe('World', () => {
 	beforeEach(() => {
@@ -24,6 +24,24 @@ describe('World', () => {
 		expect(world.entities.length).toBe(1);
 	});
 
+	it('reset should remove entities with auto-remove relations', () => {
+		const Node = trait();
+		const ChildOf = relation({ autoRemoveTarget: true, exclusive: true });
+
+		const world = createWorld();
+
+		// Create a parent node and a child node.
+		const parentNode = world.spawn(Node);
+		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.reset()).not.toThrow();
+
+		// Always has one entity that is the world itself.
+		expect(world.entities.length).toBe(1);
+	});
+
 	it('errors if more than 16 worlds are created', () => {
 		for (let i = 0; i < 16; i++) {
 			createWorld();

packages/publish/README.md

@@ -447,7 +447,7 @@ These are more like notes for docs. Take a look around, ask questions. Eventuall
 
 This is where all data is stored. We have methods on entities but this is a bit of a trick, entities don't actually store any data and instead it is operating on the connected world. Each world has its own set of entities that do not overlap with another. Typically you only need one world.
 
-Worlds can have traits, which is our version of a singleton. Use these for global resources like a clock. Each world gets its own entity used for world traits. This entity is no queryable but will show up in the list of active entities making the only way to retrieve a world trait with its API.
+Worlds can have traits, which is our version of a singleton. Use these for global resources like a clock. Each world gets its own entity used for world traits. This entity is not queryable but will show up in the list of active entities making the only way to retrieve a world trait with its API.
 
 ```js
 // Spawns an entity
@@ -533,7 +533,7 @@ entity.remove(Position)
 
 // Checks if the entity has the trait
 // Return boolean
-const result = enttiy.has(Position) 
+const result = entity.has(Position) 
 
 // Gets a snapshot instance of the trait
 // Return TraitInstance

packages/publish/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "koota",
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"description": "🌎 Performant real-time state management for React and TypeScript",
 	"license": "ISC",
 	"type": "module",

packages/publish/tsup.config.ts

@@ -3,6 +3,18 @@ import { defineConfig } from 'tsup';
 export default defineConfig({
 	entry: ['src/index.ts', 'src/react.ts'],
 	format: ['esm', 'cjs'],
+	// Force emitting "use strict" for ESM output
+	// Not all bundlers and frameworks are capable of correctly transforming esm
+	// to cjs output and koota requires strict mode to be enabled for the code to
+	// be sound. The "use strict" directive has no ill effect when running in an
+	// esm environment, while bringing the extra guarantee of ensuring strict mode
+	// is used in non-conformant environments.
+	// See https://262.ecma-international.org/5.1/#sec-C for more details.
+	esbuildOptions: (options, { format }) => {
+		options.banner = format === 'esm' ? {
+			js: '\"use strict\";',
+		} : undefined;
+	},
 	dts: {
 		resolve: true,
 	},