Diffusion Open Access Compliance Check Tool (OACCT) (issn4frontend) Browse

rOACCT/node_modules/react-styleguidist/lib/scripts/utils/sanitizeConfig.js
49c99f97fe9aissn4frontend

sanitizeConfig.js
View Options

			"use strict";

			exports.__esModule = true;
			exports.default = sanitizeConfig;

			var _fs = _interopRequireDefault(require("fs"));

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

			var _castArray = _interopRequireDefault(require("lodash/castArray"));

			var _isBoolean = _interopRequireDefault(require("lodash/isBoolean"));

			var _isFunction = _interopRequireDefault(require("lodash/isFunction"));

			var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));

			var _isString = _interopRequireDefault(require("lodash/isString"));

			var _isFinite = _interopRequireDefault(require("lodash/isFinite"));

			var _map = _interopRequireDefault(require("lodash/map"));

			var _listify = _interopRequireDefault(require("listify"));

			var _kleur = _interopRequireDefault(require("kleur"));

			var _fastestLevenshtein = require("fastest-levenshtein");

			var _typeDetect = _interopRequireDefault(require("type-detect"));

			var _glogg = _interopRequireDefault(require("glogg"));

			var _qI = require("q-i");

			var _error = _interopRequireDefault(require("./error"));

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

			const logger = (0, _glogg.default)('rsg');
			const typeCheckers = {
			number: _isFinite.default,
			string: _isString.default,
			boolean: _isBoolean.default,
			array: Array.isArray,
			function: _isFunction.default,
			object: _isPlainObject.default,
			'file path': _isString.default,
			'existing file path': _isString.default,
			'directory path': _isString.default,
			'existing directory path': _isString.default
			};

			const typesList = types => (0, _listify.default)(types, {
			finalWord: 'or'
			});

			const shouldBeFile = types => types.some(type => type.includes('file'));

			const shouldBeDirectory = types => types.some(type => type.includes('directory'));

			const shouldExist = types => types.some(type => type.includes('existing'));

			function isDirectory(pathString) {
			try {
			return _fs.default.lstatSync(pathString).isDirectory();
			} catch (e) {
			if (e.code !== 'ENOENT') {
			throw e;
			}

			return false;
			}
			}
			/**
			* Validates and normalizes config.
			*
			* @param {object} config
			* @param {object} schema
			* @param {string} rootDir
			* @return {object}
			*/


			function sanitizeConfig(config, schema, rootDir) {
			// Check for unknown fields
			(0, _map.default)(config, (value, keyAny) => {
			const key = keyAny;

			if (!schema[key]) {
			// Try to guess
			const possibleOptions = Object.keys(schema);
			const suggestedOption = possibleOptions.reduce((suggestion, option) => {
			const steps = (0, _fastestLevenshtein.distance)(option, key);

			if (steps < 2) {
			return option;
			}

			return suggestion;
			}, '');
			throw new _error.default(`Unknown config option ${_kleur.default.bold(key)} was found, the value is:\n` + (0, _qI.stringify)(value) + (suggestedOption ? `\n\nDid you mean ${_kleur.default.bold(suggestedOption)}?` : ''), suggestedOption);
			}
			}); // Check all fields

			const safeConfig = {};
			(0, _map.default)(schema, (props, keyAny) => {
			const key = keyAny;
			let value = config[key]; // Custom processing

			if (props.process) {
			value = props.process(value, config, rootDir);
			}

			if (value === undefined) {
			// Default value
			value = props.default; // Check if the field is required

			const isRequired = (0, _isFunction.default)(props.required) ? props.required(config) : props.required;

			if (isRequired) {
			const message = (0, _isString.default)(isRequired) ? isRequired : `${_kleur.default.bold(key)} config option is required.`;
			throw new _error.default(message, key);
			}
			} else if (props.deprecated) {
			logger.warn(`${key} config option is deprecated. ${props.deprecated}`);
			} else if (props.removed) {
			throw new _error.default(`${_kleur.default.bold(key)} config option was removed. ${props.removed}`);
			}

			if (value !== undefined && props.type) {
			const types = (0, _castArray.default)(props.type); // Check type

			const hasRightType = types.some(type => {
			if (!typeCheckers[type]) {
			throw new _error.default(`Wrong type ${_kleur.default.bold(type)} specified for ${_kleur.default.bold(key)} in schema.`);
			}

			return typeCheckers[type](value);
			});

			if (!hasRightType) {
			const exampleValue = props.example \|\| props.default;
			const example = {};

			if (exampleValue) {
			example[key] = exampleValue;
			}

			const exampleText = exampleValue ? `
			Example:

			${(0, _qI.stringify)(example)}` : '';
			throw new _error.default(`${_kleur.default.bold(key)} config option should be ${typesList(types)}, received ${(0, _typeDetect.default)(value)}.\n${exampleText}`, key);
			} // Absolutize paths


			if ((0, _isString.default)(value) && (shouldBeFile(types) \|\| shouldBeDirectory(types))) {
			value = _path.default.resolve(rootDir, value); // Check for existence

			if (shouldExist(types)) {
			if (shouldBeFile(types) && !_fs.default.existsSync(value)) {
			throw new _error.default(`A file specified in ${_kleur.default.bold(key)} config option does not exist:\n${value}`, key);
			}

			if (shouldBeDirectory(types) && !isDirectory(value)) {
			throw new _error.default(`A directory specified in ${_kleur.default.bold(key)} config option does not exist:\n${value}`, key);
			}
			}
			}
			}

			safeConfig[keyAny] = value;
			});
			return safeConfig;
			}