preconstruct/lib/build/rollup.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.toUnsafeRollupConfig = toUnsafeRollupConfig;
exports.getRollupConfig = exports.rollup = void 0;

var _path = _interopRequireDefault(require("path"));

var _builtinModules = _interopRequireDefault(require("builtin-modules"));

var _package = require("../package");

var _entrypoint = require("../entrypoint");

var _rollup2 = require("rollup");

var _errors = require("../errors");

var _messages = require("../messages");

var _rewriteCjsRuntimeHelpers = _interopRequireDefault(require("../rollup-plugins/rewrite-cjs-runtime-helpers"));

var _flowAndProdDevEntry = _interopRequireDefault(require("../rollup-plugins/flow-and-prod-dev-entry"));

var _typescriptDeclarations = _interopRequireDefault(require("../rollup-plugins/typescript-declarations"));

var _rollupPluginJson = _interopRequireDefault(require("rollup-plugin-json"));

var _babel = _interopRequireDefault(require("../rollup-plugins/babel"));

var _terser = _interopRequireDefault(require("../rollup-plugins/terser"));

var _prompt = require("../prompt");

var _utils = require("../utils");

var _constants = require("../constants");

var _installPackages = _interopRequireDefault(require("install-packages"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const resolve = require("rollup-plugin-node-resolve");

const alias = require("rollup-plugin-alias");

const cjs = require("rollup-plugin-commonjs");

const replace = require("rollup-plugin-replace");

const resolveFrom = require("resolve-from");

const chalk = require("chalk");

// this makes sure nested imports of external packages are external
const makeExternalPredicate = externalArr => {
  if (externalArr.length === 0) {
    return () => false;
  }

  const pattern = new RegExp(`^(${externalArr.join("|")})($|/)`);
  return id => pattern.test(id);
};

let rollup = _rollup2.rollup;
exports.rollup = rollup;

function toUnsafeRollupConfig(config) {
  return config;
}

let getRollupConfig = (pkg, entrypoints, aliases, type) => {
  let external = [];

  if (pkg.peerDependencies) {
    external.push(...Object.keys(pkg.peerDependencies));
  }

  if (pkg.dependencies && type !== "umd") {
    external.push(...Object.keys(pkg.dependencies));
  }

  if (type === "node-dev" || type === "node-prod") {
    external.push(..._builtinModules.default);
  }

  let rollupAliases = {};
  Object.keys(aliases).forEach(key => {
    try {
      rollupAliases[key] = resolveFrom(pkg.directory, aliases[key]);
    } catch (err) {
      if (err.code !== "MODULE_NOT_FOUND") {
        throw err;
      }
    }
  });
  let input = {};
  entrypoints.forEach(entrypoint => {
    input[_path.default.relative(pkg.directory, _path.default.join(entrypoint.directory, "dist", (0, _utils.getNameForDist)(pkg.name)))] = entrypoint.strict().source;
  });
  const config = {
    input,
    external: makeExternalPredicate(external),
    onwarn: warning => {
      switch (warning.code) {
        case "UNUSED_EXTERNAL_IMPORT":
          {
            break;
          }

        case "UNRESOLVED_IMPORT":
          {
            if (/^@babel\/runtime\/helpers\//.test(warning.source)) {
              throw (async () => {
                let shouldInstallBabelRuntime = await _messages.confirms.shouldInstallBabelRuntime(pkg);

                if (shouldInstallBabelRuntime) {
                  await (0, _prompt.limit)(() => (0, _installPackages.default)({
                    packages: ["@babel/runtime"],
                    cwd: pkg.directory,
                    installPeers: false,
                    packageManager: pkg.project.isBolt ? "bolt" : undefined
                  }));
                  await pkg.refresh();
                } else {
                  throw new _errors.FatalError(`@babel/runtime should be in dependencies of ${pkg.name}`, pkg.name);
                }
              })();
            }

            if (!warning.source.startsWith(".")) {
              throw new _errors.FatalError(`"${warning.source}" is imported by "${_path.default.relative(pkg.directory, warning.importer)}" but it is not specified in dependencies or peerDependencies`, pkg.name);
            }
          }

        default:
          {
            throw new _errors.FatalError(`There was an error compiling ${pkg.name}: ${chalk.red(warning.toString())}`, pkg.name);
          }
      }
    },
    plugins: [type === "node-prod" && (0, _flowAndProdDevEntry.default)(pkg), type === "node-prod" && (0, _typescriptDeclarations.default)(pkg), (0, _babel.default)({
      cwd: pkg.project.directory,
      plugins: [[require.resolve("@babel/plugin-transform-runtime"), {
        useESModules: true
      }]],
      extensions: _constants.EXTENSIONS
    }), type === "umd" && cjs({
      include: ["**/node_modules/**", "node_modules/**"]
    }), (type === "browser" || type === "umd") && replace({
      "typeof document": JSON.stringify("object"),
      "typeof window": JSON.stringify("object")
    }), (0, _rewriteCjsRuntimeHelpers.default)(), (0, _rollupPluginJson.default)({
      namedExports: false
    }), type === "umd" && alias(rollupAliases), resolve({
      extensions: _constants.EXTENSIONS,
      customResolveOptions: {
        moduleDirectory: type === "umd" ? "node_modules" : []
      }
    }), (type === "umd" || type === "node-prod") && replace({
      "process.env.NODE_ENV": '"production"'
    }), type === "umd" && (0, _terser.default)(), type === "node-prod" && (0, _terser.default)({
      mangle: false,
      output: {
        beautify: true,
        indent_level: 2
      }
    })].filter(Boolean)
  };
  return config;
};

exports.getRollupConfig = getRollupConfig;