tutuca 0.9.89 → 0.9.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tutuca",
-  "version": "0.9.89",
+  "version": "0.9.90",
   "type": "module",
   "description": "Zero-dependency SPA framework with immutable state and virtual DOM",
   "main": "./dist/tutuca.js",

package/skill/tutuca/request-response.md

@@ -274,7 +274,7 @@ You can also fire several in one handler
 ### The request-handler contract
 
 Registered request handlers run with **no `this`** (they're invoked as
-`fn.apply(null, args)`), so they can't read component state — pass
+`fn.apply(null, [...args, ctx])`), so they can't read component state — pass
 everything they need through `args`
 (`ctx.request("persistState", [{ key, value }])`). They're plain async
 functions or closures. Aggregate handlers from sub-modules with spread:
@@ -285,6 +285,15 @@ export function getRequestHandlers() {
 }
 ```
 
+The handler also receives a request context as its **final argument**
+(consistent with `receive`/`input`/`response`, where `ctx` is last) — usually
+ignored, but available when needed. Like every ctx it exposes
+`ctx.walkPath(callback)`, which walks the component instances on the issuing
+path **leaf→root**, calling `callback(Component, instance)` (return `false` to
+stop early). It captures the immutable dispatch root/path, so it may be called
+before or after an `await`. (The storybook uses this to let an example mock the
+request handlers its component triggers — per example, in isolation.)
+
 ### Chaining from a response handler
 
 A `response` handler gets the full `ctx`, so it can issue further

package/skill/tutuca-source/tutuca.ext.js

@@ -250,6 +250,17 @@ class Path {
     }
     return curVal;
   }
+  resolveChain(root) {
+    const out = [root];
+    let curVal = root;
+    for (const step of this.steps) {
+      curVal = step.lookup(curVal, NONE);
+      if (curVal === NONE)
+        break;
+      out.push(curVal);
+    }
+    return out;
+  }
   setValue(root, v) {
     const intermediates = new Array(this.steps.length);
     let curVal = root;
@@ -2926,6 +2937,7 @@ class Transactor {
     const txnPath = path.toTransactionPath();
     const curLeaf = txnPath.lookup(curRoot);
     const handler = this.comps.getRequestFor(curLeaf, name) ?? mkReq404(name);
+    const reqCtx = new RequestContext(path, this, parent, curRoot);
     const resHandlerName = opts?.onResName ?? name;
     const resPath = opts?.livePath ? null : txnPath.pinKeys(curRoot);
     const push = (specificName, baseName, singleArg, result, error) => {
@@ -2934,7 +2946,7 @@ class Transactor {
       this.pushTransaction(t);
     };
     try {
-      const result = await handler.fn.apply(null, args);
+      const result = await handler.fn.apply(null, [...args, reqCtx]);
       push(opts?.onOkName, resHandlerName, result, result, null);
     } catch (error) {
       push(opts?.onErrorName, resHandlerName, error, null, error);
@@ -3177,10 +3189,20 @@ class Task {
 }
 
 class Dispatcher {
-  constructor(path, transactor, parentTransaction) {
+  constructor(path, transactor, parentTransaction, root = transactor.state.val) {
     this.path = path;
     this.transactor = transactor;
     this.parent = parentTransaction;
+    this.root = root;
+  }
+  walkPath(callback) {
+    const comps = this.transactor.comps;
+    const chain = this.path.toTransactionPath().resolveChain(this.root);
+    for (let i = chain.length - 1;i >= 0; i--) {
+      const comp = comps.getCompFor(chain[i]);
+      if (comp && callback(comp, chain[i]) === false)
+        return;
+    }
   }
   get at() {
     return new PathChanges(this);
@@ -3217,6 +3239,9 @@ class EventContext extends Dispatcher {
   }
 }
 
+class RequestContext extends Dispatcher {
+}
+
 class PathChanges extends PathBuilder {
   constructor(dispatcher) {
     super();