react-static/lib/utils/binHelper.js

A progressive static site generator for React

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var path = require('path');

var PrettyError = require('pretty-error');

var resolveFrom = require('resolve-from');

var Module = require('module'); //


var _require = require('./'),
    escapeRegExp = _require.escapeRegExp; // Allow as much stack tracing as possible


Error.stackTraceLimit = 10000;
var ignorePath;
var originalRequire = Module.prototype.require; // Check and see if we are running react-static from the repo

var needsWorkspaceCheck = __dirname.includes('/react-static/packages/react-static/'); // Recursively checks a module to see if it originated from a
// react-static package in the repo


var inRepo = function inRepo(mod) {
  if (!mod.filename.includes('react-static/packages/react-static/') && mod.filename.includes('react-static/packages/')) {
    return true;
  }

  if (mod.parent) {
    return inRepo(mod.parent);
  }

  return false;
}; // The following ensures that there is always only a single (and same)
// copy of React in an app at any given moment.
// eslint-disable-next-line


Module.prototype.require = function (modulePath) {
  // If we are running in the repo, we need to make sure
  // module resolutions coming from other react-static packages
  // are first attempted from the
  var isInWorkspace = needsWorkspaceCheck && inRepo(this); // Only redirect resolutions to non-relative and non-absolute modules

  if (!modulePath.startsWith('.') && !modulePath.startsWith('/')) {
    if ( // If module is in the repo try and redirect
    isInWorkspace || // Always try and redirect react and react-dom resolutions
    ['react', 'react-dom'].some(function (d) {
      return modulePath.includes(d);
    })) {
      try {
        modulePath = resolveFrom(path.resolve(process.cwd(), 'node_modules'), modulePath);
      } catch (err) {//
      }
    }
  }

  return originalRequire.call(this, modulePath);
};

require('@babel/register')({
  babelrc: false,
  presets: [[path.resolve(__dirname, '../../babel-preset.js'), {
    node: true
  }]],
  ignore: [function babelIgnore(filename) {
    // true if should ignore
    return new RegExp(escapeRegExp("".concat(path.sep, "node_modules").concat(path.sep))).test(filename) || ignorePath && ignorePath.test(filename);
  }]
}); // necessary at any entry point of the cli to ensure that Babel-register
// does not attempt to transform non JavaScript files.


var ignoredExtensions = ['css', 'scss', 'styl', 'less', 'png', 'gif', 'jpg', 'jpeg', 'svg', 'woff', 'woff2', 'ttf', 'eot', 'otf', 'mp4', 'webm', 'ogg', 'mp3', 'wav', 'md', 'yaml'];
ignoredExtensions.forEach(function (ext) {
  require.extensions[".".concat(ext)] = function () {};
});
var originalConsoleError = console.error;

console.error = function () {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  if (args.length === 0) {
    return undefined;
  }

  var err = args[0],
      rest = args.slice(1);

  if (err instanceof Error) {
    var _console;

    (_console = console).log.apply(_console, [new PrettyError().render(err)].concat((0, _toConsumableArray2["default"])(rest)));

    return;
  }

  return originalConsoleError.apply(void 0, [err].concat((0, _toConsumableArray2["default"])(rest)));
}; // Be sure to log useful information about unhandled exceptions. This should seriously
// be a default: https://github.com/nodejs/node/issues/9523#issuecomment-259303079


process.on('unhandledRejection', function (r) {
  console.error(r);
});
module.exports = {
  setIgnorePath: function setIgnorePath(path) {
    ignorePath = path ? new RegExp(escapeRegExp(path)) : undefined;
  }
};
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utils/binHelper.js"],"names":["path","require","PrettyError","resolveFrom","Module","escapeRegExp","Error","stackTraceLimit","ignorePath","originalRequire","prototype","needsWorkspaceCheck","__dirname","includes","inRepo","mod","filename","parent","modulePath","isInWorkspace","startsWith","some","d","resolve","process","cwd","err","call","babelrc","presets","node","ignore","babelIgnore","RegExp","sep","test","ignoredExtensions","forEach","ext","extensions","originalConsoleError","console","error","args","length","undefined","rest","log","render","on","r","module","exports","setIgnorePath"],"mappings":"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","sourcesContent":["const path = require('path')\nconst PrettyError = require('pretty-error')\nconst resolveFrom = require('resolve-from')\nconst Module = require('module')\n//\nconst { escapeRegExp } = require('./')\n\n// Allow as much stack tracing as possible\nError.stackTraceLimit = 10000\n\nlet ignorePath\n\nconst originalRequire = Module.prototype.require\n\n// Check and see if we are running react-static from the repo\nconst needsWorkspaceCheck = __dirname.includes(\n  '/react-static/packages/react-static/'\n)\n\n// Recursively checks a module to see if it originated from a\n// react-static package in the repo\nconst inRepo = mod => {\n  if (\n    !mod.filename.includes('react-static/packages/react-static/') &&\n    mod.filename.includes('react-static/packages/')\n  ) {\n    return true\n  }\n  if (mod.parent) {\n    return inRepo(mod.parent)\n  }\n  return false\n}\n\n// The following ensures that there is always only a single (and same)\n// copy of React in an app at any given moment.\n// eslint-disable-next-line\nModule.prototype.require = function(modulePath) {\n  // If we are running in the repo, we need to make sure\n  // module resolutions coming from other react-static packages\n  // are first attempted from the\n  const isInWorkspace = needsWorkspaceCheck && inRepo(this)\n\n  // Only redirect resolutions to non-relative and non-absolute modules\n  if (!modulePath.startsWith('.') && !modulePath.startsWith('/')) {\n    if (\n      // If module is in the repo try and redirect\n      isInWorkspace ||\n      // Always try and redirect react and react-dom resolutions\n      ['react', 'react-dom'].some(d => modulePath.includes(d))\n    ) {\n      try {\n        modulePath = resolveFrom(\n          path.resolve(process.cwd(), 'node_modules'),\n          modulePath\n        )\n      } catch (err) {\n        //\n      }\n    }\n  }\n  return originalRequire.call(this, modulePath)\n}\n\nrequire('@babel/register')({\n  babelrc: false,\n  presets: [\n    [\n      path.resolve(__dirname, '../../babel-preset.js'),\n      {\n        node: true,\n      },\n    ],\n  ],\n  ignore: [\n    function babelIgnore(filename) {\n      // true if should ignore\n      return (\n        new RegExp(escapeRegExp(`${path.sep}node_modules${path.sep}`)).test(\n          filename\n        ) ||\n        (ignorePath && ignorePath.test(filename))\n      )\n    },\n  ],\n})\n\n// necessary at any entry point of the cli to ensure that Babel-register\n// does not attempt to transform non JavaScript files.\nconst ignoredExtensions = [\n  'css',\n  'scss',\n  'styl',\n  'less',\n  'png',\n  'gif',\n  'jpg',\n  'jpeg',\n  'svg',\n  'woff',\n  'woff2',\n  'ttf',\n  'eot',\n  'otf',\n  'mp4',\n  'webm',\n  'ogg',\n  'mp3',\n  'wav',\n  'md',\n  'yaml',\n]\nignoredExtensions.forEach(ext => {\n  require.extensions[`.${ext}`] = () => {}\n})\n\nconst originalConsoleError = console.error\nconsole.error = (...args) => {\n  if (args.length === 0) {\n    return undefined\n  }\n  const [err, ...rest] = args\n  if (err instanceof Error) {\n    console.log(new PrettyError().render(err), ...rest)\n    return\n  }\n\n  return originalConsoleError(err, ...rest)\n}\n\n// Be sure to log useful information about unhandled exceptions. This should seriously\n// be a default: https://github.com/nodejs/node/issues/9523#issuecomment-259303079\nprocess.on('unhandledRejection', r => {\n  console.error(r)\n})\n\nmodule.exports = {\n  setIgnorePath(path) {\n    ignorePath = path ? new RegExp(escapeRegExp(path)) : undefined\n  },\n}\n"]}