marko 5.36.4 → 5.37.0

package/dist/translator/placeholder/index[html].js

@@ -0,0 +1,93 @@
+"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 _toString = _interopRequireDefault(require("marko/src/runtime/helpers/to-string"));
+var _escapeScriptPlaceholder = _interopRequireDefault(require("marko/src/runtime/html/helpers/escape-script-placeholder"));
+var _escapeStylePlaceholder = _interopRequireDefault(require("marko/src/runtime/html/helpers/escape-style-placeholder"));
+var _escapeXml = require("marko/src/runtime/html/helpers/escape-xml");
+
+var _htmlOutWrite = _interopRequireDefault(require("../util/html-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+
+const ESCAPE_TYPES = {
+  html: {
+    name: "x",
+    module: "marko/src/runtime/html/helpers/escape-xml.js",
+    alias: "marko_escapeXml",
+    fn: _escapeXml.x
+  },
+  script: {
+    module: "marko/src/runtime/html/helpers/escape-script-placeholder.js",
+    alias: "marko_escapeScript",
+    fn: _escapeScriptPlaceholder.default
+  },
+  style: {
+    module: "marko/src/runtime/html/helpers/escape-style-placeholder.js",
+    alias: "marko_escapeStyle",
+    fn: _escapeStylePlaceholder.default
+  }
+};
+
+function _default(path) {
+  const {
+    node,
+    hub: { file }
+  } = path;
+  const computed = (0, _babelUtils.computeNode)(node.value);
+  let { escape, value } = node;
+
+  if (escape) {
+    const tagName = findParentTagName(path);
+    const escapeType = ESCAPE_TYPES[tagName] || ESCAPE_TYPES.html;
+
+    value = computed ?
+    _compiler.types.stringLiteral(escapeType.fn(computed.value)) :
+    _compiler.types.callExpression(
+      escapeType.name ?
+      (0, _babelUtils.importNamed)(
+        file,
+        escapeType.module,
+        escapeType.name,
+        escapeType.alias
+      ) :
+      (0, _babelUtils.importDefault)(file, escapeType.module, escapeType.alias),
+      [value]
+    );
+  } else {
+    value = computed ?
+    _compiler.types.stringLiteral((0, _toString.default)(computed.value)) :
+    _compiler.types.callExpression(
+      (0, _babelUtils.importDefault)(
+        file,
+        "marko/src/runtime/helpers/to-string.js",
+        "marko_to_string"
+      ),
+      [value]
+    );
+  }
+
+  const replacement = (0, _htmlOutWrite.default)`${value}`;
+
+  if (replacement) {
+    path.replaceWith((0, _withPreviousLocation.default)(replacement, node));
+  } else {
+    path.remove();
+  }
+}
+
+function findParentTagName(path) {
+  while (path = path.parentPath) {
+    if (path.isProgram()) {
+      return;
+    }
+
+    if (path.isMarkoTag()) {
+      const tagDef = (0, _babelUtils.getTagDef)(path);
+      return tagDef && tagDef.html && path.get("name.value").node;
+    }
+  }
+}

package/dist/translator/placeholder/index[vdom].js

@@ -0,0 +1,22 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _babelUtils = require("@marko/compiler/babel-utils");
+
+var _vdomOutWrite = _interopRequireDefault(require("../util/vdom-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+
+function _default(path) {
+  const { node } = path;
+  const { escape, value } = node;
+  const method = escape ? "t" : "h";
+  const computed = (0, _babelUtils.computeNode)(value);
+
+  if (computed && computed.value == null) {
+    path.remove();
+  } else {
+    path.replaceWith(
+      (0, _withPreviousLocation.default)(
+        (0, _vdomOutWrite.default)(method, value, path.hub.file._componentInstanceIdentifier),
+        node
+      )
+    );
+  }
+}

package/dist/translator/scriptlet.js

@@ -0,0 +1,4 @@
+"use strict";exports.__esModule = true;exports.default = _default;function _default(path) {
+  const { node } = path;
+  path.replaceWithMultiple(node.body);
+}

package/dist/translator/tag/attribute/directives/class.js

@@ -0,0 +1,42 @@
+"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 _classValue = _interopRequireDefault(require("marko/src/runtime/helpers/class-value"));
+
+var _withPreviousLocation = _interopRequireDefault(require("../../../util/with-previous-location"));var _default = exports.default =
+
+{
+  exit(tag, _, value) {
+    const {
+      hub: { file }
+    } = tag;
+    if (!(0, _babelUtils.isNativeTag)(tag)) return;
+
+    const computed = (0, _babelUtils.computeNode)(value.node);
+    if (computed) {
+      const str = (0, _classValue.default)(computed.value);
+      if (str) {
+        value.replaceWith(_compiler.types.stringLiteral(str));
+      } else {
+        value.parentPath.remove();
+      }
+    } else if (!value.isTemplateLiteral()) {
+      value.replaceWith(
+        (0, _withPreviousLocation.default)(
+          _compiler.types.callExpression(
+            (0, _babelUtils.importDefault)(
+              file,
+              "marko/src/runtime/helpers/class-value.js",
+              "marko_class_merge"
+            ),
+            [value.node]
+          ),
+          value.node
+        )
+      );
+    }
+  }
+};

package/dist/translator/tag/attribute/directives/index.js

@@ -0,0 +1,15 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _class = _interopRequireDefault(require("./class"));
+var _noUpdate = _interopRequireDefault(require("./no-update"));
+var _noUpdateBody = _interopRequireDefault(require("./no-update-body"));
+var _noUpdateBodyIf = _interopRequireDefault(require("./no-update-body-if"));
+var _noUpdateIf = _interopRequireDefault(require("./no-update-if"));
+var _style = _interopRequireDefault(require("./style"));var _default = exports.default =
+
+{
+  class: _class.default,
+  style: _style.default,
+  "no-update": _noUpdate.default,
+  "no-update-if": _noUpdateIf.default,
+  "no-update-body": _noUpdateBody.default,
+  "no-update-body-if": _noUpdateBodyIf.default
+};

package/dist/translator/tag/attribute/directives/no-update-body-if.js

@@ -0,0 +1,15 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _babelUtils = require("@marko/compiler/babel-utils");
+
+var _noUpdate = _interopRequireDefault(require("./no-update"));var _default = exports.default =
+
+{
+  enter(tag) {
+    tag.node.isPreserved = true;
+  },
+  exit(tag, attr, value) {
+    _noUpdate.default.exit(tag, attr, value, {
+      if: (0, _babelUtils.getArgOrSequence)(attr),
+      bodyOnly: true
+    });
+  }
+};

package/dist/translator/tag/attribute/directives/no-update-body.js

@@ -0,0 +1,10 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _noUpdate = _interopRequireDefault(require("./no-update"));var _default = exports.default =
+
+{
+  enter(tag) {
+    tag.node.isPreserved = true;
+  },
+  exit(tag, attr, value) {
+    _noUpdate.default.exit(tag, attr, value, { bodyOnly: true });
+  }
+};

package/dist/translator/tag/attribute/directives/no-update-if.js

@@ -0,0 +1,12 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _babelUtils = require("@marko/compiler/babel-utils");
+
+var _noUpdate = _interopRequireDefault(require("./no-update"));var _default = exports.default =
+
+{
+  enter(tag) {
+    tag.node.isPreserved = true;
+  },
+  exit(tag, attr, value) {
+    _noUpdate.default.exit(tag, attr, value, { if: (0, _babelUtils.getArgOrSequence)(attr) });
+  }
+};

package/dist/translator/tag/attribute/directives/no-update.js

@@ -0,0 +1,48 @@
+"use strict";exports.__esModule = true;exports.default = void 0;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+const EMPTY_OBJECT = {};var _default = exports.default =
+
+{
+  enter(tag) {
+    tag.node.isPreserved = true;
+  },
+  exit(tag, attr, _, opts = EMPTY_OBJECT) {
+    attr.remove();
+    const { node } = tag;
+    const replacement = _compiler.types.markoTag(
+      _compiler.types.stringLiteral("_preserve"),
+      [],
+      opts.bodyOnly ? node.body : _compiler.types.markoTagBody([node])
+    );
+
+    if ((0, _babelUtils.isNativeTag)(tag)) {
+      replacement.key = node.key;
+      replacement.attributes.push(
+        _compiler.types.markoAttribute("n", _compiler.types.booleanLiteral(true))
+      );
+
+      if (opts.bodyOnly) {
+        replacement.attributes.push(
+          _compiler.types.markoAttribute("b", _compiler.types.booleanLiteral(true))
+        );
+      }
+    } else {
+      replacement.key = (0, _babelUtils.normalizeTemplateString)`p_${node.key}`;
+    }
+
+    replacement.isPreserved = true;
+
+    if (opts.if) {
+      replacement.attributes.push(_compiler.types.markoAttribute("i", opts.if));
+    }
+
+    if (opts.bodyOnly) {
+      tag.set("body", _compiler.types.markoTagBody([replacement]));
+    } else {
+      tag.replaceWith(replacement);
+    }
+  }
+};

package/dist/translator/tag/attribute/directives/style.js

@@ -0,0 +1,42 @@
+"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 _styleValue = _interopRequireDefault(require("marko/src/runtime/helpers/style-value"));
+
+var _withPreviousLocation = _interopRequireDefault(require("../../../util/with-previous-location"));var _default = exports.default =
+
+{
+  exit(tag, _, value) {
+    const {
+      hub: { file }
+    } = tag;
+    if (!(0, _babelUtils.isNativeTag)(tag)) return;
+
+    const computed = (0, _babelUtils.computeNode)(value.node);
+    if (computed) {
+      const str = (0, _styleValue.default)(computed.value);
+      if (str) {
+        value.replaceWith(_compiler.types.stringLiteral(str));
+      } else {
+        value.parentPath.remove();
+      }
+    } else if (!value.isTemplateLiteral()) {
+      value.replaceWith(
+        (0, _withPreviousLocation.default)(
+          _compiler.types.callExpression(
+            (0, _babelUtils.importDefault)(
+              file,
+              "marko/src/runtime/helpers/style-value.js",
+              "marko_style_merge"
+            ),
+            [value.node]
+          ),
+          value.node
+        )
+      );
+    }
+  }
+};

package/dist/translator/tag/attribute/index.js

@@ -0,0 +1,150 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+var _directives = _interopRequireDefault(require("./directives"));
+var _modifiers = _interopRequireDefault(require("./modifiers"));
+
+const EMPTY_ARRAY = [];
+const EVENT_REG = /^(on(?:ce)?)(-)?(.*)$/;
+const attachedDetachedLoaded = new WeakSet();var _default = exports.default =
+
+{
+  enter(attr) {
+    const {
+      hub: { file }
+    } = attr;
+    const tag = attr.parentPath;
+    const value = attr.get("value");
+    const { name, arguments: args } = attr.node;
+    const isVDOM = file.markoOpts.output !== "html";
+
+    if (execModifiersAndDirectives("enter", tag, attr, value)) {
+      return;
+    }
+
+    // Event handlers.
+    let [, eventType, isDash, eventName] = EVENT_REG.exec(name) || EMPTY_ARRAY;
+
+    if (eventType && args) {
+      if (!args.length) {
+        throw attr.buildCodeFrameError("Event handler is missing arguments.");
+      }
+
+      if (!value.isBooleanLiteral(true)) {
+        throw value.buildCodeFrameError(
+          `"${name}(handler, ...args)" does not accept a value.`
+        );
+      }
+
+      if (!isDash) {
+        // When the event is not in dash case we normalized differently for html tags and custom tags.
+
+        if ((0, _babelUtils.isNativeTag)(tag)) {
+          // Lowercase the string
+          // Example: onMouseOver → mouseover
+          eventName = eventName.toLowerCase();
+        } else {
+          // Convert first character to lower case:
+          // Example: onBeforeShow → beforeShow
+          eventName = eventName.charAt(0).toLowerCase() + eventName.slice(1);
+        }
+      }
+
+      const handlers = tag.node.handlers = tag.node.handlers || {};
+      if (handlers[eventName]) {
+        throw attr.buildCodeFrameError(
+          "Duplicate event handlers are not supported."
+        );
+      }
+
+      handlers[eventName] = {
+        arguments: args,
+        once: eventType === "once"
+      };
+
+      if (isVDOM) {
+        if (eventName === "attach" || eventName === "detach") {
+          if (!attachedDetachedLoaded.has(file)) {
+            // Pull in helper for element attach/detach;
+            attachedDetachedLoaded.add(file);
+            (0, _babelUtils.importDefault)(
+              file,
+              "marko/src/runtime/components/attach-detach.js"
+            );
+          }
+        }
+      }
+
+      attr.remove();
+      return;
+    }
+  },
+  exit(attr) {
+    const tag = attr.parentPath;
+    const { name, arguments: args } = attr.node;
+    const value = attr.get("value");
+
+    if (execModifiersAndDirectives("exit", tag, attr, value)) {
+      return;
+    }
+
+    const tagDef = (0, _babelUtils.getTagDef)(tag);
+
+    if (tagDef) {
+      if (!tagDef.html && !tagDef.getAttribute(name)) {
+        throw attr.buildCodeFrameError(
+          `<${
+          tag.get("name.value").node}> does not support the "${
+          name}" attribute.`
+        );
+      }
+    }
+
+    if (args && args.length) {
+      throw attr.buildCodeFrameError(
+        `Unsupported arguments on the "${name}" attribute.`
+      );
+    }
+
+    if (attr.node.bound) {
+      throw attr.buildCodeFrameError(
+        `The binding syntax (:=) is only supported when using the "Tags API".`
+      );
+    }
+  }
+};
+
+function execModifiersAndDirectives(type, tag, attr, value) {
+  const { node } = attr;
+  const { name, modifier } = node;
+
+  if (modifier) {
+    const modifierTranslate = _modifiers.default[modifier];
+    if (modifierTranslate) {
+      if (modifierTranslate[type]) {
+        const tagNode = tag.node;
+        const attrNode = attr.node;
+        modifierTranslate[type](tag, attr, value);
+        if (tag.node !== tagNode || attr.node !== attrNode) return true;
+      }
+    } else if (name === "xlink" && modifier === "href" && (0, _babelUtils.isNativeTag)(tag)) {
+      node.name += `:${modifier}`;
+      node.modifier = undefined;
+    } else {
+      throw attr.buildCodeFrameError(`Unsupported modifier "${modifier}".`);
+    }
+  }
+
+  const directiveTranslate = _directives.default[name];
+  if (directiveTranslate) {
+    if (directiveTranslate[type]) {
+      const tagNode = tag.node;
+      const attrNode = attr.node;
+      directiveTranslate[type](tag, attr, value);
+      if (tag.node !== tagNode || attr.node !== attrNode) return true;
+    }
+  }
+}

package/dist/translator/tag/attribute/modifiers/index.js

@@ -0,0 +1,7 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _noUpdate = _interopRequireDefault(require("./no-update"));
+var _scoped = _interopRequireDefault(require("./scoped"));var _default = exports.default =
+
+{
+  scoped: _scoped.default,
+  "no-update": _noUpdate.default
+};

package/dist/translator/tag/attribute/modifiers/no-update.js

@@ -0,0 +1,14 @@
+"use strict";exports.__esModule = true;exports.default = void 0; /**
+ * Does nothing in html mode.
+ */var _default = exports.default =
+{
+  exit(tag, attr) {
+    const { node } = tag;
+
+    if (!node.preserveAttrs) {
+      node.preserveAttrs = [];
+    }
+
+    node.preserveAttrs.push(attr.node.name);
+  }
+};

package/dist/translator/tag/attribute/modifiers/scoped.js

@@ -0,0 +1,23 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = void 0;var _compiler = require("@marko/compiler");
+
+var _withPreviousLocation = _interopRequireDefault(require("../../../util/with-previous-location"));var _default = exports.default =
+
+{
+  exit(tag, _, value) {
+    const {
+      hub: { file }
+    } = tag;
+    value.replaceWith(
+      (0, _withPreviousLocation.default)(
+        _compiler.types.callExpression(
+          _compiler.types.memberExpression(
+            file._componentDefIdentifier,
+            _compiler.types.identifier("elId")
+          ),
+          [value.node]
+        ),
+        value.node
+      )
+    );
+  }
+};

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

@@ -0,0 +1,149 @@
+"use strict";exports.__esModule = true;exports.analyzeAttributeTags = analyzeAttributeTags;exports.default = translateAttributeTag;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+
+
+
+
+var _util = require("./util");
+
+const attributeTagsForTag = new WeakMap();
+const contentTypeCache = new WeakMap();
+const ContentType = {
+  attribute: 0,
+  render: 1,
+  mixed: 2
+};
+
+function analyzeAttributeTags(rootTag) {
+  const visit = [rootTag];
+  const parentTags = [rootTag];
+  let i = 0;
+  let attributeTags;
+
+  while (i < visit.length) {
+    const tag = visit[i++];
+    const attrTags = tag.node.body.attributeTags ?
+    tag.get("body").get("body") :
+    tag.get("attributeTags");
+    for (const child of attrTags) {
+      if ((0, _babelUtils.isAttributeTag)(child)) {
+        (0, _babelUtils.assertNoArgs)(child);
+        const tagDef = (0, _babelUtils.getTagDef)(child) || {};
+        const name = (0, _babelUtils.getFullyResolvedTagName)(child);
+        let {
+          targetProperty = child.node.name.value.slice(1),
+          isRepeated = false
+        } = tagDef;
+
+        const preserveName =
+        tagDef.preserveName === true || tagDef.removeDashes === false;
+
+        if (!preserveName) {
+          targetProperty = removeDashes(targetProperty);
+        }
+
+        const attrTagMeta = (attributeTags ||= {})[name] ||= {
+          targetProperty,
+          isRepeated
+        };
+
+        (child.node.extra ||= {}).attributeTag = attrTagMeta;
+
+        const parentTag = (0, _babelUtils.findParentTag)(child);
+        const parentTagExtra = parentTag.node.extra ||= {};
+        const parentSeenAttributeTagProperties =
+        attributeTagsForTag.get(parentTag);
+        let hasAttributeTags = false;
+
+        if (!parentSeenAttributeTagProperties) {
+          parentTagExtra.hasAttributeTags = true;
+          attributeTagsForTag.set(parentTag, new Set([targetProperty]));
+        } else if (parentSeenAttributeTagProperties.has(targetProperty)) {
+          hasAttributeTags = true;
+        } else {
+          parentSeenAttributeTagProperties.add(targetProperty);
+        }
+
+        if (!hasAttributeTags) {
+          if (
+          parentTag.
+          get("attributes").
+          some(
+            (attr) =>
+            attr.isMarkoSpreadAttribute() ||
+            attr.node.name === targetProperty
+          ))
+          {
+            parentTag.pushContainer(
+              "attributes",
+              _compiler.types.markoAttribute(
+                targetProperty,
+                _compiler.types.unaryExpression("void", _compiler.types.numericLiteral(0))
+              )
+            );
+          }
+        }
+
+        parentTags.push(child);
+        visit.push(child);
+      } else if ((0, _babelUtils.isTransparentTag)(child)) {
+        visit.push(child);
+      }
+    }
+  }
+
+  if (attributeTags) {
+    (rootTag.node.extra ??= {}).attributeTags = attributeTags;
+  }
+}
+
+function translateAttributeTag(tag) {
+  const { node } = tag;
+  const meta = node.extra?.attributeTag;
+  if (!meta) {
+    throw tag.
+    get("name").
+    buildCodeFrameError("@tags must be nested within another element.");
+  }
+
+  (0, _babelUtils.assertNoArgs)(tag);
+
+  tag.replaceWith(
+    _compiler.types.expressionStatement(
+      _compiler.types.callExpression(
+        (0, _babelUtils.importNamed)(
+          tag.hub.file,
+          "marko/src/runtime/helpers/attr-tag.js",
+          meta.isRepeated ? "r" : "a",
+          meta.isRepeated ?
+          "marko_repeated_attr_tag" :
+          "marko_repeatable_attr_tag"
+        ),
+        [_compiler.types.stringLiteral(meta.targetProperty), getAttrTagObject(tag)]
+      )
+    )
+  );
+}
+
+function getAttrTagObject(tag) {
+  const attrs = (0, _util.getAttrs)(tag, false, true);
+
+  if (_compiler.types.isNullLiteral(attrs)) {
+    return _compiler.types.objectExpression([]);
+  }
+
+  return attrs;
+}
+
+function removeDashes(str) {
+  return str.replace(/-([a-z])/g, matchToUpperCase);
+}
+
+function matchToUpperCase(_match, lower) {
+  return lower.toUpperCase();
+}