1

node_modules/webpack-chain/src/Rule.js

@@ -0,0 +1,141 @@
+const ChainedMap = require('./ChainedMap');
+const ChainedSet = require('./ChainedSet');
+const Orderable = require('./Orderable');
+const Use = require('./Use');
+const Resolve = require('./Resolve');
+
+function toArray(arr) {
+  return Array.isArray(arr) ? arr : [arr];
+}
+
+const Rule = Orderable(
+  class extends ChainedMap {
+    constructor(parent, name, ruleType = 'rule') {
+      super(parent);
+      this.name = name;
+      this.names = [];
+      this.ruleType = ruleType;
+      this.ruleTypes = [];
+
+      let rule = this;
+      while (rule instanceof Rule) {
+        this.names.unshift(rule.name);
+        this.ruleTypes.unshift(rule.ruleType);
+        rule = rule.parent;
+      }
+
+      this.uses = new ChainedMap(this);
+      this.include = new ChainedSet(this);
+      this.exclude = new ChainedSet(this);
+      this.rules = new ChainedMap(this);
+      this.oneOfs = new ChainedMap(this);
+      this.resolve = new Resolve(this);
+      this.extend([
+        'enforce',
+        'issuer',
+        'parser',
+        'resource',
+        'resourceQuery',
+        'sideEffects',
+        'test',
+        'type',
+      ]);
+    }
+
+    use(name) {
+      return this.uses.getOrCompute(name, () => new Use(this, name));
+    }
+
+    rule(name) {
+      return this.rules.getOrCompute(name, () => new Rule(this, name, 'rule'));
+    }
+
+    oneOf(name) {
+      return this.oneOfs.getOrCompute(
+        name,
+        () => new Rule(this, name, 'oneOf'),
+      );
+    }
+
+    pre() {
+      return this.enforce('pre');
+    }
+
+    post() {
+      return this.enforce('post');
+    }
+
+    toConfig() {
+      const config = this.clean(
+        Object.assign(this.entries() || {}, {
+          include: this.include.values(),
+          exclude: this.exclude.values(),
+          rules: this.rules.values().map((rule) => rule.toConfig()),
+          oneOf: this.oneOfs.values().map((oneOf) => oneOf.toConfig()),
+          use: this.uses.values().map((use) => use.toConfig()),
+          resolve: this.resolve.toConfig(),
+        }),
+      );
+
+      Object.defineProperties(config, {
+        __ruleNames: { value: this.names },
+        __ruleTypes: { value: this.ruleTypes },
+      });
+
+      return config;
+    }
+
+    merge(obj, omit = []) {
+      if (!omit.includes('include') && 'include' in obj) {
+        this.include.merge(toArray(obj.include));
+      }
+
+      if (!omit.includes('exclude') && 'exclude' in obj) {
+        this.exclude.merge(toArray(obj.exclude));
+      }
+
+      if (!omit.includes('use') && 'use' in obj) {
+        Object.keys(obj.use).forEach((name) =>
+          this.use(name).merge(obj.use[name]),
+        );
+      }
+
+      if (!omit.includes('rules') && 'rules' in obj) {
+        Object.keys(obj.rules).forEach((name) =>
+          this.rule(name).merge(obj.rules[name]),
+        );
+      }
+
+      if (!omit.includes('oneOf') && 'oneOf' in obj) {
+        Object.keys(obj.oneOf).forEach((name) =>
+          this.oneOf(name).merge(obj.oneOf[name]),
+        );
+      }
+
+      if (!omit.includes('resolve') && 'resolve' in obj) {
+        this.resolve.merge(obj.resolve);
+      }
+
+      if (!omit.includes('test') && 'test' in obj) {
+        this.test(
+          obj.test instanceof RegExp || typeof obj.test === 'function'
+            ? obj.test
+            : new RegExp(obj.test),
+        );
+      }
+
+      return super.merge(obj, [
+        ...omit,
+        'include',
+        'exclude',
+        'use',
+        'rules',
+        'oneOf',
+        'resolve',
+        'test',
+      ]);
+    }
+  },
+);
+
+module.exports = Rule;