@marko/compiler/dist/index.js

Marko template to JS compiler.

"use strict";exports.__esModule = true;exports._clearDefaults = _clearDefaults;exports.compile = compile;exports.compileFile = compileFile;exports.compileFileSync = compileFileSync;exports.compileSync = compileSync;exports.configure = configure;exports.getRuntimeEntryFiles = getRuntimeEntryFiles;exports.taglib = exports.globalConfig = void 0;var _babelUtils = require("@marko/compiler/babel-utils");
var _babel = require("@marko/compiler/internal/babel");exports.types = _babel.types;







var _modules = _interopRequireDefault(require("@marko/compiler/modules"));
var _path = _interopRequireDefault(require("path"));

var _babelPlugin = _interopRequireDefault(require("./babel-plugin"));
var _config = _interopRequireDefault(require("./config"));
var taglib = _interopRequireWildcard(require("./taglib"));exports.taglib = taglib;
var _buildCodeFrame = require("./util/build-code-frame");
var _mergeErrors = _interopRequireDefault(require("./util/merge-errors"));
var _shouldOptimize = _interopRequireDefault(require("./util/should-optimize"));
var _tryLoadTranslator = _interopRequireDefault(require("./util/try-load-translator"));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);}function _interopRequireDefault(e) {return e && e.__esModule ? e : { default: e };}


let globalConfig = exports.globalConfig = { ..._config.default };
function configure(newConfig) {
  exports.globalConfig = globalConfig = { ..._config.default, ...newConfig };
}

async function compile(src, filename, config) {
  const markoConfig = loadMarkoConfig(config);
  const babelConfig = await loadBabelConfig(filename, markoConfig);
  const babelResult = await (0, _babel.transformAsync)(src, babelConfig);
  return buildResult(src, filename, markoConfig.errorRecovery, babelResult);
}

function compileSync(src, filename, config) {
  const markoConfig = loadMarkoConfig(config);
  const babelConfig = loadBabelConfigSync(filename, markoConfig);
  const babelResult = (0, _babel.transformSync)(src, babelConfig);
  return buildResult(src, filename, markoConfig.errorRecovery, babelResult);
}

async function compileFile(filename, config) {
  return new Promise((resolve, reject) => {
    getFs(config).readFile(filename, "utf-8", (err, src) => {
      if (err) {
        return reject(err);
      }

      return resolve(compile(src, filename, config));
    });
  });
}

function compileFileSync(filename, config) {
  const src = getFs(config).readFileSync(filename, "utf-8");
  return compileSync(src, filename, config);
}

function getRuntimeEntryFiles(output, requestedTranslator) {
  const translator = (0, _tryLoadTranslator.default)(requestedTranslator);
  if (translator && translator.getRuntimeEntryFiles) {
    return translator.getRuntimeEntryFiles(output, (0, _shouldOptimize.default)());
  }

  return [];
}

function loadMarkoConfig(config) {
  const markoConfig = { ...globalConfig, ...config };

  if (markoConfig.stripTypes === undefined) {
    markoConfig.stripTypes = isTranslatedOutput(markoConfig.output);
  }

  return markoConfig;
}

async function loadBabelConfig(filename, config) {
  const baseBabelConfig = getBaseBabelConfig(filename, config);
  return isTranslatedOutput(config.output) ?
  (await (0, _babel.loadPartialConfigAsync)(baseBabelConfig)).options :
  baseBabelConfig;
}

function loadBabelConfigSync(filename, config) {
  const baseBabelConfig = getBaseBabelConfig(filename, config);
  return isTranslatedOutput(config.output) ?
  (0, _babel.loadPartialConfig)(baseBabelConfig).options :
  baseBabelConfig;
}

function getBaseBabelConfig(filename, { babelConfig, ...markoConfig }) {
  const isTranslated = isTranslatedOutput(markoConfig.output);
  const requiredPlugins = [[_babelPlugin.default, markoConfig]];
  const baseBabelConfig = {
    filenameRelative: filename ?
    _path.default.relative(_modules.default.cwd, filename) :
    undefined,
    sourceRoot: filename ? _path.default.dirname(filename) : undefined,
    sourceFileName: filename ? _path.default.basename(filename) : undefined,
    configFile: isTranslated,
    babelrc: isTranslated,
    ...babelConfig,
    filename,
    sourceType: "module",
    sourceMaps: markoConfig.sourceMaps,
    code: markoConfig.code,
    ast: markoConfig.ast,
    plugins:
    babelConfig && babelConfig.plugins ?
    requiredPlugins.concat(babelConfig.plugins) :
    requiredPlugins
  };

  if (isTranslated) {
    if (markoConfig.modules === "cjs") {
      baseBabelConfig.plugins.push([
      _babel.pluginTransformModulesCommonjs,
      { loose: true }]
      );
    }
  }

  return baseBabelConfig;
}

function buildResult(src, filename, errorRecovery, babelResult) {
  const {
    ast,
    map,
    code,
    metadata: { marko: meta }
  } = babelResult;

  if (!errorRecovery) {
    const errors = [];

    for (const diag of meta.diagnostics) {
      if (diag.type === _babelUtils.DiagnosticType.Error) {
        errors.push((0, _buildCodeFrame.buildCodeFrameError)(filename, src, diag.loc, diag.label));
      }
    }

    (0, _mergeErrors.default)(errors);
  }

  return { ast, map, code, meta };
}

function _clearDefaults() {
  globalConfig.cache.clear();
}

function getFs(config) {
  return config.fileSystem || globalConfig.fileSystem;
}

function isTranslatedOutput(output) {
  return output !== "source" && output !== "migrate";
}