plotly-icons/demo/node_modules/next/dist/server/build/webpack/utils.js

set of plotly icons

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getPages = undefined;

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var getPages = exports.getPages = function () {
  var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee(dir, _ref) {
    var dev = _ref.dev,
        isServer = _ref.isServer,
        pageExtensions = _ref.pageExtensions;
    var pageFiles;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return getPagePaths(dir, { dev: dev, isServer: isServer, pageExtensions: pageExtensions });

          case 2:
            pageFiles = _context.sent;
            return _context.abrupt('return', getPageEntries(pageFiles, { isServer: isServer, pageExtensions: pageExtensions }));

          case 4:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function getPages(_x, _x2) {
    return _ref2.apply(this, arguments);
  };
}();

var getPagePaths = function () {
  var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(dir, _ref3) {
    var dev = _ref3.dev,
        isServer = _ref3.isServer,
        pageExtensions = _ref3.pageExtensions;
    var pages;
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            pages = void 0;

            if (!dev) {
              _context2.next = 7;
              break;
            }

            _context2.next = 4;
            return (0, _globPromise2.default)(isServer ? 'pages/+(_document|_error).+(' + pageExtensions + ')' : 'pages/_error.+(' + pageExtensions + ')', { cwd: dir });

          case 4:
            pages = _context2.sent;
            _context2.next = 10;
            break;

          case 7:
            _context2.next = 9;
            return (0, _globPromise2.default)(isServer ? 'pages/**/*.+(' + pageExtensions + ')' : 'pages/**/!(_document)*.+(' + pageExtensions + ')', { cwd: dir });

          case 9:
            pages = _context2.sent;

          case 10:
            return _context2.abrupt('return', pages);

          case 11:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));

  return function getPagePaths(_x3, _x4) {
    return _ref4.apply(this, arguments);
  };
}();

// Convert page path into single entry


exports.createEntry = createEntry;
exports.getPageEntries = getPageEntries;

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _globPromise = require('glob-promise');

var _globPromise2 = _interopRequireDefault(_globPromise);

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

var nextPagesDir = _path2.default.join(__dirname, '..', '..', '..', 'pages');

function createEntry(filePath) {
  var _ref5 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      name = _ref5.name,
      pageExtensions = _ref5.pageExtensions;

  var parsedPath = _path2.default.parse(filePath);
  var entryName = name || filePath;

  // This makes sure we compile `pages/blog/index.js` to `pages/blog.js`.
  // Excludes `pages/index.js` from this rule since we do want `/` to route to `pages/index.js`
  if (parsedPath.dir !== 'pages' && parsedPath.name === 'index') {
    entryName = parsedPath.dir + '.js';
  }

  // Makes sure supported extensions are stripped off. The outputted file should always be `.js`
  if (pageExtensions) {
    entryName = entryName.replace(new RegExp('\\.+(' + pageExtensions + ')$'), '.js');
  }

  return {
    name: _path2.default.join('bundles', entryName),
    files: [parsedPath.root ? filePath : './' + filePath] // The entry always has to be an array.
  };
}

// Convert page paths into entries
function getPageEntries(pagePaths) {
  var _ref6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref6$isServer = _ref6.isServer,
      isServer = _ref6$isServer === undefined ? false : _ref6$isServer,
      pageExtensions = _ref6.pageExtensions;

  var entries = {};

  var _iteratorNormalCompletion = true;
  var _didIteratorError = false;
  var _iteratorError = undefined;

  try {
    for (var _iterator = (0, _getIterator3.default)(pagePaths), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
      var filePath = _step.value;

      var entry = createEntry(filePath, { pageExtensions: pageExtensions });
      entries[entry.name] = entry.files;
    }
  } catch (err) {
    _didIteratorError = true;
    _iteratorError = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion && _iterator.return) {
        _iterator.return();
      }
    } finally {
      if (_didIteratorError) {
        throw _iteratorError;
      }
    }
  }

  var errorPagePath = _path2.default.join(nextPagesDir, '_error.js');
  var errorPageEntry = createEntry(errorPagePath, { name: 'pages/_error.js' }); // default error.js
  if (!entries[errorPageEntry.name]) {
    entries[errorPageEntry.name] = errorPageEntry.files;
  }

  if (isServer) {
    var documentPagePath = _path2.default.join(nextPagesDir, '_document.js');
    var documentPageEntry = createEntry(documentPagePath, { name: 'pages/_document.js' }); // default _document.js
    if (!entries[documentPageEntry.name]) {
      entries[documentPageEntry.name] = documentPageEntry.files;
    }
  }

  return entries;
}