eslint-plugin-tailwind-variants 0.0.0 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Made by Dom | Dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+<div align="center">
+	<img height="75px" alt="eslint-plugin-tailwind-variants logo" src="./.github/assets/eslint-plugin-tailwind-variants-logo.svg" />
+</div>
+
+<h1 align="center">eslint-plugin-tailwind-variants</h1>
+
+<div align="center">
+	<img alt="GitHub License MIT" src="https://img.shields.io/github/license/domingasp/eslint-plugin-tailwind-variants?color=615fff"/>
+</div>
+
+<br />
+
+ESLint plugin to enforce best practices and consistent naming conventions for tailwind-variants.
+
+Automatically enforces proper variable naming, limits excessive inline classes, and promotes clean tv() usage with auto-fix support. This plugin supports a wide range of projects, including React, Vue, plain JavaScript or TypeScript.
+
+## Installation
+
+```sh
+npm i -D eslint eslint-plugin-tailwind-variants
+```
+
+## Quick start
+
+1. Depending on your environment you may need to install the following dependencies:
+
+```sh
+# TypeScript
+npm i -D @typescript-eslint/parser
+
+# Vue
+npm i -D vue-eslint-parser
+```
+
+2. Enable the `recommended` config in your ESLint config:
+
+```js
+// eslint.config.{js|ts)
+
+// ...
+import tailwindVariants from "eslint-plugin-tailwind-variants";
+
+export default defineConfig([
+	tailwindVariants.configs.recommended,
+]);
+```
+
+### Rules
+
+| Name                                                                                 | Description                                                                                                                 | `recommended` | autofix |
+| ------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------- | ------------- | ------- |
+| [require-variants-call-styles-name](docs/rules/require-variants-call-styles-name.md) | enforce that the result of tailwind-variants ( `tv()` ) is assigned to a variable named  `styles`  (or a configurable name) | ✔             | ✔       |
+| [require-variants-suffix](docs/rules/require-variants-suffix.md)                     | require variables assigned from tv() to end with a specific suffix                                                          | ✔             | ✔       |
+| [limited-inline-classes](docs/rules/limited-inline-classes.md)                       | enforce limited number of inline class names and prohibit cn() usage                                                        | ✔             |         |

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { Linter } from "@typescript-eslint/utils/ts-eslint";
+declare const plugin: {
+    configs: Record<string, Linter.Config>;
+    meta: {
+        name: string;
+        namespace: string;
+        version: string;
+    };
+    rules: {
+        "limited-inline-classes": import("@typescript-eslint/utils/ts-eslint").RuleModule<"limitedInlineClasses" | "noCnInClassName", [{
+            directoryPattern?: string;
+            maxInlineClasses?: number;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        "require-variants-call-styles-name": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireVariantsCallStylesName", [{
+            name?: string;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        "require-variants-suffix": import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireVariantsSuffix", [{
+            suffix?: string;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+    };
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,24 @@
+import { rules } from "./rules/index.js";
+const plugin = {
+    // Plugin type expects Config rather than ConfigType
+    configs: {},
+    meta: {
+        name: "eslint-plugin-tailwind-variants",
+        namespace: "tailwind-variants",
+        version: "0.1.0",
+    },
+    rules,
+};
+Object.assign(plugin.configs, {
+    recommended: {
+        plugins: {
+            "eslint-plugin-tailwind-variants": plugin,
+        },
+        rules: {
+            "tailwind-variants/limited-inline-classes": "error",
+            "tailwind-variants/require-variants-call-styles-name": "error",
+            "tailwind-variants/require-variants-suffix": "error",
+        },
+    },
+});
+export default plugin;

package/dist/rules/index.d.ts

@@ -0,0 +1,19 @@
+import { TSESLint } from "@typescript-eslint/utils";
+export declare const rules: {
+    "limited-inline-classes": TSESLint.RuleModule<"limitedInlineClasses" | "noCnInClassName", [{
+        directoryPattern?: string;
+        maxInlineClasses?: number;
+    }], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    "require-variants-call-styles-name": TSESLint.RuleModule<"requireVariantsCallStylesName", [{
+        name?: string;
+    }], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+    "require-variants-suffix": TSESLint.RuleModule<"requireVariantsSuffix", [{
+        suffix?: string;
+    }], unknown, TSESLint.RuleListener> & {
+        name: string;
+    };
+};

package/dist/rules/index.js

@@ -0,0 +1,8 @@
+import { rule as limitedInlineClasses } from "./limited-inline-classes.js";
+import { rule as requireVariantsCallStylesName } from "./require-variants-call-styles-name.js";
+import { rule as requireVariantsSuffix } from "./require-variants-suffix.js";
+export const rules = {
+    "limited-inline-classes": limitedInlineClasses,
+    "require-variants-call-styles-name": requireVariantsCallStylesName,
+    "require-variants-suffix": requireVariantsSuffix,
+};

package/dist/rules/limited-inline-classes.d.ts

@@ -0,0 +1,24 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const MESSAGE_IDS: {
+    readonly limitedInlineClasses: "limitedInlineClasses";
+    readonly noCnInClassName: "noCnInClassName";
+};
+type MessageIds = (typeof MESSAGE_IDS)[keyof typeof MESSAGE_IDS];
+type Options = [
+    {
+        /**
+         * Directory pattern to match
+         * @default "/components/"
+         */
+        directoryPattern?: string;
+        /**
+         * Maximum number of inline classes allowed
+         * @default 5
+         */
+        maxInlineClasses?: number;
+    }
+];
+export declare const rule: ESLintUtils.RuleModule<MessageIds, Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/limited-inline-classes.js

@@ -0,0 +1,198 @@
+import { AST_NODE_TYPES, ESLintUtils, } from "@typescript-eslint/utils";
+import { createRuleVisitors } from "../utils/create-rule-visitors";
+import { getBindClassExpression } from "../utils/get-bind-class-expression";
+const createRule = ESLintUtils.RuleCreator((name) => name);
+export const MESSAGE_IDS = {
+    limitedInlineClasses: "limitedInlineClasses",
+    noCnInClassName: "noCnInClassName",
+};
+function countClasses(value) {
+    return value.trim().split(/\s+/).filter(Boolean).length;
+}
+/** Recursively validate classes in any expression and detect cn() calls */
+function validateExpression(node, expr, context, maxInlineClasses = 5) {
+    if (!expr)
+        return false;
+    switch (expr.type) {
+        case AST_NODE_TYPES.ArrayExpression:
+            return expr.elements
+                .filter((el) => {
+                return el !== null && el.type !== AST_NODE_TYPES.SpreadElement;
+            })
+                .some((el) => validateExpression(node, el, context, maxInlineClasses));
+        case AST_NODE_TYPES.BinaryExpression:
+            return (validateExpression(node, expr.left, context, maxInlineClasses) ||
+                validateExpression(node, expr.right, context, maxInlineClasses));
+        case AST_NODE_TYPES.CallExpression:
+            if (expr.callee.type === AST_NODE_TYPES.Identifier &&
+                expr.callee.name === "cn") {
+                context.report({
+                    messageId: MESSAGE_IDS.noCnInClassName,
+                    node: node,
+                });
+                return true;
+            }
+            return expr.arguments
+                .filter((arg) => {
+                return arg.type !== AST_NODE_TYPES.SpreadElement;
+            })
+                .some((arg) => validateExpression(node, arg, context, maxInlineClasses));
+        case AST_NODE_TYPES.ConditionalExpression:
+            return (validateExpression(node, expr.consequent, context, maxInlineClasses) ||
+                validateExpression(node, expr.alternate, context, maxInlineClasses));
+        case AST_NODE_TYPES.Identifier:
+            return false;
+        case AST_NODE_TYPES.Literal:
+            if (typeof expr.value === "string") {
+                if (countClasses(expr.value) > maxInlineClasses) {
+                    context.report({
+                        data: { max: maxInlineClasses.toString() },
+                        messageId: MESSAGE_IDS.limitedInlineClasses,
+                        node: node,
+                    });
+                    return true;
+                }
+            }
+            return false;
+        case AST_NODE_TYPES.LogicalExpression:
+            return (validateExpression(node, expr.left, context, maxInlineClasses) ||
+                validateExpression(node, expr.right, context, maxInlineClasses));
+        case AST_NODE_TYPES.ObjectExpression:
+            return expr.properties.some((prop) => {
+                if (prop.type === AST_NODE_TYPES.Property) {
+                    return validateExpression(node, prop.value &&
+                        prop.value.type !== "ObjectPattern" &&
+                        prop.value.type !== "ArrayPattern"
+                        ? prop.value
+                        : null, context, maxInlineClasses);
+                }
+                // Ignore SpreadElement and other non-Property types
+                return false;
+            });
+        case AST_NODE_TYPES.TemplateLiteral:
+            // Static template literal
+            if (expr.expressions.length === 0) {
+                const raw = expr.quasis[0]?.value.cooked ?? "";
+                if (countClasses(raw) > maxInlineClasses) {
+                    context.report({
+                        data: { max: maxInlineClasses.toString() },
+                        messageId: MESSAGE_IDS.limitedInlineClasses,
+                        node: node,
+                    });
+                    return true;
+                }
+            }
+            // Recurse into expressions
+            return expr.expressions.some((el) => validateExpression(node, el, context, maxInlineClasses));
+        case AST_NODE_TYPES.ThisExpression:
+            return false;
+        default:
+            console.log("Unhandled expression type:", expr.type);
+            return false;
+    }
+}
+export const rule = createRule({
+    name: "limited-inline-classes",
+    meta: {
+        docs: {
+            description: `Allow a configurable number of inline class names; require use of tailwind-variants.`,
+        },
+        messages: {
+            limitedInlineClasses: `Inline className may contain at most {{max}} class. Use tailwind-variants instead.`,
+            noCnInClassName: "Using cn() in className is not allowed in component definition. Use tailwind-variants instead.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    directoryPattern: {
+                        default: "/components/",
+                        description: 'Directory pattern to match, e.g., "/components/".',
+                        type: "string",
+                    },
+                    maxInlineClasses: {
+                        default: 5,
+                        description: "Maximum number of inline classes allowed (default: 5).",
+                        minimum: 1,
+                        type: "number",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "problem",
+    },
+    defaultOptions: [
+        {
+            directoryPattern: "/components/",
+            maxInlineClasses: 5,
+        },
+    ],
+    create: (context) => {
+        const options = context.options[0] || {};
+        const directoryPattern = options.directoryPattern || "/components/";
+        const maxInlineClasses = options.maxInlineClasses ?? 5;
+        const fileName = context.filename;
+        if (!fileName.replace(/\\/g, "/").includes(directoryPattern)) {
+            return {};
+        }
+        // Script visitors (for JSX in Vue <script> or React files)
+        const scriptVisitor = {
+            JSXAttribute(node) {
+                const jsxAttr = node;
+                if (jsxAttr.name.name !== "className")
+                    return;
+                const value = jsxAttr.value;
+                if (!value)
+                    return;
+                // className="..."
+                if (value.type === AST_NODE_TYPES.Literal &&
+                    typeof value.value === "string") {
+                    if (countClasses(value.value) > maxInlineClasses) {
+                        context.report({
+                            data: { max: maxInlineClasses.toString() },
+                            messageId: MESSAGE_IDS.limitedInlineClasses,
+                            node: jsxAttr,
+                        });
+                        return;
+                    }
+                }
+                // className={`...`} / className={"..."}
+                if (value.type === AST_NODE_TYPES.JSXExpressionContainer) {
+                    const expr = value.expression;
+                    if (expr.type !== AST_NODE_TYPES.JSXEmptyExpression) {
+                        validateExpression(jsxAttr, expr, context, maxInlineClasses);
+                    }
+                }
+            },
+        };
+        // Template visitors (for Vue <template>)
+        const templateVisitor = {
+            VAttribute(node) {
+                const vAttr = node;
+                if (!vAttr.value)
+                    return;
+                // class="..."
+                if (!vAttr.directive &&
+                    vAttr.key.type === "VIdentifier" &&
+                    vAttr.key.name === "class") {
+                    if (countClasses(vAttr.value.value) > maxInlineClasses) {
+                        context.report({
+                            data: { max: maxInlineClasses.toString() },
+                            messageId: MESSAGE_IDS.limitedInlineClasses,
+                            node: vAttr,
+                        });
+                    }
+                }
+                const container = getBindClassExpression(vAttr);
+                if (!container)
+                    return;
+                // :class="..." / v-bind:class
+                if (container.expression) {
+                    validateExpression(vAttr, container.expression, context, maxInlineClasses);
+                }
+            },
+        };
+        return createRuleVisitors(context, templateVisitor, scriptVisitor);
+    },
+});

package/dist/rules/require-variants-call-styles-name.d.ts

@@ -0,0 +1,17 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const MESSAGE_IDS: {
+    readonly requireVariantsCallStylesName: "requireVariantsCallStylesName";
+};
+type Options = [
+    {
+        /**
+         * Name required for variables assigned from tv()
+         * @default "styles"
+         */
+        name?: string;
+    }
+];
+export declare const rule: ESLintUtils.RuleModule<"requireVariantsCallStylesName", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/require-variants-call-styles-name.js

@@ -0,0 +1,86 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator((name) => name);
+export const MESSAGE_IDS = {
+    requireVariantsCallStylesName: "requireVariantsCallStylesName",
+};
+export const rule = createRule({
+    name: "require-variants-call-styles-name",
+    meta: {
+        docs: {
+            description: "Require variables assigned from tv() to be named {{name}}.",
+        },
+        fixable: "code",
+        messages: {
+            requireVariantsCallStylesName: "Variable assigned from tv() must be named '{{name}}'.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    name: {
+                        default: "styles",
+                        description: "Name required for variables assigned from tv().",
+                        type: "string",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "suggestion",
+    },
+    defaultOptions: [
+        {
+            name: "styles",
+        },
+    ],
+    create: (context) => {
+        const options = context.options[0] || {};
+        const requiredName = options.name || "styles";
+        const variantFunctions = new Set();
+        return {
+            VariableDeclarator(node) {
+                const init = node.init;
+                const id = node.id;
+                if (!init)
+                    return;
+                if (init.type !== "CallExpression")
+                    return;
+                if (init.callee.type !== "Identifier")
+                    return;
+                if (id.type !== "Identifier")
+                    return;
+                // Always enforce required name for direct tv() assignment
+                if (init.callee.name === "tv") {
+                    if (id.name !== requiredName) {
+                        context.report({
+                            data: {
+                                functionName: "tv",
+                                name: requiredName,
+                            },
+                            fix: (fixer) => fixer.replaceText(id, requiredName),
+                            messageId: MESSAGE_IDS.requireVariantsCallStylesName,
+                            node: id,
+                        });
+                    }
+                    variantFunctions.add(id.name);
+                    return;
+                }
+                if (variantFunctions.has(init.callee.name)) {
+                    const variableName = id.name;
+                    const functionName = init.callee.name;
+                    if (variableName === requiredName)
+                        return;
+                    context.report({
+                        data: {
+                            functionName,
+                            name: requiredName,
+                        },
+                        fix: (fixer) => fixer.replaceText(id, requiredName),
+                        messageId: MESSAGE_IDS.requireVariantsCallStylesName,
+                        node: id,
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-variants-suffix.d.ts

@@ -0,0 +1,17 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const MESSAGE_IDS: {
+    readonly requireVariantsSuffix: "requireVariantsSuffix";
+};
+type Options = [
+    {
+        /**
+         * Suffix required for variables assigned from tv()
+         * @default "Variants"
+         */
+        suffix?: string;
+    }
+];
+export declare const rule: ESLintUtils.RuleModule<"requireVariantsSuffix", Options, unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/rules/require-variants-suffix.js

@@ -0,0 +1,66 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator((name) => name);
+export const MESSAGE_IDS = {
+    requireVariantsSuffix: "requireVariantsSuffix",
+};
+export const rule = createRule({
+    name: "require-variants-suffix",
+    meta: {
+        docs: {
+            description: "Require variables assigned from tv() to end with {{suffix}}.",
+        },
+        fixable: "code",
+        messages: {
+            requireVariantsSuffix: "Variable assigned from tv() must end with '{{suffix}}'.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    suffix: {
+                        default: "Variants",
+                        description: "Suffix required for variables assigned from tv().",
+                        type: "string",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "suggestion",
+    },
+    defaultOptions: [
+        {
+            suffix: "Variants",
+        },
+    ],
+    create: (context) => {
+        const options = context.options[0] || {};
+        const suffix = options.suffix || "Variants";
+        return {
+            VariableDeclarator(node) {
+                const init = node.init;
+                if (!init)
+                    return;
+                if (init.type !== "CallExpression")
+                    return;
+                if (init.callee.type !== "Identifier")
+                    return;
+                if (init.callee.name !== "tv")
+                    return;
+                const { id } = node;
+                if (id.type !== "Identifier")
+                    return;
+                if (id.name.endsWith(suffix))
+                    return;
+                context.report({
+                    data: { suffix },
+                    fix: (fixer) => {
+                        return fixer.insertTextAfter(id, suffix);
+                    },
+                    messageId: MESSAGE_IDS.requireVariantsSuffix,
+                    node: id,
+                });
+            },
+        };
+    },
+});

package/dist/utils/create-rule-visitors.d.ts

@@ -0,0 +1,6 @@
+import { RuleContext, RuleListener } from "@typescript-eslint/utils/ts-eslint";
+/**
+ * Creates rule visitors that work for both Vue single-file components and
+ * regular script files (e.g., React).
+ */
+export declare function createRuleVisitors<TMessageIds extends string, TOptions extends readonly unknown[]>(context: RuleContext<TMessageIds, TOptions>, templateVisitor: RuleListener, scriptVisitor: RuleListener): RuleListener;

package/dist/utils/create-rule-visitors.js

@@ -0,0 +1,18 @@
+/**
+ * Creates rule visitors that work for both Vue single-file components and
+ * regular script files (e.g., React).
+ */
+export function createRuleVisitors(context, templateVisitor, scriptVisitor) {
+    const fileName = context.filename;
+    if (fileName.endsWith(".vue")) {
+        const sourceCode = context.sourceCode;
+        const parserServices = sourceCode.parserServices;
+        if (isVueParserServices(parserServices)) {
+            return parserServices.defineTemplateBodyVisitor(templateVisitor, scriptVisitor);
+        }
+    }
+    return scriptVisitor;
+}
+function isVueParserServices(services) {
+    return services !== undefined && "defineTemplateBodyVisitor" in services;
+}

package/dist/utils/get-bind-class-expression.d.ts

@@ -0,0 +1,6 @@
+import { AST } from "vue-eslint-parser";
+/**
+ * Return the expression container for a bound class attribute,
+ * or null if not applicable
+ */
+export declare function getBindClassExpression(node: AST.VAttribute): AST.VExpressionContainer | null;

package/dist/utils/get-bind-class-expression.js

@@ -0,0 +1,20 @@
+/**
+ * Return the expression container for a bound class attribute,
+ * or null if not applicable
+ */
+export function getBindClassExpression(node) {
+    if (!node.directive)
+        return null;
+    if (!node.value)
+        return null;
+    const key = node.key;
+    if (key.name.name !== "bind")
+        return null;
+    if (key.argument?.type !== "VIdentifier")
+        return null;
+    if (key.argument.name !== "class")
+        return null;
+    if (!("expression" in node.value))
+        return null;
+    return node.value;
+}

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "eslint-plugin-tailwind-variants",
-  "version": "0.0.0",
-  "description": "Bootstrap release for trusted publisher setup",
-  "license": "MIT"
-}
+  "version": "1.0.0",
+  "description": "ESLint plugin for Tailwind Variants",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/domingasp/eslint-plugin-tailwind-variants.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "lint": "eslint . --ext .ts",
+    "build": "tsc",
+    "prepublishOnly": "pnpm run build",
+    "test": "vitest",
+    "test:debug": "vitest --reporter=verbose",
+    "prepare": "husky"
+  },
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "tailwind",
+    "tailwind-variants"
+  ],
+  "files": [
+    "dist"
+  ],
+  "author": "madebydomdev",
+  "license": "MIT",
+  "packageManager": "pnpm@10.22.0",
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@typescript-eslint/parser": ">8.0.0",
+    "eslint": ">9.0.0",
+    "vue-eslint-parser": "^9.4.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.51.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.3.0",
+    "@commitlint/config-conventional": "^20.3.0",
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.3",
+    "@typescript-eslint/parser": "^8.51.0",
+    "@typescript-eslint/rule-tester": "^8.51.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-perfectionist": "^5.2.0",
+    "globals": "^17.0.0",
+    "husky": "^9.1.7",
+    "jiti": "^2.6.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0",
+    "vitest": "^4.0.16",
+    "vue-eslint-parser": "^10.2.0"
+  }
+}