@rocicorp/zero 0.11.2025011402 → 0.11.2025011801

package/out/react.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../zero-react/src/use-query.tsx", "../../shared/src/deep-clone.ts", "../../zero-react/src/use-zero.tsx"],
-  "sourcesContent": ["import {useSyncExternalStore} from 'react';\nimport {deepClone} from '../../shared/src/deep-clone.js';\nimport type {Immutable} from '../../shared/src/immutable.js';\nimport type {\n  Query,\n  QueryType,\n  ReadonlyJSONValue,\n  Smash,\n  TypedView,\n} from '../../zero-client/src/mod.js';\nimport type {TableSchema} from '../../zero-schema/src/table-schema.js';\nimport type {AdvancedQuery} from '../../zql/src/query/query-internal.js';\nimport type {ResultType} from '../../zql/src/query/typed-view.js';\nimport {useZero} from './use-zero.js';\n\nexport type QueryResultDetails = Readonly<{\n  type: ResultType;\n}>;\n\nexport type QueryResult<TReturn extends QueryType> = readonly [\n  Smash<TReturn>,\n  QueryResultDetails,\n];\n\nexport function useQuery<\n  TSchema extends TableSchema,\n  TReturn extends QueryType,\n>(q: Query<TSchema, TReturn>, enable: boolean = true): QueryResult<TReturn> {\n  const z = useZero();\n  const view = viewStore.getView(\n    z.clientID,\n    q as AdvancedQuery<TSchema, TReturn>,\n    enable && z.server !== null,\n  );\n  // https://react.dev/reference/react/useSyncExternalStore\n  return useSyncExternalStore(\n    view.subscribeReactInternals,\n    view.getSnapshot,\n    view.getSnapshot,\n  );\n}\n\nconst emptyArray: unknown[] = [];\nconst disabledSubscriber = () => () => {};\n\nconst defaultSnapshots = {\n  singular: [undefined, {type: 'unknown'}] as const,\n  plural: [emptyArray, {type: 'unknown'}] as const,\n};\n\nfunction getDefaultSnapshot<TReturn extends QueryType>(\n  singular: boolean,\n): QueryResult<TReturn> {\n  return (\n    singular ? defaultSnapshots.singular : defaultSnapshots.plural\n  ) as QueryResult<TReturn>;\n}\n\n/**\n * A global store of all active views.\n *\n * React subscribes and unsubscribes to these views\n * via `useSyncExternalStore`.\n *\n * Managing views through `useEffect` or `useLayoutEffect` causes\n * inconsistencies because effects run after render.\n *\n * For example, if useQuery used use*Effect in the component below:\n * ```ts\n * function Foo({issueID}) {\n *   const issue = useQuery(z.query.issue.where('id', issueID).one());\n *   if (issue?.id !== undefined && issue.id !== issueID) {\n *     console.log('MISMATCH!', issue.id, issueID);\n *   }\n * }\n * ```\n *\n * `MISMATCH` will be printed whenever the `issueID` prop changes.\n *\n * This is because the component will render once with\n * the old state returned from `useQuery`. Then the effect inside\n * `useQuery` will run. The component will render again with the new\n * state. This inconsistent transition can cause unexpected results.\n *\n * Emulating `useEffect` via `useState` and `if` causes resource leaks.\n * That is:\n *\n * ```ts\n * function useQuery(q) {\n *   const [oldHash, setOldHash] = useState();\n *   if (hash(q) !== oldHash) {\n *      // make new view\n *   }\n *\n *   useEffect(() => {\n *     return () => view.destroy();\n *   }, []);\n * }\n * ```\n *\n * I'm not sure why but in strict mode the cleanup function\n * fails to be called for the first instance of the view and only\n * cleans up later instances.\n *\n * Swapping `useState` to `useRef` has similar problems.\n */\nclass ViewStore {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  #views = new Map<string, ViewWrapper<any, any>>();\n\n  getView<TSchema extends TableSchema, TReturn extends QueryType>(\n    clientID: string,\n    query: AdvancedQuery<TSchema, TReturn>,\n    enabled: boolean,\n  ): {\n    getSnapshot: () => QueryResult<TReturn>;\n    subscribeReactInternals: (internals: () => void) => () => void;\n  } {\n    if (!enabled) {\n      return {\n        getSnapshot: () => getDefaultSnapshot(query.format.singular),\n        subscribeReactInternals: disabledSubscriber,\n      };\n    }\n\n    const hash = query.hash() + clientID;\n    let existing = this.#views.get(hash);\n    if (!existing) {\n      existing = new ViewWrapper(\n        query,\n        view => {\n          const lastView = this.#views.get(hash);\n          // I don't think this can happen\n          // but lets guard against it so we don't\n          // leak resources.\n          if (lastView && lastView !== view) {\n            throw new Error('View already exists');\n          }\n          this.#views.set(hash, view);\n        },\n        () => {\n          this.#views.delete(hash);\n        },\n      ) as ViewWrapper<TSchema, TReturn>;\n      this.#views.set(hash, existing);\n    }\n    return existing as ViewWrapper<TSchema, TReturn>;\n  }\n}\n\nconst viewStore = new ViewStore();\n\n/**\n * This wraps and ref counts a view.\n *\n * The only signal we have from React as to whether or not it is\n * done with a view is when it calls `unsubscribe`.\n *\n * In non-strict-mode we can clean up the view as soon\n * as the listener count goes to 0.\n *\n * In strict-mode, the listener cound will go to 0 then a\n * new listener for the same view is immeidatiely added back.\n *\n * This is why the `onMaterialized` and `onDematerialized` callbacks exist --\n * they allow a view which React is still referencing to be added\n * back into the store when React re-subscribes to it.\n *\n * This wrapper also exists to deal with the various\n * `useSyncExternalStore` caveats that cause excessive\n * re-renders and materializations.\n *\n * See: https://react.dev/reference/react/useSyncExternalStore#caveats\n * Especially:\n * 1. The store snapshot returned by getSnapshot must be immutable. If the underlying store has mutable data, return a new immutable snapshot if the data has changed. Otherwise, return a cached last snapshot.\n * 2. If a different subscribe function is passed during a re-render, React will re-subscribe to the store using the newly passed subscribe function. You can prevent this by declaring subscribe outside the component.\n */\nclass ViewWrapper<TSchema extends TableSchema, TReturn extends QueryType> {\n  #view: TypedView<Smash<TReturn>> | undefined;\n  readonly #onDematerialized;\n  readonly #onMaterialized;\n  readonly #query: AdvancedQuery<TSchema, TReturn>;\n  #snapshot: QueryResult<TReturn>;\n  #reactInternals: Set<() => void>;\n\n  constructor(\n    query: AdvancedQuery<TSchema, TReturn>,\n    onMaterialized: (view: ViewWrapper<TSchema, TReturn>) => void,\n    onDematerialized: () => void,\n  ) {\n    this.#snapshot = getDefaultSnapshot(query.format.singular);\n    this.#onMaterialized = onMaterialized;\n    this.#onDematerialized = onDematerialized;\n    this.#reactInternals = new Set();\n    this.#query = query;\n  }\n\n  #onData = (snap: Immutable<Smash<TReturn>>, resultType: ResultType) => {\n    const data =\n      snap === undefined\n        ? snap\n        : (deepClone(snap as ReadonlyJSONValue) as Smash<TReturn>);\n    this.#snapshot = [data, {type: resultType}] as QueryResult<TReturn>;\n    for (const internals of this.#reactInternals) {\n      internals();\n    }\n  };\n\n  #materializeIfNeeded = () => {\n    if (this.#view) {\n      return;\n    }\n\n    this.#view = this.#query.materialize();\n    this.#view.addListener(this.#onData);\n\n    this.#onMaterialized(this);\n  };\n\n  getSnapshot = () => this.#snapshot;\n\n  subscribeReactInternals = (internals: () => void): (() => void) => {\n    this.#reactInternals.add(internals);\n    this.#materializeIfNeeded();\n    return () => {\n      this.#reactInternals.delete(internals);\n      if (this.#reactInternals.size === 0) {\n        this.#view?.destroy();\n        this.#view = undefined;\n        this.#onDematerialized();\n      }\n    };\n  };\n}\n", "import {hasOwn} from './has-own.js';\nimport type {JSONValue, ReadonlyJSONValue} from './json.js';\n\nexport function deepClone(value: ReadonlyJSONValue): JSONValue {\n  const seen: Array<ReadonlyJSONValue> = [];\n  return internalDeepClone(value, seen);\n}\n\nexport function internalDeepClone(\n  value: ReadonlyJSONValue,\n  seen: Array<ReadonlyJSONValue>,\n): JSONValue {\n  switch (typeof value) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n    case 'undefined':\n      return value;\n    case 'object': {\n      if (value === null) {\n        return null;\n      }\n      if (seen.includes(value)) {\n        throw new Error('Cyclic object');\n      }\n      seen.push(value);\n      if (Array.isArray(value)) {\n        const rv = value.map(v => internalDeepClone(v, seen));\n        seen.pop();\n        return rv;\n      }\n\n      const obj: JSONValue = {};\n\n      for (const k in value) {\n        if (hasOwn(value, k)) {\n          const v = (value as Record<string, ReadonlyJSONValue>)[k];\n          if (v !== undefined) {\n            obj[k] = internalDeepClone(v, seen);\n          }\n        }\n      }\n      seen.pop();\n      return obj;\n    }\n\n    default:\n      throw new Error(`Invalid type: ${typeof value}`);\n  }\n}\n", "import {createContext, useContext} from 'react';\nimport type {Zero} from '../../zero-client/src/mod.js';\nimport type {Schema} from '../../zero-schema/src/mod.js';\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst ZeroContext = createContext<unknown | undefined>(undefined);\n\nexport function useZero<S extends Schema>(): Zero<S> {\n  const zero = useContext(ZeroContext);\n  if (zero === undefined) {\n    throw new Error('useZero must be used within a ZeroProvider');\n  }\n  return zero as Zero<S>;\n}\n\nexport function createUseZero<S extends Schema>() {\n  return () => useZero<S>();\n}\n\nexport function ZeroProvider<S extends Schema>({\n  children,\n  zero,\n}: {\n  children: React.ReactNode;\n  zero: Zero<S>;\n}) {\n  return <ZeroContext.Provider value={zero}>{children}</ZeroContext.Provider>;\n}\n"],
-  "mappings": ";;;;;;AAAA,SAAQ,4BAA2B;;;ACG5B,SAAS,UAAU,OAAqC;AAC7D,QAAM,OAAiC,CAAC;AACxC,SAAO,kBAAkB,OAAO,IAAI;AACtC;AAEO,SAAS,kBACd,OACA,MACW;AACX,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT,KAAK,UAAU;AACb,UAAI,UAAU,MAAM;AAClB,eAAO;AAAA,MACT;AACA,UAAI,KAAK,SAAS,KAAK,GAAG;AACxB,cAAM,IAAI,MAAM,eAAe;AAAA,MACjC;AACA,WAAK,KAAK,KAAK;AACf,UAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,cAAM,KAAK,MAAM,IAAI,OAAK,kBAAkB,GAAG,IAAI,CAAC;AACpD,aAAK,IAAI;AACT,eAAO;AAAA,MACT;AAEA,YAAM,MAAiB,CAAC;AAExB,iBAAW,KAAK,OAAO;AACrB,YAAI,OAAO,OAAO,CAAC,GAAG;AACpB,gBAAM,IAAK,MAA4C,CAAC;AACxD,cAAI,MAAM,QAAW;AACnB,gBAAI,CAAC,IAAI,kBAAkB,GAAG,IAAI;AAAA,UACpC;AAAA,QACF;AAAA,MACF;AACA,WAAK,IAAI;AACT,aAAO;AAAA,IACT;AAAA,IAEA;AACE,YAAM,IAAI,MAAM,iBAAiB,OAAO,KAAK,EAAE;AAAA,EACnD;AACF;;;ACjDA,SAAQ,eAAe,kBAAiB;AA0B/B;AArBT,IAAM,cAAc,cAAmC,MAAS;AAEzD,SAAS,UAAqC;AACnD,QAAM,OAAO,WAAW,WAAW;AACnC,MAAI,SAAS,QAAW;AACtB,UAAM,IAAI,MAAM,4CAA4C;AAAA,EAC9D;AACA,SAAO;AACT;AAEO,SAAS,gBAAkC;AAChD,SAAO,MAAM,QAAW;AAC1B;AAEO,SAAS,aAA+B;AAAA,EAC7C;AAAA,EACA;AACF,GAGG;AACD,SAAO,oBAAC,YAAY,UAAZ,EAAqB,OAAO,MAAO,UAAS;AACtD;;;AFHO,SAAS,SAGd,GAA4B,SAAkB,MAA4B;AAC1E,QAAM,IAAI,QAAQ;AAClB,QAAM,OAAO,UAAU;AAAA,IACrB,EAAE;AAAA,IACF;AAAA,IACA,UAAU,EAAE,WAAW;AAAA,EACzB;AAEA,SAAO;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,EACP;AACF;AAEA,IAAM,aAAwB,CAAC;AAC/B,IAAM,qBAAqB,MAAM,MAAM;AAAC;AAExC,IAAM,mBAAmB;AAAA,EACvB,UAAU,CAAC,QAAW,EAAC,MAAM,UAAS,CAAC;AAAA,EACvC,QAAQ,CAAC,YAAY,EAAC,MAAM,UAAS,CAAC;AACxC;AAEA,SAAS,mBACP,UACsB;AACtB,SACE,WAAW,iBAAiB,WAAW,iBAAiB;AAE5D;AAkDA,IAAM,YAAN,MAAgB;AAAA;AAAA,EAEd,SAAS,oBAAI,IAAmC;AAAA,EAEhD,QACE,UACA,OACA,SAIA;AACA,QAAI,CAAC,SAAS;AACZ,aAAO;AAAA,QACL,aAAa,MAAM,mBAAmB,MAAM,OAAO,QAAQ;AAAA,QAC3D,yBAAyB;AAAA,MAC3B;AAAA,IACF;AAEA,UAAM,OAAO,MAAM,KAAK,IAAI;AAC5B,QAAI,WAAW,KAAK,OAAO,IAAI,IAAI;AACnC,QAAI,CAAC,UAAU;AACb,iBAAW,IAAI;AAAA,QACb;AAAA,QACA,UAAQ;AACN,gBAAM,WAAW,KAAK,OAAO,IAAI,IAAI;AAIrC,cAAI,YAAY,aAAa,MAAM;AACjC,kBAAM,IAAI,MAAM,qBAAqB;AAAA,UACvC;AACA,eAAK,OAAO,IAAI,MAAM,IAAI;AAAA,QAC5B;AAAA,QACA,MAAM;AACJ,eAAK,OAAO,OAAO,IAAI;AAAA,QACzB;AAAA,MACF;AACA,WAAK,OAAO,IAAI,MAAM,QAAQ;AAAA,IAChC;AACA,WAAO;AAAA,EACT;AACF;AAEA,IAAM,YAAY,IAAI,UAAU;AA2BhC,IAAM,cAAN,MAA0E;AAAA,EACxE;AAAA,EACS;AAAA,EACA;AAAA,EACA;AAAA,EACT;AAAA,EACA;AAAA,EAEA,YACE,OACA,gBACA,kBACA;AACA,SAAK,YAAY,mBAAmB,MAAM,OAAO,QAAQ;AACzD,SAAK,kBAAkB;AACvB,SAAK,oBAAoB;AACzB,SAAK,kBAAkB,oBAAI,IAAI;AAC/B,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,UAAU,CAAC,MAAiC,eAA2B;AACrE,UAAM,OACJ,SAAS,SACL,OACC,UAAU,IAAyB;AAC1C,SAAK,YAAY,CAAC,MAAM,EAAC,MAAM,WAAU,CAAC;AAC1C,eAAW,aAAa,KAAK,iBAAiB;AAC5C,gBAAU;AAAA,IACZ;AAAA,EACF;AAAA,EAEA,uBAAuB,MAAM;AAC3B,QAAI,KAAK,OAAO;AACd;AAAA,IACF;AAEA,SAAK,QAAQ,KAAK,OAAO,YAAY;AACrC,SAAK,MAAM,YAAY,KAAK,OAAO;AAEnC,SAAK,gBAAgB,IAAI;AAAA,EAC3B;AAAA,EAEA,cAAc,MAAM,KAAK;AAAA,EAEzB,0BAA0B,CAAC,cAAwC;AACjE,SAAK,gBAAgB,IAAI,SAAS;AAClC,SAAK,qBAAqB;AAC1B,WAAO,MAAM;AACX,WAAK,gBAAgB,OAAO,SAAS;AACrC,UAAI,KAAK,gBAAgB,SAAS,GAAG;AACnC,aAAK,OAAO,QAAQ;AACpB,aAAK,QAAQ;AACb,aAAK,kBAAkB;AAAA,MACzB;AAAA,IACF;AAAA,EACF;AACF;",
+  "sourcesContent": ["import {useSyncExternalStore} from 'react';\nimport {deepClone} from '../../shared/src/deep-clone.js';\nimport type {Immutable} from '../../shared/src/immutable.js';\nimport type {\n  Query,\n  ReadonlyJSONValue,\n  TypedView,\n} from '../../zero-client/src/mod.js';\nimport type {AdvancedQuery} from '../../zql/src/query/query-internal.js';\nimport type {ResultType} from '../../zql/src/query/typed-view.js';\nimport {useZero} from './use-zero.js';\nimport type {HumanReadable} from '../../zql/src/query/query.js';\nimport type {Schema} from '../../zero-client/src/mod.js';\n\nexport type QueryResultDetails = Readonly<{\n  type: ResultType;\n}>;\n\nexport type QueryResult<TReturn> = readonly [\n  HumanReadable<TReturn>,\n  QueryResultDetails,\n];\n\nexport function useQuery<\n  TSchema extends Schema,\n  TTable extends keyof TSchema['tables'] & string,\n  TReturn,\n>(\n  q: Query<TSchema, TTable, TReturn>,\n  enable: boolean = true,\n): QueryResult<TReturn> {\n  const z = useZero();\n  const view = viewStore.getView(\n    z.clientID,\n    q as AdvancedQuery<TSchema, TTable, TReturn>,\n    enable && z.server !== null,\n  );\n  // https://react.dev/reference/react/useSyncExternalStore\n  return useSyncExternalStore(\n    view.subscribeReactInternals,\n    view.getSnapshot,\n    view.getSnapshot,\n  );\n}\n\nconst emptyArray: unknown[] = [];\nconst disabledSubscriber = () => () => {};\n\nconst defaultSnapshots = {\n  singular: [undefined, {type: 'unknown'}] as const,\n  plural: [emptyArray, {type: 'unknown'}] as const,\n};\n\nfunction getDefaultSnapshot<TReturn>(singular: boolean): QueryResult<TReturn> {\n  return (\n    singular ? defaultSnapshots.singular : defaultSnapshots.plural\n  ) as QueryResult<TReturn>;\n}\n\n/**\n * A global store of all active views.\n *\n * React subscribes and unsubscribes to these views\n * via `useSyncExternalStore`.\n *\n * Managing views through `useEffect` or `useLayoutEffect` causes\n * inconsistencies because effects run after render.\n *\n * For example, if useQuery used use*Effect in the component below:\n * ```ts\n * function Foo({issueID}) {\n *   const issue = useQuery(z.query.issue.where('id', issueID).one());\n *   if (issue?.id !== undefined && issue.id !== issueID) {\n *     console.log('MISMATCH!', issue.id, issueID);\n *   }\n * }\n * ```\n *\n * `MISMATCH` will be printed whenever the `issueID` prop changes.\n *\n * This is because the component will render once with\n * the old state returned from `useQuery`. Then the effect inside\n * `useQuery` will run. The component will render again with the new\n * state. This inconsistent transition can cause unexpected results.\n *\n * Emulating `useEffect` via `useState` and `if` causes resource leaks.\n * That is:\n *\n * ```ts\n * function useQuery(q) {\n *   const [oldHash, setOldHash] = useState();\n *   if (hash(q) !== oldHash) {\n *      // make new view\n *   }\n *\n *   useEffect(() => {\n *     return () => view.destroy();\n *   }, []);\n * }\n * ```\n *\n * I'm not sure why but in strict mode the cleanup function\n * fails to be called for the first instance of the view and only\n * cleans up later instances.\n *\n * Swapping `useState` to `useRef` has similar problems.\n */\nclass ViewStore {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  #views = new Map<string, ViewWrapper<any, any, any>>();\n\n  getView<\n    TSchema extends Schema,\n    TTable extends keyof TSchema['tables'] & string,\n    TReturn,\n  >(\n    clientID: string,\n    query: AdvancedQuery<TSchema, TTable, TReturn>,\n    enabled: boolean,\n  ): {\n    getSnapshot: () => QueryResult<TReturn>;\n    subscribeReactInternals: (internals: () => void) => () => void;\n  } {\n    if (!enabled) {\n      return {\n        getSnapshot: () => getDefaultSnapshot(query.format.singular),\n        subscribeReactInternals: disabledSubscriber,\n      };\n    }\n\n    const hash = query.hash() + clientID;\n    let existing = this.#views.get(hash);\n    if (!existing) {\n      existing = new ViewWrapper(\n        query,\n        view => {\n          const lastView = this.#views.get(hash);\n          // I don't think this can happen\n          // but lets guard against it so we don't\n          // leak resources.\n          if (lastView && lastView !== view) {\n            throw new Error('View already exists');\n          }\n          this.#views.set(hash, view);\n        },\n        () => {\n          this.#views.delete(hash);\n        },\n      ) as ViewWrapper<TSchema, TTable, TReturn>;\n      this.#views.set(hash, existing);\n    }\n    return existing as ViewWrapper<TSchema, TTable, TReturn>;\n  }\n}\n\nconst viewStore = new ViewStore();\n\n/**\n * This wraps and ref counts a view.\n *\n * The only signal we have from React as to whether or not it is\n * done with a view is when it calls `unsubscribe`.\n *\n * In non-strict-mode we can clean up the view as soon\n * as the listener count goes to 0.\n *\n * In strict-mode, the listener cound will go to 0 then a\n * new listener for the same view is immeidatiely added back.\n *\n * This is why the `onMaterialized` and `onDematerialized` callbacks exist --\n * they allow a view which React is still referencing to be added\n * back into the store when React re-subscribes to it.\n *\n * This wrapper also exists to deal with the various\n * `useSyncExternalStore` caveats that cause excessive\n * re-renders and materializations.\n *\n * See: https://react.dev/reference/react/useSyncExternalStore#caveats\n * Especially:\n * 1. The store snapshot returned by getSnapshot must be immutable. If the underlying store has mutable data, return a new immutable snapshot if the data has changed. Otherwise, return a cached last snapshot.\n * 2. If a different subscribe function is passed during a re-render, React will re-subscribe to the store using the newly passed subscribe function. You can prevent this by declaring subscribe outside the component.\n */\nclass ViewWrapper<\n  TSchema extends Schema,\n  TTable extends keyof TSchema['tables'] & string,\n  TReturn,\n> {\n  #view: TypedView<HumanReadable<TReturn>> | undefined;\n  readonly #onDematerialized;\n  readonly #onMaterialized;\n  readonly #query: AdvancedQuery<TSchema, TTable, TReturn>;\n  #snapshot: QueryResult<TReturn>;\n  #reactInternals: Set<() => void>;\n\n  constructor(\n    query: AdvancedQuery<TSchema, TTable, TReturn>,\n    onMaterialized: (view: ViewWrapper<TSchema, TTable, TReturn>) => void,\n    onDematerialized: () => void,\n  ) {\n    this.#snapshot = getDefaultSnapshot(query.format.singular);\n    this.#onMaterialized = onMaterialized;\n    this.#onDematerialized = onDematerialized;\n    this.#reactInternals = new Set();\n    this.#query = query;\n  }\n\n  #onData = (\n    snap: Immutable<HumanReadable<TReturn>>,\n    resultType: ResultType,\n  ) => {\n    const data =\n      snap === undefined\n        ? snap\n        : (deepClone(snap as ReadonlyJSONValue) as HumanReadable<TReturn>);\n    this.#snapshot = [data, {type: resultType}] as QueryResult<TReturn>;\n    for (const internals of this.#reactInternals) {\n      internals();\n    }\n  };\n\n  #materializeIfNeeded = () => {\n    if (this.#view) {\n      return;\n    }\n\n    this.#view = this.#query.materialize();\n    this.#view.addListener(this.#onData);\n\n    this.#onMaterialized(this);\n  };\n\n  getSnapshot = () => this.#snapshot;\n\n  subscribeReactInternals = (internals: () => void): (() => void) => {\n    this.#reactInternals.add(internals);\n    this.#materializeIfNeeded();\n    return () => {\n      this.#reactInternals.delete(internals);\n      if (this.#reactInternals.size === 0) {\n        this.#view?.destroy();\n        this.#view = undefined;\n        this.#onDematerialized();\n      }\n    };\n  };\n}\n", "import {hasOwn} from './has-own.js';\nimport type {JSONValue, ReadonlyJSONValue} from './json.js';\n\nexport function deepClone(value: ReadonlyJSONValue): JSONValue {\n  const seen: Array<ReadonlyJSONValue> = [];\n  return internalDeepClone(value, seen);\n}\n\nexport function internalDeepClone(\n  value: ReadonlyJSONValue,\n  seen: Array<ReadonlyJSONValue>,\n): JSONValue {\n  switch (typeof value) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n    case 'undefined':\n      return value;\n    case 'object': {\n      if (value === null) {\n        return null;\n      }\n      if (seen.includes(value)) {\n        throw new Error('Cyclic object');\n      }\n      seen.push(value);\n      if (Array.isArray(value)) {\n        const rv = value.map(v => internalDeepClone(v, seen));\n        seen.pop();\n        return rv;\n      }\n\n      const obj: JSONValue = {};\n\n      for (const k in value) {\n        if (hasOwn(value, k)) {\n          const v = (value as Record<string, ReadonlyJSONValue>)[k];\n          if (v !== undefined) {\n            obj[k] = internalDeepClone(v, seen);\n          }\n        }\n      }\n      seen.pop();\n      return obj;\n    }\n\n    default:\n      throw new Error(`Invalid type: ${typeof value}`);\n  }\n}\n", "import {createContext, useContext} from 'react';\nimport type {Zero} from '../../zero-client/src/mod.js';\nimport type {Schema} from '../../zero-schema/src/mod.js';\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nconst ZeroContext = createContext<unknown | undefined>(undefined);\n\nexport function useZero<S extends Schema>(): Zero<S> {\n  const zero = useContext(ZeroContext);\n  if (zero === undefined) {\n    throw new Error('useZero must be used within a ZeroProvider');\n  }\n  return zero as Zero<S>;\n}\n\nexport function createUseZero<S extends Schema>() {\n  return () => useZero<S>();\n}\n\nexport function ZeroProvider<S extends Schema>({\n  children,\n  zero,\n}: {\n  children: React.ReactNode;\n  zero: Zero<S>;\n}) {\n  return <ZeroContext.Provider value={zero}>{children}</ZeroContext.Provider>;\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/out/shared/src/btree-set.d.ts

@@ -0,0 +1,34 @@
+type Comparator<K> = (a: K, b: K) => number;
+export declare class BTreeSet<K> {
+    #private;
+    size: number;
+    readonly comparator: Comparator<K>;
+    constructor(comparator: Comparator<K>, entries?: IterableIterator<K>);
+    /** Releases the tree so that its size is 0. */
+    clear(): void;
+    get(key: K): K | undefined;
+    add(key: K): this;
+    /**
+     * Returns true if the key exists in the B+ tree, false if not.
+     * Use get() for best performance; use has() if you need to
+     * distinguish between "undefined value" and "key not present".
+     * @param key Key to detect
+     * @description Computational complexity: O(log size)
+     */
+    has(key: K): boolean;
+    /**
+     * Removes a single key-value pair from the B+ tree.
+     * @param key Key to find
+     * @returns true if a pair was found and removed, false otherwise.
+     * @description Computational complexity: O(log size)
+     */
+    delete(key: K): boolean;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<K>;
+    valuesFrom(lowestKey?: K, inclusive?: boolean): IterableIterator<K>;
+    valuesReversed(): IterableIterator<K>;
+    valuesFromReversed(highestKey?: K, inclusive?: boolean): IterableIterator<K>;
+    [Symbol.iterator](): IterableIterator<K>;
+}
+export {};
+//# sourceMappingURL=btree-set.d.ts.map

package/out/shared/src/btree-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"btree-set.d.ts","sourceRoot":"","sources":["../../../../shared/src/btree-set.ts"],"names":[],"mappings":"AAIA,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAC5C,qBAAa,QAAQ,CAAC,CAAC;;IAErB,IAAI,EAAE,MAAM,CAAK;IAEjB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;gBAEvB,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;IASpE,+CAA+C;IAC/C,KAAK;IAKL,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI1B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI;IASjB;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAyBvB,IAAI,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI3B,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI7B,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,SAAS,GAAE,OAAc,GAAG,gBAAgB,CAAC,CAAC,CAAC;IAIzE,cAAc,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAUrC,kBAAkB,CAChB,UAAU,CAAC,EAAE,CAAC,EACd,SAAS,GAAE,OAAc,GACxB,gBAAgB,CAAC,CAAC,CAAC;IAetB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC;CAGzC"}

package/out/shared/src/btree-set.js

@@ -0,0 +1,528 @@
+import { assert } from './asserts.js';
+const MAX_NODE_SIZE = 32;
+export class BTreeSet {
+    #root = emptyLeaf;
+    size = 0;
+    comparator;
+    constructor(comparator, entries) {
+        this.comparator = comparator;
+        if (entries) {
+            for (const key of entries) {
+                this.add(key);
+            }
+        }
+    }
+    /** Releases the tree so that its size is 0. */
+    clear() {
+        this.#root = emptyLeaf;
+        this.size = 0;
+    }
+    get(key) {
+        return this.#root.get(key, this);
+    }
+    add(key) {
+        if (this.#root.isShared)
+            this.#root = this.#root.clone();
+        const result = this.#root.set(key, this);
+        if (result === null)
+            return this;
+        // Root node has split, so create a new root node.
+        this.#root = new BNodeInternal([this.#root, result]);
+        return this;
+    }
+    /**
+     * Returns true if the key exists in the B+ tree, false if not.
+     * Use get() for best performance; use has() if you need to
+     * distinguish between "undefined value" and "key not present".
+     * @param key Key to detect
+     * @description Computational complexity: O(log size)
+     */
+    has(key) {
+        return this.#root.has(key, this);
+    }
+    /**
+     * Removes a single key-value pair from the B+ tree.
+     * @param key Key to find
+     * @returns true if a pair was found and removed, false otherwise.
+     * @description Computational complexity: O(log size)
+     */
+    delete(key) {
+        return this.#delete(key);
+    }
+    #delete(key) {
+        let root = this.#root;
+        if (root.isShared) {
+            this.#root = root = root.clone();
+        }
+        try {
+            return root.delete(key, this);
+        }
+        finally {
+            let isShared;
+            while (root.keys.length <= 1 && root.isInternal()) {
+                isShared ||= root.isShared;
+                this.#root = root =
+                    root.keys.length === 0 ? emptyLeaf : root.children[0];
+            }
+            // If any ancestor of the new root was shared, the new root must also be shared
+            if (isShared) {
+                root.isShared = true;
+            }
+        }
+    }
+    keys() {
+        return valuesFrom(this.#root, this.comparator, undefined, true);
+    }
+    values() {
+        return valuesFrom(this.#root, this.comparator, undefined, true);
+    }
+    valuesFrom(lowestKey, inclusive = true) {
+        return valuesFrom(this.#root, this.comparator, lowestKey, inclusive);
+    }
+    valuesReversed() {
+        return valuesFromReversed(this.#maxKey(), this.#root, this.comparator, undefined, true);
+    }
+    valuesFromReversed(highestKey, inclusive = true) {
+        return valuesFromReversed(this.#maxKey(), this.#root, this.comparator, highestKey, inclusive);
+    }
+    /** Gets the highest key in the tree. Complexity: O(1) */
+    #maxKey() {
+        return this.#root.maxKey();
+    }
+    [Symbol.iterator]() {
+        return this.keys();
+    }
+}
+function valuesFrom(root, comparator, lowestKey, inclusive) {
+    const info = findPath(lowestKey, root, comparator);
+    if (info === undefined) {
+        return iterator(() => ({ done: true, value: undefined }));
+    }
+    // eslint-disable-next-line prefer-const
+    let [nodeQueue, nodeIndex, leaf] = info;
+    let i = lowestKey === undefined
+        ? -1
+        : indexOf(lowestKey, leaf.keys, 0, comparator) - 1;
+    if (!inclusive &&
+        i < leaf.keys.length &&
+        // +1 because we did -1 above.
+        comparator(leaf.keys[i + 1], lowestKey) === 0) {
+        i++;
+    }
+    return iterator(() => {
+        for (;;) {
+            if (++i < leaf.keys.length) {
+                return { done: false, value: leaf.keys[i] };
+            }
+            let level = -1;
+            for (;;) {
+                if (++level >= nodeQueue.length) {
+                    return { done: true, value: undefined };
+                }
+                if (++nodeIndex[level] < nodeQueue[level].length) {
+                    break;
+                }
+            }
+            for (; level > 0; level--) {
+                nodeQueue[level - 1] = nodeQueue[level][nodeIndex[level]].children;
+                nodeIndex[level - 1] = 0;
+            }
+            leaf = nodeQueue[0][nodeIndex[0]];
+            i = -1;
+        }
+    });
+}
+function valuesFromReversed(maxKey, root, comparator, highestKey, inclusive) {
+    if (highestKey === undefined) {
+        highestKey = maxKey;
+        if (highestKey === undefined)
+            return iterator(() => ({ done: true, value: undefined })); // collection is empty
+    }
+    // eslint-disable-next-line prefer-const
+    let [nodeQueue, nodeIndex, leaf] = findPath(highestKey, root, comparator) ||
+        findPath(maxKey, root, comparator);
+    assert(!nodeQueue[0] || leaf === nodeQueue[0][nodeIndex[0]]);
+    let i = indexOf(highestKey, leaf.keys, 0, comparator);
+    if (inclusive &&
+        i < leaf.keys.length &&
+        comparator(leaf.keys[i], highestKey) <= 0) {
+        i++;
+    }
+    return iterator(() => {
+        for (;;) {
+            if (--i >= 0) {
+                return { done: false, value: leaf.keys[i] };
+            }
+            let level;
+            // Advance to the next leaf node
+            for (level = -1;;) {
+                if (++level >= nodeQueue.length) {
+                    return { done: true, value: undefined };
+                }
+                if (--nodeIndex[level] >= 0) {
+                    break;
+                }
+            }
+            for (; level > 0; level--) {
+                nodeQueue[level - 1] = nodeQueue[level][nodeIndex[level]].children;
+                nodeIndex[level - 1] = nodeQueue[level - 1].length - 1;
+            }
+            leaf = nodeQueue[0][nodeIndex[0]];
+            i = leaf.keys.length;
+        }
+    });
+}
+function findPath(key, root, comparator) {
+    let nextNode = root;
+    const nodeQueue = [];
+    const nodeIndex = [];
+    if (nextNode.isInternal()) {
+        for (let d = 0; nextNode.isInternal(); d++) {
+            nodeQueue[d] = nextNode.children;
+            nodeIndex[d] =
+                key === undefined ? 0 : indexOf(key, nextNode.keys, 0, comparator);
+            if (nodeIndex[d] >= nodeQueue[d].length)
+                return; // first key > maxKey()
+            nextNode = nodeQueue[d][nodeIndex[d]];
+        }
+        nodeQueue.reverse();
+        nodeIndex.reverse();
+    }
+    return [nodeQueue, nodeIndex, nextNode];
+}
+function iterator(next) {
+    return {
+        next,
+        [Symbol.iterator]() {
+            return this;
+        },
+    };
+}
+/** Leaf node / base class. **************************************************/
+class BNode {
+    // If this is an internal node, _keys[i] is the highest key in children[i].
+    keys;
+    // True if this node might be within multiple `BTree`s (or have multiple parents).
+    // If so, it must be cloned before being mutated to avoid changing an unrelated tree.
+    // This is transitive: if it's true, children are also shared even if `isShared!=true`
+    // in those children. (Certain operations will propagate isShared=true to children.)
+    isShared;
+    constructor(keys) {
+        this.keys = keys;
+        this.isShared = undefined;
+    }
+    isInternal() {
+        return false;
+    }
+    maxKey() {
+        return this.keys[this.keys.length - 1];
+    }
+    minKey() {
+        return this.keys[0];
+    }
+    clone() {
+        return new BNode(this.keys.slice(0));
+    }
+    get(key, tree) {
+        const i = indexOf(key, this.keys, -1, tree.comparator);
+        return i < 0 ? undefined : this.keys[i];
+    }
+    has(key, tree) {
+        const i = indexOf(key, this.keys, -1, tree.comparator);
+        return i >= 0 && i < this.keys.length;
+    }
+    set(key, tree) {
+        let i = indexOf(key, this.keys, -1, tree.comparator);
+        if (i < 0) {
+            // key does not exist yet
+            i = ~i;
+            tree.size++;
+            if (this.keys.length < MAX_NODE_SIZE) {
+                this.keys.splice(i, 0, key);
+                return null;
+            }
+            // This leaf node is full and must split
+            const newRightSibling = this.splitOffRightSide();
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            let target = this;
+            if (i > this.keys.length) {
+                i -= this.keys.length;
+                target = newRightSibling;
+            }
+            // target.#insertInLeaf(i, key);
+            target.keys.splice(i, 0, key);
+            return newRightSibling;
+        }
+        // usually this is a no-op, but some users may wish to edit the key
+        this.keys[i] = key;
+        return null;
+    }
+    takeFromRight(rhs) {
+        this.keys.push(rhs.keys.shift());
+    }
+    takeFromLeft(lhs) {
+        this.keys.unshift(lhs.keys.pop());
+    }
+    splitOffRightSide() {
+        const half = this.keys.length >> 1;
+        const keys = this.keys.splice(half);
+        return new BNode(keys);
+    }
+    delete(key, tree) {
+        const cmp = tree.comparator;
+        const iLow = indexOf(key, this.keys, -1, cmp);
+        const iHigh = iLow + 1;
+        if (iLow < 0) {
+            return false;
+        }
+        const { keys } = this;
+        for (let i = iLow; i < iHigh; i++) {
+            const key = keys[i];
+            if (key !== keys[i] || this.isShared === true) {
+                throw new Error('BTree illegally changed or cloned in delete');
+            }
+            this.keys.splice(i, 1);
+            tree.size--;
+            return true;
+        }
+        return false;
+    }
+    mergeSibling(rhs, _) {
+        this.keys.push(...rhs.keys);
+    }
+}
+/** Internal node (non-leaf node) ********************************************/
+class BNodeInternal extends BNode {
+    // Note: conventionally B+ trees have one fewer key than the number of
+    // children, but I find it easier to keep the array lengths equal: each
+    // keys[i] caches the value of children[i].maxKey().
+    children;
+    /**
+     * This does not mark `children` as shared, so it is the responsibility of the caller
+     * to ensure children are either marked shared, or aren't included in another tree.
+     */
+    constructor(children, keys) {
+        if (!keys) {
+            keys = [];
+            for (let i = 0; i < children.length; i++) {
+                keys[i] = children[i].maxKey();
+            }
+        }
+        super(keys);
+        this.children = children;
+    }
+    isInternal() {
+        return true;
+    }
+    clone() {
+        const children = this.children.slice(0);
+        for (let i = 0; i < children.length; i++) {
+            children[i].isShared = true;
+        }
+        return new BNodeInternal(children, this.keys.slice(0));
+    }
+    minKey() {
+        return this.children[0].minKey();
+    }
+    get(key, tree) {
+        const i = indexOf(key, this.keys, 0, tree.comparator);
+        const { children } = this;
+        return i < children.length ? children[i].get(key, tree) : undefined;
+    }
+    has(key, tree) {
+        const i = indexOf(key, this.keys, 0, tree.comparator);
+        const { children } = this;
+        return i < children.length ? children[i].has(key, tree) : false;
+    }
+    set(key, tree) {
+        const c = this.children;
+        const cmp = tree.comparator;
+        let i = Math.min(indexOf(key, this.keys, 0, cmp), c.length - 1);
+        let child = c[i];
+        if (child.isShared) {
+            c[i] = child = child.clone();
+        }
+        if (child.keys.length >= MAX_NODE_SIZE) {
+            // child is full; inserting anything else will cause a split.
+            // Shifting an item to the left or right sibling may avoid a split.
+            // We can do a shift if the adjacent node is not full and if the
+            // current key can still be placed in the same node after the shift.
+            let other;
+            if (i > 0 &&
+                (other = c[i - 1]).keys.length < MAX_NODE_SIZE &&
+                cmp(child.keys[0], key) < 0) {
+                if (other.isShared) {
+                    c[i - 1] = other = other.clone();
+                }
+                other.takeFromRight(child);
+                this.keys[i - 1] = other.maxKey();
+            }
+            else if ((other = c[i + 1]) !== undefined &&
+                other.keys.length < MAX_NODE_SIZE &&
+                cmp(child.maxKey(), key) < 0) {
+                if (other.isShared)
+                    c[i + 1] = other = other.clone();
+                other.takeFromLeft(child);
+                this.keys[i] = c[i].maxKey();
+            }
+        }
+        const result = child.set(key, tree);
+        this.keys[i] = child.maxKey();
+        if (result === null)
+            return null;
+        // The child has split and `result` is a new right child... does it fit?
+        if (this.keys.length < MAX_NODE_SIZE) {
+            // yes
+            this.insert(i + 1, result);
+            return null;
+        }
+        // no, we must split also
+        const newRightSibling = this.splitOffRightSide();
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let target = this;
+        if (cmp(result.maxKey(), this.maxKey()) > 0) {
+            target = newRightSibling;
+            i -= this.keys.length;
+        }
+        target.insert(i + 1, result);
+        return newRightSibling;
+    }
+    /**
+     * Inserts `child` at index `i`.
+     * This does not mark `child` as shared, so it is the responsibility of the caller
+     * to ensure that either child is marked shared, or it is not included in another tree.
+     */
+    insert(i, child) {
+        this.children.splice(i, 0, child);
+        this.keys.splice(i, 0, child.maxKey());
+    }
+    /**
+     * Split this node.
+     * Modifies this to remove the second half of the items, returning a separate node containing them.
+     */
+    splitOffRightSide() {
+        const half = this.children.length >> 1;
+        return new BNodeInternal(this.children.splice(half), this.keys.splice(half));
+    }
+    takeFromRight(rhs) {
+        this.keys.push(rhs.keys.shift());
+        this.children.push(rhs.children.shift());
+    }
+    takeFromLeft(lhs) {
+        this.keys.unshift(lhs.keys.pop());
+        this.children.unshift(lhs.children.pop());
+    }
+    delete(key, tree) {
+        const cmp = tree.comparator;
+        const { keys } = this;
+        const { children } = this;
+        let iLow = indexOf(key, this.keys, 0, cmp);
+        let i = iLow;
+        const iHigh = Math.min(iLow, keys.length - 1);
+        if (i <= iHigh) {
+            try {
+                if (children[i].isShared) {
+                    children[i] = children[i].clone();
+                }
+                const result = children[i].delete(key, tree);
+                // Note: if children[i] is empty then keys[i]=undefined.
+                //       This is an invalid state, but it is fixed below.
+                keys[i] = children[i].maxKey();
+                return result;
+            }
+            finally {
+                // Deletions may have occurred, so look for opportunities to merge nodes.
+                const half = MAX_NODE_SIZE >> 1;
+                if (iLow > 0)
+                    iLow--;
+                for (i = iHigh; i >= iLow; i--) {
+                    if (children[i].keys.length <= half) {
+                        if (children[i].keys.length !== 0) {
+                            this.tryMerge(i, MAX_NODE_SIZE);
+                        }
+                        else {
+                            // child is empty! delete it!
+                            keys.splice(i, 1);
+                            children.splice(i, 1);
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /** Merges child i with child i+1 if their combined size is not too large */
+    tryMerge(i, maxSize) {
+        const { children } = this;
+        if (i >= 0 && i + 1 < children.length) {
+            if (children[i].keys.length + children[i + 1].keys.length <= maxSize) {
+                if (children[i].isShared)
+                    // cloned already UNLESS i is outside scan range
+                    children[i] = children[i].clone();
+                children[i].mergeSibling(children[i + 1], maxSize);
+                children.splice(i + 1, 1);
+                this.keys.splice(i + 1, 1);
+                this.keys[i] = children[i].maxKey();
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Move children from `rhs` into this.
+     * `rhs` must be part of this tree, and be removed from it after this call
+     * (otherwise isShared for its children could be incorrect).
+     */
+    mergeSibling(rhs, maxNodeSize) {
+        // assert !this.isShared;
+        const oldLength = this.keys.length;
+        this.keys.push(...rhs.keys);
+        const rhsChildren = rhs.children;
+        this.children.push(...rhsChildren);
+        if (rhs.isShared && !this.isShared) {
+            // All children of a shared node are implicitly shared, and since their new
+            // parent is not shared, they must now be explicitly marked as shared.
+            for (let i = 0; i < rhsChildren.length; i++) {
+                rhsChildren[i].isShared = true;
+            }
+        }
+        // If our children are themselves almost empty due to a mass-delete,
+        // they may need to be merged too (but only the oldLength-1 and its
+        // right sibling should need this).
+        this.tryMerge(oldLength - 1, maxNodeSize);
+    }
+}
+// If key not found, returns i^failXor where i is the insertion index.
+// Callers that don't care whether there was a match will set failXor=0.
+function indexOf(key, keys, failXor, comparator) {
+    let lo = 0;
+    let hi = keys.length;
+    let mid = hi >> 1;
+    while (lo < hi) {
+        const c = comparator(keys[mid], key);
+        if (c < 0) {
+            lo = mid + 1;
+        }
+        else if (c > 0) {
+            // key < keys[mid]
+            hi = mid;
+        }
+        else if (c === 0) {
+            return mid;
+        }
+        else {
+            // c is NaN or otherwise invalid
+            if (key === key) {
+                // at least the search key is not NaN
+                return keys.length;
+            }
+            throw new Error('NaN was used as a key');
+        }
+        mid = (lo + hi) >> 1;
+    }
+    return mid ^ failXor;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const emptyLeaf = new BNode([]);
+emptyLeaf.isShared = true;
+//# sourceMappingURL=btree-set.js.map