tutuca 0.11.2 → 0.12.0

package/dist/tutuca-dev.js

@@ -5469,6 +5469,9 @@ var PathBuilder = class {
   }
 };
 
+// src/util/env.js
+var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
+
 // src/value.js
 var VALID_VAL_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*\??$/;
 var isValidValId = (name) => VALID_VAL_ID_RE.test(name);
@@ -5487,6 +5490,7 @@ var K_NAME = 32;
 var K_TYPE = 64;
 var K_SEQ = 256;
 var K_METHOD = 1024;
+var K_EVENT = 2048;
 var G_BOOL = K_FIELD | K_METHOD | K_BIND | K_DYN | K_CONST;
 var G_TEXT = G_BOOL | K_STRTPL;
 var G_COMPONENT = K_FIELD | K_SEQ | K_DYN;
@@ -5494,6 +5498,7 @@ var G_SEQUENCE = K_FIELD | K_DYN;
 var G_PROVIDE = K_FIELD | K_SEQ;
 var G_FIELD = K_FIELD | K_METHOD | K_CONST | K_SEQ;
 var G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_CONST;
+var G_HANDLER_ARG = G_VALUE & ~K_NAME | K_EVENT;
 var G_ALL = G_VALUE | K_STRTPL | K_SEQ;
 function sizeOf(v) {
   if (v == null) return null;
@@ -5503,6 +5508,10 @@ function sizeOf(v) {
   if (typeof l === "number") return l;
   return isPlainObject(v) ? Object.keys(v).length : null;
 }
+var toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
+function getValue(e) {
+  return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
+}
 var predTruthy = (v) => {
   const n = sizeOf(v);
   return n === null ? !!v : n > 0;
@@ -5553,6 +5562,10 @@ function parseToken(s, px) {
   const num = VALID_FLOAT_RE.test(s) ? parseFloat(s) : null;
   if (Number.isFinite(num)) return new ConstVal(num);
   if (s === "true" || s === "false") return new ConstVal(s === "true");
+  if (c0 === 101) {
+    const m = /^e(\.[a-zA-Z][a-zA-Z0-9_]*)+$/.exec(s);
+    if (m !== null) return new EventMemberVal(s.split(".").slice(1));
+  }
   if (c0 >= 97 && c0 <= 122) return mkVal(s, NameVal);
   if (c0 >= 65 && c0 <= 90) return mkVal(s, TypeVal);
   return null;
@@ -5628,7 +5641,7 @@ function _parseHandler(s, px, namespace, allowArgs, report, allowMethod) {
   const args = new Array(tokens.length - 1);
   for (let i = 1; i < tokens.length; i++) {
     const val = parseToken(tokens[i], px);
-    if (val !== null && kindOf(val) & G_VALUE) args[i - 1] = val;
+    if (val !== null && kindOf(val) & G_HANDLER_ARG) args[i - 1] = val;
     else {
       if (report) px.onParseIssue("bad-value", { role: "handler-arg", value: tokens[i] });
       args[i - 1] = NULL_CONST_VAL;
@@ -5671,6 +5684,7 @@ function kindOf(val) {
   if (val instanceof DynVal) return K_DYN;
   if (val instanceof TypeVal) return K_TYPE;
   if (val instanceof NameVal) return K_NAME;
+  if (val instanceof EventMemberVal) return K_EVENT;
   return 0;
 }
 var BaseVal = class {
@@ -5795,11 +5809,14 @@ var HandlerNameVal = class extends NameVal {
     this.namespace = namespace;
   }
   eval(stack) {
-    return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(this.namespace, this.name);
+    return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(stack, this.namespace, this.name);
   }
 };
-var mk404Handler = (type3, name) => function(...args) {
-  console.warn("handler not found", { type: type3, name, args }, this);
+var mk404Handler = (stack, type3, name) => function(...args) {
+  const transactor = stack?.ctx?.transactor;
+  if (transactor)
+    transactor.refuse("NO_HANDLER", { namespace: type3, name, argCount: args.length });
+  else console.warn("handler not found", { type: type3, name });
   return this;
 };
 var TypeVal = class extends NameVal {
@@ -5807,6 +5824,53 @@ var TypeVal = class extends NameVal {
     return stack.lookupType(this.name);
   }
 };
+var keyIs = (k) => (e) => e.key === k;
+var macCtrl = (e) => isMac && e.metaKey || e.ctrlKey;
+var nullSafe = (fn) => (e, stack) => {
+  const info = stack.lookupDragInfo();
+  return info == null ? null : fn(info);
+};
+var EVENT_CONVENIENCES = {
+  value: (e) => getValue(e),
+  valueAsInt: (e) => toNullIfNaN(parseInt(getValue(e), 10)),
+  valueAsFloat: (e) => toNullIfNaN(parseFloat(getValue(e))),
+  isAlt: (e) => e.altKey,
+  isShift: (e) => e.shiftKey,
+  isCtrl: macCtrl,
+  isCmd: macCtrl,
+  isUpKey: keyIs("ArrowUp"),
+  isDownKey: keyIs("ArrowDown"),
+  isSend: keyIs("Enter"),
+  isCancel: keyIs("Escape"),
+  isTabKey: keyIs("Tab"),
+  dragInfo: (_e, stack) => stack.lookupDragInfo(),
+  dragType: nullSafe((info) => info.type),
+  dragValue: nullSafe((info) => info.val),
+  dragKey: nullSafe((info) => info.lookupBind("key"))
+};
+var EventMemberVal = class extends BaseVal {
+  constructor(members) {
+    super();
+    this.members = members;
+  }
+  eval(stack) {
+    const e = stack.lookupEvent();
+    if (e == null) return null;
+    if (this.members.length === 1) {
+      const convenience = EVENT_CONVENIENCES[this.members[0]];
+      if (convenience !== void 0) return convenience(e, stack);
+    }
+    let v = e;
+    for (const member of this.members) {
+      if (v == null) return null;
+      v = v[member];
+    }
+    return v ?? null;
+  }
+  toString() {
+    return `e.${this.members.join(".")}`;
+  }
+};
 var RenderVal = class extends BaseVal {
   render(stack, _rx) {
     return this.eval(stack);
@@ -6738,9 +6802,6 @@ var unkIter = () => {
 };
 var SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
 
-// src/util/env.js
-var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
-
 // src/anode.js
 function resolveDynProducer(comp, name) {
   let producerComp, producerProvide;
@@ -10038,7 +10099,6 @@ var LOOKUP_BAD_SHAPE = "LOOKUP_BAD_SHAPE";
 var LOOKUP_TARGET_MALFORMED = "LOOKUP_TARGET_MALFORMED";
 var RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
 var UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
-var UNKNOWN_HANDLER_ARG_NAME = "UNKNOWN_HANDLER_ARG_NAME";
 var RECEIVE_HANDLER_NOT_IMPLEMENTED = "RECEIVE_HANDLER_NOT_IMPLEMENTED";
 var EVENT_HANDLER_METHOD_NOT_ALLOWED = "EVENT_HANDLER_METHOD_NOT_ALLOWED";
 var HANDLER_NAME_COLLISION = "HANDLER_NAME_COLLISION";
@@ -10392,29 +10452,6 @@ function checkEventModifiers(lx, view) {
     }
   }
 }
-var KNOWN_HANDLER_NAMES = /* @__PURE__ */ new Set([
-  "value",
-  "valueAsInt",
-  "valueAsFloat",
-  "target",
-  "event",
-  "isAlt",
-  "isShift",
-  "isCtrl",
-  "isCmd",
-  "key",
-  "keyCode",
-  "isUpKey",
-  "isDownKey",
-  "isSend",
-  "isCancel",
-  "isTabKey",
-  "ctx",
-  "dragInfo"
-]);
-function isKnownHandlerName(name) {
-  return KNOWN_HANDLER_NAMES.has(name);
-}
 function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedDynamics) {
   const env = mkAttrValEnv(Comp, referencedAlters, referencedDynamics);
   for (const event of view.ctx.events) {
@@ -10524,10 +10561,11 @@ var ATTR_VAL_CHECKERS = {
         errCtx
       );
   },
-  NameVal({ lx, val, errCtx, skipNameVal }) {
-    if (!skipNameVal && !isKnownHandlerName(val.name))
-      reportUnknownName(lx, UNKNOWN_HANDLER_ARG_NAME, val.name, KNOWN_HANDLER_NAMES, errCtx);
-  },
+  // NameVals on a macro call-site attribute are macro-param bindings, not
+  // handler args — their role is determined inside the macro body after
+  // ^-substitution, where re-parsing handles validation. No checker: a NameVal
+  // can no longer reach a handler-arg slot (sigil-less words fail to parse),
+  // and macro-attr pass-throughs are skipped via skipNameVal.
   StrTplVal({ lx, val, errCtx, recurse, isRoot }) {
     const vs = val.vals;
     const literal = val.toLiteralSource();
@@ -11424,8 +11462,19 @@ var Stack = class _Stack {
     const fn = this.it[name];
     return fn instanceof Function ? fn.call(this.it) : null;
   }
-  lookupName(name) {
-    return this.ctx.lookupName(name);
+  // Bare implicit event names are gone: a sigil-less word cannot reach a
+  // handler-arg slot anymore, so this only ever serves stale NameVals parsed
+  // before the removal (e.g. macro-attr pass-throughs). Always null.
+  lookupName(_name) {
+    return null;
+  }
+  // The dispatched DOM event / drag info, read only by EventMemberVal's
+  // `e.<member>` handler args. Null outside a live event transaction.
+  lookupEvent() {
+    return this.ctx?.event ?? null;
+  }
+  lookupDragInfo() {
+    return this.ctx?.dragInfo ?? null;
   }
   getHandlerFor(name, key) {
     return this.comps.getHandlerFor(this.it, name, key);
@@ -11467,6 +11516,8 @@ var Transactor = class {
     this.onTransactionPushed = () => {
     };
     this._observers = [];
+    this.refusals = [];
+    this._refusalObservers = [];
     this._inflight = /* @__PURE__ */ new Set();
   }
   pushTransaction(t) {
@@ -11490,6 +11541,29 @@ var Transactor = class {
   _emit(record) {
     for (const cb of this._observers) cb(record);
   }
+  // Record a refusal: a dispatch the runtime could not carry out. Kinds are
+  // open strings; today the runtime raises NO_HANDLER (a receive name with no
+  // implementation, including the auto-generated fallback firing at dispatch
+  // time) and FORWARD_NO_NAME (ctx.forward() from a handler whose view wrote
+  // no name). Records carry { kind, info, timestamp } and are observational —
+  // the dispatch itself has already failed gracefully.
+  refuse(kind, info = {}) {
+    const record = { kind, info, timestamp: Date.now() };
+    this.refusals.push(record);
+    if (this.refusals.length > REFUSAL_RING_CAP) this.refusals.shift();
+    console.warn(`tutuca refusal [${kind}]`, info);
+    for (const cb of this._refusalObservers) cb(record);
+    return record;
+  }
+  // Subscribe to refusal records as they happen. Returns an unsubscribe fn,
+  // like observe().
+  observeRefusals(cb) {
+    this._refusalObservers.push(cb);
+    return () => {
+      const i = this._refusalObservers.indexOf(cb);
+      if (i !== -1) this._refusalObservers.splice(i, 1);
+    };
+  }
   // Build and dispatch the observer record for a settled transaction. The
   // resolved handler (`_resolvedHandler`/`_matched`) and per-leaf before/after
   // (`_before`/`_after`) were captured while the handler ran (see callHandler /
@@ -11655,14 +11729,7 @@ var Transaction = class {
     this._completion?.markSelfSettled({ value: newLeaf, old: curLeaf });
     return curLeaf !== newLeaf ? txnPath.setValue(curRoot, newLeaf) : curRoot;
   }
-  lookupName(_name) {
-    return null;
-  }
 };
-var toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
-function getValue(e) {
-  return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
-}
 var InputEvent = class extends Transaction {
   constructor(path, e, handler, transactor, dragInfo) {
     super(path, transactor);
@@ -11700,8 +11767,10 @@ var InputEvent = class extends Transaction {
     const { args = this._handlerArgs ?? [], ...rest } = f;
     const hv = this.handler?.handlerCall?.handlerVal ?? this.handler?.handlerVal;
     const name = hv?.name;
-    if (name === void 0)
-      return console.warn("ctx.forward() from a handler with no name - ignored");
+    if (name === void 0) {
+      this.transactor.refuse("FORWARD_NO_NAME", {});
+      return;
+    }
     this.transactor.pushIntent(this.dispatchPath, name, args, rest, this);
   }
   buildRootStack(root, comps) {
@@ -11715,47 +11784,11 @@ var InputEvent = class extends Transaction {
     args.push(new EventContext(path, this.transactor, this));
     return [handler, args];
   }
-  lookupName(name) {
-    const { e } = this;
-    switch (name) {
-      case "value":
-        return getValue(e);
-      case "valueAsInt":
-        return toNullIfNaN(parseInt(getValue(e), 10));
-      case "valueAsFloat":
-        return toNullIfNaN(parseFloat(getValue(e)));
-      case "target":
-        return e.target;
-      case "event":
-        return e;
-      case "isAlt":
-        return e.altKey;
-      case "isShift":
-        return e.shiftKey;
-      case "isCtrl":
-      /* falls through */
-      case "isCmd":
-        return isMac && e.metaKey || e.ctrlKey;
-      case "key":
-        return e.key;
-      case "keyCode":
-        return e.keyCode;
-      case "isUpKey":
-        return e.key === "ArrowUp";
-      case "isDownKey":
-        return e.key === "ArrowDown";
-      case "isSend":
-        return e.key === "Enter";
-      case "isCancel":
-        return e.key === "Escape";
-      case "isTabKey":
-        return e.key === "Tab";
-      case "ctx":
-        return new EventContext(this.dispatchPath, this.transactor, this);
-      case "dragInfo":
-        return this.dragInfo;
-    }
-    return null;
+  // The dispatched DOM event, read only through `e.<member>` handler args
+  // (src/value.js EventMemberVal via Stack.lookupEvent). There is no bare
+  // implicit-name vocabulary anymore: every arg carries a sigil.
+  get event() {
+    return this.e;
   }
 };
 var NameArgsTransaction = class extends Transaction {
@@ -11846,6 +11879,7 @@ var IntentEvent = class extends NameArgsTransaction {
   }
 };
 var PASS = /* @__PURE__ */ Symbol.for("tutuca.intent.pass");
+var REFUSAL_RING_CAP = 200;
 var DEFAULT_ROUTE = ["dyn", "lex"];
 var INTENT_DEPTH = 64;
 var IntentWalk = class {
@@ -12636,8 +12670,6 @@ function lintIdToMessage(id, info) {
       const written = `@on.${info.name}+${mods.join("+")}`;
       return `Unknown modifier '+${info.modifier}' in '${written}'`;
     }
-    case "UNKNOWN_HANDLER_ARG_NAME":
-      return `Unknown handler argument '${info.name}'${fmtOriginSuffix(info)}`;
     case "HANDLER_NAME_COLLISION":
       return `${info.problem} — ${info.fix}`;
     case "RECEIVE_HANDLER_NOT_IMPLEMENTED":
@@ -13329,7 +13361,6 @@ export {
   UNKNOWN_COMPONENT_SPEC_KEY,
   UNKNOWN_DIRECTIVE,
   UNKNOWN_EVENT_MODIFIER,
-  UNKNOWN_HANDLER_ARG_NAME,
   UNKNOWN_MACRO_ARG,
   UNKNOWN_X_ATTR,
   UNKNOWN_X_OP,