@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 _interopRequireWildcard(e, t) {if ("function" == typeof WeakMap) var r = new WeakMap(),n = new WeakMap();return (_interopRequireWildcard = function (e, t) {if (!t && e && e.__esModule) return e;var o,i,f = { __proto__: null, default: e };if (null === e || "object" != typeof e && "function" != typeof e) return f;if (o = t ? n : r) {if (o.has(e)) return o.get(e);o.set(e, f);}for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]);return f;})(e, t);} /* 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;
}