tutuca 0.9.19 → 0.9.21

package/dist/tutuca-cli.js

@@ -667,191 +667,17 @@ __export(exports_md, {
   supports: () => supports2,
   format: () => format2
 });
-
-// src/util/docs.js
-function getSignature(name, fn) {
-  const s = fn.toString();
-  const m = s.match(/^(?:\w+|function\s*\w*)\s*\(([^)]*)\)/);
-  const params = m ? m[1].trim() : "";
-  return `${name}(${params})`;
-}
-function getFieldMethods(field) {
-  const { name, type } = field;
-  const uname = name[0].toUpperCase() + name.slice(1);
-  const methods = [
-    { name: `set${uname}`, sig: `set${uname}(v)`, desc: "Set value" },
-    {
-      name: `update${uname}`,
-      sig: `update${uname}(fn)`,
-      desc: "Update value with function"
-    },
-    {
-      name: `reset${uname}`,
-      sig: `reset${uname}()`,
-      desc: "Reset to default value"
-    },
-    {
-      name: `is${uname}NotSet`,
-      sig: `is${uname}NotSet()`,
-      desc: "Check if null/undefined"
-    },
-    {
-      name: `is${uname}Set`,
-      sig: `is${uname}Set()`,
-      desc: "Check if not null/undefined"
-    }
-  ];
-  switch (type) {
-    case "bool":
-      methods[0].desc = "Set value (coerces to boolean)";
-      methods.push({
-        name: `toggle${uname}`,
-        sig: `toggle${uname}()`,
-        desc: "Toggle boolean value"
-      });
-      break;
-    case "text":
-      methods.push({
-        name: `is${uname}Empty`,
-        sig: `is${uname}Empty()`,
-        desc: "Check if string is empty"
-      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get string length" });
-      break;
-    case "list":
-      methods.push({
-        name: `is${uname}Empty`,
-        sig: `is${uname}Empty()`,
-        desc: "Check if list is empty"
-      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get list size" }, {
-        name: `setIn${uname}At`,
-        sig: `setIn${uname}At(i, v)`,
-        desc: "Set item at index"
-      }, {
-        name: `getIn${uname}At`,
-        sig: `getIn${uname}At(i, defaultValue)`,
-        desc: "Get item at index"
-      }, {
-        name: `updateIn${uname}At`,
-        sig: `updateIn${uname}At(i, fn)`,
-        desc: "Update item at index with function"
-      }, {
-        name: `deleteIn${uname}At`,
-        sig: `deleteIn${uname}At(i)`,
-        desc: "Delete item at index"
-      }, {
-        name: `removeIn${uname}At`,
-        sig: `removeIn${uname}At(i)`,
-        desc: "Delete item at index (alias)"
-      }, {
-        name: `pushIn${uname}`,
-        sig: `pushIn${uname}(v)`,
-        desc: "Push item to end"
-      }, {
-        name: `insertIn${uname}At`,
-        sig: `insertIn${uname}At(i, v)`,
-        desc: "Insert item at index"
-      });
-      break;
-    case "map":
-    case "omap": {
-      const label = type === "omap" ? "ordered map" : "map";
-      methods.push({
-        name: `is${uname}Empty`,
-        sig: `is${uname}Empty()`,
-        desc: `Check if ${label} is empty`
-      }, {
-        name: `${name}Len`,
-        sig: `${name}Len()`,
-        desc: `Get ${label} size`
-      }, {
-        name: `setIn${uname}At`,
-        sig: `setIn${uname}At(key, v)`,
-        desc: "Set value at key"
-      }, {
-        name: `getIn${uname}At`,
-        sig: `getIn${uname}At(key, defaultValue)`,
-        desc: "Get value at key"
-      }, {
-        name: `updateIn${uname}At`,
-        sig: `updateIn${uname}At(key, fn)`,
-        desc: "Update value at key with function"
-      }, {
-        name: `deleteIn${uname}At`,
-        sig: `deleteIn${uname}At(key)`,
-        desc: "Delete entry at key"
-      }, {
-        name: `removeIn${uname}At`,
-        sig: `removeIn${uname}At(key)`,
-        desc: "Delete entry at key (alias)"
-      });
-      break;
-    }
-    case "set":
-      methods.push({
-        name: `is${uname}Empty`,
-        sig: `is${uname}Empty()`,
-        desc: "Check if set is empty"
-      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get set size" }, {
-        name: `addIn${uname}`,
-        sig: `addIn${uname}(v)`,
-        desc: "Add value to set"
-      }, {
-        name: `deleteIn${uname}`,
-        sig: `deleteIn${uname}(v)`,
-        desc: "Remove value from set"
-      }, {
-        name: `removeIn${uname}`,
-        sig: `removeIn${uname}(v)`,
-        desc: "Remove value from set (alias)"
-      }, {
-        name: `hasIn${uname}`,
-        sig: `hasIn${uname}(v)`,
-        desc: "Check if value is in set"
-      }, {
-        name: `toggleIn${uname}`,
-        sig: `toggleIn${uname}(v)`,
-        desc: "Toggle value in set"
-      });
-      break;
-  }
-  return methods;
-}
-function serializeDefault(v) {
-  if (v === null || v === undefined)
-    return v;
-  if (v?.toJS)
-    return v.toJS();
-  return v;
-}
-function getComponentDoc(comp) {
-  const meta = comp.Class.getMetaClass();
-  const { fields, name, methods } = meta;
-  const userMethods = Object.keys(methods).map((k) => ({
-    name: k,
-    sig: getSignature(k, methods[k])
-  }));
-  const inputHandlers = Object.keys(comp.input).map((k) => ({
-    name: k,
-    sig: getSignature(k, comp.input[k])
-  }));
-  const fieldDocs = [];
-  for (const fieldName in fields) {
-    const field = fields[fieldName];
-    fieldDocs.push({
-      name: fieldName,
-      type: field.type,
-      default: serializeDefault(field.defaultValue),
-      methods: getFieldMethods(field)
-    });
-  }
-  return { name, methods: userMethods, input: inputHandlers, fields: fieldDocs };
-}
-function getComponentsDocs(components) {
-  return components.map((comp) => getComponentDoc(comp));
-}
-function docsToMarkdown(docs) {
+var supports2 = new Set([
+  "ComponentDocs",
+  "RenderBatch",
+  "ExampleIndex",
+  "LintReport",
+  "ModuleInfo",
+  "ComponentList"
+]);
+function fmtComponentDocs2(docs) {
   const lines = [];
-  for (const comp of docs) {
+  for (const comp of docs.items) {
     lines.push(`# ${comp.name}
 `);
     if (comp.methods.length > 0) {
@@ -882,19 +708,6 @@ function docsToMarkdown(docs) {
   return lines.join(`
 `);
 }
-
-// tools/format/md.js
-var supports2 = new Set([
-  "ComponentDocs",
-  "RenderBatch",
-  "ExampleIndex",
-  "LintReport",
-  "ModuleInfo",
-  "ComponentList"
-]);
-function fmtComponentDocs2(docs) {
-  return docsToMarkdown(docs.items);
-}
 async function fmtRenderBatch2(batch, { pretty = false } = {}) {
   const prettify = pretty ? (await import("prettier")).format : null;
   const lines = [];
@@ -1212,6 +1025,186 @@ __export(exports_docs, {
 });
 
 // tools/core/docs.js
+function getSignature(name, fn) {
+  const s = fn.toString();
+  const m = s.match(/^(?:\w+|function\s*\w*)\s*\(([^)]*)\)/);
+  const params = m ? m[1].trim() : "";
+  return `${name}(${params})`;
+}
+function getFieldMethods(field) {
+  const { name, type } = field;
+  const uname = name[0].toUpperCase() + name.slice(1);
+  const methods = [
+    { name: `set${uname}`, sig: `set${uname}(v)`, desc: "Set value" },
+    {
+      name: `update${uname}`,
+      sig: `update${uname}(fn)`,
+      desc: "Update value with function"
+    },
+    {
+      name: `reset${uname}`,
+      sig: `reset${uname}()`,
+      desc: "Reset to default value"
+    },
+    {
+      name: `is${uname}NotSet`,
+      sig: `is${uname}NotSet()`,
+      desc: "Check if null/undefined"
+    },
+    {
+      name: `is${uname}Set`,
+      sig: `is${uname}Set()`,
+      desc: "Check if not null/undefined"
+    }
+  ];
+  switch (type) {
+    case "bool":
+      methods[0].desc = "Set value (coerces to boolean)";
+      methods.push({
+        name: `toggle${uname}`,
+        sig: `toggle${uname}()`,
+        desc: "Toggle boolean value"
+      });
+      break;
+    case "text":
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: "Check if string is empty"
+      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get string length" });
+      break;
+    case "list":
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: "Check if list is empty"
+      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get list size" }, {
+        name: `setIn${uname}At`,
+        sig: `setIn${uname}At(i, v)`,
+        desc: "Set item at index"
+      }, {
+        name: `getIn${uname}At`,
+        sig: `getIn${uname}At(i, defaultValue)`,
+        desc: "Get item at index"
+      }, {
+        name: `updateIn${uname}At`,
+        sig: `updateIn${uname}At(i, fn)`,
+        desc: "Update item at index with function"
+      }, {
+        name: `deleteIn${uname}At`,
+        sig: `deleteIn${uname}At(i)`,
+        desc: "Delete item at index"
+      }, {
+        name: `removeIn${uname}At`,
+        sig: `removeIn${uname}At(i)`,
+        desc: "Delete item at index (alias)"
+      }, {
+        name: `pushIn${uname}`,
+        sig: `pushIn${uname}(v)`,
+        desc: "Push item to end"
+      }, {
+        name: `insertIn${uname}At`,
+        sig: `insertIn${uname}At(i, v)`,
+        desc: "Insert item at index"
+      });
+      break;
+    case "map":
+    case "omap": {
+      const label = type === "omap" ? "ordered map" : "map";
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: `Check if ${label} is empty`
+      }, {
+        name: `${name}Len`,
+        sig: `${name}Len()`,
+        desc: `Get ${label} size`
+      }, {
+        name: `setIn${uname}At`,
+        sig: `setIn${uname}At(key, v)`,
+        desc: "Set value at key"
+      }, {
+        name: `getIn${uname}At`,
+        sig: `getIn${uname}At(key, defaultValue)`,
+        desc: "Get value at key"
+      }, {
+        name: `updateIn${uname}At`,
+        sig: `updateIn${uname}At(key, fn)`,
+        desc: "Update value at key with function"
+      }, {
+        name: `deleteIn${uname}At`,
+        sig: `deleteIn${uname}At(key)`,
+        desc: "Delete entry at key"
+      }, {
+        name: `removeIn${uname}At`,
+        sig: `removeIn${uname}At(key)`,
+        desc: "Delete entry at key (alias)"
+      });
+      break;
+    }
+    case "set":
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: "Check if set is empty"
+      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get set size" }, {
+        name: `addIn${uname}`,
+        sig: `addIn${uname}(v)`,
+        desc: "Add value to set"
+      }, {
+        name: `deleteIn${uname}`,
+        sig: `deleteIn${uname}(v)`,
+        desc: "Remove value from set"
+      }, {
+        name: `removeIn${uname}`,
+        sig: `removeIn${uname}(v)`,
+        desc: "Remove value from set (alias)"
+      }, {
+        name: `hasIn${uname}`,
+        sig: `hasIn${uname}(v)`,
+        desc: "Check if value is in set"
+      }, {
+        name: `toggleIn${uname}`,
+        sig: `toggleIn${uname}(v)`,
+        desc: "Toggle value in set"
+      });
+      break;
+  }
+  return methods;
+}
+function serializeDefault(v) {
+  if (v === null || v === undefined)
+    return v;
+  if (v?.toJS)
+    return v.toJS();
+  return v;
+}
+function getComponentDoc(comp) {
+  const meta = comp.Class.getMetaClass();
+  const { fields, name, methods } = meta;
+  const userMethods = Object.keys(methods).map((k) => ({
+    name: k,
+    sig: getSignature(k, methods[k])
+  }));
+  const inputHandlers = Object.keys(comp.input).map((k) => ({
+    name: k,
+    sig: getSignature(k, comp.input[k])
+  }));
+  const fieldDocs = [];
+  for (const fieldName in fields) {
+    const field = fields[fieldName];
+    fieldDocs.push({
+      name: fieldName,
+      type: field.type,
+      default: serializeDefault(field.defaultValue),
+      methods: getFieldMethods(field)
+    });
+  }
+  return { name, methods: userMethods, input: inputHandlers, fields: fieldDocs };
+}
+function getComponentsDocs(components) {
+  return components.map((comp) => getComponentDoc(comp));
+}
 function docComponents(normalized, { name = null } = {}) {
   const comps = normalized.components;
   const picked = name === null ? comps : comps.filter((c) => c.name === name);
@@ -2848,9 +2841,14 @@ class ComponentStack {
       comp.scope = this.enter();
       this.comps.registerComponent(comp);
       this.byName[comp.name] = comp;
-      const alias = aliases[comp.name];
-      if (alias)
+    }
+    for (const alias in aliases) {
+      const comp = this.byName[aliases[alias]];
+      console.assert(this.byName[alias] === undefined, "alias overrides component", alias);
+      if (comp !== undefined)
         this.byName[alias] = comp;
+      else
+        console.warn("alias", alias, "to inexistent component", aliases[alias]);
     }
   }
   registerMacros(macros) {
@@ -2877,34 +2875,43 @@ function defaultOnStackEnter(stack) {
   return stack;
 }
 
-// src/lint/index.js
+// tools/core/lint-check.js
 var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
+var ALT_HANDLER_NOT_REFERENCED = "ALT_HANDLER_NOT_REFERENCED";
 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 INPUT_HANDLER_NOT_IMPLEMENTED = "INPUT_HANDLER_NOT_IMPLEMENTED";
+var INPUT_HANDLER_NOT_REFERENCED = "INPUT_HANDLER_NOT_REFERENCED";
 var INPUT_HANDLER_METHOD_NOT_IMPLEMENTED = "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED";
 var INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD = "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD";
 var INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER = "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER";
 var FIELD_VAL_NOT_DEFINED = "FIELD_VAL_NOT_DEFINED";
 var COMPUTED_VAL_NOT_DEFINED = "COMPUTED_VAL_NOT_DEFINED";
+var COMPUTED_NOT_REFERENCED = "COMPUTED_NOT_REFERENCED";
 var UNKNOWN_REQUEST_NAME = "UNKNOWN_REQUEST_NAME";
 var UNKNOWN_COMPONENT_NAME = "UNKNOWN_COMPONENT_NAME";
 var LEVEL_WARN = "warn";
 var LEVEL_ERROR = "error";
 var LEVEL_HINT = "hint";
 function checkComponent(Comp, lx = new LintContext) {
-  checkEventHandlersHaveImpls(lx, Comp);
-  checkConsistentAttrs(lx, Comp);
+  const referencedAlters = new Set;
+  const referencedInputs = new Set;
+  const referencedComputed = new Set;
+  checkEventHandlersHaveImpls(lx, Comp, referencedInputs);
+  checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed);
   for (const name in Comp.views) {
-    checkView(lx, Comp.views[name], Comp);
+    checkView(lx, Comp.views[name], Comp, referencedAlters, referencedComputed);
   }
+  checkUnreferencedAlterHandlers(lx, Comp, referencedAlters);
+  checkUnreferencedInputHandlers(lx, Comp, referencedInputs);
+  checkUnreferencedComputed(lx, Comp, referencedComputed);
   return lx;
 }
-function checkView(lx, view, Comp) {
+function checkView(lx, view, Comp, referencedAlters, referencedComputed) {
   checkRenderItInLoop(lx, view);
   checkEventModifiers(lx, view);
-  checkKnownHandlerNames(lx, view, Comp);
+  checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComputed);
 }
 function checkRenderItInLoop(lx, view) {
   const { nodes } = view.ctx;
@@ -2956,7 +2963,7 @@ var KNOWN_HANDLER_NAMES = new Set([
 function isKnownHandlerName(name) {
   return KNOWN_HANDLER_NAMES.has(name);
 }
-function checkKnownHandlerNames(lx, view, Comp) {
+function checkKnownHandlerNames(lx, view, Comp, referencedAlters, referencedComputed) {
   const { computed, scope, alter, Class } = Comp;
   const { prototype: proto } = Class;
   const { fields } = Class.getMetaClass();
@@ -2965,12 +2972,12 @@ function checkKnownHandlerNames(lx, view, Comp) {
       const { args } = handler.handlerCall;
       for (let i = 0;i < args.length; i++) {
         const arg = args[i];
-        checkConsistentAttrVal(lx, arg, fields, proto, computed, scope, alter);
+        checkConsistentAttrVal(lx, arg, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
       }
     }
   }
 }
-function checkEventHandlersHaveImpls(lx, Comp) {
+function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
   const { input, views, Class } = Comp;
   const { prototype: proto } = Class;
   for (const viewName in views) {
@@ -2980,6 +2987,7 @@ function checkEventHandlersHaveImpls(lx, Comp) {
         const { handlerVal } = handler.handlerCall;
         const hvName = handlerVal?.constructor.name;
         if (hvName === "InputHandlerNameVal") {
+          referencedInputs?.add(handlerVal.name);
           if (input[handlerVal.name] === undefined) {
             lx.warn(INPUT_HANDLER_NOT_IMPLEMENTED, {
               name: handlerVal.name,
@@ -2995,6 +3003,7 @@ function checkEventHandlersHaveImpls(lx, Comp) {
             }
           }
         } else if (hvName === "RawFieldVal") {
+          referencedInputs?.add(handlerVal.name);
           if (proto[handlerVal.name] === undefined) {
             lx.warn(INPUT_HANDLER_METHOD_NOT_IMPLEMENTED, {
               name: handlerVal.name,
@@ -3014,7 +3023,7 @@ function checkEventHandlersHaveImpls(lx, Comp) {
     }
   }
 }
-function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter) {
+function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed) {
   const valName = val?.constructor.name;
   if (valName === "FieldVal" || valName === "RawFieldVal") {
     const { name } = val;
@@ -3023,12 +3032,13 @@ function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter)
     }
   } else if (valName === "ComputedVal") {
     const { name } = val;
+    referencedComputed?.add(name);
     if (computed[name] === undefined) {
       lx.error(COMPUTED_VAL_NOT_DEFINED, { val, name });
     }
   } else if (valName === "SeqAccessVal") {
-    checkConsistentAttrVal(lx, val.seqVal, fields, proto, computed, scope, alter);
-    checkConsistentAttrVal(lx, val.keyVal, fields, proto, computed, scope, alter);
+    checkConsistentAttrVal(lx, val.seqVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
+    checkConsistentAttrVal(lx, val.keyVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
   } else if (valName === "RequestVal") {
     if (scope.lookupRequest(val.name) === null) {
       lx.warn(UNKNOWN_REQUEST_NAME, { name: val.name });
@@ -3043,9 +3053,10 @@ function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter)
     }
   } else if (valName === "StrTplVal") {
     for (const subVal of val.vals) {
-      checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter);
+      checkConsistentAttrVal(lx, subVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
     }
   } else if (valName === "AlterHandlerNameVal") {
+    referencedAlters?.add(val.name);
     if (alter[val.name] === undefined) {
       lx.warn(ALT_HANDLER_NOT_DEFINED, { name: val.name });
     }
@@ -3053,7 +3064,7 @@ function checkConsistentAttrVal(lx, val, fields, proto, computed, scope, alter)
     console.log(val);
   }
 }
-function checkConsistentAttrs(lx, Comp) {
+function checkConsistentAttrs(lx, Comp, referencedAlters, referencedComputed) {
   const { computed, scope, views, alter, Class } = Comp;
   const { prototype: proto } = Class;
   const { fields } = Class.getMetaClass();
@@ -3064,7 +3075,7 @@ function checkConsistentAttrs(lx, Comp) {
       if (attrs?.constructor.name === "DynAttrs") {
         for (const attr2 of attrs.items) {
           if (attr2?.constructor.name === "Attr") {
-            checkConsistentAttrVal(lx, attr2.val, fields, proto, computed, scope, alter);
+            checkConsistentAttrVal(lx, attr2.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
           }
         }
       }
@@ -3072,27 +3083,48 @@ function checkConsistentAttrs(lx, Comp) {
         for (const w of wrapperAttrs) {
           if (w.name === "each") {
             if (w.whenVal)
-              checkConsistentAttrVal(lx, w.whenVal, fields, proto, computed, scope, alter);
+              checkConsistentAttrVal(lx, w.whenVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
             if (w.enrichWithVal)
-              checkConsistentAttrVal(lx, w.enrichWithVal, fields, proto, computed, scope, alter);
+              checkConsistentAttrVal(lx, w.enrichWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
             if (w.loopWithVal)
-              checkConsistentAttrVal(lx, w.loopWithVal, fields, proto, computed, scope, alter);
+              checkConsistentAttrVal(lx, w.loopWithVal, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
           } else if (w.name !== "scope") {
-            checkConsistentAttrVal(lx, w.val, fields, proto, computed, scope, alter);
+            checkConsistentAttrVal(lx, w.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
           }
         }
       }
       if (textChild) {
-        checkConsistentAttrVal(lx, textChild, fields, proto, computed, scope, alter);
+        checkConsistentAttrVal(lx, textChild, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
       }
     }
     for (const node of view.ctx.nodes) {
       if (node.val) {
-        checkConsistentAttrVal(lx, node.val, fields, proto, computed, scope, alter);
+        checkConsistentAttrVal(lx, node.val, fields, proto, computed, scope, alter, referencedAlters, referencedComputed);
       }
     }
   }
 }
+function checkUnreferencedAlterHandlers(lx, Comp, referencedAlters) {
+  for (const name in Comp.alter) {
+    if (!referencedAlters.has(name)) {
+      lx.hint(ALT_HANDLER_NOT_REFERENCED, { name });
+    }
+  }
+}
+function checkUnreferencedInputHandlers(lx, Comp, referencedInputs) {
+  for (const name in Comp.input) {
+    if (!referencedInputs.has(name)) {
+      lx.hint(INPUT_HANDLER_NOT_REFERENCED, { name });
+    }
+  }
+}
+function checkUnreferencedComputed(lx, Comp, referencedComputed) {
+  for (const name in Comp.computed) {
+    if (!referencedComputed.has(name)) {
+      lx.hint(COMPUTED_NOT_REFERENCED, { name });
+    }
+  }
+}
 
 class LintContext {
   constructor() {
@@ -3405,9 +3437,10 @@ class Transactor {
   }
 }
 function mkReq404(name) {
-  return () => {
+  const fn = () => {
     throw new Error(`Request not found: ${name}`);
   };
+  return { fn };
 }
 function nullHandler() {
   return this;
@@ -4048,15 +4081,13 @@ class App {
   _dispatchEvent(e) {
     const { type } = e;
     const isDrag = type === "dragover" || type === "dragstart" || type === "dragend";
-    const { rootNode: root, maxEventNodeDepth: maxDepth, comps } = this;
+    const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
     const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
     if (isDrag)
       this._handleDragEvent(e, type, path);
-    if (path !== null && handlers !== null) {
-      for (const handler of handlers) {
-        this.transactor.transactInputNow(path, e, handler, this.dragInfo);
-      }
-    }
+    if (path !== null && handlers !== null)
+      for (const handler of handlers)
+        transactor.transactInputNow(path, e, handler, this.dragInfo);
   }
   _handleTouchEvent(e) {
     const { type } = e;