@pundle/chunk-generator-js/lib/index.js

TODO

"use strict";

var _sbFs = _interopRequireDefault(require("sb-fs"));

var _path = _interopRequireDefault(require("path"));

var _sourceMap = require("source-map");

var _api = require("@pundle/api");

var Helpers = _interopRequireWildcard(require("./helpers"));

var _package = _interopRequireDefault(require("../package.json"));

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

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

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

function createComponent() {
  const wrapperNode = _sbFs.default.readFile(_path.default.join(__dirname, 'wrapper', 'node.js'), 'utf8');

  const wrapperBrowser = _sbFs.default.readFile(_path.default.join(__dirname, 'wrapper', 'browser.js'), 'utf8');

  return (0, _api.createChunkGenerator)({
    name: _package.default.name,
    version: _package.default.version,

    callback({
      chunk,
      job,
      context
    }) {
      return _asyncToGenerator(function* () {
        if (chunk.format !== 'js') return null;
        const sourceMap = new _sourceMap.SourceMapGenerator({
          skipValidation: true
        });
        const sourceMapPath = context.getPublicPath(_objectSpread({}, chunk, {
          format: `${chunk.format}.map`
        }));

        const _Helpers$getContentFo = Helpers.getContentForOutput(chunk, job),
              files = _Helpers$getContentFo.files;

        const contents = [';(function(){', yield context.config.target === 'browser' ? wrapperBrowser : wrapperNode, `sbPundleChunkLoading(${JSON.stringify(context.getPublicPath(chunk))});`];
        let sourceMapOffset = Helpers.getLinesCount(contents.join('\n')) + 1;
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
          for (var _iterator = files[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            const file = _step.value;
            const fileContents = `sbPundleModuleRegister(${JSON.stringify((0, _api.getUniqueHash)(file))}, function(exports, require, module, __filename, __dirname) {\n${file.contents.toString()}\n});`;

            if (sourceMapPath) {
              if (file.sourceMap) {
                yield Helpers.mergeSourceMap(file.sourceMap, sourceMap, sourceMapOffset, file.filePath);
              }

              sourceMapOffset += Helpers.getLinesCount(fileContents);
            }

            contents.push(fileContents);
          }
        } catch (err) {
          _didIteratorError = true;
          _iteratorError = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion && _iterator.return != null) {
              _iterator.return();
            }
          } finally {
            if (_didIteratorError) {
              throw _iteratorError;
            }
          }
        }

        if (chunk.filePath && chunk.root) {
          const chunkEntryId = (0, _api.getUniqueHash)(chunk);
          contents.push(`${context.config.target === 'node' ? 'module.exports = ' : ''}sbPundleModuleGenerate('$root')(${JSON.stringify(chunkEntryId)})`);
        }

        contents.push(`sbPundleChunkLoaded(${JSON.stringify(context.getPublicPath(chunk))});`);
        contents.push('})();');
        const output = {
          contents: '',
          sourceMap: null,
          format: chunk.format
        };
        const publicPath = context.getPublicPath(chunk);

        if (sourceMapPath) {
          output.sourceMap = {
            contents: JSON.stringify(sourceMap.toJSON()),
            filePath: sourceMapPath
          };
          contents.push(`//# sourceMappingURL=${_path.default.posix.relative(_path.default.dirname(publicPath), sourceMapPath)}`);
        }

        output.contents = contents.join('\n');
        return output;
      })();
    }

  });
}

module.exports = createComponent;