prepublish-lib/bin/prepublish-lib.js

#!/usr/bin/env node

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var path = require('path');
var async = require('async');
var lodash = require('lodash');
var fileExists = _interopDefault(require('file-exists'));
var meow = _interopDefault(require('meow'));
var chalk = _interopDefault(require('chalk'));
var rollup = require('rollup');
var relink = _interopDefault(require('rollup-plugin-relink'));
var nodeResolve = _interopDefault(require('rollup-plugin-node-resolve'));
var jsonPlugin = _interopDefault(require('rollup-plugin-json'));
var yamlPlugin = _interopDefault(require('rollup-plugin-yaml'));
var replacePlugin = _interopDefault(require('rollup-plugin-replace'));
var buble = _interopDefault(require('rollup-plugin-buble'));
var babel = _interopDefault(require('rollup-plugin-babel'));

function createBubleConfig() {
  return buble()
}

var classicPreset = [ "latest", {
  es2015: {
    modules: false
  }
}];

var modernPreset = [ "babel-preset-env", {
  targets: {
    node: 6,
    browsers: [
      "Safari 10",
      "iOS 10",
      "Edge 14",
      "Chrome 54",
      "ChromeAndroid 54",
      "Firefox 50",
      "FirefoxAndroid 50"
    ]
  },

  modules: false,
  debug: false,
  useBuiltIns: true
}];

function createHelper(modern, minified, presets, plugins) {
  if ( presets === void 0 ) presets = [];
  if ( plugins === void 0 ) plugins = [];

  if (minified) {
    presets = presets.concat([
      [ "babili", {
        booleans: false,
        infinity: false
      }]
    ]);
  }

  return babel({
    // Don't try to find .babelrc because we want to force this configuration.
    babelrc: false,

    // Allow usage of transform-runtime for referencing to a common library of polyfills
    runtimeHelpers: true,

    // Remove comments - these are often positioned on the wrong positon after transpiling anyway
    comments: false,

    // No need for preserve perfect formatting
    compact: true,

    // Should the output be minified (not printing last semicolons in blocks, printing literal string
    // values instead of escaped ones, stripping () from new when safe)
    minified: minified,

    exclude: "node_modules/**",

    presets: [
      modern ? modernPreset : classicPreset ].concat( presets
    ),

    plugins: [
      // Cherry-picks Lodash modules so you don’t have to.
      // https://www.npmjs.com/package/babel-plugin-lodash
      "lodash",

      // Improve some ES3 edge case to make code parseable by older clients
      // e.g. when using reserved words as keys like "catch"
      "transform-es3-property-literals",
      "transform-es3-member-expression-literals",

      // Using centralized helpers but require generic Polyfills being loaded separately
      // e.g. via Babel-Runtime or via services like polyfill.io.
      // See also: https://github.com/babel/babel/tree/master/packages/babel-plugin-transform-runtime
      [ "transform-runtime", {
        // default
        helpers: true,

        // default
        regenerator: true,

        // changed from default. More efficient to use real polyfills.
        polyfill: false
      }],

      // class { handleClick = () => { } }
      "transform-class-properties",

      // { ...todo, completed: true }
      [ "transform-object-rest-spread", { useBuiltIns: true }],

      // Eliminates unnecessary closures from your JavaScript in the name of performance
      // https://github.com/codemix/babel-plugin-closure-elimination
      "closure-elimination",

      // Strip flow type annotations from your output code.
      "transform-flow-strip-types" ].concat( plugins
    )
  })
}

function createLatestConfig(minified) {
  return {
    classic: createHelper(false, minified),
    modern: createHelper(true, minified)
  }
}

var additionalPresets = [
  "react"
];

var additionalPlugins = [
  // Transform JSX and prefer built-in methods
  [ "transform-react-jsx", { useBuiltIns: true }],

  // Optimization: hoist JSX that never changes out of render()
  "transform-react-constant-elements",

  // Optimization: wrap propTypes into environment checks
  "transform-react-remove-prop-types"
];

function createReactConfig(minified) {
  return {
    classic: createHelper(false, minified, additionalPresets, additionalPlugins),
    modern: createHelper(true, minified, additionalPresets, additionalPlugins)
  }
}

// We try to benefit from native features when possible and offer
// additional builds containing es2015 code for modern clients (Node v6, Chrome 50+, etc.)
// For bundling you have to use a tool which is aware of the additional package entries
// to access the additional exported library files though e.g. via 'main' fields in Webpack v2.
function getTranspilers(mode, ref)
{
  var minified = ref.minified;

  switch (mode)
  {
    case "buble":
      return createBubleConfig(minified)

    case "latest":
      return createLatestConfig(minified)

    case "react":
      return createReactConfig(minified)

  }
}

function getBanner(pkg) {
  var banner = "/*! " + (pkg.name) + " v" + (pkg.version);

  if (pkg.author) {
    if (typeof pkg.author === "object") {
      banner += " by " + (pkg.author.name) + " <" + (pkg.author.email) + ">";
    } else if (typeof pkg.author === "string") {
      banner += " by " + (pkg.author.name);
    }
  }

  banner += " */";

  return banner
}

var CWD = process.cwd();
var PKG = require(path.resolve(CWD, "package.json"));

var cache;



var cli = meow("\n  Usage\n    $ prepublish-lib\n\n  Options\n    --entry-node      Entry file for NodeJS environment [default = auto]\n    --entry-browser   Entry file for Browser environment [default = auto]\n\n    --output-folder   Configure the output folder [default = auto]\n\n    -t, --transpiler  Chose the transpiler/config to use. Either \"react\", \"latest\" or \"buble\". [default = latest]\n    -x, --minified    Enabled minification of output files\n    -m, --sourcemap   Create a source map file during processing\n\n    -v, --verbose     Verbose output mode [default = false]\n    -q, --quiet       Quiet output mode [default = false]\n", {
  default: {
    entryNode: null,
    entryBrowser: null,

    outputFolder: null,

    transpiler: "react",
    minified: false,
    sourcemap: true,

    verbose: false,
    quiet: false
  }
});


var verbose = cli.flags.verbose;
var quiet = cli.flags.quiet;

if (verbose) {
  console.log(cli.flags);
}


/* eslint-disable dot-notation */
var outputFileMatrix = {
  "node-classic-commonjs": PKG["main"] || null,
  "node-classic-esmodule": PKG["module"] || PKG["jsnext:main"] || null,
  "node-modern-commonjs": PKG["main:modern"] || null,
  "node-modern-esmodule": PKG["module:modern"] || null,
  "browser-classic-esmodule": PKG["browser"] || PKG["web"] || PKG["browserify"] || null,
  "browser-modern-esmodule": PKG["browser:modern"] || PKG["web:modern"] || PKG["browserify:modern"] || null
};

var outputFolder = cli.flags.outputFolder;
if (outputFolder) {
  outputFileMatrix["node-classic-commonjs"] = outputFolder + "/node.classic.commonjs.js";
  outputFileMatrix["node-classic-esmodule"] = outputFolder + "/node.classic.esmodule.js";
  outputFileMatrix["node-modern-commonjs"] = outputFolder + "/node.modern.commonjs.js";
  outputFileMatrix["node-modern-esmodule"] = outputFolder + "/node.modern.esmodule.js";
  outputFileMatrix["browser-classic-esmodule"] = outputFolder + "/browser.classic.esmodule.js";
  outputFileMatrix["browser-modern-esmodule"] = outputFolder + "/browser.modern.esmodule.js";
}

// Rollups support these formats: 'amd', 'cjs', 'es', 'iife', 'umd'
var format2Rollup = {
  commonjs: "cjs",
  esmodule: "es"
};

var moduleId = PKG.name;
var moduleName = lodash.camelCase(moduleId);
var banner = getBanner(PKG);
var envs = {};
var formats = [ "esmodule", "commonjs" ];
var transpilers = getTranspilers("react", {
  minified: cli.flags.minified
});

if (cli.flags.entryNode) {
  envs.node = [ cli.flags.entryNode ];
} else {
  envs.node = [ "src/index.js", "module/index.js", "src/server/index.js" ];
}

if (cli.flags.entryBrowser) {
  envs.browser = [ cli.flags.entryBrowser ];
} else {
  envs.browser = [ "src/browser/index.js", "src/client/index.js", "src/browser.js", "src/client.js", "src/web.js" ];
}

async.eachOfSeries(envs, function (envEntries, envId, envCallback) {
  var entry = lookupBest(envEntries);
  if (entry)
  {
    if (!quiet) {
      console.log(("Using entry " + (chalk.blue(entry)) + " for environment " + (chalk.blue(envId))));
    }

    async.eachOfSeries(formats, function (format, formatIndex, formatCallback) {
      async.eachOfSeries(transpilers, function (currentTranspiler, transpilerId, variantCallback) {
        var destFile = outputFileMatrix[(envId + "-" + transpilerId + "-" + format)];
        if (destFile) {
          return bundleTo({ entry: entry, envId: envId, transpilerId: transpilerId, currentTranspiler: currentTranspiler, format: format, destFile: destFile, variantCallback: variantCallback })
        } else {
          return variantCallback(null)
        }
      }, formatCallback);
    }, envCallback);
  }
  else
  {
    envCallback(null);
  }
});

function lookupBest(candidates) {
  var filtered = candidates.filter(fileExists);
  return filtered[0]
}

function bundleTo(ref) {
  var entry = ref.entry;
  var envId = ref.envId;
  var transpilerId = ref.transpilerId;
  var currentTranspiler = ref.currentTranspiler;
  var format = ref.format;
  var destFile = ref.destFile;
  var variantCallback = ref.variantCallback;

  if (!quiet) {
    console.log(((chalk.green(">>> Bundling")) + " " + (chalk.magenta(PKG.name)) + "-" + (chalk.magenta(PKG.version)) + " as " + (chalk.blue(transpilerId)) + " defined as " + (chalk.blue(format)) + " to " + (chalk.green(destFile)) + "..."));
  }

  var prefix = "process.env.";
  var variables = {};
  variables[(prefix + "NAME")] = JSON.stringify(PKG.name);
  variables[(prefix + "VERSION")] = JSON.stringify(PKG.version);
  variables[(prefix + "TARGET")] = JSON.stringify(envId);

  var fileRelink = relink({ outputFolder: outputFolder, entry: entry, verbose: verbose });
  rollup.rollup({
    entry: entry,
    cache: cache,
    onwarn: function (msg) { return console.warn(msg); },
    external: function external(dependency)
    {
      if (dependency === entry) {
        return false
      }

      if (fileRelink.isExternal(dependency)) {
        return true
      }

      if (path.isAbsolute(dependency)) {
        var rel = path.relative(CWD, dependency);
        return Boolean(/node_modules/.exec(rel))
      }

      return dependency.charAt(0) !== "."
    },
    plugins:
    [
      nodeResolve({
        extensions: [ ".js", ".jsx", ".ts", ".tsx", ".json" ],
        jsnext: true,
        module: true,
        main: true
      }),
      jsonPlugin,
      yamlPlugin,
      replacePlugin(variables),
      currentTranspiler,
      fileRelink
    ]
  })
    .then(function (bundle) { return bundle.write({
        format: format2Rollup[format],
        moduleId: moduleId,
        moduleName: moduleName,
        banner: banner,
        sourceMap: cli.flags.sourcemap,
        dest: destFile
      }); }
    )
    .then(function () { return variantCallback(null); }
    )
    .catch(function (err) {
      console.error(err);
      variantCallback(("Error during bundling " + format + ": " + err));
    });
}
//# sourceMappingURL=prepublish-lib.js.map