@marko/compiler 5.38.4 → 5.39.0

package/dist/babel-utils/parse.js

@@ -0,0 +1,199 @@
+"use strict";exports.__esModule = true;exports.parseArgs = parseArgs;exports.parseExpression = parseExpression;exports.parseParams = parseParams;exports.parseStatements = parseStatements;exports.parseTemplateLiteral = parseTemplateLiteral;exports.parseTypeArgs = parseTypeArgs;exports.parseTypeParams = parseTypeParams;exports.parseVar = parseVar;var babelParser = _interopRequireWildcard(require("@babel/parser"));
+var _compiler = require("@marko/compiler");
+
+var _loc = require("./loc");function _getRequireWildcardCache(e) {if ("function" != typeof WeakMap) return null;var r = new WeakMap(),t = new WeakMap();return (_getRequireWildcardCache = function (e) {return e ? t : r;})(e);}function _interopRequireWildcard(e, r) {if (!r && e && e.__esModule) return e;if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };var t = _getRequireWildcardCache(r);if (t && t.has(e)) return t.get(e);var n = { __proto__: null },a = Object.defineProperty && Object.getOwnPropertyDescriptor;for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) {var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];}return n.default = e, t && t.set(e, n), n;}
+
+function parseStatements(
+file,
+str,
+sourceStart,
+sourceEnd,
+sourceOffset)
+{
+  return tryParse(file, false, str, sourceStart, sourceEnd, sourceOffset);
+}
+
+function parseExpression(
+file,
+str,
+sourceStart,
+sourceEnd,
+sourceOffset)
+{
+  return tryParse(file, true, str, sourceStart, sourceEnd, sourceOffset);
+}
+
+function parseParams(file, str, sourceStart, sourceEnd) {
+  const parsed = parseExpression(
+    file,
+    `(${str})=>{}`,
+    sourceStart,
+    sourceEnd,
+    1
+  );
+
+  if (parsed.type === "ArrowFunctionExpression") {
+    return parsed.params;
+  }
+
+  return [ensureParseError(file, parsed, sourceStart, sourceEnd)];
+}
+
+function parseArgs(file, str, sourceStart, sourceEnd) {
+  const parsed = parseExpression(file, `_(${str})`, sourceStart, sourceEnd, 2);
+
+  if (parsed.type === "CallExpression") {
+    return parsed.arguments;
+  }
+
+  return [ensureParseError(file, parsed, sourceStart, sourceEnd)];
+}
+
+function parseVar(file, str, sourceStart, sourceEnd) {
+  const parsed = parseExpression(
+    file,
+    `(${str})=>{}`,
+    sourceStart,
+    sourceEnd,
+    1
+  );
+
+  if (parsed.type === "ArrowFunctionExpression" && parsed.params.length === 1) {
+    return parsed.params[0];
+  }
+
+  return ensureParseError(file, parsed, sourceStart, sourceEnd);
+}
+
+function parseTemplateLiteral(file, str, sourceStart, sourceEnd) {
+  const parsed = parseExpression(
+    file,
+    "`" + str + "`",
+    sourceStart,
+    sourceEnd,
+    1
+  );
+
+  if (parsed.type === "TemplateLiteral") {
+    return parsed;
+  }
+
+  return ensureParseError(file, parsed, sourceStart, sourceEnd);
+}
+
+function parseTypeArgs(file, str, sourceStart, sourceEnd) {
+  const parsed = parseExpression(file, `_<${str}>`, sourceStart, sourceEnd, 2);
+
+  if (parsed.type === "TSInstantiationExpression") {
+    // typeArguments is Flow only (not TS), we need to use typeParameters
+    return parsed.typeParameters;
+  }
+
+  return [ensureParseError(file, parsed, sourceStart, sourceEnd)];
+}
+
+function parseTypeParams(file, str, sourceStart, sourceEnd) {
+  const parsed = parseExpression(
+    file,
+    `<${str}>()=>{}`,
+    sourceStart,
+    sourceEnd,
+    1
+  );
+
+  if (parsed.type === "ArrowFunctionExpression") {
+    return parsed.typeParameters;
+  }
+
+  return [ensureParseError(file, parsed, sourceStart, sourceEnd)];
+}
+
+function tryParse(
+file,
+isExpression,
+code,
+sourceStart,
+sourceEnd,
+sourceOffset)
+{
+  const { parserOpts } = file.opts;
+
+  if (typeof sourceStart === "number") {
+    const startIndex = sourceStart - (sourceOffset || 0);
+    const startLoc = (0, _loc.getLoc)(file, startIndex);
+    parserOpts.startIndex = startIndex;
+    parserOpts.startColumn = startLoc.column;
+    parserOpts.startLine = startLoc.line;
+
+    try {
+      return isExpression ?
+      babelParser.parseExpression(code, parserOpts) :
+      babelParser.parse(code, parserOpts).program.body;
+    } catch (err) {
+      const parseError = createParseError(
+        file,
+        sourceStart,
+        sourceEnd,
+        err.message,
+        err.loc
+      );
+
+      if (isExpression) {
+        return parseError;
+      } else {
+        return [parseError];
+      }
+    } finally {
+      parserOpts.startIndex = 0;
+      parserOpts.startColumn = 0;
+      parserOpts.startLine = 1;
+    }
+  } else {
+    return isExpression ?
+    _compiler.types.cloneDeepWithoutLoc(babelParser.parseExpression(code, parserOpts)) :
+    babelParser.
+    parse(code, parserOpts).
+    program.body.map((node) => _compiler.types.cloneDeepWithoutLoc(node));
+  }
+}
+
+function ensureParseError(file, node, sourceStart, sourceEnd) {
+  if (node.type === "MarkoParseError") return node;
+  return createParseError(
+    file,
+    sourceStart,
+    sourceEnd,
+    `Unexpected node of type ${node.type} returned while parsing.`
+  );
+}
+
+function createParseError(file, sourceStart, sourceEnd, label, errorLoc) {
+  file.___hasParseErrors = true;
+  const loc = (0, _loc.getLocRange)(file, sourceStart, sourceEnd);
+  return {
+    type: "MarkoParseError",
+    source: file.code.slice(sourceStart, sourceEnd),
+    label: label.replace(/ *\(\d+:\d+\)$/, ""),
+    errorLoc: errorLoc && getBoundedRange(loc, errorLoc),
+    loc,
+    start: sourceStart,
+    end: sourceEnd
+  };
+}
+
+function getBoundedRange(range, loc) {
+  if (loc && typeof loc.line === "number") {
+    const { start, end } = range;
+    // If start is out of bounds return the source.
+    if (
+    loc.line < start.line ||
+    loc.line === start.line && loc.column < start.column ||
+    loc.line > end.line ||
+    loc.line === end.line && loc.column > end.column)
+    {
+      return range;
+    }
+
+    return { start: loc, end: loc };
+  }
+}

package/dist/babel-utils/taglib.js

@@ -0,0 +1,27 @@
+"use strict";exports.__esModule = true;exports.getTagDefForTagName = getTagDefForTagName;exports.getTaglibLookup = getTaglibLookup;const SEEN_TAGS_KEY = Symbol();
+
+function getTaglibLookup(file) {
+  return file.___taglibLookup;
+}
+
+function getTagDefForTagName(file, tagName) {
+  const tagDef = getTaglibLookup(file).getTag(tagName);
+
+  if (tagDef) {
+    let seen = file.metadata.marko[SEEN_TAGS_KEY];
+    if (!seen) {
+      seen = file.metadata.marko[SEEN_TAGS_KEY] = new Set();
+    }
+
+    if (!seen.has(tagDef)) {
+      seen.add(tagName);
+      const { filePath } = tagDef;
+      const len = filePath.length;
+
+      if (filePath[len - 14] === "m" && filePath.endsWith("marko-tag.json")) {
+        file.metadata.marko.watchFiles.push(filePath);
+      }
+    }
+  }
+  return tagDef;
+}

package/dist/babel-utils/tags.js

@@ -0,0 +1,430 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.findAttributeTags = findAttributeTags;exports.findParentTag = findParentTag;exports.getArgOrSequence = getArgOrSequence;exports.getFullyResolvedTagName = getFullyResolvedTagName;exports.getMacroIdentifier = getMacroIdentifier;exports.getMacroIdentifierForName = getMacroIdentifierForName;exports.getTagDef = getTagDef;exports.getTagTemplate = getTagTemplate;exports.getTemplateId = getTemplateId;exports.hasMacro = hasMacro;exports.isAttributeTag = isAttributeTag;exports.isDynamicTag = isDynamicTag;exports.isLoopTag = isLoopTag;exports.isMacroTag = isMacroTag;exports.isNativeTag = isNativeTag;exports.isTransparentTag = isTransparentTag;exports.loadFileForImport = loadFileForImport;exports.loadFileForTag = loadFileForTag;exports.registerMacro = registerMacro;exports.resolveTagImport = resolveTagImport;var _compiler = require("@marko/compiler");
+var _crypto = require("crypto");
+var _lassoPackageRoot = require("lasso-package-root");
+var _path = require("path");
+var _resolveFrom = _interopRequireDefault(require("resolve-from"));
+
+var _diagnostics = require("./diagnostics");
+var _imports = require("./imports");
+var _taglib = require("./taglib");
+
+const MACRO_IDS_KEY = Symbol();
+const MACRO_NAMES_KEY = "__marko_macro_names__"; // must be a string literal since it is used across compiler stages.
+const TRANSPARENT_TAGS = new Set([
+"for",
+"while",
+"if",
+"else",
+"else-if",
+"_no-update"]
+);
+
+const CWD = process.cwd();
+let ROOT = CWD;
+try {
+  ROOT = (0, _lassoPackageRoot.getRootDir)(ROOT) || ROOT;
+  // eslint-disable-next-line no-empty
+} catch {}
+
+function isNativeTag(path) {
+  if (path.node._isDynamicString) {
+    return true;
+  }
+
+  const tagDef = getTagDef(path);
+  return (
+    tagDef &&
+    tagDef.html && (
+    tagDef.htmlType === "custom-element" ||
+    !tagDef.template && !tagDef.renderer));
+
+}
+
+function isDynamicTag(path) {
+  return !_compiler.types.isStringLiteral(path.node.name);
+}
+
+function isAttributeTag(path) {
+  const {
+    node: { name }
+  } = path;
+  return _compiler.types.isStringLiteral(name) && name.value[0] === "@";
+}
+
+function isTransparentTag(path) {
+  const {
+    node: { name }
+  } = path;
+  return _compiler.types.isStringLiteral(name) && TRANSPARENT_TAGS.has(name.value);
+}
+
+function registerMacro(path, name) {
+  const { file } = path.hub;
+  const markoMeta = file.metadata.marko;
+  const macroNames = markoMeta[MACRO_NAMES_KEY];
+
+  if (macroNames) {
+    if (macroNames[name]) {
+      (0, _diagnostics.diagnosticWarn)(path, {
+        label: `A macro with the name "${name}" already exists.`,
+        fix() {
+          findParentTag(path).remove();
+        }
+      });
+    }
+    macroNames[name] = true;
+  } else {
+    markoMeta[MACRO_NAMES_KEY] = { [name]: true };
+  }
+}
+
+function hasMacro(path, name) {
+  const macroNames = path.hub.file.metadata.marko[MACRO_NAMES_KEY];
+  return !!(macroNames && macroNames[name]);
+}
+
+function isMacroTag(path) {
+  const { name } = path.node;
+  return _compiler.types.isStringLiteral(name) && hasMacro(path, name.value);
+}
+
+function getMacroIdentifierForName(path, name) {
+  const { file } = path.hub;
+
+  if (file.___compileStage !== "translate") {
+    throw new Error(
+      "getMacroIdentifierForName can only be called during the translate phase of the compiler."
+    );
+  }
+
+  const markoMeta = file.metadata.marko;
+  let macroIds = markoMeta[MACRO_IDS_KEY];
+
+  if (!macroIds) {
+    macroIds = markoMeta[MACRO_IDS_KEY] = {};
+
+    for (const macroName in markoMeta[MACRO_NAMES_KEY]) {
+      macroIds[macroName] = file.path.scope.generateUid(macroName);
+    }
+  }
+
+  const id = macroIds[name];
+
+  if (!id) {
+    throw new Error(
+      "<macro> was added programmatically, but was not registered via the 'registerMacro' api in @marko/compiler/babel-utils."
+    );
+  }
+
+  return _compiler.types.identifier(id);
+}
+
+function getMacroIdentifier(path) {
+  const { file } = path.hub;
+
+  if (file.___compileStage !== "translate") {
+    throw new Error(
+      "getMacroIdentifier can only be called during the translate phase of the compiler."
+    );
+  }
+
+  if (!isMacroTag(path)) {
+    throw path.buildCodeFrameError(
+      "getMacroIdentifier called on non macro referencing tag."
+    );
+  }
+
+  return getMacroIdentifierForName(path, path.node.name.value);
+}
+
+function getTagTemplate(tag) {
+  const {
+    node,
+    hub: { file }
+  } = tag;
+
+  if (node.extra?.tagNameImported) {
+    return (0, _path.join)(file.opts.filename, node.extra.tagNameImported);
+  }
+  return getTagDef(tag)?.template;
+}
+
+function getTagDef(path) {
+  const {
+    node,
+    hub: { file }
+  } = path;
+
+  if (node.tagDef === undefined) {
+    if (isDynamicTag(path) || isMacroTag(path)) {
+      node.tagDef = null;
+    } else {
+      node.tagDef =
+      (0, _taglib.getTagDefForTagName)(
+        file,
+        isAttributeTag(path) ?
+        getFullyResolvedTagName(path) :
+        node.name.value
+      ) || null;
+    }
+  }
+
+  return node.tagDef;
+}
+
+function getFullyResolvedTagName(path) {
+  const parts = [];
+  let cur;
+  do {
+    cur = path.node.name.value;
+
+    if (isAttributeTag(path)) {
+      parts.push(cur.slice(1));
+    } else {
+      parts.push(cur || "*");
+      break;
+    }
+  } while (path = findParentTag(path));
+
+  return parts.reverse().join(":");
+}
+
+function findParentTag(path) {
+  let cur = path.parentPath;
+
+  while (cur.node) {
+    if (cur.isMarkoTagBody()) {
+      cur = cur.parentPath;
+      continue;
+    }
+
+    if (!cur.isMarkoTag()) {
+      cur = undefined;
+      break;
+    }
+
+    if (isTransparentTag(cur)) {
+      cur = cur.parentPath;
+      continue;
+    }
+
+    return cur;
+  }
+}
+
+function findAttributeTags(path, attributeTags = []) {
+  const attrTags = path.node.body.attributeTags ?
+  path.get("body").get("body") :
+  path.get("attributeTags");
+  attrTags.forEach((child) => {
+    if (isAttributeTag(child)) {
+      attributeTags.push(child);
+    } else if (isTransparentTag(child)) {
+      findAttributeTags(child, attributeTags);
+    }
+  });
+
+  return attributeTags;
+}
+
+function getArgOrSequence(path) {
+  const {
+    node: { arguments: args }
+  } = path;
+  const len = args && args.length;
+
+  if (len) {
+    if (len > 1) {
+      return _compiler.types.sequenceExpression(args);
+    } else {
+      return args[0];
+    }
+  }
+}
+
+function isLoopTag(path) {
+  if (!path.isMarkoTag()) {
+    return false;
+  }
+
+  const tagName = path.node.name.value;
+  return tagName === "while" || tagName === "for";
+}
+
+function loadFileForTag(tag) {
+  const { file } = tag.hub;
+  if (tag.node.extra?.tagNameImported) {
+    return loadFileForImport(file, tag.node.extra?.tagNameImported);
+  }
+
+  const def = getTagDef(tag);
+  const fs = file.markoOpts.fileSystem;
+  const filename = def && def.template;
+
+  if (filename) {
+    const markoMeta = file.metadata.marko;
+    const relativeFileName = (0, _imports.resolveRelativePath)(file, filename);
+    const { analyzedTags } = markoMeta;
+    if (analyzedTags) {
+      analyzedTags.add(relativeFileName);
+    } else {
+      markoMeta.analyzedTags = new Set([relativeFileName]);
+    }
+
+    return resolveMarkoFile(file, filename);
+  }
+}
+
+function loadFileForImport(file, request) {
+  const fs = file.markoOpts.fileSystem;
+  const relativeRequest = resolveTagImport(file.path, request);
+
+  if (relativeRequest) {
+    const filename =
+    relativeRequest[0] === "." ?
+    (0, _path.resolve)(file.opts.filename, "..", relativeRequest) :
+    (0, _resolveFrom.default)((0, _path.dirname)(file.opts.filename), relativeRequest);
+    const markoMeta = file.metadata.marko;
+    const { analyzedTags } = markoMeta;
+    if (analyzedTags) {
+      analyzedTags.add(relativeRequest);
+    } else {
+      markoMeta.analyzedTags = new Set([relativeRequest]);
+    }
+
+    return resolveMarkoFile(file, filename);
+  }
+}
+
+function resolveMarkoFile(file, filename) {
+  if (filename === file.opts.filename) {
+    if (file.___compileStage === "analyze") {
+      return file;
+    }
+
+    return file.___getMarkoFile(file.code, file.opts, file.markoOpts);
+  }
+
+  try {
+    return file.___getMarkoFile(
+      file.markoOpts.fileSystem.readFileSync(filename).toString("utf-8"),
+      createNewFileOpts(file.opts, filename),
+      file.markoOpts
+    );
+  } catch (_) {
+
+    // ignore
+  }}
+
+const idCache = new WeakMap();
+const templateIdHashOpts = { outputLength: 5 };
+function getTemplateId(opts, request, child) {
+  const id = (0, _path.relative)(ROOT, request);
+  const optimize = typeof opts === "object" ? opts.optimize : opts;
+
+  if (optimize) {
+    const optimizeKnownTemplates =
+    typeof opts === "object" && opts.optimizeKnownTemplates;
+    const knownTemplatesSize = optimizeKnownTemplates?.length || 0;
+    if (knownTemplatesSize) {
+      let lookup = idCache.get(optimizeKnownTemplates);
+      if (!lookup) {
+        lookup = new Map();
+        idCache.set(optimizeKnownTemplates, lookup);
+        for (let i = 0; i < knownTemplatesSize; i++) {
+          lookup.set(optimizeKnownTemplates[i], {
+            id: encodeTemplateId(i),
+            children: new Map()
+          });
+        }
+      }
+      let registered = lookup.get(request);
+      if (registered) {
+        if (child) {
+          let childId = registered.children.get(child);
+          if (childId === undefined) {
+            childId = registered.children.size;
+            registered.children.set(child, childId);
+          }
+          return registered.id + childId;
+        }
+        return registered.id;
+      }
+    }
+
+    const hash = (0, _crypto.createHash)("shake256", templateIdHashOpts).update(id);
+    if (child) {
+      hash.update(child);
+    }
+
+    return encodeTemplateId(parseInt(hash.digest("hex"), 16));
+  }
+
+  return id + (child ? `_${child}` : "");
+}
+
+function resolveTagImport(path, request) {
+  const {
+    hub: { file }
+  } = path;
+  if (request[0] === "<") {
+    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);
+
+    if (!relativePath) {
+      throw path.buildCodeFrameError(
+        `Unable to find entry point for custom tag <${tagName}>.`
+      );
+    }
+
+    return relativePath;
+  }
+
+  if (request.endsWith(".marko")) {
+    return (0, _imports.resolveRelativePath)(file, request);
+  }
+}
+
+function createNewFileOpts(opts, filename) {
+  const sourceFileName = (0, _path.basename)(filename);
+  const sourceRoot = (0, _path.dirname)(filename);
+  const filenameRelative = (0, _path.relative)(CWD, filename);
+  return {
+    ...opts,
+    filename,
+    sourceRoot,
+    sourceFileName,
+    filenameRelative,
+    parserOpts: {
+      ...opts.parserOpts,
+      sourceFileName
+    },
+    generatorOpts: {
+      ...opts.generatorOpts,
+      filename,
+      sourceRoot,
+      sourceFileName
+    }
+  };
+}
+
+function encodeTemplateId(index) {
+  const encodeChars =
+  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_0123456789";
+  const encodeLen = encodeChars.length;
+  const encodeStartLen = encodeLen - 11; // Avoids chars that cannot start a property name and _ (reserved).
+  let cur = index;
+  let mod = cur % encodeStartLen;
+  let id = encodeChars[mod];
+  cur = (cur - mod) / encodeStartLen;
+
+  while (cur > 0) {
+    mod = cur % encodeLen;
+    id += encodeChars[mod];
+    cur = (cur - mod) / encodeLen;
+  }
+
+  return id;
+}

package/dist/babel-utils/template-string.js

@@ -0,0 +1,56 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.normalizeTemplateString = normalizeTemplateString;var _compiler = require("@marko/compiler");
+var _jsesc = _interopRequireDefault(require("jsesc"));
+
+function normalizeTemplateString(quasis, ...expressions) {
+  quasis = quasis.map((q) => _compiler.types.isTemplateElement(q) ? q.value.cooked : q);
+
+  for (let i = expressions.length; i--;) {
+    let v = expressions[i];
+    if (_compiler.types.isTemplateLiteral(v)) {
+      quasis[i] += v.quasis[0].value.cooked;
+      quasis[i + 1] =
+      v.quasis[v.quasis.length - 1].value.cooked + (quasis[i + 1] || "");
+      quasis.splice(
+        i + 1,
+        0,
+        ...v.quasis.slice(1, -1).map((q) => q.value.cooked)
+      );
+      expressions.splice(i, 1, ...v.expressions);
+      i += v.expressions.length;
+    } else if (_compiler.types.isStringLiteral(v) || typeof v === "string") {
+      const value = _compiler.types.isStringLiteral(v) ? v.value : v;
+      quasis[i] += value + quasis[i + 1];
+      expressions.splice(i, 1);
+      quasis.splice(i + 1, 1);
+    }
+  }
+
+  if (!expressions.length) {
+    // No expression, just return a literal or empty.
+    const literal = quasis.join("");
+    return literal === "" ? undefined : _compiler.types.stringLiteral(literal);
+  }
+
+  if (
+  expressions.length === 1 &&
+  quasis.length === 2 &&
+  quasis.every(isEmptyString))
+  {
+    // Only expression `${expr}` just return the expr.
+    return expressions[0];
+  }
+
+  // Do it.
+  return _compiler.types.templateLiteral(quasis.map(getTemplateElement), expressions);
+}
+
+function getTemplateElement(s = "") {
+  return _compiler.types.templateElement({
+    cooked: s,
+    raw: (0, _jsesc.default)(s, { quotes: "backtick" })
+  });
+}
+
+function isEmptyString(s = "") {
+  return s === "";
+}