marko 5.36.4 → 5.37.0

package/dist/translator/taglib/core/transform-style.js

@@ -0,0 +1,66 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _babelUtils = require("@marko/compiler/babel-utils");
+var _path = _interopRequireDefault(require("path"));
+
+var _getComponentFiles = _interopRequireDefault(require("../../util/get-component-files"));
+
+const STYLE_REG = /^style((?:\.[^.\s\\/:*?"<>|({]+)+)?\s*\{/;
+
+function _default(tag) {
+  const { hub, node } = tag;
+  const { deps } = hub.file.metadata.marko;
+  const { rawValue } = node;
+  const matchedBlock = STYLE_REG.exec(rawValue);
+  if (!matchedBlock) {
+    return;
+  }
+
+  if (!tag.parentPath.isProgram()) {
+    throw tag.
+    get("name").
+    buildCodeFrameError(
+      "Style blocks must be at the root of your Marko template."
+    );
+  }
+
+  if (deps.some((dep) => dep.style)) {
+    throw tag.
+    get("name").
+    buildCodeFrameError(
+      "A Marko file can only contain a single inline style block."
+    );
+  }
+
+  if ((0, _getComponentFiles.default)(tag).styleFile) {
+    throw tag.
+    get("name").
+    buildCodeFrameError(
+      'A Marko file can either have an inline style block, or an external "style.ext" file, but not both.'
+    );
+  }
+
+  const [startContent, type = ".css"] = matchedBlock;
+  const codeSartOffset = startContent.length;
+  const codeEndOffset = rawValue.lastIndexOf("}");
+  const code = rawValue.slice(codeSartOffset, codeEndOffset);
+  const base = _path.default.basename(hub.file.opts.filename);
+  const start = (0, _babelUtils.getStart)(hub.file, node.name);
+  let startPos = undefined;
+  let endPos = undefined;
+
+  if (start !== null) {
+    startPos = start + codeSartOffset;
+    endPos = start + codeEndOffset;
+  }
+
+  deps.push({
+    type: type.slice(1),
+    code,
+    style: true,
+    startPos,
+    endPos,
+    path: `./${base}`,
+    virtualPath: `./${base + type}`
+  });
+
+  tag.remove();
+}

package/dist/translator/taglib/core/translate-await.js

@@ -0,0 +1,41 @@
+"use strict";exports.__esModule = true;exports.enter = enter;var _compiler = require("@marko/compiler");
+
+function enter(path) {
+  const args = path.get("arguments");
+
+  if (!args.length) {
+    throw path.
+    get("name").
+    buildCodeFrameError(
+      'You must provide a promise argument to the "<await>" tag, eg: "<await(promise)>".'
+    );
+  } else if (args.length > 1) {
+    const {
+      loc: { start }
+    } = args[1].node;
+    const {
+      loc: { end }
+    } = args[args.length - 1].node;
+    throw path.hub.file.buildCodeFrameError(
+      { loc: { start, end } },
+      'You can only pass one argument to the "<await>" tag.'
+    );
+  }
+
+  const [provider] = args;
+  path.pushContainer(
+    "attributes",
+    _compiler.types.markoAttribute("_provider", provider.node)
+  );
+
+  if (
+  !path.get("attributes").some((attr) => attr.get("name").node === "name"))
+  {
+    path.pushContainer(
+      "attributes",
+      _compiler.types.markoAttribute("_name", _compiler.types.stringLiteral(provider.toString()))
+    );
+  }
+
+  path.set("arguments", undefined);
+}

package/dist/translator/taglib/core/translate-body.js

@@ -0,0 +1,17 @@
+"use strict";exports.__esModule = true;exports.enter = enter;var _compiler = require("@marko/compiler");
+
+function enter(path) {
+  if (path.hub.file.markoOpts.output === "html") {
+    const body = path.get("body");
+
+    body.pushContainer("body", [
+    _compiler.types.markoTag(_compiler.types.stringLiteral("init-components"), [], _compiler.types.markoTagBody()),
+    _compiler.types.markoTag(_compiler.types.stringLiteral("await-reorderer"), [], _compiler.types.markoTagBody()),
+    _compiler.types.markoTag(
+      _compiler.types.stringLiteral("_preferred-script-location"),
+      [],
+      _compiler.types.markoTagBody()
+    )]
+    );
+  }
+}

package/dist/translator/taglib/core/translate-for.js

@@ -0,0 +1,156 @@
+"use strict";exports.__esModule = true;exports.exit = exit;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+function exit(path) {
+  const { node } = path;
+  const {
+    attributes,
+    body: { params }
+  } = node;
+  const body = node.body.body;
+  const namePath = path.get("name");
+  const ofAttr = findName(attributes, "of");
+  const inAttr = findName(attributes, "in");
+  const fromAttr = findName(attributes, "from");
+  const toAttr = findName(attributes, "to");
+  const block = _compiler.types.blockStatement(body);
+  let forNode;
+  let allowedAttributes = ["by"];
+
+  if (inAttr) {
+    allowedAttributes.push("in");
+
+    const [keyParam, valParam] = params;
+
+    if (!keyParam) {
+      throw namePath.buildCodeFrameError(
+        "Invalid 'for in' tag, missing |key, value| params."
+      );
+    }
+
+    if (valParam) {
+      block.body.unshift(
+        _compiler.types.variableDeclaration("const", [
+        _compiler.types.variableDeclarator(
+          valParam,
+          _compiler.types.memberExpression(inAttr.value, keyParam, true)
+        )]
+        )
+      );
+    }
+
+    forNode = _compiler.types.forInStatement(
+      _compiler.types.variableDeclaration("const", [_compiler.types.variableDeclarator(keyParam)]),
+      inAttr.value,
+      block
+    );
+  } else if (ofAttr) {
+    let ofAttrValue = _compiler.types.callExpression(
+      (0, _babelUtils.importDefault)(
+        path.hub.file,
+        "marko/src/runtime/helpers/of-fallback.js",
+        "of_fallback"
+      ),
+      [ofAttr.value]
+    );
+    allowedAttributes.push("of");
+
+    const [valParam, keyParam, loopParam] = params;
+
+    if (!valParam) {
+      throw namePath.buildCodeFrameError(
+        "Invalid 'for of' tag, missing |value, index| params."
+      );
+    }
+
+    forNode = [];
+
+    if (keyParam) {
+      const indexName = path.scope.generateUidIdentifier(keyParam.name);
+      forNode.push(
+        _compiler.types.variableDeclaration("let", [
+        _compiler.types.variableDeclarator(indexName, _compiler.types.numericLiteral(0))]
+        )
+      );
+
+      block.body.unshift(
+        _compiler.types.variableDeclaration("let", [
+        _compiler.types.variableDeclarator(keyParam, _compiler.types.updateExpression("++", indexName))]
+        )
+      );
+    }
+
+    if (loopParam) {
+      ofAttrValue = loopParam;
+      forNode.push(
+        _compiler.types.variableDeclaration("const", [
+        _compiler.types.variableDeclarator(loopParam, ofAttr.value)]
+        )
+      );
+    }
+
+    forNode.push(
+      _compiler.types.forOfStatement(
+        _compiler.types.variableDeclaration("const", [_compiler.types.variableDeclarator(valParam)]),
+        ofAttrValue,
+        block
+      )
+    );
+  } else if (fromAttr && toAttr) {
+    allowedAttributes.push("from", "to", "step");
+
+    const stepAttr = findName(attributes, "step") || {
+      value: _compiler.types.numericLiteral(1)
+    };
+    const stepValue = stepAttr ? stepAttr.value : _compiler.types.numericLiteral(1);
+    const [indexParam] = params;
+    const stepsName = path.scope.generateUidIdentifier("steps");
+    const stepName = path.scope.generateUidIdentifier("step");
+
+    if (indexParam) {
+      block.body.unshift(
+        _compiler.types.variableDeclaration("const", [
+        _compiler.types.variableDeclarator(
+          indexParam,
+          _compiler.types.binaryExpression(
+            "+",
+            fromAttr.value,
+            _compiler.types.binaryExpression("*", stepName, stepValue)
+          )
+        )]
+        )
+      );
+    }
+
+    forNode = _compiler.types.forStatement(
+      _compiler.types.variableDeclaration("let", [
+      _compiler.types.variableDeclarator(
+        stepsName,
+        _compiler.types.binaryExpression(
+          "/",
+          _compiler.types.binaryExpression("-", toAttr.value, fromAttr.value),
+          stepValue
+        )
+      ),
+      _compiler.types.variableDeclarator(stepName, _compiler.types.numericLiteral(0))]
+      ),
+      _compiler.types.binaryExpression("<=", stepName, stepsName),
+      _compiler.types.updateExpression("++", stepName),
+      block
+    );
+  } else {
+    throw namePath.buildCodeFrameError(
+      "Invalid 'for' tag, missing an 'of', 'in' or 'to' attribute."
+    );
+  }
+
+  (0, _babelUtils.assertAllowedAttributes)(path, allowedAttributes);
+  path.replaceWithMultiple([].concat(forNode));
+}
+
+function findName(arr, value) {
+  return arr.find((obj) => obj.name === value);
+}

package/dist/translator/taglib/core/translate-html-comment.js

@@ -0,0 +1,52 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.enter = enter;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+var _htmlOutWrite = _interopRequireDefault(require("../../util/html-out-write"));
+var _vdomOutWrite = _interopRequireDefault(require("../../util/vdom-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../../util/with-previous-location"));
+
+function enter(path) {
+  (0, _babelUtils.assertNoArgs)(path);
+  (0, _babelUtils.assertNoParams)(path);
+  (0, _babelUtils.assertNoAttributes)(path);
+
+  if (path.hub.file.markoOpts.output === "html") {
+    path.replaceWithMultiple([
+    (0, _htmlOutWrite.default)`<!--`,
+    ...path.node.body.body,
+    (0, _htmlOutWrite.default)`-->`]
+    );
+  } else {
+    const templateQuasis = [];
+    const templateExpressions = [];
+    let currentQuasi = "";
+    for (const child of path.node.body.body) {
+      if (_compiler.types.isMarkoText(child)) {
+        currentQuasi += child.value;
+      } else if (_compiler.types.isMarkoPlaceholder(child)) {
+        templateQuasis.push(_compiler.types.templateElement({ raw: currentQuasi }));
+        templateExpressions.push(child.value);
+        currentQuasi = "";
+      }
+    }
+
+    let value;
+    if (templateExpressions.length === 0) {
+      value = _compiler.types.stringLiteral(currentQuasi);
+    } else {
+      templateQuasis.push(_compiler.types.templateElement({ raw: currentQuasi }));
+      value = _compiler.types.templateLiteral(templateQuasis, templateExpressions);
+    }
+
+    path.replaceWith(
+      (0, _withPreviousLocation.default)(
+        (0, _vdomOutWrite.default)("comment", value, path.hub.file._componentInstanceIdentifier),
+        path.node
+      )
+    );
+  }
+}

package/dist/translator/taglib/core/translate-include-content.js

@@ -0,0 +1,53 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.enter = enter;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+var _path = _interopRequireDefault(require("path"));
+
+function enter(tag) {
+  const {
+    hub: { file }
+  } = tag;
+  (0, _babelUtils.assertNoParams)(tag);
+  (0, _babelUtils.assertNoAttributes)(tag);
+
+  const fs = file.markoOpts.fileSystem;
+  const tagName = tag.get("name").node.value;
+  const tagExample = `<${tagName}("./path-to-file.ext")>`;
+  const args = tag.get("arguments");
+
+  if (args.length !== 1) {
+    throw tag.buildCodeFrameError(
+      `A single path argument is required for ${tagExample}.`
+    );
+  }
+
+  const [content] = args;
+
+  if (!content.isStringLiteral()) {
+    throw content.buildCodeFrameError(
+      `The argument to ${tagExample} must be a static string.`
+    );
+  }
+
+  const dir = _path.default.dirname(file.opts.filename);
+  const fullPath = _path.default.resolve(dir, content.node.value);
+
+  try {
+    const stat = fs.statSync(fullPath);
+
+    if (!stat.isFile()) {
+      throw new Error();
+    }
+  } catch {
+    throw content.buildCodeFrameError(`Unable to find file for <${tagName}>.`);
+  }
+
+  tag.replaceWith(
+    _compiler.types.markoPlaceholder(
+      _compiler.types.stringLiteral(fs.readFileSync(fullPath).toString("utf-8")),
+      tagName === "include-text"
+    )
+  );
+}

package/dist/translator/taglib/core/translate-server-only.js

@@ -0,0 +1,5 @@
+"use strict";exports.__esModule = true;exports.enter = enter;function enter(path) {
+  if (path.hub.file.markoOpts.output !== "html") {
+    path.remove();
+  }
+}

package/dist/translator/taglib/core/translate-while.js

@@ -0,0 +1,32 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.exit = exit;var _compiler = require("@marko/compiler");
+var _babelUtils = require("@marko/compiler/babel-utils");
+
+
+
+
+
+var _withPreviousLocation = _interopRequireDefault(require("../../util/with-previous-location"));
+
+function exit(path) {
+  (0, _babelUtils.assertNoParams)(path);
+  (0, _babelUtils.assertNoAttributes)(path);
+  const arg = (0, _babelUtils.getArgOrSequence)(path);
+
+  if (!arg) {
+    throw path.
+    get("name").
+    buildCodeFrameError(
+      "A condition is required for the <while(condition)> tag."
+    );
+  }
+
+  path.replaceWith(
+    (0, _withPreviousLocation.default)(
+      _compiler.types.whileStatement(
+        (0, _babelUtils.getArgOrSequence)(path),
+        _compiler.types.blockStatement(path.node.body.body)
+      ),
+      path.node
+    )
+  );
+}

package/dist/translator/taglib/index.js

@@ -0,0 +1,6 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.optionalTaglibs = exports.default = void 0;var _core = _interopRequireDefault(require("./core"));
+var _migrate = _interopRequireDefault(require("./migrate"));
+const optionalTaglibs = exports.optionalTaglibs = ["marko-widgets", "@marko/compat-v4"];var _default = exports.default =
+[
+["marko/core", _core.default],
+["marko/migrate", _migrate.default]];

package/dist/translator/taglib/migrate/all-templates.js

@@ -0,0 +1,46 @@
+"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 _withPreviousLocation = _interopRequireDefault(require("../../util/with-previous-location"));
+const kHadAssignment = Symbol();var _default = exports.default =
+
+{
+  AssignmentExpression(path, state) {
+    if (
+    !state[kHadAssignment] &&
+    path.node.left.type === "Identifier" &&
+    path.node.left.name === "data")
+    {
+      state[kHadAssignment] = true;
+
+      let root = path.parentPath;
+      while (root.parentPath.type !== "Program") {
+        root = root.parentPath;
+      }
+
+      root.insertBefore(
+        _compiler.types.markoScriptlet([
+        _compiler.types.variableDeclaration("var", [
+        _compiler.types.variableDeclarator(_compiler.types.identifier("data"))]
+        )]
+        )
+      );
+    }
+  },
+  ReferencedIdentifier(path, state) {
+    if (
+    !state[kHadAssignment] &&
+    path.node.name === "data" &&
+    !path.scope.hasBinding("data"))
+    {
+      (0, _babelUtils.diagnosticDeprecate)(path, {
+        label: "The 'data' variable is deprecated. Use 'input' instead.",
+        fix() {
+          path.replaceWith(
+            (0, _withPreviousLocation.default)(_compiler.types.identifier("input"), path.node)
+          );
+        }
+      });
+    }
+  }
+};

package/dist/translator/taglib/migrate/index.js

@@ -0,0 +1,5 @@
+"use strict";exports.__esModule = true;exports.default = void 0;var migrateAllTemplates = _interopRequireWildcard(require("./all-templates"));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 =
+{
+  "taglib-id": "marko-default-migrate",
+  migrator: migrateAllTemplates
+};

package/dist/translator/text/index.js

@@ -0,0 +1,10 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _indexHtml = _interopRequireDefault(require("./index[html]"));
+var _indexVdom = _interopRequireDefault(require("./index[vdom]"));
+
+function _default(path) {
+  if (path.hub.file.markoOpts.output === "html") {
+    (0, _indexHtml.default)(path);
+  } else {
+    (0, _indexVdom.default)(path);
+  }
+}

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

@@ -0,0 +1,12 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+
+var _htmlOutWrite = _interopRequireDefault(require("../util/html-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+
+function _default(path) {
+  const { node } = path;
+
+  path.replaceWith(
+    (0, _withPreviousLocation.default)((0, _htmlOutWrite.default)`${_compiler.types.stringLiteral(node.value)}`, node)
+  );
+}

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

@@ -0,0 +1,20 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+var _he = require("he");
+
+var _vdomOutWrite = _interopRequireDefault(require("../util/vdom-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+
+function _default(path) {
+  const { node } = path;
+
+  path.replaceWith(
+    (0, _withPreviousLocation.default)(
+      (0, _vdomOutWrite.default)(
+        "t",
+        _compiler.types.stringLiteral((0, _he.decode)(node.value)),
+        path.hub.file._componentInstanceIdentifier
+      ),
+      node
+    )
+  );
+}