webpack-isomorphic-tools/babel-transpiled-modules/common.js

'use strict';

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

var _keys = require('babel-runtime/core-js/object/keys');

var _keys2 = _interopRequireDefault(_keys);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

exports.default_webpack_assets = default_webpack_assets;
exports.normalize_options = normalize_options;
exports.alias_hook = alias_hook;
exports.normalize_asset_path = normalize_asset_path;
exports.uniform_path = uniform_path;

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _requireHacker = require('require-hacker');

var _requireHacker2 = _interopRequireDefault(_requireHacker);

var _helpers = require('./helpers');

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

// returns a stub for webpack-assets.json if it doesn't exist yet
// (because node.js and webpack are being run in parallel in development mode)
function default_webpack_assets() {
	var webpack_assets = {
		javascript: {},
		styles: {},
		assets: {}
	};

	return webpack_assets;
}

// adds missing fields, etc
function normalize_options(options) {
	// parameters check
	var _iteratorNormalCompletion = true;
	var _didIteratorError = false;
	var _iteratorError = undefined;

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

			switch (_key) {
				case 'assets':
					if (!(0, _helpers.is_object)(options[_key])) {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'an object');
					}
					break;

				case 'debug':
					if (typeof options[_key] !== 'boolean') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a boolean');
					}
					break;

				case 'verbose':
					if (typeof options[_key] !== 'boolean') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a boolean');
					}
					// Legacy `verbose` option is converted to `verbosity`
					console.log('[webpack-isomorphic-tools] WARNING: `verbose` option is now called `verbosity`');
					if (options.verbose) {
						options.verbosity = verbosity_levels.webpack_stats_for_each_build;
					}
					delete options.verbose;
					break;

				case 'verbosity':
					if (typeof options[_key] !== 'string') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a string');
					}
					if ((0, _keys2.default)(verbosity_levels).map(function (key) {
						return verbosity_levels[key];
					}).indexOf(options[_key]) < 0) {
						throw new Error('Unknown "verbosity" passed: ' + options[_key]);
					}
					break;

				case 'port':
					if (typeof options[_key] !== 'number') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a number');
					}
					break;

				case 'webpack_assets_file_path':
				case 'webpack_stats_file_path':
					if (typeof options[_key] !== 'string') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a string');
					}
					break;

				case 'alias':
					if (!(0, _helpers.is_object)(options[_key])) {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'an object');
					}
					break;

				case 'modules_directories':
					if (!Array.isArray(options[_key])) {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'an array');
					}
					break;

				case 'require_context':
					if (typeof options[_key] !== 'boolean') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a boolean');
					}
					// Legacy `require_context` option is converted to `patch_require`
					console.log('[webpack-isomorphic-tools] WARNING: `require_context` option is now called `patch_require`');
					delete options.require_context;
					options.patch_require = true;
					break;

				case 'patch_require':
					if (typeof options[_key] !== 'boolean') {
						throw new Error('"' + _key + '" configuration parameter must be ' + 'a boolean');
					}
					break;

				default:
					throw new Error('Unknown configuration parameter "' + _key + '"');
			}
		}

		// if no assets specified (for whatever reason), make it an empty array
	} catch (err) {
		_didIteratorError = true;
		_iteratorError = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion && _iterator.return) {
				_iterator.return();
			}
		} finally {
			if (_didIteratorError) {
				throw _iteratorError;
			}
		}
	}

	if (!options.assets) {
		// options.assets = {}
		throw new Error('You must specify "assets" parameter in webpack-isomorphic-tools configuration');
	}

	// webpack-assets.json path, relative to the project base path
	options.webpack_assets_file_path = options.webpack_assets_file_path || 'webpack-assets.json';

	// webpack-stats.json path, relative to the project base path
	options.webpack_stats_file_path = options.webpack_stats_file_path || 'webpack-stats.json';

	// if Webpack aliases are supplied, validate them
	if (options.alias) {
		var _iteratorNormalCompletion2 = true;
		var _didIteratorError2 = false;
		var _iteratorError2 = undefined;

		try {
			for (var _iterator2 = (0, _getIterator3.default)((0, _keys2.default)(options.alias)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
				var key = _step2.value;

				if (typeof options.alias[key] !== 'string') {
					throw new Error('Invalid alias for "' + key + '": "' + options.alias[key] + '"');
				}
			}
		} catch (err) {
			_didIteratorError2 = true;
			_iteratorError2 = err;
		} finally {
			try {
				if (!_iteratorNormalCompletion2 && _iterator2.return) {
					_iterator2.return();
				}
			} finally {
				if (_didIteratorError2) {
					throw _iteratorError2;
				}
			}
		}
	}

	// generate names (if required) for each user defined asset type, normalize extensions
	var _iteratorNormalCompletion3 = true;
	var _didIteratorError3 = false;
	var _iteratorError3 = undefined;

	try {
		for (var _iterator3 = (0, _getIterator3.default)((0, _keys2.default)(options.assets)), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
			var asset_type = _step3.value;

			var description = options.assets[asset_type];

			// normalize extensions
			if (description.extension) {
				// sanity check
				if (Array.isArray(description.extension)) {
					throw new Error('Use "extensions" key instead of "extension" for specifying an array of file extensions for assets of type "' + asset_type + '"');
				}

				// sanity check
				if (typeof description.extension !== 'string') {
					throw new Error('"extension" value must be a string for assets of type "' + asset_type + '"');
				}

				// normalize
				description.extensions = [description.extension];
				delete description.extension;
			}

			// sanity check
			if (!description.extensions) {
				throw new Error('You must specify file extensions for assets of type "' + asset_type + '"');
			}

			// parameters check
			var _iteratorNormalCompletion4 = true;
			var _didIteratorError4 = false;
			var _iteratorError4 = undefined;

			try {
				for (var _iterator4 = (0, _getIterator3.default)((0, _keys2.default)(description)), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
					var _key2 = _step4.value;

					switch (_key2) {
						case 'extensions':
							break;

						case 'exclude':
						case 'include':
							if (!Array.isArray(description[_key2])) {
								throw new Error('"' + _key2 + '" must be an array for asset type "' + asset_type + '"');
							}
							var _iteratorNormalCompletion5 = true;
							var _didIteratorError5 = false;
							var _iteratorError5 = undefined;

							try {
								for (var _iterator5 = (0, _getIterator3.default)(description[_key2]), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
									var clusion = _step5.value;

									if (typeof clusion !== 'string' && !(clusion instanceof RegExp) && typeof clusion !== 'function') {
										throw new Error('Unsupported object type for exclusion/inclusion "' + clusion + '" for asset type "' + asset_type + '"');
									}
								}
							} catch (err) {
								_didIteratorError5 = true;
								_iteratorError5 = err;
							} finally {
								try {
									if (!_iteratorNormalCompletion5 && _iterator5.return) {
										_iterator5.return();
									}
								} finally {
									if (_didIteratorError5) {
										throw _iteratorError5;
									}
								}
							}

							break;

						case 'filter':
						case 'parser':
						case 'path':
							if (typeof description[_key2] !== 'function') {
								throw new Error('"' + _key2 + '" must be a function for asset type "' + asset_type + '"');
							}
							break;

						case 'regular_expression':
							if (!(description[_key2] instanceof RegExp)) {
								throw new Error('"' + _key2 + '" must be a regular expression for asset type "' + asset_type + '"');
							}
							break;

						default:
							throw new Error('Unknown property "' + _key2 + '" for asset type "' + asset_type + '"');
					}
				}
			} catch (err) {
				_didIteratorError4 = true;
				_iteratorError4 = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion4 && _iterator4.return) {
						_iterator4.return();
					}
				} finally {
					if (_didIteratorError4) {
						throw _iteratorError4;
					}
				}
			}
		}
	} catch (err) {
		_didIteratorError3 = true;
		_iteratorError3 = err;
	} finally {
		try {
			if (!_iteratorNormalCompletion3 && _iterator3.return) {
				_iterator3.return();
			}
		} finally {
			if (_didIteratorError3) {
				throw _iteratorError3;
			}
		}
	}
}

// alias the path if an alias is found,
// and resolve it to a global filesystem path
function alias_hook(path, module, project_path, aliases, log) {
	// possibly alias the path
	var aliased_path = alias(path, aliases);

	// return if an alias not found
	if (!aliased_path) {
		return;
	}

	// if an alias is found, require() the correct path
	log.debug('require("' + path + '") was called and an alias was found, so aliasing to module path "' + aliased_path + '"');

	// resolve the path to a real filesystem path (resolves `npm link`, etc)
	var global_path = _requireHacker2.default.resolve(aliased_path, module);
	log.debug(' resolved the path for the aliased module to ' + global_path);

	return global_path;

	// const result = require(global_path)
	// // log.debug(` the path was found`)

	// return require_hacker.to_javascript_module_source(result)
}

// alias the path provided the aliases map
function alias(path, aliases) {
	// if it's a path to a file - don't interfere
	if ((0, _helpers.starts_with)(path, '.') || (0, _helpers.starts_with)(path, '/')) {
		return;
	}

	// extract module name from the path
	var slash_index = path.indexOf('/');
	var module_name = slash_index >= 0 ? path.substring(0, slash_index) : path;
	var rest = slash_index >= 0 ? path.substring(slash_index) : '';

	// find an alias
	var alias = aliases[module_name];

	// if an alias is found, require() the correct path
	if (alias) {
		return alias + rest;
	}
}

// converts global asset path to local-to-the-project asset path
function normalize_asset_path(global_asset_path, project_path) {
	// // if this path is outside project folder,
	// // return it as a global path
	// if (!starts_with(global_asset_path, project_path + path.sep))
	// {
	// 	return global_asset_path
	// }

	// this path is inside project folder,
	// convert it to a relative path

	// asset path relative to the project folder
	var asset_path = _path2.default.relative(project_path, global_asset_path);

	// for Windows:
	//
	// convert Node.js path to a correct Webpack path
	asset_path = uniform_path(asset_path);

	return asset_path;
}

// for Windows:
//
// converts Node.js path to a correct Webpack path
function uniform_path(asset_path) {
	// correct slashes
	asset_path = asset_path.replace(/\\/g, '/');

	// add './' in the beginning if it's missing (for example, in case of Windows)
	if (asset_path.indexOf('.') !== 0) {
		asset_path = './' + asset_path;
	}

	return asset_path;
}

var verbosity_levels = exports.verbosity_levels = {
	no_webpack_stats: 'no webpack stats',
	webpack_stats_for_each_build: 'webpack stats for each build'
};
//# sourceMappingURL=common.js.map