@shivaedev/quality 0.4.0 → 0.5.0

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

@@ -3,15 +3,15 @@ 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 line: number;
+	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;
 }
@@ -22,18 +22,18 @@ 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, weak: boolean, wholeGroup = false): ReadonlyArray<Setting> =>
+const at = (rule: string, node: Json | undefined, weak: boolean, wholeGroup = false): readonly Setting[] =>
 	node === undefined ? [] : [{ line: node.line, rule, weak, wholeGroup }];
 
-const enabled = (rule: string, section: Json | undefined): ReadonlyArray<Setting> =>
+const enabled = (rule: string, section: Json | undefined): readonly Setting[] =>
 	at(rule, member(section, "enabled"), isFalse(member(section, "enabled")));
 
-const defaults = (rule: string, set: Json | undefined): ReadonlyArray<Setting> => [
+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 ruleSettings = (group: string, weak: ReadonlySet<string>, rules: Json): ReadonlyArray<Setting> =>
+const ruleSettings = (group: string, weak: ReadonlySet<string>, rules: Json): readonly Setting[] =>
 	entriesOf(rules)
 		.filter(([rule]) => !PRESETS.has(rule))
 		.flatMap(([rule, setting]) => {
@@ -41,7 +41,7 @@ const ruleSettings = (group: string, weak: ReadonlySet<string>, rules: Json): Re
 			return level === undefined ? [] : at(`${group}/${rule}`, setting, weak.has(level));
 		});
 
-const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): ReadonlyArray<Setting> =>
+const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json | undefined): readonly Setting[] =>
 	entriesOf(groups)
 		.filter(([group]) => !PRESETS.has(group))
 		.flatMap(([group, rules]) => {
@@ -51,20 +51,20 @@ const groupSettings = (prefix: string, weak: ReadonlySet<string>, groups: Json |
 				: at(`${prefix}/${group}`, rules, weak.has(severity), true);
 		});
 
-const linter = (section: Json | undefined): ReadonlyArray<Setting> => [
+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")).flatMap(([domain, value]) => at(`lint/domains/${domain}`, value, textOf(value) === "none")),
 ];
 
-const assist = (section: Json | undefined): ReadonlyArray<Setting> => [
+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"],
@@ -74,7 +74,7 @@ const TOOLS: ReadonlyArray<readonly [string, string]> = [
 
 const SCOPED_SECTIONS: ReadonlyArray<readonly [string, string]> = [["files", "files"], ...TOOLS];
 
-const settingsOf = (scope: Json): ReadonlyArray<Setting> => [
+const settingsOf = (scope: Json): readonly Setting[] => [
 	...linter(member(scope, "linter")),
 	...assist(member(scope, "assist")),
 	...enabled("format", member(scope, "formatter")),
@@ -84,15 +84,14 @@ const settingsOf = (scope: Json): ReadonlyArray<Setting> => [
 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, base: string): ReadonlyArray<Omit<Weakening, "layer">> =>
+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) ?? []);
@@ -101,7 +100,7 @@ const narrowings = (config: Json, base: string): ReadonlyArray<Omit<Weakening, "
 			: [{ includes: globs.map((glob) => scoped(base, glob)), line: list.line, rule: `${name}/includes` }];
 	});
 
-const layerWeakenings = (layer: Layer, later: ReadonlyArray<Layer>, base: string): ReadonlyArray<Weakening> => {
+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 [
@@ -115,5 +114,5 @@ const layerWeakenings = (layer: Layer, later: ReadonlyArray<Layer>, base: string
 	].map((weakening) => ({ ...weakening, layer }));
 };
 
-export const weakeningsOf = ({ base, layers }: Chain): ReadonlyArray<Weakening> =>
+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

@@ -12,7 +12,7 @@ interface Shipped extends Scoped {
 	readonly specifier: string;
 }
 
-const shippedBy = ({ base, layers }: Chain): ReadonlyArray<Shipped> =>
+const shippedBy = ({ base, layers }: Chain): readonly Shipped[] =>
 	layers.flatMap(({ preset }) =>
 		preset === undefined
 			? []
@@ -41,7 +41,7 @@ const repeated = (file: string, declaration: Scoped, shipped: Shipped): Finding
 	subject: declaration.rule,
 });
 
-const staleOrRepeated = (file: string, weakenings: ReadonlyArray<Weakening>, shipped: ReadonlyArray<Shipped>) => (declaration: Scoped) => {
+const staleOrRepeated = (file: string, weakenings: readonly Weakening[], shipped: readonly Shipped[]) => (declaration: Scoped) => {
 	if (!weakenings.some((weakening) => matches(declaration, weakening))) {
 		return [unused(file, declaration)];
 	}
@@ -50,11 +50,6 @@ const staleOrRepeated = (file: string, weakenings: ReadonlyArray<Weakening>, shi
 };
 
 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 { chains, problems, root } = await biomeConfigs(inputs);
 		const { declared } = inputs.options;
@@ -67,4 +62,9 @@ export const biomeOverrides = defineRule({
 			...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

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

package/tsconfig/package.json

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