@codehz/ecs 0.6.6 → 0.6.8

package/builder.d.mts

@@ -405,6 +405,7 @@ type SerializedWorld = {
   version: number;
   entityManager: any;
   entities: SerializedEntity[];
+  componentEntities?: SerializedEntity[];
 };
 type SerializedEntity = {
   id: SerializedEntityId;
@@ -428,6 +429,8 @@ declare class World {
   private archetypesByComponent;
   private entityReferences;
   private dontFragmentRelations;
+  private componentEntityComponents;
+  private relationEntityIdsByTarget;
   private queries;
   private queryCache;
   private commandBuffer;
@@ -449,6 +452,12 @@ declare class World {
    * world.sync();
    */
   new<T = void>(): EntityId<T>;
+  private isComponentEntityId;
+  private registerRelationEntityId;
+  private unregisterRelationEntityId;
+  private getComponentEntityComponents;
+  private clearComponentEntityComponents;
+  private cleanupComponentEntitiesReferencingEntity;
   private destroyEntityImmediate;
   /**
    * Checks if an entity exists in the world.
@@ -473,21 +482,32 @@ declare class World {
    * @overload set<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void
    * Adds or updates a component with data on the entity
    *
+   * @overload set<T>(componentId: ComponentId<T>, component: NoInfer<T>): void
+   * Adds or updates a singleton component (shorthand for set(componentId, componentId, component))
+   *
    * @throws {Error} If the entity does not exist
    * @throws {Error} If the component type is invalid or is a wildcard relation
    *
    * @example
    * world.set(entity, Position, { x: 10, y: 20 });
    * world.set(entity, Marker); // void component
+   * world.set(GlobalConfig, { debug: true }); // singleton component
    * world.sync(); // Apply changes
    */
   set(entityId: EntityId, componentType: EntityId<void>): void;
   set<T>(entityId: EntityId, componentType: EntityId<T>, component: NoInfer<T>): void;
+  set<T>(componentId: ComponentId<T>, component: NoInfer<T>): void;
   /**
    * Removes a component from an entity.
    * The change is buffered and takes effect after calling `world.sync()`.
    * If the entity does not exist, throws an error.
    *
+   * @overload remove<T>(entityId: EntityId, componentType: EntityId<T>): void
+   * Removes a component from an entity.
+   *
+   * @overload remove<T>(componentId: ComponentId<T>): void
+   * Removes a singleton component (shorthand for remove(componentId, componentId)).
+   *
    * @template T - The component data type
    * @param entityId - The entity identifier
    * @param componentType - The component type to remove
@@ -497,8 +517,10 @@ declare class World {
    *
    * @example
    * world.remove(entity, Position);
+   * world.remove(GlobalConfig); // Remove singleton component
    * world.sync(); // Apply changes
    */
+  remove<T>(componentId: ComponentId<T>): void;
   remove<T>(entityId: EntityId, componentType: EntityId<T>): void;
   /**
    * Deletes an entity and all its components from the world.
@@ -516,6 +538,12 @@ declare class World {
    * Checks if an entity has a specific component.
    * Immediately reflects the current state without waiting for `sync()`.
    *
+   * @overload has<T>(entityId: EntityId, componentType: EntityId<T>): boolean
+   * Checks if a specific component type is present on the entity.
+   *
+   * @overload has<T>(componentId: ComponentId<T>): boolean
+   * Checks if a singleton component has data (shorthand for has(componentId, componentId)).
+   *
    * @template T - The component data type
    * @param entityId - The entity identifier
    * @param componentType - The component type to check
@@ -525,7 +553,11 @@ declare class World {
    * if (world.has(entity, Position)) {
    *   const pos = world.get(entity, Position);
    * }
+   * if (world.has(GlobalConfig)) {
+   *   const config = world.get(GlobalConfig);
+   * }
    */
+  has<T>(componentId: ComponentId<T>): boolean;
   has<T>(entityId: EntityId, componentType: EntityId<T>): boolean;
   /**
    * Retrieves a component from an entity.
@@ -747,6 +779,7 @@ declare class World {
     components: ComponentTuple<T>;
   }>;
   executeEntityCommands(entityId: EntityId, commands: Command[]): ComponentChangeset;
+  private executeComponentEntityCommands;
   private createHooksContext;
   private removeComponentImmediate;
   private updateEntityReferences;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codehz/ecs",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "repository": {
     "url": "https://github.com/codehz/ecs"
   },

package/world.mjs

@@ -1766,6 +1766,8 @@ var World = class {
 	archetypesByComponent = /* @__PURE__ */ new Map();
 	entityReferences = /* @__PURE__ */ new Map();
 	dontFragmentRelations = /* @__PURE__ */ new Map();
+	componentEntityComponents = /* @__PURE__ */ new Map();
+	relationEntityIdsByTarget = /* @__PURE__ */ new Map();
 	queries = [];
 	queryCache = /* @__PURE__ */ new Map();
 	commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
@@ -1776,6 +1778,18 @@ var World = class {
 	}
 	deserializeSnapshot(snapshot) {
 		if (snapshot.entityManager) this.entityIdManager.deserializeState(snapshot.entityManager);
+		if (Array.isArray(snapshot.componentEntities)) for (const entry of snapshot.componentEntities) {
+			const entityId = decodeSerializedId(entry.id);
+			if (!this.isComponentEntityId(entityId)) continue;
+			const componentsArray = entry.components || [];
+			const componentMap = /* @__PURE__ */ new Map();
+			for (const componentEntry of componentsArray) {
+				const componentType = decodeSerializedId(componentEntry.type);
+				componentMap.set(componentType, componentEntry.value);
+			}
+			this.componentEntityComponents.set(entityId, componentMap);
+			this.registerRelationEntityId(entityId);
+		}
 		if (Array.isArray(snapshot.entities)) for (const entry of snapshot.entities) {
 			const entityId = decodeSerializedId(entry.id);
 			const componentsArray = entry.components || [];
@@ -1818,6 +1832,50 @@ var World = class {
 		this.entityToArchetype.set(entityId, emptyArchetype);
 		return entityId;
 	}
+	isComponentEntityId(entityId) {
+		const detailed = getDetailedIdType(entityId);
+		return detailed.type !== "entity" && detailed.type !== "invalid";
+	}
+	registerRelationEntityId(entityId) {
+		const detailed = getDetailedIdType(entityId);
+		if (detailed.type !== "entity-relation") return;
+		const targetId = detailed.targetId;
+		if (targetId === void 0) return;
+		const existing = this.relationEntityIdsByTarget.get(targetId);
+		if (existing) {
+			existing.add(entityId);
+			return;
+		}
+		this.relationEntityIdsByTarget.set(targetId, new Set([entityId]));
+	}
+	unregisterRelationEntityId(entityId) {
+		const detailed = getDetailedIdType(entityId);
+		if (detailed.type !== "entity-relation") return;
+		const targetId = detailed.targetId;
+		if (targetId === void 0) return;
+		const existing = this.relationEntityIdsByTarget.get(targetId);
+		if (!existing) return;
+		existing.delete(entityId);
+		if (existing.size === 0) this.relationEntityIdsByTarget.delete(targetId);
+	}
+	getComponentEntityComponents(entityId, create) {
+		let data = this.componentEntityComponents.get(entityId);
+		if (!data && create) {
+			data = /* @__PURE__ */ new Map();
+			this.componentEntityComponents.set(entityId, data);
+			this.registerRelationEntityId(entityId);
+		}
+		return data;
+	}
+	clearComponentEntityComponents(entityId) {
+		if (this.componentEntityComponents.delete(entityId)) this.unregisterRelationEntityId(entityId);
+	}
+	cleanupComponentEntitiesReferencingEntity(targetId) {
+		const relationEntities = this.relationEntityIdsByTarget.get(targetId);
+		if (!relationEntities) return;
+		for (const relationEntityId of relationEntities) this.componentEntityComponents.delete(relationEntityId);
+		this.relationEntityIdsByTarget.delete(targetId);
+	}
 	destroyEntityImmediate(entityId) {
 		const queue = [entityId];
 		const visited = /* @__PURE__ */ new Set();
@@ -1839,6 +1897,7 @@ var World = class {
 			triggerRemoveHooksForEntityDeletion(this.createHooksContext(), cur, removedComponents, archetype);
 			this.cleanupArchetypesReferencingEntity(cur);
 			this.entityIdManager.deallocate(cur);
+			this.cleanupComponentEntitiesReferencingEntity(cur);
 		}
 	}
 	/**
@@ -1853,35 +1912,43 @@ var World = class {
 	* }
 	*/
 	exists(entityId) {
+		if (this.isComponentEntityId(entityId)) return true;
 		return this.entityToArchetype.has(entityId);
 	}
-	set(entityId, componentType, component$1) {
-		if (!this.exists(entityId)) throw new Error(`Entity ${entityId} does not exist`);
+	set(entityId, componentTypeOrComponent, maybeComponent) {
+		if (maybeComponent === void 0 && componentTypeOrComponent !== void 0) {
+			const detailedType$1 = getDetailedIdType(entityId);
+			if (detailedType$1.type === "component" || detailedType$1.type === "component-relation") {
+				const componentId = entityId;
+				const component$2 = componentTypeOrComponent;
+				if (!this.exists(componentId)) throw new Error(`Component entity ${componentId} does not exist`);
+				const detailedComponentType = getDetailedIdType(componentId);
+				if (detailedComponentType.type === "invalid") throw new Error(`Invalid component type: ${componentId}`);
+				if (detailedComponentType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentId}`);
+				this.commandBuffer.set(componentId, componentId, component$2);
+				return;
+			}
+		}
+		const entityIdArg = entityId;
+		const componentType = componentTypeOrComponent;
+		const component$1 = maybeComponent;
+		if (!this.exists(entityIdArg)) throw new Error(`Entity ${entityIdArg} does not exist`);
 		const detailedType = getDetailedIdType(componentType);
 		if (detailedType.type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
 		if (detailedType.type === "wildcard-relation") throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
-		this.commandBuffer.set(entityId, componentType, component$1);
+		this.commandBuffer.set(entityIdArg, componentType, component$1);
 	}
-	/**
-	* Removes a component from an entity.
-	* The change is buffered and takes effect after calling `world.sync()`.
-	* If the entity does not exist, throws an error.
-	*
-	* @template T - The component data type
-	* @param entityId - The entity identifier
-	* @param componentType - The component type to remove
-	*
-	* @throws {Error} If the entity does not exist
-	* @throws {Error} If the component type is invalid
-	*
-	* @example
-	* world.remove(entity, Position);
-	* world.sync(); // Apply changes
-	*/
 	remove(entityId, componentType) {
-		if (!this.exists(entityId)) throw new Error(`Entity ${entityId} does not exist`);
+		if (componentType === void 0) {
+			const componentId = entityId;
+			if (!this.exists(componentId)) throw new Error(`Component entity ${componentId} does not exist`);
+			this.commandBuffer.remove(componentId, componentId);
+			return;
+		}
+		const entityIdArg = entityId;
+		if (!this.exists(entityIdArg)) throw new Error(`Entity ${entityIdArg} does not exist`);
 		if (getDetailedIdType(componentType).type === "invalid") throw new Error(`Invalid component type: ${componentType}`);
-		this.commandBuffer.remove(entityId, componentType);
+		this.commandBuffer.remove(entityIdArg, componentType);
 	}
 	/**
 	* Deletes an entity and all its components from the world.
@@ -1897,21 +1964,22 @@ var World = class {
 	delete(entityId) {
 		this.commandBuffer.delete(entityId);
 	}
-	/**
-	* Checks if an entity has a specific component.
-	* Immediately reflects the current state without waiting for `sync()`.
-	*
-	* @template T - The component data type
-	* @param entityId - The entity identifier
-	* @param componentType - The component type to check
-	* @returns `true` if the entity has the component, `false` otherwise
-	*
-	* @example
-	* if (world.has(entity, Position)) {
-	*   const pos = world.get(entity, Position);
-	* }
-	*/
 	has(entityId, componentType) {
+		if (componentType === void 0) {
+			const componentId = entityId;
+			return this.componentEntityComponents.get(componentId)?.has(componentId) ?? false;
+		}
+		if (this.isComponentEntityId(entityId)) {
+			if (isWildcardRelationId(componentType)) {
+				const componentId = getComponentIdFromRelationId(componentType);
+				if (componentId === void 0) return false;
+				const data = this.componentEntityComponents.get(entityId);
+				if (!data) return false;
+				for (const key of data.keys()) if (getComponentIdFromRelationId(key) === componentId) return true;
+				return false;
+			}
+			return this.componentEntityComponents.get(entityId)?.has(componentType) ?? false;
+		}
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) return false;
 		if (archetype.componentTypes.includes(componentType)) return true;
@@ -1919,6 +1987,23 @@ var World = class {
 		return false;
 	}
 	get(entityId, componentType = entityId) {
+		if (this.isComponentEntityId(entityId)) {
+			if (isWildcardRelationId(componentType)) {
+				const componentId = getComponentIdFromRelationId(componentType);
+				const data$1 = this.componentEntityComponents.get(entityId);
+				const relations = [];
+				if (componentId !== void 0 && data$1) {
+					for (const [key, value] of data$1.entries()) if (getComponentIdFromRelationId(key) === componentId) {
+						const detailed = getDetailedIdType(key);
+						if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
+					}
+				}
+				return relations;
+			}
+			const data = this.componentEntityComponents.get(entityId);
+			if (!data || !data.has(componentType)) throw new Error(`Entity ${entityId} does not have component ${componentType}. Use has() to check component existence before calling get().`);
+			return data.get(componentType);
+		}
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) throw new Error(`Entity ${entityId} does not exist`);
 		if (componentType >= 0 || componentType % 2 ** 42 !== 0) {
@@ -1929,6 +2014,24 @@ var World = class {
 		return archetype.get(entityId, componentType);
 	}
 	getOptional(entityId, componentType = entityId) {
+		if (this.isComponentEntityId(entityId)) {
+			if (isWildcardRelationId(componentType)) {
+				const componentId = getComponentIdFromRelationId(componentType);
+				if (componentId === void 0) return void 0;
+				const data$1 = this.componentEntityComponents.get(entityId);
+				if (!data$1) return void 0;
+				const relations = [];
+				for (const [key, value] of data$1.entries()) if (getComponentIdFromRelationId(key) === componentId) {
+					const detailed = getDetailedIdType(key);
+					if (detailed.type === "entity-relation" || detailed.type === "component-relation") relations.push([detailed.targetId, value]);
+				}
+				if (relations.length === 0) return void 0;
+				return { value: relations };
+			}
+			const data = this.componentEntityComponents.get(entityId);
+			if (!data || !data.has(componentType)) return void 0;
+			return { value: data.get(componentType) };
+		}
 		const archetype = this.entityToArchetype.get(entityId);
 		if (!archetype) throw new Error(`Entity ${entityId} does not exist`);
 		if (isWildcardRelationId(componentType)) {
@@ -2193,6 +2296,10 @@ var World = class {
 	}
 	executeEntityCommands(entityId, commands) {
 		const changeset = new ComponentChangeset();
+		if (this.isComponentEntityId(entityId)) {
+			this.executeComponentEntityCommands(entityId, commands);
+			return changeset;
+		}
 		if (commands.some((cmd) => cmd.type === "destroy")) {
 			this.destroyEntityImmediate(entityId);
 			return changeset;
@@ -2210,6 +2317,24 @@ var World = class {
 		triggerLifecycleHooks(this.createHooksContext(), entityId, changeset.adds, removedComponents, currentArchetype, newArchetype);
 		return changeset;
 	}
+	executeComponentEntityCommands(entityId, commands) {
+		if (commands.some((cmd) => cmd.type === "destroy")) {
+			this.clearComponentEntityComponents(entityId);
+			return;
+		}
+		for (const command of commands) if (command.type === "set" && command.componentType) this.getComponentEntityComponents(entityId, true).set(command.componentType, command.component);
+		else if (command.type === "delete" && command.componentType) {
+			const data = this.componentEntityComponents.get(entityId);
+			if (!data) continue;
+			if (isWildcardRelationId(command.componentType)) {
+				const componentId = getComponentIdFromRelationId(command.componentType);
+				if (componentId !== void 0) {
+					for (const key of Array.from(data.keys())) if (getComponentIdFromRelationId(key) === componentId) data.delete(key);
+				}
+			} else data.delete(command.componentType);
+			if (data.size === 0) this.clearComponentEntityComponents(entityId);
+		}
+	}
 	createHooksContext() {
 		return {
 			hooks: this.legacyHooks,
@@ -2331,10 +2456,19 @@ var World = class {
 				}))
 			});
 		}
+		const componentEntities = [];
+		for (const [entityId, components] of this.componentEntityComponents.entries()) componentEntities.push({
+			id: encodeEntityId(entityId),
+			components: Array.from(components.entries()).map(([rawType, value]) => ({
+				type: encodeEntityId(rawType),
+				value: value === MISSING_COMPONENT ? void 0 : value
+			}))
+		});
 		return {
 			version: 1,
 			entityManager: this.entityIdManager.serializeState(),
-			entities
+			entities,
+			componentEntities
 		};
 	}
 };