@lewishowles/lint-config 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.8.0: 2026-10-05
+
+### Changes
+
+- Breaking: `vite-plus` 1.0.0 is now required. Put the selected lint layers in a `vite.config.js` `lint` block; `vp check` and `vp lint` ignore a `.oxlintrc.json` on its own. Use `lintConfig` from `@lewishowles/lint-config/layers` to build the block, with an optional `.oxlintrc.json` for local settings. Vite+ 1.0 also adds its own `vite-plus/prefer-vite-plus-imports` rule, which may report new problems after upgrading.
+- New `./layers` export provides `base`, `vue`, `comments`, and `lintConfig`. The Vue layer includes base, and `lintConfig` carries inherited environments and globals into the Vite+ lint block.
+- `comments/function-documentation` adds an `ignoreInlineArrows` option, enabled by `comments.json` for test files. Arrow functions used as object property values no longer need JSDoc there; other function forms and files keep their existing requirements.
+- `comments/formatting` changes the output of `--fix` for comments. Run `--fix` once after upgrading.
+
+### Fixes
+
+- `comments/formatting` keeps code spans, quotes, colons, Markdown blocks, and descriptions in mixed-tag JSDoc blocks as written. It places free-form tag text at the comment margin, removes a separator hyphen when a tag description moves onto its own line, keeps wrapped parameter, return, and throw descriptions indented, and preserves line breaks between adjacent `//` comments.
+- The documentation rules for functions, variables, configured API calls and classes recognise comments across tool directives such as `eslint-disable-next-line`. `comments/function-documentation` accepts plain or optional JSDoc names for destructured parameters with defaults.
+
 ## 0.7.0: 2026-09-30
 
 ### Changes

package/README.md

@@ -62,6 +62,14 @@ Add the comments layer alongside the base or Vue layer to enforce the comment-fo
 }
 ```
 
+For functions, variables, configured API calls and classes, a tool directive comment such as `// eslint-disable-next-line` may sit between the documentation comment and the code.
+
+For destructured parameters with defaults, document the parent and each property. Plain names such as `result.errors` and optional names such as `[result.errors]` or `[result.errors=[]]` all match `errors = []`. The parent can likewise be `result`, `[result]` or `[result={}]`. A documented default does not have to match the value in the code.
+
+Lines below a free-form tag such as `@description` or `@note` start at the comment margin so they can be pasted into Markdown without becoming a code block. `@example` content is left as written. Wrapped `@param`, `@returns` and `@throws` descriptions keep a four-space hanging indent so each description is easy to scan beneath its tag. A description written as `name - description` loses the hyphen when it moves onto its own line.
+
+Consecutive `//` comments keep their line breaks, and only a line past 80 columns is wrapped.
+
 The Vue component rule reads the raw `.vue` file because Oxlint's JS Plugin API only receives the extracted script block. The comments layer loads its plugin for you, so there's no relative `jsPlugins` path to add. To pick rules yourself instead, add the plugin directly:
 
 ```json
@@ -102,36 +110,32 @@ The `comments/variable-declarations` rule accepts a `rootOnly` option to require
 }
 ```
 
+The `comments/function-documentation` rule accepts an `ignoreInlineArrows` option. The comments layer enables it for the same test files, so arrow functions used as object property values do not need JSDoc there. Function declarations, method shorthand, function expression properties, and `const` functions still need JSDoc. Other files keep the default of `false`.
+
 The `comments/class-documentation` rule requires an immediately preceding block comment before class declarations and const-assigned class expressions. Constructors, methods, getters, and setters require full JSDoc; constructors never need an `@returns` tag, and getters and setters need one only when they return a value. Instance and static fields require an immediately preceding line comment.
 
 ### `vp check` configuration
 
-The `vp check` and `vp lint` commands read Oxlint settings only from a `lint` block in `vite.config.js`; they do not read `.oxlintrc.json` directly. If `vite.config.js` is missing, they silently use an unrelated default configuration. You may still see plausible warnings and exit codes, but none of your rules are applied.
+On vite-plus 1.0.0, `vp check` and `vp lint` take their Oxlint settings from the `lint` block in `vite.config.js`. They ignore a `.oxlintrc.json` on its own, even though the Vite+ documentation says `vp lint` finds Oxlint config files by itself. If `vite.config.js` is missing, both commands quietly fall back to default settings. You still see plausible warnings and exit codes, but none of your rules are applied.
 
-Each consuming repo needs a `vite.config.js` with a `lint` block built from the config layer(s) and the repo's `.oxlintrc.json`, imported as JSON. Concatenate the `overrides` arrays from every imported layer before the local overrides so shared file-specific rules still apply. Verify the setup with `vp lint --print-config <file>` and check that your real values, not defaults, are active.
+Each consuming repo needs a `vite.config.js` with a `lint` block. Use `lintConfig` with the layers you want. Oxlint ignores `env` and `globals` in configs listed under `extends`, so `lintConfig` copies them into the `lint` block itself, including values from the layers each one extends. Without that, `no-undef` reports Vue macros such as `defineProps` and browser globals such as `window` (see [docs/limitations.md](docs/limitations.md)). The Vue layer already includes base; add comments only if you want the comment rules. You can pass your project's `.oxlintrc.json` as the second argument to keep its local settings. `lintConfig` ignores the `extends` list in that file, so list every layer you want in the first argument.
 
 ```js
 import { defineConfig } from "vite-plus";
-import lintConfigBase from "@lewishowles/lint-config/base.json" with { type: "json" };
-import lintConfigComments from "@lewishowles/lint-config/comments.json" with { type: "json" };
+import { base, comments, lintConfig } from "@lewishowles/lint-config/layers";
 import oxlintrc from "./.oxlintrc.json" with { type: "json" };
 
-const lint = {
-	...lintConfigBase,
-	env: oxlintrc.env,
-	ignorePatterns: oxlintrc.ignorePatterns,
-	jsPlugins: [...lintConfigBase.jsPlugins, ...lintConfigComments.jsPlugins],
-	overrides: [
-		...(lintConfigBase.overrides ?? []),
-		...(lintConfigComments.overrides ?? []),
-		...(oxlintrc.overrides ?? []),
-	],
-	rules: { ...lintConfigBase.rules, ...lintConfigComments.rules },
-};
-
-export default defineConfig({ lint });
+export default defineConfig({
+	lint: lintConfig([base, comments], oxlintrc),
+});
 ```
 
+For a Vue project, use `lintConfig([vue, comments], oxlintrc)` and import `vue` instead of `base`. The local config is optional; `lintConfig([vue, comments])` also works. If you combine layers by hand, use object layers in `extends` and lift their `env` and `globals` to the top level yourself. Spreading JSON layers together replaces earlier `jsPlugins`, `overrides`, and `rules` arrays or objects.
+
+Verify the setup with `vp lint --print-config <file>` and check that your real values, not defaults, are active. The printed `rules` leave out every rule that comes from a plugin, such as `comments/*` and `@stylistic/*`, even when those rules are running. To check a plugin layer, confirm the plugin is listed in `jsPlugins`, then lint a file that breaks one of its rules.
+
+Vite+ also adds its own `vite-plus` lint plugin, so `vp check` can report rules that this package doesn't define. For example, `vite-plus/prefer-vite-plus-imports` reports imports from `oxlint` packages that Vite+ already provides, such as `oxlint/plugins-dev`.
+
 ## Customising
 
 Your project's `.oxlintrc.json` can override rules, add ignore patterns, add overrides, or add plugins on top of the shared layer.

package/comments/rules/formatting.js

@@ -656,13 +656,10 @@ function reportLineCommentGroups(context) {
 			});
 		});
 
-		// The group's lines after refilling words from early-wrapped lines.
-		const refilledLines = refillCommentLines(formattedLines, maximumLineLength);
-
 		// The group's text after applying its final line formatting and
 		// placement gap.
 		const formattedText =
-			refilledLines
+			formattedLines
 				.map(({ prefix, text }) => (text === "" ? prefix.trimEnd() : `${prefix}${text}`))
 				.join(getNewline(context.sourceCode.text)) + (placement?.gap ?? "");
 
@@ -833,9 +830,10 @@ function reportBlockComments(context) {
 }
 
 /**
- * The comment-formatting rule: punctuates comments as sentences, refills
- * early-wrapped lines, reindents line-comment groups and wraps any comment past
- * 80 columns, replacing each comment in one edit.
+ * The comment-formatting rule: punctuates comments as sentences and wraps any
+ * comment past 80 columns, replacing each comment in one edit. Block comments
+ * that wrap too early are refilled. Line-comment groups are reindented, but
+ * words never move between their lines.
  */
 export default {
 	meta: {

package/comments/rules/function-documentation.js

@@ -53,6 +53,18 @@ export default {
 	meta: {
 		docs: { description: "Require JSDoc documentation for named functions and methods." },
 		type: "suggestion",
+		schema: [
+			{
+				type: "object",
+				properties: {
+					ignoreInlineArrows: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		defaultOptions: [{ ignoreInlineArrows: false }],
 	},
 	/**
 	 * Create the rule's node visitors.
@@ -77,13 +89,20 @@ export default {
 				}
 			},
 			/**
-			 * Check a first-level object method for documentation.
+			 * Check a first-level object method for documentation. When the
+			 * ignoreInlineArrows option is on, arrow function values are
+			 * skipped, which suits small inline callbacks.
 			 *
 			 * @param  {object}  node
 			 *     The property node.
 			 */
 			Property(node) {
-				if (!isFirstLevelObjectProperty(node) || !isFunctionValue(node.value)) {
+				if (
+					!isFirstLevelObjectProperty(node) ||
+					!isFunctionValue(node.value) ||
+					(context.options?.[0]?.ignoreInlineArrows &&
+						node.value.type === "ArrowFunctionExpression")
+				) {
 					return;
 				}
 

package/comments/utils/documentation.js

@@ -2,7 +2,7 @@ import { getJSDocContent, isJSDoc } from "./jsdoc.js";
 import {
 	getCommentNeighbours,
 	getCommentText,
-	isDirectiveComment,
+	getImmediateNonDirectiveComment,
 	isLeadingComment,
 } from "./source.js";
 import { getPropertyName } from "./vue-macro.js";
@@ -45,8 +45,8 @@ export function isFunctionValue(node) {
 }
 
 /**
- * Return the JSDoc comment immediately preceding a node, when the comment
- * qualifies as that node's documentation.
+ * Return the JSDoc comment directly above a node, when the comment qualifies as
+ * that node's documentation. Tool directive comments may sit between them.
  *
  * @param  {object}  sourceCode
  *     The Oxlint source code object.
@@ -57,26 +57,21 @@ export function isFunctionValue(node) {
  *     The qualifying JSDoc comment, or null when none precedes the node.
  */
 function getDocumentationComment(sourceCode, node) {
-	// Finds the closest preceding comment.
-	const comment = sourceCode
-		.getAllComments()
-		.findLast((candidate) => candidate.range[1] <= node.range[0]);
+	// The closest comment above the node, looking past tool directive comments.
+	const comment = getImmediateNonDirectiveComment(sourceCode, node);
 
-	if (comment?.type !== "Block" || isDirectiveComment(comment)) {
+	if (comment?.type !== "Block") {
 		return null;
 	}
 
 	// Checks the comments immediately around the documented node.
 	const { next, previous } = getCommentNeighbours(sourceCode, comment);
-	// Confirms there is no blank line before the documented node.
-	const gap = sourceCode.text.slice(comment.range[1], node.range[0]);
 
 	if (
 		!next ||
 		next.range[0] > node.range[0] ||
 		next.range[1] > node.range[1] ||
-		!isLeadingComment(sourceCode, comment, previous) ||
-		!/^\r?\n[ \t]*$/.test(gap)
+		!isLeadingComment(sourceCode, comment, previous)
 	) {
 		return null;
 	}
@@ -192,8 +187,9 @@ function getParameterPaths(sourceCode, node, rootPath = "options") {
  *     The JSDoc comment token.
  *
  * @returns  {object}
- *     An object with names, the set of every documented parameter path, and
- *     topLevelNames, the top-level names in the order they are documented.
+ *     An object with names, the set of every documented parameter path with
+ *     optional brackets and defaults removed, and topLevelNames, the top-level
+ *     names in the order they are documented.
  */
 function getDocumentedParameters(sourceCode, comment) {
 	// Splits the JSDoc block into its individual lines.
@@ -205,21 +201,16 @@ function getDocumentedParameters(sourceCode, comment) {
 
 	for (const line of content) {
 		// Matches an @param tag and captures its documented path.
-		const match = line.trim().match(/^@param(?:\s+\{[^}]+\})?\s+(\[[^\]]+\]|\S+)/);
+		const match = line.trim().match(/^@param(?:\s+\{[^}]+\})?\s+(\S+)/);
 
 		if (match) {
-			// The documented name as written, including optional brackets and
-			// any default value.
-			const name = match[1];
+			// The documented path without optional brackets or a default value.
+			const name = getPlainParameterPath(match[1]);
 
 			names.add(name);
 
-			// Removes optional and default-value syntax before checking for a
-			// nested path.
-			const topLevelName = name.replace(/^\[|\]$/g, "").split("=")[0];
-
-			if (!topLevelName.includes(".")) {
-				topLevelNames.push(topLevelName);
+			if (!name.includes(".")) {
+				topLevelNames.push(name);
 			}
 		}
 	}
@@ -334,10 +325,12 @@ export function reportFunctionDocumentation(context, node, functionNode, options
 	);
 
 	for (const path of parameterPaths) {
-		// The optional JSDoc spelling for this parameter path.
-		const optionalPath = `[${path}]`;
+		// The path without optional brackets or a default. Documented defaults
+		// are not compared with the code, so result.errors, [result.errors] and
+		// [result.errors=[]] all document the same property.
+		const plainPath = getPlainParameterPath(path);
 
-		if (!documentedParameters.has(path) && !documentedParameters.has(optionalPath)) {
+		if (!documentedParameters.has(plainPath)) {
 			context.report({
 				message: `${subject} require an @param for ${path}.`,
 				node,
@@ -366,3 +359,18 @@ export function reportFunctionDocumentation(context, node, functionNode, options
 		});
 	}
 }
+
+/**
+ * Reduce a parameter path to its plain name, so a documented path matches the
+ * required one however the documentation spells it.
+ *
+ * @param  {string}  path
+ *     The documented or required parameter path.
+ *
+ * @returns  {string}
+ *     The path with brackets and any default removed, such as result.errors for
+ *     [result.errors=[]].
+ */
+function getPlainParameterPath(path) {
+	return path.replace(/^\[|\]$/g, "").split("=")[0];
+}

package/comments/utils/jsdoc.js

@@ -13,6 +13,10 @@ const tagOrder = ["param", "throws", "returns"];
 const preservedSectionTags = new Set(["example"]);
 // Fast lookup set built from tagOrder.
 const targetTags = new Set(tagOrder);
+// Markdown headings start with one to six hashes and a space.
+const markdownHeadingPattern = /^#{1,6}\s/;
+// Markdown list items start with a bullet or numbered marker and a space.
+const markdownListItemPattern = /^(?:[-*]|\d+[.)])\s/;
 
 /**
  * Return whether source text is a JSDoc-style block comment.
@@ -174,19 +178,19 @@ function parseTargetTags(tagLines) {
  *     The aligned tag header.
  */
 function formatTagHeader(entry) {
-	// Splits the tag's remainder into its type, name, and description.
-	const typeMatch = entry.rest.match(/^(\{[^}]+\})(?:\s+(\S+))?(?:\s+(.*))?$/);
+	// The tag's type annotation, plus a name when the tag is @param.
+	const typeMatch = parseTargetTagRest(entry);
 
 	if (!typeMatch) {
 		return `@${entry.type}  ${entry.rest}`.trimEnd();
 	}
 
 	// The bare {type} annotation.
-	const type = typeMatch[1];
+	const type = typeMatch.groups.type;
 	// The parameter name, when the tag has one.
-	const name = typeMatch[2];
+	const name = typeMatch.groups.name;
 
-	if (entry.type === "param" && name) {
+	if (name) {
 		return `@param  ${type}  ${name}`;
 	}
 
@@ -194,23 +198,204 @@ function formatTagHeader(entry) {
 }
 
 /**
- * Return the inline description from a target tag.
+ * Return a target tag's inline description without a separator hyphen. Once the
+ * description moves onto its own line, a leading hyphen would read as a
+ * Markdown bullet.
  *
  * @param  {object}  entry
  *     The parsed tag entry.
  *
  * @returns  {string}
- *     The inline description, when present.
+ *     The inline description, or an empty string when there is none.
  */
 function getInlineTagDescription(entry) {
-	// Splits the tag's remainder into its type, name, and description.
-	const typeMatch = entry.rest.match(/^(\{[^}]+\})(?:\s+(\S+))?(?:\s+(.*))?$/);
+	// The parsed type and description, with a name only for parameters.
+	const tagParts = parseTargetTagRest(entry);
 
-	return typeMatch?.[3] ?? "";
+	return (tagParts?.groups.description ?? "").replace(/^-(?:\s+|$)/, "");
+}
+
+/**
+ * Parse a target tag's type and inline description, including a parameter name
+ * only when the tag is @param.
+ *
+ * @param  {object}  entry
+ *     The parsed tag entry.
+ *
+ * @returns  {RegExpMatchArray|null}
+ *     The type, name and description, or null when there is no type.
+ */
+function parseTargetTagRest(entry) {
+	if (entry.type === "param") {
+		return entry.rest.match(/^(?<type>\{[^}]+\})(?:\s+(?<name>\S+))?(?:\s+(?<description>.*))?$/);
+	}
+
+	return entry.rest.match(/^(?<type>\{[^}]+\})(?:\s+(?<description>.*))?$/);
+}
+
+/**
+ * Find the lines that belong to a Markdown heading, list, table or fenced code
+ * block, so formatting can leave them exactly as written.
+ *
+ * @param  {string[]}  lines
+ *     The undecorated JSDoc lines.
+ *
+ * @returns  {boolean[]}
+ *     True for each line that belongs to a Markdown block, in line order.
+ */
+function getMarkdownStructure(lines) {
+	// Whether each line read so far belongs to a Markdown block.
+	const structure = [];
+
+	// Whether the current line is inside a fenced code block.
+	let inFence = false;
+	// The indentation of the open list item; deeper lines continue it.
+	let listIndent = null;
+
+	for (const line of lines) {
+		// The line without surrounding whitespace.
+		const trimmed = line.trim();
+		// The number of whitespace characters before the line's text.
+		const indent = line.length - line.trimStart().length;
+
+		// A list or table can start on the first line, after a blank line, or
+		// straight after another Markdown block.
+		const blockBoundary =
+			structure.length === 0 || lines[structure.length - 1].trim() === "" || structure.at(-1);
+
+		if (inFence) {
+			structure.push(true);
+
+			inFence = !trimmed.startsWith("```");
+
+			continue;
+		}
+
+		if (trimmed.startsWith("```")) {
+			structure.push(true);
+
+			inFence = true;
+			listIndent = null;
+
+			continue;
+		}
+
+		// A bullet or a list numbered from 1 can follow prose directly. Other
+		// numbers need a block boundary, so prose such as "2) the second case"
+		// isn't read as a list.
+		if (
+			markdownListItemPattern.test(trimmed) &&
+			(blockBoundary || /^1[.)]\s/.test(trimmed) || /^[-*]\s/.test(trimmed))
+		) {
+			structure.push(true);
+
+			listIndent = indent;
+
+			continue;
+		}
+
+		// An indented line continues the list item above it.
+		if (trimmed !== "" && listIndent !== null && indent > listIndent) {
+			structure.push(true);
+
+			continue;
+		}
+
+		listIndent = null;
+
+		// A heading can start anywhere, but a table must start at a boundary.
+		structure.push(
+			markdownHeadingPattern.test(trimmed) || (blockBoundary && trimmed.startsWith("|")),
+		);
+	}
+
+	return structure;
+}
+
+/**
+ * Format the prose in a run of JSDoc lines and copy Markdown block lines
+ * through unchanged.
+ *
+ * @param  {string[]}  lines
+ *     The undecorated JSDoc lines.
+ * @param  {function}  formatPlainLines
+ *     Formats one run of prose lines and returns the formatted lines.
+ * @param  {string[]}  structureLines
+ *     The lines to check for Markdown blocks, when they differ from the lines
+ *     being formatted. Tag descriptions pass a blank line in place of the
+ *     inline description so it is never read as Markdown.
+ *
+ * @returns  {string[]}
+ *     The formatted prose and unchanged Markdown lines.
+ */
+function splitMarkdownProse(lines, formatPlainLines, structureLines = lines) {
+	// Whether each line belongs to a Markdown block.
+	const structure = getMarkdownStructure(structureLines);
+	// The formatted lines, including unchanged Markdown blocks.
+	const result = [];
+
+	// The prose waiting to be formatted.
+	let prose = [];
+
+	/**
+	 * Format the waiting prose, keeping the blank line that separated it from
+	 * the next Markdown block.
+	 *
+	 * @param  {boolean}  keepBlank
+	 *     Whether a Markdown block follows, so the blank line before it stays.
+	 */
+	function flushProse(keepBlank = false) {
+		if (prose.length > 0) {
+			// Whether the source separates the prose from the next block.
+			const endsWithBlank = prose.at(-1)?.trim() === "";
+
+			result.push(...formatPlainLines(prose));
+
+			if (keepBlank && endsWithBlank && result.at(-1) !== "") {
+				result.push("");
+			}
+
+			prose = [];
+		}
+	}
+
+	for (let index = 0; index < lines.length; index += 1) {
+		if (structure[index]) {
+			flushProse(true);
+			result.push(lines[index]);
+		} else {
+			prose.push(lines[index]);
+		}
+	}
+
+	flushProse();
+
+	return result;
+}
+
+/**
+ * Wrap prose without making a new line look like a Markdown block.
+ *
+ * @param  {string}  text
+ *     The prose to wrap.
+ * @param  {number}  width
+ *     The available content width.
+ *
+ * @returns  {string[]}
+ *     The wrapped prose lines.
+ */
+function wrapProse(text, width) {
+	// Joins each word that looks like a Markdown marker to the word before it
+	// with a word joiner (U+2060), so wrapping never starts a line with it. The
+	// joiner turns back into a space before the lines are returned.
+	const joined = text.replace(/(\S+)\s+([-*|]|\d+[.)]|#{1,6})(?=\s)/g, "$1\u2060$2");
+
+	return wrapWords(joined, width).map((line) => line.replaceAll("\u2060", " "));
 }
 
 /**
  * Format and refill JSDoc prose while preserving paragraph and list boundaries.
+ * Markdown blocks are left as written.
  *
  * @param  {string[]}  lines
  *     The prose content lines.
@@ -223,6 +408,25 @@ function getInlineTagDescription(entry) {
  *     The formatted prose lines.
  */
 function formatUnwrappedProse(lines, addPunctuation, indentation) {
+	return splitMarkdownProse(lines, (prose) =>
+		formatPlainUnwrappedProse(prose, addPunctuation, indentation),
+	);
+}
+
+/**
+ * Refill and format JSDoc prose that contains no Markdown blocks.
+ *
+ * @param  {string[]}  lines
+ *     The prose lines to refill.
+ * @param  {boolean}  addPunctuation
+ *     Whether to format each paragraph as a sentence.
+ * @param  {string}  indentation
+ *     The indentation used by the comment.
+ *
+ * @returns  {string[]}
+ *     The refilled prose lines.
+ */
+function formatPlainUnwrappedProse(lines, addPunctuation, indentation) {
 	// The prose lines after refilling, then formatted in place below.
 	const result = refillCommentLines(
 		lines.map((line) => ({ prefix: `${indentation} * `, text: line })),
@@ -259,7 +463,8 @@ function formatUnwrappedProse(lines, addPunctuation, indentation) {
 }
 
 /**
- * Format prose paragraphs to the block-comment width.
+ * Format prose paragraphs to the block-comment width, leaving Markdown blocks
+ * as written.
  *
  * @param  {string[]}  lines
  *     The prose content lines.
@@ -272,7 +477,26 @@ function formatUnwrappedProse(lines, addPunctuation, indentation) {
  *     Formatted prose content lines.
  */
 function formatProse(lines, width, addPunctuation) {
-	// The formatted lines, built up in place.
+	return splitMarkdownProse(lines, (proseLines) =>
+		formatPlainProse(proseLines, width, addPunctuation),
+	);
+}
+
+/**
+ * Format prose paragraphs that contain no Markdown blocks.
+ *
+ * @param  {string[]}  lines
+ *     The prose lines.
+ * @param  {number}  width
+ *     The available content width.
+ * @param  {boolean}  addPunctuation
+ *     Whether to format each paragraph as a sentence.
+ *
+ * @returns  {string[]}
+ *     The formatted prose lines.
+ */
+function formatPlainProse(lines, width, addPunctuation) {
+	// The formatted prose lines, built up in place.
 	const result = [];
 
 	// The prose lines collected for the paragraph in progress.
@@ -293,12 +517,15 @@ function formatProse(lines, width, addPunctuation) {
 			text = formatSentence(text);
 		}
 
-		result.push(...wrapWords(text, width));
+		result.push(...wrapProse(text, width));
 
 		paragraph = [];
 	}
 
-	for (const line of lines) {
+	for (let index = 0; index < lines.length; index += 1) {
+		// The current undecorated JSDoc line.
+		const line = lines[index];
+
 		if (line.trim() === "") {
 			flushParagraph();
 
@@ -325,7 +552,8 @@ function formatProse(lines, width, addPunctuation) {
  * @param  {string[]}  tagLines
  *     The undecorated tag content.
  * @param  {number}  width
- *     The available description width.
+ *     The width of the comment text. @param, @returns and @throws descriptions
+ *     wrap four characters narrower to fit their indent.
  * @param  {boolean}  addPunctuation
  *     Whether to format tag descriptions as sentences.
  * @param  {boolean}  normaliseTags
@@ -364,22 +592,7 @@ function formatTags(tagLines, width, addPunctuation, normaliseTags) {
 		}
 
 		result.push(formatTagHeader(entry));
-
-		// The entry's inline and multi-line description text, combined.
-		const description = [getInlineTagDescription(entry), ...entry.description]
-			.filter((line) => line.trim() !== "")
-			.map((line) => line.trim());
-
-		// The description text, punctuated as a sentence when requested.
-		let descriptionText = description.join(" ");
-
-		if (addPunctuation && descriptionText !== "") {
-			descriptionText = formatSentence(descriptionText);
-		}
-
-		if (descriptionText !== "") {
-			result.push(...wrapWords(descriptionText, width).map((line) => `    ${line}`));
-		}
+		result.push(...formatTargetDescription(entry, width, addPunctuation));
 
 		lastType = entry.type;
 	}
@@ -393,7 +606,8 @@ function formatTags(tagLines, width, addPunctuation, normaliseTags) {
  * @param  {string[]}  lines
  *     The undecorated tag content lines.
  * @param  {number}  width
- *     The available description width.
+ *     The width of the comment text. @param, @returns and @throws descriptions
+ *     wrap four characters narrower to fit their indent.
  * @param  {boolean}  addPunctuation
  *     Whether to format descriptions as sentences.
  *
@@ -401,6 +615,9 @@ function formatTags(tagLines, width, addPunctuation, normaliseTags) {
  *     Formatted mixed tag content lines.
  */
 function formatMixedTags(lines, width, addPunctuation) {
+	// Whether each line belongs to a Markdown block. Tag lines count as blank
+	// so a list ends at the next tag.
+	const structure = getMarkdownStructure(lines.map((line) => (getJSDocTagName(line) ? "" : line)));
 	// The formatted lines, built up in place.
 	const result = [];
 
@@ -409,12 +626,28 @@ function formatMixedTags(lines, width, addPunctuation) {
 	// Whether the current tag's content is copied through unchanged.
 	let preserveSection = false;
 
-	for (const line of lines) {
+	for (let index = 0; index < lines.length; index += 1) {
+		// The current undecorated JSDoc line.
+		const line = lines[index];
 		// The tag name, or null when the line isn't a tag at all.
 		const tagName = getJSDocTagName(line);
 		// Matches a new @param/@throws/@returns tag line.
 		const match = line.trim().match(/^@(param|throws|returns)\b(.*)$/);
 
+		if (tagName !== null && currentEntry) {
+			// Whether the author left a blank line between this description and
+			// the next tag.
+			const hasTagSeparator = currentEntry.description.at(-1)?.trim() === "";
+
+			result.push(...formatTargetDescription(currentEntry, width, addPunctuation));
+
+			if (hasTagSeparator && result.at(-1) !== "") {
+				result.push("");
+			}
+
+			currentEntry = null;
+		}
+
 		if (match) {
 			currentEntry = {
 				description: [],
@@ -426,30 +659,28 @@ function formatMixedTags(lines, width, addPunctuation) {
 
 			result.push(formatTagHeader(currentEntry));
 		} else if (tagName !== null) {
-			currentEntry = null;
 			preserveSection = isPreservedSectionTag(line);
 
 			result.push(line.trim());
+		} else if (currentEntry) {
+			currentEntry.description.push(line);
 		} else if (preserveSection) {
 			result.push(line);
+		} else if (structure[index]) {
+			result.push(line);
 		} else if (line.trim() === "") {
-			currentEntry = null;
-
 			if (result.at(-1) !== "") {
 				result.push("");
 			}
 		} else {
-			// The description text, punctuated as a sentence when requested.
-			let text = line.trim();
-
-			if (addPunctuation && currentEntry) {
-				text = formatSentence(text);
-			}
-
-			result.push(...wrapWords(text, width).map((wrappedLine) => `    ${wrappedLine}`));
+			result.push(...wrapProse(line.trim(), width));
 		}
 	}
 
+	if (currentEntry) {
+		result.push(...formatTargetDescription(currentEntry, width, addPunctuation));
+	}
+
 	while (result.at(-1) === "") {
 		result.pop();
 	}
@@ -457,13 +688,60 @@ function formatMixedTags(lines, width, addPunctuation) {
 	return result;
 }
 
+/**
+ * Format the description of a @param, @returns or @throws tag, joining the text
+ * on the tag line with the lines below it.
+ *
+ * @param  {object}  entry
+ *     The parsed tag, with its tag-line text and the description lines
+ *     collected beneath it.
+ * @param  {number}  width
+ *     The width of the comment text. The description wraps four characters
+ *     narrower to fit its indent.
+ * @param  {boolean}  addPunctuation
+ *     Whether to format prose paragraphs as sentences.
+ *
+ * @returns  {string[]}
+ *     The formatted description lines beneath the tag header.
+ */
+function formatTargetDescription(entry, width, addPunctuation) {
+	// The description written on the tag line, without a leading hyphen.
+	const inlineDescription = getInlineTagDescription(entry);
+	// The full tag description, before wrapping.
+	const description = [inlineDescription, ...entry.description];
+
+	// Drop blank lines around the description.
+	while (description[0]?.trim() === "") {
+		description.shift();
+	}
+
+	while (description.at(-1)?.trim() === "") {
+		description.pop();
+	}
+
+	// Ignore the inline description when finding Markdown blocks, so a
+	// description that starts with something like "1." or "#" stays prose.
+	const structuralDescription = inlineDescription ? ["", ...description.slice(1)] : description;
+
+	return splitMarkdownProse(
+		description,
+		(prose) => {
+			return formatPlainProse(prose, Math.max(1, width - 4), addPunctuation).map((line) => {
+				return line === "" ? "" : `    ${line}`;
+			});
+		},
+		structuralDescription,
+	);
+}
+
 /**
  * Format descriptions while retaining non-target tag lines.
  *
  * @param  {string[]}  lines
  *     The undecorated tag content lines.
  * @param  {number}  width
- *     The available description width.
+ *     The width of the comment text. @param, @returns and @throws descriptions
+ *     wrap four characters narrower to fit their indent.
  * @param  {boolean}  addPunctuation
  *     Whether to format descriptions as sentences.
  *
@@ -471,11 +749,17 @@ function formatMixedTags(lines, width, addPunctuation) {
  *     Formatted tag content lines.
  */
 function formatTagDescriptions(lines, width, addPunctuation) {
+	// Whether each line belongs to a Markdown block. Tag lines count as blank
+	// so a list ends at the next tag.
+	const structure = getMarkdownStructure(lines.map((line) => (getJSDocTagName(line) ? "" : line)));
 	// The formatted lines, built up in place.
 	const result = [];
 
 	// The description lines collected for the tag in progress.
 	let description = [];
+	// Whether the current tag is @param, @returns or @throws, whose description
+	// keeps a four-space indent.
+	let indentDescription = false;
 	// Whether the current tag's content is copied through unchanged.
 	let preserveSection = false;
 
@@ -494,12 +778,20 @@ function formatTagDescriptions(lines, width, addPunctuation) {
 			text = formatSentence(text);
 		}
 
-		result.push(...wrapWords(text, width).map((line) => `    ${line}`));
+		// The wrapping width, four characters narrower for @param, @returns and
+		// @throws so their indent still fits.
+		const descriptionWidth = indentDescription ? Math.max(1, width - 4) : width;
+		// The indent applied to each wrapped description line.
+		const indent = indentDescription ? "    " : "";
+
+		result.push(...wrapProse(text, descriptionWidth).map((line) => `${indent}${line}`));
 
 		description = [];
 	}
 
-	for (const line of lines) {
+	for (let index = 0; index < lines.length; index += 1) {
+		// The current undecorated JSDoc line.
+		const line = lines[index];
 		// The tag name, or null when the line isn't a tag at all.
 		const tagName = getJSDocTagName(line);
 
@@ -507,9 +799,13 @@ function formatTagDescriptions(lines, width, addPunctuation) {
 			flushDescription();
 			result.push(line.trim());
 
+			indentDescription = isTargetTag(line);
 			preserveSection = isPreservedSectionTag(line);
 		} else if (preserveSection) {
 			result.push(line);
+		} else if (structure[index]) {
+			flushDescription();
+			result.push(line);
 		} else if (line.trim() === "") {
 			flushDescription();
 
@@ -645,15 +941,8 @@ export function formatJSDocBlockStructure(commentText, formattingOptions) {
 	const formattingContext = getJSDocFormattingContext(commentText, formattingOptions);
 	// The prose lines, refilled before tags are appended.
 	const prose = formatUnwrappedProse(formattingContext.proseLines, false, formattingContext.indent);
-
 	// The tag lines, without spacing or grouping normalisation.
-	const tags = formatTags(
-		formattingContext.tagLines,
-		Math.max(1, formattingContext.width - 4),
-		false,
-		false,
-	);
-
+	const tags = formatTags(formattingContext.tagLines, formattingContext.width, false, false);
 	// The formatted comment content, before tags are appended.
 	const outputLines = [...prose];
 
@@ -692,15 +981,8 @@ export function formatJSDocTagFormatting(commentText, formattingOptions) {
 	const formattingContext = getJSDocFormattingContext(commentText, formattingOptions);
 	// The prose, rewrapped to the comment's available width.
 	const prose = formatProse(formattingContext.proseLines, formattingContext.width, false);
-
 	// The tag lines, with spacing and grouping normalised.
-	const tags = formatTags(
-		formattingContext.tagLines,
-		Math.max(1, formattingContext.width - 4),
-		false,
-		true,
-	);
-
+	const tags = formatTags(formattingContext.tagLines, formattingContext.width, false, true);
 	// The formatted comment content, before tags are appended.
 	const outputLines = [...prose];
 
@@ -726,15 +1008,8 @@ export function formatJSDocPunctuation(commentText, formattingOptions) {
 	const formattingContext = getJSDocFormattingContext(commentText, formattingOptions);
 	// The prose, capitalised and punctuated as sentences.
 	const prose = formatUnwrappedProse(formattingContext.proseLines, true, formattingContext.indent);
-
 	// The tag lines, with descriptions punctuated as sentences.
-	const tags = formatTags(
-		formattingContext.tagLines,
-		Math.max(1, formattingContext.width - 4),
-		true,
-		false,
-	);
-
+	const tags = formatTags(formattingContext.tagLines, formattingContext.width, true, false);
 	// The formatted comment content, before tags are appended.
 	const outputLines = [...prose];
 
@@ -760,15 +1035,8 @@ export function formatJSDocWrapping(commentText, formattingOptions) {
 	const formattingContext = getJSDocFormattingContext(commentText, formattingOptions);
 	// The prose, rewrapped to the comment's available width.
 	const prose = formatProse(formattingContext.proseLines, formattingContext.width, false);
-
 	// The tag lines, without spacing or grouping normalisation.
-	const tags = formatTags(
-		formattingContext.tagLines,
-		Math.max(1, formattingContext.width - 4),
-		false,
-		false,
-	);
-
+	const tags = formatTags(formattingContext.tagLines, formattingContext.width, false, false);
 	// The formatted comment content, before tags are appended.
 	const outputLines = [...prose];
 

package/comments/utils/source.js

@@ -301,28 +301,68 @@ export function isLeadingComment(sourceCode, comment, previous) {
  *     The source node.
  *
  * @returns  {boolean}
- *     Whether an ordinary line comment immediately precedes the node.
+ *     Whether an ordinary line comment sits directly above the node. Tool
+ *     directive comments may sit between them.
  */
 export function hasImmediateLineComment(sourceCode, node) {
-	// Finds the closest preceding comment.
-	const comment = sourceCode
-		.getAllComments()
-		.findLast((candidate) => candidate.range[1] <= node.range[0]);
+	// The closest comment above the node, looking past tool directive comments.
+	const comment = getImmediateNonDirectiveComment(sourceCode, node);
 
-	if (comment?.type !== "Line" || isDirectiveComment(comment)) {
+	if (comment?.type !== "Line") {
 		return false;
 	}
 
 	// Checks the comments immediately around the node.
 	const { next, previous } = getCommentNeighbours(sourceCode, comment);
-	// Confirms there is no blank line before the node.
-	const gap = sourceCode.text.slice(comment.range[1], node.range[0]);
 
-	return (
-		next?.range[0] === node.range[0] &&
-		isLeadingComment(sourceCode, comment, previous) &&
-		/^\r?\n[ \t]*$/.test(gap)
-	);
+	return next?.range[0] === node.range[0] && isLeadingComment(sourceCode, comment, previous);
+}
+
+/**
+ * Return the closest comment above a node, skipping tool directive comments
+ * such as `// eslint-disable-next-line`. The comment, each directive and the
+ * node must each start on the line after the one before, with no blank lines.
+ *
+ * @param  {object}  sourceCode
+ *     The Oxlint source code object.
+ * @param  {object}  node
+ *     The source node.
+ *
+ * @returns  {object|null}
+ *     The comment above the node, or null when no comment sits directly above
+ *     the node.
+ */
+export function getImmediateNonDirectiveComment(sourceCode, node) {
+	// Comments before the node, in source order.
+	const comments = sourceCode
+		.getAllComments()
+		.filter((comment) => comment.range[1] <= node.range[0]);
+
+	// The position of the closest comment that is not a tool directive.
+	const commentIndex = comments.findLastIndex((comment) => !isDirectiveComment(comment));
+
+	if (commentIndex < 0) {
+		return null;
+	}
+
+	// The comment that may document the node.
+	const comment = comments[commentIndex];
+
+	// Where the comment or directive checked last ends.
+	let previousEnd = comment.range[1];
+
+	for (const next of [...comments.slice(commentIndex + 1), node]) {
+		// The text between the previous item and this one.
+		const gap = sourceCode.text.slice(previousEnd, next.range[0]);
+
+		if (!/^\r?\n[ \t]*$/.test(gap)) {
+			return null;
+		}
+
+		previousEnd = next.range[1];
+	}
+
+	return comment;
 }
 
 /**
@@ -334,26 +374,19 @@ export function hasImmediateLineComment(sourceCode, node) {
  *     The source node.
  *
  * @returns  {boolean}
- *     Whether an ordinary block comment immediately precedes the node.
+ *     Whether an ordinary block comment sits directly above the node. Tool
+ *     directive comments may sit between them.
  */
 export function hasImmediateBlockComment(sourceCode, node) {
-	// Finds the closest preceding comment.
-	const comment = sourceCode
-		.getAllComments()
-		.findLast((candidate) => candidate.range[1] <= node.range[0]);
+	// The closest comment above the node, looking past tool directive comments.
+	const comment = getImmediateNonDirectiveComment(sourceCode, node);
 
-	if (comment?.type !== "Block" || isDirectiveComment(comment)) {
+	if (comment?.type !== "Block") {
 		return false;
 	}
 
 	// Checks the comments immediately around the node.
 	const { next, previous } = getCommentNeighbours(sourceCode, comment);
-	// Confirms there is no blank line before the node.
-	const gap = sourceCode.text.slice(comment.range[1], node.range[0]);
 
-	return (
-		next?.range[0] === node.range[0] &&
-		isLeadingComment(sourceCode, comment, previous) &&
-		/^\r?\n[ \t]*$/.test(gap)
-	);
+	return next?.range[0] === node.range[0] && isLeadingComment(sourceCode, comment, previous);
 }

package/comments/utils/wrap.js

@@ -1,8 +1,22 @@
 import { getDisplayWidth } from "./source.js";
 
+// One word of comment text. A backtick code span counts as part of the word
+// around it, so wrapping never splits the code inside it across lines.
+const wordPattern = /(?:`[^`]*`|[^\s`]+|`)+/g;
+// Text that is only an inline code span, which reads as code, not a sentence.
+const codeSpanOnlyPattern = /^`[^`]*`$/;
+// An inline code span anywhere in the text.
+const codeSpanPattern = /`[^`]*`/;
+// Text that is only a quotation, in straight or curly quotes.
+const quoteOnlyPattern = /^(?:"[^"]*"|'[^']*'|“[^”]*”|‘[^’]*’)$/;
+
 /**
  * Wrap words to a maximum line width.
  *
+ * A code span is never split: one wider than the line goes whole on its own
+ * line. Any other word wider than the line also gets its own line, and is cut
+ * at the width only when nothing comes before it on the line.
+ *
  * @param  {string}  text
  *     The text to wrap.
  * @param  {number}  width
@@ -12,8 +26,8 @@ import { getDisplayWidth } from "./source.js";
  *     Wrapped lines.
  */
 export function wrapWords(text, width) {
-	// The text's individual words.
-	const words = text.trim().split(/\s+/).filter(Boolean);
+	// The text's words, with code spans kept whole.
+	const words = text.trim().match(wordPattern) ?? [];
 	// The wrapped lines, built up in place.
 	const lines = [];
 
@@ -22,6 +36,13 @@ export function wrapWords(text, width) {
 
 	for (const word of words) {
 		if (word.length > width && currentLine === "") {
+			// Code stays whole even when it overflows the line.
+			if (codeSpanPattern.test(word)) {
+				lines.push(word);
+
+				continue;
+			}
+
 			for (let index = 0; index < word.length; index += width) {
 				lines.push(word.slice(index, index + width));
 			}
@@ -74,8 +95,8 @@ export function refillCommentLines(lines, maximumLineLength) {
 				break;
 			}
 
-			// The words still waiting on the following line.
-			const nextWords = nextLine.text.split(/\s+/).filter(Boolean);
+			// The next line's words, with code spans kept whole.
+			const nextWords = nextLine.text.match(wordPattern) ?? [];
 
 			// Whether the following line was removed after giving up all its
 			// words.
@@ -180,6 +201,9 @@ export function formatSentence(text) {
 /**
  * Capitalise the first letter of sentence text.
  *
+ * Text that starts with anything other than a letter, such as a code span, a
+ * quote or an emoji, is returned unchanged.
+ *
  * @param  {string}  text
  *     The sentence text.
  *
@@ -194,15 +218,14 @@ export function capitaliseSentence(text) {
 		return text;
 	}
 
-	// The index of the first letter character, ignoring leading punctuation.
-	const firstLetter = trimmedText.search(/\p{L}/u);
-
-	if (firstLetter < 0) {
+	// Code, quoted text and emoji keep their own casing, so only a sentence
+	// that starts with a letter is capitalised.
+	if (!/^\p{L}/u.test(trimmedText)) {
 		return text;
 	}
 
-	// The leading word, starting from the first letter character.
-	const leadingWord = trimmedText.slice(firstLetter).match(/^\p{L}[\p{L}\p{N}]*/u)?.[0] ?? "";
+	// The leading word, before any space or punctuation.
+	const leadingWord = trimmedText.match(/^\p{L}[\p{L}\p{N}]*/u)?.[0] ?? "";
 
 	// A camelCase word (lowercase start, later uppercase) is a code identifier
 	// and must keep its own casing rather than sentence casing.
@@ -211,15 +234,20 @@ export function capitaliseSentence(text) {
 	}
 
 	// The first letter character.
-	const letter = trimmedText[firstLetter];
+	const letter = trimmedText[0];
 	// The text with its first letter capitalised.
-	const formattedText = `${trimmedText.slice(0, firstLetter)}${letter.toLocaleUpperCase()}${trimmedText.slice(firstLetter + 1)}`;
+	const formattedText = `${letter.toLocaleUpperCase()}${trimmedText.slice(1)}`;
 
 	return text.replace(trimmedText, formattedText);
 }
 
 /**
- * Add terminal punctuation to sentence text.
+ * Add a full stop to sentence text that has no closing punctuation.
+ *
+ * Text ending in a colon introduces what follows, and text that is only a code
+ * span or a quotation is not a sentence, so both are returned unchanged. A
+ * sentence that ends in a code span or quotation gets its full stop after the
+ * closing mark.
  *
  * @param  {string}  text
  *     The sentence text.
@@ -231,7 +259,13 @@ export function addTerminalPunctuation(text) {
 	// The sentence text, without leading or trailing whitespace.
 	const trimmedText = text.trim();
 
-	if (trimmedText === "" || trimmedText.startsWith("@") || /[.!?]$/.test(trimmedText)) {
+	if (
+		trimmedText === "" ||
+		trimmedText.startsWith("@") ||
+		/[.!?:]$/.test(trimmedText) ||
+		codeSpanOnlyPattern.test(trimmedText) ||
+		quoteOnlyPattern.test(trimmedText)
+	) {
 		return text;
 	}
 

package/comments.json

@@ -19,6 +19,7 @@
 		{
 			"files": ["**/*.test.*", "**/*.spec.*", "**/test/**"],
 			"rules": {
+				"comments/function-documentation": ["error", { "ignoreInlineArrows": true }],
 				"comments/variable-declarations": ["error", { "rootOnly": true }]
 			}
 		}

package/layers.js

@@ -0,0 +1,60 @@
+import base from "./base.json" with { type: "json" };
+import comments from "./comments.json" with { type: "json" };
+import vueConfig from "./vue.json" with { type: "json" };
+
+// The Vue layer. It includes base as an object because Oxlint rejects the file
+// path that vue.json uses to extend base.
+export const vue = { ...vueConfig, extends: [base] };
+
+/**
+ * Build a Vite+ lint block from the selected layers and local settings.
+ *
+ * @param  {object[]}  layers
+ *     The layer objects to extend. When two layers set the same env or global,
+ *     the later layer's value is used.
+ * @param  {object}  local
+ *     Project settings that take priority over the layers. Its extends list is
+ *     ignored, so every layer must be passed in layers.
+ *
+ * @returns  {object}
+ *     A lint block with inherited environments and globals at the top level.
+ */
+export function lintConfig(layers, local = {}) {
+	// The environments inherited from the selected layers.
+	const env = {};
+	// The globals inherited from the selected layers.
+	const globals = {};
+
+	for (const layer of layers) {
+		collectEnvAndGlobals(layer, env, globals);
+	}
+
+	return {
+		...local,
+		env: { ...env, ...local.env },
+		globals: { ...globals, ...local.globals },
+		extends: layers,
+	};
+}
+
+/**
+ * Copy a layer's env and globals into the collected values. The layers it
+ * extends are copied first, so the layer's own values win.
+ *
+ * @param  {object}  layer
+ *     The layer to read, along with every layer it extends.
+ * @param  {object}  env
+ *     The collected environments, updated in place.
+ * @param  {object}  globals
+ *     The collected globals, updated in place.
+ */
+function collectEnvAndGlobals(layer, env, globals) {
+	for (const extendedLayer of layer.extends ?? []) {
+		collectEnvAndGlobals(extendedLayer, env, globals);
+	}
+
+	Object.assign(env, layer.env);
+	Object.assign(globals, layer.globals);
+}
+
+export { base, comments };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lewishowles/lint-config",
-	"version": "0.7.0",
+	"version": "0.8.0",
 	"description": "Shared oxlint configuration for Lewis Howles projects",
 	"keywords": [
 		"config",
@@ -24,6 +24,7 @@
 		"comments",
 		"comments.json",
 		"imports.json",
+		"layers.js",
 		"vue.json",
 		"README.md"
 	],
@@ -36,6 +37,7 @@
 		"./comments.json": "./comments.json",
 		"./comments/plugin": "./comments/plugin.js",
 		"./imports.json": "./imports.json",
+		"./layers": "./layers.js",
 		"./vue.json": "./vue.json"
 	},
 	"publishConfig": {
@@ -46,15 +48,15 @@
 		"lint:fix": "vp check --fix",
 		"prepare": "vp config --no-agent",
 		"publint": "publint",
-		"test:unit": "node --test test/comments/*.test.js"
+		"test:unit": "node --test test/comments/*.test.js test/layers/*.test.js"
 	},
 	"devDependencies": {
 		"publint": "^0.3.22",
-		"vite-plus": "0.2.8"
+		"vite-plus": "1.0.0"
 	},
 	"peerDependencies": {
 		"@stylistic/eslint-plugin": "*",
-		"vite-plus": "0.2.8"
+		"vite-plus": "^1.0.0"
 	},
 	"engines": {
 		"node": ">=20"