bundlib/dist/bundlib.cjs.js

'use strict';

var builtinModules = require('builtin-modules');
var readPkg = require('read-pkg');
var path = require('path');
var babel = require('rollup-plugin-babel');
var buble = require('rollup-plugin-buble');
var commonjs = require('rollup-plugin-commonjs');
var exportEquals = require('rollup-plugin-export-equals');
var json = require('rollup-plugin-json');
var nodeResolve = require('rollup-plugin-node-resolve');
var rollupPluginTerser = require('rollup-plugin-terser');
var ts2 = require('rollup-plugin-typescript2');
var events = require('events');
var rollup = require('rollup');

var resolvePath = function (filename, cwd) { return path.resolve(cwd, filename); };

function log(pattern) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];

  // tslint:disable-next-line: no-console
  console.log.apply(console, [ pattern ].concat( args ));
}
function logFilename(filename, cwd, pattern) {
  log(pattern, path.relative(cwd, filename));
}

function error(msg) {
  return new TypeError(msg);
}
function invalidPkgField(fieldName) {
  return error(("Invalid package.json " + fieldName + " field."));
}
function invalidOption(optionName) {
  return error(("Invalid " + optionName + " options."));
}

function isNull(value) {
  return value == null;
}
function isObject(value) {
  return typeof value === "object" && !!value;
}
function isString(value) {
  return typeof value === "string";
}
function isBool(value) {
  return value === true || value === false;
}
var isArray = Array.isArray;

function isBrowserFormat(value) {
  return !!value && (value === "iife" || value === "amd" || value === "umd");
}

function isValidMin(value) {
  return !!value && (value === "main" || value === "module" || value === "browser");
}
function isValidMinOption(value) {
  return isBool(value) || isValidMin(value) || isArray(value) && value.every(function (item) { return isValidMin(item); });
}

function _await(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var analizePkg = _async(function (cwd, pkg) {
  return _await(pkg || readPkg({
    cwd: cwd
  }), function (resolvedPkg) {
    var obj;

    var pkgName = resolvedPkg.name;
    var cjsModuleFile = resolvedPkg.main;
    var esModuleFile = resolvedPkg.module;
    var browserFile = resolvedPkg.browser;
    var pkgTypes = resolvedPkg.types;
    var typings = resolvedPkg.typings;
    var runtimeDependencies = resolvedPkg.dependencies;
    var peerDependencies = resolvedPkg.peerDependencies;
    var bundledDependencies = resolvedPkg.bundledDependencies;
    var bundleDependencies = resolvedPkg.bundleDependencies;
    var bundlibOptions = resolvedPkg.bundlib;

    if (browserFile && !isString(browserFile)) {
      throw invalidPkgField("browser");
    }

    if (!isNull(bundlibOptions) && (!isObject(bundlibOptions) || isArray(bundlibOptions))) {
      throw invalidPkgField("bundlib");
    }

    var ref = bundlibOptions || {};
    var pkgInput = ref.input;
    var sourcemapFlag = ref.sourcemap;
    var esModuleFlag = ref.esModule;
    var interopFlag = ref.interop;
    var extendFlag = ref.extend;
    var equalsFlag = ref.equals;
    var pkgBrowserFormat = ref.browser;
    var browserName = ref.name;
    var amdId = ref.id;
    var browserGlobals = ref.globals;
    var iife = ref.iife;
    var amd = ref.amd;
    var umd = ref.umd;
    var min = ref.min;

    if (!isNull(pkgInput) && !isString(pkgInput)) {
      throw invalidOption("input");
    }

    if (!isNull(pkgBrowserFormat) && !isBrowserFormat(pkgBrowserFormat)) {
      throw invalidOption("browser");
    }

    if (!isNull(browserName) && !isString(browserName)) {
      throw invalidOption("name");
    }

    if (!isNull(amdId) && !isString(amdId)) {
      throw invalidOption("id");
    }

    if (!isNull(browserGlobals) && !isObject(browserGlobals)) {
      throw invalidOption("globals");
    }

    if (!isNull(min) && !isValidMinOption(min)) {
      throw invalidOption("min");
    } // compatible with version <0.3


    if (iife && amd || iife && umd || amd && umd) {
      throw error("multiple browser builds are no longer supported in bundlib >= 0.3.");
    }

    if (iife || amd || umd) {
      // warn about deprecated options
      log("options iife, amd & umd are deprecated in version >= 0.3");
    }

    var deprecatedBrowserFormat = iife ? "iife" : amd ? "amd" : null; // get format from deprecated options if no format specified

    var browserFormat = pkgBrowserFormat || deprecatedBrowserFormat || "umd"; //

    var input = resolvePath(pkgInput || "src/index.ts", cwd);
    var typesPath = pkgTypes || typings;
    var output = {
      main: cjsModuleFile ? resolvePath(cjsModuleFile, cwd) : null,
      module: esModuleFile ? resolvePath(esModuleFile, cwd) : null,
      browser: browserFile ? resolvePath(browserFile, cwd) : null,
      types: typesPath ? resolvePath(typesPath, cwd) : null
    };
    var dependencies = {
      builtin: builtinModules,
      runtime: runtimeDependencies ? Object.keys(runtimeDependencies) : [],
      peer: peerDependencies ? Object.keys(peerDependencies) : [],
      bundled: bundledDependencies || bundleDependencies || []
    };
    var buildName = browserName || pkgName || null;
    var minify = !min ? {} : min === true ? {
      main: true,
      module: true,
      browser: true
    } : isArray(min) ? min.reduce(function (result, value) {
      result[value] = true;
      return result;
    }, {}) : ( obj = {}, obj[min] = true, obj );
    var globals = !browserGlobals ? null : isArray(browserGlobals) ? browserGlobals.reduce(function (result, value) {
      if (isString(value)) {
        result[value] = value;
      }

      return result;
    }, {}) : browserGlobals;
    var browser = {
      format: browserFormat,
      name: buildName,
      id: amdId || null,
      globals: globals
    };
    var options = {
      sourcemap: sourcemapFlag !== false,
      esModule: !!esModuleFlag,
      interop: !!interopFlag,
      extend: !!extendFlag,
      equals: !!equalsFlag
    };
    return {
      cwd: cwd,
      pkg: resolvedPkg,
      dependencies: dependencies,
      input: input,
      output: output,
      minify: minify,
      browser: browser,
      options: options
    };
  }, pkg);
});

function _async(f) {
  return function () {
    var arguments$1 = arguments;

    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments$1[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var BUILDING = "BUILDING";
var BUILT = "BUILT";
var WRITING = "WRITING";
var WRITTEN = "WRITTEN";
var ERROR = "ERROR";

function createOutput(format, file, sourcemap, esModule, interop, extra) {
  var output = Object.assign({}, {file: file,
    format: format,
    sourcemap: sourcemap,
    esModule: esModule,
    interop: interop},
    extra);
  return output;
}
function createConfig(input, output, external, plugins, extra) {
  var config = Object.assign({}, {input: input,
    output: output,
    external: external,
    plugins: plugins.filter(Boolean)},
    extra);
  return config;
}
function createModuleConfig(input, format, file, sourcemap, esModule, interop, external, plugins) {
  var output = createOutput(format, file, sourcemap, esModule, interop);
  return createConfig(input, output, external, plugins);
}
function createBrowserConfig(input, format, file, sourcemap, esModule, interop, plugins, name, extend, globals, id) {
  var output = createOutput(format, file, sourcemap, esModule, interop, {
    name: name,
    extend: extend,
    globals: globals
  });

  if (id && (format === "umd" || format === "amd")) {
    output.amd = {
      id: id
    };
  }

  var external = globals ? Object.keys(globals) : [];
  return createConfig(input, output, external, plugins);
}

function renameMin(filename) {
  var ref = path.parse(filename);
  var dir = ref.dir;
  var name = ref.name;
  var ext = ref.ext;
  return path.join(dir, name + ".min" + ext);
}

var pkgToConfigs = function (ref, dev) {
  var cwd = ref.cwd;
  var apiInput = ref.input;
  var output = ref.output;
  var minify = ref.minify;
  var dependencies = ref.dependencies;
  var browserOptions = ref.browser;
  var options = ref.options;

  var apiFolder = path.dirname(apiInput);
  var cjsOutputFile = output.main;
  var esOutputFile = output.module;
  var browserOutputFile = output.browser;
  var typesOutputFile = output.types;
  var builtinDependencies = dependencies.builtin;
  var runtimeDependencies = dependencies.runtime;
  var peerDependencies = dependencies.peer;
  var sourcemap = options.sourcemap;
  var esModule = options.esModule;
  var interop = options.interop;
  var extend = options.extend;
  var equals = options.equals;
  var browserFormat = browserOptions.format;
  var pkgName = browserOptions.name;
  var id = browserOptions.id;
  var globals = browserOptions.globals;
  var prod = !dev;
  var configs = [];
  var typesOutputDir = typesOutputFile;

  if (typesOutputDir && path.extname(typesOutputDir) === ".ts") {
    typesOutputDir = path.dirname(typesOutputDir);
  }

  var modulePlugins = function (mini) {
    var declarationDir = !configs.length && typesOutputDir;
    var srcFolderContent = resolvePath("**/*.ts", apiFolder);
    return [ts2({
      include: srcFolderContent,
      cacheRoot: resolvePath(".cache/rpt2", cwd),
      useTsconfigDeclarationDir: true,
      tsconfigDefaults: {
        include: [srcFolderContent],
        exclude: []
      },
      tsconfigOverride: {
        compilerOptions: {
          target: "esnext",
          module: "esnext",
          moduleResolution: "node",
          sourceMap: sourcemap,
          declaration: !!declarationDir,
          declarationDir: declarationDir || "",
          emitDeclarationOnly: false
        }
      }
    }), json(), declarationDir && equals && exportEquals({
      file: resolvePath(path.join(declarationDir, "index.d.ts"), cwd)
    }) || null, babel({
      extensions: [".ts", ".js"],
      exclude: /node_modules/,
      babelrc: false,
      plugins: [require.resolve("babel-plugin-transform-async-to-promises")]
    }), buble({
      exclude: /node_modules/,
      target: {
        node: 0.12
      },
      objectAssign: true
    }), mini && rollupPluginTerser.terser({
      sourcemap: sourcemap,
      toplevel: true,
      module: true
    })];
  };

  var browserPlugins = function (mini) { return [nodeResolve(), commonjs() ].concat( modulePlugins(mini)); };

  var external = builtinDependencies.concat( runtimeDependencies, peerDependencies);

  if (esOutputFile) {
    var config = createModuleConfig(apiInput, "es", esOutputFile, sourcemap, true, false, external, modulePlugins(prod && !minify.module));
    configs.push(config);

    if (minify.module) {
      var configMin = createModuleConfig(apiInput, "es", renameMin(esOutputFile), sourcemap, true, false, external, modulePlugins(true));
      configs.push(configMin);
    }
  }

  if (cjsOutputFile) {
    var config$1 = createModuleConfig(apiInput, "cjs", cjsOutputFile, sourcemap, esModule, interop, external, modulePlugins(prod && !minify.main));
    configs.push(config$1);

    if (minify.main) {
      var configMin$1 = createModuleConfig(apiInput, "cjs", renameMin(cjsOutputFile), sourcemap, esModule, interop, external, modulePlugins(true));
      configs.push(configMin$1);
    }
  }

  if (!pkgName && browserOutputFile) {
    throw new Error("name option is required for IIFE and UMD builds");
  }

  if (browserOutputFile) {
    var config$2 = createBrowserConfig(apiInput, browserFormat, browserOutputFile, sourcemap, esModule, interop, browserPlugins(prod && !minify.browser), pkgName, extend, globals || {}, id);
    configs.push(config$2);

    if (minify.browser) {
      var configMin$2 = createBrowserConfig(apiInput, browserFormat, renameMin(browserOutputFile), sourcemap, esModule, interop, browserPlugins(true), pkgName, extend, globals || {}, id);
      configs.push(configMin$2);
    }
  }

  return configs;
};

function _async$1(f) {
  return function () {
    var arguments$1 = arguments;

    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments$1[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

function createNext(arr, callback) {
  var index = 0;

  var next = _async$1(function (err) {
    if (!(index in arr)) {
      return;
    }

    var currentIndex = index++;
    var item = arr[currentIndex];
    callback(item, next, currentIndex);
  });

  return next;
}

function oneByOne(arr, callback) {
  var next = createNext(arr, callback);
  next();
}

function _async$2(f) {
  return function () {
    var arguments$1 = arguments;

    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments$1[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var build = _async$2(function (configs) {
  var result = new events.EventEmitter();
  setImmediate(function () {
    result.emit(BUILDING);
    oneByOne(configs, _async$2(function (config, next, index) {
      var output = config.output;
      var filename = output.file;
      result.emit(WRITING, filename);
      return _await$1(rollup.rollup(config), function (buildResult) {
        return _await$1(buildResult.write(output), function () {
          result.emit(WRITTEN, filename);
          next();

          if (index + 1 >= configs.length) {
            result.emit(BUILT);
          }
        });
      });
    }));
  });
  return result;
});

function _await$1(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var ERR = function (result, ref) {
  var error = ref.error;

  result.emit(ERROR, error);
};

var map = {
  START: function START(result) {
    result.emit(BUILDING);
  },

  END: function END(result) {
    result.emit(BUILT);
  },

  BUNDLE_START: function BUNDLE_START(result, ref) {
    var output = ref.output;

    for (var filename of output) {
      result.emit(WRITING, filename);
    }
  },

  BUNDLE_END: function BUNDLE_END(result, ref) {
    var output = ref.output;

    for (var filename of output) {
      result.emit(WRITTEN, filename);
    }
  },

  ERROR: ERR,
  FATAL: ERR
};

var watch = function (configs) {
  var watcher = rollup.watch(configs);
  var result = new events.EventEmitter();
  watcher.on("event", function (event) {
    var code = event.code;
    var emit = map[code];

    if (emit) {
      emit(result, event);
    }
  });
  return result;
};

var rollItUp = function (configs, watch$1) {
  return watch$1 ? watch(configs) : build(configs);
};

// version has to be hardcoded due to issue #7
// https://github.com/manferlo81/bundlib/issues/7

function _await$2(value, then, direct) {
  if (direct) {
    return then ? then(value) : value;
  }

  if (!value || !value.then) {
    value = Promise.resolve(value);
  }

  return then ? value.then(then) : value;
}

var version = 0.4;

function _async$3(f) {
  return function () {
    var arguments$1 = arguments;

    for (var args = [], i = 0; i < arguments.length; i++) {
      args[i] = arguments$1[i];
    }

    try {
      return Promise.resolve(f.apply(this, args));
    } catch (e) {
      return Promise.reject(e);
    }
  };
}

var bundlib = _async$3(function (cwd, ref) {
  if ( ref === void 0 ) ref = {};
  var dev = ref.dev;
  var watch = ref.watch;
  var silent = ref.silent;

  if (!silent) {
    log("bundlib v%s\r\n", version);
    log("> reading package.json...");
  }

  return _await$2(analizePkg(cwd), function (pkg) {
    var configs = pkgToConfigs(pkg, dev);
    return _await$2(rollItUp(configs, watch), function (buildProcess) {
      if (!silent) {
        buildProcess.on(WRITING, function (filename) {
          logFilename(filename, cwd, "building > %s...");
        });
        buildProcess.on(WRITTEN, function (filename) {
          logFilename(filename, cwd, "built > %s");
        });
        buildProcess.on(ERROR, function (err) {
          log(err);
        });

        if (watch) {
          buildProcess.on(BUILT, function () {
            log("> watching for changes...");
          });
        }
      }

      return buildProcess;
    });
  });
});

exports.analizePkg = analizePkg;
exports.bundlib = bundlib;
exports.pkgToConfigs = pkgToConfigs;
exports.rollItUp = rollItUp;
//# sourceMappingURL=bundlib.cjs.js.map