@latticexyz/recs 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2 → 2.2.18-c2ad22c7feb566e1731ff16e8be291746bdffb3e

package/dist/index.cjs

@@ -1,836 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames(from3))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  Has: () => Has,
-  HasValue: () => HasValue,
-  Not: () => Not,
-  NotValue: () => NotValue,
-  OptionalTypes: () => OptionalTypes,
-  ProxyExpand: () => ProxyExpand,
-  ProxyRead: () => ProxyRead,
-  QueryFragmentType: () => QueryFragmentType,
-  Type: () => Type,
-  UpdateType: () => UpdateType,
-  clearLocalCache: () => clearLocalCache,
-  componentValueEquals: () => componentValueEquals,
-  createEntity: () => createEntity,
-  createIndexer: () => createIndexer,
-  createLocalCache: () => createLocalCache,
-  createWorld: () => createWorld,
-  defineComponent: () => defineComponent,
-  defineComponentSystem: () => defineComponentSystem,
-  defineEnterQuery: () => defineEnterQuery,
-  defineEnterSystem: () => defineEnterSystem,
-  defineExitQuery: () => defineExitQuery,
-  defineExitSystem: () => defineExitSystem,
-  defineQuery: () => defineQuery,
-  defineRxSystem: () => defineRxSystem,
-  defineSyncSystem: () => defineSyncSystem,
-  defineSystem: () => defineSystem,
-  defineUpdateQuery: () => defineUpdateQuery,
-  defineUpdateSystem: () => defineUpdateSystem,
-  getChildEntities: () => getChildEntities,
-  getComponentEntities: () => getComponentEntities,
-  getComponentValue: () => getComponentValue,
-  getComponentValueStrict: () => getComponentValueStrict,
-  getEntitiesWithValue: () => getEntitiesWithValue,
-  getEntityComponents: () => getEntityComponents,
-  getEntityString: () => getEntityString,
-  getEntitySymbol: () => getEntitySymbol,
-  hasComponent: () => hasComponent,
-  isArrayType: () => isArrayType,
-  isComponentUpdate: () => isComponentUpdate,
-  isEntityType: () => isEntityType,
-  isFullComponentValue: () => isFullComponentValue,
-  isIndexer: () => isIndexer,
-  isNumberType: () => isNumberType,
-  isOptionalType: () => isOptionalType,
-  namespaceWorld: () => namespaceWorld,
-  overridableComponent: () => overridableComponent,
-  removeComponent: () => removeComponent,
-  runQuery: () => runQuery,
-  setComponent: () => setComponent,
-  toUpdate: () => toUpdate,
-  toUpdateStream: () => toUpdateStream,
-  updateComponent: () => updateComponent,
-  withValue: () => withValue
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/Component.ts
-var import_utils = require("@latticexyz/utils");
-var import_utils2 = require("@latticexyz/utils");
-var import_rxjs2 = require("rxjs");
-
-// src/constants.ts
-var Type = /* @__PURE__ */ ((Type3) => {
-  Type3[Type3["Boolean"] = 0] = "Boolean";
-  Type3[Type3["Number"] = 1] = "Number";
-  Type3[Type3["OptionalNumber"] = 2] = "OptionalNumber";
-  Type3[Type3["BigInt"] = 3] = "BigInt";
-  Type3[Type3["OptionalBigInt"] = 4] = "OptionalBigInt";
-  Type3[Type3["String"] = 5] = "String";
-  Type3[Type3["OptionalString"] = 6] = "OptionalString";
-  Type3[Type3["NumberArray"] = 7] = "NumberArray";
-  Type3[Type3["OptionalNumberArray"] = 8] = "OptionalNumberArray";
-  Type3[Type3["BigIntArray"] = 9] = "BigIntArray";
-  Type3[Type3["OptionalBigIntArray"] = 10] = "OptionalBigIntArray";
-  Type3[Type3["StringArray"] = 11] = "StringArray";
-  Type3[Type3["OptionalStringArray"] = 12] = "OptionalStringArray";
-  Type3[Type3["Entity"] = 13] = "Entity";
-  Type3[Type3["OptionalEntity"] = 14] = "OptionalEntity";
-  Type3[Type3["EntityArray"] = 15] = "EntityArray";
-  Type3[Type3["OptionalEntityArray"] = 16] = "OptionalEntityArray";
-  Type3[Type3["T"] = 17] = "T";
-  Type3[Type3["OptionalT"] = 18] = "OptionalT";
-  return Type3;
-})(Type || {});
-var UpdateType = /* @__PURE__ */ ((UpdateType2) => {
-  UpdateType2[UpdateType2["Enter"] = 0] = "Enter";
-  UpdateType2[UpdateType2["Exit"] = 1] = "Exit";
-  UpdateType2[UpdateType2["Update"] = 2] = "Update";
-  UpdateType2[UpdateType2["Noop"] = 3] = "Noop";
-  return UpdateType2;
-})(UpdateType || {});
-var OptionalTypes = [
-  14 /* OptionalEntity */,
-  16 /* OptionalEntityArray */,
-  2 /* OptionalNumber */,
-  8 /* OptionalNumberArray */,
-  4 /* OptionalBigInt */,
-  10 /* OptionalBigIntArray */,
-  6 /* OptionalString */,
-  12 /* OptionalStringArray */,
-  18 /* OptionalT */
-];
-
-// src/Entity.ts
-function createEntity(world, components, options) {
-  const entity = world.registerEntity(options ?? {});
-  if (components) {
-    for (const [component, value] of components) {
-      setComponent(component, entity, value);
-    }
-  }
-  return entity;
-}
-function getEntitySymbol(entityString) {
-  return Symbol.for(entityString);
-}
-function getEntityString(entity) {
-  return Symbol.keyFor(entity);
-}
-
-// src/Indexer.ts
-function createIndexer(component) {
-  const valueToEntities = /* @__PURE__ */ new Map();
-  function getEntitiesWithValue2(value) {
-    const entities = valueToEntities.get(getValueKey(value));
-    return entities ? new Set([...entities].map(getEntityString)) : /* @__PURE__ */ new Set();
-  }
-  function getValueKey(value) {
-    return Object.values(value).join("/");
-  }
-  function add(entity, value) {
-    if (!value) return;
-    const valueKey = getValueKey(value);
-    let entitiesWithValue = valueToEntities.get(valueKey);
-    if (!entitiesWithValue) {
-      entitiesWithValue = /* @__PURE__ */ new Set();
-      valueToEntities.set(valueKey, entitiesWithValue);
-    }
-    entitiesWithValue.add(entity);
-  }
-  function remove(entity, value) {
-    if (!value) return;
-    const valueKey = getValueKey(value);
-    const entitiesWithValue = valueToEntities.get(valueKey);
-    if (!entitiesWithValue) return;
-    entitiesWithValue.delete(entity);
-  }
-  for (const entity of getComponentEntities(component)) {
-    const value = getComponentValue(component, entity);
-    add(getEntitySymbol(entity), value);
-  }
-  const subscription = component.update$.subscribe(({ entity, value }) => {
-    remove(getEntitySymbol(entity), value[1]);
-    add(getEntitySymbol(entity), value[0]);
-  });
-  component.world.registerDisposer(() => subscription?.unsubscribe());
-  return { ...component, getEntitiesWithValue: getEntitiesWithValue2 };
-}
-
-// src/utils.ts
-var import_rxjs = require("rxjs");
-function isComponentUpdate(update, component) {
-  return update.component === component;
-}
-function toUpdate(entity, component) {
-  const value = getComponentValue(component, entity);
-  return {
-    entity,
-    component,
-    value: [value, void 0],
-    type: value == null ? 3 /* Noop */ : 0 /* Enter */
-  };
-}
-function toUpdateStream(component) {
-  return (0, import_rxjs.pipe)((0, import_rxjs.map)((entity) => toUpdate(entity, component)));
-}
-function isIndexer(c) {
-  return "getEntitiesWithValue" in c;
-}
-function isFullComponentValue(component, value) {
-  return Object.keys(component.schema).every((key) => key in value);
-}
-
-// src/Component.ts
-function getComponentName(component) {
-  return component.metadata?.componentName ?? component.metadata?.tableName ?? component.metadata?.tableId ?? component.metadata?.contractId ?? component.id;
-}
-function defineComponent(world, schema, options) {
-  if (Object.keys(schema).length === 0) throw new Error("Component schema must have at least one key");
-  const id = options?.id ?? (0, import_utils.uuid)();
-  const values = (0, import_utils2.mapObject)(schema, () => /* @__PURE__ */ new Map());
-  const update$ = new import_rxjs2.Subject();
-  const metadata = options?.metadata;
-  const entities = () => (0, import_utils.transformIterator)(Object.values(values)[0].keys(), getEntityString);
-  let component = { values, schema, id, update$, metadata, entities, world };
-  if (options?.indexed) component = createIndexer(component);
-  world.registerComponent(component);
-  return component;
-}
-function setComponent(component, entity, value, options = {}) {
-  const entitySymbol = getEntitySymbol(entity);
-  const prevValue = getComponentValue(component, entity);
-  for (const [key, val] of Object.entries(value)) {
-    if (component.values[key]) {
-      component.values[key].set(entitySymbol, val);
-    } else {
-      const isTableFieldIndex = component.metadata?.tableId && /^\d+$/.test(key);
-      if (!isTableFieldIndex) {
-        console.warn(
-          "Component definition for",
-          getComponentName(component),
-          "is missing key",
-          key,
-          ", ignoring value",
-          val,
-          "for entity",
-          entity,
-          ". Existing keys: ",
-          Object.keys(component.values)
-        );
-      }
-    }
-  }
-  if (!options.skipUpdateStream) {
-    component.update$.next({ entity, value: [value, prevValue], component });
-  }
-}
-function updateComponent(component, entity, value, initialValue, options = {}) {
-  const currentValue = getComponentValue(component, entity);
-  if (currentValue === void 0) {
-    if (initialValue === void 0) {
-      throw new Error(`Can't update component ${getComponentName(component)} without a current value or initial value`);
-    }
-    setComponent(component, entity, { ...initialValue, ...value }, options);
-  } else {
-    setComponent(component, entity, { ...currentValue, ...value }, options);
-  }
-}
-function removeComponent(component, entity, options = {}) {
-  const entitySymbol = getEntitySymbol(entity);
-  const prevValue = getComponentValue(component, entity);
-  for (const key of Object.keys(component.values)) {
-    component.values[key].delete(entitySymbol);
-  }
-  if (!options.skipUpdateStream) {
-    component.update$.next({ entity, value: [void 0, prevValue], component });
-  }
-}
-function hasComponent(component, entity) {
-  const entitySymbol = getEntitySymbol(entity);
-  const map4 = Object.values(component.values)[0];
-  return map4.has(entitySymbol);
-}
-function getComponentValue(component, entity) {
-  const value = {};
-  const entitySymbol = getEntitySymbol(entity);
-  const schemaKeys = Object.keys(component.schema);
-  for (const key of schemaKeys) {
-    const val = component.values[key].get(entitySymbol);
-    if (val === void 0 && !OptionalTypes.includes(component.schema[key])) return void 0;
-    value[key] = val;
-  }
-  return value;
-}
-function getComponentValueStrict(component, entity) {
-  const value = getComponentValue(component, entity);
-  if (!value) throw new Error(`No value for component ${getComponentName(component)} on entity ${entity}`);
-  return value;
-}
-function componentValueEquals(a, b) {
-  if (!a && !b) return true;
-  if (!a || !b) return false;
-  let equals = true;
-  for (const key of Object.keys(a)) {
-    equals = a[key] === b[key];
-    if (!equals) return false;
-  }
-  return equals;
-}
-function withValue(component, value) {
-  return [component, value];
-}
-function getEntitiesWithValue(component, value) {
-  if (isIndexer(component) && isFullComponentValue(component, value)) {
-    return component.getEntitiesWithValue(value);
-  }
-  const entities = /* @__PURE__ */ new Set();
-  for (const entity of getComponentEntities(component)) {
-    const val = getComponentValue(component, entity);
-    if (componentValueEquals(value, val)) {
-      entities.add(entity);
-    }
-  }
-  return entities;
-}
-function getComponentEntities(component) {
-  return component.entities();
-}
-function overridableComponent(component) {
-  let nonce = 0;
-  const overrides = /* @__PURE__ */ new Map();
-  const overriddenEntityValues = /* @__PURE__ */ new Map();
-  const update$ = new import_rxjs2.Subject();
-  function addOverride(id, update) {
-    overrides.set(id, { update, nonce: nonce++ });
-    setOverriddenComponentValue(update.entity, update.value);
-  }
-  function removeOverride(id) {
-    const affectedEntity = overrides.get(id)?.update.entity;
-    overrides.delete(id);
-    if (affectedEntity == null) return;
-    const relevantOverrides = [...overrides.values()].filter((o) => o.update.entity === affectedEntity).sort((a, b) => a.nonce < b.nonce ? -1 : 1);
-    if (relevantOverrides.length > 0) {
-      const lastOverride = relevantOverrides[relevantOverrides.length - 1];
-      setOverriddenComponentValue(affectedEntity, lastOverride.update.value);
-    } else {
-      setOverriddenComponentValue(affectedEntity, void 0);
-    }
-  }
-  function getOverriddenComponentValue(entity) {
-    const originalValue = getComponentValue(component, entity);
-    const entitySymbol = getEntitySymbol(entity);
-    const overriddenValue = overriddenEntityValues.get(entitySymbol);
-    return (originalValue || overriddenValue) && overriddenValue !== null ? { ...originalValue, ...overriddenValue } : void 0;
-  }
-  const valueProxyHandler = (key) => ({
-    get(target, prop) {
-      if (prop === "get") {
-        return (entity) => {
-          const originalValue = target.get(entity);
-          const overriddenValue = overriddenEntityValues.get(entity);
-          return overriddenValue && overriddenValue[key] != null ? overriddenValue[key] : originalValue;
-        };
-      }
-      if (prop === "has") {
-        return (entity) => {
-          return target.has(entity) || overriddenEntityValues.has(entity);
-        };
-      }
-      if (prop === "keys") {
-        return () => (/* @__PURE__ */ new Set([...target.keys(), ...overriddenEntityValues.keys()])).values();
-      }
-      return Reflect.get(target, prop, target);
-    }
-  });
-  const partialValues = {};
-  for (const key of Object.keys(component.values)) {
-    partialValues[key] = new Proxy(component.values[key], valueProxyHandler(key));
-  }
-  const valuesProxy = partialValues;
-  const overriddenComponent = new Proxy(component, {
-    get(target, prop) {
-      if (prop === "addOverride") return addOverride;
-      if (prop === "removeOverride") return removeOverride;
-      if (prop === "values") return valuesProxy;
-      if (prop === "update$") return update$;
-      if (prop === "entities")
-        return () => (/* @__PURE__ */ new Set([
-          ...(0, import_utils.transformIterator)(overriddenEntityValues.keys(), getEntityString),
-          ...target.entities()
-        ])).values();
-      return Reflect.get(target, prop);
-    },
-    has(target, prop) {
-      if (prop === "addOverride" || prop === "removeOverride") return true;
-      return prop in target;
-    }
-  });
-  function setOverriddenComponentValue(entity, value) {
-    const entitySymbol = getEntitySymbol(entity);
-    const prevValue = getOverriddenComponentValue(entity);
-    if (value !== void 0) overriddenEntityValues.set(entitySymbol, value);
-    else overriddenEntityValues.delete(entitySymbol);
-    update$.next({ entity, value: [getOverriddenComponentValue(entity), prevValue], component: overriddenComponent });
-  }
-  component.update$.pipe(
-    (0, import_rxjs2.filter)((e) => !overriddenEntityValues.get(getEntitySymbol(e.entity))),
-    (0, import_rxjs2.map)((update) => ({ ...update, component: overriddenComponent }))
-  ).subscribe(update$);
-  return overriddenComponent;
-}
-function getLocalCacheId(component, uniqueWorldIdentifier) {
-  return `localcache-${uniqueWorldIdentifier}-${component.id}`;
-}
-function clearLocalCache(component, uniqueWorldIdentifier) {
-  localStorage.removeItem(getLocalCacheId(component, uniqueWorldIdentifier));
-}
-function createLocalCache(component, uniqueWorldIdentifier) {
-  const { world, update$, values } = component;
-  const cacheId = getLocalCacheId(component, uniqueWorldIdentifier);
-  let numUpdates = 0;
-  const creation = Date.now();
-  const encodedCache = localStorage.getItem(cacheId);
-  if (encodedCache) {
-    const cache = JSON.parse(encodedCache);
-    const state = {};
-    for (const [key, values2] of cache) {
-      for (const [entity, value] of values2) {
-        state[entity] = state[entity] || {};
-        state[entity][key] = value;
-      }
-    }
-    for (const [entityId, value] of Object.entries(state)) {
-      const entity = world.registerEntity({ id: entityId });
-      setComponent(component, entity, value);
-    }
-    console.info("Loading component", getComponentName(component), "from local cache.");
-  }
-  const updateSub = update$.subscribe(() => {
-    numUpdates++;
-    const encoded = JSON.stringify(
-      Object.entries((0, import_utils2.mapObject)(values, (m) => [...m.entries()].map((e) => [getEntityString(e[0]), e[1]])))
-    );
-    localStorage.setItem(cacheId, encoded);
-    if (numUpdates > 200) {
-      console.warn(
-        "Component",
-        getComponentName(component),
-        "was locally cached",
-        numUpdates,
-        "times since",
-        new Date(creation).toLocaleTimeString(),
-        "- the local cache is in an alpha state and should not be used with components that update frequently yet"
-      );
-    }
-  });
-  component.world.registerDisposer(() => updateSub?.unsubscribe());
-  return component;
-}
-
-// src/System.ts
-var import_rxjs4 = require("rxjs");
-
-// src/Query.ts
-var import_utils4 = require("@latticexyz/utils");
-var import_mobx = require("mobx");
-var import_rxjs3 = require("rxjs");
-
-// src/types.ts
-var QueryFragmentType = /* @__PURE__ */ ((QueryFragmentType2) => {
-  QueryFragmentType2[QueryFragmentType2["Has"] = 0] = "Has";
-  QueryFragmentType2[QueryFragmentType2["HasValue"] = 1] = "HasValue";
-  QueryFragmentType2[QueryFragmentType2["Not"] = 2] = "Not";
-  QueryFragmentType2[QueryFragmentType2["NotValue"] = 3] = "NotValue";
-  QueryFragmentType2[QueryFragmentType2["ProxyRead"] = 4] = "ProxyRead";
-  QueryFragmentType2[QueryFragmentType2["ProxyExpand"] = 5] = "ProxyExpand";
-  return QueryFragmentType2;
-})(QueryFragmentType || {});
-function isOptionalType(t) {
-  return [
-    2 /* OptionalNumber */,
-    4 /* OptionalBigInt */,
-    6 /* OptionalString */,
-    14 /* OptionalEntity */,
-    16 /* OptionalEntityArray */,
-    8 /* OptionalNumberArray */,
-    10 /* OptionalBigIntArray */,
-    12 /* OptionalStringArray */
-  ].includes(t);
-}
-function isArrayType(t) {
-  return [
-    7 /* NumberArray */,
-    8 /* OptionalNumberArray */,
-    9 /* BigIntArray */,
-    10 /* OptionalBigIntArray */,
-    11 /* StringArray */,
-    12 /* OptionalStringArray */,
-    15 /* EntityArray */,
-    16 /* OptionalEntityArray */
-  ].includes(t);
-}
-function isNumberType(t) {
-  return [1 /* Number */, 2 /* OptionalNumber */].includes(t);
-}
-function isEntityType(t) {
-  return [13 /* Entity */, 14 /* OptionalEntity */].includes(t);
-}
-
-// src/Query.ts
-function Has(component) {
-  return { type: 0 /* Has */, component };
-}
-function Not(component) {
-  return { type: 2 /* Not */, component };
-}
-function HasValue(component, value) {
-  return { type: 1 /* HasValue */, component, value };
-}
-function NotValue(component, value) {
-  return { type: 3 /* NotValue */, component, value };
-}
-function ProxyRead(component, depth) {
-  return { type: 4 /* ProxyRead */, component, depth };
-}
-function ProxyExpand(component, depth) {
-  return { type: 5 /* ProxyExpand */, component, depth };
-}
-function passesQueryFragment(entity, fragment) {
-  if (fragment.type === 0 /* Has */) {
-    return hasComponent(fragment.component, entity);
-  }
-  if (fragment.type === 1 /* HasValue */) {
-    return componentValueEquals(fragment.value, getComponentValue(fragment.component, entity));
-  }
-  if (fragment.type === 2 /* Not */) {
-    return !hasComponent(fragment.component, entity);
-  }
-  if (fragment.type === 3 /* NotValue */) {
-    return !componentValueEquals(fragment.value, getComponentValue(fragment.component, entity));
-  }
-  throw new Error("Unknown query fragment");
-}
-function isPositiveFragment(fragment) {
-  return fragment.type === 0 /* Has */ || fragment.type == 1 /* HasValue */;
-}
-function isNegativeFragment(fragment) {
-  return fragment.type === 2 /* Not */ || fragment.type == 3 /* NotValue */;
-}
-function isSettingFragment(fragment) {
-  return fragment.type === 5 /* ProxyExpand */ || fragment.type == 4 /* ProxyRead */;
-}
-function isBreakingPassState(passes, fragment) {
-  return passes && isPositiveFragment(fragment) || !passes && isNegativeFragment(fragment);
-}
-function passesQueryFragmentProxy(entity, fragment, proxyRead) {
-  let proxyEntity = entity;
-  let passes = false;
-  for (let i = 0; i < proxyRead.depth; i++) {
-    const value = getComponentValue(proxyRead.component, proxyEntity);
-    if (!value) return null;
-    const entity2 = value.value;
-    if (!entity2) return null;
-    proxyEntity = entity2;
-    passes = passesQueryFragment(proxyEntity, fragment);
-    if (isBreakingPassState(passes, fragment)) {
-      return passes;
-    }
-  }
-  return passes;
-}
-function getChildEntities(entity, component, depth) {
-  if (depth === 0) return /* @__PURE__ */ new Set();
-  const directChildEntities = getEntitiesWithValue(component, { value: entity });
-  if (depth === 1) return directChildEntities;
-  const indirectChildEntities = [...directChildEntities].map((childEntity) => [...getChildEntities(childEntity, component, depth - 1)]).flat();
-  return /* @__PURE__ */ new Set([...directChildEntities, ...indirectChildEntities]);
-}
-function runQuery(fragments, initialSet) {
-  let entities = initialSet ? /* @__PURE__ */ new Set([...initialSet]) : void 0;
-  let proxyRead = void 0;
-  let proxyExpand = void 0;
-  for (let i = 0; i < fragments.length; i++) {
-    const fragment = fragments[i];
-    if (isSettingFragment(fragment)) {
-      if (fragment.type === 4 /* ProxyRead */) proxyRead = fragment;
-      if (fragment.type === 5 /* ProxyExpand */) proxyExpand = fragment;
-    } else if (!entities) {
-      if (isNegativeFragment(fragment)) {
-        throw new Error("First EntityQueryFragment must be Has or HasValue");
-      }
-      entities = fragment.type === 0 /* Has */ ? /* @__PURE__ */ new Set([...getComponentEntities(fragment.component)]) : getEntitiesWithValue(fragment.component, fragment.value);
-      if (proxyExpand && proxyExpand.depth > 0) {
-        for (const entity of [...entities]) {
-          for (const childEntity of getChildEntities(entity, proxyExpand.component, proxyExpand.depth)) {
-            entities.add(childEntity);
-          }
-        }
-      }
-    } else {
-      for (const entity of [...entities]) {
-        let passes = passesQueryFragment(entity, fragment);
-        if (proxyRead && proxyRead.depth > 0 && !isBreakingPassState(passes, fragment)) {
-          passes = passesQueryFragmentProxy(entity, fragment, proxyRead) ?? passes;
-        }
-        if (!passes) entities.delete(entity);
-        if (proxyExpand && proxyExpand.depth > 0) {
-          const childEntities = getChildEntities(entity, proxyExpand.component, proxyExpand.depth);
-          for (const childEntity of childEntities) {
-            if (passesQueryFragment(childEntity, fragment) || proxyRead && proxyRead.depth > 0 && passesQueryFragmentProxy(childEntity, fragment, proxyRead))
-              entities.add(childEntity);
-          }
-        }
-      }
-    }
-  }
-  return entities ?? /* @__PURE__ */ new Set();
-}
-function defineQuery(fragments, options) {
-  const initialSet = options?.runOnInit || options?.initialSet ? runQuery(fragments, options.initialSet) : /* @__PURE__ */ new Set();
-  const matching = (0, import_mobx.observable)(initialSet);
-  const initial$ = (0, import_rxjs3.from)(matching).pipe(toUpdateStream(fragments[0].component));
-  const containsProxy = fragments.findIndex((v) => [5 /* ProxyExpand */, 4 /* ProxyRead */].includes(v.type)) !== -1;
-  const internal$ = (0, import_rxjs3.merge)(...fragments.map((f) => f.component.update$)).pipe(
-    containsProxy ? (0, import_rxjs3.concatMap)((update) => {
-      const newMatchingSet = runQuery(fragments, options?.initialSet);
-      const updates = [];
-      for (const previouslyMatchingEntity of matching) {
-        if (!newMatchingSet.has(previouslyMatchingEntity)) {
-          matching.delete(previouslyMatchingEntity);
-          updates.push({
-            entity: previouslyMatchingEntity,
-            type: 1 /* Exit */,
-            component: update.component,
-            value: [void 0, void 0]
-          });
-        }
-      }
-      for (const matchingEntity of newMatchingSet) {
-        if (matching.has(matchingEntity)) {
-          updates.push({
-            entity: matchingEntity,
-            type: 2 /* Update */,
-            component: update.component,
-            value: [getComponentValue(update.component, matchingEntity), void 0]
-          });
-        } else {
-          matching.add(matchingEntity);
-          updates.push({
-            entity: matchingEntity,
-            type: 0 /* Enter */,
-            component: update.component,
-            value: [getComponentValue(update.component, matchingEntity), void 0]
-          });
-        }
-      }
-      return (0, import_rxjs3.of)(...updates);
-    }) : (
-      // Query does not contain proxies
-      (0, import_rxjs3.map)((update) => {
-        if (matching.has(update.entity)) {
-          const relevantFragments = fragments.filter((f) => f.component.id === update.component.id);
-          const pass2 = relevantFragments.every((f) => passesQueryFragment(update.entity, f));
-          if (pass2) {
-            return { ...update, type: 2 /* Update */ };
-          } else {
-            matching.delete(update.entity);
-            return { ...update, type: 1 /* Exit */ };
-          }
-        }
-        const pass = fragments.every((f) => passesQueryFragment(update.entity, f));
-        if (pass) {
-          matching.add(update.entity);
-          return { ...update, type: 0 /* Enter */ };
-        }
-      })
-    ),
-    (0, import_utils4.filterNullish)()
-  );
-  return {
-    matching,
-    update$: (0, import_rxjs3.concat)(initial$, internal$).pipe((0, import_rxjs3.share)())
-  };
-}
-function defineUpdateQuery(fragments, options) {
-  return defineQuery(fragments, options).update$.pipe((0, import_rxjs3.filter)((e) => e.type === 2 /* Update */));
-}
-function defineEnterQuery(fragments, options) {
-  return defineQuery(fragments, options).update$.pipe((0, import_rxjs3.filter)((e) => e.type === 0 /* Enter */));
-}
-function defineExitQuery(fragments, options) {
-  return defineQuery(fragments, options).update$.pipe((0, import_rxjs3.filter)((e) => e.type === 1 /* Exit */));
-}
-
-// src/System.ts
-function defineRxSystem(world, observable$, system) {
-  const subscription = observable$.subscribe(system);
-  world.registerDisposer(() => subscription?.unsubscribe());
-}
-function defineUpdateSystem(world, query, system, options = { runOnInit: true }) {
-  defineRxSystem(world, defineUpdateQuery(query, options), system);
-}
-function defineEnterSystem(world, query, system, options = { runOnInit: true }) {
-  defineRxSystem(world, defineEnterQuery(query, options), system);
-}
-function defineExitSystem(world, query, system, options = { runOnInit: true }) {
-  defineRxSystem(world, defineExitQuery(query, options), system);
-}
-function defineSystem(world, query, system, options = { runOnInit: true }) {
-  defineRxSystem(world, defineQuery(query, options).update$, system);
-}
-function defineComponentSystem(world, component, system, options = { runOnInit: true }) {
-  const initial$ = options?.runOnInit ? (0, import_rxjs4.from)(getComponentEntities(component)).pipe(toUpdateStream(component)) : import_rxjs4.EMPTY;
-  defineRxSystem(world, (0, import_rxjs4.concat)(initial$, component.update$), system);
-}
-function defineSyncSystem(world, query, component, value, options = { update: false, runOnInit: true }) {
-  defineSystem(
-    world,
-    query,
-    ({ entity, type }) => {
-      if (type === 0 /* Enter */) setComponent(component(entity), entity, value(entity));
-      if (type === 1 /* Exit */) removeComponent(component(entity), entity);
-      if (options?.update && type === 2 /* Update */) setComponent(component(entity), entity, value(entity));
-    },
-    options
-  );
-}
-
-// src/World.ts
-var import_utils7 = require("@latticexyz/utils");
-function createWorld() {
-  const entitySymbols = /* @__PURE__ */ new Set();
-  const components = [];
-  let disposers = [];
-  function registerEntity({ id, idSuffix } = {}) {
-    const entity = id || entitySymbols.size + (idSuffix ? "-" + idSuffix : "");
-    const entitySymbol = getEntitySymbol(entity);
-    entitySymbols.add(entitySymbol);
-    return entity;
-  }
-  function getEntities() {
-    return (0, import_utils7.transformIterator)(entitySymbols.values(), getEntityString);
-  }
-  function registerComponent(component) {
-    components.push(component);
-  }
-  function dispose(namespace) {
-    for (const [, disposer] of disposers.filter((d) => !namespace || d[0] === namespace)) {
-      disposer();
-    }
-    disposers = disposers.filter((d) => namespace && d[0] !== namespace);
-  }
-  function registerDisposer(disposer, namespace = "") {
-    disposers.push([namespace, disposer]);
-  }
-  function hasEntity(entity) {
-    const entitySymbol = getEntitySymbol(entity);
-    return entitySymbols.has(entitySymbol);
-  }
-  function deleteEntity(entity) {
-    for (const component of components) {
-      if (hasComponent(component, entity)) removeComponent(component, entity);
-    }
-    entitySymbols.delete(getEntitySymbol(entity));
-  }
-  return {
-    registerEntity,
-    components,
-    registerComponent,
-    dispose,
-    registerDisposer,
-    hasEntity,
-    getEntities,
-    entitySymbols,
-    deleteEntity
-  };
-}
-function namespaceWorld(world, namespace) {
-  return {
-    ...world,
-    registerDisposer: (disposer) => world.registerDisposer(disposer, namespace),
-    dispose: () => world.dispose(namespace)
-  };
-}
-function getEntityComponents(world, entity) {
-  return world.components.filter((component) => hasComponent(component, entity));
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Has,
-  HasValue,
-  Not,
-  NotValue,
-  OptionalTypes,
-  ProxyExpand,
-  ProxyRead,
-  QueryFragmentType,
-  Type,
-  UpdateType,
-  clearLocalCache,
-  componentValueEquals,
-  createEntity,
-  createIndexer,
-  createLocalCache,
-  createWorld,
-  defineComponent,
-  defineComponentSystem,
-  defineEnterQuery,
-  defineEnterSystem,
-  defineExitQuery,
-  defineExitSystem,
-  defineQuery,
-  defineRxSystem,
-  defineSyncSystem,
-  defineSystem,
-  defineUpdateQuery,
-  defineUpdateSystem,
-  getChildEntities,
-  getComponentEntities,
-  getComponentValue,
-  getComponentValueStrict,
-  getEntitiesWithValue,
-  getEntityComponents,
-  getEntityString,
-  getEntitySymbol,
-  hasComponent,
-  isArrayType,
-  isComponentUpdate,
-  isEntityType,
-  isFullComponentValue,
-  isIndexer,
-  isNumberType,
-  isOptionalType,
-  namespaceWorld,
-  overridableComponent,
-  removeComponent,
-  runQuery,
-  setComponent,
-  toUpdate,
-  toUpdateStream,
-  updateComponent,
-  withValue
-});
-//# sourceMappingURL=index.cjs.map