tutuca 0.9.93 → 0.9.95

package/dist/tutuca-cli.js

@@ -13933,36 +13933,81 @@ class Transactor {
     this.transactions = [];
     this.state = new State2(rootValue);
     this.onTransactionPushed = () => {};
+    this._inflight = new Set;
   }
   pushTransaction(t) {
     this.transactions.push(t);
     this.onTransactionPushed(t);
   }
+  _link(child, parent) {
+    if (parent) {
+      const release = parent.completion.track();
+      child.completion.whenSubtreeSettled().then(release);
+    }
+    return child;
+  }
   pushSend(path, name, args = [], opts = {}, parent = null) {
-    this.pushTransaction(new SendEvent(path, this, name, args, parent, opts));
+    const t = new SendEvent(path, this, name, args, parent, opts);
+    this.pushTransaction(t);
+    return this._link(t, parent);
+  }
+  pushInput(path, name, args = [], opts = {}, parent = null) {
+    const t = new InputDispatchEvent(path, this, name, args, parent, opts);
+    this.pushTransaction(t);
+    return this._link(t, parent);
   }
   pushBubble(path, name, args = [], opts = {}, parent = null, targetPath = null) {
     const newOpts = opts.skipSelf ? { ...opts, skipSelf: false } : opts;
-    this.pushTransaction(new BubbleEvent(path, this, name, args, parent, newOpts, targetPath));
-  }
-  async pushRequest(path, name, args = [], opts = {}, parent = null) {
-    const curRoot = this.state.val;
-    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) => {
-      const resArgs = specificName ? [singleArg] : [result, error];
-      const t = new ResponseEvent(path, this, specificName ?? baseName, resArgs, parent, resPath);
-      this.pushTransaction(t);
+    const t = new BubbleEvent(path, this, name, args, parent, newOpts, targetPath);
+    this.pushTransaction(t);
+    return this._link(t, parent);
+  }
+  pushRequest(path, name, args = [], opts = {}, parent = null) {
+    const release = parent ? parent.completion.track() : null;
+    const p = this._runRequest(path, name, args, opts, parent, release);
+    this._inflight.add(p);
+    p.finally(() => this._inflight.delete(p));
+    return p;
+  }
+  async settle(maxTurns = 1e4) {
+    while ((this.hasPendingTransactions || this._inflight.size) && maxTurns-- > 0) {
+      while (this.hasPendingTransactions)
+        this.transactNext();
+      if (this._inflight.size)
+        await Promise.allSettled([...this._inflight]);
+    }
+  }
+  async _runRequest(path, name, args = [], opts = {}, parent = null, release = null) {
+    let released = false;
+    const transfer = (t) => {
+      if (release) {
+        released = true;
+        t.completion.whenSubtreeSettled().then(release);
+      }
     };
     try {
-      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);
+      const curRoot = this.state.val;
+      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) => {
+        const resArgs = specificName ? [singleArg] : [result, error];
+        const t = new ResponseEvent(path, this, specificName ?? baseName, resArgs, parent, resPath);
+        transfer(t);
+        this.pushTransaction(t);
+      };
+      try {
+        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);
+      }
+    } finally {
+      if (release && !released)
+        release();
     }
   }
   get hasPendingTransactions() {
@@ -13973,13 +14018,18 @@ class Transactor {
       this.transact(this.transactions.shift());
   }
   transact(transaction) {
-    const curState = this.state.val;
-    const newState = transaction.run(curState, this.comps);
-    if (newState !== undefined) {
-      this.state.set(newState, { transaction });
-      transaction.afterTransaction();
-    } else
-      console.warn("undefined new state", { curState, transaction });
+    try {
+      const curState = this.state.val;
+      const newState = transaction.run(curState, this.comps);
+      if (newState !== undefined) {
+        this.state.set(newState, { transaction });
+        transaction.afterTransaction();
+      } else
+        console.warn("undefined new state", { curState, transaction });
+    } finally {
+      transaction._completion?.ensureSelfSettled();
+      transaction._completion?.releaseSelf();
+    }
   }
   transactInputNow(path, event, eventHandler, dragInfo) {
     this.transact(new InputEvent(path, event, eventHandler, this, dragInfo));
@@ -14000,18 +14050,17 @@ class Transaction {
     this.path = path;
     this.transactor = transactor;
     this.parentTransaction = parentTransaction;
-    this._task = null;
+    this._completion = null;
   }
-  get task() {
-    this._task ??= new Task;
-    return this._task;
+  get completion() {
+    this._completion ??= new Completion;
+    return this._completion;
   }
-  getCompletionPromise() {
-    return this.task.promise;
+  whenSettled() {
+    return this.completion.whenSettled();
   }
-  setParent(parentTransaction) {
-    this.parentTransaction = parentTransaction;
-    parentTransaction.task.addDep(this.task);
+  whenSubtreeSettled() {
+    return this.completion.whenSubtreeSettled();
   }
   run(rootValue, comps) {
     return this.updateRootValue(rootValue, comps);
@@ -14037,7 +14086,7 @@ class Transaction {
     const txnPath = this.getTransactionPath();
     const curLeaf = txnPath.lookup(curRoot);
     const newLeaf = this.callHandler(curRoot, curLeaf, comps);
-    this._task?.complete?.({ value: newLeaf, old: curLeaf });
+    this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
     return curLeaf !== newLeaf ? txnPath.setValue(curRoot, newLeaf) : curRoot;
   }
   lookupName(_name) {
@@ -14048,29 +14097,65 @@ function getValue(e) {
   return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
 }
 
-class Task {
+class Completion {
   constructor() {
-    this.deps = [];
-    this.val = this.resolve = this.reject = null;
-    this.promise = new Promise((res, rej) => {
-      this.resolve = res;
-      this.reject = rej;
+    this.val = undefined;
+    this.selfSettled = false;
+    this.subtreeSettled = false;
+    this.pending = 1;
+    this._selfResolve = null;
+    this._selfPromise = null;
+    this._subtreeResolve = null;
+    this._subtreePromise = null;
+    this._selfReleased = false;
+  }
+  whenSettled() {
+    if (this.selfSettled)
+      return Promise.resolve(this.val);
+    this._selfPromise ??= new Promise((res) => {
+      this._selfResolve = res;
     });
-    this.isCompleted = false;
+    return this._selfPromise;
   }
-  addDep(task) {
-    console.assert(!this.isCompleted, "addDep for completed task", this, task);
-    this.deps.push(task);
-    task.promise.then((_) => this._check());
+  whenSubtreeSettled() {
+    if (this.subtreeSettled)
+      return Promise.resolve(this.val);
+    this._subtreePromise ??= new Promise((res) => {
+      this._subtreeResolve = res;
+    });
+    return this._subtreePromise;
   }
-  complete(val) {
+  markSelfSettled(val) {
+    if (this.selfSettled)
+      return;
+    this.selfSettled = true;
     this.val = val;
-    this._check();
+    this._selfResolve?.(val);
+  }
+  ensureSelfSettled() {
+    if (!this.selfSettled)
+      this.markSelfSettled(this.val);
+  }
+  track() {
+    this.pending++;
+    let done = false;
+    return () => {
+      if (done)
+        return;
+      done = true;
+      this._release();
+    };
+  }
+  releaseSelf() {
+    if (this._selfReleased)
+      return;
+    this._selfReleased = true;
+    this._release();
   }
-  _check() {
-    if (this.deps.every((task) => task.isCompleted)) {
-      this.isCompleted = true;
-      this.resolve(this);
+  _release() {
+    if (--this.pending === 0) {
+      this.subtreeSettled = true;
+      this._subtreeResolve?.(this.val);
     }
   }
 }
@@ -14109,11 +14194,17 @@ class Dispatcher {
   requestAtPath(path, name, args, opts) {
     return this.transactor.pushRequest(path, name, args, opts, this.parent);
   }
+  inputAtPath(path, name, args, opts) {
+    return this.transactor.pushInput(path, name, args, opts, this.parent);
+  }
   lookupTypeFor(name, inst) {
     return this.transactor.comps.getCompFor(inst).scope.lookupComponent(name);
   }
 }
-var toNullIfNaN = (v) => Number.isNaN(v) ? null : v, InputEvent, NameArgsTransaction, ResponseEvent, SendEvent, BubbleEvent, EventContext, RequestContext, PathChanges;
+function rootDispatcher(transactor) {
+  return new Dispatcher(new Path([]), transactor, null);
+}
+var toNullIfNaN = (v) => Number.isNaN(v) ? null : v, InputEvent, NameArgsTransaction, ResponseEvent, SendEvent, BubbleEvent, InputDispatchEvent, EventContext, RequestContext, PathChanges;
 var init_transactor = __esm(() => {
   init_path();
   init_stack();
@@ -14238,6 +14329,9 @@ var init_transactor = __esm(() => {
       this.opts.bubbles = false;
     }
   };
+  InputDispatchEvent = class InputDispatchEvent extends NameArgsTransaction {
+    handlerProp = "input";
+  };
   EventContext = class EventContext extends Dispatcher {
     get name() {
       return this.parent?.name ?? null;
@@ -14623,6 +14717,49 @@ var init_render2 = __esm(() => {
   init_render();
 });
 
+// src/on.js
+function phaseOps(phase) {
+  const ops = [];
+  for (const type3 of OP_KINDS)
+    for (const a of phase[type3] ?? [])
+      ops.push({ type: type3, ...a });
+  for (const a of phase.do ?? [])
+    ops.push(a);
+  return ops;
+}
+function resolveArgs(args, self) {
+  return typeof args === "function" ? args(self) ?? [] : args ?? [];
+}
+function dispatchPhase(dispatcher, targetPath, phase, self) {
+  if (!phase)
+    return;
+  for (const op of phaseOps(phase)) {
+    const args = resolveArgs(op.args, self);
+    switch (op.type) {
+      case "send":
+        dispatcher.sendAtPath(targetPath, op.name, args, op.opts);
+        break;
+      case "bubble":
+        dispatcher.sendAtPath(targetPath, op.name, args, {
+          skipSelf: true,
+          bubbles: true,
+          ...op.opts
+        });
+        break;
+      case "request":
+        dispatcher.requestAtPath(targetPath, op.name, args, op.opts);
+        break;
+      case "input":
+        dispatcher.inputAtPath(targetPath, op.name, args, op.opts);
+        break;
+    }
+  }
+}
+var OP_KINDS;
+var init_on = __esm(() => {
+  OP_KINDS = ["send", "bubble", "request", "input"];
+});
+
 // tools/core/tests.js
 class Describe {
   constructor({ title, componentName = null, parent = null }) {
@@ -14755,6 +14892,26 @@ function captureError(e) {
     out.actual = e.actual;
   return out;
 }
+function buildStack({ components = [], macros = null, requestHandlers = null } = {}) {
+  const stack = new ComponentStack;
+  stack.registerComponents(components);
+  if (macros)
+    stack.registerMacros(macros);
+  if (requestHandlers)
+    stack.registerRequestHandlers(requestHandlers);
+  return stack;
+}
+async function driveStack(stack, value, phase, opts = {}) {
+  const transactor = new Transactor(stack.comps, value);
+  if (opts.onMessage)
+    transactor.state.onChange(({ val, old, info }) => {
+      const t = info?.transaction;
+      opts.onMessage({ kind: t?.handlerProp ?? "input", name: t?.name, args: t?.args, path: t?.path }, old, val);
+    });
+  dispatchPhase(rootDispatcher(transactor), new Path([]), phase, value);
+  await transactor.settle();
+  return transactor.state.val;
+}
 async function runTests({
   getTests,
   components = [],
@@ -14762,7 +14919,9 @@ async function runTests({
   expect: expect2,
   name = null,
   grep = null,
-  bail = false
+  bail = false,
+  requestHandlers = null,
+  macros = null
 } = {}) {
   const counts = { pass: 0, fail: 0, skip: 0, total: 0 };
   if (typeof getTests !== "function") {
@@ -14774,7 +14933,10 @@ async function runTests({
     throw new Error("runTests: expect must be provided (e.g. chai's expect)");
   }
   const { describe, test: test2, moduleTests } = makeCollector({ path, components });
-  await getTests({ describe, test: test2, expect: expect2 });
+  let _stack = null;
+  const getStack = () => _stack ??= buildStack({ components, macros, requestHandlers });
+  const driveLocal = (value, phase, opts = {}) => driveStack(getStack(), value, phase, opts);
+  await getTests({ describe, test: test2, expect: expect2, drive: driveLocal });
   let bailed = false;
   async function visit(node) {
     if (node instanceof Test) {
@@ -14842,7 +15004,12 @@ async function runTests({
     modules: [new ModuleTestReport({ path, suites: suiteResults, counts })]
   });
 }
-var init_test = () => {};
+var init_test = __esm(() => {
+  init_components();
+  init_on();
+  init_path();
+  init_transactor();
+});
 
 // tools/cli/commands/_registry.js
 var exports__registry = {};
@@ -14930,7 +15097,9 @@ var init__registry = __esm(() => {
         expect,
         name: positionals[0] ?? null,
         grep: values.grep ?? null,
-        bail: values.bail ?? false
+        bail: values.bail ?? false,
+        requestHandlers: normalized.requestHandlers,
+        macros: normalized.macros
       }),
       exitOn: (result) => result.hasFailures ? 4 : 0
     }
@@ -15951,7 +16120,9 @@ async function runDevTests(projectDir, devModuleUrls) {
       getTests: mod.getTests,
       components: normalized.components,
       path: abs,
-      expect
+      expect,
+      requestHandlers: normalized.requestHandlers,
+      macros: normalized.macros
     });
     const m = report.modules[0];
     totalTests += m.counts.total;