@shivaedev/quality 0.3.0 → 0.4.0

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

@@ -0,0 +1,86 @@
+import { posix } from "node:path";
+import { Schema } from "effect";
+import { decodeWith } from "../../../decoded.ts";
+import type { RuleInputs } from "../../../rule.ts";
+
+const Manifest = Schema.Struct({
+	name: Schema.optionalKey(Schema.String),
+	main: Schema.optionalKey(Schema.String),
+	exports: Schema.optionalKey(Schema.Unknown),
+});
+
+type Manifest = typeof Manifest.Type;
+
+const manifestSchema = Schema.toStandardSchemaV1(Schema.fromJsonString(Manifest));
+
+const CONDITIONS: ReadonlySet<string> = new Set(["biome", "default"]);
+
+const SPECIFIER = /^((?:@[^/]+\/)?[^/]+)(?:\/(.+))?$/;
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const targetOf = (value: unknown, star: string | undefined): string | undefined => {
+	if (typeof value === "string") {
+		return star === undefined ? value : value.replaceAll("*", star);
+	}
+	if (Array.isArray(value)) {
+		return value.map((item: unknown) => targetOf(item, star)).find((target) => target !== undefined);
+	}
+	const condition = isRecord(value) ? Object.keys(value).find((key) => CONDITIONS.has(key)) : undefined;
+	return isRecord(value) && condition !== undefined ? targetOf(value[condition], star) : undefined;
+};
+
+const bySpecificity = (left: string, right: string): number => right.indexOf("*") - left.indexOf("*") || right.length - left.length;
+
+const patternTarget = (exports: Readonly<Record<string, unknown>>, key: string): string | undefined => {
+	const pattern = Object.keys(exports)
+		.filter((candidate) => candidate.split("*").length === 2)
+		.sort(bySpecificity)
+		.find((candidate) => {
+			const [prefix = "", suffix = ""] = candidate.split("*");
+			return key.startsWith(prefix) && key !== prefix && key.endsWith(suffix) && key.length >= candidate.length;
+		});
+	const [prefix = "", suffix = ""] = pattern?.split("*") ?? [];
+	return pattern === undefined ? undefined : targetOf(exports[pattern], key.slice(prefix.length, key.length - suffix.length));
+};
+
+const exported = (exports: unknown, subpath: string): string | undefined => {
+	const key = subpath === "" ? "." : `./${subpath}`;
+	if (!isRecord(exports)) {
+		return targetOf(exports, undefined);
+	}
+	return Object.hasOwn(exports, key) ? targetOf(exports[key], undefined) : (patternTarget(exports, key) ?? targetOf(exports, undefined));
+};
+
+const inPackage = (directory: string, target: string | undefined): string | undefined =>
+	target?.startsWith("./") === true ? posix.join(directory, target) : undefined;
+
+const manifestAt = async (readText: RuleInputs["readText"], path: string): Promise<Manifest | undefined> => {
+	const text = await readText(path);
+	const decoded = text === undefined ? undefined : await decodeWith(manifestSchema, text);
+	return decoded?._tag === "Valid" ? decoded.value : undefined;
+};
+
+const fromDependency = (directory: string, manifest: Manifest, subpath: string): string | undefined => {
+	if (manifest.exports !== undefined) {
+		return inPackage(directory, exported(manifest.exports, subpath));
+	}
+	if (subpath === "" && manifest.main !== undefined) {
+		return posix.join(directory, manifest.main);
+	}
+	return subpath === "" ? undefined : posix.join(directory, subpath);
+};
+
+export const resolvePackage = async (readText: RuleInputs["readText"], specifier: string): Promise<string | undefined> => {
+	const [, name, subpath = ""] = SPECIFIER.exec(specifier) ?? [];
+	if (name === undefined) {
+		return undefined;
+	}
+	const own = await manifestAt(readText, "package.json");
+	if (own?.name === name && own.exports !== undefined && subpath !== "") {
+		return inPackage("", exported(own.exports, subpath));
+	}
+	const directory = posix.join("node_modules", name);
+	const manifest = await manifestAt(readText, posix.join(directory, "package.json"));
+	return manifest === undefined ? undefined : fromDependency(directory, manifest, subpath);
+};

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 line: number;
+	readonly layer: Layer;
 }
 
 interface Setting {
 	readonly rule: string;
 	readonly line: number;
+	readonly weak: boolean;
+	readonly wholeGroup: boolean;
 }
 
 const LINT_WEAK = new Set(["off", "warn", "info"]);
@@ -18,39 +22,45 @@ 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): ReadonlyArray<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): ReadonlyArray<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): ReadonlyArray<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> =>
+	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): ReadonlyArray<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)),
-		]);
+		.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): ReadonlyArray<Setting> => [
-	...disabled("lint", section),
-	...withoutDefaults("lint/recommended", member(section, "rules")),
+	...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")),
+	...enabled("assist", section),
+	...defaults("assist/recommended", member(section, "actions")),
 	...groupSettings("assist", ASSIST_WEAK, member(section, "actions")),
 ];
 
@@ -64,17 +74,15 @@ 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): ReadonlyArray<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 includes = itemsOf(member(override, "includes")).flatMap((item) => textOf(item) ?? []);
@@ -84,19 +92,28 @@ const includesOf = (override: Json): ReadonlyArray<string> => {
 const narrowsScope = (globs: ReadonlyArray<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): ReadonlyArray<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: ReadonlyArray<Layer>, base: string): ReadonlyArray<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): ReadonlyArray<Weakening> =>
+	layers.flatMap((layer, index) => layerWeakenings(layer, layers.slice(index + 1), base));

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

@@ -1,43 +1,53 @@
 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): ReadonlyArray<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: ReadonlyArray<Weakening>, shipped: ReadonlyArray<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",
@@ -46,16 +56,15 @@ export const biomeOverrides = defineRule({
 	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)),
 		];
 	},
 });

package/tsconfig/base.json

@@ -0,0 +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,
+		"checkJs": true,
+		"noEmit": true,
+		"strict": true,
+		"noImplicitAny": true,
+		"strictBuiltinIteratorReturn": true,
+		"useUnknownInCatchVariables": true,
+		"noUncheckedIndexedAccess": true,
+		"exactOptionalPropertyTypes": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"allowUnreachableCode": false,
+		"allowUnusedLabels": false,
+		"noUncheckedSideEffectImports": true,
+		"libReplacement": false,
+		"stableTypeOrdering": true,
+		"forceConsistentCasingInFileNames": true,
+		"skipLibCheck": true
+	}
+}

package/tsconfig/package.json

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