eslint-plugin-vuetify 2.6.0 → 2.7.0

package/README.md

@@ -31,6 +31,9 @@ Use [eslint-plugin-vuetify@vuetify-2](https://www.npmjs.com/package/eslint-plugi
 
 ## Vuetify 4 Migration
 
+> [!IMPORTANT]
+> We suggest running [vuetify-codemods](https://www.npmjs.com/package/vuetify-codemods) first to automatically apply most migration fixes
+
 This plugin includes four new rules for migrating from Vuetify v3 to v4:
 
 - **`no-deprecated-typography`** — replaces MD2 typography classes (`text-h1`) with MD3 equivalents (`text-display-large`)
@@ -147,6 +150,14 @@ These rules help migrate from Vuetify v3 to v4. They are included in the `recomm
 - Disallow elevation classes above the MD3 maximum ([`no-elevation-overflow`])
 - Disallow deprecated props and slots on snackbar components ([`no-deprecated-snackbar`])
 
+### Custom deprecations
+
+User-configurable rules for deprecating components, props, events, and slots - helpful to enforce standardization.
+
+- Disallow usage of specified components, with optional replacements ([`custom-deprecated-components`])
+- Disallow usage of specified component props ([`custom-deprecated-props`])
+- Disallow usage of specified component events ([`custom-deprecated-events`])
+- Disallow usage of specified component slots ([`custom-deprecated-slots`])
 
 [`grid-unknown-attributes`]: ./docs/rules/grid-unknown-attributes.md
 [`no-deprecated-components`]: ./docs/rules/no-deprecated-components.md
@@ -157,10 +168,13 @@ These rules help migrate from Vuetify v3 to v4. They are included in the `recomm
 [`no-deprecated-slots`]: ./docs/rules/no-deprecated-slots.md
 [`no-deprecated-imports`]: ./docs/rules/no-deprecated-imports.md
 [`icon-button-variant`]: ./docs/rules/icon-button-variant.md
+[`custom-deprecated-components`]: ./docs/rules/custom-deprecated-components.md
+[`custom-deprecated-props`]: ./docs/rules/custom-deprecated-props.md
+[`custom-deprecated-events`]: ./docs/rules/custom-deprecated-events.md
+[`custom-deprecated-slots`]: ./docs/rules/custom-deprecated-slots.md
 [`no-deprecated-typography`]: ./docs/rules/no-deprecated-typography.md
 [`no-legacy-grid-props`]: ./docs/rules/no-legacy-grid-props.md
 [`no-elevation-overflow`]: ./docs/rules/no-elevation-overflow.md
-[`no-deprecated-snackbar`]: ./docs/rules/no-deprecated-snackbar.md
 
 
 ## 💪 Supporting Vuetify

package/lib/eslint-typegen.d.ts

@@ -0,0 +1,136 @@
+/* eslint-disable */
+/* prettier-ignore */
+import type { Linter } from 'eslint'
+
+export interface RuleOptions {
+  /**
+   * Disallow usage of specified components, with optional replacements
+   */
+  'vuetify/custom-deprecated-components'?: Linter.RuleEntry<VuetifyCustomDeprecatedComponents>
+  /**
+   * Disallow usage of specified component events, with optional replacements
+   */
+  'vuetify/custom-deprecated-events'?: Linter.RuleEntry<VuetifyCustomDeprecatedEvents>
+  /**
+   * Disallow usage of specified component props, with optional replacements
+   */
+  'vuetify/custom-deprecated-props'?: Linter.RuleEntry<VuetifyCustomDeprecatedProps>
+  /**
+   * Disallow usage of specified component slots, with optional replacements
+   */
+  'vuetify/custom-deprecated-slots'?: Linter.RuleEntry<VuetifyCustomDeprecatedSlots>
+  /**
+   * Warn about v1 grid attributes not being auto-converted to classes in v2.
+   */
+  'vuetify/grid-unknown-attributes'?: Linter.RuleEntry<[]>
+  /**
+   * Ensure icon buttons have a variant defined.
+   */
+  'vuetify/icon-button-variant'?: Linter.RuleEntry<VuetifyIconButtonVariant>
+  /**
+   * Disallow the `border` prop; use Tailwind border utilities instead.
+   */
+  'vuetify/no-border-prop'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the use of classes that have been removed from Vuetify
+   */
+  'vuetify/no-deprecated-classes'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the use of classes that have been removed from Vuetify
+   */
+  'vuetify/no-deprecated-colors'?: Linter.RuleEntry<VuetifyNoDeprecatedColors>
+  /**
+   * Prevent the use of components that have been removed from Vuetify
+   */
+  'vuetify/no-deprecated-components'?: Linter.RuleEntry<[]>
+  /**
+   * Prevent the use of removed and deprecated events.
+   */
+  'vuetify/no-deprecated-events'?: Linter.RuleEntry<[]>
+  /**
+   * disallow import from "vuetify/lib/util/colors", suggest "vuetify/util/colors" instead
+   */
+  'vuetify/no-deprecated-imports'?: Linter.RuleEntry<[]>
+  /**
+   * Prevent the use of removed and deprecated props.
+   */
+  'vuetify/no-deprecated-props'?: Linter.RuleEntry<[]>
+  /**
+   * Prevent the use of removed and deprecated slots.
+   */
+  'vuetify/no-deprecated-slots'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow deprecated props and slots on Vuetify snackbar components.
+   */
+  'vuetify/no-deprecated-snackbar'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow deprecated MD2 typography classes, with configurable replacements.
+   */
+  'vuetify/no-deprecated-typography'?: Linter.RuleEntry<VuetifyNoDeprecatedTypography>
+  /**
+   * Disallow elevation classes above the MD3 maximum (0–5).
+   */
+  'vuetify/no-elevation-overflow'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow the `elevation` prop; use Tailwind shadow utilities instead.
+   */
+  'vuetify/no-elevation-prop'?: Linter.RuleEntry<[]>
+  /**
+   * Prevent the use of removed grid props.
+   */
+  'vuetify/no-legacy-grid-props'?: Linter.RuleEntry<[]>
+  /**
+   * Disallow Vuetify utility classes; use Tailwind equivalents instead.
+   */
+  'vuetify/no-legacy-utilities'?: Linter.RuleEntry<VuetifyNoLegacyUtilities>
+  /**
+   * Disallow the `rounded` prop; use Tailwind rounded utilities instead.
+   */
+  'vuetify/no-rounded-prop'?: Linter.RuleEntry<[]>
+}
+
+/* ======= Declarations ======= */
+// ----- vuetify/custom-deprecated-components -----
+type VuetifyCustomDeprecatedComponents = []|[{
+  [k: string]: (string | false | {
+    message: string
+  }) | undefined
+}]
+// ----- vuetify/custom-deprecated-events -----
+type VuetifyCustomDeprecatedEvents = []|[{
+  [k: string]: {
+    [k: string]: (string | false | {
+      message: string
+    }) | undefined
+  } | undefined
+}]
+// ----- vuetify/custom-deprecated-props -----
+type VuetifyCustomDeprecatedProps = []|[{
+  [k: string]: {
+    [k: string]: (string | false | {
+      message: string
+    }) | undefined
+  } | undefined
+}]
+// ----- vuetify/custom-deprecated-slots -----
+type VuetifyCustomDeprecatedSlots = []|[{
+  [k: string]: {
+    [k: string]: (string | false | {
+      message: string
+    }) | undefined
+  } | undefined
+}]
+// ----- vuetify/icon-button-variant -----
+type VuetifyIconButtonVariant = []|[string]
+// ----- vuetify/no-deprecated-colors -----
+type VuetifyNoDeprecatedColors = []|[{
+  themeColors?: string[]
+}]
+// ----- vuetify/no-deprecated-typography -----
+type VuetifyNoDeprecatedTypography = []|[{
+  [k: string]: (string | false) | undefined
+}]
+// ----- vuetify/no-legacy-utilities -----
+type VuetifyNoLegacyUtilities = []|[{
+  [k: string]: (string | false) | undefined
+}]

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference path="./eslint-typegen.d.ts" />
+import type { Linter } from 'eslint'
+
+declare const vuetify: {
+  configs: {
+    base: Linter.LegacyConfig
+    recommended: Linter.LegacyConfig
+    'recommended-v4': Linter.LegacyConfig
+
+    'flat/base': Linter.FlatConfig[]
+    'flat/recommended': Linter.FlatConfig[]
+    'flat/recommended-v4': Linter.FlatConfig[]
+
+    tailwindcss: Linter.LegacyConfig
+    'flat/tailwindcss': Linter.FlatConfig[]
+  }
+  rules: Record<string, any>
+}
+
+export = vuetify

package/lib/rules/custom-deprecated-components.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const {
+  classify,
+  hyphenate,
+  isVueTemplate
+} = require('../util/helpers');
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow usage of specified components, with optional replacements'
+    },
+    fixable: 'code',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        oneOf: [{
+          type: 'string'
+        }, {
+          type: 'boolean',
+          enum: [false]
+        }, {
+          type: 'object',
+          properties: {
+            message: {
+              type: 'string'
+            }
+          },
+          required: ['message'],
+          additionalProperties: false
+        }]
+      }
+    }],
+    messages: {
+      deprecated: `'{{ name }}' is deprecated`,
+      deprecatedWithMessage: `'{{ name }}' is deprecated: {{ message }}`,
+      deprecatedWithReplacement: `'{{ name }}' is deprecated, use '<{{ tag }}{{ classAttr }}>' instead`
+    }
+  },
+  create(context) {
+    if (!isVueTemplate(context)) return {};
+    const options = context.options[0];
+    if (!options || !Object.keys(options).length) return {};
+
+    // Normalize keys to PascalCase for lookup
+    const banned = new Map();
+    for (const [key, value] of Object.entries(options)) {
+      banned.set(classify(key), value);
+    }
+    return context.sourceCode.parserServices.defineTemplateBodyVisitor({
+      VElement(element) {
+        const tag = classify(element.rawName);
+        if (!banned.has(tag)) return;
+        const replacement = banned.get(tag);
+        const tokens = context.sourceCode.parserServices.getTemplateBodyTokenStore();
+        if (typeof replacement === 'string') {
+          // Parse replacement: tag part and optional classes (dot-separated)
+          const parts = replacement.split('.');
+          const replacementTag = parts[0];
+          const classes = parts.slice(1);
+          context.report({
+            node: element,
+            messageId: 'deprecatedWithReplacement',
+            data: {
+              name: hyphenate(tag),
+              tag: replacementTag,
+              classAttr: classes.length ? ` class="${classes.join(' ')}"` : ''
+            },
+            fix(fixer) {
+              const fixes = [];
+              const open = tokens.getFirstToken(element.startTag);
+              fixes.push(fixer.replaceText(open, `<${replacementTag}`));
+              if (element.endTag) {
+                const endTagOpen = tokens.getFirstToken(element.endTag);
+                fixes.push(fixer.replaceText(endTagOpen, `</${replacementTag}`));
+              }
+              if (classes.length) {
+                const classValue = classes.join(' ');
+                const classAttr = element.startTag.attributes.find(attr => !attr.directive && attr.key.rawName === 'class');
+                if (classAttr && classAttr.value) {
+                  const existing = classAttr.value.value;
+                  fixes.push(fixer.replaceText(classAttr.value, `"${existing} ${classValue}"`));
+                } else if (!classAttr) {
+                  fixes.push(fixer.insertTextAfter(open, ` class="${classValue}"`));
+                }
+              }
+              return fixes;
+            }
+          });
+        } else if (typeof replacement === 'object' && replacement !== null) {
+          context.report({
+            node: element,
+            messageId: 'deprecatedWithMessage',
+            data: {
+              name: hyphenate(tag),
+              message: replacement.message
+            }
+          });
+        } else {
+          context.report({
+            node: element,
+            messageId: 'deprecated',
+            data: {
+              name: hyphenate(tag)
+            }
+          });
+        }
+      }
+    });
+  }
+};

package/lib/rules/custom-deprecated-events.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const {
+  hyphenate,
+  classify,
+  isVueTemplate
+} = require('../util/helpers');
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow usage of specified component events, with optional replacements'
+    },
+    fixable: 'code',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        additionalProperties: {
+          oneOf: [{
+            type: 'string'
+          }, {
+            type: 'boolean',
+            enum: [false]
+          }, {
+            type: 'object',
+            properties: {
+              message: {
+                type: 'string'
+              }
+            },
+            required: ['message'],
+            additionalProperties: false
+          }]
+        }
+      }
+    }],
+    messages: {
+      replacedWith: `{{ tag }}: @{{ a }} has been replaced with @{{ b }}`,
+      removed: `{{ tag }}: @{{ name }} has been removed`,
+      removedWithMessage: `{{ tag }}: @{{ name }} has been removed: {{ message }}`
+    }
+  },
+  create(context) {
+    if (!isVueTemplate(context)) return {};
+    const options = context.options[0];
+    if (!options || !Object.keys(options).length) return {};
+
+    // Normalize keys to PascalCase
+    const replacements = new Map();
+    for (const [component, events] of Object.entries(options)) {
+      const normalizedEvents = {};
+      for (const [event, value] of Object.entries(events)) {
+        normalizedEvents[hyphenate(event)] = value;
+      }
+      replacements.set(classify(component), normalizedEvents);
+    }
+    return context.sourceCode.parserServices.defineTemplateBodyVisitor({
+      VAttribute(attr) {
+        if (!(attr.directive && attr.key.name.name === 'on' && attr.key.argument?.type === 'VIdentifier')) return;
+        const tag = classify(attr.parent.parent.rawName);
+        if (!replacements.has(tag)) return;
+        const eventNameNode = attr.key.argument;
+        const eventName = hyphenate(eventNameNode.rawName);
+        const events = replacements.get(tag);
+        const replace = events[eventName];
+        if (replace === undefined) return;
+        if (replace === false) {
+          context.report({
+            messageId: 'removed',
+            data: {
+              tag,
+              name: eventName
+            },
+            node: eventNameNode
+          });
+        } else if (typeof replace === 'string') {
+          context.report({
+            messageId: 'replacedWith',
+            data: {
+              tag,
+              a: eventName,
+              b: replace
+            },
+            node: eventNameNode,
+            fix(fixer) {
+              return fixer.replaceText(eventNameNode, hyphenate(replace));
+            }
+          });
+        } else if (typeof replace === 'object' && replace !== null) {
+          context.report({
+            messageId: 'removedWithMessage',
+            data: {
+              tag,
+              name: eventName,
+              message: replace.message
+            },
+            node: eventNameNode
+          });
+        }
+      }
+    });
+  }
+};

package/lib/rules/custom-deprecated-props.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const {
+  hyphenate,
+  classify,
+  isVueTemplate
+} = require('../util/helpers');
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow usage of specified component props, with optional replacements'
+    },
+    fixable: 'code',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        additionalProperties: {
+          oneOf: [{
+            type: 'string'
+          }, {
+            type: 'boolean',
+            enum: [false]
+          }, {
+            type: 'object',
+            properties: {
+              message: {
+                type: 'string'
+              }
+            },
+            required: ['message'],
+            additionalProperties: false
+          }]
+        }
+      }
+    }],
+    messages: {
+      replacedWith: `'{{ a }}' has been replaced with '{{ b }}'`,
+      removed: `'{{ name }}' has been removed`,
+      removedWithMessage: `'{{ name }}' has been removed: {{ message }}`
+    }
+  },
+  create(context) {
+    if (!isVueTemplate(context)) return {};
+    const options = context.options[0];
+    if (!options || !Object.keys(options).length) return {};
+
+    // Normalize keys to PascalCase
+    const replacements = new Map();
+    for (const [component, props] of Object.entries(options)) {
+      const normalizedProps = {};
+      for (const [prop, value] of Object.entries(props)) {
+        normalizedProps[hyphenate(prop)] = value;
+      }
+      replacements.set(classify(component), normalizedProps);
+    }
+    return context.sourceCode.parserServices.defineTemplateBodyVisitor({
+      VAttribute(attr) {
+        if (attr.directive && (attr.key.name.name !== 'bind' || !attr.key.argument)) return;
+        const tag = classify(attr.parent.parent.rawName);
+        if (!replacements.has(tag)) return;
+        const propName = attr.directive ? hyphenate(attr.key.argument.rawName) : hyphenate(attr.key.rawName);
+        const propNameNode = attr.directive ? attr.key.argument : attr.key;
+        const props = replacements.get(tag);
+        const replace = props[propName];
+        if (replace === undefined) return;
+        if (replace === false) {
+          context.report({
+            messageId: 'removed',
+            data: {
+              name: propName
+            },
+            node: propNameNode
+          });
+        } else if (typeof replace === 'string') {
+          context.report({
+            messageId: 'replacedWith',
+            data: {
+              a: propName,
+              b: replace
+            },
+            node: propNameNode,
+            fix(fixer) {
+              return fixer.replaceText(propNameNode, replace);
+            }
+          });
+        } else if (typeof replace === 'object' && replace !== null) {
+          context.report({
+            messageId: 'removedWithMessage',
+            data: {
+              name: propName,
+              message: replace.message
+            },
+            node: propNameNode
+          });
+        }
+      }
+    });
+  }
+};

package/lib/rules/custom-deprecated-slots.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const {
+  classify,
+  isVueTemplate
+} = require('../util/helpers');
+module.exports = {
+  meta: {
+    docs: {
+      description: 'Disallow usage of specified component slots, with optional replacements'
+    },
+    fixable: 'code',
+    schema: [{
+      type: 'object',
+      additionalProperties: {
+        type: 'object',
+        additionalProperties: {
+          oneOf: [{
+            type: 'string'
+          }, {
+            type: 'boolean',
+            enum: [false]
+          }, {
+            type: 'object',
+            properties: {
+              message: {
+                type: 'string'
+              }
+            },
+            required: ['message'],
+            additionalProperties: false
+          }]
+        }
+      }
+    }],
+    messages: {
+      replacedWith: `{{ component }}'s '{{ slot }}' slot has been replaced with '{{ newSlot }}'`,
+      removed: `{{ component }}'s '{{ slot }}' slot has been removed`,
+      removedWithMessage: `{{ component }}'s '{{ slot }}' slot has been removed: {{ message }}`
+    }
+  },
+  create(context) {
+    if (!isVueTemplate(context)) return {};
+    const options = context.options[0];
+    if (!options || !Object.keys(options).length) return {};
+
+    // Normalize keys to PascalCase
+    const replacements = new Map();
+    for (const [component, slots] of Object.entries(options)) {
+      replacements.set(classify(component), slots);
+    }
+    return context.sourceCode.parserServices.defineTemplateBodyVisitor({
+      VElement(node) {
+        if (node.name !== 'template' || node.parent.type !== 'VElement') return;
+        const tag = classify(node.parent.name);
+        if (!replacements.has(tag)) return;
+        const slots = replacements.get(tag);
+        const directive = node.startTag.attributes.find(attr => {
+          return attr.directive && attr.key.name.name === 'slot' && attr.key.argument?.name && slots[attr.key.argument.name] !== undefined;
+        });
+        if (!directive) return;
+        const slotName = directive.key.argument.name;
+        const replace = slots[slotName];
+        if (replace === false) {
+          context.report({
+            messageId: 'removed',
+            data: {
+              component: node.parent.name,
+              slot: slotName
+            },
+            node: directive
+          });
+        } else if (typeof replace === 'string') {
+          context.report({
+            messageId: 'replacedWith',
+            data: {
+              component: node.parent.name,
+              slot: slotName,
+              newSlot: replace
+            },
+            node: directive,
+            fix(fixer) {
+              return fixer.replaceText(directive.key.argument, replace);
+            }
+          });
+        } else if (typeof replace === 'object' && replace !== null) {
+          context.report({
+            messageId: 'removedWithMessage',
+            data: {
+              component: node.parent.name,
+              slot: slotName,
+              message: replace.message
+            },
+            node: directive
+          });
+        }
+      }
+    });
+  }
+};

package/lib/rules/grid-unknown-attributes.js

@@ -33,7 +33,7 @@ const tags = Object.keys(VGrid).reduce((t, k) => {
 module.exports = {
   meta: {
     docs: {
-      description: 'warn about unknown attributes not being converted to classes on new grid components',
+      description: 'Warn about v1 grid attributes not being auto-converted to classes in v2.',
       category: 'recommended'
     },
     fixable: 'code',

package/lib/util/grid-attributes.js

@@ -7,7 +7,9 @@ const alignmentClasses = [/^align-(content-)?(start|baseline|center|end|space-ar
 const noFix = {
   VContainer: [...alignmentClasses, /^grid-list-(xs|sm|md|lg|xl)$/],
   VRow: [...alignmentClasses, 'row', 'column', 'reverse', 'wrap'],
-  VCol: [/^align-self-(start|baseline|center|end)$/, /^offset-(xs|sm|md|lg|xl)\d{1,2}$/, /^order-(xs|sm|md|lg|xl)\d{1,2}$/, /^(xs|sm|md|lg|xl)\d{1,2}$/]
+  VCol: ['align', 'justify',
+  // user error, don't attempt to fix
+  /^align-self-(start|baseline|center|end)$/, /^offset-(xs|sm|md|lg|xl)\d{1,2}$/, /^order-(xs|sm|md|lg|xl)\d{1,2}$/, /^(xs|sm|md|lg|xl)\d{1,2}$/]
 };
 function isGridAttribute(tag, name) {
   return noFix[tag] && noFix[tag].some(match => {

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "eslint-plugin-vuetify",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "An eslint plugin for Vuetify",
   "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "author": "Kael Watts-Deuchar <kaelwd@gmail.com>",
   "license": "MIT",
   "repository": "github:vuetifyjs/eslint-plugin-vuetify",
   "scripts": {
-    "build": "rimraf lib && babel src --out-dir lib",
+    "build": "rimraf lib && babel src --out-dir lib --copy-files && pnpm typegen",
     "test": "mocha tests --recursive --reporter dot",
     "test:8": "cross-env ESLINT8=true mocha tests --recursive --reporter dot",
     "test:9": "cross-env ESLINT9=true mocha tests --recursive --reporter dot",
     "test:coverage": "nyc mocha tests --recursive --reporter dot",
     "test:ci": "nyc --reporter=lcov mocha tests --recursive --reporter dot",
+    "typegen": "node tools/generate-dts.mjs",
     "lint": "eslint src tests",
     "prepublishOnly": "npm run build",
     "release": "bumpp -r"
@@ -32,11 +34,12 @@
     "@stylistic/eslint-plugin": "^4.4.1",
     "bumpp": "^10.1.0",
     "conventional-changelog-cli": "^2.2.2",
-    "cross-env": "^7.0.3",
     "conventional-changelog-vuetify": "^2.0.2",
     "conventional-github-releaser": "^3.1.5",
+    "cross-env": "^7.0.3",
     "eslint": "^10.0.0",
     "eslint-plugin-vue": "^10.0.0",
+    "eslint-typegen": "^2.3.1",
     "eslint8": "npm:eslint@8.57.1",
     "eslint9": "npm:eslint@9",
     "husky": "^8.0.1",
@@ -50,17 +53,7 @@
   },
   "peerDependencies": {
     "eslint": "^8.0.0 || ^9.0.0 || ^10.0.0",
-    "vuetify": "^3.0.0"
+    "vuetify": "^3.0.0 || ^4.0.0"
   },
-  "packageManager": "pnpm@10.26.1",
-  "pnpm": {
-    "overrides": {
-      "@stylistic/eslint-plugin": "$@stylistic/eslint-plugin"
-    },
-    "peerDependencyRules": {
-      "allowedVersions": {
-        "eslint": "10"
-      }
-    }
-  }
+  "packageManager": "pnpm@10.26.1"
 }