@marko/compiler/dist/babel-types/types/patch.js

Marko template to JS compiler.

"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
var babelTypes = _interopRequireWildcard(require("@babel/types"));
var definitionUtils = _interopRequireWildcard(require("@babel/types/lib/definitions/utils"));
var generatedValidators = _interopRequireWildcard(require("@babel/types/lib/validators/generated"));
var referencedValidators = _interopRequireWildcard(require("@babel/types/lib/validators/isReferenced"));
var _validate = _interopRequireDefault(require("@babel/types/lib/validators/validate"));

var _definitions = _interopRequireWildcard(require("./definitions"));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;} /* eslint-disable no-import-assign */

const {
  TYPES,
  VISITOR_KEYS,
  FLIPPED_ALIAS_KEYS,
  DEPRECATED_KEYS,
  is,
  getBindingIdentifiers
} = babelTypes;

getBindingIdentifiers.keys.Program = ["params"];
getBindingIdentifiers.keys.MarkoTag = ["var"];
getBindingIdentifiers.keys.MarkoTagBody = ["params"];

_definitions.MARKO_TYPES.forEach((typeName) => {
  definitionUtils.default(typeName, _definitions.default[typeName]);
});

babelTypes.NODE_FIELDS.Program.params =
babelTypes.NODE_FIELDS.MarkoTagBody.params;

for (const type of [
...Object.keys(VISITOR_KEYS),
...Object.keys(FLIPPED_ALIAS_KEYS),
...Object.keys(DEPRECATED_KEYS)])
{
  if (!TYPES.includes(type)) TYPES.push(type);
}

_definitions.MARKO_TYPES.forEach((typeName) => {
  const lowerName = typeName[0].toLowerCase() + typeName.slice(1);
  const checkKey = `is${typeName}`;
  const assertKey = `assert${typeName}`;
  babelTypes[checkKey] = (node, opts) => is(typeName, node, opts);
  babelTypes[assertKey] = (node, opts) => assert(typeName, node, opts);
  babelTypes[typeName] = babelTypes[lowerName] = function () {
    return builder(typeName, arguments);
  };
});

_definitions.MARKO_ALIAS_TYPES.forEach((aliasName) => {
  const checkKey = `is${aliasName}`;
  const originalCheck = generatedValidators[checkKey];
  generatedValidators[checkKey] = (node, opts) =>
  is(aliasName, node, opts) || originalCheck(node, opts);
});

const originalIsReferenced = referencedValidators.default;
referencedValidators.default = (node, parent, grandparent) => {
  switch (parent.type) {
    case "MarkoTag":
      return parent.var !== node;
    case "MarkoTagBody":
      return false;
    default:
      return originalIsReferenced(node, parent, grandparent);
  }
};

for (const { types, set } of definitionUtils.allExpandedTypes || []) {
  for (const type of types) {
    const aliases = FLIPPED_ALIAS_KEYS[type];
    if (aliases) {
      aliases.forEach(set.add, set);
    } else {
      set.add(type);
    }
  }
}

function assert(typeName, node, opts) {
  if (!is(typeName, node, opts)) {
    throw new Error(
      `Expected type "${typeName}" with option ${JSON.stringify(
        opts
      )}, but instead got "${node.type}".`
    );
  }
}

function builder(type, args) {
  const definition = _definitions.default[type];
  const keys = definition.builder;
  const countArgs = args.length;
  if (countArgs > keys.length) {
    throw new Error(
      `${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`
    );
  }

  const node = { type };

  for (let i = 0; i < keys.length; ++i) {
    const key = keys[i];
    const field = definition.fields[key];

    let arg;
    if (i < countArgs) arg = args[i];
    if (arg === undefined) {
      arg = Array.isArray(field.default) ? [] : field.default;
    }

    node[key] = arg;
  }

  // (assume all enumerable properties are own)

  for (const key in node) {
    (0, _validate.default)(node, key, node[key]);
  }

  return node;
}