@shivaedev/quality 0.3.1 → 0.5.0

package/src/rules/suppressions/biome/weakenings.ts

@@ -1,15 +1,19 @@
+import type { Chain, Layer } from "./configs.ts";
+import { scoped } from "./declarations.ts";
 import { entriesOf, isFalse, itemsOf, type Json, member, textOf } from "./json.ts";
 
 export interface Weakening {
-	readonly rule: string;
-	readonly includes: ReadonlyArray<string>;
-	readonly file: string;
+	readonly includes: readonly string[];
+	readonly layer: Layer;
 	readonly line: number;
+	readonly rule: string;
 }
 
 interface Setting {
-	readonly rule: string;
 	readonly line: number;
+	readonly rule: string;
+	readonly weak: boolean;
+	readonly wholeGroup: boolean;
 }
 
 const LINT_WEAK = new Set(["off", "warn", "info"]);
@@ -18,43 +22,49 @@ const PRESETS = new Set(["recommended", "preset"]);
 
 const levelOf = (node: Json): string | undefined => textOf(node) ?? textOf(member(node, "level"));
 
-const at = (rule: string, node: Json | undefined): ReadonlyArray<Setting> => (node === undefined ? [] : [{ line: node.line, rule }]);
+const at = (rule: string, node: Json | undefined, weak: boolean, wholeGroup = false): readonly Setting[] =>
+	node === undefined ? [] : [{ line: node.line, rule, weak, wholeGroup }];
 
-const disabled = (rule: string, section: Json | undefined): ReadonlyArray<Setting> =>
-	isFalse(member(section, "enabled")) ? at(rule, member(section, "enabled")) : [];
+const enabled = (rule: string, section: Json | undefined): readonly Setting[] =>
+	at(rule, member(section, "enabled"), isFalse(member(section, "enabled")));
 
-const withoutDefaults = (rule: string, set: Json | undefined): ReadonlyArray<Setting> => [
-	...(isFalse(member(set, "recommended")) ? at(rule, member(set, "recommended")) : []),
-	...(textOf(member(set, "preset")) === "none" ? at(rule, member(set, "preset")) : []),
+const defaults = (rule: string, set: Json | undefined): readonly Setting[] => [
+	...at(rule, member(set, "recommended"), isFalse(member(set, "recommended"))),
+	...at(rule, member(set, "preset"), textOf(member(set, "preset")) === "none"),
 ];
 
-const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): ReadonlyArray<Setting> =>
+const ruleSettings = (group: string, weak: ReadonlySet<string>, rules: Json): readonly Setting[] =>
+	entriesOf(rules)
+		.filter(([rule]) => !PRESETS.has(rule))
+		.flatMap(([rule, setting]) => {
+			const level = levelOf(setting);
+			return level === undefined ? [] : at(`${group}/${rule}`, setting, weak.has(level));
+		});
+
+const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): readonly Setting[] =>
 	entriesOf(groups)
 		.filter(([group]) => !PRESETS.has(group))
-		.flatMap(([group, rules]) => [
-			...(weak.has(textOf(rules) ?? "") ? at(`${prefix}/${group}`, rules) : []),
-			...withoutDefaults(`${prefix}/${group}`, rules),
-			...entriesOf(rules)
-				.filter(([rule, setting]) => !PRESETS.has(rule) && weak.has(levelOf(setting) ?? ""))
-				.flatMap(([rule, setting]) => at(`${prefix}/${group}/${rule}`, setting)),
-		]);
-
-const linter = (section: Json | undefined): ReadonlyArray<Setting> => [
-	...disabled("lint", section),
-	...withoutDefaults("lint/recommended", member(section, "rules")),
+		.flatMap(([group, rules]) => {
+			const severity = textOf(rules);
+			return severity === undefined
+				? [...defaults(`${prefix}/${group}`, rules), ...ruleSettings(`${prefix}/${group}`, weak, rules)]
+				: at(`${prefix}/${group}`, rules, weak.has(severity), true);
+		});
+
+const linter = (section: Json | undefined): readonly Setting[] => [
+	...enabled("lint", section),
+	...defaults("lint/recommended", member(section, "rules")),
 	...groupSettings("lint", LINT_WEAK, member(section, "rules")),
-	...entriesOf(member(section, "domains"))
-		.filter(([, value]) => textOf(value) === "none")
-		.flatMap(([domain, value]) => at(`lint/domains/${domain}`, value)),
+	...entriesOf(member(section, "domains")).flatMap(([domain, value]) => at(`lint/domains/${domain}`, value, textOf(value) === "none")),
 ];
 
-const assist = (section: Json | undefined): ReadonlyArray<Setting> => [
-	...disabled("assist", section),
-	...withoutDefaults("assist/recommended", member(section, "actions")),
+const assist = (section: Json | undefined): readonly Setting[] => [
+	...enabled("assist", section),
+	...defaults("assist/recommended", member(section, "actions")),
 	...groupSettings("assist", ASSIST_WEAK, member(section, "actions")),
 ];
 
-const LANGUAGES: ReadonlyArray<string> = ["javascript", "json", "css", "graphql", "grit", "html"];
+const LANGUAGES: readonly string[] = ["javascript", "json", "css", "graphql", "grit", "html"];
 
 const TOOLS: ReadonlyArray<readonly [string, string]> = [
 	["linter", "lint"],
@@ -64,39 +74,45 @@ const TOOLS: ReadonlyArray<readonly [string, string]> = [
 
 const SCOPED_SECTIONS: ReadonlyArray<readonly [string, string]> = [["files", "files"], ...TOOLS];
 
-const scopeSettings = (scope: Json): ReadonlyArray<Setting> => [
+const settingsOf = (scope: Json): readonly Setting[] => [
 	...linter(member(scope, "linter")),
 	...assist(member(scope, "assist")),
-	...disabled("format", member(scope, "formatter")),
-	...LANGUAGES.flatMap((language) => TOOLS.flatMap(([key, name]) => disabled(`${language}/${name}`, member(member(scope, language), key)))),
+	...enabled("format", member(scope, "formatter")),
+	...LANGUAGES.flatMap((language) => TOOLS.flatMap(([key, name]) => enabled(`${language}/${name}`, member(member(scope, language), key)))),
 ];
 
-const scoped = (base: string, glob: string): string => {
-	const [, negation = "", path = glob] = /^(!*)(.*)$/.exec(glob) ?? [];
-	return base === "" ? glob : `${negation}${base}/${path}`;
-};
+const replaces = (later: Setting, earlier: Setting): boolean =>
+	later.rule === earlier.rule || (later.wholeGroup && earlier.rule.startsWith(`${later.rule}/`));
 
-const includesOf = (override: Json): ReadonlyArray<string> => {
+const includesOf = (override: Json): readonly string[] => {
 	const includes = itemsOf(member(override, "includes")).flatMap((item) => textOf(item) ?? []);
 	return includes.length === 0 ? ["**"] : includes;
 };
 
-const narrowsScope = (globs: ReadonlyArray<string>): boolean =>
-	globs.length > 0 && (globs.some((glob) => glob.startsWith("!")) || !globs.includes("**"));
+const narrowsScope = (globs: readonly string[]): boolean => globs.length > 0 && (globs.some((glob) => glob.startsWith("!")) || !globs.includes("**"));
 
-const narrowings = (config: Json, file: string, base: string): ReadonlyArray<Weakening> =>
+const narrowings = (config: Json, base: string): readonly Omit<Weakening, "layer">[] =>
 	SCOPED_SECTIONS.flatMap(([key, name]) => {
 		const list = member(member(config, key), "includes");
 		const globs = itemsOf(list).flatMap((item) => textOf(item) ?? []);
 		return list === undefined || !narrowsScope(globs)
 			? []
-			: [{ file, includes: globs.map((glob) => scoped(base, glob)), line: list.line, rule: `${name}/includes` }];
+			: [{ includes: globs.map((glob) => scoped(base, glob)), line: list.line, rule: `${name}/includes` }];
 	});
 
-export const weakeningsOf = (config: Json, file: string, base: string): ReadonlyArray<Weakening> => [
-	...narrowings(config, file, base),
-	...scopeSettings(config).map((setting) => ({ ...setting, file, includes: [scoped(base, "**")] })),
-	...itemsOf(member(config, "overrides")).flatMap((override) =>
-		scopeSettings(override).map((setting) => ({ ...setting, file, includes: includesOf(override).map((glob) => scoped(base, glob)) })),
-	),
-];
+const layerWeakenings = (layer: Layer, later: readonly Layer[], base: string): readonly Weakening[] => {
+	const overriding = later.flatMap((next) => settingsOf(next.json));
+	const top = settingsOf(layer.json).filter((setting) => setting.weak && !overriding.some((next) => replaces(next, setting)));
+	return [
+		...narrowings(layer.json, base),
+		...top.map(({ line, rule }) => ({ includes: [scoped(base, "**")], line, rule })),
+		...itemsOf(member(layer.json, "overrides")).flatMap((override) =>
+			settingsOf(override)
+				.filter((setting) => setting.weak)
+				.map(({ line, rule }) => ({ includes: includesOf(override).map((glob) => scoped(base, glob)), line, rule })),
+		),
+	].map((weakening) => ({ ...weakening, layer }));
+};
+
+export const weakeningsOf = ({ base, layers }: Chain): readonly Weakening[] =>
+	layers.flatMap((layer, index) => layerWeakenings(layer, layers.slice(index + 1), base));

package/src/rules/suppressions/biome-overrides.ts

@@ -1,61 +1,70 @@
 import { Effect, Schema } from "effect";
 import { defineRule, type Finding } from "../../rule.ts";
-import { biomeConfigs, type Config } from "./biome/configs.ts";
+import { biomeConfigs, type Chain } from "./biome/configs.ts";
+import { Declaration, matches, type Scoped, scoped, scopeText } from "./biome/declarations.ts";
 import { type Weakening, weakeningsOf } from "./biome/weakenings.ts";
 
-const Declaration = Schema.Struct({
-	rule: Schema.NonEmptyString,
-	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
-	reason: Schema.String.check(Schema.isPattern(/\S/, { expected: "a reason that says why the scope needs the rule weakened" })),
-});
-
-type Declaration = typeof Declaration.Type;
-
 const BiomeOverridesOptions = Schema.Struct({
 	declared: Schema.Array(Declaration).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
 });
 
-const sameScope = (left: ReadonlyArray<string>, right: ReadonlyArray<string>): boolean =>
-	new Set(left).size === new Set(right).size && left.every((glob) => right.includes(glob));
+interface Shipped extends Scoped {
+	readonly specifier: string;
+}
 
-const matches = (declaration: Declaration, weakening: Weakening): boolean =>
-	declaration.rule === weakening.rule && sameScope(declaration.includes, weakening.includes);
+const shippedBy = ({ base, layers }: Chain): readonly Shipped[] =>
+	layers.flatMap(({ preset }) =>
+		preset === undefined
+			? []
+			: preset.declared.map(({ includes, rule }) => ({ includes: includes.map((glob) => scoped(base, glob)), rule, specifier: preset.specifier })),
+	);
 
-const scopeText = (includes: ReadonlyArray<string>): string => includes.map((glob) => `"${glob}"`).join(", ");
+const undeclared = ({ includes, layer, line, rule }: Weakening): Finding =>
+	layer.preset === undefined
+		? { file: layer.path, line, message: `Weakens "${rule}" for ${scopeText(includes)} without a declaration.`, subject: rule }
+		: {
+				file: layer.preset.file,
+				line: layer.preset.line,
+				message: `Extends "${layer.preset.specifier}", which weakens "${rule}" for ${scopeText(includes)} without a declaration.`,
+				subject: rule,
+			};
 
-const undeclared = (weakening: Weakening): Finding => ({
-	file: weakening.file,
-	line: weakening.line,
-	message: `Weakens "${weakening.rule}" for ${scopeText(weakening.includes)} without a declaration.`,
-	subject: weakening.rule,
+const unused = (file: string, declaration: Scoped): Finding => ({
+	file,
+	message: `Declares "${declaration.rule}" for ${scopeText(declaration.includes)}, which no Biome config weakens. Remove the declaration.`,
+	subject: declaration.rule,
 });
 
-const unused = (file: string, declaration: Declaration): Finding => ({
+const repeated = (file: string, declaration: Scoped, shipped: Shipped): Finding => ({
 	file,
-	message: `Declares "${declaration.rule}" for ${scopeText(declaration.includes)}, which no Biome config weakens. Remove the declaration.`,
+	message: `Declares "${declaration.rule}" for ${scopeText(declaration.includes)}, which "${shipped.specifier}" already declares. Remove the declaration.`,
 	subject: declaration.rule,
 });
 
-const unreadable = (config: Config): ReadonlyArray<Finding> =>
-	config._tag === "Unreadable" ? [{ file: config.path, message: `Cannot read this Biome config: ${config.reason}.` }] : [];
+const staleOrRepeated = (file: string, weakenings: readonly Weakening[], shipped: readonly Shipped[]) => (declaration: Scoped) => {
+	if (!weakenings.some((weakening) => matches(declaration, weakening))) {
+		return [unused(file, declaration)];
+	}
+	const already = shipped.find((candidate) => matches(declaration, candidate));
+	return already === undefined ? [] : [repeated(file, declaration, already)];
+};
 
 export const biomeOverrides = defineRule({
-	id: "suppressions/biome-overrides",
-	description:
-		"A Biome setting that turns a check off or down, or keeps files out of it, is an exception for every file it covers. Fix the code and remove the setting, or declare its rule, includes and reason under this rule's declared option.",
-	options: Schema.toStandardSchemaV1(BiomeOverridesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
-	registrable: false,
 	check: async (inputs) => {
-		const configs = await biomeConfigs(inputs);
+		const { chains, problems, root } = await biomeConfigs(inputs);
 		const { declared } = inputs.options;
-		const weakenings = configs.flatMap((config) => (config._tag === "Config" ? weakeningsOf(config.json, config.path, config.base) : []));
-		const root = configs.find((config) => !config.path.includes("/"))?.path ?? "biome.json";
+		const weakenings = chains.flatMap(weakeningsOf);
+		const shipped = chains.flatMap(shippedBy);
+		const covered = (weakening: Weakening): boolean => [...declared, ...shipped].some((declaration) => matches(declaration, weakening));
 		return [
-			...configs.flatMap(unreadable),
-			...weakenings.filter((weakening) => !declared.some((declaration) => matches(declaration, weakening))).map(undeclared),
-			...declared
-				.filter((declaration) => !weakenings.some((weakening) => matches(declaration, weakening)))
-				.map((declaration) => unused(root, declaration)),
+			...problems,
+			...weakenings.filter((weakening) => !covered(weakening)).map(undeclared),
+			...declared.flatMap(staleOrRepeated(root, weakenings, shipped)),
 		];
 	},
+	description:
+		"A Biome setting that turns a check off or down, or keeps files out of it, is an exception for every file it covers. Fix the code and remove the setting, or declare its rule, includes and reason under this rule's declared option.",
+	id: "suppressions/biome-overrides",
+	options: Schema.toStandardSchemaV1(BiomeOverridesOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+	registrable: false,
 });

package/src/rules/suppressions/directives.ts

@@ -1,24 +1,24 @@
 import type { SourceComment } from "../comments/scan.ts";
 
-export const SUPPRESSIONS: ReadonlyArray<RegExp> = [
-	/^biome-ignore(?:-all|-start)?(?![\w-])/,
-	/^@ts-(?:ignore|expect-error|nocheck)(?![\w-])/,
-	/^(?:eslint|oxlint|stylelint)-disable(?:-next-line|-line)?(?![\w-])/,
-	/^deno-lint-ignore(?:-file)?(?![\w-])/,
-	/^tslint:disable/,
-	/^prettier-ignore(?![\w-])/,
-	/^\$Flow(?:FixMe|Ignore|ExpectedError|Issue)(?!\w)/,
-	/^@noflow(?!\w)/,
+export const SUPPRESSIONS: readonly RegExp[] = [
+	/^biome-ignore(?:-all|-start)?(?![\w-])/u,
+	/^@ts-(?:ignore|expect-error|nocheck)(?![\w-])/u,
+	/^(?:eslint|oxlint|stylelint)-disable(?:-next-line|-line)?(?![\w-])/u,
+	/^deno-lint-ignore(?:-file)?(?![\w-])/u,
+	/^tslint:disable/u,
+	/^prettier-ignore(?![\w-])/u,
+	/^\$Flow(?:FixMe|Ignore|ExpectedError|Issue)(?!\w)/u,
+	/^@noflow(?!\w)/u,
 ];
 
-const INLINE_ESLINT_CONFIG = /^eslint\s+["']?[\w@/-]+["']?\s*:/;
+const INLINE_ESLINT_CONFIG = /^eslint\s+["']?[\w@/-]+["']?\s*:/u;
 
-const LEADER = /^[\s/*]+/;
+const LEADER = /^[\s/*]+/u;
 
 const directiveOn = (comment: SourceComment, line: string): string | undefined => {
 	const content = line.replace(LEADER, "");
 	const patterns = comment.kind === "block" ? [...SUPPRESSIONS, INLINE_ESLINT_CONFIG] : SUPPRESSIONS;
-	return patterns.map((pattern) => pattern.exec(content)?.[0].replace(/\s*:$/, "")).find((match) => match !== undefined);
+	return patterns.map((pattern) => pattern.exec(content)?.[0].replace(/\s*:$/u, "")).find((match) => match !== undefined);
 };
 
 export const suppressionIn = (comment: SourceComment): string | undefined =>

package/src/rules/suppressions/no-double-cast.ts

@@ -19,7 +19,7 @@ const bridgeOf = (node: Assertion): string | undefined => {
 	return isAssertion(inner) ? BRIDGES.get(inner.type.kind) : undefined;
 };
 
-const castsIn = (path: string, source: ts.SourceFile): ReadonlyArray<Finding> => {
+const castsIn = (path: string, source: ts.SourceFile): readonly Finding[] => {
 	const findings: Finding[] = [];
 	const visit = (node: ts.Node): void => {
 		const bridge = isAssertion(node) ? bridgeOf(node) : undefined;
@@ -33,15 +33,15 @@ const castsIn = (path: string, source: ts.SourceFile): ReadonlyArray<Finding> =>
 	return findings;
 };
 
-const doubleCasts = (file: SourceFile): ReadonlyArray<Finding> => {
+const doubleCasts = (file: SourceFile): readonly Finding[] => {
 	const source = parse(file);
 	return source === undefined ? [] : castsIn(file.path, source);
 };
 
 export const noDoubleCast = defineRule({
-	id: "suppressions/no-double-cast",
+	check: ({ sources }) => sources.flatMap(doubleCasts),
 	description:
 		"A cast through unknown, any or never silences the compiler the way a suppression does. Decode the value at its boundary, narrow it, or fix the type that disagrees.",
+	id: "suppressions/no-double-cast",
 	registrable: false,
-	check: ({ sources }) => sources.flatMap(doubleCasts),
 });

package/src/rules/suppressions/no-inline.ts

@@ -1,63 +1,39 @@
-import { Effect, Schema } from "effect";
-import ignore from "ignore";
-import { CONFIG_FILE } from "../../config/file.ts";
 import { defineRule, type Finding, type RuleInputs } from "../../rule.ts";
 import { type SourceComment, scanComments } from "../comments/scan.ts";
 import { suppressionIn } from "./directives.ts";
 import { STYLESHEET, stylesheetComments } from "./stylesheet-comments.ts";
 
-const Declaration = Schema.Struct({
-	directive: Schema.Literal("@ts-expect-error"),
-	includes: Schema.NonEmptyArray(Schema.NonEmptyString),
-	reason: Schema.String.check(Schema.isPattern(/\S/, { expected: "a reason that says why these files assert type errors" })),
-});
-
-type Declaration = typeof Declaration.Type;
+const TYPE_TEST = /(?:^|[/.])typecheck\.test\.[cm]?[jt]sx?$/u;
 
-const NoInlineOptions = Schema.Struct({
-	declared: Schema.Array(Declaration).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
-});
+const TYPE_TEST_DIRECTIVE = "@ts-expect-error";
 
 interface Site extends Finding {
 	readonly subject: string;
 }
 
-const sitesIn = (file: string, comments: ReadonlyArray<SourceComment>): ReadonlyArray<Site> =>
+const sitesIn = (file: string, comments: readonly SourceComment[]): readonly Site[] =>
 	comments.flatMap((comment) => {
 		const directive = suppressionIn(comment);
 		return directive === undefined ? [] : [{ file, line: comment.line, message: `Suppresses a check: "${directive}".`, subject: directive }];
 	});
 
-const stylesheetSites = async ({ files, readText, sources }: RuleInputs): Promise<ReadonlyArray<Site>> => {
+const stylesheetSites = async ({ files, readText, sources }: RuleInputs): Promise<readonly Site[]> => {
 	const read = files.filter((path) => STYLESHEET.test(path));
 	const texts = await Promise.all(read.map(async (path) => sources.find((source) => source.path === path)?.text ?? (await readText(path))));
 	return read.flatMap((path, index) => sitesIn(path, stylesheetComments(path, texts[index] ?? "")));
 };
 
-const allows = (declaration: Declaration, site: Site): boolean =>
-	declaration.directive === site.subject &&
-	ignore()
-		.add([...declaration.includes])
-		.ignores(site.file);
-
-const unused = (declaration: Declaration): Finding => ({
-	file: CONFIG_FILE,
-	message: `Declares "${declaration.directive}" for ${declaration.includes.map((glob) => `"${glob}"`).join(", ")}, which matches no directive. Remove the declaration.`,
-	subject: declaration.directive,
-});
+function allowed(site: Site): boolean {
+	return site.subject === TYPE_TEST_DIRECTIVE && TYPE_TEST.test(site.file);
+}
 
 export const noInline = defineRule({
-	id: "suppressions/no-inline",
+	check: async (inputs) =>
+		[...inputs.sources.flatMap((file) => sitesIn(file.path, scanComments(file))), ...(await stylesheetSites(inputs))].filter(
+			(site) => !allowed(site),
+		),
 	description:
-		"A suppression silences a check at one site instead of fixing the cause. Fix the code; where a lint rule truly cannot apply, turn it off for that scope in the Biome config and declare it under suppressions/biome-overrides.",
-	options: Schema.toStandardSchemaV1(NoInlineOptions, { parseOptions: { errors: "all", onExcessProperty: "error" } }),
+		"A suppression silences a check at one site instead of fixing the cause. Fix the code; where a lint rule truly cannot apply, turn it off for that scope in the Biome config and declare it under suppressions/biome-overrides. A type test asserts a compile error with @ts-expect-error in a *.typecheck.test.ts file.",
+	id: "suppressions/no-inline",
 	registrable: false,
-	check: async (inputs) => {
-		const { declared } = inputs.options;
-		const sites = [...inputs.sources.flatMap((file) => sitesIn(file.path, scanComments(file))), ...(await stylesheetSites(inputs))];
-		return [
-			...sites.filter((site) => !declared.some((declaration) => allows(declaration, site))),
-			...declared.filter((declaration) => !sites.some((site) => allows(declaration, site))).map(unused),
-		];
-	},
 });

package/src/rules/suppressions/stylesheet-comments.ts

@@ -1,12 +1,12 @@
 import { bodyOf, type SourceComment } from "../comments/scan.ts";
 
-export const STYLESHEET = /\.(?:css|scss|less)$/;
+export const STYLESHEET = /\.(?:css|scss|less)$/u;
 
-const LINE_COMMENTS = /\.(?:scss|less)$/;
+const LINE_COMMENTS = /\.(?:scss|less)$/u;
 
 const TOKENS = String.raw`"(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?|url\([^)]*\)?|\/\*[\s\S]*?(?:\*\/|$)`;
 
-const tokensOf = (path: string): RegExp => new RegExp(LINE_COMMENTS.test(path) ? `${TOKENS}|\\/\\/[^\\n]*` : TOKENS, "gi");
+const tokensOf = (path: string): RegExp => new RegExp(LINE_COMMENTS.test(path) ? `${TOKENS}|\\/\\/[^\\n]*` : TOKENS, "giu");
 
 const lineOf = (text: string, offset: number): number => text.slice(0, offset).split("\n").length;
 
@@ -23,5 +23,5 @@ const toComment = (text: string, token: string, offset: number): SourceComment =
 	};
 };
 
-export const stylesheetComments = (path: string, text: string): ReadonlyArray<SourceComment> =>
+export const stylesheetComments = (path: string, text: string): readonly SourceComment[] =>
 	[...text.matchAll(tokensOf(path))].flatMap((match) => (match[0].startsWith("/") ? [toComment(text, match[0], match.index)] : []));

package/src/rules/syntax.ts

@@ -2,10 +2,10 @@ import ts from "typescript";
 import type { SourceFile } from "../rule.ts";
 
 const SCRIPT_KINDS: ReadonlyArray<readonly [RegExp, ts.ScriptKind]> = [
-	[/\.[cm]?ts$/, ts.ScriptKind.TS],
-	[/\.tsx$/, ts.ScriptKind.TSX],
-	[/\.[cm]?js$/, ts.ScriptKind.JS],
-	[/\.jsx$/, ts.ScriptKind.JSX],
+	[/\.[cm]?ts$/u, ts.ScriptKind.TS],
+	[/\.tsx$/u, ts.ScriptKind.TSX],
+	[/\.[cm]?js$/u, ts.ScriptKind.JS],
+	[/\.jsx$/u, ts.ScriptKind.JSX],
 ];
 
 export const parse = (file: SourceFile): ts.SourceFile | undefined => {

package/src/standard-schema.ts

@@ -9,7 +9,7 @@ export interface StandardSchemaV1<Input = unknown, Output = Input> {
 	};
 }
 
-export type StandardResult<Output> = { readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<StandardIssue> };
+export type StandardResult<Output> = { readonly value: Output; readonly issues?: undefined } | { readonly issues: readonly StandardIssue[] };
 
 export interface StandardIssue {
 	readonly message: string;

package/src/vitest.ts

@@ -0,0 +1,22 @@
+import { defaultExclude, type TestUserConfig } from "vitest/config";
+
+const TEST = "**/*.test.?(c|m)[jt]s?(x)";
+const DOM = "**/*.dom.test.?(c|m)[jt]s?(x)";
+const SLOW = "**/*.slow.test.?(c|m)[jt]s?(x)";
+const TYPECHECK = "**/*.typecheck.test.?(c|m)[jt]s?(x)";
+const TYPECHECK_ALONE = "**/typecheck.test.?(c|m)[jt]s?(x)";
+
+function excluding(...patterns: readonly string[]): string[] {
+	return [...defaultExclude, TYPECHECK, TYPECHECK_ALONE, ...patterns];
+}
+
+export function testProjects(): TestUserConfig {
+	return {
+		project: ["unit", "dom"],
+		projects: [
+			{ extends: true, test: { environment: "node", exclude: excluding(DOM, SLOW), include: [TEST], name: "unit" } },
+			{ extends: true, test: { environment: "happy-dom", exclude: excluding(SLOW), include: [DOM], name: "dom" } },
+			{ extends: true, test: { environment: "node", exclude: excluding(), include: [SLOW], name: "slow" } },
+		],
+	};
+}

package/tsconfig/base.json

@@ -0,0 +1,35 @@
+{
+	"compilerOptions": {
+		"allowImportingTsExtensions": true,
+		"allowJs": true,
+		"allowUnreachableCode": false,
+		"allowUnusedLabels": false,
+		"checkJs": true,
+		"erasableSyntaxOnly": true,
+		"exactOptionalPropertyTypes": true,
+		"forceConsistentCasingInFileNames": true,
+		"isolatedModules": true,
+		"lib": ["ESNext"],
+		"libReplacement": false,
+		"module": "ESNext",
+		"moduleDetection": "force",
+		"moduleResolution": "bundler",
+		"noEmit": true,
+		"noFallthroughCasesInSwitch": true,
+		"noImplicitAny": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noUncheckedIndexedAccess": true,
+		"noUncheckedSideEffectImports": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"stableTypeOrdering": true,
+		"strict": true,
+		"strictBuiltinIteratorReturn": true,
+		"target": "ESNext",
+		"useUnknownInCatchVariables": true,
+		"verbatimModuleSyntax": true
+	}
+}

package/tsconfig/package.json

@@ -0,0 +1,10 @@
+{
+	"compilerOptions": {
+		"noEmit": false,
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"rewriteRelativeImportExtensions": true
+	},
+	"extends": "./base.json"
+}