universal-webpack/es6/loaders.js

Isomorphic Webpack

function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

import util from 'util';
import querystring from 'querystring';
import { is_object, ends_with } from './helpers.js'; // https://webpack.js.org/configuration/module/
// Finds module rules with `style-loader`.
// If a rule has `oneOf` then a branch of `oneOf` is returned.
//
// `configuration` rule loaders must already be normalized.
//

export function get_style_rules(configuration) {
  // Sanity check
  if (!configuration.module.rules) {
    throw new Error('No `module.rules` found in Webpack configuration. Migrate your configuration to Webpack 2: https://webpack.js.org/guides/migrating/');
  }

  var style_rules = [];

  var _iterator = _createForOfIteratorHelper(configuration.module.rules),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var rule = _step.value;

      // Recurse into `oneOf`.
      // https://webpack.js.org/configuration/module/#rule-oneof
      if (rule.oneOf) {
        var _iterator2 = _createForOfIteratorHelper(rule.oneOf),
            _step2;

        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var subrule = _step2.value;

            if (is_style_rule(subrule)) {
              style_rules.push(subrule);
            }
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }

        continue;
      }

      if (is_style_rule(rule)) {
        style_rules.push(rule);
      }
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return style_rules;
} // `rule` must already be normalized

export function is_style_rule(rule) {
  // Check if this module loader has a `style-loader`
  var style_loader = find_loader(rule, 'style-loader'); // Is it `extract-text-webpack-plugin` loader
  // (the regular expression is a filesystem path
  //  which is `.../extract-text-webpack-plugin/loader.js` for v2
  //  and `.../extract-text-webpack-plugin/dist/loader.js` for v3)

  var extract_text_plugin_loader = rule.use && rule.use.filter(function (loader) {
    return /extract-text-webpack-plugin/.test(loader.loader);
  })[0];
  return style_loader && !extract_text_plugin_loader;
} // Converts loader string into a Webpack 2 loader structure

export function parse_loader(loader) {
  var name;
  var options;

  if (is_object(loader)) {
    if (!loader.loader) {
      throw new Error(".loader not set for a used loader");
    }

    var parsed = parse_loader(loader.loader);
    name = parsed.loader;
    options = parsed.options || loader.query || loader.options;

    if (typeof options === 'string') {
      options = querystring.parse(options);
    }
  } else {
    name = loader;

    if (name.indexOf('?') >= 0) {
      name = name.substring(0, name.indexOf('?'));
      options = querystring.parse(loader.substring(loader.indexOf('?') + 1));
    }
  }

  var result = {
    loader: name
  };

  if (options) {
    result.options = options;
  }

  return result;
} // Converts loader info into a string

export function stringify_loader(loader) {
  return loader.loader + (loader.options ? '?' + querystring.stringify(loader.options) : '');
} // Checks if the passed loader is `loader_name`.

export function find_loader(rule, loader_name) {
  return rule.use && rule.use.filter(function (_) {
    return _.loader === loader_name;
  })[0];
} // Converts `loader` to `loaders`

export function normalize_configuration_rule_loaders(configuration) {
  var _iterator3 = _createForOfIteratorHelper(configuration.module.rules),
      _step3;

  try {
    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
      var rule = _step3.value;
      normalize_rule_loaders(rule);
    }
  } catch (err) {
    _iterator3.e(err);
  } finally {
    _iterator3.f();
  }
} // Converts `loader` to `loaders`

export function normalize_rule_loaders(rule) {
  // Recurse into `oneOf`.
  // https://webpack.js.org/configuration/module/#rule-oneof
  if (rule.oneOf) {
    var _iterator4 = _createForOfIteratorHelper(rule.oneOf),
        _step4;

    try {
      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
        var subrule = _step4.value;

        if (!subrule.use && !subrule.type) {
          throw new Error("A \"oneOf\" subrule must have a \"use\" or \"type\" property.", util.inspect(subrule));
        }

        normalize_rule_loaders(subrule);
      }
    } catch (err) {
      _iterator4.e(err);
    } finally {
      _iterator4.f();
    }

    return;
  } // Convert `loaders` to `use`


  if (rule.loaders) {
    rule.use = rule.loaders;
    delete rule.loaders;
  } // If a `loader` shorthand is used, convert it to `use`


  if (rule.loader) {
    var loaders = rule.loader.split('!');

    if (rule.query || rule.options) {
      var parsed_loader = parse_loader(loaders[0]);

      if (loaders.length > 1 || parsed_loader.options) {
        throw new Error("You have both a compound \".loader\" and a \".query\" (or an \".options\") property set up directly inside a module rule: ".concat(util.inspect(rule), ". Rewrite it either using \".loaders\" or \".use\"."));
      }

      loaders = [parsed_loader];
      parsed_loader.options = rule.query || rule.options;
      delete rule.query;
      delete rule.options;
    }

    rule.use = loaders;
    delete rule.loader;
  }

  if (rule.use) {
    if (typeof rule.use === 'string') {
      rule.use = [rule.use];
    }

    if (!Array.isArray(rule.use)) {
      throw new Error("Invalid Webpack configuration: \"rule.use\" must be an array:\n\n".concat(JSON.stringify(rule, null, 2), "\n\nSee https://webpack.js.org/configuration/module/#rule-use"));
    }

    rule.use = rule.use.map(parse_loader);
  } else if (!rule.type) {
    throw new Error("Neither \"loaders\" nor \"loader\" nor \"use\" nor \"oneOf\" nor \"type\" are present inside a module rule: ".concat(util.inspect(rule)));
  }
}
//# sourceMappingURL=loaders.js.map