marko 5.36.4 → 5.37.0

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

@@ -0,0 +1,221 @@
+"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 _path = require("path");
+var _selfClosingTags = _interopRequireDefault(require("self-closing-tags"));
+
+var _htmlOutWrite = _interopRequireDefault(require("../../util/html-out-write"));
+var _keyManager = require("../../util/key-manager");
+var _withPreviousLocation = _interopRequireDefault(require("../../util/with-previous-location"));
+var _attributes = _interopRequireDefault(require("./attributes"));
+
+const EMPTY_OBJECT = {};
+
+/**
+ * Translates the html streaming version of a standard html element.
+ */
+function _default(path, isNullable) {
+  const {
+    hub: { file },
+    node
+  } = path;
+  const {
+    key,
+    name,
+    body: { body },
+    handlers
+  } = node;
+  const tagProperties = path.node.extra && path.node.extra.properties || [];
+  const tagDef = (0, _babelUtils.getTagDef)(path);
+  const meta = file.metadata.marko;
+
+  if (tagDef) {
+    const { parseOptions = EMPTY_OBJECT } = tagDef;
+    if (parseOptions.import) {
+      // TODO: the taglib should be updated to support this as a top level option.
+      file.metadata.marko.deps.push((0, _path.resolve)(tagDef.dir, parseOptions.import));
+    }
+  }
+
+  if (handlers) {
+    Object.entries(handlers).forEach(
+      ([eventName, { arguments: args, once }]) => {
+        const delegateArgs = [_compiler.types.stringLiteral(eventName), args[0]];
+
+        // TODO: look into only sending this if once is true.
+        delegateArgs.push(_compiler.types.booleanLiteral(once));
+
+        if (args.length > 1) {
+          delegateArgs.push(_compiler.types.arrayExpression(args.slice(1)));
+        }
+
+        // TODO: why do we output eventName twice.
+        tagProperties.push(
+          _compiler.types.objectProperty(
+            _compiler.types.stringLiteral(`on${eventName}`),
+            _compiler.types.callExpression(
+              _compiler.types.memberExpression(
+                file._componentDefIdentifier,
+                _compiler.types.identifier("d")
+              ),
+              delegateArgs
+            )
+          )
+        );
+      }
+    );
+  }
+
+  const isHTML = file.markoOpts.output === "html";
+  let dataMarko = _compiler.types.stringLiteral("");
+
+  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 (isHTML) {
+    if (
+    !meta.hasStatefulTagParams &&
+    !meta.hasFunctionEventHandlers && (
+    meta.hasComponentBrowser || !meta.hasComponent) ||
+    isPreserved(path))
+    {
+      const dataMarkoArgs = [_compiler.types.identifier("out"), file._componentDefIdentifier];
+
+      if (tagProperties.length) {
+        // TODO we should pre evaluate this if it is static.
+        dataMarkoArgs.push(_compiler.types.objectExpression(tagProperties));
+      }
+
+      if ((0, _keyManager.hasUserKey)(path) || key && node.isPreserved) {
+        if (dataMarkoArgs.length === 2) {
+          dataMarkoArgs.push(_compiler.types.numericLiteral(0));
+        }
+
+        dataMarkoArgs.push(key);
+      }
+
+      if (dataMarkoArgs.length > 2) {
+        dataMarko = _compiler.types.callExpression(
+          (0, _babelUtils.importDefault)(
+            file,
+            "marko/src/runtime/html/helpers/data-marko.js",
+            "marko_props"
+          ),
+          dataMarkoArgs
+        );
+      }
+    }
+  }
+
+  const translatedAttrs = (0, _attributes.default)(path, path.get("attributes"));
+  let isSelfClosing = false;
+  let openTagEnding = ">";
+
+  if (_compiler.types.isStringLiteral(name)) {
+    if (
+    tagDef &&
+    tagDef.htmlType && (
+    tagDef.htmlType === "svg" || tagDef.htmlType === "math"))
+    {
+      if (!body.length) {
+        isSelfClosing = true;
+        openTagEnding = " />";
+      }
+    } else if (_selfClosingTags.default.voidElements.indexOf(name.value) !== -1) {
+      isSelfClosing = true;
+    }
+  }
+
+  const isEmpty = isSelfClosing || !body.length;
+  let writeStartNode = (0, _babelUtils.normalizeTemplateString)`<${name}${dataMarko}${translatedAttrs}${openTagEnding}`;
+
+  writeStartNode = (0, _withPreviousLocation.default)(
+    isEmpty && !isSelfClosing ?
+    (0, _htmlOutWrite.default)`${writeStartNode}</${name}>` :
+    (0, _htmlOutWrite.default)`${writeStartNode}`,
+    name
+  );
+
+  if (isNullable) {
+    writeStartNode = _compiler.types.ifStatement(name, writeStartNode);
+
+    if (!isEmpty) {
+      writeStartNode.alternate = _compiler.types.expressionStatement(
+        _compiler.types.callExpression(
+          _compiler.types.memberExpression(_compiler.types.identifier("out"), _compiler.types.identifier("bf")),
+          [
+          (0, _babelUtils.normalizeTemplateString)`f_${key}`,
+          file._componentInstanceIdentifier,
+          _compiler.types.numericLiteral(1)]
+
+        )
+      );
+    }
+  }
+
+  if (isEmpty) {
+    path.replaceWith(writeStartNode);
+    return;
+  }
+
+  let needsBlock;
+  for (const childNode of body) {
+    if (_compiler.types.isVariableDeclaration(childNode)) {
+      if (childNode.kind === "const" || childNode.kind === "let") {
+        needsBlock = true;
+        break;
+      }
+    }
+  }
+
+  let writeEndNode = (0, _htmlOutWrite.default)`</${name}>`;
+
+  if (isNullable) {
+    writeEndNode = _compiler.types.ifStatement(
+      name,
+      writeEndNode,
+      _compiler.types.expressionStatement(
+        _compiler.types.callExpression(
+          _compiler.types.memberExpression(_compiler.types.identifier("out"), _compiler.types.identifier("ef")),
+          []
+        )
+      )
+    );
+  }
+
+  path.replaceWithMultiple(
+    [writeStartNode].
+    concat(needsBlock ? _compiler.types.blockStatement(body) : body).
+    concat(writeEndNode)
+  );
+}
+
+function isPreserved(path) {
+  let parentTag = path;
+  do {
+    parentTag = parentTag.parentPath.parentPath;
+    if (parentTag.get("isPreserved").node === true) {
+      return true;
+    }
+  } while (_compiler.types.isMarkoTag(parentTag));
+
+  return false;
+}

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

@@ -0,0 +1,105 @@
+"use strict";exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+var _util = require("../util");
+
+function _default(path, attrs) {
+  const len = attrs.length;
+  if (len === 0) return _compiler.types.nullLiteral();
+  if (len === 1 && attrs[0].node.type === "MarkoSpreadAttribute") {
+    return _compiler.types.callExpression(
+      (0, _babelUtils.importDefault)(
+        path.hub.file,
+        "marko/src/runtime/vdom/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/vdom/helpers/merge-attrs.js",
+        "marko_merge_attrs"
+      ),
+      attrsObjects
+    );
+  }
+
+  const attrValues = new Map();
+  const props = [];
+
+  // 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;
+      }
+
+      props.push(
+        _compiler.types.objectProperty(_compiler.types.stringLiteral(name), _compiler.types.stringLiteral(computed))
+      );
+    } else {
+      props.push(_compiler.types.objectProperty(_compiler.types.stringLiteral(name), value));
+    }
+  }
+
+  if (props.length) {
+    return _compiler.types.objectExpression(props);
+  }
+
+  return _compiler.types.nullLiteral();
+}

package/dist/translator/tag/native-tag[vdom]/index.js

@@ -0,0 +1,189 @@
+"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 FLAGS = _interopRequireWildcard(require("../../util/runtime-flags"));
+var _vdomOutWrite = _interopRequireDefault(require("../../util/vdom-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../../util/with-previous-location"));
+var _attributes = _interopRequireDefault(require("./attributes"));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;}
+
+const SIMPLE_ATTRS = ["id", "class", "style"];
+
+/**
+ * Translates the html streaming version of a standard html element.
+ */
+function _default(path, isNullable) {
+  const { node } = path;
+  const {
+    name,
+    key,
+    body: { body }
+  } = node;
+
+  const isEmpty = !body.length;
+  const writeArgs = tagArguments(path, false);
+  let writeStartNode = (0, _withPreviousLocation.default)(
+    (0, _vdomOutWrite.default)(isEmpty ? "e" : "be", ...writeArgs),
+    node.name
+  );
+
+  if (isNullable) {
+    writeStartNode = _compiler.types.ifStatement(name, writeStartNode);
+
+    if (!isEmpty) {
+      writeStartNode.alternate = _compiler.types.expressionStatement(
+        _compiler.types.callExpression(
+          _compiler.types.memberExpression(_compiler.types.identifier("out"), _compiler.types.identifier("bf")),
+          [
+          (0, _babelUtils.normalizeTemplateString)`f_${key}`,
+          path.hub.file._componentInstanceIdentifier]
+
+        )
+      );
+    }
+  }
+
+  if (isEmpty) {
+    path.replaceWith(writeStartNode);
+    return;
+  }
+
+  let writeEndNode = (0, _vdomOutWrite.default)("ee");
+  if (isNullable) {
+    writeEndNode = _compiler.types.ifStatement(
+      name,
+      writeEndNode,
+      _compiler.types.expressionStatement(
+        _compiler.types.callExpression(
+          _compiler.types.memberExpression(_compiler.types.identifier("out"), _compiler.types.identifier("ef")),
+          []
+        )
+      )
+    );
+  }
+
+  let needsBlock;
+  for (const childNode of body) {
+    if (_compiler.types.isVariableDeclaration(childNode)) {
+      if (childNode.kind === "const" || childNode.kind === "let") {
+        needsBlock = true;
+        break;
+      }
+    }
+  }
+
+  path.replaceWithMultiple(
+    [writeStartNode].
+    concat(needsBlock ? _compiler.types.blockStatement(body) : body).
+    concat(writeEndNode)
+  );
+}
+
+function isPropertyName({ key }, names) {
+  if (_compiler.types.isStringLiteral(key)) {
+    return names.includes(key.value);
+  } else if (_compiler.types.isIdentifier(key)) {
+    return names.includes(key.name);
+  }
+}
+
+function tagArguments(path) {
+  const {
+    hub: { file },
+    node
+  } = path;
+  const {
+    name,
+    key,
+    body: { body },
+    handlers
+  } = node;
+  const tagProperties = path.node.extra && path.node.extra.properties || [];
+  const attrsObj = (0, _attributes.default)(path, path.get("attributes"));
+  let runtimeFlags = 0;
+
+  if (!_compiler.types.isNullLiteral(attrsObj) && !_compiler.types.isObjectExpression(attrsObj)) {
+    runtimeFlags |= FLAGS.SPREAD_ATTRS;
+  }
+
+  const writeArgs = [
+  name,
+  attrsObj,
+  key,
+  file._componentInstanceIdentifier,
+  body.length ? _compiler.types.nullLiteral() : _compiler.types.numericLiteral(0)];
+
+
+  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 (handlers) {
+    Object.entries(handlers).forEach(
+      ([eventName, { arguments: args, once }]) => {
+        const delegateArgs = [_compiler.types.stringLiteral(eventName), args[0]];
+
+        // TODO: look into only sending this if once is true.
+        delegateArgs.push(_compiler.types.booleanLiteral(once));
+
+        if (args.length > 1) {
+          delegateArgs.push(_compiler.types.arrayExpression(args.slice(1)));
+        }
+
+        // TODO: why do we output eventName twice.
+        tagProperties.push(
+          _compiler.types.objectProperty(
+            _compiler.types.stringLiteral(`on${eventName}`),
+            _compiler.types.callExpression(
+              _compiler.types.memberExpression(
+                file._componentDefIdentifier,
+                _compiler.types.identifier("d")
+              ),
+              delegateArgs
+            )
+          )
+        );
+      }
+    );
+  }
+
+  if (
+  _compiler.types.isObjectExpression(attrsObj) &&
+  attrsObj.properties.every((n) => isPropertyName(n, SIMPLE_ATTRS)) &&
+  !node.preserveAttrs)
+  {
+    runtimeFlags |= FLAGS.HAS_SIMPLE_ATTRS;
+  }
+
+  const tagDef = (0, _babelUtils.getTagDef)(path);
+
+  if (tagDef) {
+    const { htmlType } = tagDef;
+    if (htmlType === "custom-element") {
+      runtimeFlags |= FLAGS.IS_CUSTOM_ELEMENT;
+    }
+  }
+
+  writeArgs.push(_compiler.types.numericLiteral(runtimeFlags));
+
+  if (tagProperties.length) {
+    writeArgs.push(_compiler.types.objectExpression(tagProperties));
+  }
+  return writeArgs;
+}