@bhollis/eslint-plugin-css-modules 1.0.0

package/README.md

@@ -0,0 +1,142 @@
+# @bhollis/eslint-plugin-css-modules
+
+This plugin intends to help you in tracking down problems when you are using css-modules. It tells if you are using a non-existent css/scss/less class in js or if you forgot to use some classes which you declared in css/scss/less.
+
+This is a forked version of https://github.com/atfzl/eslint-plugin-css-modules with fixes to make it compatible with more recent versions of css-loader, especially with [`namedExports: true`](https://webpack.js.org/loaders/css-loader/#namedexport). It is also compatible with ESLint's flat config.
+
+## Rules
+
+* `css-modules/no-unused-class`: You must use all the classes defined in css/scss/less file.
+
+>If you still want to mark a class as used, then use this comment on top of your file
+```js
+/* eslint css-modules/no-unused-class: [2, { markAsUsed: ['container'] }] */
+```
+where container is the css class that you want to mark as used.
+Add all such classes in the array.
+
+>If you use the `camelCase` option of `css-loader`, you must also enabled it for this plugin
+```js
+/* eslint css-modules/no-unused-class: [2, { camelCase: true }] */
+```
+
+* `css-modules/no-undef-class`: You must not use a non existing class, or a property that hasn't been exported using the [:export keyword](https://github.com/css-modules/icss#export).
+
+>If you use the `camelCase` option of `css-loader`, you must also enabled it for this plugin
+```js
+/* eslint css-modules/no-undef-class: [2, { camelCase: true }] */
+```
+
+## Installation
+
+```
+npm i --save-dev @bhollis/eslint-plugin-css-modules
+```
+
+## Usage:
+
+```js
+// eslint.config.js
+import { defineConfig } from "eslint/config";
+import cssModules from "@bhollis/eslint-plugin-css-modules";
+
+export default defineConfig([
+  cssModules.configs.recommended
+	{
+		files: ["**/*.jsx"], // any patterns you want to apply the config to
+		plugins: {
+			'css-modules': cssModules,
+		},
+		extends: ["css-modules/recommended"],
+	},
+]);
+```
+
+You may also tweak the rules individually. For instance, if you use the [camelCase](https://github.com/webpack-contrib/css-loader#camelcase) option of webpack's css-loader:
+
+```js
+// eslint.config.js
+import { defineConfig } from "eslint/config";
+import cssModules from "@bhollis/eslint-plugin-css-modules";
+
+export default defineConfig([
+	{
+		files: ["**/*.jsx"], // any patterns you want to apply the config to
+		plugins: {
+			'css-modules': cssModules,
+		},
+		rules: {
+      "css-modules/no-unused-class": [2, { "camelCase": true }],
+      "css-modules/no-undef-class": [2, { "camelCase": true }]
+    },
+	},
+]);
+```
+
+The camelCase option has 4 possible values, see [css-loader#camelCase](https://github.com/webpack-contrib/css-loader#camelcase) for description:
+```js
+true | "dashes" | "only" | "dashes-only"
+```
+
+## Specifying base path
+
+You can specify path for the base directory via plugin settings in eslint.config.js. This is used by the plugin to resolve absolute (S)CSS paths:
+
+```js
+// eslint.config.js
+import { defineConfig } from "eslint/config";
+import cssModules from "@bhollis/eslint-plugin-css-modules";
+
+export default defineConfig([
+	{
+		files: ["**/*.jsx"], // any patterns you want to apply the config to
+		plugins: {
+			'css-modules': cssModules,
+		},
+		settings: {
+      'css-modules': {
+        basePath: "app/scripts/..."
+      }
+    },
+	},
+]);
+```
+
+## Screen Shot
+
+![ScreenShot](https://raw.githubusercontent.com/bhollis/eslint-plugin-css-modules/master/screenshots/screenshot3.png)
+
+```
+   1:8   error  Unused classes found: container  css-modules/no-unused-class
+   5:17  error  Class 'containr' not found       css-modules/no-undef-class
+  10:26  error  Class 'foo' not found            css-modules/no-undef-class
+```
+
+scss:
+
+```scss
+/* .head is global, will not be used in js */
+:global(.head) {
+  color: green;
+}
+
+.container {
+  width: 116px;
+
+  i {
+    font-size: 2.2rem;
+  }
+
+  .button {
+    padding: 7px 0 0 5px;
+  }
+}
+
+.footer {
+  color: cyan;
+}
+```
+
+## With Thanks
+
+* This is forked from [`eslint-plugin-css-modules`](https://github.com/atfzl/eslint-plugin-css-modules).

package/build/core/index.js

@@ -0,0 +1,138 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { camelCase } from 'es-toolkit';
+import gonzales from 'gonzales-pe';
+import { getRegularClassesMap, getComposesClassesMap, getExtendClassesMap, getParentSelectorClassesMap, getICSSExportPropsMap, eliminateGlobals } from './traversalUtils.js';
+const styleExtensionRegex = /\.(s?css|less)$/;
+function dashesCamelCase(str) {
+  return str.replace(/-+(\w)/g, function (match, firstLetter) {
+    return firstLetter.toUpperCase();
+  });
+}
+export const getFilePath = (context, styleFilePath) => {
+  const settings = context.settings['css-modules'];
+  const dirName = path.dirname(context.getFilename());
+  const basePath = settings && settings.basePath ? settings.basePath : '';
+  return styleFilePath.startsWith('.') ? path.resolve(dirName, styleFilePath) : path.resolve(basePath, styleFilePath);
+};
+export const getPropertyName = node => {
+  const propertyName = node.computed
+  /*
+     square braces eg s['header']
+     we won't use node.property.name because it is for cases like
+     s[abc] where abc is a variable
+   */ ? node.property.value
+  /* dot notation, eg s.header */ : node.property.name;
+
+  /*
+     skip property names starting with _
+     eg. special functions provided
+     by css modules like _getCss()
+      Tried to just skip function calls, but the parser
+     thinks of normal property access like s._getCss and
+     function calls like s._getCss() as same.
+   */
+  if (!propertyName || propertyName?.toString().startsWith('_')) {
+    return null;
+  }
+  return propertyName;
+};
+export const getClassesMap = (classes, camelCaseOption) => {
+  const classesMap = {};
+
+  // Unroll the loop because of performance!
+  // Remember that this function will run on every lint (e.g.: on file save)
+  switch (camelCaseOption) {
+    case true:
+      for (const className of Object.keys(classes)) {
+        classesMap[className] = className;
+        classesMap[camelCase(className)] = className;
+      }
+      break;
+    case 'dashes':
+      for (const className of Object.keys(classes)) {
+        classesMap[className] = className;
+        classesMap[dashesCamelCase(className)] = className;
+      }
+      break;
+    case 'only':
+      for (const className of Object.keys(classes)) {
+        classesMap[camelCase(className)] = className;
+      }
+      break;
+    case 'dashes-only':
+      for (const className of Object.keys(classes)) {
+        classesMap[dashesCamelCase(className)] = className;
+      }
+      break;
+    default:
+      for (const className of Object.keys(classes)) {
+        classesMap[className] = className;
+      }
+  }
+  return classesMap;
+};
+export const getStyleImportNodeData = node => {
+  // path from which it was imported
+  const styleFilePath = node?.source?.value;
+  if (styleFilePath && styleExtensionRegex.test(styleFilePath)) {
+    const importNode = node.specifiers?.find(specifier => specifier.type === 'ImportDefaultSpecifier' || specifier.type === 'ImportNamespaceSpecifier');
+    const importName = importNode?.local?.name;
+    if (importName) {
+      // it had a default or namespace import
+      return {
+        importName,
+        styleFilePath,
+        importNode
+      };
+    }
+  }
+};
+export const fileExists = filePath => {
+  try {
+    // check if file exists
+    fs.statSync(filePath);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * @returns AST of the parsed file or null if parse failed
+ */
+export const getAST = filePath => {
+  const fileContent = fs.readFileSync(filePath);
+  const syntax = path.extname(filePath).slice(1); // remove leading .
+
+  try {
+    return gonzales.parse(fileContent.toString(), {
+      syntax
+    });
+  } catch (e) {
+    return null;
+  }
+};
+export const getStyleClasses = ast => {
+  /*
+     mutates ast by removing :global scopes
+   */
+  eliminateGlobals(ast);
+  const classesMap = getRegularClassesMap(ast);
+  const composedClassesMap = getComposesClassesMap(ast);
+  const extendClassesMap = getExtendClassesMap(ast);
+  const parentSelectorClassesMap = getParentSelectorClassesMap(ast);
+  return {
+    ...classesMap,
+    ...composedClassesMap,
+    ...extendClassesMap,
+    ...parentSelectorClassesMap
+  };
+};
+export const getExportPropsMap = ast => {
+  const exportPropsMap = getICSSExportPropsMap(ast);
+  return {
+    ...exportPropsMap
+  };
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","path","camelCase","gonzales","getRegularClassesMap","getComposesClassesMap","getExtendClassesMap","getParentSelectorClassesMap","getICSSExportPropsMap","eliminateGlobals","styleExtensionRegex","dashesCamelCase","str","replace","match","firstLetter","toUpperCase","getFilePath","context","styleFilePath","settings","dirName","dirname","getFilename","basePath","startsWith","resolve","getPropertyName","node","propertyName","computed","property","value","name","toString","getClassesMap","classes","camelCaseOption","classesMap","className","Object","keys","getStyleImportNodeData","source","test","importNode","specifiers","find","specifier","type","importName","local","fileExists","filePath","statSync","e","getAST","fileContent","readFileSync","syntax","extname","slice","parse","getStyleClasses","ast","composedClassesMap","extendClassesMap","parentSelectorClassesMap","getExportPropsMap","exportPropsMap"],"sources":["../../lib/core/index.js"],"sourcesContent":["// @flow\n\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport { camelCase } from 'es-toolkit';\nimport gonzales from 'gonzales-pe';\n\nimport type { JsNode, gASTNode } from '../types/index.js';\n\nimport {\n  getRegularClassesMap,\n  getComposesClassesMap,\n  getExtendClassesMap,\n  getParentSelectorClassesMap,\n  getICSSExportPropsMap,\n  eliminateGlobals,\n} from './traversalUtils.js';\n\nconst styleExtensionRegex = /\\.(s?css|less)$/;\n\nfunction dashesCamelCase (str: string) {\n  return str.replace(/-+(\\w)/g, function (match, firstLetter) {\n    return firstLetter.toUpperCase();\n  });\n}\n\nexport const getFilePath = (context, styleFilePath) => {\n  const settings = context.settings['css-modules'];\n\n  const dirName = path.dirname(context.getFilename());\n  const basePath = (settings && settings.basePath) ? settings.basePath : '';\n\n  return styleFilePath.startsWith('.')\n    ? path.resolve(dirName, styleFilePath)\n    : path.resolve(basePath, styleFilePath);\n};\n\nexport const getPropertyName = (node: JsNode): ?string => {\n  const propertyName = node.computed\n    /*\n       square braces eg s['header']\n       we won't use node.property.name because it is for cases like\n       s[abc] where abc is a variable\n     */\n    ? node.property.value\n    /* dot notation, eg s.header */\n    : node.property.name;\n\n  /*\n     skip property names starting with _\n     eg. special functions provided\n     by css modules like _getCss()\n\n     Tried to just skip function calls, but the parser\n     thinks of normal property access like s._getCss and\n     function calls like s._getCss() as same.\n   */\n  if (!propertyName || propertyName?.toString().startsWith('_')) {\n    return null;\n  }\n\n  return propertyName;\n};\n\nexport const getClassesMap = (classes: Object, camelCaseOption: string|boolean): Object => {\n  const classesMap = {};\n\n  // Unroll the loop because of performance!\n  // Remember that this function will run on every lint (e.g.: on file save)\n  switch (camelCaseOption) {\n    case true:\n      for (const className of Object.keys(classes)) {\n        classesMap[className] = className;\n        classesMap[camelCase(className)] = className;\n      }\n      break;\n    case 'dashes':\n      for (const className of Object.keys(classes)) {\n        classesMap[className] = className;\n        classesMap[dashesCamelCase(className)] = className;\n      }\n      break;\n    case 'only':\n      for (const className of Object.keys(classes)) {\n        classesMap[camelCase(className)] = className;\n      }\n      break;\n    case 'dashes-only':\n      for (const className of Object.keys(classes)) {\n        classesMap[dashesCamelCase(className)] = className;\n      }\n      break;\n    default:\n      for (const className of Object.keys(classes)) {\n        classesMap[className] = className;\n      }\n  }\n\n  return classesMap;\n};\n\nexport const getStyleImportNodeData = (node: JsNode): ?Object => {\n  // path from which it was imported\n  const styleFilePath = node?.source?.value;\n\n  if (styleFilePath && styleExtensionRegex.test(styleFilePath)) {\n    const importNode = node.specifiers?.find(\n      (specifier) =>\n        specifier.type === 'ImportDefaultSpecifier' || specifier.type === 'ImportNamespaceSpecifier'\n    );\n    const importName = importNode?.local?.name;\n    if (importName) {\n      // it had a default or namespace import\n      return { importName, styleFilePath, importNode };\n    }\n  }\n};\n\nexport const fileExists = (filePath: string): boolean => {\n  try {\n    // check if file exists\n    fs.statSync(filePath);\n    return true;\n  } catch (e) {\n    return false;\n  }\n};\n\n/**\n * @returns AST of the parsed file or null if parse failed\n */\nexport const getAST = (filePath: string): gASTNode | null => {\n  const fileContent = fs.readFileSync(filePath);\n\n  const syntax = path.extname(filePath).slice(1); // remove leading .\n\n  try {\n    return gonzales.parse(fileContent.toString(), { syntax });\n  } catch (e) {\n    return null;\n  }\n};\n\nexport const getStyleClasses = (ast: gASTNode): ?Object => {\n  /*\n     mutates ast by removing :global scopes\n   */\n  eliminateGlobals(ast);\n\n  const classesMap = getRegularClassesMap(ast);\n  const composedClassesMap = getComposesClassesMap(ast);\n  const extendClassesMap = getExtendClassesMap(ast);\n  const parentSelectorClassesMap = getParentSelectorClassesMap(ast);\n\n  return {\n    ...classesMap,\n    ...composedClassesMap,\n    ...extendClassesMap,\n    ...parentSelectorClassesMap\n  };\n};\n\nexport const getExportPropsMap = (ast: gASTNode): ?Object => {\n  const exportPropsMap = getICSSExportPropsMap(ast);\n  return {\n    ...exportPropsMap\n  };\n};\n"],"mappings":"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"}

package/build/core/traversalUtils.js

@@ -0,0 +1,186 @@
+/* eslint-disable no-param-reassign */
+export const getICSSExportPropsMap = ast => {
+  const ruleSets = [];
+  ast.traverseByType('ruleset', node => ruleSets.push(node));
+  return ruleSets.filter(ruleSet => {
+    const content = ruleSet.content || [];
+    return content.some(item => item.type === 'selector' && item.content?.some(selectorItem => selectorItem.type === 'pseudoClass' && selectorItem.content?.some(pseudoItem => pseudoItem.type === 'ident' && pseudoItem.content === 'export')));
+  }).reduce((result, ruleSet) => {
+    const declarations = (ruleSet.content || []).filter(item => item.type === 'block').flatMap(block => block.content || []).filter(item => item.type === 'declaration');
+    for (const declaration of declarations) {
+      const property = (declaration.content || []).find(item => item.type === 'property');
+      const propName = (property?.content || [])[0]?.content;
+      if (propName) {
+        result[propName] = propName;
+      }
+    }
+    return result;
+  }, {});
+};
+export const getRegularClassesMap = ast => {
+  const ruleSets = [];
+  ast.traverseByType('ruleset', node => ruleSets.push(node));
+  return ruleSets.reduce((result, ruleSet) => {
+    const selectors = ruleSet.content?.filter(item => item.type === 'selector') ?? [];
+    for (const selector of selectors) {
+      const classes = selector.content?.filter(item => item.type === 'class') ?? [];
+      for (const classNode of classes) {
+        const ident = classNode.content?.find(item => item.type === 'ident');
+        if (ident?.content) {
+          result[ident.content] = false;
+        }
+      }
+    }
+    return result;
+  }, {});
+};
+export const getComposesClassesMap = ast => {
+  const declarations = [];
+  ast.traverseByType('declaration', node => declarations.push(node));
+  return declarations.reduce((result, declaration) => {
+    const content = declaration.content;
+    const property = content?.find(item => item.type === 'property');
+    const hasComposes = property?.content?.some(item => item.type === 'ident' && item.content === 'composes');
+    if (!hasComposes) return result;
+    const value = content?.find(item => item.type === 'value');
+    const valueContent = value?.content;
+
+    // Reject classes composing from other files, e.g. `composes: foo from './other.css'`
+    if (valueContent?.some(item => item.type === 'ident' && item.content === 'from')) {
+      return result;
+    }
+
+    // Extract and mark composed classes
+    const composedClasses = valueContent?.filter(item => item.type === 'ident' && item.content) ?? [];
+    for (const item of composedClasses) {
+      result[item.content] = true;
+    }
+    return result;
+  }, {});
+};
+export const getExtendClassesMap = ast => {
+  const extendNodes = [];
+  ast.traverseByType('extend', node => extendNodes.push(node));
+  return extendNodes.reduce((result, extendNode) => {
+    const selector = extendNode.content?.find(item => item.type === 'selector');
+    const classNode = selector?.content?.find(item => item.type === 'class');
+    const ident = classNode?.content?.find(item => item.type === 'ident');
+    const className = ident?.content;
+    if (className) {
+      result[className] = true; // mark extend classes as true
+    }
+
+    return result;
+  }, {});
+};
+
+/**
+ * Resolves parent selectors to their full class names.
+ *
+ * E.g. `.foo { &_bar {color: blue } }` to `.foo_bar`.
+ */
+export const getParentSelectorClassesMap = ast => {
+  const classesMap = {};
+
+  // Recursively traverses down the tree looking for parent selector
+  // extensions. Recursion is necessary as these selectors can be nested.
+  const getExtensions = nodeContent => {
+    const blockContent = nodeContent.filter(item => item.type === 'block').flatMap(item => item.content || []);
+    const rulesetChildren = blockContent.filter(item => item.type === 'ruleset');
+    const rulesetDescendants = blockContent.filter(item => item.type === 'include').flatMap(item => item.content || []).filter(subItem => subItem.type === 'block').flatMap(subItem => subItem.content || []).filter(subItem => subItem.type === 'ruleset');
+    const rulesetsContent = [...rulesetChildren, ...rulesetDescendants].flatMap(item => item.content || []);
+    const extensions = rulesetsContent.filter(item => item.type === 'selector').flatMap(item => item.content || []).filter(selectorItem => selectorItem.type === 'parentSelectorExtension').flatMap(selectorItem => selectorItem.content || []).filter(identItem => identItem.type === 'ident').map(identItem => identItem.content);
+    if (!extensions.length) return [];
+    const nestedExtensions = getExtensions(rulesetsContent);
+    const result = extensions;
+    if (nestedExtensions.length) {
+      for (const nestedExt of nestedExtensions) {
+        extensions.forEach(ext => {
+          result.push(ext + nestedExt);
+        });
+      }
+    }
+    return result;
+  };
+  ast.traverseByType('ruleset', node => {
+    const classNames = (node.content || []).filter(item => item.type === 'selector').flatMap(item => item.content || []).filter(item => item.type === 'class').flatMap(item => item.content || []).filter(item => item.type === 'ident' && item.content).map(item => item.content);
+    if (!classNames.length) return;
+    const extensions = getExtensions(node.content);
+    if (!extensions.length) return;
+    classNames.forEach(className => {
+      extensions.forEach(ext => {
+        classesMap[className + ext] = false;
+      });
+
+      // Ignore the base class if it only exists for nesting parent selectors
+      const hasDeclarations = node.content?.some(item => item.type === 'block' && item.content?.some(subItem => subItem.type === 'declaration'));
+      if (!hasDeclarations) classesMap[className] = true;
+    });
+  });
+  return classesMap;
+};
+
+/**
+ * Mutates the AST by removing `:global` instances.
+ *
+ * For the AST structure:
+ * @see https://github.com/css/gonzales/blob/master/doc/AST.CSSP.en.md
+ */
+export const eliminateGlobals = ast => {
+  // Remove all :global/:global(...) in selectors
+  ast.traverseByType('selector', selectorNode => {
+    const selectorContent = selectorNode.content;
+    let hasGlobalWithNoArgs = false;
+    let i = 0;
+    let currNode = selectorContent[i];
+    while (currNode) {
+      if (currNode.is('pseudoClass')) {
+        // Remove all :global/:global(...) and trailing space
+        const identifierNode = currNode.content[0];
+        if (identifierNode && identifierNode.content === 'global') {
+          if (currNode.content.length === 1) hasGlobalWithNoArgs = true;
+          selectorNode.removeChild(i);
+          if (selectorContent[i] && selectorContent[i].is('space')) {
+            selectorNode.removeChild(i);
+          }
+        } else {
+          i++;
+        }
+      } else if (currNode.is('class') && hasGlobalWithNoArgs) {
+        // Remove all class after :global and their trailing space
+        selectorNode.removeChild(i);
+        if (selectorContent[i] && selectorContent[i].is('space')) {
+          selectorNode.removeChild(i);
+        }
+      } else {
+        i++;
+      }
+      currNode = selectorContent[i];
+    }
+  });
+
+  // Remove all ruleset with no selectors
+  ast.traverseByType('ruleset', (node, index, parent) => {
+    const rulesetContent = node.content;
+
+    // Remove empty selectors and trailing deliminator and space
+    let i = 0;
+    let currNode = rulesetContent[i];
+    while (currNode) {
+      if (currNode.is('selector') && currNode.content.length === 0) {
+        node.removeChild(i);
+        if (rulesetContent[i].is('delimiter')) node.removeChild(i);
+        if (rulesetContent[i].is('space')) node.removeChild(i);
+      } else {
+        i++;
+      }
+      currNode = rulesetContent[i];
+    }
+
+    // Remove the ruleset if no selectors
+    if (rulesetContent.filter(node => node.is('selector')).length === 0) {
+      parent.removeChild(index);
+    }
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getICSSExportPropsMap","ast","ruleSets","traverseByType","node","push","filter","ruleSet","content","some","item","type","selectorItem","pseudoItem","reduce","result","declarations","flatMap","block","declaration","property","find","propName","getRegularClassesMap","selectors","selector","classes","classNode","ident","getComposesClassesMap","hasComposes","value","valueContent","composedClasses","getExtendClassesMap","extendNodes","extendNode","className","getParentSelectorClassesMap","classesMap","getExtensions","nodeContent","blockContent","rulesetChildren","rulesetDescendants","subItem","rulesetsContent","extensions","identItem","map","length","nestedExtensions","nestedExt","forEach","ext","classNames","hasDeclarations","eliminateGlobals","selectorNode","selectorContent","hasGlobalWithNoArgs","i","currNode","is","identifierNode","removeChild","index","parent","rulesetContent"],"sources":["../../lib/core/traversalUtils.js"],"sourcesContent":["// @flow\n/* eslint-disable no-param-reassign */\n\nimport type { gASTNode } from '../types/index.js';\n\ntype classMapType = {\n  [key: string]: boolean,\n}\n\nexport const getICSSExportPropsMap = (ast: gASTNode): classMapType => {\n  const ruleSets: Array<gASTNode> = [];\n  ast.traverseByType('ruleset', node => ruleSets.push(node));\n\n  return ruleSets\n    .filter(ruleSet => {\n      const content = ruleSet.content || [];\n      return content.some(item =>\n        item.type === 'selector' &&\n        item.content?.some(selectorItem =>\n          selectorItem.type === 'pseudoClass' &&\n          selectorItem.content?.some(pseudoItem =>\n            pseudoItem.type === 'ident' && pseudoItem.content === 'export'\n          )\n        )\n      );\n    })\n    .reduce((result, ruleSet) => {\n      const declarations = (ruleSet.content || [])\n        .filter(item => item.type === 'block')\n        .flatMap(block => (block.content || []))\n        .filter(item => item.type === 'declaration');\n\n      for (const declaration of declarations) {\n        const property = (declaration.content || []).find(item => item.type === 'property');\n        const propName = (property?.content || [])[0]?.content;\n        if (propName) {\n          result[propName] = propName;\n        }\n      }\n\n      return result;\n    }, {});\n};\n\nexport const getRegularClassesMap = (ast: gASTNode): classMapType => {\n  const ruleSets: Array<gASTNode> = [];\n  ast.traverseByType('ruleset', node => ruleSets.push(node));\n\n  return ruleSets\n    .reduce((result, ruleSet) => {\n      const selectors = ruleSet.content?.filter(item => item.type === 'selector') ?? [];\n      for (const selector of selectors) {\n        const classes = selector.content?.filter(item => item.type === 'class') ?? [];\n        for (const classNode of classes) {\n          const ident = classNode.content?.find(item => item.type === 'ident');\n          if (ident?.content) {\n            result[ident.content] = false;\n          }\n        }\n      }\n      return result;\n    }, {});\n};\n\nexport const getComposesClassesMap = (ast: gASTNode): classMapType => {\n  const declarations = [];\n  ast.traverseByType('declaration', node => declarations.push(node));\n\n  return declarations\n    .reduce((result, declaration) => {\n      const content = declaration.content;\n      const property = content?.find(item => item.type === 'property');\n      const hasComposes = property?.content?.some(item =>\n        item.type === 'ident' && item.content === 'composes'\n      );\n\n      if (!hasComposes) return result;\n\n      const value = content?.find(item => item.type === 'value');\n      const valueContent = value?.content;\n\n      // Reject classes composing from other files, e.g. `composes: foo from './other.css'`\n      if (valueContent?.some(item => item.type === 'ident' && item.content === 'from')) {\n        return result;\n      }\n\n      // Extract and mark composed classes\n      const composedClasses = valueContent?.filter(item => item.type === 'ident' && item.content) ?? [];\n      for (const item of composedClasses) {\n        result[item.content] = true;\n      }\n\n      return result;\n    }, {});\n};\n\nexport const getExtendClassesMap = (ast: gASTNode): classMapType => {\n  const extendNodes = [];\n  ast.traverseByType('extend', node => extendNodes.push(node));\n\n  return extendNodes.reduce((result, extendNode) => {\n    const selector = extendNode.content?.find(item => item.type === 'selector');\n    const classNode = selector?.content?.find(item => item.type === 'class');\n    const ident = classNode?.content?.find(item => item.type === 'ident');\n    const className = ident?.content;\n\n    if (className) {\n      result[className] = true; // mark extend classes as true\n    }\n\n    return result;\n  }, {});\n};\n\n/**\n * Resolves parent selectors to their full class names.\n *\n * E.g. `.foo { &_bar {color: blue } }` to `.foo_bar`.\n */\nexport const getParentSelectorClassesMap = (ast: gASTNode): classMapType => {\n  const classesMap: classMapType = {};\n\n  // Recursively traverses down the tree looking for parent selector\n  // extensions. Recursion is necessary as these selectors can be nested.\n  const getExtensions = nodeContent => {\n    const blockContent = nodeContent\n      .filter(item => item.type === 'block')\n      .flatMap(item => item.content || []);\n\n    const rulesetChildren = blockContent.filter(item => item.type === 'ruleset');\n\n    const rulesetDescendants = blockContent\n      .filter(item => item.type === 'include')\n      .flatMap(item => item.content || [])\n      .filter(subItem => subItem.type === 'block')\n      .flatMap(subItem => subItem.content || [])\n      .filter(subItem => subItem.type === 'ruleset');\n\n    const rulesetsContent = [...rulesetChildren, ...rulesetDescendants]\n      .flatMap(item => item.content || []);\n\n    const extensions = rulesetsContent\n      .filter(item => item.type === 'selector')\n      .flatMap(item => item.content || [])\n      .filter(selectorItem => selectorItem.type === 'parentSelectorExtension')\n      .flatMap(selectorItem => selectorItem.content || [])\n      .filter(identItem => identItem.type === 'ident')\n      .map(identItem => identItem.content);\n\n    if (!extensions.length) return [];\n\n    const nestedExtensions = getExtensions(rulesetsContent);\n    const result = extensions;\n    if (nestedExtensions.length) {\n      for (const nestedExt of nestedExtensions) {\n        extensions.forEach(ext => {\n          result.push(ext + nestedExt);\n        });\n      }\n    }\n\n    return result;\n  };\n\n  ast.traverseByType('ruleset', node => {\n    const classNames = (node.content || [])\n      .filter(item => item.type === 'selector')\n      .flatMap(item => item.content || [])\n      .filter(item => item.type === 'class')\n      .flatMap(item => item.content || [])\n      .filter(item => item.type === 'ident' && item.content)\n      .map(item => item.content);\n\n    if (!classNames.length) return;\n\n    const extensions = getExtensions(node.content);\n    if (!extensions.length) return;\n\n    classNames.forEach(className => {\n      extensions.forEach(ext => {\n        classesMap[className + ext] = false;\n      });\n\n      // Ignore the base class if it only exists for nesting parent selectors\n      const hasDeclarations = node.content?.some(item => item.type === 'block' &&\n          item.content?.some(subItem => subItem.type === 'declaration'));\n      if (!hasDeclarations) classesMap[className] = true;\n    });\n  });\n\n  return classesMap;\n};\n\n/**\n * Mutates the AST by removing `:global` instances.\n *\n * For the AST structure:\n * @see https://github.com/css/gonzales/blob/master/doc/AST.CSSP.en.md\n */\nexport const eliminateGlobals = (ast: gASTNode) => {\n  // Remove all :global/:global(...) in selectors\n  ast.traverseByType('selector', (selectorNode) => {\n    const selectorContent = selectorNode.content;\n    let hasGlobalWithNoArgs = false;\n    let i = 0;\n    let currNode = selectorContent[i];\n    while (currNode) {\n      if (currNode.is('pseudoClass')) {\n        // Remove all :global/:global(...) and trailing space\n        const identifierNode = currNode.content[0];\n        if (identifierNode && identifierNode.content === 'global') {\n          if (currNode.content.length === 1) hasGlobalWithNoArgs = true;\n          selectorNode.removeChild(i);\n          if (selectorContent[i] && selectorContent[i].is('space')) {\n            selectorNode.removeChild(i);\n          }\n        } else {\n          i++;\n        }\n      } else if (currNode.is('class') && hasGlobalWithNoArgs) {\n        // Remove all class after :global and their trailing space\n        selectorNode.removeChild(i);\n        if (selectorContent[i] && selectorContent[i].is('space')) {\n          selectorNode.removeChild(i);\n        }\n      } else {\n        i++;\n      }\n\n      currNode = selectorContent[i];\n    }\n  });\n\n  // Remove all ruleset with no selectors\n  ast.traverseByType('ruleset', (node, index, parent) => {\n    const rulesetContent = node.content;\n\n    // Remove empty selectors and trailing deliminator and space\n    let i = 0;\n    let currNode = rulesetContent[i];\n    while (currNode) {\n      if (currNode.is('selector') && currNode.content.length === 0) {\n        node.removeChild(i);\n        if (rulesetContent[i].is('delimiter')) node.removeChild(i);\n        if (rulesetContent[i].is('space')) node.removeChild(i);\n      } else {\n        i++;\n      }\n      currNode = rulesetContent[i];\n    }\n\n    // Remove the ruleset if no selectors\n    if (rulesetContent.filter((node) => node.is('selector')).length === 0) {\n      parent.removeChild(index);\n    }\n  });\n};\n"],"mappings":"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"}

package/build/index.js

@@ -0,0 +1,27 @@
+import fs from 'node:fs';
+import rules from './rules/index.js';
+const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const plugin = {
+  meta: {
+    name: pkg.name,
+    version: pkg.version,
+    namespace: 'css-modules'
+  },
+  configs: {},
+  rules
+};
+Object.assign(plugin.configs, {
+  recommended: [{
+    plugins: {
+      'css-modules': plugin
+    },
+    rules: {
+      'css-modules/no-unused-class': 2,
+      // error
+      'css-modules/no-undef-class': 2 // error
+    }
+  }]
+});
+
+export default plugin;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmcyIsInJ1bGVzIiwicGtnIiwiSlNPTiIsInBhcnNlIiwicmVhZEZpbGVTeW5jIiwiVVJMIiwiaW1wb3J0IiwibWV0YSIsInVybCIsInBsdWdpbiIsIm5hbWUiLCJ2ZXJzaW9uIiwibmFtZXNwYWNlIiwiY29uZmlncyIsIk9iamVjdCIsImFzc2lnbiIsInJlY29tbWVuZGVkIiwicGx1Z2lucyJdLCJzb3VyY2VzIjpbIi4uL2xpYi9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgZnMgZnJvbSAnbm9kZTpmcyc7XG5pbXBvcnQgcnVsZXMgZnJvbSAnLi9ydWxlcy9pbmRleC5qcyc7XG5cbmNvbnN0IHBrZyA9IEpTT04ucGFyc2UoXG4gIGZzLnJlYWRGaWxlU3luYyhuZXcgVVJMKCcuLi9wYWNrYWdlLmpzb24nLCBpbXBvcnQubWV0YS51cmwpLCAndXRmOCcpLFxuKTtcblxuY29uc3QgcGx1Z2luID0ge1xuICBtZXRhOiB7XG4gICAgbmFtZTogcGtnLm5hbWUsXG4gICAgdmVyc2lvbjogcGtnLnZlcnNpb24sXG4gICAgbmFtZXNwYWNlOiAnY3NzLW1vZHVsZXMnLFxuICB9LFxuICBjb25maWdzOiB7fSxcbiAgcnVsZXMsXG59O1xuXG5PYmplY3QuYXNzaWduKHBsdWdpbi5jb25maWdzLCB7XG4gIHJlY29tbWVuZGVkOiBbXG4gICAge1xuICAgICAgcGx1Z2luczoge1xuICAgICAgICAnY3NzLW1vZHVsZXMnOiBwbHVnaW4sXG4gICAgICB9LFxuICAgICAgcnVsZXM6IHtcbiAgICAgICAgJ2Nzcy1tb2R1bGVzL25vLXVudXNlZC1jbGFzcyc6IDIsIC8vIGVycm9yXG4gICAgICAgICdjc3MtbW9kdWxlcy9uby11bmRlZi1jbGFzcyc6IDIsIC8vIGVycm9yXG4gICAgICB9LFxuICAgIH0sXG4gIF0sXG59KTtcblxuZXhwb3J0IGRlZmF1bHQgcGx1Z2luO1xuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPQSxFQUFFLE1BQU0sU0FBUztBQUN4QixPQUFPQyxLQUFLLE1BQU0sa0JBQWtCO0FBRXBDLE1BQU1DLEdBQUcsR0FBR0MsSUFBSSxDQUFDQyxLQUFLLENBQ3BCSixFQUFFLENBQUNLLFlBQVksQ0FBQyxJQUFJQyxHQUFHLENBQUMsaUJBQWlCLEVBQUVDLE1BQU0sQ0FBQ0MsSUFBSSxDQUFDQyxHQUFHLENBQUMsRUFBRSxNQUFNLENBQ3JFLENBQUM7QUFFRCxNQUFNQyxNQUFNLEdBQUc7RUFDYkYsSUFBSSxFQUFFO0lBQ0pHLElBQUksRUFBRVQsR0FBRyxDQUFDUyxJQUFJO0lBQ2RDLE9BQU8sRUFBRVYsR0FBRyxDQUFDVSxPQUFPO0lBQ3BCQyxTQUFTLEVBQUU7RUFDYixDQUFDO0VBQ0RDLE9BQU8sRUFBRSxDQUFDLENBQUM7RUFDWGI7QUFDRixDQUFDO0FBRURjLE1BQU0sQ0FBQ0MsTUFBTSxDQUFDTixNQUFNLENBQUNJLE9BQU8sRUFBRTtFQUM1QkcsV0FBVyxFQUFFLENBQ1g7SUFDRUMsT0FBTyxFQUFFO01BQ1AsYUFBYSxFQUFFUjtJQUNqQixDQUFDO0lBQ0RULEtBQUssRUFBRTtNQUNMLDZCQUE2QixFQUFFLENBQUM7TUFBRTtNQUNsQyw0QkFBNEIsRUFBRSxDQUFDLENBQUU7SUFDbkM7RUFDRixDQUFDO0FBRUwsQ0FBQyxDQUFDOztBQUVGLGVBQWVTLE1BQU0ifQ==

package/build/rules/index.js

@@ -0,0 +1,7 @@
+import noUnusedClass from './no-unused-class.js';
+import noUndefClass from './no-undef-class.js';
+export default {
+  'no-unused-class': noUnusedClass,
+  'no-undef-class': noUndefClass
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJub1VudXNlZENsYXNzIiwibm9VbmRlZkNsYXNzIl0sInNvdXJjZXMiOlsiLi4vLi4vbGliL3J1bGVzL2luZGV4LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBub1VudXNlZENsYXNzIGZyb20gJy4vbm8tdW51c2VkLWNsYXNzLmpzJztcbmltcG9ydCBub1VuZGVmQ2xhc3MgZnJvbSAnLi9uby11bmRlZi1jbGFzcy5qcyc7XG5cbmV4cG9ydCBkZWZhdWx0IHtcbiAgJ25vLXVudXNlZC1jbGFzcyc6IG5vVW51c2VkQ2xhc3MsXG4gICduby11bmRlZi1jbGFzcyc6IG5vVW5kZWZDbGFzcyxcbn07XG4iXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLGFBQWEsTUFBTSxzQkFBc0I7QUFDaEQsT0FBT0MsWUFBWSxNQUFNLHFCQUFxQjtBQUU5QyxlQUFlO0VBQ2IsaUJBQWlCLEVBQUVELGFBQWE7RUFDaEMsZ0JBQWdCLEVBQUVDO0FBQ3BCLENBQUMifQ==

package/build/rules/no-undef-class.js

@@ -0,0 +1,86 @@
+import { getStyleImportNodeData, getAST, fileExists, getStyleClasses, getPropertyName, getClassesMap, getExportPropsMap, getFilePath } from '../core/index.js';
+export default {
+  meta: {
+    docs: {
+      description: 'Checks that you are using the existent css/scss/less classes',
+      recommended: true
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        camelCase: {
+          enum: [true, 'dashes', 'only', 'dashes-only']
+        }
+      }
+    }]
+  },
+  create(context) {
+    const camelCase = context?.options[0]?.camelCase;
+
+    /*
+       maps variable name to property Object
+       map = {
+         [variableName]: {
+           classesMap: { foo: 'foo', fooBar: 'foo-bar', 'foo-bar': 'foo-bar' },
+           node: {...}
+         }
+       }
+        example:
+       import s from './foo.scss';
+       s is variable name
+        property Object has two keys
+       1. classesMap: an object with propertyName as key and its className as value
+       2. node: node that correspond to s (see example above)
+     */
+    const map = {};
+    return {
+      ImportDeclaration(node) {
+        const styleImportNodeData = getStyleImportNodeData(node);
+        if (!styleImportNodeData) {
+          return;
+        }
+        const {
+          importName,
+          styleFilePath,
+          importNode
+        } = styleImportNodeData;
+        const styleFileAbsolutePath = getFilePath(context, styleFilePath);
+        let classesMap = {};
+        let exportPropsMap = {};
+        if (fileExists(styleFileAbsolutePath)) {
+          const ast = getAST(styleFileAbsolutePath);
+          const classes = ast && getStyleClasses(ast);
+          classesMap = classes && getClassesMap(classes, camelCase);
+          exportPropsMap = ast && getExportPropsMap(ast);
+        }
+        map[importName] ??= {};
+
+        // this will be used to check if classes are defined
+        map[importName].classesMap = classesMap;
+
+        // this will be used to check if :export properties are defined
+        map[importName].exportPropsMap = exportPropsMap;
+
+        // save node for reporting unused styles
+        map[importName].node = importNode;
+      },
+      MemberExpression: node => {
+        /*
+           Check if property exists in css/scss file as class
+         */
+
+        const objectName = node.object.name;
+        const propertyName = getPropertyName(node, camelCase);
+        if (!propertyName) {
+          return;
+        }
+        const classesMap = map[objectName]?.classesMap;
+        const exportPropsMap = map[objectName]?.exportPropsMap;
+        if (classesMap && classesMap[propertyName] == null && exportPropsMap && exportPropsMap[propertyName] == null) {
+          context.report(node.property, `Class or exported property '${propertyName}' not found`);
+        }
+      }
+    };
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/rules/no-unused-class.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import { getStyleImportNodeData, getStyleClasses, getPropertyName, getClassesMap, getFilePath, getAST, fileExists } from '../core/index.js';
+export default {
+  meta: {
+    docs: {
+      description: 'Checks that you are using all css/scss/less classes',
+      recommended: true
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        camelCase: {
+          enum: [true, 'dashes', 'only', 'dashes-only']
+        },
+        markAsUsed: {
+          type: 'array'
+        }
+      }
+    }]
+  },
+  create(context) {
+    const markAsUsed = context?.options?.[0]?.markAsUsed;
+    const camelCase = context?.options?.[0]?.camelCase;
+
+    /*
+       maps variable name to property Object
+       map = {
+         [variableName]: {
+           classes: { foo: false, 'foo-bar': false },
+           classesMap: { foo: 'foo', fooBar: 'foo-bar', 'foo-bar': 'foo-bar' },
+           node: {...}
+         }
+       }
+        example:
+       import s from './foo.scss';
+       s is variable name
+        property Object has two keys
+       1. classes: an object with className as key and a boolean as value. The boolean is marked if it is used in file
+       2. classesMap: an object with propertyName as key and its className as value
+       3. node: node that correspond to s (see example above)
+     */
+    const map = {};
+    return {
+      ImportDeclaration(node) {
+        const styleImportNodeData = getStyleImportNodeData(node);
+        if (!styleImportNodeData) {
+          return;
+        }
+        const {
+          importName,
+          styleFilePath,
+          importNode
+        } = styleImportNodeData;
+        const styleFileAbsolutePath = getFilePath(context, styleFilePath);
+        let classes = {};
+        let classesMap = {};
+        if (fileExists(styleFileAbsolutePath)) {
+          // this will be used to mark s.foo as used in MemberExpression
+          const ast = getAST(styleFileAbsolutePath);
+          classes = ast && getStyleClasses(ast);
+          classesMap = classes && getClassesMap(classes, camelCase);
+        }
+        map[importName] ??= {};
+        map[importName].classes = classes;
+        map[importName].classesMap = classesMap;
+
+        // save node for reporting unused styles
+        map[importName].node = importNode;
+
+        // save file path for reporting unused styles
+        map[importName].filePath = styleFilePath;
+      },
+      MemberExpression: node => {
+        /*
+           Check if property exists in css/scss file as class
+         */
+
+        const objectName = node.object.name;
+        const propertyName = getPropertyName(node, camelCase);
+        if (!propertyName) {
+          return;
+        }
+        const className = map[objectName]?.classesMap?.[propertyName];
+        if (className == null) {
+          return;
+        }
+
+        // mark this property has used
+        (map[objectName] ??= {
+          classes: {}
+        }).classes[className] = true;
+      },
+      'Program:exit'() {
+        /*
+           Check if all classes defined in css/scss file are used
+         */
+
+        /*
+           we are looping over each import style node in program
+           example:
+           ```
+             import s from './foo.css';
+             import x from './bar.scss';
+           ```
+           then the loop will be run 2 times
+         */
+        for (const o of Object.values(map)) {
+          const {
+            classes,
+            node,
+            filePath
+          } = o;
+
+          /*
+             if option is passed to mark a class as used, example:
+             eslint css-modules/no-unused-class: [2, { markAsUsed: ['container'] }]
+           */
+          for (const usedClass of markAsUsed ?? []) {
+            classes[usedClass] = true;
+          }
+
+          // classNames not marked as true are unused
+          const unusedClasses = classes ? Object.entries(classes).filter(([_k, v]) => !v).map(([k, _v]) => k) : [];
+          if (unusedClasses.length > 0) {
+            context.report(node, `Unused classes found in ${path.basename(filePath)}: ${unusedClasses.join(', ')}`);
+          }
+        }
+      }
+    };
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["path","getStyleImportNodeData","getStyleClasses","getPropertyName","getClassesMap","getFilePath","getAST","fileExists","meta","docs","description","recommended","schema","type","properties","camelCase","enum","markAsUsed","create","context","options","map","ImportDeclaration","node","styleImportNodeData","importName","styleFilePath","importNode","styleFileAbsolutePath","classes","classesMap","ast","filePath","MemberExpression","objectName","object","name","propertyName","className","Program:exit","o","Object","values","usedClass","unusedClasses","entries","filter","_k","v","k","_v","length","report","basename","join"],"sources":["../../lib/rules/no-unused-class.js"],"sourcesContent":["/* @flow */\nimport path from 'node:path';\n\nimport {\n  getStyleImportNodeData,\n  getStyleClasses,\n  getPropertyName,\n  getClassesMap,\n  getFilePath,\n  getAST,\n  fileExists,\n} from '../core/index.js';\n\nimport type { JsNode } from '../types/index.js';\n\nexport default {\n  meta: {\n    docs: {\n      description: 'Checks that you are using all css/scss/less classes',\n      recommended: true,\n    },\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          camelCase: { enum: [true, 'dashes', 'only', 'dashes-only'] },\n          markAsUsed: { type: 'array' },\n        },\n      }\n    ],\n  },\n  create (context: Object) {\n    const markAsUsed = context?.options?.[0]?.markAsUsed;\n    const camelCase = context?.options?.[0]?.camelCase;\n\n    /*\n       maps variable name to property Object\n       map = {\n         [variableName]: {\n           classes: { foo: false, 'foo-bar': false },\n           classesMap: { foo: 'foo', fooBar: 'foo-bar', 'foo-bar': 'foo-bar' },\n           node: {...}\n         }\n       }\n\n       example:\n       import s from './foo.scss';\n       s is variable name\n\n       property Object has two keys\n       1. classes: an object with className as key and a boolean as value. The boolean is marked if it is used in file\n       2. classesMap: an object with propertyName as key and its className as value\n       3. node: node that correspond to s (see example above)\n     */\n    const map = {};\n\n    return {\n      ImportDeclaration (node: JsNode) {\n        const styleImportNodeData = getStyleImportNodeData(node);\n\n        if (!styleImportNodeData) {\n          return;\n        }\n\n        const {\n          importName,\n          styleFilePath,\n          importNode,\n        } = styleImportNodeData;\n\n        const styleFileAbsolutePath = getFilePath(context, styleFilePath);\n\n        let classes = {};\n        let classesMap = {};\n\n        if (fileExists(styleFileAbsolutePath)) {\n          // this will be used to mark s.foo as used in MemberExpression\n          const ast = getAST(styleFileAbsolutePath);\n          classes = ast && getStyleClasses(ast);\n          classesMap = classes && getClassesMap(classes, camelCase);\n        }\n\n        map[importName] ??= {};\n\n        map[importName].classes = classes;\n        map[importName].classesMap = classesMap;\n\n        // save node for reporting unused styles\n        map[importName].node = importNode;\n\n        // save file path for reporting unused styles\n        map[importName].filePath = styleFilePath;\n      },\n      MemberExpression: (node: JsNode) => {\n        /*\n           Check if property exists in css/scss file as class\n         */\n\n        const objectName = node.object.name;\n        const propertyName = getPropertyName(node, camelCase);\n\n        if (!propertyName) {\n          return;\n        }\n\n        const className = map[objectName]?.classesMap?.[propertyName];\n\n        if (className == null) {\n          return;\n        }\n\n        // mark this property has used\n        (map[objectName] ??= { classes: {} }).classes[className] = true;\n      },\n      'Program:exit' () {\n        /*\n           Check if all classes defined in css/scss file are used\n         */\n\n        /*\n           we are looping over each import style node in program\n           example:\n           ```\n             import s from './foo.css';\n             import x from './bar.scss';\n           ```\n           then the loop will be run 2 times\n         */\n        for (const o of Object.values(map)) {\n          const { classes, node, filePath } = o;\n\n          /*\n             if option is passed to mark a class as used, example:\n             eslint css-modules/no-unused-class: [2, { markAsUsed: ['container'] }]\n           */\n          for (const usedClass of markAsUsed ?? []) {\n            classes[usedClass] = true;\n          }\n\n          // classNames not marked as true are unused\n          const unusedClasses = classes ? Object.entries(classes).filter(([_k, v]) => !v).map(([k, _v]) => k) : [];\n\n          if (unusedClasses.length > 0) {\n            context.report(node, `Unused classes found in ${path.basename(filePath)}: ${unusedClasses.join(', ')}`);\n          }\n        }\n      }\n    };\n  }\n};\n"],"mappings":"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"}

package/build/types/index.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vbGliL3R5cGVzL2luZGV4LmpzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIGpzIE5vZGVcbmV4cG9ydCB0eXBlIFBvc2l0aW9uID0ge1xuICBsaW5lOiBudW1iZXIsIC8vIDEgaW5kZXhlZFxuICBjb2x1bW46IG51bWJlciwgLy8gMCBpbmRleGVkXG59O1xuXG5leHBvcnQgdHlwZSBTb3VyY2VMb2NhdGlvbiA9IHtcbiAgc3RhcnQ6IFBvc2l0aW9uLFxuICBlbmQ6IFBvc2l0aW9uLFxuICBpZGVudGlmaWVyTmFtZT86IHN0cmluZyxcbn07XG5cbmV4cG9ydCB0eXBlIEpzTm9kZSA9IHtcbiAgdHlwZTogJ0ltcG9ydERlY2xhcmF0aW9uJyB8ICdJbXBvcnREZWZhdWx0U3BlY2lmaWVyJyxcbiAgc3RhcnQ6IG51bWJlcixcbiAgZW5kOiBudW1iZXIsXG4gIGxvYzogSnNOb2RlLFxuICBsb2NhbD86IEpzTm9kZSxcbiAgbmFtZT86IHN0cmluZyxcbiAgdmFsdWU/OiBzdHJpbmcsXG4gIHNwZWNpZmllcnM/OiBBcnJheTxKc05vZGU+LFxuICBpbXBvcnRLaW5kPzogJ3ZhbHVlJyxcbiAgZXh0cmE/OiB7XG4gICAgcmF3VmFsdWU6IHN0cmluZyxcbiAgICByYXc6IHN0cmluZyxcbiAgfSxcbiAgc291cmNlOiBKc05vZGUsXG4gIHJhbmdlOiBBcnJheTxudW1iZXI+LCAvLyBtb3N0IHByb2JhYmx5IGFycmF5IG9mIDIgbnVtYmVycyA/LFxuICBfYmFiZWxUeXBlOiBzdHJpbmcsXG4gIHBhcmVudDogSnNOb2RlLFxufTtcblxuLy8gZ29uemFsZXMgQVNUIE5vZGUgVHlwZVxuZXhwb3J0IHR5cGUgZ0FTVE5vZGUgPSB7XG4gIHRyYXZlcnNlQnlUeXBlOiBGdW5jdGlvbixcblxuICB0eXBlOiAnc3R5bGVzaGVldCdcbiAgICAgIHwgJ2lkZW50J1xuICAgICAgfCAnY2xhc3MnXG4gICAgICB8ICdzZWxlY3RvcidcbiAgICAgIHwgJ3ZhbHVlJ1xuICAgICAgfCAncHJvcGVydHknXG4gICAgICB8ICdydWxlc2V0J1xuICAgICAgfCAnZXh0ZW5kJ1xuICAgICAgfCAnZGVjbGFyYXRpb24nLFxuICBjb250ZW50OiBzdHJpbmcgfCBBcnJheTxnQVNUTm9kZT4sXG4gIHN5bnRheDogJ2NzcycgfCAnc2NzcycgfCAnbGVzcycsXG59O1xuIl0sIm1hcHBpbmdzIjoiIn0=

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@bhollis/eslint-plugin-css-modules",
+  "version": "1.0.0",
+  "description": "Checks that you are using the existent css/scss/less classes, no more no less",
+  "main": "build/index.js",
+  "files": [
+    "build",
+    "packages"
+  ],
+  "type": "module",
+  "scripts": {
+    "watch": "babel lib -d build --watch",
+    "build": "rm -rf build && babel lib -d build",
+    "lint": "eslint lib test",
+    "test": "npm run build && rm -rf test-out && babel test -d test-out && cp -r test/files test-out/ && node --test test-out/**/*.test.js",
+    "my-pre-publish": "npm run test && npm run build",
+    "my-publish": "npm run my-pre-publish && yarn publish"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "css-modules"
+  ],
+  "author": {
+    "name": "Atif Afzal",
+    "email": "atif5801@gmail.com",
+    "url": "http://atfzl.me"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/bhollis/eslint-plugin-css-modules.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/bhollis/eslint-plugin-css-modules/issues"
+  },
+  "homepage": "https://github.com/bhollis/eslint-plugin-css-modules#readme",
+  "peerDependencies": {
+    "eslint": ">=2.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.23.0",
+    "@babel/core": "^7.23.0",
+    "@babel/eslint-parser": "^7.22.15",
+    "@babel/plugin-proposal-export-default-from": "^7.22.17",
+    "@babel/plugin-syntax-flow": "^7.22.5",
+    "@babel/plugin-transform-flow-strip-types": "^7.22.5",
+    "@babel/preset-env": "^7.22.20",
+    "@babel/register": "^7.22.15",
+    "eslint": "^8.50.0",
+    "eslint-config-standard": "^17.1.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-n": "^16.1.0",
+    "eslint-plugin-promise": "^6.1.1",
+    "flow-bin": "^0.36.0",
+    "nodemon": "^3.0.1"
+  },
+  "dependencies": {
+    "es-toolkit": "^1.42.0",
+    "gonzales-pe": "^4.3.0"
+  }
+}