@workleap/webpack-configs 1.5.2 → 1.5.3

package/src/transformers/moduleRules.ts

@@ -0,0 +1,229 @@
+import path from "node:path";
+import type { RuleSetRule, RuleSetUseItem } from "webpack";
+import type { WebpackConfig } from "../types.ts";
+
+export type ModuleRuleMatcher = (moduleRule: RuleSetRule | RuleSetUseItem, index: number, array: RuleSetRule[] | RuleSetUseItem[]) => boolean;
+
+export type WithModuleRuleMatcherInfo = {
+    info: {
+        type: string;
+        value: string;
+    };
+} & ModuleRuleMatcher;
+
+function isNameMatchingLoader(loader: string, name: string) {
+    return loader === name || loader.indexOf(`${path.sep}${name}${path.sep}`) !== -1 || loader.indexOf(`@${name}${path.sep}`) !== -1;
+}
+
+export function matchLoaderName(name: string): ModuleRuleMatcher {
+    const matcher: WithModuleRuleMatcherInfo = moduleRule => {
+        if (typeof moduleRule === "string") {
+            return isNameMatchingLoader(moduleRule, name);
+        } else {
+            if ("loader" in moduleRule && moduleRule.loader) {
+                return isNameMatchingLoader(moduleRule.loader, name);
+            }
+        }
+
+        return false;
+    };
+
+    // Add contextual information about the matcher for debugging.
+    matcher.info = {
+        type: matchLoaderName.name,
+        value: name
+    };
+
+    return matcher;
+}
+
+export type AssetModuleType =
+  | "javascript/auto"
+  | "javascript/dynamic"
+  | "javascript/esm"
+  | "json"
+  | "webassembly/sync"
+  | "webassembly/async"
+  | "asset"
+  | "asset/source"
+  | "asset/resource"
+  | "asset/inline";
+
+export function matchAssetModuleType(type: AssetModuleType): ModuleRuleMatcher {
+    const matcher: WithModuleRuleMatcherInfo = moduleRule => {
+        if (typeof moduleRule !== "string" && "type" in moduleRule) {
+            return moduleRule.type === type;
+        }
+
+        return false;
+    };
+
+    // Add contextual information about the matcher for debugging.
+    matcher.info = {
+        type: matchAssetModuleType.name,
+        value: type
+    };
+
+    return matcher;
+}
+
+export function matchTest(test: string | RegExp): ModuleRuleMatcher {
+    const matcher: WithModuleRuleMatcherInfo = moduleRule => {
+        if (typeof moduleRule !== "string" && "test" in moduleRule) {
+            if (typeof moduleRule.test === "object" && typeof test === "object") {
+                // Assuming it's regular expressions.
+                return moduleRule.test.toString() === test.toString();
+            }
+
+            return moduleRule.test === test;
+        }
+
+        return false;
+    };
+
+    // Add contextual information about the matcher for debugging.
+    matcher.info = {
+        type: matchTest.name,
+        value: test.toString()
+    };
+
+    return matcher;
+}
+
+export interface ModuleRuleMatch {
+    moduleRule: RuleSetRule | RuleSetUseItem;
+    index: number;
+    parent: RuleSetRule[] | RuleSetUseItem[];
+}
+
+function toMatch(moduleRule: RuleSetRule | RuleSetUseItem, index: number, parent: RuleSetRule[] | RuleSetUseItem[]) {
+    return {
+        moduleRule,
+        index,
+        parent
+    };
+}
+
+function isRuleSetRule(value: RuleSetRule | RuleSetUseItem): value is RuleSetRule {
+    return (value as RuleSetRule).use !== undefined || (value as RuleSetRule).oneOf !== undefined;
+}
+
+function findModuleRulesRecursively(moduleRules: RuleSetRule[] | RuleSetUseItem[], matcher: ModuleRuleMatcher, parent: RuleSetRule[] | RuleSetUseItem[], matches: ModuleRuleMatch[]) {
+    moduleRules.forEach((x, index, array) => {
+        if (x) {
+            if (matcher(x, index, array)) {
+                matches.push(toMatch(x, index, parent));
+            } else {
+                if (isRuleSetRule(x)) {
+                    if (x.use) {
+                        findModuleRulesRecursively(x.use as RuleSetUseItem[], matcher, x.use as RuleSetUseItem[], matches);
+                    } else if (x.oneOf) {
+                        // This error seems to have been introduced by either TS 5.2. or webpack 5.88.1 (https://github.com/webpack/webpack/releases/tag/v5.88.1),
+                        // I am not sure what changed thought.
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        findModuleRulesRecursively(x.oneOf, matcher, x.oneOf, matches);
+                    }
+                }
+            }
+        }
+    });
+}
+
+export function findModuleRule(config: WebpackConfig, matcher: ModuleRuleMatcher) {
+    const moduleRules = config.module?.rules;
+
+    if (!moduleRules) {
+        return;
+    }
+
+    const matches: ModuleRuleMatch[] = [];
+
+    findModuleRulesRecursively(moduleRules as RuleSetRule[], matcher, moduleRules as RuleSetRule[], matches);
+
+    if (matches.length > 1) {
+        const matcherInfo = (matcher as WithModuleRuleMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Found more than 1 matching module rule.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"\n[webpack-configs] Matches: "${JSON.stringify(matches.map(x => x.moduleRule))}"`);
+    }
+
+    return matches[0];
+}
+
+export function findModuleRules(config: WebpackConfig, matcher: ModuleRuleMatcher) {
+    const moduleRules = config.module?.rules;
+
+    if (!moduleRules) {
+        return;
+    }
+
+    const matches: ModuleRuleMatch[] = [];
+
+    findModuleRulesRecursively(moduleRules as RuleSetRule[], matcher, moduleRules as RuleSetRule[], matches);
+
+    return matches;
+}
+
+export function addBeforeModuleRule(config: WebpackConfig, matcher: ModuleRuleMatcher, newModuleRules: RuleSetRule[] | RuleSetUseItem[]) {
+    const match = findModuleRule(config, matcher);
+
+    if (match) {
+        match.parent.splice(match.index, 0, ...newModuleRules);
+    } else {
+        const matcherInfo = (matcher as WithModuleRuleMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Couldn't add the new module rules because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}
+
+export function addAfterModuleRule(config: WebpackConfig, matcher: ModuleRuleMatcher, newModuleRules: RuleSetRule[] | RuleSetUseItem[]) {
+    const match = findModuleRule(config, matcher);
+
+    if (match) {
+        match.parent.splice(match.index + 1, 0, ...newModuleRules);
+    } else {
+        const matcherInfo = (matcher as WithModuleRuleMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Couldn't add the new module rules because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}
+
+export function replaceModuleRule(config: WebpackConfig, matcher: ModuleRuleMatcher, newModuleRule: RuleSetRule | RuleSetUseItem) {
+    const match = findModuleRule(config, matcher);
+
+    if (match) {
+        match.parent[match.index] = newModuleRule;
+    } else {
+        const matcherInfo = (matcher as WithModuleRuleMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Couldn't replace the module rule because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}
+
+export function removeModuleRules(config: WebpackConfig, matcher: ModuleRuleMatcher) {
+    const moduleRules = config.module?.rules;
+
+    if (!moduleRules) {
+        return;
+    }
+
+    const matches: ModuleRuleMatch[] = [];
+
+    findModuleRulesRecursively(moduleRules as RuleSetRule[], matcher, moduleRules as RuleSetRule[], matches);
+
+    if (matches.length > 0) {
+        // Must keep the initial parent arrays' length to calculate the adjustment
+        // once the first match has been deleted.
+        const initialParentLengths = new Map<RuleSetRule[] | RuleSetUseItem[], number>(matches.map(x => [x.parent, x.parent.length]));
+
+        matches.forEach(x => {
+            const positionAdjustment = initialParentLengths.get(x.parent)! - x.parent.length;
+
+            x.parent.splice(x.index - positionAdjustment, 1);
+        });
+    } else {
+        const matcherInfo = (matcher as WithModuleRuleMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Didn't remove any module rules because no match has been found.\n[webpack-configs] Matcher: "${matcherInfo}"`);
+    }
+}

package/src/transformers/plugins.ts

@@ -0,0 +1,102 @@
+import type { WebpackConfig } from "../types.ts";
+
+export type WebpackPlugin = NonNullable<WebpackConfig["plugins"]>[number];
+
+export type PluginMatcher = (plugin: WebpackPlugin, index: number, array: WebpackPlugin[]) => boolean;
+
+export type WithPluginMatcherInfo = {
+    info: {
+        type: string;
+        value: string;
+    };
+} & PluginMatcher;
+
+export function matchConstructorName(name: string): PluginMatcher {
+    const matcher: WithPluginMatcherInfo = plugin => {
+        return plugin?.constructor.name === name;
+    };
+
+    // Add contextual information about the matcher for debugging.
+    matcher.info = {
+        type: matchConstructorName.name,
+        value: name
+    };
+
+    return matcher;
+}
+
+export interface PluginMatch {
+    plugin: WebpackPlugin;
+    index: number;
+}
+
+export function findPlugin(config: WebpackConfig, matcher: PluginMatcher) {
+    const matches: PluginMatch[] = [];
+
+    config.plugins?.forEach((x, index, array) => {
+        if (matcher(x, index, array)) {
+            matches.push({
+                plugin: x,
+                index
+            });
+        }
+    });
+
+    if (matches.length > 1) {
+        const matcherInfo = (matcher as WithPluginMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Found more than 1 matching plugin.\n[webp-configs] Matcher: "${JSON.stringify(matcherInfo)}"\n[webpack-configs] Matches: "${JSON.stringify(matches.map(x => x.plugin))}"`);
+    }
+
+    return matches[0];
+}
+
+export function replacePlugin(config: WebpackConfig, matcher: PluginMatcher, newPlugin: WebpackPlugin) {
+    const match = findPlugin(config, matcher);
+
+    if (match) {
+        config.plugins![match.index] = newPlugin;
+    } else {
+        const matcherInfo = (matcher as WithPluginMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Couldn't replace the plugin because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}
+
+export function addBeforePlugin(config: WebpackConfig, matcher: PluginMatcher, newPlugins: WebpackPlugin[]) {
+    const match = findPlugin(config, matcher);
+
+    if (match) {
+        config.plugins?.splice(match.index, 0, ...newPlugins);
+    } else {
+        const matcherInfo = (matcher as WithPluginMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Couldn't add the new plugins because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}
+
+export function addAfterPlugin(config: WebpackConfig, matcher: PluginMatcher, newPlugins: WebpackPlugin[]) {
+    const match = findPlugin(config, matcher);
+
+    if (match) {
+        config.plugins?.splice(match.index + 1, 0, ...newPlugins);
+    } else {
+        const matcherInfo = (matcher as WithPluginMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Couldn't add the new plugins because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}
+
+export function removePlugin(config: WebpackConfig, matcher: PluginMatcher) {
+    const countBefore = config.plugins?.length ?? 0;
+
+    config.plugins = config.plugins?.filter((...args) => !matcher(...args));
+
+    const countAfter = config.plugins?.length ?? 0;
+
+    if (countBefore === countAfter) {
+        const matcherInfo = (matcher as WithPluginMatcherInfo).info;
+
+        throw new Error(`[webpack-configs] Didn't remove any plugin because no match has been found.\n[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
+    }
+}

package/src/types.ts

@@ -0,0 +1 @@
+export type { Configuration as WebpackConfig } from "webpack";

package/src/utils.ts

@@ -0,0 +1,19 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isObject(value: any): value is Record<string, unknown> {
+    return typeof value === "object" && !Array.isArray(value) && value != null;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isNull(value: any): value is null {
+    return value == null;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isUndefined(value: any): value is undefined {
+    return typeof value === "undefined" || value === undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isNil(value: any): value is null | undefined {
+    return isNull(value) || isUndefined(value);
+}

package/dist/chunk-2YARCRX5.js

@@ -1,15 +0,0 @@
-// src/utils.ts
-function isObject(value) {
-  return typeof value === "object" && !Array.isArray(value) && value != null;
-}
-function isNull(value) {
-  return value == null;
-}
-function isUndefined(value) {
-  return typeof value === "undefined" || value === void 0;
-}
-function isNil(value) {
-  return isNull(value) || isUndefined(value);
-}
-
-export { isNil, isNull, isObject, isUndefined };

package/dist/chunk-34O5ZLZ6.js

@@ -1,154 +0,0 @@
-import path from 'path';
-
-// src/transformers/moduleRules.ts
-function isNameMatchingLoader(loader, name) {
-  return loader === name || loader.indexOf(`${path.sep}${name}${path.sep}`) !== -1 || loader.indexOf(`@${name}${path.sep}`) !== -1;
-}
-function matchLoaderName(name) {
-  const matcher = (moduleRule) => {
-    if (typeof moduleRule === "string") {
-      return isNameMatchingLoader(moduleRule, name);
-    } else {
-      if ("loader" in moduleRule && moduleRule.loader) {
-        return isNameMatchingLoader(moduleRule.loader, name);
-      }
-    }
-    return false;
-  };
-  matcher.info = {
-    type: matchLoaderName.name,
-    value: name
-  };
-  return matcher;
-}
-function matchAssetModuleType(type) {
-  const matcher = (moduleRule) => {
-    if (typeof moduleRule !== "string" && "type" in moduleRule) {
-      return moduleRule.type === type;
-    }
-    return false;
-  };
-  matcher.info = {
-    type: matchAssetModuleType.name,
-    value: type
-  };
-  return matcher;
-}
-function matchTest(test) {
-  const matcher = (moduleRule) => {
-    if (typeof moduleRule !== "string" && "test" in moduleRule) {
-      if (typeof moduleRule.test === "object" && typeof test === "object") {
-        return moduleRule.test.toString() === test.toString();
-      }
-      return moduleRule.test === test;
-    }
-    return false;
-  };
-  matcher.info = {
-    type: matchTest.name,
-    value: test.toString()
-  };
-  return matcher;
-}
-function toMatch(moduleRule, index, parent) {
-  return {
-    moduleRule,
-    index,
-    parent
-  };
-}
-function isRuleSetRule(value) {
-  return value.use !== void 0 || value.oneOf !== void 0;
-}
-function findModuleRulesRecursively(moduleRules, matcher, parent, matches) {
-  moduleRules.forEach((x, index, array) => {
-    if (x) {
-      if (matcher(x, index, array)) {
-        matches.push(toMatch(x, index, parent));
-      } else {
-        if (isRuleSetRule(x)) {
-          if (x.use) {
-            findModuleRulesRecursively(x.use, matcher, x.use, matches);
-          } else if (x.oneOf) {
-            findModuleRulesRecursively(x.oneOf, matcher, x.oneOf, matches);
-          }
-        }
-      }
-    }
-  });
-}
-function findModuleRule(config, matcher) {
-  const moduleRules = config.module?.rules;
-  if (!moduleRules) {
-    return;
-  }
-  const matches = [];
-  findModuleRulesRecursively(moduleRules, matcher, moduleRules, matches);
-  if (matches.length > 1) {
-    const matcherInfo = matcher.info;
-    throw new Error(`[webpack-configs] Found more than 1 matching module rule.
-[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"
-[webpack-configs] Matches: "${JSON.stringify(matches.map((x) => x.moduleRule))}"`);
-  }
-  return matches[0];
-}
-function findModuleRules(config, matcher) {
-  const moduleRules = config.module?.rules;
-  if (!moduleRules) {
-    return;
-  }
-  const matches = [];
-  findModuleRulesRecursively(moduleRules, matcher, moduleRules, matches);
-  return matches;
-}
-function addBeforeModuleRule(config, matcher, newModuleRules) {
-  const match = findModuleRule(config, matcher);
-  if (match) {
-    match.parent.splice(match.index, 0, ...newModuleRules);
-  } else {
-    const matcherInfo = matcher.info;
-    throw new Error(`[webpack-configs] Couldn't add the new module rules because no match has been found.
-[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
-  }
-}
-function addAfterModuleRule(config, matcher, newModuleRules) {
-  const match = findModuleRule(config, matcher);
-  if (match) {
-    match.parent.splice(match.index + 1, 0, ...newModuleRules);
-  } else {
-    const matcherInfo = matcher.info;
-    throw new Error(`[webpack-configs] Couldn't add the new module rules because no match has been found.
-[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
-  }
-}
-function replaceModuleRule(config, matcher, newModuleRule) {
-  const match = findModuleRule(config, matcher);
-  if (match) {
-    match.parent[match.index] = newModuleRule;
-  } else {
-    const matcherInfo = matcher.info;
-    throw new Error(`[webpack-configs] Couldn't replace the module rule because no match has been found.
-[webpack-configs] Matcher: "${JSON.stringify(matcherInfo)}"`);
-  }
-}
-function removeModuleRules(config, matcher) {
-  const moduleRules = config.module?.rules;
-  if (!moduleRules) {
-    return;
-  }
-  const matches = [];
-  findModuleRulesRecursively(moduleRules, matcher, moduleRules, matches);
-  if (matches.length > 0) {
-    const initialParentLengths = new Map(matches.map((x) => [x.parent, x.parent.length]));
-    matches.forEach((x) => {
-      const positionAdjustment = initialParentLengths.get(x.parent) - x.parent.length;
-      x.parent.splice(x.index - positionAdjustment, 1);
-    });
-  } else {
-    const matcherInfo = matcher.info;
-    throw new Error(`[webpack-configs] Didn't remove any module rules because no match has been found.
-[webpack-configs] Matcher: "${matcherInfo}"`);
-  }
-}
-
-export { addAfterModuleRule, addBeforeModuleRule, findModuleRule, findModuleRules, matchAssetModuleType, matchLoaderName, matchTest, removeModuleRules, replaceModuleRule };

package/dist/chunk-5ACA7GOB.js

@@ -1,17 +0,0 @@
-// src/transformers/applyTransformers.ts
-function applyTransformers(config, transformers, context) {
-  let count = 0;
-  const transformedConfig = transformers.reduce((acc, transformer) => {
-    const newConfig = transformer(acc, context);
-    count += 1;
-    return newConfig;
-  }, config);
-  if (context.verbose) {
-    if (count > 0) {
-      console.log(`[webpack-configs] Applied ${count} configuration transformers.`);
-    }
-  }
-  return transformedConfig;
-}
-
-export { applyTransformers };

package/dist/chunk-6F4PWJZI.js

@@ -1 +0,0 @@
-