marko 5.36.5 → 5.37.0

package/dist/translator/tag/custom-tag.js

@@ -0,0 +1,146 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+
+
+
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+var _dynamicTag = _interopRequireDefault(require("./dynamic-tag"));
+var _nativeTag = _interopRequireDefault(require("./native-tag"));
+var _util = require("./util");
+
+function _default(path, isNullable) {
+  const {
+    hub: { file },
+    node
+  } = path;
+  const { markoOpts } = file;
+  const { name, key } = node;
+
+  (0, _babelUtils.assertNoArgs)(path);
+
+  let tagIdentifier;
+
+  if (_compiler.types.isStringLiteral(name)) {
+    const tagName = name.value;
+    let relativePath = node.extra && node.extra.relativePath;
+
+    if (!relativePath) {
+      const tagDef = (0, _babelUtils.getTagDef)(path);
+      if (tagDef && tagDef.renderer) {
+        // Normally new tags should not be added in the translate stage.
+        // We make an exception here for core tags, init-components & _preserve being the primary culprits.
+        // TODO: in the future refactor so this is not needed.
+        relativePath = (0, _babelUtils.resolveRelativePath)(file, tagDef.renderer);
+      }
+    }
+
+    let binding = !relativePath && path.scope.getBinding(tagName);
+    if (binding && !binding.identifier.loc) binding = null;
+
+    if (binding && binding.kind === "module") {
+      const importSource = binding.path.parent.source;
+      relativePath =
+      (0, _babelUtils.resolveTagImport)(path, importSource.value) || importSource.value;
+      (node.extra ??= {}).tagNameImported = relativePath;
+      binding = undefined;
+    }
+
+    const childFile = (0, _babelUtils.loadFileForTag)(path);
+    const childProgram = childFile?.ast.program;
+
+    if (childProgram?.extra?.featureType === "tags") {
+      const compatRuntimeFile = `marko/src/runtime/helpers/tags-compat/${
+      markoOpts.output === "html" ? "html" : "dom"}${
+      markoOpts.optimize ? "" : "-debug"}.${markoOpts.modules === "esm" ? "mjs" : "js"}`;
+      (0, _babelUtils.importDefault)(file, compatRuntimeFile);
+      path.set("name", (0, _babelUtils.importDefault)(file, relativePath, path.node.name.value));
+      return (0, _dynamicTag.default)(path);
+    } else if (relativePath) {
+      if (binding) {
+
+
+
+
+
+
+
+        // TODO: implement auto migration for conflicts here
+        // and log below warning
+        // console.warn(
+        //   path.buildCodeFrameError(
+        //     `The <${tagName}> tag has been resolved from the filesystem, however a local variable with the same name exists. In the next major version of Marko the local variable will tag precedence.`
+        //   )
+        // );
+      }tagIdentifier = (0, _babelUtils.importDefault)(file, relativePath, tagName);} else if (binding) {path.set("name", _compiler.types.identifier(tagName));return (0, _dynamicTag.default)(path);} else if (markoOpts.ignoreUnrecognizedTags) {return (0, _nativeTag.default)(path);
+    } else {
+      throw path.
+      get("name").
+      buildCodeFrameError(
+        `Unable to find entry point for custom tag <${tagName}>.`
+      );
+    }
+  } else {
+    tagIdentifier = name;
+  }
+
+  const foundAttrs = (0, _util.getAttrs)(path);
+  const customTagRenderCall = (0, _withPreviousLocation.default)(
+    _compiler.types.expressionStatement(
+      _compiler.types.callExpression(
+        (0, _babelUtils.importDefault)(
+          file,
+          "marko/src/runtime/helpers/render-tag.js",
+          "marko_tag"
+        ),
+        [
+        tagIdentifier,
+        // TODO: this could be left as null if we froze input mutations and used a default object in the runtime.
+        _compiler.types.isNullLiteral(foundAttrs) ? _compiler.types.objectExpression([]) : foundAttrs,
+        _compiler.types.identifier("out"),
+        file._componentDefIdentifier,
+        key,
+        ...(0, _util.buildEventHandlerArray)(path)]
+
+      )
+    ),
+    node
+  );
+
+  if (isNullable) {
+    let renderBodyIdentifier;
+    const renderBodyProp =
+    _compiler.types.isObjectExpression(foundAttrs) &&
+    foundAttrs.properties.find(
+      (prop) => prop.key && prop.key.value === "renderBody"
+    );
+
+    if (renderBodyProp) {
+      renderBodyIdentifier = path.scope.generateUidIdentifier("renderBody");
+      path.insertBefore(
+        _compiler.types.variableDeclaration("const", [
+        _compiler.types.variableDeclarator(renderBodyIdentifier, renderBodyProp.value)]
+        )
+      );
+
+      renderBodyProp.value = renderBodyIdentifier;
+    }
+
+    path.replaceWith(
+      _compiler.types.ifStatement(
+        name,
+        customTagRenderCall,
+        renderBodyIdentifier &&
+        _compiler.types.expressionStatement(
+          _compiler.types.callExpression(renderBodyIdentifier, [_compiler.types.identifier("out")])
+        )
+      )
+    );
+  } else {
+    path.replaceWith(customTagRenderCall);
+  }
+}

package/dist/translator/tag/dynamic-tag.js

@@ -0,0 +1,74 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+var _util = require("./util");
+
+function _default(path) {
+  const {
+    node,
+    hub: { file }
+  } = path;
+  const tagProperties = path.node.extra && path.node.extra.properties || [];
+  const { key, arguments: args } = node;
+  const foundAttrs = (0, _util.getAttrs)(path, true);
+  let renderBodyProp;
+  let attrsLen = _compiler.types.isNullLiteral(foundAttrs) ? 0 : 1;
+
+  if (node.preserveAttrs) {
+    tagProperties.push(
+      _compiler.types.objectProperty(
+        _compiler.types.identifier("pa"),
+        _compiler.types.objectExpression(
+          node.preserveAttrs.map((name) =>
+          _compiler.types.objectProperty(
+            _compiler.types.isValidIdentifier(name) ?
+            _compiler.types.identifier(name) :
+            _compiler.types.stringLiteral(name),
+            _compiler.types.numericLiteral(1)
+          )
+          )
+        )
+      )
+    );
+  }
+
+  if (_compiler.types.isObjectExpression(foundAttrs)) {
+    const renderBodyIndex = foundAttrs.properties.findIndex(
+      (prop) => prop.key && prop.key.value === "renderBody"
+    );
+
+    attrsLen = foundAttrs.properties.length;
+
+    if (renderBodyIndex > -1) {
+      renderBodyProp = foundAttrs.properties[renderBodyIndex];
+      foundAttrs.properties.splice(renderBodyIndex, 1);
+      attrsLen--;
+    }
+  }
+
+  const dynamicTagRenderCall = _compiler.types.expressionStatement(
+    _compiler.types.callExpression(
+      (0, _babelUtils.importDefault)(
+        file,
+        `marko/src/runtime/helpers/dynamic-tag.js`,
+        "marko_dynamic_tag"
+      ),
+      [
+      _compiler.types.identifier("out"),
+      node.name,
+      attrsLen ? _compiler.types.arrowFunctionExpression([], foundAttrs) : _compiler.types.nullLiteral(),
+      renderBodyProp ? renderBodyProp.value : _compiler.types.nullLiteral(),
+      args && args.length ? _compiler.types.arrayExpression(args) : _compiler.types.nullLiteral(),
+      tagProperties.length ?
+      _compiler.types.objectExpression(tagProperties) :
+      _compiler.types.nullLiteral(),
+      file._componentDefIdentifier,
+      key,
+      ...(0, _util.buildEventHandlerArray)(path)]
+
+    )
+  );
+
+  path.replaceWith((0, _withPreviousLocation.default)(dynamicTagRenderCall, node));
+}

package/dist/translator/tag/index.js

@@ -0,0 +1,287 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+
+
+
+
+
+var _path = _interopRequireDefault(require("path"));
+
+var _keyManager = require("../util/key-manager");
+var _optimizeVdomCreate = require("../util/optimize-vdom-create");
+var _pluginHooks = require("../util/plugin-hooks");
+var _attribute = _interopRequireDefault(require("./attribute"));
+var _attributeTag = _interopRequireWildcard(require("./attribute-tag"));
+var _customTag = _interopRequireDefault(require("./custom-tag"));
+var _dynamicTag = _interopRequireDefault(require("./dynamic-tag"));
+var _macroTag = _interopRequireDefault(require("./macro-tag"));
+var _nativeTag = _interopRequireDefault(require("./native-tag"));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;}var _default = exports.default =
+
+{
+  enter(path) {
+    const tagDef = (0, _babelUtils.getTagDef)(path);
+
+    if (tagDef && tagDef.translator) {
+      const { node } = path;
+      (0, _pluginHooks.enter)(tagDef.translator.hook, path, _compiler.types);
+
+      if (path.node !== node) {
+        return;
+      }
+    }
+
+    (0, _babelUtils.assertNoVar)(path);
+
+    for (const attr of path.get("attributes")) {
+      if (attr.isMarkoAttribute()) {
+        const { node } = path;
+        _attribute.default.enter(attr);
+        if (path.node !== node) {
+          return;
+        }
+      }
+    }
+
+    if (!(0, _babelUtils.isAttributeTag)(path)) {
+      if (
+      !tagDef &&
+      path.hub.file.markoOpts.ignoreUnrecognizedTags && (
+      path.node.attributeTags.length || path.node.body.attributeTags) &&
+      !(0, _babelUtils.isDynamicTag)(path))
+      {
+        moveIgnoredAttrTags(path);
+      }
+
+      if ((0, _babelUtils.isDynamicTag)(path) || !((0, _babelUtils.isMacroTag)(path) || (0, _babelUtils.isNativeTag)(path))) {
+        (0, _attributeTag.analyzeAttributeTags)(path);
+      }
+
+      (0, _keyManager.getKeyManager)(path).resolveKey(path);
+    }
+
+    (0, _optimizeVdomCreate.optimizeStaticVDOM)(path);
+  },
+  exit(path) {
+    let isUnknownDynamic = false;
+    let isDynamicNullable = false;
+
+    if ((0, _babelUtils.isDynamicTag)(path)) {
+      const name = path.get("name");
+      const types = findDynamicTagTypes(name);
+      if (types && !(types.string && types.component)) {
+        if (!name.isIdentifier()) {
+          const tagIdentifier = path.scope.generateUidIdentifier(`tagName`);
+          path.insertBefore(
+            _compiler.types.variableDeclaration("const", [
+            _compiler.types.variableDeclarator(tagIdentifier, name.node)]
+            )
+          );
+
+          name.replaceWith(tagIdentifier);
+        }
+
+        isDynamicNullable = types.empty;
+        path.node._isDynamicString = types.string;
+      } else {
+        isUnknownDynamic = true;
+      }
+    }
+
+    for (const attr of path.get("attributes")) {
+      if (attr.isMarkoAttribute()) {
+        const { node } = path;
+        _attribute.default.exit(attr);
+        if (path.node !== node) {
+          return;
+        }
+      }
+    }
+
+    if (isUnknownDynamic) {
+      return (0, _dynamicTag.default)(path);
+    }
+
+    if ((0, _babelUtils.isAttributeTag)(path)) {
+      return (0, _attributeTag.default)(path);
+    }
+
+    if ((0, _babelUtils.isMacroTag)(path)) {
+      return (0, _macroTag.default)(path);
+    }
+
+    const tagDef = (0, _babelUtils.getTagDef)(path);
+
+    if (tagDef && tagDef.translator) {
+      const { node } = path;
+
+      (0, _pluginHooks.exit)(tagDef.translator.hook, path, _compiler.types);
+
+      if (path.node !== node) {
+        return;
+      }
+    }
+
+    if ((0, _babelUtils.isNativeTag)(path)) {
+      return (0, _nativeTag.default)(path, isDynamicNullable);
+    } else {
+      return (0, _customTag.default)(path, isDynamicNullable);
+    }
+  }
+};
+
+const HANDLE_BINDINGS = ["module", "var", "let", "const"];
+function findDynamicTagTypes(root) {
+  const pending = [root];
+  const types = {
+    string: false,
+    empty: false,
+    component: false
+  };
+  let tagNameImported;
+
+  let path;
+  while (path = pending.pop()) {
+    switch (path.type) {
+      case "ConditionalExpression":
+        pending.push(path.get("consequent"));
+
+        if (path.get("alternate").node) {
+          pending.push(path.get("alternate"));
+        }
+        break;
+
+      case "LogicalExpression":
+        if (path.get("operator").node === "||") {
+          pending.push(path.get("left"));
+        } else {
+          types.empty = true;
+        }
+
+        pending.push(path.get("right"));
+        break;
+
+      case "AssignmentExpression":
+        pending.push(path.get("right"));
+        break;
+
+      case "BinaryExpression":
+        if (path.get("operator").node !== "+") {
+          return false;
+        }
+
+        types.string = true;
+        break;
+
+      case "StringLiteral":
+      case "TemplateLiteral":
+        types.string = true;
+        break;
+
+      case "NullLiteral":
+        types.empty = true;
+        break;
+
+      case "Identifier":
+        if (path.get("name").node === "undefined") {
+          types.empty = true;
+        } else {
+          const binding = path.scope.getBinding(path.node.name);
+
+          if (!binding || !HANDLE_BINDINGS.includes(binding.kind)) {
+            return false;
+          }
+
+          if (binding.kind === "module") {
+            const importSource = binding.path.parent.source;
+            if (
+            _compiler.types.isStringLiteral(importSource) &&
+            isMarkoFile(importSource.value))
+            {
+              const resolvedImport =
+              (0, _babelUtils.resolveTagImport)(root.parentPath, importSource.value) ||
+              importSource.value;
+
+              if (tagNameImported === undefined) {
+                tagNameImported = resolvedImport;
+              } else if (
+              tagNameImported &&
+              tagNameImported !== resolvedImport)
+              {
+                tagNameImported = null;
+              }
+
+              types.component = true;
+            } else {
+              return false;
+            }
+          } else {
+            const initialValue = binding.path.get("init");
+            if (initialValue.node) {
+              pending.push(initialValue);
+            } else {
+              types.empty = true;
+            }
+
+            const assignments = binding.constantViolations;
+            if (assignments && assignments.length) {
+              for (const assignment of assignments) {
+                const operator = assignment.get("operator").node;
+                if (operator === "=") {
+                  pending.push(assignment.get("right"));
+                } else if (operator === "+=") {
+                  types.string = true;
+                } else {
+                  return false;
+                }
+              }
+            }
+          }
+        }
+        break;
+
+      default:
+        return false;
+    }
+  }
+
+  if (tagNameImported && !types.string) {
+    (root.parent.extra ??= {}).tagNameImported = tagNameImported;
+  }
+
+  return types;
+}
+
+function isMarkoFile(request) {
+  return _path.default.extname(request) === ".marko" || /^<.*>$/.test(request);
+}
+
+function moveIgnoredAttrTags(parentTag) {
+  const attrTags = parentTag.node.body.attributeTags ?
+  parentTag.get("body").get("body") :
+  parentTag.get("attributeTags");
+
+  if (!attrTags.length) return;
+
+  for (const attrTag of attrTags) {
+    if (attrTag.isMarkoTag()) {
+      if ((0, _babelUtils.isAttributeTag)(attrTag)) {
+        attrTag.set(
+          "name",
+          _compiler.types.stringLiteral(`at_${attrTag.get("name.value").node.slice(1)}`)
+        );
+      }
+
+      moveIgnoredAttrTags(attrTag);
+    }
+  }
+
+  parentTag.node.body.body = parentTag.node.attributeTags.concat(
+    parentTag.node.body.body
+  );
+  parentTag.node.attributeTags = [];
+}

package/dist/translator/tag/macro-tag.js

@@ -0,0 +1,7 @@
+"use strict";exports.__esModule = true;exports.default = _default;var _babelUtils = require("@marko/compiler/babel-utils");
+
+function _default(path) {
+  path.node.name = (0, _babelUtils.getMacroIdentifier)(path);
+  path.node._isMacroTagCall = true;
+  path.requeue();
+}

package/dist/translator/tag/native-tag.js

@@ -0,0 +1,27 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+var _nativeTagHtml = _interopRequireDefault(require("./native-tag[html]"));
+var _nativeTagVdom = _interopRequireDefault(require("./native-tag[vdom]"));
+
+function _default(path, isNullable) {
+  const {
+    hub: { file }
+  } = path;
+  const { markoOpts } = file;
+
+  if (!markoOpts.ignoreUnrecognizedTags) {
+    (0, _babelUtils.assertNoArgs)(path);
+    (0, _babelUtils.assertNoParams)(path);
+    (0, _babelUtils.assertNoAttributeTags)(path);
+  }
+
+  if (markoOpts.output === "html") {
+    (0, _nativeTagHtml.default)(path, isNullable);
+  } else {
+    (0, _nativeTagVdom.default)(path, isNullable);
+  }
+}

package/dist/translator/tag/native-tag[html]/attributes.js

@@ -0,0 +1,151 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+var _attr = _interopRequireDefault(require("marko/src/runtime/html/helpers/attr"));
+var _escapeQuotes = require("marko/src/runtime/html/helpers/escape-quotes");
+
+var _util = require("../util");
+
+function _default(path, attrs) {
+  const len = attrs.length;
+  if (len === 0) return _compiler.types.stringLiteral("");
+  if (len === 1 && attrs[0].node.type === "MarkoSpreadAttribute") {
+    return _compiler.types.callExpression(
+      (0, _babelUtils.importDefault)(
+        path.hub.file,
+        "marko/src/runtime/html/helpers/attrs.js",
+        "marko_attrs"
+      ),
+      [attrs[0].node.value]
+    );
+  }
+
+  if (attrs.some((attr) => attr.node.type === "MarkoSpreadAttribute")) {
+    const attrsObjects = [];
+    let props;
+
+    for (let i = 0; i < len; i++) {
+      const attr = attrs[i];
+      const {
+        node: { name, value }
+      } = attr;
+
+      if (name) {
+        const computed = (0, _util.evaluateAttr)(attr);
+        const prop = _compiler.types.objectProperty(
+          _compiler.types.stringLiteral(name),
+          computed?.value !== undefined ?
+          _compiler.types.stringLiteral(computed.value) :
+          value
+        );
+        if (props) {
+          props.push(prop);
+        } else {
+          attrsObjects.push(_compiler.types.objectExpression(props = [prop]));
+        }
+      } else {
+        attrsObjects.push(value);
+        props = undefined;
+      }
+    }
+
+    return _compiler.types.callExpression(
+      (0, _babelUtils.importDefault)(
+        path.hub.file,
+        "marko/src/runtime/html/helpers/merge-attrs.js",
+        "marko_merge_attrs"
+      ),
+      attrsObjects
+    );
+  }
+
+  const file = path.hub.file;
+  const quasis = [];
+  const expressions = [];
+  const attrValues = new Map();
+  let curString = "";
+
+  // Remove duplicate attrs so last one wins.
+  for (let i = len; i--;) {
+    const attr = attrs[i];
+    const { name, value } = attr.node;
+    if (attrValues.has(name)) continue;
+    const computed = (0, _util.evaluateAttr)(attr);
+    attrValues.set(
+      name,
+      computed ?
+      {
+        confident: true,
+        computed: computed.value,
+        value
+      } :
+      {
+        confident: false,
+        computed: undefined,
+        value
+      }
+    );
+  }
+
+  for (const [name, { confident, computed, value }] of [
+  ...attrValues].
+  reverse()) {
+    if (confident) {
+      if (computed == null || computed === false) {
+        continue;
+      }
+
+      curString += (0, _attr.default)(name, computed);
+    } else if (value.type === "TemplateLiteral") {
+      curString += " " + name + '="';
+
+      for (let i = 0; i < value.expressions.length; i++) {
+        const quasi = value.quasis[i];
+        const expression = value.expressions[i];
+        curString += (0, _escapeQuotes.d)(quasi.value.cooked);
+        quasis.push(curString);
+        curString = "";
+        expressions.push(
+          _compiler.types.callExpression(
+            (0, _babelUtils.importNamed)(
+              file,
+              "marko/src/runtime/html/helpers/escape-quotes.js",
+              "d",
+              "marko_escape_double_quotes"
+            ),
+            [expression]
+          )
+        );
+      }
+
+      curString +=
+      (0, _escapeQuotes.d)(
+        value.quasis[value.expressions.length].value.cooked
+      ) + '"';
+    } else {
+      quasis.push(curString);
+      curString = "";
+      expressions.push(
+        _compiler.types.callExpression(
+          (0, _babelUtils.importDefault)(
+            file,
+            "marko/src/runtime/html/helpers/attr.js",
+            "marko_attr"
+          ),
+          [_compiler.types.stringLiteral(name), value]
+        )
+      );
+    }
+  }
+
+  quasis.push(curString);
+
+  if (expressions.length) {
+    return (0, _babelUtils.normalizeTemplateString)(quasis, ...expressions);
+  } else {
+    return _compiler.types.stringLiteral(quasis.join(""));
+  }
+}