@ibodr/state 0.0.0

package/dist/index.mjs

@@ -0,0 +1,1311 @@
+import { registerDrawLibraryVersion, getFromLocalStorage, deleteFromLocalStorage, setInLocalStorage, assert } from '@ibodr/utils';
+
+// src/index.ts
+
+// src/lib/helpers.ts
+function isChild(x) {
+  return x && typeof x === "object" && "parents" in x;
+}
+function haveParentsChanged(child) {
+  for (let i = 0, n = child.parents.length; i < n; i++) {
+    child.parents[i].__unsafe__getWithoutCapture(true);
+    if (child.parents[i].lastChangedEpoch !== child.parentEpochs[i]) {
+      return true;
+    }
+  }
+  return false;
+}
+function detach(parent, child) {
+  if (!parent.children.remove(child)) {
+    return;
+  }
+  if (parent.children.isEmpty && isChild(parent)) {
+    for (let i = 0, n = parent.parents.length; i < n; i++) {
+      detach(parent.parents[i], parent);
+    }
+  }
+}
+function attach(parent, child) {
+  if (!parent.children.add(child)) {
+    return;
+  }
+  if (isChild(parent)) {
+    for (let i = 0, n = parent.parents.length; i < n; i++) {
+      attach(parent.parents[i], parent);
+    }
+  }
+}
+function equals(a, b) {
+  const shallowEquals = a === b || Object.is(a, b) || Boolean(a && b && typeof a.equals === "function" && a.equals(b));
+  return shallowEquals;
+}
+function singleton(key, init) {
+  const symbol = /* @__PURE__ */ Symbol.for(`com.draw.state/${key}`);
+  const global = globalThis;
+  global[symbol] ??= init();
+  return global[symbol];
+}
+var EMPTY_ARRAY = singleton("empty_array", () => Object.freeze([]));
+
+// src/lib/ArraySet.ts
+var ARRAY_SIZE_THRESHOLD = 8;
+var ArraySet = class {
+  arraySize = 0;
+  array = Array(ARRAY_SIZE_THRESHOLD);
+  set = null;
+  /**
+   * Get whether this ArraySet has any elements.
+   *
+   * @returns True if this ArraySet has any elements, false otherwise.
+   */
+  // eslint-disable-next-line tldraw/no-setter-getter
+  get isEmpty() {
+    if (this.array) {
+      return this.arraySize === 0;
+    }
+    if (this.set) {
+      return this.set.size === 0;
+    }
+    throw new Error("no set or array");
+  }
+  /**
+   * Add an element to the ArraySet if it is not already present.
+   *
+   * @param elem - The element to add to the set
+   * @returns `true` if the element was added, `false` if it was already present
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<string>()
+   *
+   * console.log(arraySet.add('hello')) // true
+   * console.log(arraySet.add('hello')) // false (already exists)
+   * ```
+   */
+  add(elem) {
+    if (this.array) {
+      const idx = this.array.indexOf(elem);
+      if (idx !== -1) {
+        return false;
+      }
+      if (this.arraySize < ARRAY_SIZE_THRESHOLD) {
+        this.array[this.arraySize] = elem;
+        this.arraySize++;
+        return true;
+      } else {
+        this.set = new Set(this.array);
+        this.array = null;
+        this.set.add(elem);
+        return true;
+      }
+    }
+    if (this.set) {
+      if (this.set.has(elem)) {
+        return false;
+      }
+      this.set.add(elem);
+      return true;
+    }
+    throw new Error("no set or array");
+  }
+  /**
+   * Remove an element from the ArraySet if it is present.
+   *
+   * @param elem - The element to remove from the set
+   * @returns `true` if the element was removed, `false` if it was not present
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<string>()
+   * arraySet.add('hello')
+   *
+   * console.log(arraySet.remove('hello')) // true
+   * console.log(arraySet.remove('hello')) // false (not present)
+   * ```
+   */
+  remove(elem) {
+    if (this.array) {
+      const idx = this.array.indexOf(elem);
+      if (idx === -1) {
+        return false;
+      }
+      this.array[idx] = void 0;
+      this.arraySize--;
+      if (idx !== this.arraySize) {
+        this.array[idx] = this.array[this.arraySize];
+        this.array[this.arraySize] = void 0;
+      }
+      return true;
+    }
+    if (this.set) {
+      if (!this.set.has(elem)) {
+        return false;
+      }
+      this.set.delete(elem);
+      return true;
+    }
+    throw new Error("no set or array");
+  }
+  /**
+   * Execute a callback function for each element in the ArraySet.
+   *
+   * @param visitor - A function to call for each element in the set
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<string>()
+   * arraySet.add('hello')
+   * arraySet.add('world')
+   *
+   * arraySet.visit((item) => {
+   *   console.log(item) // 'hello', 'world'
+   * })
+   * ```
+   */
+  visit(visitor) {
+    if (this.array) {
+      for (let i = 0; i < this.arraySize; i++) {
+        const elem = this.array[i];
+        if (typeof elem !== "undefined") {
+          visitor(elem);
+        }
+      }
+      return;
+    }
+    if (this.set) {
+      this.set.forEach(visitor);
+      return;
+    }
+    throw new Error("no set or array");
+  }
+  /**
+   * Make the ArraySet iterable, allowing it to be used in for...of loops and with spread syntax.
+   *
+   * @returns An iterator that yields each element in the set
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<number>()
+   * arraySet.add(1)
+   * arraySet.add(2)
+   *
+   * for (const item of arraySet) {
+   *   console.log(item) // 1, 2
+   * }
+   *
+   * const items = [...arraySet] // [1, 2]
+   * ```
+   */
+  *[Symbol.iterator]() {
+    if (this.array) {
+      for (let i = 0; i < this.arraySize; i++) {
+        const elem = this.array[i];
+        if (typeof elem !== "undefined") {
+          yield elem;
+        }
+      }
+    } else if (this.set) {
+      yield* this.set;
+    } else {
+      throw new Error("no set or array");
+    }
+  }
+  /**
+   * Check whether an element is present in the ArraySet.
+   *
+   * @param elem - The element to check for
+   * @returns `true` if the element is present, `false` otherwise
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<string>()
+   * arraySet.add('hello')
+   *
+   * console.log(arraySet.has('hello')) // true
+   * console.log(arraySet.has('world')) // false
+   * ```
+   */
+  has(elem) {
+    if (this.array) {
+      return this.array.indexOf(elem) !== -1;
+    } else {
+      return this.set.has(elem);
+    }
+  }
+  /**
+   * Remove all elements from the ArraySet.
+   *
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<string>()
+   * arraySet.add('hello')
+   * arraySet.add('world')
+   *
+   * arraySet.clear()
+   * console.log(arraySet.size()) // 0
+   * ```
+   */
+  clear() {
+    if (this.set) {
+      this.set.clear();
+    } else {
+      this.arraySize = 0;
+      this.array = [];
+    }
+  }
+  /**
+   * Get the number of elements in the ArraySet.
+   *
+   * @returns The number of elements in the set
+   * @example
+   * ```ts
+   * const arraySet = new ArraySet<string>()
+   * console.log(arraySet.size()) // 0
+   *
+   * arraySet.add('hello')
+   * console.log(arraySet.size()) // 1
+   * ```
+   */
+  size() {
+    if (this.set) {
+      return this.set.size;
+    } else {
+      return this.arraySize;
+    }
+  }
+};
+
+// src/lib/isComputed.ts
+function isComputed(value) {
+  return !!(value && value.__isComputed === true);
+}
+
+// src/lib/capture.ts
+var CaptureStackFrame = class {
+  constructor(below, child) {
+    this.below = below;
+    this.child = child;
+  }
+  below;
+  child;
+  offset = 0;
+  maybeRemoved;
+};
+var inst = singleton("capture", () => ({ stack: null }));
+function unsafe__withoutCapture(fn) {
+  const oldStack = inst.stack;
+  inst.stack = null;
+  try {
+    return fn();
+  } finally {
+    inst.stack = oldStack;
+  }
+}
+function startCapturingParents(child) {
+  inst.stack = new CaptureStackFrame(inst.stack, child);
+  if (child.__debug_ancestor_epochs__) {
+    const previousAncestorEpochs = child.__debug_ancestor_epochs__;
+    child.__debug_ancestor_epochs__ = null;
+    for (const p of child.parents) {
+      p.__unsafe__getWithoutCapture(true);
+    }
+    logChangedAncestors(child, previousAncestorEpochs);
+  }
+  child.parentSet.clear();
+}
+function stopCapturingParents() {
+  const frame = inst.stack;
+  inst.stack = frame.below;
+  if (frame.offset < frame.child.parents.length) {
+    for (let i = frame.offset; i < frame.child.parents.length; i++) {
+      const maybeRemovedParent = frame.child.parents[i];
+      if (!frame.child.parentSet.has(maybeRemovedParent)) {
+        detach(maybeRemovedParent, frame.child);
+      }
+    }
+    frame.child.parents.length = frame.offset;
+    frame.child.parentEpochs.length = frame.offset;
+  }
+  if (frame.maybeRemoved) {
+    for (let i = 0; i < frame.maybeRemoved.length; i++) {
+      const maybeRemovedParent = frame.maybeRemoved[i];
+      if (!frame.child.parentSet.has(maybeRemovedParent)) {
+        detach(maybeRemovedParent, frame.child);
+      }
+    }
+  }
+  if (frame.child.__debug_ancestor_epochs__) {
+    captureAncestorEpochs(frame.child, frame.child.__debug_ancestor_epochs__);
+  }
+}
+function maybeCaptureParent(p) {
+  if (inst.stack) {
+    const wasCapturedAlready = inst.stack.child.parentSet.has(p);
+    if (wasCapturedAlready) {
+      return;
+    }
+    inst.stack.child.parentSet.add(p);
+    if (inst.stack.child.isActivelyListening) {
+      attach(p, inst.stack.child);
+    }
+    if (inst.stack.offset < inst.stack.child.parents.length) {
+      const maybeRemovedParent = inst.stack.child.parents[inst.stack.offset];
+      if (maybeRemovedParent !== p) {
+        if (!inst.stack.maybeRemoved) {
+          inst.stack.maybeRemoved = [maybeRemovedParent];
+        } else {
+          inst.stack.maybeRemoved.push(maybeRemovedParent);
+        }
+      }
+    }
+    inst.stack.child.parents[inst.stack.offset] = p;
+    inst.stack.child.parentEpochs[inst.stack.offset] = p.lastChangedEpoch;
+    inst.stack.offset++;
+  }
+}
+function whyAmIRunning() {
+  const child = inst.stack?.child;
+  if (!child) {
+    throw new Error("whyAmIRunning() called outside of a reactive context");
+  }
+  child.__debug_ancestor_epochs__ = /* @__PURE__ */ new Map();
+}
+function captureAncestorEpochs(child, ancestorEpochs) {
+  for (let i = 0; i < child.parents.length; i++) {
+    const parent = child.parents[i];
+    const epoch = child.parentEpochs[i];
+    ancestorEpochs.set(parent, epoch);
+    if (isComputed(parent)) {
+      captureAncestorEpochs(parent, ancestorEpochs);
+    }
+  }
+  return ancestorEpochs;
+}
+function collectChangedAncestors(child, ancestorEpochs) {
+  const changeTree = {};
+  for (let i = 0; i < child.parents.length; i++) {
+    const parent = child.parents[i];
+    if (!ancestorEpochs.has(parent)) {
+      continue;
+    }
+    const prevEpoch = ancestorEpochs.get(parent);
+    const currentEpoch = parent.lastChangedEpoch;
+    if (currentEpoch !== prevEpoch) {
+      if (isComputed(parent)) {
+        changeTree[parent.name] = collectChangedAncestors(parent, ancestorEpochs);
+      } else {
+        changeTree[parent.name] = null;
+      }
+    }
+  }
+  return changeTree;
+}
+function logChangedAncestors(child, ancestorEpochs) {
+  const changeTree = collectChangedAncestors(child, ancestorEpochs);
+  if (Object.keys(changeTree).length === 0) {
+    console.log(`Effect(${child.name}) was executed manually.`);
+    return;
+  }
+  let str = isComputed(child) ? `Computed(${child.name}) is recomputing because:` : `Effect(${child.name}) is executing because:`;
+  function logParent(tree, indent) {
+    const indentStr = "\n" + " ".repeat(indent) + "\u21B3 ";
+    for (const [name, val] of Object.entries(tree)) {
+      if (val) {
+        str += `${indentStr}Computed(${name}) changed`;
+        logParent(val, indent + 2);
+      } else {
+        str += `${indentStr}Atom(${name}) changed`;
+      }
+    }
+  }
+  logParent(changeTree, 1);
+  console.log(str);
+}
+
+// src/lib/types.ts
+var RESET_VALUE = /* @__PURE__ */ Symbol.for("com.draw.state/RESET_VALUE");
+
+// src/lib/HistoryBuffer.ts
+var HistoryBuffer = class {
+  /**
+   * Creates a new HistoryBuffer with the specified capacity.
+   *
+   * capacity - Maximum number of diffs to store in the buffer
+   * @example
+   * ```ts
+   * const buffer = new HistoryBuffer<number>(10) // Store up to 10 diffs
+   * ```
+   */
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  capacity;
+  /**
+   * Current write position in the circular buffer.
+   * @internal
+   */
+  index = 0;
+  /**
+   * Circular buffer storing range tuples. Uses undefined to represent empty slots.
+   * @internal
+   */
+  buffer;
+  /**
+   * Adds a diff entry to the history buffer, representing a change between two epochs.
+   *
+   * If the diff is undefined, the operation is ignored. If the diff is RESET_VALUE,
+   * the entire buffer is cleared to indicate that historical tracking should restart.
+   *
+   * @param lastComputedEpoch - The epoch when the previous value was computed
+   * @param currentEpoch - The epoch when the current value was computed
+   * @param diff - The diff representing the change, or RESET_VALUE to clear history
+   * @example
+   * ```ts
+   * const buffer = new HistoryBuffer<string>(5)
+   * buffer.pushEntry(0, 1, 'added text')
+   * buffer.pushEntry(1, 2, RESET_VALUE) // Clears the buffer
+   * ```
+   */
+  pushEntry(lastComputedEpoch, currentEpoch, diff) {
+    if (diff === void 0) {
+      return;
+    }
+    if (diff === RESET_VALUE) {
+      this.clear();
+      return;
+    }
+    this.buffer[this.index] = [lastComputedEpoch, currentEpoch, diff];
+    this.index = (this.index + 1) % this.capacity;
+  }
+  /**
+   * Clears all entries from the history buffer and resets the write position.
+   * This is called when a RESET_VALUE diff is encountered.
+   *
+   * @example
+   * ```ts
+   * const buffer = new HistoryBuffer<string>(5)
+   * buffer.pushEntry(0, 1, 'change')
+   * buffer.clear()
+   * console.log(buffer.getChangesSince(0)) // RESET_VALUE
+   * ```
+   */
+  clear() {
+    this.index = 0;
+    this.buffer.fill(void 0);
+  }
+  /**
+   * Retrieves all diffs that occurred since the specified epoch.
+   *
+   * The method searches backwards through the circular buffer to find changes
+   * that occurred after the given epoch. If insufficient history is available
+   * or the requested epoch is too old, returns RESET_VALUE indicating that
+   * a complete state rebuild is required.
+   *
+   * @param sinceEpoch - The epoch from which to retrieve changes
+   * @returns Array of diffs since the epoch, or RESET_VALUE if history is insufficient
+   * @example
+   * ```ts
+   * const buffer = new HistoryBuffer<string>(5)
+   * buffer.pushEntry(0, 1, 'first')
+   * buffer.pushEntry(1, 2, 'second')
+   * const changes = buffer.getChangesSince(0) // ['first', 'second']
+   * const recentChanges = buffer.getChangesSince(1) // ['second']
+   * const tooOld = buffer.getChangesSince(-100) // RESET_VALUE
+   * ```
+   */
+  getChangesSince(sinceEpoch) {
+    const { index, capacity, buffer } = this;
+    for (let i = 0; i < capacity; i++) {
+      const offset = (index - 1 + capacity - i) % capacity;
+      const elem = buffer[offset];
+      if (!elem) {
+        return RESET_VALUE;
+      }
+      const [fromEpoch, toEpoch] = elem;
+      if (i === 0 && sinceEpoch >= toEpoch) {
+        return [];
+      }
+      if (fromEpoch <= sinceEpoch && sinceEpoch < toEpoch) {
+        const len = i + 1;
+        const result = new Array(len);
+        for (let j = 0; j < len; j++) {
+          result[j] = buffer[(offset + j) % capacity][2];
+        }
+        return result;
+      }
+    }
+    return RESET_VALUE;
+  }
+};
+
+// src/lib/constants.ts
+var GLOBAL_START_EPOCH = -1;
+
+// src/lib/transactions.ts
+var Transaction = class {
+  constructor(parent, isSync) {
+    this.parent = parent;
+    this.isSync = isSync;
+  }
+  parent;
+  isSync;
+  asyncProcessCount = 0;
+  initialAtomValues = /* @__PURE__ */ new Map();
+  /**
+   * Get whether this transaction is a root (no parents).
+   *
+   * @public
+   */
+  // eslint-disable-next-line tldraw/no-setter-getter
+  get isRoot() {
+    return this.parent === null;
+  }
+  /**
+   * Commit the transaction's changes.
+   *
+   * @public
+   */
+  commit() {
+    if (inst2.globalIsReacting) {
+      for (const atom2 of this.initialAtomValues.keys()) {
+        traverseAtomForCleanup(atom2);
+      }
+    } else if (this.isRoot) {
+      flushChanges(this.initialAtomValues.keys());
+    } else {
+      this.initialAtomValues.forEach((value, atom2) => {
+        if (!this.parent.initialAtomValues.has(atom2)) {
+          this.parent.initialAtomValues.set(atom2, value);
+        }
+      });
+    }
+  }
+  /**
+   * Abort the transaction.
+   *
+   * @public
+   */
+  abort() {
+    inst2.globalEpoch++;
+    this.initialAtomValues.forEach((value, atom2) => {
+      atom2.set(value);
+      atom2.historyBuffer?.clear();
+    });
+    this.commit();
+  }
+};
+var inst2 = singleton("transactions", () => ({
+  // The current epoch (global to all atoms).
+  globalEpoch: GLOBAL_START_EPOCH + 1,
+  // Whether any transaction is reacting.
+  globalIsReacting: false,
+  currentTransaction: null,
+  cleanupReactors: null,
+  reactionEpoch: GLOBAL_START_EPOCH + 1
+}));
+function getReactionEpoch() {
+  return inst2.reactionEpoch;
+}
+function getGlobalEpoch() {
+  return inst2.globalEpoch;
+}
+function getIsReacting() {
+  return inst2.globalIsReacting;
+}
+var traverseReactors;
+function traverseChild(child) {
+  if (child.lastTraversedEpoch === inst2.globalEpoch) {
+    return;
+  }
+  child.lastTraversedEpoch = inst2.globalEpoch;
+  if ("__isEffectScheduler" in child) {
+    traverseReactors.add(child);
+  } else {
+    child.children.visit(traverseChild);
+  }
+}
+function traverse(reactors, child) {
+  traverseReactors = reactors;
+  traverseChild(child);
+}
+function flushChanges(atoms) {
+  if (inst2.globalIsReacting) {
+    throw new Error("flushChanges cannot be called during a reaction");
+  }
+  const outerTxn = inst2.currentTransaction;
+  try {
+    inst2.currentTransaction = null;
+    inst2.globalIsReacting = true;
+    inst2.reactionEpoch = inst2.globalEpoch;
+    const reactors = /* @__PURE__ */ new Set();
+    for (const atom2 of atoms) {
+      atom2.children.visit((child) => traverse(reactors, child));
+    }
+    for (const r of reactors) {
+      r.maybeScheduleEffect();
+    }
+    let updateDepth = 0;
+    while (inst2.cleanupReactors?.size) {
+      if (updateDepth++ > 1e3) {
+        throw new Error("Reaction update depth limit exceeded");
+      }
+      const reactors2 = inst2.cleanupReactors;
+      inst2.cleanupReactors = null;
+      for (const r of reactors2) {
+        r.maybeScheduleEffect();
+      }
+    }
+  } finally {
+    inst2.cleanupReactors = null;
+    inst2.globalIsReacting = false;
+    inst2.currentTransaction = outerTxn;
+    traverseReactors = void 0;
+  }
+}
+function atomDidChange(atom2, previousValue) {
+  if (inst2.currentTransaction) {
+    if (!inst2.currentTransaction.initialAtomValues.has(atom2)) {
+      inst2.currentTransaction.initialAtomValues.set(atom2, previousValue);
+    }
+  } else if (inst2.globalIsReacting) {
+    traverseAtomForCleanup(atom2);
+  } else {
+    flushChanges([atom2]);
+  }
+}
+function traverseAtomForCleanup(atom2) {
+  const rs = inst2.cleanupReactors ??= /* @__PURE__ */ new Set();
+  atom2.children.visit((child) => traverse(rs, child));
+}
+function advanceGlobalEpoch() {
+  inst2.globalEpoch++;
+}
+function transaction(fn) {
+  const txn = new Transaction(inst2.currentTransaction, true);
+  inst2.currentTransaction = txn;
+  try {
+    let result = void 0;
+    let rollback = false;
+    try {
+      result = fn(() => rollback = true);
+    } catch (e) {
+      txn.abort();
+      throw e;
+    }
+    if (inst2.currentTransaction !== txn) {
+      throw new Error("Transaction boundaries overlap");
+    }
+    if (rollback) {
+      txn.abort();
+    } else {
+      txn.commit();
+    }
+    return result;
+  } finally {
+    inst2.currentTransaction = txn.parent;
+  }
+}
+function transact(fn) {
+  if (inst2.currentTransaction) {
+    return fn();
+  }
+  return transaction(fn);
+}
+async function deferAsyncEffects(fn) {
+  if (inst2.currentTransaction?.isSync) {
+    throw new Error("deferAsyncEffects cannot be called during a sync transaction");
+  }
+  while (inst2.globalIsReacting) {
+    await new Promise((r) => queueMicrotask(() => r(null)));
+  }
+  const txn = inst2.currentTransaction ?? new Transaction(null, false);
+  if (txn.isSync) throw new Error("deferAsyncEffects cannot be called during a sync transaction");
+  inst2.currentTransaction = txn;
+  txn.asyncProcessCount++;
+  let result = void 0;
+  let error = void 0;
+  try {
+    result = await fn();
+  } catch (e) {
+    error = e ?? null;
+  }
+  if (--txn.asyncProcessCount > 0) {
+    if (typeof error !== "undefined") {
+      throw error;
+    } else {
+      return result;
+    }
+  }
+  inst2.currentTransaction = null;
+  if (typeof error !== "undefined") {
+    txn.abort();
+    throw error;
+  } else {
+    txn.commit();
+    return result;
+  }
+}
+
+// src/lib/Atom.ts
+var __Atom__ = class {
+  constructor(name, current, options) {
+    this.name = name;
+    this.current = current;
+    this.isEqual = options?.isEqual ?? null;
+    if (!options) return;
+    if (options.historyLength) {
+      this.historyBuffer = new HistoryBuffer(options.historyLength);
+    }
+    this.computeDiff = options.computeDiff;
+  }
+  name;
+  current;
+  /**
+   * Custom equality function for comparing values, or null to use default equality.
+   * @internal
+   */
+  isEqual;
+  /**
+   * Optional function to compute diffs between old and new values.
+   * @internal
+   */
+  computeDiff;
+  /**
+   * The global epoch when this atom was last changed.
+   * @internal
+   */
+  lastChangedEpoch = getGlobalEpoch();
+  /**
+   * Set of child signals that depend on this atom.
+   * @internal
+   */
+  children = new ArraySet();
+  /**
+   * Optional history buffer for tracking changes over time.
+   * @internal
+   */
+  historyBuffer;
+  /**
+   * Gets the current value without capturing it as a dependency in the current reactive context.
+   * This is unsafe because it breaks the reactivity chain - use with caution.
+   *
+   * @param _ignoreErrors - Unused parameter for API compatibility
+   * @returns The current value
+   * @internal
+   */
+  __unsafe__getWithoutCapture(_ignoreErrors) {
+    return this.current;
+  }
+  /**
+   * Gets the current value of this atom. When called within a computed signal or reaction,
+   * this atom will be automatically captured as a dependency.
+   *
+   * @returns The current value
+   * @example
+   * ```ts
+   * const count = atom('count', 5)
+   * console.log(count.get()) // 5
+   * ```
+   */
+  get() {
+    maybeCaptureParent(this);
+    return this.current;
+  }
+  /**
+   * Sets the value of this atom to the given value. If the value is the same as the current value, this is a no-op.
+   *
+   * @param value - The new value to set
+   * @param diff - The diff to use for the update. If not provided, the diff will be computed using {@link AtomOptions.computeDiff}
+   * @returns The new value
+   * @example
+   * ```ts
+   * const count = atom('count', 0)
+   * count.set(5) // count.get() is now 5
+   * ```
+   */
+  set(value, diff) {
+    if (this.isEqual?.(this.current, value) ?? equals(this.current, value)) {
+      return this.current;
+    }
+    advanceGlobalEpoch();
+    if (this.historyBuffer) {
+      this.historyBuffer.pushEntry(
+        this.lastChangedEpoch,
+        getGlobalEpoch(),
+        diff ?? this.computeDiff?.(this.current, value, this.lastChangedEpoch, getGlobalEpoch()) ?? RESET_VALUE
+      );
+    }
+    this.lastChangedEpoch = getGlobalEpoch();
+    const oldValue = this.current;
+    this.current = value;
+    atomDidChange(this, oldValue);
+    return value;
+  }
+  /**
+   * Updates the value of this atom using the given updater function. If the returned value is the same as the current value, this is a no-op.
+   *
+   * @param updater - A function that takes the current value and returns the new value
+   * @returns The new value
+   * @example
+   * ```ts
+   * const count = atom('count', 5)
+   * count.update(n => n + 1) // count.get() is now 6
+   * ```
+   */
+  update(updater) {
+    return this.set(updater(this.current));
+  }
+  /**
+   * Gets all the diffs that have occurred since the given epoch. When called within a computed
+   * signal or reaction, this atom will be automatically captured as a dependency.
+   *
+   * @param epoch - The epoch to get changes since
+   * @returns An array of diffs, or RESET_VALUE if history is insufficient
+   * @internal
+   */
+  getDiffSince(epoch) {
+    maybeCaptureParent(this);
+    if (epoch >= this.lastChangedEpoch) {
+      return EMPTY_ARRAY;
+    }
+    return this.historyBuffer?.getChangesSince(epoch) ?? RESET_VALUE;
+  }
+};
+var _Atom = singleton("Atom", () => __Atom__);
+function atom(name, initialValue, options) {
+  return new _Atom(name, initialValue, options);
+}
+function isAtom(value) {
+  return value instanceof _Atom;
+}
+
+// src/lib/warnings.ts
+var didWarnComputedGetter = false;
+function logComputedGetterWarning() {
+  if (didWarnComputedGetter) return;
+  didWarnComputedGetter = true;
+  console.warn(
+    `Using \`@computed\` as a decorator for getters is deprecated and will be removed in the near future. Please refactor to use \`@computed\` as a decorator for methods.
+
+// Before
+@computed
+get foo() {
+	return 'foo'
+}
+
+// After
+@computed
+getFoo() {
+	return 'foo'
+}
+`
+  );
+}
+
+// src/lib/Computed.ts
+var UNINITIALIZED = /* @__PURE__ */ Symbol.for("com.draw.state/UNINITIALIZED");
+function isUninitialized(value) {
+  return value === UNINITIALIZED;
+}
+var WithDiff = singleton(
+  "WithDiff",
+  () => class WithDiff {
+    constructor(value, diff) {
+      this.value = value;
+      this.diff = diff;
+    }
+    value;
+    diff;
+  }
+);
+function withDiff(value, diff) {
+  return new WithDiff(value, diff);
+}
+var __UNSAFE__Computed = class {
+  constructor(name, derive, options) {
+    this.name = name;
+    this.derive = derive;
+    if (options?.historyLength) {
+      this.historyBuffer = new HistoryBuffer(options.historyLength);
+    }
+    this.computeDiff = options?.computeDiff;
+    this.isEqual = options?.isEqual ?? equals;
+  }
+  name;
+  derive;
+  __isComputed = true;
+  lastChangedEpoch = GLOBAL_START_EPOCH;
+  lastTraversedEpoch = GLOBAL_START_EPOCH;
+  __debug_ancestor_epochs__ = null;
+  /**
+   * The epoch when the reactor was last checked.
+   */
+  lastCheckedEpoch = GLOBAL_START_EPOCH;
+  parentSet = new ArraySet();
+  parents = [];
+  parentEpochs = [];
+  children = new ArraySet();
+  // eslint-disable-next-line tldraw/no-setter-getter
+  get isActivelyListening() {
+    return !this.children.isEmpty;
+  }
+  historyBuffer;
+  // The last-computed value of this signal.
+  state = UNINITIALIZED;
+  // If the signal throws an error we stash it so we can rethrow it on the next get()
+  error = null;
+  computeDiff;
+  isEqual;
+  __unsafe__getWithoutCapture(ignoreErrors) {
+    const isNew = this.lastChangedEpoch === GLOBAL_START_EPOCH;
+    const globalEpoch = getGlobalEpoch();
+    if (!isNew && (this.lastCheckedEpoch === globalEpoch || this.isActivelyListening && getIsReacting() && this.lastTraversedEpoch < getReactionEpoch() || !haveParentsChanged(this))) {
+      this.lastCheckedEpoch = globalEpoch;
+      if (this.error) {
+        if (!ignoreErrors) {
+          throw this.error.thrownValue;
+        } else {
+          return this.state;
+        }
+      } else {
+        return this.state;
+      }
+    }
+    try {
+      startCapturingParents(this);
+      const result = this.derive(this.state, this.lastCheckedEpoch);
+      const newState = result instanceof WithDiff ? result.value : result;
+      const isUninitialized2 = this.state === UNINITIALIZED;
+      if (isUninitialized2 || !this.isEqual(newState, this.state)) {
+        if (this.historyBuffer && !isUninitialized2) {
+          const diff = result instanceof WithDiff ? result.diff : void 0;
+          this.historyBuffer.pushEntry(
+            this.lastChangedEpoch,
+            getGlobalEpoch(),
+            diff ?? this.computeDiff?.(this.state, newState, this.lastCheckedEpoch, getGlobalEpoch()) ?? RESET_VALUE
+          );
+        }
+        this.lastChangedEpoch = getGlobalEpoch();
+        this.state = newState;
+      }
+      this.error = null;
+      this.lastCheckedEpoch = getGlobalEpoch();
+      return this.state;
+    } catch (e) {
+      if (this.state !== UNINITIALIZED) {
+        this.state = UNINITIALIZED;
+        this.lastChangedEpoch = getGlobalEpoch();
+      }
+      this.lastCheckedEpoch = getGlobalEpoch();
+      if (this.historyBuffer) {
+        this.historyBuffer.clear();
+      }
+      this.error = { thrownValue: e };
+      if (!ignoreErrors) throw e;
+      return this.state;
+    } finally {
+      stopCapturingParents();
+    }
+  }
+  get() {
+    try {
+      return this.__unsafe__getWithoutCapture();
+    } finally {
+      maybeCaptureParent(this);
+    }
+  }
+  getDiffSince(epoch) {
+    this.__unsafe__getWithoutCapture(true);
+    maybeCaptureParent(this);
+    if (epoch >= this.lastChangedEpoch) {
+      return EMPTY_ARRAY;
+    }
+    return this.historyBuffer?.getChangesSince(epoch) ?? RESET_VALUE;
+  }
+};
+var _Computed = singleton("Computed", () => __UNSAFE__Computed);
+function computedMethodLegacyDecorator(options = {}, _target, key, descriptor) {
+  const originalMethod = descriptor.value;
+  const derivationKey = /* @__PURE__ */ Symbol.for("__@ibodr/state__computed__" + key);
+  descriptor.value = function() {
+    let d = this[derivationKey];
+    if (!d) {
+      d = new _Computed(key, originalMethod.bind(this), options);
+      Object.defineProperty(this, derivationKey, {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: d
+      });
+    }
+    return d.get();
+  };
+  descriptor.value[isComputedMethodKey] = true;
+  return descriptor;
+}
+function computedGetterLegacyDecorator(options = {}, _target, key, descriptor) {
+  const originalMethod = descriptor.get;
+  const derivationKey = /* @__PURE__ */ Symbol.for("__@ibodr/state__computed__" + key);
+  descriptor.get = function() {
+    let d = this[derivationKey];
+    if (!d) {
+      d = new _Computed(key, originalMethod.bind(this), options);
+      Object.defineProperty(this, derivationKey, {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: d
+      });
+    }
+    return d.get();
+  };
+  return descriptor;
+}
+function computedMethodTc39Decorator(options, compute, context) {
+  assert(context.kind === "method", "@computed can only be used on methods");
+  const derivationKey = /* @__PURE__ */ Symbol.for("__@ibodr/state__computed__" + String(context.name));
+  const fn = function() {
+    let d = this[derivationKey];
+    if (!d) {
+      d = new _Computed(String(context.name), compute.bind(this), options);
+      Object.defineProperty(this, derivationKey, {
+        enumerable: false,
+        configurable: false,
+        writable: false,
+        value: d
+      });
+    }
+    return d.get();
+  };
+  fn[isComputedMethodKey] = true;
+  return fn;
+}
+function computedDecorator(options = {}, args) {
+  if (args.length === 2) {
+    const [originalMethod, context] = args;
+    return computedMethodTc39Decorator(options, originalMethod, context);
+  } else {
+    const [_target, key, descriptor] = args;
+    if (descriptor.get) {
+      logComputedGetterWarning();
+      return computedGetterLegacyDecorator(options, _target, key, descriptor);
+    } else {
+      return computedMethodLegacyDecorator(options, _target, key, descriptor);
+    }
+  }
+}
+var isComputedMethodKey = "@@__isComputedMethod__@@";
+function getComputedInstance(obj, propertyName) {
+  const key = /* @__PURE__ */ Symbol.for("__@ibodr/state__computed__" + propertyName.toString());
+  let inst3 = obj[key];
+  if (!inst3) {
+    const val = obj[propertyName];
+    if (typeof val === "function" && val[isComputedMethodKey]) {
+      val.call(obj);
+    }
+    inst3 = obj[key];
+  }
+  return inst3;
+}
+function computed() {
+  if (arguments.length === 1) {
+    const options = arguments[0];
+    return (...args) => computedDecorator(options, args);
+  } else if (typeof arguments[0] === "string") {
+    return new _Computed(arguments[0], arguments[1], arguments[2]);
+  } else {
+    return computedDecorator(void 0, arguments);
+  }
+}
+
+// src/lib/EffectScheduler.ts
+var __EffectScheduler__ = class {
+  constructor(name, runEffect, options) {
+    this.name = name;
+    this.runEffect = runEffect;
+    this._scheduleEffect = options?.scheduleEffect;
+  }
+  name;
+  runEffect;
+  __isEffectScheduler = true;
+  /** @internal */
+  _isActivelyListening = false;
+  /**
+   * Whether this scheduler is attached and actively listening to its parents.
+   * @public
+   */
+  // eslint-disable-next-line tldraw/no-setter-getter
+  get isActivelyListening() {
+    return this._isActivelyListening;
+  }
+  /** @internal */
+  lastTraversedEpoch = GLOBAL_START_EPOCH;
+  /** @internal */
+  lastReactedEpoch = GLOBAL_START_EPOCH;
+  /** @internal */
+  _scheduleCount = 0;
+  /** @internal */
+  __debug_ancestor_epochs__ = null;
+  /**
+   * The number of times this effect has been scheduled.
+   * @public
+   */
+  // eslint-disable-next-line tldraw/no-setter-getter
+  get scheduleCount() {
+    return this._scheduleCount;
+  }
+  /** @internal */
+  parentSet = new ArraySet();
+  /** @internal */
+  parentEpochs = [];
+  /** @internal */
+  parents = [];
+  /** @internal */
+  _scheduleEffect;
+  /** @internal */
+  maybeScheduleEffect() {
+    if (!this._isActivelyListening) return;
+    if (this.lastReactedEpoch === getGlobalEpoch()) return;
+    if (this.parents.length && !haveParentsChanged(this)) {
+      this.lastReactedEpoch = getGlobalEpoch();
+      return;
+    }
+    this.scheduleEffect();
+  }
+  /** @internal */
+  scheduleEffect() {
+    this._scheduleCount++;
+    if (this._scheduleEffect) {
+      this._scheduleEffect(this.maybeExecute);
+    } else {
+      this.execute();
+    }
+  }
+  /** @internal */
+  // eslint-disable-next-line tldraw/prefer-class-methods
+  maybeExecute = () => {
+    if (!this._isActivelyListening) return;
+    this.execute();
+  };
+  /**
+   * Makes this scheduler become 'actively listening' to its parents.
+   * If it has been executed before it will immediately become eligible to receive 'maybeScheduleEffect' calls.
+   * If it has not executed before it will need to be manually executed once to become eligible for scheduling, i.e. by calling `EffectScheduler.execute`.
+   * @public
+   */
+  attach() {
+    this._isActivelyListening = true;
+    for (let i = 0, n = this.parents.length; i < n; i++) {
+      attach(this.parents[i], this);
+    }
+  }
+  /**
+   * Makes this scheduler stop 'actively listening' to its parents.
+   * It will no longer be eligible to receive 'maybeScheduleEffect' calls until `EffectScheduler.attach` is called again.
+   * @public
+   */
+  detach() {
+    this._isActivelyListening = false;
+    for (let i = 0, n = this.parents.length; i < n; i++) {
+      detach(this.parents[i], this);
+    }
+  }
+  /**
+   * Executes the effect immediately and returns the result.
+   * @returns The result of the effect.
+   * @public
+   */
+  execute() {
+    try {
+      startCapturingParents(this);
+      const currentEpoch = getGlobalEpoch();
+      const result = this.runEffect(this.lastReactedEpoch);
+      this.lastReactedEpoch = currentEpoch;
+      return result;
+    } finally {
+      stopCapturingParents();
+    }
+  }
+};
+var EffectScheduler = singleton(
+  "EffectScheduler",
+  () => __EffectScheduler__
+);
+function react(name, fn, options) {
+  const scheduler = new EffectScheduler(name, fn, options);
+  scheduler.attach();
+  scheduler.scheduleEffect();
+  return () => {
+    scheduler.detach();
+  };
+}
+function reactor(name, fn, options) {
+  const scheduler = new EffectScheduler(name, fn, options);
+  return {
+    scheduler,
+    start: (options2) => {
+      const force = options2?.force ?? false;
+      scheduler.attach();
+      if (force) {
+        scheduler.scheduleEffect();
+      } else {
+        scheduler.maybeScheduleEffect();
+      }
+    },
+    stop: () => {
+      scheduler.detach();
+    }
+  };
+}
+
+// src/lib/isSignal.ts
+function isSignal(value) {
+  return value instanceof _Atom || value instanceof _Computed;
+}
+function localStorageAtom(name, initialValue, options) {
+  let _initialValue = initialValue;
+  try {
+    const value = getFromLocalStorage(name);
+    if (value) {
+      _initialValue = JSON.parse(value);
+    }
+  } catch {
+    deleteFromLocalStorage(name);
+  }
+  const outAtom = atom(name, _initialValue, options);
+  const reactCleanup = react(`save ${name} to localStorage`, () => {
+    setInLocalStorage(name, JSON.stringify(outAtom.get()));
+  });
+  const handleStorageEvent = (event) => {
+    if (event.key !== name) return;
+    if (event.newValue === null) {
+      outAtom.set(initialValue);
+      return;
+    }
+    try {
+      const newValue = JSON.parse(event.newValue);
+      outAtom.set(newValue);
+    } catch {
+    }
+  };
+  window.addEventListener("storage", handleStorageEvent);
+  const cleanup = () => {
+    reactCleanup();
+    window.removeEventListener("storage", handleStorageEvent);
+  };
+  return [outAtom, cleanup];
+}
+
+// src/index.ts
+var currentApiVersion = 1;
+var actualApiVersion = singleton("apiVersion", () => currentApiVersion);
+if (actualApiVersion !== currentApiVersion) {
+  throw new Error(
+    `You have multiple incompatible versions of @ibodr/state in your app. Please deduplicate the package.`
+  );
+}
+registerDrawLibraryVersion(
+  "@ibodr/state",
+  "0.0.0",
+  "esm"
+);
+
+export { ArraySet, EMPTY_ARRAY, EffectScheduler, RESET_VALUE, UNINITIALIZED, atom, computed, deferAsyncEffects, getComputedInstance, isAtom, isSignal, isUninitialized, localStorageAtom, react, reactor, transact, transaction, unsafe__withoutCapture, whyAmIRunning, withDiff };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map