From de98e0b232509d5f40c135d540a70e415272ff85 Mon Sep 17 00:00:00 2001 From: Florian Dold Date: Wed, 3 May 2017 15:35:00 +0200 Subject: node_modules --- node_modules/webpack/lib/RuleSet.js | 444 ++++++++++++++++++++++++++++++++++++ 1 file changed, 444 insertions(+) create mode 100644 node_modules/webpack/lib/RuleSet.js (limited to 'node_modules/webpack/lib/RuleSet.js') diff --git a/node_modules/webpack/lib/RuleSet.js b/node_modules/webpack/lib/RuleSet.js new file mode 100644 index 000000000..c52226b84 --- /dev/null +++ b/node_modules/webpack/lib/RuleSet.js @@ -0,0 +1,444 @@ +/* + MIT License http://www.opensource.org/licenses/mit-license.php + Author Tobias Koppers @sokra +*/ +/* +: +: [] +: { + resource: { + test: , + include: , + exclude: , + }, + resource: , -> resource.test + test: , -> resource.test + include: , -> resource.include + exclude: , -> resource.exclude + resourceQuery: , + compiler: , + issuer: , + use: "loader", -> use[0].loader + loader: <>, -> use[0].loader + loaders: <>, -> use + options: {}, -> use[0].options, + query: {}, -> options + parser: {}, + use: [ + "loader" -> use[x].loader + ], + use: [ + { + loader: "loader", + options: {} + } + ], + rules: [ + + ], + oneOf: [ + + ] +} + +: /regExp/ +: function(arg) {} +: "starting" +: [] // or +: { and: [] } +: { or: [] } +: { not: [] } +: { test: , include: , exclude: } + + +normalized: + +{ + resource: function(), + resourceQuery: function(), + compiler: function(), + issuer: function(), + use: [ + { + loader: string, + options: string, + : + } + ], + rules: [], + oneOf: [], + : , +} + +*/ + +"use strict"; + +module.exports = class RuleSet { + constructor(rules) { + this.references = Object.create(null); + this.rules = RuleSet.normalizeRules(rules, this.references, "ref-"); + } + + static normalizeRules(rules, refs, ident) { + if(Array.isArray(rules)) { + return rules.map((rule, idx) => { + return RuleSet.normalizeRule(rule, refs, `${ident}-${idx}`); + }); + } else if(rules) { + return [RuleSet.normalizeRule(rules, refs, ident)]; + } else { + return []; + } + } + + static normalizeRule(rule, refs, ident) { + if(typeof rule === "string") + return { + use: [{ + loader: rule + }] + }; + if(!rule) + throw new Error("Unexcepted null when object was expected as rule"); + if(typeof rule !== "object") + throw new Error("Unexcepted " + typeof rule + " when object was expected as rule (" + rule + ")"); + + let newRule = {}; + let useSource; + let resourceSource; + let condition; + + if(rule.test || rule.include || rule.exclude) { + checkResourceSource("test + include + exclude"); + condition = { + test: rule.test, + include: rule.include, + exclude: rule.exclude + }; + try { + newRule.resource = RuleSet.normalizeCondition(condition); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(condition, error)); + } + } + + if(rule.resource) { + checkResourceSource("resource"); + try { + newRule.resource = RuleSet.normalizeCondition(rule.resource); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.resource, error)); + } + } + + if(rule.resourceQuery) { + try { + newRule.resourceQuery = RuleSet.normalizeCondition(rule.resourceQuery); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.resourceQuery, error)); + } + } + + if(rule.compiler) { + try { + newRule.compiler = RuleSet.normalizeCondition(rule.compiler); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.compiler, error)); + } + } + + if(rule.issuer) { + try { + newRule.issuer = RuleSet.normalizeCondition(rule.issuer); + } catch(error) { + throw new Error(RuleSet.buildErrorMessage(rule.issuer, error)); + } + } + + if(rule.loader && rule.loaders) + throw new Error(RuleSet.buildErrorMessage(rule, new Error("Provided loader and loaders for rule (use only one of them)"))); + + const loader = rule.loaders || rule.loader; + if(typeof loader === "string" && !rule.options && !rule.query) { + checkUseSource("loader"); + newRule.use = RuleSet.normalizeUse(loader.split("!"), ident); + } else if(typeof loader === "string" && (rule.options || rule.query)) { + checkUseSource("loader + options/query"); + newRule.use = RuleSet.normalizeUse({ + loader: loader, + options: rule.options, + query: rule.query + }, ident); + } else if(loader && (rule.options || rule.query)) { + throw new Error(RuleSet.buildErrorMessage(rule, new Error("options/query cannot be used with loaders (use options for each array item)"))); + } else if(loader) { + checkUseSource("loaders"); + newRule.use = RuleSet.normalizeUse(loader, ident); + } else if(rule.options || rule.query) { + throw new Error(RuleSet.buildErrorMessage(rule, new Error("options/query provided without loader (use loader + options)"))); + } + + if(rule.use) { + checkUseSource("use"); + newRule.use = RuleSet.normalizeUse(rule.use, ident); + } + + if(rule.rules) + newRule.rules = RuleSet.normalizeRules(rule.rules, refs, `${ident}-rules`); + + if(rule.oneOf) + newRule.oneOf = RuleSet.normalizeRules(rule.oneOf, refs, `${ident}-oneOf`); + + const keys = Object.keys(rule).filter((key) => { + return ["resource", "resourceQuery", "compiler", "test", "include", "exclude", "issuer", "loader", "options", "query", "loaders", "use", "rules", "oneOf"].indexOf(key) < 0; + }); + keys.forEach((key) => { + newRule[key] = rule[key]; + }); + + function checkUseSource(newSource) { + if(useSource && useSource !== newSource) + throw new Error(RuleSet.buildErrorMessage(rule, new Error("Rule can only have one result source (provided " + newSource + " and " + useSource + ")"))); + useSource = newSource; + } + + function checkResourceSource(newSource) { + if(resourceSource && resourceSource !== newSource) + throw new Error(RuleSet.buildErrorMessage(rule, new Error("Rule can only have one resource source (provided " + newSource + " and " + resourceSource + ")"))); + resourceSource = newSource; + } + + if(Array.isArray(newRule.use)) { + newRule.use.forEach((item) => { + if(item.ident) { + refs[item.ident] = item.options; + } + }); + } + + return newRule; + } + + static buildErrorMessage(condition, error) { + const conditionAsText = JSON.stringify(condition, (key, value) => { + return value === undefined ? "undefined" : value; + }, 2); + return error.message + " in " + conditionAsText; + } + + static normalizeUse(use, ident) { + if(Array.isArray(use)) { + return use + .map((item, idx) => RuleSet.normalizeUse(item, `${ident}-${idx}`)) + .reduce((arr, items) => arr.concat(items), []); + } + return [RuleSet.normalizeUseItem(use, ident)]; + } + + static normalizeUseItemFunction(use, data) { + const result = use(data); + if(typeof result === "string") { + return RuleSet.normalizeUseItem(result); + } + return result; + } + + static normalizeUseItemString(useItemString) { + const idx = useItemString.indexOf("?"); + if(idx >= 0) { + return { + loader: useItemString.substr(0, idx), + options: useItemString.substr(idx + 1) + }; + } + return { + loader: useItemString + }; + } + + static normalizeUseItem(item, ident) { + if(typeof item === "function") + return item; + + if(typeof item === "string") { + return RuleSet.normalizeUseItemString(item); + } + + let newItem = {}; + + if(item.options && item.query) + throw new Error("Provided options and query in use"); + + if(!item.loader) + throw new Error("No loader specified"); + + newItem.options = item.options || item.query; + + if(typeof newItem.options === "object" && newItem.options) { + if(newItem.options.ident) + newItem.ident = newItem.options.ident; + else + newItem.ident = ident; + } + + const keys = Object.keys(item).filter(function(key) { + return ["options", "query"].indexOf(key) < 0; + }); + + keys.forEach(function(key) { + newItem[key] = item[key]; + }); + + return newItem; + } + + static normalizeCondition(condition) { + if(!condition) + throw new Error("Expected condition but got falsy value"); + if(typeof condition === "string") { + return str => str.indexOf(condition) === 0; + } + if(typeof condition === "function") { + return condition; + } + if(condition instanceof RegExp) { + return condition.test.bind(condition); + } + if(Array.isArray(condition)) { + const items = condition.map(c => RuleSet.normalizeCondition(c)); + return orMatcher(items); + } + if(typeof condition !== "object") + throw Error("Unexcepted " + typeof condition + " when condition was expected (" + condition + ")"); + + let matchers = []; + Object.keys(condition).forEach(key => { + const value = condition[key]; + switch(key) { + case "or": + case "include": + case "test": + if(value) + matchers.push(RuleSet.normalizeCondition(value)); + break; + case "and": + if(value) { + const items = value.map(c => RuleSet.normalizeCondition(c)); + matchers.push(andMatcher(items)); + } + break; + case "not": + case "exclude": + if(value) { + const matcher = RuleSet.normalizeCondition(value); + matchers.push(notMatcher(matcher)); + } + break; + default: + throw new Error("Unexcepted property " + key + " in condition"); + } + }); + if(matchers.length === 0) + throw new Error("Excepted condition but got " + condition); + if(matchers.length === 1) + return matchers[0]; + return andMatcher(matchers); + } + + exec(data) { + const result = []; + this._run(data, { + rules: this.rules + }, result); + return result; + } + + _run(data, rule, result) { + // test conditions + if(rule.resource && !data.resource) + return false; + if(rule.resourceQuery && !data.resourceQuery) + return false; + if(rule.compiler && !data.compiler) + return false; + if(rule.issuer && !data.issuer) + return false; + if(rule.resource && !rule.resource(data.resource)) + return false; + if(data.issuer && rule.issuer && !rule.issuer(data.issuer)) + return false; + if(data.resourceQuery && rule.resourceQuery && !rule.resourceQuery(data.resourceQuery)) + return false; + if(data.compiler && rule.compiler && !rule.compiler(data.compiler)) + return false; + + // apply + const keys = Object.keys(rule).filter((key) => { + return ["resource", "resourceQuery", "compiler", "issuer", "rules", "oneOf", "use", "enforce"].indexOf(key) < 0; + }); + keys.forEach((key) => { + result.push({ + type: key, + value: rule[key] + }); + }); + + if(rule.use) { + rule.use.forEach((use) => { + result.push({ + type: "use", + value: typeof use === "function" ? RuleSet.normalizeUseItemFunction(use, data) : use, + enforce: rule.enforce + }); + }); + } + + if(rule.rules) { + for(let i = 0; i < rule.rules.length; i++) { + this._run(data, rule.rules[i], result); + } + } + + if(rule.oneOf) { + for(let i = 0; i < rule.oneOf.length; i++) { + if(this._run(data, rule.oneOf[i], result)) + break; + } + } + + return true; + } + + findOptionsByIdent(ident) { + const options = this.references[ident]; + if(!options) throw new Error("Can't find options with ident '" + ident + "'"); + return options; + } +}; + +function notMatcher(matcher) { + return function(str) { + return !matcher(str); + }; +} + +function orMatcher(items) { + return function(str) { + for(let i = 0; i < items.length; i++) { + if(items[i](str)) + return true; + } + return false; + }; +} + +function andMatcher(items) { + return function(str) { + for(let i = 0; i < items.length; i++) { + if(!items[i](str)) + return false; + } + return true; + }; +} -- cgit v1.2.3