prepack/lib/prepack-node.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  prepackStdin: true,
  prepackFile: true,
  prepackFileSync: true
};
exports.prepackStdin = prepackStdin;
exports.prepackFile = prepackFile;
exports.prepackFileSync = prepackFileSync;

var _options = require("./options");

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

var _prepackStandalone = require("./prepack-standalone.js");

var _DebugChannel = require("./debugger/server/channel/DebugChannel.js");

var _FileIOWrapper = require("./debugger/common/channel/FileIOWrapper.js");

var _statistics = require("./serializer/statistics.js");

var _fs = _interopRequireDefault(require("fs"));

var _prepackStandalone2 = require("./prepack-standalone");

Object.keys(_prepackStandalone2).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _prepackStandalone2[key];
    }
  });
});

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

/**
 * Copyright (c) 2017-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 */

/*
 Prepack API functions that require Node as the execution environment for Prepack.
 */
function createStatistics(options) {
  let gc = global.gc; // eslint-disable-line no-undef

  return options.profile !== undefined ? new _statistics.SerializerStatistics(() => Date.now(), () => {
    if (gc) gc();
    return process.memoryUsage().heapUsed;
  }, !!gc) : new _statistics.SerializerStatistics();
}

function prepackStdin(options = _options.defaultOptions, processSerializedCode, printDiagnostics) {
  let sourceMapFilename = options.inputSourceMapFilename || "";
  process.stdin.setEncoding("utf8");
  process.stdin.resume();
  process.stdin.on("data", function (code) {
    _fs.default.readFile(sourceMapFilename, "utf8", function (mapErr, sourceMap = "") {
      if (mapErr) {
        //if no sourcemap was provided we silently ignore
        if (sourceMapFilename !== "") console.warn(`No sourcemap found at ${sourceMapFilename}.`);
      }

      let filename = "no-filename-specified";
      let serialized;
      let success;

      try {
        serialized = (0, _prepackStandalone.prepackSources)([{
          filePath: filename,
          fileContents: code,
          sourceMapContents: sourceMap
        }], options, undefined, createStatistics(options));
        processSerializedCode(serialized);
        success = printDiagnostics(false);
      } catch (err) {
        printDiagnostics(err instanceof _errors.FatalError);

        if (!(err instanceof _errors.FatalError)) {
          // if it is not a FatalError, it means prepack failed, and we should display the Prepack stack trace.
          console.error(err.stack);
        }

        success = false;
      }

      if (!success) process.exit(1);
    });
  });
}

function prepackFile(filename, options = _options.defaultOptions, callback, fileErrorHandler) {
  let sourceMapFilename = options.inputSourceMapFilename !== undefined ? options.inputSourceMapFilename : filename + ".map";

  _fs.default.readFile(filename, "utf8", function (fileErr, code) {
    if (fileErr) {
      if (fileErrorHandler) fileErrorHandler(fileErr);
      return;
    }

    _fs.default.readFile(sourceMapFilename, "utf8", function (mapErr, _sourceMap) {
      let sourceMap = _sourceMap;

      if (mapErr) {
        console.warn(`No sourcemap found at ${sourceMapFilename}.`);
        sourceMap = "";
      }

      let serialized;

      try {
        serialized = (0, _prepackStandalone.prepackSources)([{
          filePath: filename,
          fileContents: code,
          sourceMapContents: sourceMap
        }], options, undefined, createStatistics(options));
      } catch (err) {
        callback(err, null);
        return;
      }

      callback(null, serialized);
    });
  });
}

function prepackFileSync(filenames, options = _options.defaultOptions) {
  const sourceFiles = filenames.map(filename => {
    let code = _fs.default.readFileSync(filename, "utf8");

    let sourceMap = "";
    let sourceMapFilename = options.inputSourceMapFilename !== undefined ? options.inputSourceMapFilename : filename + ".map";

    try {
      sourceMap = _fs.default.readFileSync(sourceMapFilename, "utf8");
    } catch (_e) {
      if (options.inputSourceMapFilename !== undefined) console.warn(`No sourcemap found at ${sourceMapFilename}.`);
    }

    return {
      filePath: filename,
      fileContents: code,
      sourceMapContents: sourceMap
    };
  }); // The existence of debug[In/Out]FilePath represents the desire to use the debugger.

  if (options.debugInFilePath !== undefined && options.debugOutFilePath !== undefined) {
    if (options.debuggerConfigArgs === undefined) options.debuggerConfigArgs = {};
    let ioWrapper = new _FileIOWrapper.FileIOWrapper(false, options.debugInFilePath, options.debugOutFilePath);
    options.debuggerConfigArgs.debugChannel = new _DebugChannel.DebugChannel(ioWrapper);
    options.debuggerConfigArgs.sourcemaps = sourceFiles;
  }

  return (0, _prepackStandalone.prepackSources)(sourceFiles, options, options.debuggerConfigArgs, createStatistics(options));
}
//# sourceMappingURL=prepack-node.js.map