🔖 version bump

Author: krispya

packages/publish/README.md

@@ -913,6 +913,40 @@ return (
 )
 ```
 
+### `useTag`
+
+Observes an entity, or world, for a tag and reactively updates when it is added or removed. Returns `true` when the tag is present or `false` when absent. Use this instead of `useTrait` for tags. For tracking the presence of non-tag traits, use `useHas`.
+
+```js
+const IsActive = trait()
+
+function ActiveIndicator({ entity }) {
+  // Returns true if the entity has the tag, false otherwise
+  const isActive = useTag(entity, IsActive)
+
+  if (!isActive) return null
+
+  return <div>🟢 Active</div>
+}
+```
+
+### `useHas`
+
+Observes an entity, or world, for any trait and reactively updates when it is added or removed. Returns `true` when the trait is present or `false` when absent. Unlike `useTrait`, this only tracks presence and not the trait's value.
+
+```js
+const Health = trait({ amount: 100 })
+
+function HealthIndicator({ entity }) {
+  // Returns true if the entity has the trait, false otherwise
+  const hasHealth = useHas(entity, Health)
+
+  if (!hasHealth) return null
+
+  return <div>❤️ Has Health</div>
+}
+```
+
 ### `useTraitEffect`
 
 Subscribes a callback to a trait on an entity. This callback fires as an effect whenever it is added, removed or changes value without rerendering.

packages/publish/package.json

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

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

@@ -424,4 +424,24 @@ describe('Query', () => {
 			expect(entities[i].id()).toBe(i + 1);
 		}
 	});
+
+	it('cached query should return values after reset', () => {
+		const movementQuery = cacheQuery(Foo);
+
+		const spawnEntities = () => {
+			for (let i = 0; i < 100; i++) {
+				world.spawn(Foo);
+			}
+		};
+
+		spawnEntities();
+		const resultsBefore = world.query(movementQuery);
+
+		world.reset();
+		spawnEntities();
+
+		const resultsAfter = world.query(movementQuery);
+
+		expect(resultsAfter.length).toBe(resultsBefore.length);
+	});
 });

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

@@ -232,4 +232,29 @@ describe('Relation', () => {
 		expect(person.has(Likes(apple))).toBe(false);
 		expect(person.has(Likes(banana))).toBe(false);
 	});
+
+	it('should keep wildcard trait when removing one of multiple relations to the same target', () => {
+		const Likes = relation();
+		const Fears = relation();
+
+		const person = world.spawn();
+		const dragon = world.spawn();
+
+		// Person both likes and fears the dragon
+		person.add(Likes(dragon));
+		person.add(Fears(dragon));
+
+		// Wildcard(dragon) query should find person
+		expect(world.query(Wildcard(dragon))).toContain(person);
+
+		// Remove only the Likes relation
+		person.remove(Likes(dragon));
+
+		// Person should still fear the dragon
+		expect(person.has(Fears(dragon))).toBe(true);
+		expect(person.has(Likes(dragon))).toBe(false);
+
+		// Wildcard(dragon) should still find person because Fears(dragon) remains
+		expect(world.query(Wildcard(dragon))).toContain(person);
+	});
 });

packages/publish/tests/react/trait.test.tsx

@@ -2,7 +2,7 @@ import { createWorld, trait, universe, type Entity, type TraitRecord, type World
 import { render } from '@testing-library/react';
 import { act, StrictMode, useEffect, useState } from 'react';
 import { beforeEach, describe, expect, it } from 'vitest';
-import { useTrait, useTraitEffect, WorldProvider } from '../../react';
+import { useHas, useTag, useTrait, useTraitEffect, WorldProvider } from '../../react';
 
 declare global {
 	var IS_REACT_ACT_ENVIRONMENT: boolean;
@@ -13,6 +13,7 @@ global.IS_REACT_ACT_ENVIRONMENT = true;
 
 let world: World;
 const Position = trait({ x: 0, y: 0 });
+const IsTagged = trait();
 
 describe('useTrait', () => {
 	beforeEach(() => {
@@ -177,6 +178,76 @@ describe('useTrait', () => {
 	});
 });
 
+describe('useTag', () => {
+	beforeEach(() => {
+		universe.reset();
+		world = createWorld();
+	});
+
+	it('reactively returns a boolean for a trait', async () => {
+		const entity = world.spawn(IsTagged);
+		let isTagged: boolean | undefined;
+
+		function Test() {
+			isTagged = useTag(entity, IsTagged);
+			return null;
+		}
+
+		await act(async () => {
+			render(
+				<StrictMode>
+					<WorldProvider world={world}>
+						<Test />
+					</WorldProvider>
+				</StrictMode>
+			);
+		});
+
+		expect(isTagged).toBe(true);
+
+		await act(async () => {
+			entity.remove(IsTagged);
+		});
+
+		expect(isTagged).toBe(false);
+	});
+});
+
+describe('useHas', () => {
+	beforeEach(() => {
+		universe.reset();
+		world = createWorld();
+	});
+
+	it('reactively returns a boolean for any trait', async () => {
+		const entity = world.spawn(Position);
+		let hasPosition: boolean | undefined;
+
+		function Test() {
+			hasPosition = useHas(entity, Position);
+			return null;
+		}
+
+		await act(async () => {
+			render(
+				<StrictMode>
+					<WorldProvider world={world}>
+						<Test />
+					</WorldProvider>
+				</StrictMode>
+			);
+		});
+
+		expect(hasPosition).toBe(true);
+
+		await act(async () => {
+			entity.remove(Position);
+		});
+
+		expect(hasPosition).toBe(false);
+	});
+});
+
 describe('useTraitEffect', () => {
 	beforeEach(() => {
 		universe.reset();