@tldraw/store 4.1.0-next.b6dfe9bccde9 → 4.1.0-next.b73a0d46b63f

package/dist-cjs/index.js

@@ -54,7 +54,7 @@ var import_StoreSchema = require("./lib/StoreSchema");
 var import_StoreSideEffects = require("./lib/StoreSideEffects");
 (0, import_utils.registerTldrawLibraryVersion)(
   "@tldraw/store",
-  "4.1.0-next.b6dfe9bccde9",
+  "4.1.0-next.b73a0d46b63f",
   "cjs"
 );
 //# sourceMappingURL=index.js.map

package/dist-cjs/lib/AtomMap.js

@@ -25,6 +25,21 @@ var import_state = require("@tldraw/state");
 var import_utils = require("@tldraw/utils");
 var import_ImmutableMap = require("./ImmutableMap");
 class AtomMap {
+  /**
+   * Creates a new AtomMap instance.
+   *
+   * name - A unique name for this map, used for atom identification
+   * entries - Optional initial entries to populate the map with
+   * @example
+   * ```ts
+   * // Create an empty map
+   * const map = new AtomMap('userMap')
+   *
+   * // Create a map with initial data
+   * const initialData: [string, number][] = [['a', 1], ['b', 2]]
+   * const mapWithData = new AtomMap('numbersMap', initialData)
+   * ```
+   */
   constructor(name, entries) {
     this.name = name;
     let atoms = (0, import_ImmutableMap.emptyMap)();
@@ -38,7 +53,13 @@ class AtomMap {
     this.atoms = (0, import_state.atom)(`${name}:atoms`, atoms);
   }
   atoms;
-  /** @internal */
+  /**
+   * Retrieves the underlying atom for a given key.
+   *
+   * @param key - The key to retrieve the atom for
+   * @returns The atom containing the value, or undefined if the key doesn't exist
+   * @internal
+   */
   getAtom(key) {
     const valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key);
     if (!valueAtom) {
@@ -47,11 +68,38 @@ class AtomMap {
     }
     return valueAtom;
   }
+  /**
+   * Gets the value associated with a key. Returns undefined if the key doesn't exist.
+   * This method is reactive and will cause reactive contexts to update when the value changes.
+   *
+   * @param key - The key to retrieve the value for
+   * @returns The value associated with the key, or undefined if not found
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('name', 'Alice')
+   * console.log(map.get('name')) // 'Alice'
+   * console.log(map.get('missing')) // undefined
+   * ```
+   */
   get(key) {
     const value = this.getAtom(key)?.get();
     (0, import_utils.assert)(value !== import_state.UNINITIALIZED);
     return value;
   }
+  /**
+   * Gets the value associated with a key without creating reactive dependencies.
+   * This method will not cause reactive contexts to update when the value changes.
+   *
+   * @param key - The key to retrieve the value for
+   * @returns The value associated with the key, or undefined if not found
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('count', 42)
+   * const value = map.__unsafe__getWithoutCapture('count') // No reactive subscription
+   * ```
+   */
   __unsafe__getWithoutCapture(key) {
     const valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key);
     if (!valueAtom) return void 0;
@@ -59,6 +107,20 @@ class AtomMap {
     (0, import_utils.assert)(value !== import_state.UNINITIALIZED);
     return value;
   }
+  /**
+   * Checks whether a key exists in the map.
+   * This method is reactive and will cause reactive contexts to update when keys are added or removed.
+   *
+   * @param key - The key to check for
+   * @returns True if the key exists in the map, false otherwise
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * console.log(map.has('name')) // false
+   * map.set('name', 'Alice')
+   * console.log(map.has('name')) // true
+   * ```
+   */
   has(key) {
     const valueAtom = this.getAtom(key);
     if (!valueAtom) {
@@ -66,12 +128,38 @@ class AtomMap {
     }
     return valueAtom.get() !== import_state.UNINITIALIZED;
   }
+  /**
+   * Checks whether a key exists in the map without creating reactive dependencies.
+   * This method will not cause reactive contexts to update when keys are added or removed.
+   *
+   * @param key - The key to check for
+   * @returns True if the key exists in the map, false otherwise
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('active', true)
+   * const exists = map.__unsafe__hasWithoutCapture('active') // No reactive subscription
+   * ```
+   */
   __unsafe__hasWithoutCapture(key) {
     const valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key);
     if (!valueAtom) return false;
     (0, import_utils.assert)(valueAtom.__unsafe__getWithoutCapture() !== import_state.UNINITIALIZED);
     return true;
   }
+  /**
+   * Sets a value for the given key. If the key already exists, its value is updated.
+   * If the key doesn't exist, a new entry is created.
+   *
+   * @param key - The key to set the value for
+   * @param value - The value to associate with the key
+   * @returns This AtomMap instance for method chaining
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('name', 'Alice').set('age', 30)
+   * ```
+   */
   set(key, value) {
     const existingAtom = this.atoms.__unsafe__getWithoutCapture().get(key);
     if (existingAtom) {
@@ -83,6 +171,19 @@ class AtomMap {
     }
     return this;
   }
+  /**
+   * Updates an existing value using an updater function.
+   *
+   * @param key - The key of the value to update
+   * @param updater - A function that receives the current value and returns the new value
+   * @throws Error if the key doesn't exist in the map
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('count', 5)
+   * map.update('count', count => count + 1) // count is now 6
+   * ```
+   */
   update(key, updater) {
     const valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key);
     if (!valueAtom) {
@@ -92,6 +193,19 @@ class AtomMap {
     (0, import_utils.assert)(value !== import_state.UNINITIALIZED);
     valueAtom.set(updater(value));
   }
+  /**
+   * Removes a key-value pair from the map.
+   *
+   * @param key - The key to remove
+   * @returns True if the key existed and was removed, false if it didn't exist
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('temp', 'value')
+   * console.log(map.delete('temp')) // true
+   * console.log(map.delete('missing')) // false
+   * ```
+   */
   delete(key) {
     const valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key);
     if (!valueAtom) {
@@ -105,6 +219,19 @@ class AtomMap {
     });
     return true;
   }
+  /**
+   * Removes multiple key-value pairs from the map in a single transaction.
+   *
+   * @param keys - An iterable of keys to remove
+   * @returns An array of [key, value] pairs that were actually deleted
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('a', 1).set('b', 2).set('c', 3)
+   * const deleted = map.deleteMany(['a', 'c', 'missing'])
+   * console.log(deleted) // [['a', 1], ['c', 3]]
+   * ```
+   */
   deleteMany(keys) {
     return (0, import_state.transact)(() => {
       const deleted = [];
@@ -125,6 +252,17 @@ class AtomMap {
       return deleted;
     });
   }
+  /**
+   * Removes all key-value pairs from the map.
+   *
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('a', 1).set('b', 2)
+   * map.clear()
+   * console.log(map.size) // 0
+   * ```
+   */
   clear() {
     return (0, import_state.transact)(() => {
       for (const valueAtom of this.atoms.__unsafe__getWithoutCapture().values()) {
@@ -133,6 +271,20 @@ class AtomMap {
       this.atoms.set((0, import_ImmutableMap.emptyMap)());
     });
   }
+  /**
+   * Returns an iterator that yields [key, value] pairs for each entry in the map.
+   * This method is reactive and will cause reactive contexts to update when entries change.
+   *
+   * @returns A generator that yields [key, value] tuples
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('a', 1).set('b', 2)
+   * for (const [key, value] of map.entries()) {
+   *   console.log(`${key}: ${value}`)
+   * }
+   * ```
+   */
   *entries() {
     for (const [key, valueAtom] of this.atoms.get()) {
       const value = valueAtom.get();
@@ -140,11 +292,39 @@ class AtomMap {
       yield [key, value];
     }
   }
+  /**
+   * Returns an iterator that yields all keys in the map.
+   * This method is reactive and will cause reactive contexts to update when keys change.
+   *
+   * @returns A generator that yields keys
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('name', 'Alice').set('age', 30)
+   * for (const key of map.keys()) {
+   *   console.log(key) // 'name', 'age'
+   * }
+   * ```
+   */
   *keys() {
     for (const key of this.atoms.get().keys()) {
       yield key;
     }
   }
+  /**
+   * Returns an iterator that yields all values in the map.
+   * This method is reactive and will cause reactive contexts to update when values change.
+   *
+   * @returns A generator that yields values
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('name', 'Alice').set('age', 30)
+   * for (const value of map.values()) {
+   *   console.log(value) // 'Alice', 30
+   * }
+   * ```
+   */
   *values() {
     for (const valueAtom of this.atoms.get().values()) {
       const value = valueAtom.get();
@@ -152,18 +332,78 @@ class AtomMap {
       yield value;
     }
   }
+  /**
+   * The number of key-value pairs in the map.
+   * This property is reactive and will cause reactive contexts to update when the size changes.
+   *
+   * @returns The number of entries in the map
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * console.log(map.size) // 0
+   * map.set('a', 1)
+   * console.log(map.size) // 1
+   * ```
+   */
   // eslint-disable-next-line no-restricted-syntax
   get size() {
     return this.atoms.get().size;
   }
+  /**
+   * Executes a provided function once for each key-value pair in the map.
+   * This method is reactive and will cause reactive contexts to update when entries change.
+   *
+   * @param callbackfn - Function to execute for each entry
+   *   - value - The value of the current entry
+   *   - key - The key of the current entry
+   *   - map - The AtomMap being traversed
+   * @param thisArg - Value to use as `this` when executing the callback
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('a', 1).set('b', 2)
+   * map.forEach((value, key) => {
+   *   console.log(`${key} = ${value}`)
+   * })
+   * ```
+   */
   forEach(callbackfn, thisArg) {
     for (const [key, value] of this.entries()) {
       callbackfn.call(thisArg, value, key, this);
     }
   }
+  /**
+   * Returns the default iterator for the map, which is the same as entries().
+   * This allows the map to be used in for...of loops and other iterable contexts.
+   *
+   * @returns The same iterator as entries()
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * map.set('a', 1).set('b', 2)
+   *
+   * // These are equivalent:
+   * for (const [key, value] of map) {
+   *   console.log(`${key}: ${value}`)
+   * }
+   *
+   * for (const [key, value] of map.entries()) {
+   *   console.log(`${key}: ${value}`)
+   * }
+   * ```
+   */
   [Symbol.iterator]() {
     return this.entries();
   }
+  /**
+   * The string tag used by Object.prototype.toString for this class.
+   *
+   * @example
+   * ```ts
+   * const map = new AtomMap('myMap')
+   * console.log(Object.prototype.toString.call(map)) // '[object AtomMap]'
+   * ```
+   */
   [Symbol.toStringTag] = "AtomMap";
 }
 //# sourceMappingURL=AtomMap.js.map

package/dist-cjs/lib/AtomMap.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/AtomMap.ts"],
-  "sourcesContent": ["import { atom, Atom, transact, UNINITIALIZED } from '@tldraw/state'\nimport { assert } from '@tldraw/utils'\nimport { emptyMap, ImmutableMap } from './ImmutableMap'\n\n/**\n * A drop-in replacement for Map that stores values in atoms and can be used in reactive contexts.\n * @public\n */\nexport class AtomMap<K, V> implements Map<K, V> {\n\tprivate atoms: Atom<ImmutableMap<K, Atom<V | UNINITIALIZED>>>\n\n\tconstructor(\n\t\tprivate readonly name: string,\n\t\tentries?: Iterable<readonly [K, V]>\n\t) {\n\t\tlet atoms = emptyMap<K, Atom<V>>()\n\t\tif (entries) {\n\t\t\tatoms = atoms.withMutations((atoms) => {\n\t\t\t\tfor (const [k, v] of entries) {\n\t\t\t\t\tatoms.set(k, atom(`${name}:${String(k)}`, v))\n\t\t\t\t}\n\t\t\t})\n\t\t}\n\t\tthis.atoms = atom(`${name}:atoms`, atoms)\n\t}\n\n\t/** @internal */\n\tgetAtom(key: K): Atom<V | UNINITIALIZED> | undefined {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) {\n\t\t\t// if the value is missing, we want to track whether it's in the present keys set\n\t\t\tthis.atoms.get()\n\t\t\treturn undefined\n\t\t}\n\t\treturn valueAtom\n\t}\n\n\tget(key: K): V | undefined {\n\t\tconst value = this.getAtom(key)?.get()\n\t\tassert(value !== UNINITIALIZED)\n\t\treturn value\n\t}\n\n\t__unsafe__getWithoutCapture(key: K): V | undefined {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) return undefined\n\t\tconst value = valueAtom.__unsafe__getWithoutCapture()\n\t\tassert(value !== UNINITIALIZED)\n\t\treturn value\n\t}\n\n\thas(key: K): boolean {\n\t\tconst valueAtom = this.getAtom(key)\n\t\tif (!valueAtom) {\n\t\t\treturn false\n\t\t}\n\t\treturn valueAtom.get() !== UNINITIALIZED\n\t}\n\n\t__unsafe__hasWithoutCapture(key: K): boolean {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) return false\n\t\tassert(valueAtom.__unsafe__getWithoutCapture() !== UNINITIALIZED)\n\t\treturn true\n\t}\n\n\tset(key: K, value: V) {\n\t\tconst existingAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (existingAtom) {\n\t\t\texistingAtom.set(value)\n\t\t} else {\n\t\t\tthis.atoms.update((atoms) => {\n\t\t\t\treturn atoms.set(key, atom(`${this.name}:${String(key)}`, value))\n\t\t\t})\n\t\t}\n\t\treturn this\n\t}\n\n\tupdate(key: K, updater: (value: V) => V) {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) {\n\t\t\tthrow new Error(`AtomMap: key ${key} not found`)\n\t\t}\n\t\tconst value = valueAtom.__unsafe__getWithoutCapture()\n\t\tassert(value !== UNINITIALIZED)\n\t\tvalueAtom.set(updater(value))\n\t}\n\n\tdelete(key: K) {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) {\n\t\t\treturn false\n\t\t}\n\n\t\ttransact(() => {\n\t\t\tvalueAtom.set(UNINITIALIZED)\n\t\t\tthis.atoms.update((atoms) => {\n\t\t\t\treturn atoms.delete(key)\n\t\t\t})\n\t\t})\n\t\treturn true\n\t}\n\n\tdeleteMany(keys: Iterable<K>): [K, V][] {\n\t\treturn transact(() => {\n\t\t\tconst deleted: [K, V][] = []\n\t\t\tconst newAtoms = this.atoms.get().withMutations((atoms) => {\n\t\t\t\tfor (const key of keys) {\n\t\t\t\t\tconst valueAtom = atoms.get(key)\n\t\t\t\t\tif (!valueAtom) continue\n\t\t\t\t\tconst oldValue = valueAtom.get()\n\t\t\t\t\tassert(oldValue !== UNINITIALIZED)\n\n\t\t\t\t\tdeleted.push([key, oldValue])\n\n\t\t\t\t\tatoms.delete(key)\n\t\t\t\t\tvalueAtom.set(UNINITIALIZED)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\tif (deleted.length) {\n\t\t\t\tthis.atoms.set(newAtoms)\n\t\t\t}\n\n\t\t\treturn deleted\n\t\t})\n\t}\n\n\tclear() {\n\t\treturn transact(() => {\n\t\t\tfor (const valueAtom of this.atoms.__unsafe__getWithoutCapture().values()) {\n\t\t\t\tvalueAtom.set(UNINITIALIZED)\n\t\t\t}\n\t\t\tthis.atoms.set(emptyMap())\n\t\t})\n\t}\n\n\t*entries(): Generator<[K, V], undefined, unknown> {\n\t\tfor (const [key, valueAtom] of this.atoms.get()) {\n\t\t\tconst value = valueAtom.get()\n\t\t\tassert(value !== UNINITIALIZED)\n\t\t\tyield [key, value]\n\t\t}\n\t}\n\n\t*keys(): Generator<K, undefined, unknown> {\n\t\tfor (const key of this.atoms.get().keys()) {\n\t\t\tyield key\n\t\t}\n\t}\n\n\t*values(): Generator<V, undefined, unknown> {\n\t\tfor (const valueAtom of this.atoms.get().values()) {\n\t\t\tconst value = valueAtom.get()\n\t\t\tassert(value !== UNINITIALIZED)\n\t\t\tyield value\n\t\t}\n\t}\n\n\t// eslint-disable-next-line no-restricted-syntax\n\tget size() {\n\t\treturn this.atoms.get().size\n\t}\n\n\tforEach(callbackfn: (value: V, key: K, map: AtomMap<K, V>) => void, thisArg?: any): void {\n\t\tfor (const [key, value] of this.entries()) {\n\t\t\tcallbackfn.call(thisArg, value, key, this)\n\t\t}\n\t}\n\n\t[Symbol.iterator]() {\n\t\treturn this.entries()\n\t}\n\n\t[Symbol.toStringTag] = 'AtomMap'\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import { atom, Atom, transact, UNINITIALIZED } from '@tldraw/state'\nimport { assert } from '@tldraw/utils'\nimport { emptyMap, ImmutableMap } from './ImmutableMap'\n\n/**\n * A drop-in replacement for Map that stores values in atoms and can be used in reactive contexts.\n * @public\n */\nexport class AtomMap<K, V> implements Map<K, V> {\n\tprivate atoms: Atom<ImmutableMap<K, Atom<V | UNINITIALIZED>>>\n\n\t/**\n\t * Creates a new AtomMap instance.\n\t *\n\t * name - A unique name for this map, used for atom identification\n\t * entries - Optional initial entries to populate the map with\n\t * @example\n\t * ```ts\n\t * // Create an empty map\n\t * const map = new AtomMap('userMap')\n\t *\n\t * // Create a map with initial data\n\t * const initialData: [string, number][] = [['a', 1], ['b', 2]]\n\t * const mapWithData = new AtomMap('numbersMap', initialData)\n\t * ```\n\t */\n\tconstructor(\n\t\tprivate readonly name: string,\n\t\tentries?: Iterable<readonly [K, V]>\n\t) {\n\t\tlet atoms = emptyMap<K, Atom<V>>()\n\t\tif (entries) {\n\t\t\tatoms = atoms.withMutations((atoms) => {\n\t\t\t\tfor (const [k, v] of entries) {\n\t\t\t\t\tatoms.set(k, atom(`${name}:${String(k)}`, v))\n\t\t\t\t}\n\t\t\t})\n\t\t}\n\t\tthis.atoms = atom(`${name}:atoms`, atoms)\n\t}\n\n\t/**\n\t * Retrieves the underlying atom for a given key.\n\t *\n\t * @param key - The key to retrieve the atom for\n\t * @returns The atom containing the value, or undefined if the key doesn't exist\n\t * @internal\n\t */\n\tgetAtom(key: K): Atom<V | UNINITIALIZED> | undefined {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) {\n\t\t\t// if the value is missing, we want to track whether it's in the present keys set\n\t\t\tthis.atoms.get()\n\t\t\treturn undefined\n\t\t}\n\t\treturn valueAtom\n\t}\n\n\t/**\n\t * Gets the value associated with a key. Returns undefined if the key doesn't exist.\n\t * This method is reactive and will cause reactive contexts to update when the value changes.\n\t *\n\t * @param key - The key to retrieve the value for\n\t * @returns The value associated with the key, or undefined if not found\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('name', 'Alice')\n\t * console.log(map.get('name')) // 'Alice'\n\t * console.log(map.get('missing')) // undefined\n\t * ```\n\t */\n\tget(key: K): V | undefined {\n\t\tconst value = this.getAtom(key)?.get()\n\t\tassert(value !== UNINITIALIZED)\n\t\treturn value\n\t}\n\n\t/**\n\t * Gets the value associated with a key without creating reactive dependencies.\n\t * This method will not cause reactive contexts to update when the value changes.\n\t *\n\t * @param key - The key to retrieve the value for\n\t * @returns The value associated with the key, or undefined if not found\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('count', 42)\n\t * const value = map.__unsafe__getWithoutCapture('count') // No reactive subscription\n\t * ```\n\t */\n\t__unsafe__getWithoutCapture(key: K): V | undefined {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) return undefined\n\t\tconst value = valueAtom.__unsafe__getWithoutCapture()\n\t\tassert(value !== UNINITIALIZED)\n\t\treturn value\n\t}\n\n\t/**\n\t * Checks whether a key exists in the map.\n\t * This method is reactive and will cause reactive contexts to update when keys are added or removed.\n\t *\n\t * @param key - The key to check for\n\t * @returns True if the key exists in the map, false otherwise\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * console.log(map.has('name')) // false\n\t * map.set('name', 'Alice')\n\t * console.log(map.has('name')) // true\n\t * ```\n\t */\n\thas(key: K): boolean {\n\t\tconst valueAtom = this.getAtom(key)\n\t\tif (!valueAtom) {\n\t\t\treturn false\n\t\t}\n\t\treturn valueAtom.get() !== UNINITIALIZED\n\t}\n\n\t/**\n\t * Checks whether a key exists in the map without creating reactive dependencies.\n\t * This method will not cause reactive contexts to update when keys are added or removed.\n\t *\n\t * @param key - The key to check for\n\t * @returns True if the key exists in the map, false otherwise\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('active', true)\n\t * const exists = map.__unsafe__hasWithoutCapture('active') // No reactive subscription\n\t * ```\n\t */\n\t__unsafe__hasWithoutCapture(key: K): boolean {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) return false\n\t\tassert(valueAtom.__unsafe__getWithoutCapture() !== UNINITIALIZED)\n\t\treturn true\n\t}\n\n\t/**\n\t * Sets a value for the given key. If the key already exists, its value is updated.\n\t * If the key doesn't exist, a new entry is created.\n\t *\n\t * @param key - The key to set the value for\n\t * @param value - The value to associate with the key\n\t * @returns This AtomMap instance for method chaining\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('name', 'Alice').set('age', 30)\n\t * ```\n\t */\n\tset(key: K, value: V) {\n\t\tconst existingAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (existingAtom) {\n\t\t\texistingAtom.set(value)\n\t\t} else {\n\t\t\tthis.atoms.update((atoms) => {\n\t\t\t\treturn atoms.set(key, atom(`${this.name}:${String(key)}`, value))\n\t\t\t})\n\t\t}\n\t\treturn this\n\t}\n\n\t/**\n\t * Updates an existing value using an updater function.\n\t *\n\t * @param key - The key of the value to update\n\t * @param updater - A function that receives the current value and returns the new value\n\t * @throws Error if the key doesn't exist in the map\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('count', 5)\n\t * map.update('count', count => count + 1) // count is now 6\n\t * ```\n\t */\n\tupdate(key: K, updater: (value: V) => V) {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) {\n\t\t\tthrow new Error(`AtomMap: key ${key} not found`)\n\t\t}\n\t\tconst value = valueAtom.__unsafe__getWithoutCapture()\n\t\tassert(value !== UNINITIALIZED)\n\t\tvalueAtom.set(updater(value))\n\t}\n\n\t/**\n\t * Removes a key-value pair from the map.\n\t *\n\t * @param key - The key to remove\n\t * @returns True if the key existed and was removed, false if it didn't exist\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('temp', 'value')\n\t * console.log(map.delete('temp')) // true\n\t * console.log(map.delete('missing')) // false\n\t * ```\n\t */\n\tdelete(key: K) {\n\t\tconst valueAtom = this.atoms.__unsafe__getWithoutCapture().get(key)\n\t\tif (!valueAtom) {\n\t\t\treturn false\n\t\t}\n\n\t\ttransact(() => {\n\t\t\tvalueAtom.set(UNINITIALIZED)\n\t\t\tthis.atoms.update((atoms) => {\n\t\t\t\treturn atoms.delete(key)\n\t\t\t})\n\t\t})\n\t\treturn true\n\t}\n\n\t/**\n\t * Removes multiple key-value pairs from the map in a single transaction.\n\t *\n\t * @param keys - An iterable of keys to remove\n\t * @returns An array of [key, value] pairs that were actually deleted\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('a', 1).set('b', 2).set('c', 3)\n\t * const deleted = map.deleteMany(['a', 'c', 'missing'])\n\t * console.log(deleted) // [['a', 1], ['c', 3]]\n\t * ```\n\t */\n\tdeleteMany(keys: Iterable<K>): [K, V][] {\n\t\treturn transact(() => {\n\t\t\tconst deleted: [K, V][] = []\n\t\t\tconst newAtoms = this.atoms.get().withMutations((atoms) => {\n\t\t\t\tfor (const key of keys) {\n\t\t\t\t\tconst valueAtom = atoms.get(key)\n\t\t\t\t\tif (!valueAtom) continue\n\t\t\t\t\tconst oldValue = valueAtom.get()\n\t\t\t\t\tassert(oldValue !== UNINITIALIZED)\n\n\t\t\t\t\tdeleted.push([key, oldValue])\n\n\t\t\t\t\tatoms.delete(key)\n\t\t\t\t\tvalueAtom.set(UNINITIALIZED)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\tif (deleted.length) {\n\t\t\t\tthis.atoms.set(newAtoms)\n\t\t\t}\n\n\t\t\treturn deleted\n\t\t})\n\t}\n\n\t/**\n\t * Removes all key-value pairs from the map.\n\t *\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('a', 1).set('b', 2)\n\t * map.clear()\n\t * console.log(map.size) // 0\n\t * ```\n\t */\n\tclear() {\n\t\treturn transact(() => {\n\t\t\tfor (const valueAtom of this.atoms.__unsafe__getWithoutCapture().values()) {\n\t\t\t\tvalueAtom.set(UNINITIALIZED)\n\t\t\t}\n\t\t\tthis.atoms.set(emptyMap())\n\t\t})\n\t}\n\n\t/**\n\t * Returns an iterator that yields [key, value] pairs for each entry in the map.\n\t * This method is reactive and will cause reactive contexts to update when entries change.\n\t *\n\t * @returns A generator that yields [key, value] tuples\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('a', 1).set('b', 2)\n\t * for (const [key, value] of map.entries()) {\n\t *   console.log(`${key}: ${value}`)\n\t * }\n\t * ```\n\t */\n\t*entries(): Generator<[K, V], undefined, unknown> {\n\t\tfor (const [key, valueAtom] of this.atoms.get()) {\n\t\t\tconst value = valueAtom.get()\n\t\t\tassert(value !== UNINITIALIZED)\n\t\t\tyield [key, value]\n\t\t}\n\t}\n\n\t/**\n\t * Returns an iterator that yields all keys in the map.\n\t * This method is reactive and will cause reactive contexts to update when keys change.\n\t *\n\t * @returns A generator that yields keys\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('name', 'Alice').set('age', 30)\n\t * for (const key of map.keys()) {\n\t *   console.log(key) // 'name', 'age'\n\t * }\n\t * ```\n\t */\n\t*keys(): Generator<K, undefined, unknown> {\n\t\tfor (const key of this.atoms.get().keys()) {\n\t\t\tyield key\n\t\t}\n\t}\n\n\t/**\n\t * Returns an iterator that yields all values in the map.\n\t * This method is reactive and will cause reactive contexts to update when values change.\n\t *\n\t * @returns A generator that yields values\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('name', 'Alice').set('age', 30)\n\t * for (const value of map.values()) {\n\t *   console.log(value) // 'Alice', 30\n\t * }\n\t * ```\n\t */\n\t*values(): Generator<V, undefined, unknown> {\n\t\tfor (const valueAtom of this.atoms.get().values()) {\n\t\t\tconst value = valueAtom.get()\n\t\t\tassert(value !== UNINITIALIZED)\n\t\t\tyield value\n\t\t}\n\t}\n\n\t/**\n\t * The number of key-value pairs in the map.\n\t * This property is reactive and will cause reactive contexts to update when the size changes.\n\t *\n\t * @returns The number of entries in the map\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * console.log(map.size) // 0\n\t * map.set('a', 1)\n\t * console.log(map.size) // 1\n\t * ```\n\t */\n\t// eslint-disable-next-line no-restricted-syntax\n\tget size() {\n\t\treturn this.atoms.get().size\n\t}\n\n\t/**\n\t * Executes a provided function once for each key-value pair in the map.\n\t * This method is reactive and will cause reactive contexts to update when entries change.\n\t *\n\t * @param callbackfn - Function to execute for each entry\n\t *   - value - The value of the current entry\n\t *   - key - The key of the current entry\n\t *   - map - The AtomMap being traversed\n\t * @param thisArg - Value to use as `this` when executing the callback\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('a', 1).set('b', 2)\n\t * map.forEach((value, key) => {\n\t *   console.log(`${key} = ${value}`)\n\t * })\n\t * ```\n\t */\n\tforEach(callbackfn: (value: V, key: K, map: AtomMap<K, V>) => void, thisArg?: any): void {\n\t\tfor (const [key, value] of this.entries()) {\n\t\t\tcallbackfn.call(thisArg, value, key, this)\n\t\t}\n\t}\n\n\t/**\n\t * Returns the default iterator for the map, which is the same as entries().\n\t * This allows the map to be used in for...of loops and other iterable contexts.\n\t *\n\t * @returns The same iterator as entries()\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * map.set('a', 1).set('b', 2)\n\t *\n\t * // These are equivalent:\n\t * for (const [key, value] of map) {\n\t *   console.log(`${key}: ${value}`)\n\t * }\n\t *\n\t * for (const [key, value] of map.entries()) {\n\t *   console.log(`${key}: ${value}`)\n\t * }\n\t * ```\n\t */\n\t[Symbol.iterator]() {\n\t\treturn this.entries()\n\t}\n\n\t/**\n\t * The string tag used by Object.prototype.toString for this class.\n\t *\n\t * @example\n\t * ```ts\n\t * const map = new AtomMap('myMap')\n\t * console.log(Object.prototype.toString.call(map)) // '[object AtomMap]'\n\t * ```\n\t */\n\t[Symbol.toStringTag] = 'AtomMap'\n}\n"],
+  "mappings": "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",
   "names": ["atoms"]
 }

package/dist-cjs/lib/BaseRecord.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/BaseRecord.ts"],
-  "sourcesContent": ["/** @public */\nexport type RecordId<R extends UnknownRecord> = string & { __type__: R }\n\n/** @public */\nexport type IdOf<R extends UnknownRecord> = R['id']\n\n/**\n * The base record that all records must extend.\n *\n * @public\n */\nexport interface BaseRecord<TypeName extends string, Id extends RecordId<UnknownRecord>> {\n\treadonly id: Id\n\treadonly typeName: TypeName\n}\n\n/** @public */\nexport type UnknownRecord = BaseRecord<string, RecordId<UnknownRecord>>\n\nexport function isRecord(record: unknown): record is UnknownRecord {\n\treturn typeof record === 'object' && record !== null && 'id' in record && 'typeName' in record\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBO,SAAS,SAAS,QAA0C;AAClE,SAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,QAAQ,UAAU,cAAc;AACzF;",
+  "sourcesContent": ["/**\n * A branded string type that represents a unique identifier for a record.\n * The brand ensures type safety by preventing mixing of IDs between different record types.\n *\n * @example\n * ```ts\n * // Define a Book record\n * interface Book extends BaseRecord<'book', RecordId<Book>> {\n *   title: string\n *   author: string\n * }\n *\n * const bookId: RecordId<Book> = 'book:abc123' as RecordId<Book>\n * const authorId: RecordId<Author> = 'author:xyz789' as RecordId<Author>\n *\n * // TypeScript prevents mixing different record ID types\n * // bookId = authorId // Type error!\n * ```\n *\n * @public\n */\nexport type RecordId<R extends UnknownRecord> = string & { __type__: R }\n\n/**\n * Utility type that extracts the ID type from a record type.\n * This is useful when you need to work with record IDs without having the full record type.\n *\n * @example\n * ```ts\n * interface Book extends BaseRecord<'book', RecordId<Book>> {\n *   title: string\n *   author: string\n * }\n *\n * // Extract the ID type from the Book record\n * type BookId = IdOf<Book> // RecordId<Book>\n *\n * function findBook(id: IdOf<Book>): Book | undefined {\n *   return store.get(id)\n * }\n * ```\n *\n * @public\n */\nexport type IdOf<R extends UnknownRecord> = R['id']\n\n/**\n * The base record interface that all records in the store must extend.\n * This interface provides the fundamental structure required for all records: a unique ID and a type name.\n * The type parameters ensure type safety and prevent mixing of different record types.\n *\n * @example\n * ```ts\n * // Define a Book record that extends BaseRecord\n * interface Book extends BaseRecord<'book', RecordId<Book>> {\n *   title: string\n *   author: string\n *   publishedYear: number\n * }\n *\n * // Define an Author record\n * interface Author extends BaseRecord<'author', RecordId<Author>> {\n *   name: string\n *   birthYear: number\n * }\n *\n * // Usage with RecordType\n * const Book = createRecordType<Book>('book', { scope: 'document' })\n * const book = Book.create({\n *   title: '1984',\n *   author: 'George Orwell',\n *   publishedYear: 1949\n * })\n * // Results in: { id: 'book:abc123', typeName: 'book', title: '1984', ... }\n * ```\n *\n * @public\n */\nexport interface BaseRecord<TypeName extends string, Id extends RecordId<UnknownRecord>> {\n\treadonly id: Id\n\treadonly typeName: TypeName\n}\n\n/**\n * A generic type representing any record that extends BaseRecord.\n * This is useful for type constraints when you need to work with records of unknown types,\n * but still want to ensure they follow the BaseRecord structure.\n *\n * @example\n * ```ts\n * // Function that works with any type of record\n * function logRecord(record: UnknownRecord): void {\n *   console.log(`Record ${record.id} of type ${record.typeName}`)\n * }\n *\n * // Can be used with any record type\n * const book: Book = { id: 'book:123' as RecordId<Book>, typeName: 'book', title: '1984' }\n * const author: Author = { id: 'author:456' as RecordId<Author>, typeName: 'author', name: 'Orwell' }\n *\n * logRecord(book)   // \"Record book:123 of type book\"\n * logRecord(author) // \"Record author:456 of type author\"\n * ```\n *\n * @public\n */\nexport type UnknownRecord = BaseRecord<string, RecordId<UnknownRecord>>\n\n/**\n * Type guard function that checks if an unknown value is a valid record.\n * A valid record must be an object with both `id` and `typeName` properties.\n *\n * @param record - The unknown value to check\n * @returns `true` if the value is a valid UnknownRecord, `false` otherwise\n *\n * @example\n * ```ts\n * const maybeRecord: unknown = { id: 'book:123', typeName: 'book', title: '1984' }\n * const notARecord: unknown = { title: '1984', author: 'Orwell' }\n * const nullValue: unknown = null\n *\n * if (isRecord(maybeRecord)) {\n *   // TypeScript now knows maybeRecord is UnknownRecord\n *   console.log(maybeRecord.id) // 'book:123'\n *   console.log(maybeRecord.typeName) // 'book'\n * }\n *\n * console.log(isRecord(maybeRecord)) // true\n * console.log(isRecord(notARecord))  // false (missing id and typeName)\n * console.log(isRecord(nullValue))   // false\n * ```\n *\n * @public\n */\nexport function isRecord(record: unknown): record is UnknownRecord {\n\treturn typeof record === 'object' && record !== null && 'id' in record && 'typeName' in record\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAqIO,SAAS,SAAS,QAA0C;AAClE,SAAO,OAAO,WAAW,YAAY,WAAW,QAAQ,QAAQ,UAAU,cAAc;AACzF;",
   "names": []
 }

package/dist-cjs/lib/ImmutableMap.js

@@ -173,6 +173,22 @@ class ImmutableMap {
   __hash;
   // @ts-ignore
   __altered;
+  /**
+   * Creates a new ImmutableMap instance.
+   *
+   * @param value - An iterable of key-value pairs to populate the map, or null/undefined for an empty map
+   * @example
+   * ```ts
+   * // Create from array of pairs
+   * const map1 = new ImmutableMap([['a', 1], ['b', 2]])
+   *
+   * // Create empty map
+   * const map2 = new ImmutableMap()
+   *
+   * // Create from another map
+   * const map3 = new ImmutableMap(map1)
+   * ```
+   */
   constructor(value) {
     return value === void 0 || value === null ? emptyMap() : value instanceof ImmutableMap ? value : emptyMap().withMutations((map) => {
       for (const [k, v] of value) {
@@ -180,15 +196,67 @@ class ImmutableMap {
       }
     });
   }
+  /**
+   * Gets the value associated with the specified key, with a fallback value.
+   *
+   * @param k - The key to look up
+   * @param notSetValue - The value to return if the key is not found
+   * @returns The value associated with the key, or the fallback value if not found
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['key1', 'value1']])
+   * console.log(map.get('key1', 'default')) // 'value1'
+   * console.log(map.get('missing', 'default')) // 'default'
+   * ```
+   */
   get(k, notSetValue) {
     return this._root ? this._root.get(0, void 0, k, notSetValue) : notSetValue;
   }
+  /**
+   * Returns a new ImmutableMap with the specified key-value pair added or updated.
+   * If the key already exists, its value is replaced. Otherwise, a new entry is created.
+   *
+   * @param k - The key to set
+   * @param v - The value to associate with the key
+   * @returns A new ImmutableMap with the key-value pair set
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1]])
+   * const updated = map.set('b', 2) // New map with both 'a' and 'b'
+   * const replaced = map.set('a', 10) // New map with 'a' updated to 10
+   * ```
+   */
   set(k, v) {
     return updateMap(this, k, v);
   }
+  /**
+   * Returns a new ImmutableMap with the specified key removed.
+   * If the key doesn't exist, returns the same map instance.
+   *
+   * @param k - The key to remove
+   * @returns A new ImmutableMap with the key removed, or the same instance if key not found
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1], ['b', 2]])
+   * const smaller = map.delete('a') // New map with only 'b'
+   * const same = map.delete('missing') // Returns original map
+   * ```
+   */
   delete(k) {
     return updateMap(this, k, NOT_SET);
   }
+  /**
+   * Returns a new ImmutableMap with all specified keys removed.
+   * This is more efficient than calling delete() multiple times.
+   *
+   * @param keys - An iterable of keys to remove
+   * @returns A new ImmutableMap with all specified keys removed
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1], ['b', 2], ['c', 3]])
+   * const smaller = map.deleteAll(['a', 'c']) // New map with only 'b'
+   * ```
+   */
   deleteAll(keys) {
     return this.withMutations((map) => {
       for (const key of keys) {
@@ -210,26 +278,99 @@ class ImmutableMap {
     }
     return makeMap(this.size, this._root, ownerID, this.__hash);
   }
+  /**
+   * Applies multiple mutations efficiently by creating a mutable copy,
+   * applying all changes, then returning an immutable result.
+   * This is more efficient than chaining multiple set/delete operations.
+   *
+   * @param fn - Function that receives a mutable copy and applies changes
+   * @returns A new ImmutableMap with all mutations applied, or the same instance if no changes
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1]])
+   * const updated = map.withMutations(mutable => {
+   *   mutable.set('b', 2)
+   *   mutable.set('c', 3)
+   *   mutable.delete('a')
+   * }) // Efficiently applies all changes at once
+   * ```
+   */
   withMutations(fn) {
     const mutable = this.asMutable();
     fn(mutable);
     return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
   }
+  /**
+   * Checks if this map instance has been altered during a mutation operation.
+   * This is used internally to optimize mutations.
+   *
+   * @returns True if the map was altered, false otherwise
+   * @internal
+   */
   wasAltered() {
     return this.__altered;
   }
+  /**
+   * Returns a mutable copy of this map that can be efficiently modified.
+   * Multiple changes to the mutable copy are batched together.
+   *
+   * @returns A mutable copy of this map
+   * @internal
+   */
   asMutable() {
     return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
   }
+  /**
+   * Makes the map iterable, yielding key-value pairs.
+   *
+   * @returns An iterator over [key, value] pairs
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1], ['b', 2]])
+   * for (const [key, value] of map) {
+   *   console.log(key, value) // 'a' 1, then 'b' 2
+   * }
+   * ```
+   */
   [Symbol.iterator]() {
     return this.entries()[Symbol.iterator]();
   }
+  /**
+   * Returns an iterable of key-value pairs.
+   *
+   * @returns An iterable over [key, value] pairs
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1], ['b', 2]])
+   * const entries = Array.from(map.entries()) // [['a', 1], ['b', 2]]
+   * ```
+   */
   entries() {
     return new MapIterator(this, ITERATE_ENTRIES, false);
   }
+  /**
+   * Returns an iterable of keys.
+   *
+   * @returns An iterable over keys
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1], ['b', 2]])
+   * const keys = Array.from(map.keys()) // ['a', 'b']
+   * ```
+   */
   keys() {
     return new MapIterator(this, ITERATE_KEYS, false);
   }
+  /**
+   * Returns an iterable of values.
+   *
+   * @returns An iterable over values
+   * @example
+   * ```ts
+   * const map = new ImmutableMap([['a', 1], ['b', 2]])
+   * const values = Array.from(map.values()) // [1, 2]
+   * ```
+   */
   values() {
     return new MapIterator(this, ITERATE_VALUES, false);
   }