@marko/compiler 5.40.1 → 5.40.2

package/babel-utils.d.ts

@@ -178,11 +178,14 @@ export function assertAllowedAttributes(
   path: t.NodePath<t.MarkoTag>,
   allowed: string[],
 ): void;
-export function assertNoArgs(path: t.NodePath<t.MarkoTag>): void;
+export function assertNoArgs(path: t.NodePath<t.MarkoTag>, hint?: string): void;
 export function assertNoVar(path: t.NodePath<t.MarkoTag>): void;
 export function assertNoAttributes(path: t.NodePath<t.MarkoTag>): void;
 export function assertNoParams(path: t.NodePath<t.MarkoTag>): void;
-export function assertNoAttributeTags(path: t.NodePath<t.MarkoTag>): void;
+export function assertNoAttributeTags(
+  path: t.NodePath<t.MarkoTag>,
+  hint?: string,
+): void;
 export function assertAttributesOrArgs(path: t.NodePath<t.MarkoTag>): void;
 export function assertAttributesOrSingleArg(path: t.NodePath<t.MarkoTag>): void;
 

package/dist/babel-plugin/index.js

@@ -323,6 +323,29 @@ function getMarkoFile(code, fileOpts, markoOpts) {
       try {
         file.___compileStage = "analyze";
         traverseAll(file, translator.analyze);
+
+        if (!markoOpts.errorRecovery) {
+          // Analyze failures are recorded as error diagnostics so the whole
+          // template reports at once (and editors compiling with
+          // `errorRecovery` keep them as recoverable diagnostics); mirror
+          // the parse layer by throwing them together at the stage's end.
+          const seen = new Set();
+          const errors = [];
+          for (const diag of meta.diagnostics) {
+            if (diag.type !== _diagnostics.DiagnosticType.Error) continue;
+            const key = `${
+            diag.loc ? `${diag.loc.start.line}:${diag.loc.start.column}` : ""}:${
+            diag.label}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            errors.push(
+              (0, _buildCodeFrame.buildCodeFrameError)(filename, file.code, diag.loc, diag.label)
+            );
+            if (errors.length === 8) break;
+          }
+
+          (0, _mergeErrors.default)(errors);
+        }
       } catch (e) {
         compileCache.delete(id);
         throw e;

package/dist/babel-plugin/parser.js

@@ -16,6 +16,22 @@ var _buildCodeFrame = require("../util/build-code-frame");
 var _mergeErrors = _interopRequireDefault(require("../util/merge-errors"));function _interopRequireDefault(e) {return e && e.__esModule ? e : { default: e };}
 
 const noop = () => {};
+const jsxStyleAttrValueReg = /^\{[\s\S]*\}$/;
+// A brace wrapped attribute value that only parses once unwrapped is almost
+// certainly a JSX/Svelte style value (eg `onClick={handler}`); say so instead
+// of surfacing the bare expression parse error.
+const withWrappedAttrValueHint = (file, part, rawValue, node) => {
+  const trimmed = rawValue.trim();
+  if (
+  node.type === "MarkoParseError" &&
+  jsxStyleAttrValueReg.test(trimmed) &&
+  (0, _babelUtils.parseExpression)(file, trimmed.slice(1, -1), part.value.start).type !==
+  "MarkoParseError")
+  {
+    node.label += `${node.label.endsWith(".") ? "" : "."} Attribute values in Marko are plain JavaScript expressions, not JSX; remove the wrapping \`{ }\`.`;
+  }
+  return node;
+};
 const emptyRange = (part) => part.start === part.end;
 const isAttrTag = (tag) => tag.name.value?.[0] === "@";
 const isStatementTag = (tag) => tag.tagDef?.parseOptions?.statement;
@@ -412,10 +428,12 @@ function parseMarko(file) {
     onAttrValue(part) {
       currentAttr.end = part.end;
       currentAttr.bound = part.bound;
-      currentAttr.value = (0, _babelUtils.parseExpression)(
+      const rawAttrValue = parser.read(part.value);
+      currentAttr.value = withWrappedAttrValueHint(
         file,
-        parser.read(part.value),
-        part.value.start
+        part,
+        rawAttrValue,
+        (0, _babelUtils.parseExpression)(file, rawAttrValue, part.value.start)
       );
     },
 

package/dist/babel-utils/assert.js

@@ -41,23 +41,23 @@ function assertNoParams(path) {
   }
 }
 
-function assertNoAttributeTags(path) {
+function assertNoAttributeTags(path, hint) {
   if (path.node.attributeTags.length) {
     throw path.hub.buildError(
       path.node.attributeTags[0],
-      "Tag not support nested attribute tags."
+      `Tag does not support nested attribute tags.${hint ? ` ${hint}` : ""}`
     );
   }
 }
 
-function assertNoArgs(path) {
+function assertNoArgs(path, hint) {
   const args = path.node.arguments;
   if (args && args.length) {
     const start = args[0].loc.start;
     const end = args[args.length - 1].loc.end;
     throw path.hub.buildError(
       { loc: { start, end } },
-      "Tag does not support arguments."
+      `Tag does not support arguments.${hint ? ` ${hint}` : ""}`
     );
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/compiler",
-  "version": "5.40.1",
+  "version": "5.40.2",
   "description": "Marko template to JS compiler.",
   "keywords": [
     "babel",