@unseenco/theatre-dataverse 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,31 +1,25 @@
+"use strict";
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __export = (target, all) => {
-  __markAsModule(target);
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-__export(exports, {
+var src_exports = {};
+__export(src_exports, {
   Atom: () => Atom,
   PointerProxy: () => PointerProxy,
   Ticker: () => Ticker,
@@ -39,6 +33,7 @@ __export(exports, {
   prism: () => prism_default,
   val: () => val
 });
+module.exports = __toCommonJS(src_exports);
 
 // ../../node_modules/lodash-es/isArray.js
 var isArray = Array.isArray;
@@ -189,7 +184,9 @@ var funcProto2 = Function.prototype;
 var objectProto3 = Object.prototype;
 var funcToString2 = funcProto2.toString;
 var hasOwnProperty2 = objectProto3.hasOwnProperty;
-var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+var reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
 function baseIsNative(value) {
   if (!isObject_default(value) || isMasked_default(value)) {
     return false;
@@ -603,8 +600,8 @@ function last(array) {
 var last_default = last;
 
 // src/pointer.ts
-var pointerMetaWeakMap = new WeakMap();
-var cachedSubPathPointersWeakMap = new WeakMap();
+var pointerMetaWeakMap = /* @__PURE__ */ new WeakMap();
+var cachedSubPathPointersWeakMap = /* @__PURE__ */ new WeakMap();
 var pointerMetaSymbol = Symbol("pointerMeta");
 var proxyHandler = {
   get(pointerKey, prop) {
@@ -612,7 +609,7 @@ var proxyHandler = {
       return pointerMetaWeakMap.get(pointerKey);
     let subPathPointers = cachedSubPathPointersWeakMap.get(pointerKey);
     if (!subPathPointers) {
-      subPathPointers = new Map();
+      subPathPointers = /* @__PURE__ */ new Map();
       cachedSubPathPointersWeakMap.set(pointerKey, subPathPointers);
     }
     const existing = subPathPointers.get(prop);
@@ -633,10 +630,9 @@ var getPointerParts = (p) => {
   return { root: root2, path };
 };
 function pointer(args) {
-  var _a;
   const meta = {
     root: args.root,
-    path: (_a = args.path) != null ? _a : []
+    path: args.path ?? []
   };
   const pointerKey = {};
   pointerMetaWeakMap.set(pointerKey, meta);
@@ -675,7 +671,7 @@ var hoop = (s, path, reducer) => {
     const newVal = hoop(oldVal, restOfPath, reducer);
     if (oldVal === newVal)
       return s;
-    const newS = __spreadProps(__spreadValues({}, s), { [key]: newVal });
+    const newS = { ...s, [key]: newVal };
     return newS;
   } else {
     const [key, ...restOfPath] = path;
@@ -762,7 +758,10 @@ function getSharedMechanism() {
   const varName = "__dataverse_discoveryMechanism_sharedStack";
   const root2 = typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {};
   if (root2) {
-    const existingMechanism = root2[varName];
+    const existingMechanism = (
+      // @ts-ignore ignore
+      root2[varName]
+    );
     if (existingMechanism && typeof existingMechanism === "object" && existingMechanism.type === "Dataverse_discoveryMechanism") {
       return existingMechanism;
     } else {
@@ -792,12 +791,28 @@ var HotHandle = class {
     this._prismInstance = _prismInstance;
     this._didMarkDependentsAsStale = false;
     this._isFresh = false;
-    this._cacheOfDendencyValues = new Map();
-    this._dependents = new Set();
-    this._dependencies = new Set();
-    this._possiblyStaleDeps = new Set();
-    this._scope = new HotScope(this);
+    this._cacheOfDendencyValues = /* @__PURE__ */ new Map();
+    /**
+     * @internal
+     */
+    this._dependents = /* @__PURE__ */ new Set();
+    /**
+     * @internal
+     */
+    this._dependencies = /* @__PURE__ */ new Set();
+    this._possiblyStaleDeps = /* @__PURE__ */ new Set();
+    this._scope = new HotScope(
+      this
+    );
+    /**
+     * @internal
+     */
     this._lastValue = void 0;
+    /**
+     * If true, the prism is stale even though its dependencies aren't
+     * marked as such. This is used by `prism.source()` and `prism.state()`
+     * to mark the prism as stale.
+     */
     this._forciblySetToStale = false;
     this._reactToDependencyGoingStale = (which) => {
       this._possiblyStaleDeps.add(which);
@@ -854,7 +869,7 @@ var HotHandle = class {
         }
       }
     }
-    const newDeps = new Set();
+    const newDeps = /* @__PURE__ */ new Set();
     this._cacheOfDendencyValues.clear();
     const collector = (observedDep) => {
       newDeps.add(observedDep);
@@ -869,7 +884,10 @@ var HotHandle = class {
     } finally {
       const topOfTheStack = hookScopeStack.pop();
       if (topOfTheStack !== this._scope) {
-        console.warn(`The Prism hook stack has slipped. This is a bug.`);
+        console.warn(
+          // @todo guide the user to report the bug in an issue
+          `The Prism hook stack has slipped. This is a bug.`
+        );
       }
     }
     popCollector(collector);
@@ -899,12 +917,18 @@ var HotHandle = class {
       dependent(this._prismInstance);
     }
   }
+  /**
+   * @internal
+   */
   _addDependency(d) {
     if (this._dependencies.has(d))
       return;
     this._dependencies.add(d);
     d._addDependent(this._reactToDependencyGoingStale);
   }
+  /**
+   * @internal
+   */
   _removeDependency(d) {
     if (!this._dependencies.has(d))
       return;
@@ -916,12 +940,18 @@ var emptyObject = {};
 var PrismInstance = class {
   constructor(_fn) {
     this._fn = _fn;
+    /**
+     * Whether the object is a prism.
+     */
     this.isPrism = true;
     this._state = {
       hot: false,
       handle: void 0
     };
   }
+  /**
+   * Whether the prism is hot.
+   */
   get isHot() {
     return this._state.hot;
   }
@@ -929,7 +959,12 @@ var PrismInstance = class {
     const dependent = () => {
       ticker.onThisOrNextTick(refresh);
     };
-    let lastValue = emptyObject;
+    let lastValue = (
+      // use an empty object as the initial value so that the listener is called on the first tick.
+      // if we were to use, say, undefined, and this.getValue() also returned undefined, the listener
+      // would never be called.
+      emptyObject
+    );
     const refresh = () => {
       const newValue = this.getValue();
       if (newValue === lastValue)
@@ -949,6 +984,9 @@ var PrismInstance = class {
     };
     return unsubscribe;
   }
+  /**
+   * Calls `callback` every time the prism's state goes from `fresh-\>stale.` Returns an `unsubscribe()` function.
+   */
   onStale(callback) {
     const untap = () => {
       this._removeDependent(fn);
@@ -957,10 +995,20 @@ var PrismInstance = class {
     this._addDependent(fn);
     return untap;
   }
+  /**
+   * Keep the prism hot, even if there are no tappers (subscribers).
+   */
   keepHot() {
     return this.onStale(() => {
     });
   }
+  /**
+   * Add a prism as a dependent of this prism.
+   *
+   * @param d - The prism to be made a dependent of this prism.
+   *
+   * @see _removeDependent
+   */
   _addDependent(d) {
     if (!this._state.hot) {
       this._goHot();
@@ -974,6 +1022,13 @@ var PrismInstance = class {
       handle: hotHandle
     };
   }
+  /**
+   * Remove a prism as a dependent of this prism.
+   *
+   * @param d - The prism to be removed from as a dependent of this prism.
+   *
+   * @see _addDependent
+   */
   _removeDependent(d) {
     const state2 = this._state;
     if (!state2.hot) {
@@ -986,6 +1041,9 @@ var PrismInstance = class {
       handle.destroy();
     }
   }
+  /**
+   * Gets the current value of the prism. If the value is stale, it causes the prism to freshen.
+   */
   getValue() {
     reportResolutionStart(this);
     const state2 = this._state;
@@ -999,14 +1057,17 @@ var PrismInstance = class {
     return val2;
   }
 };
-var HotScope = class {
+var HotScope = class _HotScope {
   constructor(_hotHandle) {
     this._hotHandle = _hotHandle;
-    this._refs = new Map();
+    this._refs = /* @__PURE__ */ new Map();
     this.isPrismScope = true;
+    // NOTE probably not a great idea to eager-allocate all of these objects/maps for every scope,
+    // especially because most wouldn't get used in the majority of cases. However, back when these
+    // were stored on weakmaps, they were uncomfortable to inspect in the debugger.
     this.subs = {};
-    this.effects = new Map();
-    this.memos = new Map();
+    this.effects = /* @__PURE__ */ new Map();
+    this.memos = /* @__PURE__ */ new Map();
   }
   ref(key, initialValue) {
     let ref2 = this._refs.get(key);
@@ -1042,6 +1103,7 @@ var HotScope = class {
     if (memo2 === void 0) {
       memo2 = {
         cachedValue: null,
+        // undefined will always indicate "deps have changed", so we set its initial value as such
         deps: void 0
       };
       this.memos.set(key, memo2);
@@ -1055,19 +1117,23 @@ var HotScope = class {
     return memo2.cachedValue;
   }
   state(key, initialValue) {
-    const { value, setValue } = this.memo("state/" + key, () => {
-      const value2 = { current: initialValue };
-      const setValue2 = (newValue) => {
-        value2.current = newValue;
-        this._hotHandle.forceStale();
-      };
-      return { value: value2, setValue: setValue2 };
-    }, []);
+    const { value, setValue } = this.memo(
+      "state/" + key,
+      () => {
+        const value2 = { current: initialValue };
+        const setValue2 = (newValue) => {
+          value2.current = newValue;
+          this._hotHandle.forceStale();
+        };
+        return { value: value2, setValue: setValue2 };
+      },
+      []
+    );
     return [value.current, setValue];
   }
   sub(key) {
     if (!this.subs[key]) {
-      this.subs[key] = new HotScope(this._hotHandle);
+      this.subs[key] = new _HotScope(this._hotHandle);
     }
     return this.subs[key];
   }
@@ -1079,12 +1145,16 @@ var HotScope = class {
   }
   source(subscribe, getValue2) {
     const sourceKey = "$$source/blah";
-    this.effect(sourceKey, () => {
-      const unsub = subscribe(() => {
-        this._hotHandle.forceStale();
-      });
-      return unsub;
-    }, [subscribe]);
+    this.effect(
+      sourceKey,
+      () => {
+        const unsub = subscribe(() => {
+          this._hotHandle.forceStale();
+        });
+        return unsub;
+      },
+      [subscribe]
+    );
     return getValue2();
   }
 };
@@ -1179,7 +1249,7 @@ function source(subscribe, getValue2) {
 var prism = (fn) => {
   return new PrismInstance(fn);
 };
-var ColdScope = class {
+var ColdScope = class _ColdScope {
   effect(key, cb, deps) {
     console.warn(`prism.effect() does not run in cold prisms`);
   }
@@ -1194,7 +1264,7 @@ var ColdScope = class {
     return { current: initialValue };
   }
   sub(key) {
-    return new ColdScope();
+    return new _ColdScope();
   }
   source(subscribe, getValue2) {
     return getValue2();
@@ -1211,7 +1281,10 @@ function calculateColdPrism(fn) {
   } finally {
     const topOfTheStack = hookScopeStack.pop();
     if (topOfTheStack !== scope2) {
-      console.warn(`The Prism hook stack has slipped. This is a bug.`);
+      console.warn(
+        // @todo guide the user to report the bug in an issue
+        `The Prism hook stack has slipped. This is a bug.`
+      );
     }
   }
   return value;
@@ -1228,23 +1301,17 @@ prism.source = source;
 var prism_default = prism;
 
 // src/Atom.ts
-var ValueTypes;
-(function(ValueTypes2) {
-  ValueTypes2[ValueTypes2["Dict"] = 0] = "Dict";
-  ValueTypes2[ValueTypes2["Array"] = 1] = "Array";
-  ValueTypes2[ValueTypes2["Other"] = 2] = "Other";
-})(ValueTypes || (ValueTypes = {}));
 var getTypeOfValue = (v) => {
   if (Array.isArray(v))
-    return 1;
+    return 1 /* Array */;
   if (isPlainObject_default(v))
-    return 0;
-  return 2;
+    return 0 /* Dict */;
+  return 2 /* Other */;
 };
 var getKeyOfValue = (v, key, vType = getTypeOfValue(v)) => {
-  if (vType === 0 && typeof key === "string") {
+  if (vType === 0 /* Dict */ && typeof key === "string") {
     return v[key];
-  } else if (vType === 1 && isValidArrayIndex(key)) {
+  } else if (vType === 1 /* Array */ && isValidArrayIndex(key)) {
     return v[key];
   } else {
     return void 0;
@@ -1254,12 +1321,12 @@ var isValidArrayIndex = (key) => {
   const inNumber = typeof key === "number" ? key : parseInt(key, 10);
   return !isNaN(inNumber) && inNumber >= 0 && inNumber < Infinity && (inNumber | 0) === inNumber;
 };
-var Scope = class {
+var Scope = class _Scope {
   constructor(_parent, _path) {
     this._parent = _parent;
     this._path = _path;
-    this.children = new Map();
-    this.identityChangeListeners = new Set();
+    this.children = /* @__PURE__ */ new Map();
+    this.identityChangeListeners = /* @__PURE__ */ new Set();
   }
   addIdentityChangeListener(cb) {
     this.identityChangeListeners.add(cb);
@@ -1278,7 +1345,7 @@ var Scope = class {
   getOrCreateChild(key) {
     let child = this.children.get(key);
     if (!child) {
-      child = child = new Scope(this, this._path.concat([key]));
+      child = child = new _Scope(this, this._path.concat([key]));
       this.children.set(key, child);
     }
     return child;
@@ -1295,9 +1362,20 @@ var Scope = class {
 };
 var Atom = class {
   constructor(initialState) {
+    /**
+     * @internal
+     */
     this.$$isPointerToPrismProvider = true;
+    /**
+     * Convenience property that gives you a pointer to the root of the atom.
+     *
+     * @remarks
+     * Equivalent to `pointer({ root: thisAtom, path: [] })`.
+     */
     this.pointer = pointer_default({ root: this, path: [] });
-    this.prism = this.pointerToPrism(this.pointer);
+    this.prism = this.pointerToPrism(
+      this.pointer
+    );
     this._onPointerValueChange = (pointer2, cb) => {
       const { path } = getPointerParts(pointer2);
       const scope2 = this._getOrCreateScopeForPath(path);
@@ -1310,6 +1388,11 @@ var Atom = class {
     this._currentState = initialState;
     this._rootScope = new Scope(void 0, []);
   }
+  /**
+   * Sets the state of the atom.
+   *
+   * @param newState - The new state of the atom.
+   */
   set(newState) {
     const oldState = this._currentState;
     this._currentState = newState;
@@ -1318,23 +1401,62 @@ var Atom = class {
   get() {
     return this._currentState;
   }
+  /**
+   * Returns the value at the given pointer
+   *
+   * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+   *
+   * Example
+   * ```ts
+   * const atom = atom({ a: { b: 1 } })
+   * atom.getByPointer(atom.pointer.a.b) // 1
+   * atom.getByPointer((p) => p.a.b) // 1
+   * ```
+   */
   getByPointer(pointerOrFn) {
     const pointer2 = isPointer(pointerOrFn) ? pointerOrFn : pointerOrFn(this.pointer);
     const path = getPointerParts(pointer2).path;
     return this._getIn(path);
   }
+  /**
+   * Gets the state of the atom at `path`.
+   */
   _getIn(path) {
     return path.length === 0 ? this.get() : get_default(this.get(), path);
   }
   reduce(fn) {
     this.set(fn(this.get()));
   }
+  /**
+   * Reduces the value at the given pointer
+   *
+   * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+   *
+   * Example
+   * ```ts
+   * const atom = atom({ a: { b: 1 } })
+   * atom.reduceByPointer(atom.pointer.a.b, (b) => b + 1) // atom.get().a.b === 2
+   * atom.reduceByPointer((p) => p.a.b, (b) => b + 1) // atom.get().a.b === 2
+   * ```
+   */
   reduceByPointer(pointerOrFn, reducer) {
     const pointer2 = isPointer(pointerOrFn) ? pointerOrFn : pointerOrFn(this.pointer);
     const path = getPointerParts(pointer2).path;
     const newState = updateDeep(this.get(), path, reducer);
     this.set(newState);
   }
+  /**
+   * Sets the value at the given pointer
+   *
+   * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+   *
+   * Example
+   * ```ts
+   * const atom = atom({ a: { b: 1 } })
+   * atom.setByPointer(atom.pointer.a.b, 2) // atom.get().a.b === 2
+   * atom.setByPointer((p) => p.a.b, 2) // atom.get().a.b === 2
+   * ```
+   */
   setByPointer(pointerOrFn, val2) {
     this.reduceByPointer(pointerOrFn, () => val2);
   }
@@ -1348,7 +1470,7 @@ var Atom = class {
       return;
     const oldValueType = getTypeOfValue(oldState);
     const newValueType = getTypeOfValue(newState);
-    if (oldValueType === 2 && oldValueType === newValueType)
+    if (oldValueType === 2 /* Other */ && oldValueType === newValueType)
       return;
     for (const [childKey, childScope] of scope2.children) {
       const oldChildVal = getKeyOfValue(oldState, childKey, oldValueType);
@@ -1363,6 +1485,16 @@ var Atom = class {
     }
     return curScope;
   }
+  /**
+   * Returns a new prism of the value at the provided path.
+   *
+   * @param pointer - The path to create the prism at.
+   *
+   * ```ts
+   * const pr = atom({ a: { b: 1 } }).pointerToPrism(atom.pointer.a.b)
+   * pr.getValue() // 1
+   * ```
+   */
   pointerToPrism(pointer2) {
     const { path } = getPointerParts(pointer2);
     const subscribe = (listener) => this._onPointerValueChange(pointer2, listener);
@@ -1374,7 +1506,7 @@ var Atom = class {
 };
 
 // src/pointerToPrism.ts
-var identifyPrismWeakMap = new WeakMap();
+var identifyPrismWeakMap = /* @__PURE__ */ new WeakMap();
 function isPointerToPrismProvider(val2) {
   return typeof val2 === "object" && val2 !== null && val2["$$isPointerToPrismProvider"] === true;
 }
@@ -1384,7 +1516,9 @@ var pointerToPrism = (pointer2) => {
   if (!prismInstance) {
     const root2 = meta.root;
     if (!isPointerToPrismProvider(root2)) {
-      throw new Error(`Cannot run pointerToPrism() on a pointer whose root is not an PointerToPrismProvider`);
+      throw new Error(
+        `Cannot run pointerToPrism() on a pointer whose root is not an PointerToPrismProvider`
+      );
     }
     prismInstance = root2.pointerToPrism(pointer2);
     identifyPrismWeakMap.set(meta, prismInstance);
@@ -1430,38 +1564,91 @@ function* iterateAndCountTicks(pointerOrPrism) {
 
 // src/Ticker.ts
 var EMPTY_TICKS_BEFORE_GOING_DORMANT = 60 * 3;
-var Ticker = class {
+var Ticker = class _Ticker {
   constructor(_conf) {
     this._conf = _conf;
     this._ticking = false;
+    /**
+     * Whether the Ticker is dormant
+     */
     this._dormant = true;
     this._numberOfDormantTicks = 0;
+    /**
+     * Counts up for every tick executed.
+     * Internally, this is used to measure ticks per second.
+     *
+     * This is "public" to TypeScript, because it's a tool for performance measurements.
+     * Consider this as experimental, and do not rely on it always being here in future releases.
+     */
     this.__ticks = 0;
-    this._scheduledForThisOrNextTick = new Set();
-    this._scheduledForNextTick = new Set();
+    this._scheduledForThisOrNextTick = /* @__PURE__ */ new Set();
+    this._scheduledForNextTick = /* @__PURE__ */ new Set();
     this._timeAtCurrentTick = 0;
   }
+  /**
+   * Whether the Ticker is dormant
+   */
   get dormant() {
     return this._dormant;
   }
+  /**
+   * Registers for fn to be called either on this tick or the next tick.
+   *
+   * If `onThisOrNextTick()` is called while `Ticker.tick()` is running, the
+   * side effect _will_ be called within the running tick. If you don't want this
+   * behavior, you can use `onNextTick()`.
+   *
+   * Note that `fn` will be added to a `Set()`. Which means, if you call `onThisOrNextTick(fn)`
+   * with the same fn twice in a single tick, it'll only run once.
+   *
+   * @param fn - The function to be registered.
+   *
+   * @see offThisOrNextTick
+   */
   onThisOrNextTick(fn) {
     this._scheduledForThisOrNextTick.add(fn);
     if (this._dormant) {
       this._goActive();
     }
   }
+  /**
+   * Registers a side effect to be called on the next tick.
+   *
+   * @param fn - The function to be registered.
+   *
+   * @see onThisOrNextTick
+   * @see offNextTick
+   */
   onNextTick(fn) {
     this._scheduledForNextTick.add(fn);
     if (this._dormant) {
       this._goActive();
     }
   }
+  /**
+   * De-registers a fn to be called either on this tick or the next tick.
+   *
+   * @param fn - The function to be de-registered.
+   *
+   * @see onThisOrNextTick
+   */
   offThisOrNextTick(fn) {
     this._scheduledForThisOrNextTick.delete(fn);
   }
+  /**
+   * De-registers a fn to be called on the next tick.
+   *
+   * @param fn - The function to be de-registered.
+   *
+   * @see onNextTick
+   */
   offNextTick(fn) {
     this._scheduledForNextTick.delete(fn);
   }
+  /**
+   * The time at the start of the current tick if there is a tick in progress, otherwise defaults to
+   * `performance.now()`.
+   */
   get time() {
     if (this._ticking) {
       return this._timeAtCurrentTick;
@@ -1469,24 +1656,32 @@ var Ticker = class {
       return performance.now();
   }
   _goActive() {
-    var _a, _b;
     if (!this._dormant)
       return;
     this._dormant = false;
-    (_b = (_a = this._conf) == null ? void 0 : _a.onActive) == null ? void 0 : _b.call(_a);
+    this._conf?.onActive?.();
   }
   _goDormant() {
-    var _a, _b;
     if (this._dormant)
       return;
     this._dormant = true;
     this._numberOfDormantTicks = 0;
-    (_b = (_a = this._conf) == null ? void 0 : _a.onDormant) == null ? void 0 : _b.call(_a);
-  }
+    this._conf?.onDormant?.();
+  }
+  /**
+   * Triggers a tick which starts executing the callbacks scheduled for this tick.
+   *
+   * @param t - The time at the tick.
+   *
+   * @see onThisOrNextTick
+   * @see onNextTick
+   */
   tick(t = performance.now()) {
     if (process.env.NODE_ENV === "development") {
-      if (!(this instanceof Ticker)) {
-        throw new Error('ticker.tick must be called while bound to the ticker. As in, "ticker.tick(time)" or "requestAnimationFrame((t) => ticker.tick(t))" for performance.');
+      if (!(this instanceof _Ticker)) {
+        throw new Error(
+          'ticker.tick must be called while bound to the ticker. As in, "ticker.tick(time)" or "requestAnimationFrame((t) => ticker.tick(t))" for performance.'
+        );
       }
     }
     this.__ticks++;
@@ -1517,7 +1712,7 @@ var Ticker = class {
       throw new Error(`Maximum recursion limit for _tick()`);
     }
     const oldSet = this._scheduledForThisOrNextTick;
-    this._scheduledForThisOrNextTick = new Set();
+    this._scheduledForThisOrNextTick = /* @__PURE__ */ new Set();
     for (const fn of oldSet) {
       fn(time);
     }
@@ -1553,18 +1748,33 @@ function* iterateOver(pointerOrPrism) {
 // src/PointerProxy.ts
 var PointerProxy = class {
   constructor(currentPointer) {
+    /**
+     * @internal
+     */
     this.$$isPointerToPrismProvider = true;
     this._currentPointerBox = new Atom(currentPointer);
     this.pointer = pointer_default({ root: this, path: [] });
   }
+  /**
+   * Sets the underlying pointer.
+   * @param p - The pointer to be proxied.
+   */
   setPointer(p) {
     this._currentPointerBox.set(p);
   }
+  /**
+   * Returns a prism of the value at the provided sub-path of the proxied pointer.
+   *
+   * @param path - The path to create the prism at.
+   */
   pointerToPrism(pointer2) {
     const { path } = getPointerMeta(pointer2);
     return prism_default(() => {
       const currentPointer = this._currentPointerBox.prism.getValue();
-      const subPointer = path.reduce((pointerSoFar, pathItem) => pointerSoFar[pathItem], currentPointer);
+      const subPointer = path.reduce(
+        (pointerSoFar, pathItem) => pointerSoFar[pathItem],
+        currentPointer
+      );
       return val(subPointer);
     });
   }