tutuca 0.9.68 → 0.9.70

package/dist/tutuca-dev.ext.js

@@ -5264,16 +5264,16 @@ function parseXOpVal(opName, value, px, parserFn) {
   return val;
 }
 function processXExtras(node, attrs, opName, startIdx, px) {
-  const consumed = X_OP_CONSUMED[opName];
-  const wrappable = X_OP_WRAPPABLE.has(opName);
+  const { consumed, wrappable } = X_OPS[opName];
   const wrappers = [];
   for (let i = startIdx;i < attrs.length; i++) {
     const a = attrs[i];
     const aName = a.name;
     if (consumed.has(aName))
       continue;
-    if (wrappable && X_ATTR_WRAPPERS[aName]) {
-      wrappers.push([X_ATTR_WRAPPERS[aName], vp.parseBool(a.value, px)]);
+    const wrapper = wrappable ? X_OPS[aName]?.wrapper : null;
+    if (wrapper) {
+      wrappers.push([wrapper, vp.parseBool(a.value, px)]);
       continue;
     }
     const issueInfo = { op: opName, name: aName, value: a.value };
@@ -5365,6 +5365,12 @@ class RenderViewId extends ANode {
   }
   setDataAttr(_key, _val) {}
 }
+function dynRenderStep(comp, name, key) {
+  const p = resolveDynProducer(comp, name);
+  if (!p)
+    return null;
+  return key === undefined ? new DynStep(p.producerCompId, p.producerSteps) : new DynEachStep(p.producerCompId, p.producerSteps, key);
+}
 
 class RenderNode extends RenderViewId {
   render(stack, rx) {
@@ -5372,10 +5378,8 @@ class RenderNode extends RenderViewId {
     return rx.renderIt(newStack, this, "", this.viewId);
   }
   toPathStep(ctx) {
-    if (this.val instanceof DynVal) {
-      const p = resolveDynProducer(ctx.comp, this.val.name);
-      return p ? new DynStep(p.producerCompId, p.producerSteps) : null;
-    }
+    if (this.val instanceof DynVal)
+      return dynRenderStep(ctx.comp, this.val.name);
     return super.toPathStep(ctx);
   }
 }
@@ -5391,10 +5395,8 @@ class RenderItNode extends RenderViewId {
       return null;
     const nextNode = next.resolveNode();
     if (nextNode instanceof EachNode && next.hasKey) {
-      if (nextNode.val instanceof DynVal) {
-        const p = resolveDynProducer(ctx.comp, nextNode.val.name);
-        return p ? new DynEachStep(p.producerCompId, p.producerSteps, next.key) : null;
-      }
+      if (nextNode.val instanceof DynVal)
+        return dynRenderStep(ctx.comp, nextNode.val.name, next.key);
       return new EachRenderItStep(nextNode.val.name, next.key);
     }
     return null;
@@ -5410,12 +5412,8 @@ class RenderEachNode extends RenderViewId {
     return rx.renderEach(stack, this.iterInfo, this, this.viewId);
   }
   toPathStep(ctx) {
-    if (this.val instanceof DynVal) {
-      if (!ctx.hasKey)
-        return null;
-      const p = resolveDynProducer(ctx.comp, this.val.name);
-      return p ? new DynEachStep(p.producerCompId, p.producerSteps, ctx.key) : null;
-    }
+    if (this.val instanceof DynVal)
+      return ctx.hasKey ? dynRenderStep(ctx.comp, this.val.name, ctx.key) : null;
     return super.toPathStep(ctx);
   }
   static parse(px, vp2, s, as, attrs) {
@@ -5545,17 +5543,18 @@ class IterInfo {
 }
 var filterAlwaysTrue = (_v, _k, _seq) => true;
 var nullLoopWith = (seq) => ({ iterData: { seq } });
-var X_OP_CONSUMED = {
-  slot: new Set,
-  text: new Set,
-  render: new Set(["as"]),
-  "render-it": new Set(["as"]),
-  "render-each": new Set(["as", "when", "loop-with"]),
-  show: new Set,
-  hide: new Set
-};
-var X_OP_WRAPPABLE = new Set(["text", "render", "render-it", "render-each"]);
-var X_ATTR_WRAPPERS = { show: ShowNode, hide: HideNode };
+function xOp(consumed = [], { wrappable = false, wrapper = null } = {}) {
+  return { consumed: new Set(consumed), wrappable, wrapper };
+}
+var X_OPS = {
+  slot: xOp(),
+  text: xOp([], { wrappable: true }),
+  render: xOp(["as"], { wrappable: true }),
+  "render-it": xOp(["as"], { wrappable: true }),
+  "render-each": xOp(["as", "when", "loop-with"], { wrappable: true }),
+  show: xOp([], { wrapper: ShowNode }),
+  hide: xOp([], { wrapper: HideNode })
+};
 var WRAPPER_NODES = {
   slot: SlotNode,
   show: ShowNode,
@@ -5643,29 +5642,30 @@ var isBlockDomNode = (n) => {
   const node = n instanceof FragmentNode ? n.childs[0] : n;
   return node instanceof DomNode && HTML_BLOCK_TAGS.has(node.tagName);
 };
+var isEmptyText = (c) => c instanceof TextNode && c.val === "";
+function trimEdgeWhite(node) {
+  if (!node.isWhiteSpace?.())
+    return false;
+  node.condenseWhiteSpace();
+  return true;
+}
 function condenseChildsWhites(childs) {
   if (childs.length === 0)
     return childs;
-  let changed = false;
-  if (childs[0].isWhiteSpace?.()) {
-    childs[0].condenseWhiteSpace();
-    changed = true;
-  }
   const last = childs.length - 1;
-  if (last > 0 && childs[last].isWhiteSpace?.()) {
-    childs[last].condenseWhiteSpace();
-    changed = true;
-  }
+  let emptied = trimEdgeWhite(childs[0]);
+  if (last > 0 && trimEdgeWhite(childs[last]))
+    emptied = true;
   for (let i = 1;i < last; i++) {
     const cur = childs[i];
-    if (cur.isWhiteSpace?.() && cur.hasNewLine()) {
-      const bothBlock = isBlockDomNode(childs[i - 1]) && isBlockDomNode(childs[i + 1]);
-      cur.condenseWhiteSpace(bothBlock ? "" : " ");
-      if (bothBlock)
-        changed = true;
-    }
+    if (!(cur.isWhiteSpace?.() && cur.hasNewLine()))
+      continue;
+    const bothBlock = isBlockDomNode(childs[i - 1]) && isBlockDomNode(childs[i + 1]);
+    cur.condenseWhiteSpace(bothBlock ? "" : " ");
+    if (bothBlock)
+      emptied = true;
   }
-  return changed ? childs.filter((c) => !(c instanceof TextNode && c.val === "")) : childs;
+  return emptied ? childs.filter((c) => !isEmptyText(c)) : childs;
 }
 
 class View {
@@ -8180,12 +8180,6 @@ var REDUNDANT_TEMPLATE_STRING = "REDUNDANT_TEMPLATE_STRING";
 var PLACEHOLDERLESS_TEMPLATE_STRING = "PLACEHOLDERLESS_TEMPLATE_STRING";
 var UNKNOWN_COMPONENT_SPEC_KEY = "UNKNOWN_COMPONENT_SPEC_KEY";
 var COMP_FIELD_BAD_SHAPE = "COMP_FIELD_BAD_SHAPE";
-var PARSE_ISSUE_KIND_TO_LINT_ID = {
-  "unknown-directive": UNKNOWN_DIRECTIVE,
-  "unknown-x-op": UNKNOWN_X_OP,
-  "unknown-x-attr": UNKNOWN_X_ATTR,
-  "bad-value": BAD_VALUE
-};
 var X_KNOWN_OP_NAMES = new Set([
   "slot",
   "text",
@@ -8196,17 +8190,18 @@ var X_KNOWN_OP_NAMES = new Set([
   "hide"
 ]);
 var X_KNOWN_ATTR_NAMES = new Set(["as", "when", "loop-with", "show", "hide"]);
-var AT_PREFIX_HINT_KNOWN_BY_KIND = {
-  "unknown-x-op": X_KNOWN_OP_NAMES,
-  "unknown-x-attr": X_KNOWN_ATTR_NAMES
-};
 var LEVEL_WARN2 = "warn";
 var LEVEL_ERROR2 = "error";
 var LEVEL_HINT = "hint";
-var PARSE_ISSUE_KIND_TO_KNOWN_NAMES = {
-  "unknown-directive": KNOWN_DIRECTIVE_NAMES,
-  "unknown-x-op": X_KNOWN_OP_NAMES,
-  "unknown-x-attr": X_KNOWN_ATTR_NAMES
+var PARSE_ISSUES = {
+  "unknown-directive": { id: UNKNOWN_DIRECTIVE, candidates: KNOWN_DIRECTIVE_NAMES },
+  "unknown-x-op": { id: UNKNOWN_X_OP, candidates: X_KNOWN_OP_NAMES, atPrefix: X_KNOWN_OP_NAMES },
+  "unknown-x-attr": {
+    id: UNKNOWN_X_ATTR,
+    candidates: X_KNOWN_ATTR_NAMES,
+    atPrefix: X_KNOWN_ATTR_NAMES
+  },
+  "bad-value": { id: BAD_VALUE }
 };
 function collectProtoMethodNames(proto) {
   const out = [];
@@ -8301,9 +8296,10 @@ function checkParseIssues(lx, view) {
   if (!issues)
     return;
   for (const { kind, info } of issues) {
-    const id = PARSE_ISSUE_KIND_TO_LINT_ID[kind];
-    if (!id)
+    const rule = PARSE_ISSUES[kind];
+    if (!rule)
       continue;
+    const id = rule.id;
     if (kind === "bad-value") {
       const detected = classifyBadValue(info.value);
       if (detected) {
@@ -8311,15 +8307,13 @@ function checkParseIssues(lx, view) {
         continue;
       }
     }
-    const atPrefixKnown = AT_PREFIX_HINT_KNOWN_BY_KIND[kind];
+    const atPrefixKnown = rule.atPrefix;
     const isAtPrefixedTypo = atPrefixKnown && info.name?.startsWith("@") && atPrefixKnown.has(info.name.slice(1));
     let suggestion = null;
     if (isAtPrefixedTypo) {
       suggestion = { kind: "drop-prefix", from: info.name, to: info.name.slice(1) };
-    } else {
-      const candidates = PARSE_ISSUE_KIND_TO_KNOWN_NAMES[kind];
-      if (candidates)
-        suggestion = replaceNameSuggestion(info.name, candidates);
+    } else if (rule.candidates) {
+      suggestion = replaceNameSuggestion(info.name, rule.candidates);
     }
     lx.error(id, info, suggestion);
     if (isAtPrefixedTypo) {
@@ -8489,70 +8483,83 @@ function checkEventHandlersHaveImpls(lx, Comp, referencedInputs) {
     });
   }
 }
-function checkConsistentAttrVal(lx, val, env, skipNameVal = false, errCtx = null) {
-  const { fields, proto, scope, alter } = env;
-  const valName = val?.constructor.name;
-  if (valName === "FieldVal") {
+var fixTo = (from, to) => ({ kind: "rewrite", from, to });
+function reportUnknownName(lx, code, name, candidates, info) {
+  lx.error(code, { ...info, name }, replaceNameSuggestion(name, candidates));
+}
+var ATTR_VAL_CHECKERS = {
+  FieldVal({ lx, val, env, errCtx }) {
+    const { fields, proto } = env;
     const { name } = val;
-    if (fields[name] === undefined) {
-      if (proto[name] !== undefined) {
-        lx.error(FIELD_VAL_IS_METHOD, { ...errCtx, val, name }, { kind: "rewrite", from: `.${name}`, to: `$${name}` });
-      } else {
-        lx.error(FIELD_VAL_NOT_DEFINED, { ...errCtx, val, name }, replaceNameSuggestion(name, Object.keys(fields)));
-      }
-    }
-  } else if (valName === "MethodVal") {
+    if (fields[name] !== undefined)
+      return;
+    if (proto[name] !== undefined)
+      lx.error(FIELD_VAL_IS_METHOD, { ...errCtx, val, name }, fixTo(`.${name}`, `$${name}`));
+    else
+      reportUnknownName(lx, FIELD_VAL_NOT_DEFINED, name, Object.keys(fields), { ...errCtx, val });
+  },
+  MethodVal({ lx, val, env, errCtx }) {
+    const { fields, proto } = env;
     const { name } = val;
-    if (proto[name] === undefined) {
-      if (fields[name] !== undefined) {
-        lx.error(METHOD_VAL_IS_FIELD, { ...errCtx, val, name }, { kind: "rewrite", from: `$${name}`, to: `.${name}` });
-      } else {
-        lx.error(METHOD_VAL_NOT_DEFINED, { ...errCtx, val, name }, replaceNameSuggestion(name, collectProtoMethodNames(proto)));
-      }
-    }
-  } else if (valName === "SeqAccessVal") {
-    checkConsistentAttrVal(lx, val.seqVal, env, skipNameVal, errCtx);
-    checkConsistentAttrVal(lx, val.keyVal, env, skipNameVal, errCtx);
-  } else if (valName === "RequestVal") {
-    if (scope.lookupRequest(val.name) === null) {
-      lx.error(UNKNOWN_REQUEST_NAME, { ...errCtx, name: val.name }, replaceNameSuggestion(val.name, scopeKeysAlong(scope, "reqsByName")));
-    }
-  } else if (valName === "TypeVal") {
-    if (scope.lookupComponent(val.name) === null) {
-      lx.error(UNKNOWN_COMPONENT_NAME, { ...errCtx, name: val.name }, replaceNameSuggestion(val.name, scopeKeysAlong(scope, "byName")));
-    }
-  } else if (valName === "NameVal") {
-    if (!skipNameVal && !isKnownHandlerName(val.name)) {
-      lx.error(UNKNOWN_HANDLER_ARG_NAME, { ...errCtx, name: val.name }, replaceNameSuggestion(val.name, KNOWN_HANDLER_NAMES));
-    }
-  } else if (valName === "StrTplVal") {
+    if (proto[name] !== undefined)
+      return;
+    if (fields[name] !== undefined)
+      lx.error(METHOD_VAL_IS_FIELD, { ...errCtx, val, name }, fixTo(`$${name}`, `.${name}`));
+    else
+      reportUnknownName(lx, METHOD_VAL_NOT_DEFINED, name, collectProtoMethodNames(proto), {
+        ...errCtx,
+        val
+      });
+  },
+  SeqAccessVal({ val, recurse }) {
+    recurse(val.seqVal);
+    recurse(val.keyVal);
+  },
+  RequestVal({ lx, val, env, errCtx }) {
+    if (env.scope.lookupRequest(val.name) === null)
+      reportUnknownName(lx, UNKNOWN_REQUEST_NAME, val.name, scopeKeysAlong(env.scope, "reqsByName"), errCtx);
+  },
+  TypeVal({ lx, val, env, errCtx }) {
+    if (env.scope.lookupComponent(val.name) === null)
+      reportUnknownName(lx, UNKNOWN_COMPONENT_NAME, val.name, scopeKeysAlong(env.scope, "byName"), errCtx);
+  },
+  NameVal({ lx, val, errCtx, skipNameVal }) {
+    if (!skipNameVal && !isKnownHandlerName(val.name))
+      reportUnknownName(lx, UNKNOWN_HANDLER_ARG_NAME, val.name, KNOWN_HANDLER_NAMES, errCtx);
+  },
+  StrTplVal({ lx, val, errCtx, recurse }) {
     const vs = val.vals;
     const literal = val.toLiteralSource();
     if (literal !== null) {
-      lx.hint(PLACEHOLDERLESS_TEMPLATE_STRING, { ...errCtx, literal }, { kind: "rewrite", from: `$${literal}`, to: literal });
+      lx.hint(PLACEHOLDERLESS_TEMPLATE_STRING, { ...errCtx, literal }, fixTo(`$${literal}`, literal));
     } else if (vs.length === 1) {
       const simpler = String(vs[0]);
-      lx.warn(REDUNDANT_TEMPLATE_STRING, { ...errCtx, simpler }, { kind: "rewrite", from: `$'{${simpler}}'`, to: simpler });
+      lx.warn(REDUNDANT_TEMPLATE_STRING, { ...errCtx, simpler }, fixTo(`$'{${simpler}}'`, simpler));
     }
-    for (const subVal of vs) {
-      checkConsistentAttrVal(lx, subVal, env, skipNameVal, errCtx);
-    }
-  } else if (valName === "HandlerNameVal") {
+    for (const subVal of vs)
+      recurse(subVal);
+  },
+  HandlerNameVal({ lx, val, env, errCtx }) {
     env.referencedAlters?.add(val.name);
-    if (alter[val.name] === undefined) {
-      lx.error(ALT_HANDLER_NOT_DEFINED, { ...errCtx, name: val.name }, replaceNameSuggestion(val.name, Object.keys(alter)));
-    }
-  } else if (valName === "PredicateVal") {
+    if (env.alter[val.name] === undefined)
+      reportUnknownName(lx, ALT_HANDLER_NOT_DEFINED, val.name, Object.keys(env.alter), errCtx);
+  },
+  PredicateVal({ val, recurse }) {
     for (const arg of val.args)
-      checkConsistentAttrVal(lx, arg, env, skipNameVal, errCtx);
-  } else if (valName === "DynVal") {
+      recurse(arg);
+  },
+  DynVal({ lx, val, env, errCtx }) {
     env.referencedDynamics?.add(val.name);
-    if (env.dynamicMap[val.name] === undefined) {
-      lx.error(DYN_VAL_NOT_DEFINED, { ...errCtx, name: val.name }, replaceNameSuggestion(val.name, Object.keys(env.dynamicMap)));
-    }
-  } else if (valName !== "ConstVal" && valName !== "BindVal") {
-    console.log(val);
+    if (env.dynamicMap[val.name] === undefined)
+      reportUnknownName(lx, DYN_VAL_NOT_DEFINED, val.name, Object.keys(env.dynamicMap), errCtx);
   }
+};
+function checkConsistentAttrVal(lx, val, env, skipNameVal = false, errCtx = null) {
+  const check = ATTR_VAL_CHECKERS[val?.constructor.name];
+  if (check === undefined)
+    return;
+  const recurse = (sub) => checkConsistentAttrVal(lx, sub, env, skipNameVal, errCtx);
+  check({ lx, val, env, errCtx, skipNameVal, recurse });
 }
 var NODE_KIND_TO_CTX = {
   RenderTextNode: { originAttr: "<x text>" },