koota 0.2.2 → 0.2.3

package/dist/{chunk-4QEK6BHY.js → chunk-ZHBGFPP2.js}

@@ -38,6 +38,137 @@ var getEntityGeneration = (entity) => entity >>> GENERATION_SHIFT & GENERATION_M
 var incrementGeneration = (entity) => entity & ~(GENERATION_MASK << GENERATION_SHIFT) | // Clear current generation bits
 ((entity >>> GENERATION_SHIFT & GENERATION_MASK) + 1 & GENERATION_MASK) << GENERATION_SHIFT;
 
+// ../core/src/world/utils/world-index.ts
+function createWorldIndex() {
+  return {
+    worldCursor: 0,
+    releasedWorldIds: [],
+    maxWorlds: 2 ** WORLD_ID_BITS
+  };
+}
+function allocateWorldId(index) {
+  if (index.releasedWorldIds.length > 0) {
+    return index.releasedWorldIds.pop();
+  }
+  if (index.worldCursor >= index.maxWorlds) {
+    throw new Error(`Koota: Too many worlds created. The maximum is ${index.maxWorlds}.`);
+  }
+  return index.worldCursor++;
+}
+function releaseWorldId(index, worldId) {
+  if (worldId < 0 || worldId >= index.maxWorlds) {
+    throw new Error(`Invalid world ID: ${worldId}`);
+  }
+  if (worldId === index.worldCursor - 1) {
+    index.worldCursor--;
+  } else if (worldId < index.worldCursor && !index.releasedWorldIds.includes(worldId)) {
+    index.releasedWorldIds.push(worldId);
+  }
+}
+
+// ../core/src/universe/universe.ts
+var universe = {
+  worlds: new Array(WORLD_ID_BITS ** 2),
+  cachedQueries: /* @__PURE__ */ new Map(),
+  worldIndex: createWorldIndex(),
+  reset: () => {
+    universe.worlds = new Array(WORLD_ID_BITS ** 2);
+    universe.cachedQueries = /* @__PURE__ */ new Map();
+    universe.worldIndex = createWorldIndex();
+  }
+};
+
+// ../core/src/query/modifier.ts
+var ModifierData = class {
+  constructor(type, id, traits) {
+    this.type = type;
+    this.id = id;
+    this.traits = traits;
+    __publicField(this, "traitIds");
+    this.traitIds = traits.map((trait2) => trait2[$internal].id);
+  }
+};
+
+// ../core/src/query/utils/tracking-cursor.ts
+var cursor = 3;
+function createTrackingId() {
+  return cursor++;
+}
+function getTrackingCursor() {
+  return cursor;
+}
+function setTrackingMasks(world, id) {
+  const ctx = world[$internal];
+  const snapshot = structuredClone(ctx.entityMasks);
+  ctx.trackingSnapshots.set(id, snapshot);
+  ctx.dirtyMasks.set(
+    id,
+    snapshot.map((mask) => mask.map(() => 0))
+  );
+  ctx.changedMasks.set(
+    id,
+    snapshot.map((mask) => mask.map(() => 0))
+  );
+}
+
+// ../core/src/relation/relation.ts
+function defineRelation(definition) {
+  const pairsMap = /* @__PURE__ */ new Map();
+  const traitFactory = () => trait(definition?.store ?? {});
+  function relationFn(target) {
+    if (target === void 0) throw Error("Relation target is undefined");
+    if (target === "*") target = Wildcard;
+    return getRelationTrait(
+      relationFn,
+      traitFactory,
+      pairsMap,
+      target
+    );
+  }
+  return Object.assign(relationFn, {
+    [$internal]: {
+      pairsMap,
+      createTrait: traitFactory,
+      exclusive: definition?.exclusive ?? false,
+      autoRemoveTarget: definition?.autoRemoveTarget ?? false
+    }
+  });
+}
+var relation = defineRelation;
+function getRelationTrait(relation2, traitFactory, pairsMap, target) {
+  if (!pairsMap.has(target)) {
+    const trait2 = traitFactory();
+    const tratCtx = trait2[$internal];
+    tratCtx.isPairTrait = true;
+    tratCtx.relation = relation2;
+    tratCtx.pairTarget = target;
+    pairsMap.set(target, trait2);
+  }
+  return pairsMap.get(target);
+}
+var getRelationTargets = (world, relation2, entity) => {
+  const ctx = world[$internal];
+  const traits = ctx.entityTraits.get(entity) || [];
+  const targets = [];
+  for (const trait2 of traits) {
+    const traitCtx = trait2[$internal];
+    if (traitCtx.relation === relation2 && traitCtx.pairTarget !== Wildcard) {
+      targets.push(traitCtx.pairTarget);
+    }
+  }
+  return targets;
+};
+var Pair = (relation2, target) => {
+  if (relation2 === void 0) throw Error("Relation is undefined");
+  if (target === void 0) throw Error("Relation target is undefined");
+  if (target === "*") target = Wildcard;
+  const ctx = relation2[$internal];
+  const pairsMap = ctx.pairsMap;
+  const traitFactory = ctx.createTrait;
+  return getRelationTrait(relation2, traitFactory, pairsMap, target);
+};
+var Wildcard = defineRelation();
+
 // ../core/src/world/utils/increment-world-bit-flag.ts
 var incrementWorldBitflag = (world) => {
   const ctx = world[$internal];
@@ -227,7 +358,7 @@ function addTrait(world, entity, ...traits) {
     } else {
       trait2 = traits[i];
     }
-    if (entity.has(trait2)) return;
+    if (hasTrait(world, entity, trait2)) return;
     const traitCtx = trait2[$internal];
     if (!ctx.traitData.has(trait2)) registerTrait(world, trait2);
     const data = ctx.traitData.get(trait2);
@@ -249,8 +380,8 @@ function addTrait(world, entity, ...traits) {
     const target = traitCtx.pairTarget;
     if (traitCtx.isPairTrait && relation2 !== null && target !== null) {
       ctx.relationTargetEntities.add(target);
-      entity.add(Pair(Wildcard, target));
-      entity.add(Pair(relation2, Wildcard));
+      addTrait(world, entity, Pair(Wildcard, target));
+      addTrait(world, entity, Pair(relation2, Wildcard));
       if (relation2[$internal].exclusive === true && target !== Wildcard) {
         const oldTarget = getRelationTargets(world, relation2, entity)[0];
         if (oldTarget !== null && oldTarget !== void 0 && oldTarget !== target) {
@@ -267,10 +398,10 @@ function addTrait(world, entity, ...traits) {
           defaults[key] = data.schema[key];
         }
       }
-      entity.set(trait2, { ...defaults, ...params }, false);
+      setTrait(world, entity, trait2, { ...defaults, ...params }, false);
     } else {
       const state = params ?? data.schema();
-      entity.set(trait2, state, false);
+      setTrait(world, entity, trait2, state, false);
     }
   }
 }
@@ -279,7 +410,7 @@ function removeTrait(world, entity, ...traits) {
   for (let i = 0; i < traits.length; i++) {
     const trait2 = traits[i];
     const traitCtx = trait2[$internal];
-    if (!entity.has(trait2)) return;
+    if (!hasTrait(world, entity, trait2)) return;
     const data = ctx.traitData.get(trait2);
     const { generationId, bitflag, queries } = data;
     const eid = getEntityId(entity);
@@ -322,136 +453,24 @@ function getStore(world, trait2) {
   const store = data.store;
   return store;
 }
-
-// ../core/src/relation/relation.ts
-function defineRelation(definition) {
-  const pairsMap = /* @__PURE__ */ new Map();
-  const traitFactory = () => trait(definition?.store ?? {});
-  function relationFn(target) {
-    if (target === void 0) throw Error("Relation target is undefined");
-    if (target === "*") target = Wildcard;
-    return getRelationTrait(
-      relationFn,
-      traitFactory,
-      pairsMap,
-      target
-    );
-  }
-  return Object.assign(relationFn, {
-    [$internal]: {
-      pairsMap,
-      createTrait: traitFactory,
-      exclusive: definition?.exclusive ?? false,
-      autoRemoveTarget: definition?.autoRemoveTarget ?? false
-    }
-  });
-}
-var relation = defineRelation;
-function getRelationTrait(relation2, traitFactory, pairsMap, target) {
-  if (!pairsMap.has(target)) {
-    const trait2 = traitFactory();
-    const tratCtx = trait2[$internal];
-    tratCtx.isPairTrait = true;
-    tratCtx.relation = relation2;
-    tratCtx.pairTarget = target;
-    pairsMap.set(target, trait2);
-  }
-  return pairsMap.get(target);
-}
-var getRelationTargets = (world, relation2, entity) => {
-  const ctx = world[$internal];
-  const traits = ctx.entityTraits.get(entity) || [];
-  const targets = [];
-  for (const trait2 of traits) {
-    const traitCtx = trait2[$internal];
-    if (traitCtx.relation === relation2 && traitCtx.pairTarget !== Wildcard) {
-      targets.push(traitCtx.pairTarget);
-    }
-  }
-  return targets;
-};
-var Pair = (relation2, target) => {
-  if (relation2 === void 0) throw Error("Relation is undefined");
-  if (target === void 0) throw Error("Relation target is undefined");
-  if (target === "*") target = Wildcard;
-  const ctx = relation2[$internal];
-  const pairsMap = ctx.pairsMap;
-  const traitFactory = ctx.createTrait;
-  return getRelationTrait(relation2, traitFactory, pairsMap, target);
-};
-var Wildcard = defineRelation();
-
-// ../core/src/world/utils/world-index.ts
-function createWorldIndex() {
-  return {
-    worldCursor: 0,
-    releasedWorldIds: [],
-    maxWorlds: 2 ** WORLD_ID_BITS
-  };
-}
-function allocateWorldId(index) {
-  if (index.releasedWorldIds.length > 0) {
-    return index.releasedWorldIds.pop();
-  }
-  if (index.worldCursor >= index.maxWorlds) {
-    throw new Error(`Koota: Too many worlds created. The maximum is ${index.maxWorlds}.`);
-  }
-  return index.worldCursor++;
-}
-function releaseWorldId(index, worldId) {
-  if (worldId < 0 || worldId >= index.maxWorlds) {
-    throw new Error(`Invalid world ID: ${worldId}`);
-  }
-  if (worldId === index.worldCursor - 1) {
-    index.worldCursor--;
-  } else if (worldId < index.worldCursor && !index.releasedWorldIds.includes(worldId)) {
-    index.releasedWorldIds.push(worldId);
-  }
-}
-
-// ../core/src/universe/universe.ts
-var universe = {
-  worlds: new Array(WORLD_ID_BITS ** 2),
-  cachedQueries: /* @__PURE__ */ new Map(),
-  worldIndex: createWorldIndex(),
-  reset: () => {
-    universe.worlds = new Array(WORLD_ID_BITS ** 2);
-    universe.cachedQueries = /* @__PURE__ */ new Map();
-    universe.worldIndex = createWorldIndex();
-  }
-};
-
-// ../core/src/query/modifier.ts
-var ModifierData = class {
-  constructor(type, id, traits) {
-    this.type = type;
-    this.id = id;
-    this.traits = traits;
-    __publicField(this, "traitIds");
-    this.traitIds = traits.map((trait2) => trait2[$internal].id);
-  }
-};
-
-// ../core/src/query/utils/tracking-cursor.ts
-var cursor = 3;
-function createTrackingId() {
-  return cursor++;
-}
-function getTrackingCursor() {
-  return cursor;
+function setTrait(world, entity, trait2, value, triggerChanged = true) {
+  const ctx = trait2[$internal];
+  const index = entity & ENTITY_ID_MASK;
+  const store = getStore(world, trait2);
+  value instanceof Function && (value = value(ctx.get(index, store)));
+  ctx.set(index, store, value);
+  triggerChanged && setChanged(world, entity, trait2);
 }
-function setTrackingMasks(world, id) {
-  const ctx = world[$internal];
-  const snapshot = structuredClone(ctx.entityMasks);
-  ctx.trackingSnapshots.set(id, snapshot);
-  ctx.dirtyMasks.set(
-    id,
-    snapshot.map((mask) => mask.map(() => 0))
-  );
-  ctx.changedMasks.set(
-    id,
-    snapshot.map((mask) => mask.map(() => 0))
-  );
+function getTrait(world, entity, trait2) {
+  const worldCtx = world[$internal];
+  const data = worldCtx.traitData.get(trait2);
+  if (!data) return void 0;
+  const index = getEntityId(entity);
+  const mask = worldCtx.entityMasks[data.generationId][index];
+  if ((mask & data.bitflag) !== data.bitflag) return void 0;
+  const traitCtx = trait2[$internal];
+  const store = getStore(world, trait2);
+  return traitCtx.get(index, store);
 }
 
 // ../core/src/query/modifiers/changed.ts
@@ -465,7 +484,7 @@ function createChanged() {
 }
 function setChanged(world, entity, trait2) {
   const ctx = world[$internal];
-  if (!entity.has(trait2)) return;
+  if (!hasTrait(world, entity, trait2)) return;
   if (!ctx.traitData.has(trait2)) registerTrait(world, trait2);
   const data = ctx.traitData.get(trait2);
   for (const changedMask of ctx.changedMasks.values()) {
@@ -560,24 +579,12 @@ Number.prototype.changed = function(trait2) {
 Number.prototype.get = function(trait2) {
   const worldId = this >>> WORLD_ID_SHIFT;
   const world = universe.worlds[worldId];
-  const worldCtx = world[$internal];
-  const data = worldCtx.traitData.get(trait2);
-  if (!data) return void 0;
-  const index = this & ENTITY_ID_MASK;
-  const mask = worldCtx.entityMasks[data.generationId][index];
-  if ((mask & data.bitflag) !== data.bitflag) return void 0;
-  const traitCtx = trait2[$internal];
-  const store = traitCtx.stores[worldId];
-  return traitCtx.get(index, store);
+  return getTrait(world, this, trait2);
 };
 Number.prototype.set = function(trait2, value, triggerChanged = true) {
-  const ctx = trait2[$internal];
-  const index = this & ENTITY_ID_MASK;
   const worldId = this >>> WORLD_ID_SHIFT;
-  const store = ctx.stores[worldId];
-  value instanceof Function && (value = value(ctx.get(index, store)));
-  ctx.set(index, store, value);
-  triggerChanged && setChanged(universe.worlds[worldId], this, trait2);
+  const world = universe.worlds[worldId];
+  setTrait(world, this, trait2, value, triggerChanged);
 };
 Number.prototype.targetsFor = function(relation2) {
   const worldId = this >>> WORLD_ID_SHIFT;
@@ -593,6 +600,11 @@ Number.prototype.id = function() {
   const id = this & ENTITY_ID_MASK;
   return id;
 };
+Number.prototype.isAlive = function() {
+  const worldId = this >>> WORLD_ID_SHIFT;
+  const world = universe.worlds[worldId];
+  return isEntityAlive(world[$internal].entityIndex, this);
+};
 
 // ../core/src/entity/entity.ts
 function createEntity(world, ...traits) {
@@ -601,10 +613,10 @@ function createEntity(world, ...traits) {
   for (const query of ctx.notQueries) {
     const match = query.check(world, entity);
     if (match) query.add(entity);
-    query.resetTrackingBitmasks(entity.id());
+    query.resetTrackingBitmasks(getEntityId(entity));
   }
   ctx.entityTraits.set(entity, /* @__PURE__ */ new Set());
-  entity.add(...traits);
+  addTrait(world, entity, ...traits);
   return entity;
 }
 var cachedSet = /* @__PURE__ */ new Set();
@@ -645,6 +657,8 @@ function destroyEntity(world, entity) {
       }
     }
     releaseEntity(ctx.entityIndex, currentEntity);
+    const allQuery = ctx.queriesHashMap.get("");
+    if (allQuery) allQuery.remove(world, currentEntity);
     ctx.entityTraits.delete(entity);
     const eid = getEntityId(currentEntity);
     for (let i = 0; i < ctx.entityMasks.length; i++) {
@@ -990,6 +1004,7 @@ var Query = class {
     for (const sub of this.removeSubscriptions) {
       sub(entity);
     }
+    this.version++;
   }
   check(world, entity, event) {
     const { bitmasks, generations } = this;
@@ -1151,7 +1166,7 @@ function createQueryResult(query, world, params) {
         }
         for (let i = 0; i < changedPairs.length; i++) {
           const [entity, trait2] = changedPairs[i];
-          entity.changed(trait2);
+          setChanged(world, entity, trait2);
         }
       } else if (options.changeDetection === "always") {
         const changedPairs = [];
@@ -1186,7 +1201,7 @@ function createQueryResult(query, world, params) {
         }
         for (let i = 0; i < changedPairs.length; i++) {
           const [entity, trait2] = changedPairs[i];
-          entity.changed(trait2);
+          setChanged(world, entity, trait2);
         }
       } else if (options.changeDetection === "never") {
         for (let i = 0; i < entities.length; i++) {
@@ -1295,19 +1310,19 @@ var World = class {
     return createEntity(this, ...traits);
   }
   has(target) {
-    return typeof target === "number" ? isEntityAlive(this[$internal].entityIndex, target) : this[$internal].worldEntity.has(target);
+    return typeof target === "number" ? isEntityAlive(this[$internal].entityIndex, target) : hasTrait(this, this[$internal].worldEntity, target);
   }
   add(...traits) {
-    this[$internal].worldEntity.add(...traits);
+    addTrait(this, this[$internal].worldEntity, ...traits);
   }
   remove(...traits) {
-    this[$internal].worldEntity.remove(...traits);
+    removeTrait(this, this[$internal].worldEntity, ...traits);
   }
   get(trait2) {
-    return this[$internal].worldEntity.get(trait2);
+    return getTrait(this, this[$internal].worldEntity, trait2);
   }
   set(trait2, value) {
-    this[$internal].worldEntity.set(trait2, value);
+    setTrait(this, this[$internal].worldEntity, trait2, value);
   }
   destroy() {
     destroyEntity(this, this[$internal].worldEntity);
@@ -1399,12 +1414,12 @@ function createWorld(...traits) {
 
 export {
   $internal,
+  universe,
+  createChanged,
   relation,
   Pair,
   Wildcard,
   trait,
-  universe,
-  createChanged,
   createWorld,
   createAdded,
   createRemoved,