@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

package/dist/observe/core/attribution-hooks.js

@@ -0,0 +1,60 @@
+let attrHooks = null;
+
+function setAttributionHooks(t) {
+    attrHooks = t;
+}
+
+/**
+ * Run `fn` as the handler of a user interaction: every root write it performs
+ * (and every action step, effect or flight the write causes) is attributed to
+ * `ref` by whichever engine is installed. The web runtime wraps event
+ * dispatch in this; custom renderers and test harnesses call it themselves.
+ * With no engine installed it is `fn()` — the wiring, not the engine, so it
+ * lives in core and is reachable as `OBSERVE.attribution.withInteraction`.
+ *
+ * The `finally` is deliberate and safe under the try rule above: this
+ * function is referenced only from the `OBSERVE` object, which prod builds
+ * fold to `undefined`, so nothing retains it there.
+ */ function withInteraction(t, n) {
+    // Pin the engine for the frame: a handler that disables it mid-way must
+    // still close the frame it opened (the engine tolerates a close after
+    // disable()), and one that enables it mid-way opened no frame to close.
+    const o = attrHooks;
+    if (o === null) return n();
+    o.interactionStart(t);
+    try {
+        return n();
+    } finally {
+        o.interactionEnd();
+    }
+}
+
+/**
+ * Run `fn` as a declared unit of work — a router's navigation: every root
+ * write it performs is attributed to `ref` (and, through it, to the enclosing
+ * interaction when there is one), so the hold those writes wait in, the
+ * re-runs they cause and the verdicts on them all carry the route's name
+ * instead of a bare signal's. Same contract as `withInteraction`: the wiring,
+ * not the engine; `fn()` with no engine installed. Reachable as
+ * `OBSERVE.attribution.withOrigin`.
+ *
+ * ```ts
+ * OBSERVE
+ *   ? OBSERVE.attribution.withOrigin(
+ *       { kind: "navigation", name: match.pattern, to, from, params: match.params },
+ *       () => setLocation(to)
+ *     )
+ *   : setLocation(to);
+ * ```
+ */ function withOrigin(t, n) {
+    const o = attrHooks;
+    if (o === null) return n();
+    o.originStart(t);
+    try {
+        return n();
+    } finally {
+        o.originEnd();
+    }
+}
+
+export { attrHooks, setAttributionHooks, withInteraction, withOrigin };