@expo/webpack-pwa-manifest-plugin/build/injector.js

Generates a progressive web app (PWA) manifest.json from a React Native app.json

'use strict';

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

var _defineProperty2;

function _load_defineProperty() {
  return _defineProperty2 = _interopRequireDefault(require('babel-runtime/helpers/defineProperty'));
}

var _getIterator2;

function _load_getIterator() {
  return _getIterator2 = _interopRequireDefault(require('babel-runtime/core-js/get-iterator'));
}

var _regenerator;

function _load_regenerator() {
  return _regenerator = _interopRequireDefault(require('babel-runtime/regenerator'));
}

var _toConsumableArray2;

function _load_toConsumableArray() {
  return _toConsumableArray2 = _interopRequireDefault(require('babel-runtime/helpers/toConsumableArray'));
}

var _slicedToArray2;

function _load_slicedToArray() {
  return _slicedToArray2 = _interopRequireDefault(require('babel-runtime/helpers/slicedToArray'));
}

var _asyncToGenerator2;

function _load_asyncToGenerator() {
  return _asyncToGenerator2 = _interopRequireDefault(require('babel-runtime/helpers/asyncToGenerator'));
}

var _stringify;

function _load_stringify() {
  return _stringify = _interopRequireDefault(require('babel-runtime/core-js/json/stringify'));
}

var _extends2;

function _load_extends() {
  return _extends2 = _interopRequireDefault(require('babel-runtime/helpers/extends'));
}

var buildResources = exports.buildResources = function () {
  var _ref = (0, (_asyncToGenerator2 || _load_asyncToGenerator()).default)( /*#__PURE__*/(_regenerator || _load_regenerator()).default.mark(function _callee(self) {
    var publicPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';

    var parsedIconsResult, _retrieveIcons, _retrieveIcons2, _results, config, _parsedIconsResult, icons, _parsedIconsResult$as, assets, results;

    return (_regenerator || _load_regenerator()).default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!(!self.assets || !self.options.inject)) {
              _context.next = 12;
              break;
            }

            parsedIconsResult = {};

            if (self.options.noResources) {
              _context.next = 8;
              break;
            }

            _retrieveIcons = (0, (_icons || _load_icons()).retrieveIcons)(self.manifest), _retrieveIcons2 = (0, (_slicedToArray2 || _load_slicedToArray()).default)(_retrieveIcons, 2), _results = _retrieveIcons2[0], config = _retrieveIcons2[1];

            self.manifest = config;
            _context.next = 7;
            return (0, (_icons || _load_icons()).parseIcons)(_results, self.options.fingerprints, publicPath);

          case 7:
            parsedIconsResult = _context.sent;

          case 8:
            _parsedIconsResult = parsedIconsResult, icons = _parsedIconsResult.icons, _parsedIconsResult$as = _parsedIconsResult.assets, assets = _parsedIconsResult$as === undefined ? [] : _parsedIconsResult$as;
            results = writeManifestToFile((0, (_extends2 || _load_extends()).default)({}, self.manifest, { icons: icons }), self.options, publicPath);

            self.assets = [results].concat((0, (_toConsumableArray2 || _load_toConsumableArray()).default)(assets));
            return _context.abrupt('return', results);

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

  return function buildResources(_x2) {
    return _ref.apply(this, arguments);
  };
}();

exports.injectResources = injectResources;
exports.generateAppleSplashAndIconTags = generateAppleSplashAndIconTags;
exports.applyTag = applyTag;
exports.generateHtmlTags = generateHtmlTags;

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

var _fingerprint;

function _load_fingerprint() {
  return _fingerprint = _interopRequireDefault(require('./helpers/fingerprint'));
}

var _uri;

function _load_uri() {
  return _uri = require('./helpers/uri');
}

var _icons;

function _load_icons() {
  return _icons = require('./icons');
}

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

var voidTags = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'];

function createFilename(filenameTemplate, json, shouldFingerprint) {
  var formatters = [{
    pattern: /\[hash(:([1-9]|[1-2][0-9]|3[0-2]))?\]/gi,
    value: function value(match) {
      var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ':32';

      if (!shouldFingerprint) return '';
      var hash = (0, (_fingerprint || _load_fingerprint()).default)(json);
      return hash.substr(0, parseInt(limit.substr(1), 10));
    }
  }, {
    pattern: /\[ext\]/gi,
    value: 'json'
  }, {
    pattern: /\[name\]/gi,
    value: 'manifest'
  }];

  return formatters.reduce(function (acc, curr) {
    return acc.replace(curr.pattern, curr.value);
  }, filenameTemplate);
}

// Create `manifest.json`
function writeManifestToFile(manifest, options, publicPath) {
  var content = (0, (_extends2 || _load_extends()).default)({}, manifest);

  if (content.orientation === 'omit') {
    delete content.orientation;
  }

  // Object.keys(content).forEach(key => content[key] == null && delete content[key]);

  var json = (0, (_stringify || _load_stringify()).default)(content, null, 2);
  var file = _path.default.parse(options.filename);
  var filename = createFilename(file.base, json, options.fingerprints);
  var output = options.includeDirectory ? _path.default.join(file.dir, filename) : filename;
  return {
    output: output,
    url: (0, (_uri || _load_uri()).joinURI)(publicPath, output),
    source: json,
    size: json.length
  };
}

function injectResources(compilation, assets, callback) {
  if (assets) {
    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      var _loop = function _loop() {
        var asset = _step.value;

        compilation.assets[asset.output] = {
          source: function source() {
            return asset.source;
          },
          size: function size() {
            return asset.size;
          }
        };
      };

      for (var _iterator = (0, (_getIterator2 || _load_getIterator()).default)(assets), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        _loop();
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  }
  callback();
}

function generateAppleSplashAndIconTags(assets) {
  var tags = {};
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;

  try {
    for (var _iterator2 = (0, (_getIterator2 || _load_getIterator()).default)(assets), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var _asset = _step2.value;

      if (_asset.ios && _asset.ios.valid) {
        if (_asset.ios.valid === 'startup') {
          tags = applyTag(tags, 'link', {
            rel: 'apple-touch-startup-image',
            media: _asset.ios.media,
            href: _asset.ios.href
          });
        } else {
          tags = applyTag(tags, 'link', {
            // apple-touch-icon-precomposed
            rel: 'apple-touch-icon',
            sizes: _asset.ios.size,
            href: _asset.ios.href
          });
        }
      }
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }

  return tags;
}

function applyTag(obj, tag, content) {
  if (!content) {
    return obj;
  }
  var tags = (0, (_extends2 || _load_extends()).default)({}, obj);
  if (tags[tag]) {
    if (Array.isArray(tags[tag])) {
      tags[tag].push(content);
      return tags;
    }
    tags[tag] = [tags[tag], content];
    return tags;
  }

  tags[tag] = content;
  return tags;
}

function generateHtmlTags(tags) {
  var html = '';
  for (var tag in tags) {
    var attrs = tags[tag];
    if (Array.isArray(attrs)) {
      var _iteratorNormalCompletion3 = true;
      var _didIteratorError3 = false;
      var _iteratorError3 = undefined;

      try {
        for (var _iterator3 = (0, (_getIterator2 || _load_getIterator()).default)(attrs), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
          var a = _step3.value;

          html = '' + html + generateHtmlTags((0, (_defineProperty2 || _load_defineProperty()).default)({}, tag, a));
        }
      } catch (err) {
        _didIteratorError3 = true;
        _iteratorError3 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion3 && _iterator3.return) {
            _iterator3.return();
          }
        } finally {
          if (_didIteratorError3) {
            throw _iteratorError3;
          }
        }
      }
    } else {
      html = html + '<' + tag;
      for (var attr in attrs) {
        html = html + ' ' + attr + '="' + attrs[attr] + '"';
      }
      html = voidTags.indexOf(tag) === -1 ? html + '></' + tag + '>' : html + ' />';
    }
  }
  return html;
}
//# sourceMappingURL=__sourcemaps__/injector.js.map