@latticexyz/recs 2.2.18-90aac1d4acce19ac592d47a090732dd11c1c3e7a → 2.2.18-9fa07c8489f1fbf167d0db01cd9aaa645a29c8e2

package/dist/index.js

@@ -1,2 +1,412 @@
-import{a as W,b as v,c as te,d as ne,e as g,f as V,g as re,h as oe,i as ie,j as S,k as pe,l as ae,m as ye,n as C,o as ue,p as E,q as s,r as l,s as me,t as h,u as de,v as O,w as b,x as se,y as le,z as ce}from"./chunk-2YR7WENB.js";import{concat as K,EMPTY as X,from as Z}from"rxjs";import{filterNullish as R}from"@latticexyz/utils";import{observable as B}from"mobx";import{concat as $,concatMap as q,filter as F,from as D,map as j,merge as L,of as z,share as Y}from"rxjs";var N=(o=>(o[o.Has=0]="Has",o[o.HasValue=1]="HasValue",o[o.Not=2]="Not",o[o.NotValue=3]="NotValue",o[o.ProxyRead=4]="ProxyRead",o[o.ProxyExpand=5]="ProxyExpand",o))(N||{});function xe(e){return[2,4,6,14,16,8,10,12].includes(e)}function Te(e){return[7,8,9,10,11,12,15,16].includes(e)}function ge(e){return[1,2].includes(e)}function Se(e){return[13,14].includes(e)}function Le(e){return{type:0,component:e}}function ze(e){return{type:2,component:e}}function Ye(e,t){return{type:1,component:e,value:t}}function Ge(e,t){return{type:3,component:e,value:t}}function Je(e,t){return{type:4,component:e,depth:t}}function Ke(e,t){return{type:5,component:e,depth:t}}function c(e,t){if(t.type===0)return s(t.component,e);if(t.type===1)return h(t.value,l(t.component,e));if(t.type===2)return!s(t.component,e);if(t.type===3)return!h(t.value,l(t.component,e));throw new Error("Unknown query fragment")}function G(e){return e.type===0||e.type==1}function P(e){return e.type===2||e.type==3}function J(e){return e.type===5||e.type==4}function U(e,t){return e&&G(t)||!e&&P(t)}function I(e,t,n){let r=e,a=!1;for(let y=0;y<n.depth;y++){let o=l(n.component,r);if(!o)return null;let p=o.value;if(!p)return null;if(r=p,a=c(r,t),U(a,t))return a}return a}function Q(e,t,n){if(n===0)return new Set;let r=O(t,{value:e});if(n===1)return r;let a=[...r].map(y=>[...Q(y,t,n-1)]).flat();return new Set([...r,...a])}function A(e,t){let n=t?new Set([...t]):void 0,r,a;for(let y=0;y<e.length;y++){let o=e[y];if(J(o))o.type===4&&(r=o),o.type===5&&(a=o);else if(n)for(let p of[...n]){let m=c(p,o);if(r&&r.depth>0&&!U(m,o)&&(m=I(p,o,r)??m),m||n.delete(p),a&&a.depth>0){let d=Q(p,a.component,a.depth);for(let i of d)(c(i,o)||r&&r.depth>0&&I(i,o,r))&&n.add(i)}}else{if(P(o))throw new Error("First EntityQueryFragment must be Has or HasValue");if(n=o.type===0?new Set([...b(o.component)]):O(o.component,o.value),a&&a.depth>0)for(let p of[...n])for(let m of Q(p,a.component,a.depth))n.add(m)}}return n??new Set}function f(e,t){let n=t?.runOnInit||t?.initialSet?A(e,t.initialSet):new Set,r=B(n),a=D(r).pipe(S(e[0].component)),y=e.findIndex(p=>[5,4].includes(p.type))!==-1,o=L(...e.map(p=>p.component.update$)).pipe(y?q(p=>{let m=A(e,t?.initialSet),d=[];for(let i of r)m.has(i)||(r.delete(i),d.push({entity:i,type:1,component:p.component,value:[void 0,void 0]}));for(let i of m)r.has(i)?d.push({entity:i,type:2,component:p.component,value:[l(p.component,i),void 0]}):(r.add(i),d.push({entity:i,type:0,component:p.component,value:[l(p.component,i),void 0]}));return z(...d)}):j(p=>{if(r.has(p.entity))return e.filter(u=>u.component.id===p.component.id).every(u=>c(p.entity,u))?{...p,type:2}:(r.delete(p.entity),{...p,type:1});if(e.every(d=>c(p.entity,d)))return r.add(p.entity),{...p,type:0}}),R());return{matching:r,update$:$(a,o).pipe(Y())}}function H(e,t){return f(e,t).update$.pipe(F(n=>n.type===2))}function w(e,t){return f(e,t).update$.pipe(F(n=>n.type===0))}function k(e,t){return f(e,t).update$.pipe(F(n=>n.type===1))}function x(e,t,n){let r=t.subscribe(n);e.registerDisposer(()=>r?.unsubscribe())}function ot(e,t,n,r={runOnInit:!0}){x(e,H(t,r),n)}function it(e,t,n,r={runOnInit:!0}){x(e,w(t,r),n)}function pt(e,t,n,r={runOnInit:!0}){x(e,k(t,r),n)}function _(e,t,n,r={runOnInit:!0}){x(e,f(t,r).update$,n)}function at(e,t,n,r={runOnInit:!0}){let a=r?.runOnInit?Z(b(t)).pipe(S(t)):X;x(e,K(a,t.update$),n)}function yt(e,t,n,r,a={update:!1,runOnInit:!0}){_(e,t,({entity:y,type:o})=>{o===0&&C(n(y),y,r(y)),o===1&&E(n(y),y),a?.update&&o===2&&C(n(y),y,r(y))},a)}import{transformIterator as ee}from"@latticexyz/utils";function lt(){let e=new Set,t=[],n=[];function r({id:i,idSuffix:u}={}){let T=i||e.size+(u?"-"+u:""),M=g(T);return e.add(M),T}function a(){return ee(e.values(),V)}function y(i){t.push(i)}function o(i){for(let[,u]of n.filter(T=>!i||T[0]===i))u();n=n.filter(u=>i&&u[0]!==i)}function p(i,u=""){n.push([u,i])}function m(i){let u=g(i);return e.has(u)}function d(i){for(let u of t)s(u,i)&&E(u,i);e.delete(g(i))}return{registerEntity:r,components:t,registerComponent:y,dispose:o,registerDisposer:p,hasEntity:m,getEntities:a,entitySymbols:e,deleteEntity:d}}function ct(e,t){return{...e,registerDisposer:n=>e.registerDisposer(n,t),dispose:()=>e.dispose(t)}}function ft(e,t){return e.components.filter(n=>s(n,t))}export{Le as Has,Ye as HasValue,ze as Not,Ge as NotValue,te as OptionalTypes,Ke as ProxyExpand,Je as ProxyRead,N as QueryFragmentType,W as Type,v as UpdateType,le as clearLocalCache,h as componentValueEquals,ne as createEntity,re as createIndexer,ce as createLocalCache,lt as createWorld,ye as defineComponent,at as defineComponentSystem,w as defineEnterQuery,it as defineEnterSystem,k as defineExitQuery,pt as defineExitSystem,f as defineQuery,x as defineRxSystem,yt as defineSyncSystem,_ as defineSystem,H as defineUpdateQuery,ot as defineUpdateSystem,Q as getChildEntities,b as getComponentEntities,l as getComponentValue,me as getComponentValueStrict,O as getEntitiesWithValue,ft as getEntityComponents,V as getEntityString,g as getEntitySymbol,s as hasComponent,Te as isArrayType,oe as isComponentUpdate,Se as isEntityType,ae as isFullComponentValue,pe as isIndexer,ge as isNumberType,xe as isOptionalType,ct as namespaceWorld,se as overridableComponent,E as removeComponent,A as runQuery,C as setComponent,ie as toUpdate,S as toUpdateStream,ue as updateComponent,de as withValue};
+import {
+  OptionalTypes,
+  Type,
+  UpdateType,
+  clearLocalCache,
+  componentValueEquals,
+  createEntity,
+  createIndexer,
+  createLocalCache,
+  defineComponent,
+  getComponentEntities,
+  getComponentValue,
+  getComponentValueStrict,
+  getEntitiesWithValue,
+  getEntityString,
+  getEntitySymbol,
+  hasComponent,
+  isComponentUpdate,
+  isFullComponentValue,
+  isIndexer,
+  overridableComponent,
+  removeComponent,
+  setComponent,
+  toUpdate,
+  toUpdateStream,
+  updateComponent,
+  withValue
+} from "./chunk-A6GOEGXN.js";
+
+// src/System.ts
+import { concat as concat2, EMPTY, from as from2 } from "rxjs";
+
+// src/Query.ts
+import { filterNullish } from "@latticexyz/utils";
+import { observable } from "mobx";
+import { concat, concatMap, filter, from, map, merge, of, share } from "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 = observable(initialSet);
+  const initial$ = from(matching).pipe(toUpdateStream(fragments[0].component));
+  const containsProxy = fragments.findIndex((v) => [5 /* ProxyExpand */, 4 /* ProxyRead */].includes(v.type)) !== -1;
+  const internal$ = merge(...fragments.map((f) => f.component.update$)).pipe(
+    containsProxy ? 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 of(...updates);
+    }) : (
+      // Query does not contain proxies
+      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 */ };
+        }
+      })
+    ),
+    filterNullish()
+  );
+  return {
+    matching,
+    update$: concat(initial$, internal$).pipe(share())
+  };
+}
+function defineUpdateQuery(fragments, options) {
+  return defineQuery(fragments, options).update$.pipe(filter((e) => e.type === 2 /* Update */));
+}
+function defineEnterQuery(fragments, options) {
+  return defineQuery(fragments, options).update$.pipe(filter((e) => e.type === 0 /* Enter */));
+}
+function defineExitQuery(fragments, options) {
+  return defineQuery(fragments, options).update$.pipe(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 ? from2(getComponentEntities(component)).pipe(toUpdateStream(component)) : EMPTY;
+  defineRxSystem(world, concat2(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
+import { transformIterator } from "@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 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));
+}
+export {
+  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.js.map