@marko/compiler 5.40.1 → 5.41.0

package/babel-utils.d.ts

@@ -54,6 +54,10 @@ export interface TagDefinition {
   isRepeated?: boolean;
   targetProperty?: string;
   taglibId: string;
+  /** Set when the taglib was discovered by resolving an installed package. */
+  packageName?: string;
+  /** The root directory of `packageName`, which contains all files for this tag. */
+  packageRoot?: string;
   types?: string;
   template?: string;
   renderer?: string;
@@ -178,11 +182,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;
 
@@ -300,7 +307,11 @@ export function parseTemplateLiteral(
   sourceEnd?: null | number,
 ): t.TemplateLiteral;
 
-export function resolveRelativePath(file: t.BabelFile, request: string): string;
+export function resolveRelativePath(
+  file: t.BabelFile,
+  request: string,
+  tagDef?: TagDefinition,
+): string;
 export function importDefault(
   file: t.BabelFile,
   request: string,

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/dist/babel-utils/imports.js

@@ -5,10 +5,13 @@ var _relativeImportPath = require("relative-import-path");function _interopRequi
 
 const IMPORTS_KEY = Symbol();
 const FS_START = _path.default.sep === "/" ? _path.default.sep : /^(.*?:)/.exec(_modules.cwd)[1];
+const REG_NODE_MODULES = /[\\/]node_modules[\\/]/;
 
-function resolveRelativePath(file, request) {
+function resolveRelativePath(file, request, tagDef) {
   if (request.startsWith(FS_START)) {
-    request = (0, _relativeImportPath.relativeImportPath)(file.opts.filename, request);
+    request =
+    packageImportPath(file.opts.filename, tagDef, request) ||
+    (0, _relativeImportPath.relativeImportPath)(file.opts.filename, request);
   }
 
   if (file.markoOpts.optimize) {
@@ -21,6 +24,34 @@ function resolveRelativePath(file, request) {
   return request;
 }
 
+/**
+ * A tag installed into `node_modules` is imported through the name its package was
+ * resolved by, since its path is a realpath which may not be importable at all.
+ */
+function packageImportPath(from, tagDef, request) {
+  if (!tagDef?.packageName || !REG_NODE_MODULES.test(request)) return;
+
+  const { packageRoot } = tagDef;
+  // Within the package we stay relative, both because it always resolves and
+  // because a self reference would only work if the package exports the tag.
+  if (!isWithin(packageRoot, request) || isWithin(packageRoot, from)) return;
+
+  const subPath = _path.default.relative(packageRoot, request);
+  return `${tagDef.packageName}/${subPath.split(_path.default.sep).join("/")}`;
+}
+
+function isWithin(dir, filename) {
+  const rel = _path.default.relative(dir, filename);
+  // `path.relative` walks out of the dir with `..`, or returns an absolute path
+  // when it cannot relate the two at all, eg across windows drives.
+  return (
+    !!rel &&
+    rel !== ".." &&
+    !rel.startsWith(`..${_path.default.sep}`) &&
+    !_path.default.isAbsolute(rel));
+
+}
+
 function importDefault(file, request, nameHint) {
   const imports = getImports(file);
   request = resolveRelativePath(file, request);

package/dist/babel-utils/tags.js

@@ -347,7 +347,8 @@ function resolveTagImport(path, request) {
     const tagName = request.slice(1, -1);
     const tagDef = (0, _taglib.getTagDefForTagName)(file, tagName);
     const tagEntry = tagDef && (tagDef.renderer || tagDef.template);
-    const relativePath = tagEntry && (0, _imports.resolveRelativePath)(file, tagEntry);
+    const relativePath =
+    tagEntry && (0, _imports.resolveRelativePath)(file, tagEntry, tagDef);
 
     if (!relativePath) {
       throw path.buildCodeFrameError(

package/dist/taglib/finder/index.js

@@ -124,7 +124,9 @@ function find(dirname, registeredTaglibs, tagDiscoveryDirs) {
           rootPkg.__dirname
         );
         if (taglibPath) {
-          var taglib = taglibLoader.loadTaglibFromFile(taglibPath, true);
+          // Resolving realpaths the taglib, which for a virtual store (eg pnpm) bears
+          // no relation to how it is imported, so hold onto the name it resolved by.
+          var taglib = taglibLoader.loadTaglibFromFile(taglibPath, true, name);
           addTaglib(taglib);
         }
       }

package/dist/taglib/loader/Taglib.js

@@ -26,11 +26,12 @@ function handleImport(taglib, importedTaglib) {
 }
 
 class Taglib {
-  constructor(filePath, isFromPackageJson) {
+  constructor(filePath, isFromPackageJson, packageName) {
     ok(filePath, '"filePath" expected');
     this.filePath = this.path /* deprecated */ = this.id = filePath;
     this.isFromPackageJson = isFromPackageJson === true;
     this.dirname = path.dirname(this.filePath);
+    this.packageName = packageName;
     this.scriptLang = undefined;
     this.tags = {};
     this.migrators = [];
@@ -72,6 +73,23 @@ class Taglib {
     }
     this.tags[tag.name] = tag;
     tag.taglibId = this.id || this.path;
+    this.setTagPackage(tag);
+  }
+
+  setPackageName(packageName) {
+    this.packageName = packageName;
+    for (var name in this.tags) {
+      if (hasOwnProperty.call(this.tags, name)) {
+        this.setTagPackage(this.tags[name]);
+      }
+    }
+  }
+
+  setTagPackage(tag) {
+    if (this.packageName) {
+      tag.packageName = this.packageName;
+      tag.packageRoot = this.dirname;
+    }
   }
 
   addImport(path) {

package/dist/taglib/loader/index.js

@@ -8,8 +8,8 @@ function loadTaglibFromProps(taglib, taglibProps) {
   return loaders.loadTaglibFromProps(taglib, taglibProps);
 }
 
-function loadTaglibFromFile(filePath, isFromPackageJson) {
-  return loaders.loadTaglibFromFile(filePath, isFromPackageJson);
+function loadTaglibFromFile(filePath, isFromPackageJson, packageName) {
+  return loaders.loadTaglibFromFile(filePath, isFromPackageJson, packageName);
 }
 
 function loadTaglibFromDir(filePath, tagDiscoveryDir) {

package/dist/taglib/loader/loadTaglibFromFile.js

@@ -4,7 +4,7 @@ var jsonFileReader = require("./json-file-reader");
 var loaders = require("./loaders");
 var types = require("./types");
 
-function loadFromFile(filePath, isFromPackageJson) {
+function loadFromFile(filePath, isFromPackageJson, packageName) {
   ok(filePath, '"filePath" is required');
 
   var taglib = cache.get(filePath);
@@ -12,11 +12,15 @@ function loadFromFile(filePath, isFromPackageJson) {
   // Only load a taglib once by caching the loaded taglibs using the file
   // system file path as the key
   if (!taglib) {
-    taglib = new types.Taglib(filePath, isFromPackageJson);
+    taglib = new types.Taglib(filePath, isFromPackageJson, packageName);
     cache.put(filePath, taglib);
 
     var taglibProps = jsonFileReader.readFileSync(filePath);
     loaders.loadTaglibFromProps(taglib, taglibProps);
+  } else if (packageName && !taglib.packageName) {
+    // The taglib may have first been loaded by walking up from a file within the
+    // package itself, in which case we did not yet know the name it is installed as.
+    taglib.setPackageName(packageName);
   }
 
   return taglib;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marko/compiler",
-  "version": "5.40.1",
+  "version": "5.41.0",
   "description": "Marko template to JS compiler.",
   "keywords": [
     "babel",
@@ -77,13 +77,13 @@
     "lasso-package-root": "^1.0.1",
     "raptor-regexp": "^1.0.1",
     "raptor-util": "^3.2.0",
-    "relative-import-path": "^1.0.0",
+    "relative-import-path": "^1.0.1",
     "resolve-from": "^5.0.0",
     "self-closing-tags": "^1.0.1",
     "source-map-support": "^0.5.21"
   },
   "devDependencies": {
-    "marko": "^5.39.14"
+    "marko": "^5.39.18"
   },
   "engines": {
     "node": "18 || 20 || >=22"