@dvukovic/style-guide 0.18.1 → 0.19.1

package/dist/stylelint/rules/no-unused-selectors/no-unused-selectors.d.ts

@@ -0,0 +1,3 @@
+declare const _default: stylelint.Plugin;
+export default _default;
+import stylelint from "stylelint";

package/dist/stylelint/rules/no-unused-selectors/no-unused-selectors.types.d.ts

@@ -0,0 +1,13 @@
+export type TemplateVariablesType = {
+    cssBaseName: string;
+    cssDirectory: string;
+    cssDirectoryName: string;
+    cssName: string;
+};
+export type ResolvedDocumentType = {
+    content: string;
+    path: string;
+};
+export type SecondaryOptionsType = {
+    documents?: string[];
+};

package/dist/stylelint/rules/no-unused-selectors/no-unused-selectors.utils.d.ts

@@ -0,0 +1,26 @@
+export const DEFAULT_DOCUMENT_TEMPLATES: string[];
+/**
+ * @param {string} sourceContent
+ * @param {string} filePath
+ * @returns {Set<string>}
+ */
+export function extractClassReferences(sourceContent: string, filePath: string): Set<string>;
+/**
+ * @param {string} resolvedSelector
+ * @returns {{ type: "class" | "id"; value: string } | null}
+ */
+export function extractSimpleSelector(resolvedSelector: string): {
+    type: "class" | "id";
+    value: string;
+} | null;
+/**
+ * @param {string[]} documentPaths
+ * @returns {import("./no-unused-selectors.types.ts").ResolvedDocumentType[]}
+ */
+export function resolveAllDocuments(documentPaths: string[]): import("./no-unused-selectors.types.ts").ResolvedDocumentType[];
+/**
+ * @param {string} cssPath
+ * @param {string[]} templates
+ * @returns {string[]}
+ */
+export function resolveDocumentPaths(cssPath: string, templates: string[]): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dvukovic/style-guide",
-    "version": "0.18.1",
+    "version": "0.19.1",
     "description": "My own style guide",
     "repository": {
         "type": "git",
@@ -68,7 +68,7 @@
         "@stylistic/eslint-plugin": "5.7.1",
         "@tanstack/eslint-plugin-query": "5.91.4",
         "@typescript-eslint/parser": "8.53.1",
-        "@vitest/eslint-plugin": "1.6.6",
+        "@vitest/eslint-plugin": "1.6.9",
         "eslint-plugin-baseline-js": "0.4.2",
         "eslint-plugin-import-x": "4.16.1",
         "eslint-plugin-jest": "29.12.1",
@@ -91,6 +91,8 @@
         "eslint-plugin-unused-imports": "4.3.0",
         "globals": "17.1.0",
         "jsonc-eslint-parser": "2.4.2",
+        "postcss-resolve-nested-selector": "0.1.6",
+        "postcss-selector-parser": "7.1.1",
         "prettier-plugin-embed": "0.5.1",
         "prettier-plugin-jsdoc": "1.8.0",
         "prettier-plugin-packagejson": "3.0.0",
@@ -99,7 +101,6 @@
         "prettier-plugin-sql": "0.19.2",
         "prettier-plugin-tailwindcss": "0.7.2",
         "prettier-plugin-toml": "2.0.6",
-        "stylelint-no-unused-selectors": "1.0.40",
         "stylelint-order": "7.0.1",
         "typescript-eslint": "8.53.1"
     },
@@ -123,7 +124,8 @@
         "eslint": "^9",
         "knip": "5",
         "prettier": "3",
-        "stylelint": "16"
+        "stylelint": "16",
+        "typescript": "5"
     },
     "peerDependenciesMeta": {
         "cspell": {
@@ -140,9 +142,12 @@
         },
         "stylelint": {
             "optional": true
+        },
+        "typescript": {
+            "optional": true
         }
     },
-    "packageManager": "yarn@4.12.0",
+    "packageManager": "yarn@4.13.0",
     "engines": {
         "node": ">=24.0.0"
     },

package/src/stylelint/configs/core.js

@@ -1,12 +1,12 @@
-import stylelintNoUnusedSelectors from "../plugins/no-unused-selectors.js"
 import stylelintOrder from "../plugins/order.js"
 import stylelint from "../plugins/stylelint.js"
+import noUnusedSelectors from "../rules/no-unused-selectors/no-unused-selectors.js"
 
 /** @type {import("stylelint").Config} */
 const config = {
     allowEmptyInput: true,
     defaultSeverity: "error",
-    plugins: ["stylelint-order", "stylelint-no-unused-selectors"],
+    plugins: ["stylelint-order", noUnusedSelectors],
     reportDescriptionlessDisables: true,
     reportInvalidScopeDisables: true,
     reportNeedlessDisables: true,
@@ -14,7 +14,7 @@ const config = {
     rules: {
         ...stylelint.rules,
         ...stylelintOrder.rules,
-        ...stylelintNoUnusedSelectors.rules,
+        "dvukovic/no-unused-selectors": true,
     },
 }
 

package/src/stylelint/rules/no-unused-selectors/fixtures/basic/Component.tsx

@@ -0,0 +1,5 @@
+import styles from "./Component.module.css"
+
+export function Component() {
+    return <div className={styles.used}>Hello</div>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/bracket-access/Dynamic.tsx

@@ -0,0 +1,5 @@
+import styles from "./Dynamic.module.css"
+
+export function Dynamic() {
+    return <div className={styles["bracket-class"]}>Hello</div>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/class-name-attribute/Static.tsx

@@ -0,0 +1,3 @@
+export function Static() {
+    return <div className="foo bar">Hello</div>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/compound-selectors/Layout.tsx

@@ -0,0 +1,9 @@
+import styles from "./Layout.module.css"
+
+export function Layout() {
+    return (
+        <div className={styles.parent}>
+            <div className={styles.child}>Content</div>
+        </div>
+    )
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/cva-pattern/Card.tsx

@@ -0,0 +1,6 @@
+import styles from "./Card.module.css"
+import { cardVariants } from "./Card.variants"
+
+export function Card({ size }) {
+    return <div className={cardVariants({ size })}>{styles.header}</div>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/cva-pattern/Card.variants.ts

@@ -0,0 +1,12 @@
+import { cva } from "class-variance-authority"
+
+import styles from "./Card.module.css"
+
+export const cardVariants = cva(styles.cardBase, {
+    variants: {
+        size: {
+            large: styles.cardLarge,
+            small: styles.cardSmall,
+        },
+    },
+})

package/src/stylelint/rules/no-unused-selectors/fixtures/id-attribute/Panel.tsx

@@ -0,0 +1,3 @@
+export function Panel() {
+    return <div id="panel">Hello</div>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/multi-document/Button.tsx

@@ -0,0 +1,6 @@
+import styles from "./Button.module.css"
+import { buttonVariants } from "./Button.variants"
+
+export function Button({ variant }) {
+    return <button className={buttonVariants({ variant })}>{styles.base}</button>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/multi-document/Button.variants.ts

@@ -0,0 +1,12 @@
+import { cva } from "class-variance-authority"
+
+import styles from "./Button.module.css"
+
+export const buttonVariants = cva(styles.variant, {
+    variants: {
+        size: {
+            large: styles.large,
+            small: styles.small,
+        },
+    },
+})

package/src/stylelint/rules/no-unused-selectors/fixtures/pseudo-classes/Link.tsx

@@ -0,0 +1,5 @@
+import styles from "./Link.module.css"
+
+export function Link() {
+    return <a className={styles.link}>Click me</a>
+}

package/src/stylelint/rules/no-unused-selectors/fixtures/utility-libraries/Widget.tsx

@@ -0,0 +1,5 @@
+import clsx from "clsx"
+
+export function Widget({ active }) {
+    return <div className={clsx("foo", "bar", { baz: active })}>Hello</div>
+}

package/src/stylelint/rules/no-unused-selectors/no-unused-selectors.js

@@ -0,0 +1,125 @@
+import resolveNestedSelector from "postcss-resolve-nested-selector"
+import stylelint from "stylelint"
+
+import {
+    DEFAULT_DOCUMENT_TEMPLATES,
+    extractClassReferences,
+    extractSimpleSelector,
+    resolveAllDocuments,
+    resolveDocumentPaths,
+} from "./no-unused-selectors.utils.js"
+
+const ruleName = "dvukovic/no-unused-selectors"
+
+const messages = stylelint.utils.ruleMessages(ruleName, {
+    rejected: (selector) => {
+        return `Selector "${selector}" is not used in any document`
+    },
+})
+
+const meta = {
+    fixable: false,
+    url: "https://github.com/vuki656/style-guide",
+}
+
+function isInsideKeyframes(ruleNode) {
+    const parent = ruleNode.parent
+
+    if (parent?.type !== "atrule") {
+        return false
+    }
+
+    return parent.name === "keyframes"
+}
+
+/**
+ * @type {import("stylelint").Rule<
+ *     boolean,
+ *     import("./no-unused-selectors.types.ts").SecondaryOptionsType
+ * >}
+ */
+const ruleFunction = (primaryOption, secondaryOptions) => {
+    return (root, result) => {
+        const validOptions = stylelint.utils.validateOptions(
+            result,
+            ruleName,
+            {
+                actual: primaryOption,
+                possible: [true, false],
+            },
+            {
+                actual: secondaryOptions,
+                optional: true,
+                possible: {
+                    documents: [
+                        (value) => {
+                            return typeof value === "string"
+                        },
+                    ],
+                },
+            },
+        )
+
+        if (!validOptions || !primaryOption) {
+            return
+        }
+
+        const cssFilePath = root.source?.input?.file
+
+        if (!cssFilePath) {
+            return
+        }
+
+        const templates = secondaryOptions?.documents ?? DEFAULT_DOCUMENT_TEMPLATES
+        const documentPaths = resolveDocumentPaths(cssFilePath, templates)
+        const documents = resolveAllDocuments(documentPaths)
+
+        if (documents.length === 0) {
+            return
+        }
+
+        const allReferences = new Set()
+
+        for (const document of documents) {
+            const documentReferences = extractClassReferences(document.content, document.path)
+
+            for (const reference of documentReferences) {
+                allReferences.add(reference)
+            }
+        }
+
+        root.walkRules((ruleNode) => {
+            if (isInsideKeyframes(ruleNode)) {
+                return
+            }
+
+            const resolvedSelectors = resolveNestedSelector(ruleNode.selector, ruleNode)
+
+            for (const resolvedSelector of resolvedSelectors) {
+                const simpleSelector = extractSimpleSelector(resolvedSelector)
+
+                if (!simpleSelector) {
+                    continue
+                }
+
+                if (allReferences.has(simpleSelector.value)) {
+                    continue
+                }
+
+                stylelint.utils.report({
+                    message: messages.rejected(simpleSelector.value),
+                    node: ruleNode,
+                    result,
+                    ruleName,
+                    word: ruleNode.selector,
+                })
+            }
+        })
+    }
+}
+
+ruleFunction.ruleName = ruleName
+ruleFunction.messages = messages
+ruleFunction.meta = meta
+
+export default stylelint.createPlugin(ruleName, ruleFunction)

package/src/stylelint/rules/no-unused-selectors/no-unused-selectors.types.ts

@@ -0,0 +1,15 @@
+export type TemplateVariablesType = {
+    cssBaseName: string
+    cssDirectory: string
+    cssDirectoryName: string
+    cssName: string
+}
+
+export type ResolvedDocumentType = {
+    content: string
+    path: string
+}
+
+export type SecondaryOptionsType = {
+    documents?: string[]
+}

package/src/stylelint/rules/no-unused-selectors/no-unused-selectors.utils.js

@@ -0,0 +1,528 @@
+import fs from "node:fs"
+import { createRequire } from "node:module"
+import path from "node:path"
+
+import selectorParser from "postcss-selector-parser"
+
+const require = createRequire(import.meta.url)
+
+let typescriptModule = null
+
+function getTypeScript() {
+    if (typescriptModule) {
+        return typescriptModule
+    }
+
+    try {
+        typescriptModule = require("typescript")
+    } catch {
+        return null
+    }
+
+    return typescriptModule
+}
+
+const NON_STRUCTURAL_PSEUDO_CLASSES = new Set([
+    "active",
+    "any-link",
+    "autofill",
+    "checked",
+    "default",
+    "defined",
+    "disabled",
+    "enabled",
+    "focus",
+    "focus-visible",
+    "focus-within",
+    "fullscreen",
+    "hover",
+    "in-range",
+    "indeterminate",
+    "invalid",
+    "link",
+    "modal",
+    "optional",
+    "out-of-range",
+    "placeholder-shown",
+    "read-only",
+    "read-write",
+    "required",
+    "target",
+    "valid",
+    "visited",
+])
+
+const NON_STRUCTURAL_PSEUDO_ELEMENTS = new Set([
+    "after",
+    "backdrop",
+    "before",
+    "cue",
+    "file-selector-button",
+    "first-letter",
+    "first-line",
+    "marker",
+    "placeholder",
+    "selection",
+])
+
+const UTILITY_LIBRARY_IMPORTS = new Set(["class-variance-authority", "classnames", "clsx"])
+
+const UTILITY_FUNCTION_NAMES = new Set(["cn", "classnames", "clsx", "cva", "cx"])
+
+const DEFAULT_DOCUMENT_TEMPLATES = [
+    "{cssDirectory}/{cssBaseName}.variants.ts",
+    "{cssDirectory}/{cssBaseName}.variants.tsx",
+    "{cssDirectory}/{cssBaseName}.tsx",
+    "{cssDirectory}/{cssBaseName}.jsx",
+    "{cssDirectory}/{cssDirectoryName}.tsx",
+    "{cssDirectory}/{cssDirectoryName}.jsx",
+    "{cssDirectory}/index.tsx",
+    "{cssDirectory}/index.jsx",
+]
+
+function addClassReference(references, name) {
+    references.add(`.${name}`)
+}
+
+function addClassReferencesFromString(references, text) {
+    const classNames = text.split(/\s+/).filter(Boolean)
+
+    for (const className of classNames) {
+        addClassReference(references, className)
+    }
+}
+
+function getCallArguments(callExpression) {
+    return [...callExpression.arguments] // eslint-disable-line baseline-js/use-baseline -- TS AST node property, not Function.arguments
+}
+
+function collectCssModuleImports(node, cssModuleIdentifiers) {
+    const ts = typescriptModule
+
+    if (!ts.isImportDeclaration(node)) {
+        return
+    }
+
+    const moduleSpecifier = node.moduleSpecifier
+
+    if (!ts.isStringLiteral(moduleSpecifier)) {
+        return
+    }
+
+    if (!moduleSpecifier.text.endsWith(".module.css")) {
+        return
+    }
+
+    const importClause = node.importClause
+
+    if (!importClause?.name) {
+        return
+    }
+
+    cssModuleIdentifiers.add(importClause.name.text)
+}
+
+function collectUtilityImports(node, utilityFunctionIdentifiers) {
+    const ts = typescriptModule
+
+    if (!ts.isImportDeclaration(node)) {
+        return
+    }
+
+    const moduleSpecifier = node.moduleSpecifier
+
+    if (!ts.isStringLiteral(moduleSpecifier)) {
+        return
+    }
+
+    const source = moduleSpecifier.text
+    const isKnownLibrary = UTILITY_LIBRARY_IMPORTS.has(source)
+    const importClause = node.importClause
+
+    if (!importClause) {
+        return
+    }
+
+    if (isKnownLibrary && importClause.name) {
+        utilityFunctionIdentifiers.add(importClause.name.text)
+    }
+
+    const namedBindings = importClause.namedBindings
+
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return
+    }
+
+    for (const specifier of namedBindings.elements) {
+        const localName = specifier.name.text
+        const importedName = specifier.propertyName?.text ?? localName
+
+        if (isKnownLibrary && UTILITY_FUNCTION_NAMES.has(importedName)) {
+            utilityFunctionIdentifiers.add(localName)
+        }
+
+        if (!isKnownLibrary && UTILITY_FUNCTION_NAMES.has(localName)) {
+            utilityFunctionIdentifiers.add(localName)
+        }
+    }
+}
+
+function collectPropertyAccessReferences(node, context) {
+    const ts = typescriptModule
+
+    if (!ts.isPropertyAccessExpression(node)) {
+        return
+    }
+
+    const expression = node.expression
+
+    if (!ts.isIdentifier(expression)) {
+        return
+    }
+
+    if (!context.cssModuleIdentifiers.has(expression.text)) {
+        return
+    }
+
+    addClassReference(context.references, node.name.text)
+}
+
+function collectBracketAccessReferences(node, context) {
+    const ts = typescriptModule
+
+    if (!ts.isElementAccessExpression(node)) {
+        return
+    }
+
+    const expression = node.expression
+
+    if (!ts.isIdentifier(expression)) {
+        return
+    }
+
+    if (!context.cssModuleIdentifiers.has(expression.text)) {
+        return
+    }
+
+    const argument = node.argumentExpression
+
+    if (!ts.isStringLiteral(argument)) {
+        return
+    }
+
+    addClassReference(context.references, argument.text)
+}
+
+function collectClassNameAttributes(node, references) {
+    const ts = typescriptModule
+
+    if (!ts.isJsxAttribute(node)) {
+        return
+    }
+
+    if (node.name.text !== "className") {
+        return
+    }
+
+    const initializer = node.initializer
+
+    if (!initializer || !ts.isStringLiteral(initializer)) {
+        return
+    }
+
+    addClassReferencesFromString(references, initializer.text)
+}
+
+function collectIdAttributes(node, references) {
+    const ts = typescriptModule
+
+    if (!ts.isJsxAttribute(node)) {
+        return
+    }
+
+    if (node.name.text !== "id") {
+        return
+    }
+
+    const initializer = node.initializer
+
+    if (!initializer || !ts.isStringLiteral(initializer)) {
+        return
+    }
+
+    references.add(`#${initializer.text}`)
+}
+
+function collectUtilityCallReferences(node, context) {
+    const ts = typescriptModule
+
+    if (!ts.isCallExpression(node)) {
+        return
+    }
+
+    const callee = node.expression
+    let functionName = null
+
+    if (ts.isIdentifier(callee)) {
+        functionName = callee.text
+    }
+
+    if (!functionName || !context.utilityFunctionIdentifiers.has(functionName)) {
+        return
+    }
+
+    // eslint-disable-next-line no-use-before-define -- mutual recursion with extractStringLiteralsFromNodes
+    extractStringLiteralsFromNodes(getCallArguments(node), context.references)
+}
+
+function extractObjectPropertyReferences(property, references) {
+    const ts = typescriptModule
+
+    if (!ts.isPropertyAssignment(property)) {
+        return
+    }
+
+    const key = property.name
+
+    if (ts.isStringLiteral(key)) {
+        addClassReferencesFromString(references, key.text)
+    }
+
+    if (ts.isIdentifier(key)) {
+        addClassReference(references, key.text)
+    }
+
+    // eslint-disable-next-line no-use-before-define -- mutual recursion with extractStringLiteralsFromNodes
+    extractStringLiteralsFromNodes([property.initializer], references)
+}
+
+function extractStringLiteralsFromNodes(nodes, references) {
+    const ts = typescriptModule
+
+    for (const node of nodes) {
+        if (ts.isStringLiteral(node)) {
+            addClassReferencesFromString(references, node.text)
+
+            continue
+        }
+
+        if (ts.isObjectLiteralExpression(node)) {
+            for (const property of node.properties) {
+                extractObjectPropertyReferences(property, references)
+            }
+
+            continue
+        }
+
+        if (ts.isArrayLiteralExpression(node)) {
+            extractStringLiteralsFromNodes([...node.elements], references)
+
+            continue
+        }
+
+        if (ts.isCallExpression(node)) {
+            extractStringLiteralsFromNodes(getCallArguments(node), references)
+
+            continue
+        }
+
+        if (ts.isConditionalExpression(node)) {
+            extractStringLiteralsFromNodes([node.whenTrue, node.whenFalse], references)
+
+            continue
+        }
+
+        if (ts.isTemplateExpression(node)) {
+            const spanExpressions = node.templateSpans.map((span) => {
+                return span.expression
+            })
+
+            extractStringLiteralsFromNodes(spanExpressions, references)
+        }
+    }
+}
+
+function isSimpleSelector(selectorRoot) {
+    for (const selector of selectorRoot.nodes) {
+        const significantNodes = selector.nodes.filter((node) => {
+            return node.type !== "comment" && node.type !== "combinator"
+        })
+
+        if (significantNodes.length !== 1) {
+            return false
+        }
+    }
+
+    return true
+}
+
+function stripNonStructuralPseudos(selectorRoot) {
+    selectorRoot.walk((node) => {
+        if (node.type !== "pseudo") {
+            return
+        }
+
+        const pseudoName = node.value.replace(/^::?/, "")
+
+        if (node.value.startsWith("::")) {
+            if (NON_STRUCTURAL_PSEUDO_ELEMENTS.has(pseudoName)) {
+                node.remove()
+            }
+
+            return
+        }
+
+        if (NON_STRUCTURAL_PSEUDO_CLASSES.has(pseudoName)) {
+            node.remove()
+        }
+    })
+
+    return selectorRoot
+}
+
+/**
+ * @param {string} cssPath
+ * @returns {import("./no-unused-selectors.types.ts").TemplateVariablesType}
+ */
+function resolveTemplateVariables(cssPath) {
+    const parsed = path.parse(cssPath)
+    const cssDirectory = parsed.dir
+    const cssName = parsed.name
+    const cssBaseName = cssName.replace(/\.module$/, "")
+    const cssDirectoryName = path.basename(cssDirectory)
+
+    return { cssBaseName, cssDirectory, cssDirectoryName, cssName }
+}
+
+/**
+ * @param {string} cssPath
+ * @param {string[]} templates
+ * @returns {string[]}
+ */
+function resolveDocumentPaths(cssPath, templates) {
+    const variables = resolveTemplateVariables(cssPath)
+
+    return templates.map((template) => {
+        return template
+            .replaceAll("{cssDirectory}", variables.cssDirectory)
+            .replaceAll("{cssName}", variables.cssName)
+            .replaceAll("{cssBaseName}", variables.cssBaseName)
+            .replaceAll("{cssDirectoryName}", variables.cssDirectoryName)
+    })
+}
+
+/**
+ * @param {string[]} documentPaths
+ * @returns {import("./no-unused-selectors.types.ts").ResolvedDocumentType[]}
+ */
+function resolveAllDocuments(documentPaths) {
+    const documents = []
+
+    for (const documentPath of documentPaths) {
+        try {
+            const content = fs.readFileSync(documentPath, "utf8")
+
+            documents.push({ content, path: documentPath })
+        } catch {
+            // File doesn't exist, skip
+        }
+    }
+
+    return documents
+}
+
+/**
+ * @param {string} sourceContent
+ * @param {string} filePath
+ * @returns {Set<string>}
+ */
+function extractClassReferences(sourceContent, filePath) {
+    /** @type {Set<string>} */
+    const references = new Set()
+
+    const ts = getTypeScript()
+
+    if (!ts) {
+        return references
+    }
+
+    const sourceFile = ts.createSourceFile(
+        filePath,
+        sourceContent,
+        ts.ScriptTarget.Latest,
+        true,
+        filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    )
+
+    const cssModuleIdentifiers = new Set()
+    const utilityFunctionIdentifiers = new Set()
+    const context = { cssModuleIdentifiers, references, utilityFunctionIdentifiers }
+
+    ts.forEachChild(sourceFile, function visit(node) {
+        collectCssModuleImports(node, cssModuleIdentifiers)
+        collectUtilityImports(node, utilityFunctionIdentifiers)
+        collectPropertyAccessReferences(node, context)
+        collectBracketAccessReferences(node, context)
+        collectClassNameAttributes(node, references)
+        collectIdAttributes(node, references)
+        collectUtilityCallReferences(node, context)
+
+        ts.forEachChild(node, visit)
+    })
+
+    return references
+}
+
+/**
+ * @param {string} resolvedSelector
+ * @returns {{ type: "class" | "id"; value: string } | null}
+ */
+function extractSimpleSelector(resolvedSelector) {
+    let result = null
+
+    try {
+        selectorParser((selectors) => {
+            const stripped = stripNonStructuralPseudos(selectors)
+
+            if (!isSimpleSelector(stripped)) {
+                return
+            }
+
+            const firstSelector = stripped.nodes[0]
+
+            if (!firstSelector) {
+                return
+            }
+
+            const significantNode = firstSelector.nodes.find((node) => {
+                return node.type !== "comment" && node.type !== "combinator"
+            })
+
+            if (!significantNode) {
+                return
+            }
+
+            if (significantNode.type === "class") {
+                result = { type: "class", value: `.${significantNode.value}` }
+
+                return
+            }
+
+            if (significantNode.type === "id") {
+                result = { type: "id", value: `#${significantNode.value}` }
+            }
+        }).processSync(resolvedSelector)
+    } catch {
+        return null
+    }
+
+    return result
+}
+
+export {
+    DEFAULT_DOCUMENT_TEMPLATES,
+    extractClassReferences,
+    extractSimpleSelector,
+    resolveAllDocuments,
+    resolveDocumentPaths,
+}

package/dist/stylelint/plugins/no-unused-selectors.d.ts

@@ -1,3 +0,0 @@
-export default plugin;
-/** @type {import("stylelint").Config} */
-declare const plugin: import("stylelint").Config;

package/src/stylelint/plugins/no-unused-selectors.js

@@ -1,30 +0,0 @@
-/** @type {import("stylelint").Config} */
-const plugin = {
-    rules: {
-        "plugin/no-unused-selectors": [
-            true,
-            {
-                resolve: {
-                    documents: [
-                        "{cssDir}/{cssName}.variants.ts",
-                        "{cssDir}/{cssName}.variants.tsx",
-                        "{cssDir}/{cssName}.tsx",
-                        "{cssDir}/{cssName}.jsx",
-                        "{cssDir}/{cssName}.html",
-                        "{cssDir}/{cssName}.htm",
-                        "{cssDir}/{cssDirName}.tsx",
-                        "{cssDir}/{cssDirName}.jsx",
-                        "{cssDir}/{cssDirName}.html",
-                        "{cssDir}/{cssDirName}.htm",
-                        "{cssDir}/index.tsx",
-                        "{cssDir}/index.jsx",
-                        "{cssDir}/index.html",
-                        "{cssDir}/index.htm",
-                    ],
-                },
-            },
-        ],
-    },
-}
-
-export default plugin