@shivaedev/quality 0.27.0 → 0.27.1

package/src/inventory/shadcnAlias.ts

@@ -0,0 +1,88 @@
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import ts from "typescript";
+
+const PROBE = "__quality_shadcn__.tsx";
+
+function capture(pattern: string, alias: string): string | undefined {
+	const star = pattern.indexOf("*");
+	if (star === -1) {
+		return pattern === alias ? "" : undefined;
+	}
+	const prefix = pattern.slice(0, star);
+	const suffix = pattern.slice(star + 1);
+	return alias.startsWith(prefix) && alias.endsWith(suffix)
+		? alias.slice(prefix.length, suffix.length === 0 ? undefined : -suffix.length)
+		: undefined;
+}
+
+function pathTarget(alias: string, options: ts.CompilerOptions, directory: string): string | undefined {
+	const pathsBase = Reflect.get(options, "pathsBasePath");
+	const base = options.baseUrl ?? (typeof pathsBase === "string" ? pathsBase : directory);
+	const patterns = Object.entries(options.paths ?? {}).toSorted(([left], [right]) => right.indexOf("*") - left.indexOf("*"));
+	const exact = options.paths?.[alias]?.[0];
+	if (exact !== undefined) {
+		return resolve(base, exact);
+	}
+	for (const [pattern, targets] of patterns) {
+		const captured = capture(pattern, alias);
+		const target = targets[0];
+		if (captured !== undefined && target !== undefined) {
+			return resolve(base, target.replace("*", captured));
+		}
+	}
+	return undefined;
+}
+
+export function shadcnAlias(directory: string, alias: string): string {
+	if (alias.startsWith(".") || isAbsolute(alias)) {
+		return resolve(directory, alias);
+	}
+	const config = ts.findConfigFile(directory, ts.sys.fileExists);
+	const parsed =
+		config === undefined
+			? undefined
+			: ts.getParsedCommandLineOfConfigFile(
+					config,
+					{},
+					{
+						...ts.sys,
+						onUnRecoverableConfigFileDiagnostic: () => undefined,
+					},
+				);
+	if (parsed?.errors.length) {
+		throw new Error(
+			ts.formatDiagnostics(parsed.errors, {
+				getCanonicalFileName: (file) => file,
+				getCurrentDirectory: () => directory,
+				getNewLine: () => "\n",
+			}),
+		);
+	}
+	const options = parsed?.options ?? {};
+	const target = pathTarget(alias, options, config === undefined ? directory : dirname(config));
+	if (target !== undefined) {
+		return target;
+	}
+	if (!alias.startsWith("#")) {
+		throw new Error(`Cannot resolve shadcn UI alias "${alias}" from ${directory}. Check tsconfig paths.`);
+	}
+	// A synthetic child lets TypeScript resolve directory aliases through package imports without requiring a stock component to exist.
+	const resolved = ts.resolveModuleName(
+		`${alias}/${PROBE}`,
+		join(directory, "components.tsx"),
+		{
+			...options,
+			customConditions: ["source", ...(options.customConditions ?? [])],
+			moduleResolution: ts.ModuleResolutionKind.Bundler,
+		},
+		{
+			...ts.sys,
+			directoryExists: () => true,
+			fileExists: (file) => file.endsWith(`/${PROBE}`) || ts.sys.fileExists(file),
+		},
+	).resolvedModule;
+	if (resolved === undefined) {
+		throw new Error(`Cannot resolve shadcn UI alias "${alias}" from ${directory}. Check tsconfig paths or package imports.`);
+	}
+	return dirname(resolved.resolvedFileName);
+}

package/src/inventory/shadcnFolders.ts

@@ -0,0 +1,30 @@
+import { basename, dirname, relative } from "node:path";
+import { Effect, type FileSystem, Schema } from "effect";
+import { FilesystemFailure, readRequiredText } from "./filesystem.ts";
+import { posix } from "./ignoreScope.ts";
+import { shadcnAlias } from "./shadcnAlias.ts";
+import { walk } from "./walk.ts";
+
+const Components = Schema.fromJsonString(Schema.Struct({ aliases: Schema.Struct({ ui: Schema.NonEmptyString }) }));
+
+export const shadcnFolders = Effect.fn("Inventory.shadcnFolders")(function* (
+	root: string,
+): Effect.fn.Return<readonly string[], FilesystemFailure, FileSystem.FileSystem> {
+	const paths = (yield* walk(root)).filter((path) => basename(path) === "components.json");
+	return yield* Effect.forEach(paths, (path) =>
+		Effect.gen(function* () {
+			const text = yield* readRequiredText(path);
+			return yield* Effect.try({
+				catch: (cause) => new FilesystemFailure({ message: `cannot resolve ${path}: ${String(cause)}`, path }),
+				try: () => {
+					const { aliases } = Schema.decodeUnknownSync(Components)(text);
+					const folder = posix(relative(root, shadcnAlias(dirname(path), aliases.ui)));
+					if (folder === "" || folder === ".." || folder.startsWith("../")) {
+						throw new Error("the shadcn UI folder must be inside the repository and cannot be its root");
+					}
+					return folder;
+				},
+			});
+		}),
+	);
+});

package/src/naming/migrationFile.ts

@@ -0,0 +1,9 @@
+import { posix } from "node:path";
+
+export const MIGRATIONS_DIRECTORY = "src/server/migrations";
+export const MIGRATION_FILE_PATTERN = /^[0-9]{4}_[a-z][a-z0-9]*(?:_[a-z0-9]+)*\.ts$/u;
+
+export function isMigrationFile(path: string): boolean {
+	const directory = posix.dirname(path);
+	return (directory === MIGRATIONS_DIRECTORY || directory.endsWith(`/${MIGRATIONS_DIRECTORY}`)) && MIGRATION_FILE_PATTERN.test(posix.basename(path));
+}

package/src/rules/files/folderNames.ts

@@ -5,15 +5,13 @@ import { packageLayout } from "#naming/packageLayout.ts";
 import { KEBAB, PASCAL } from "#naming/words.ts";
 import { defineRule, type Finding } from "#rule.ts";
 
-const DEFAULT_TOOL_OWNED: readonly string[] = ["migrations/"];
-
 const SNAKE = /^[a-z0-9]+(?:_[a-z0-9]+)*$/u;
 
 const CODE = /\.[cm]?[jt]sx?$/u;
 
 const FolderNamesOptions = Schema.Struct({
 	content: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
-	toolOwned: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed(DEFAULT_TOOL_OWNED))),
+	toolOwned: Schema.Array(Schema.String).pipe(Schema.withDecodingDefaultKey(Effect.succeed([]))),
 });
 
 function foldersIn(files: readonly string[]): readonly string[] {

package/src/rules/files/namedAfterExport.ts

@@ -3,6 +3,7 @@ import { Effect, Schema } from "effect";
 import ignore from "ignore";
 import { exportFits } from "#naming/exportFits.ts";
 import { mainExport } from "#naming/mainExport.ts";
+import { isMigrationFile } from "#naming/migrationFile.ts";
 import { ownExports } from "#naming/ownExports.ts";
 import { type PackageLayout, packageLayout } from "#naming/packageLayout.ts";
 import { CAMEL, KEBAB, sameWord, wordsOf } from "#naming/words.ts";
@@ -86,7 +87,9 @@ export const namedAfterExport = defineRule({
 	check: async ({ files, options, readText, sources }) => {
 		const layout = await packageLayout({ files, readText });
 		const toolOwned = ignore().add([...options.toolOwned]);
-		return sources.filter((file) => !(TEST.test(file.path) || toolOwned.ignores(file.path))).flatMap((file) => findingsOf(file, layout));
+		return sources
+			.filter((file) => !(TEST.test(file.path) || isMigrationFile(file.path) || toolOwned.ignores(file.path)))
+			.flatMap((file) => findingsOf(file, layout));
 	},
 	description:
 		"A file is named after its main export, with its folders as the prefix; a file of several exports is a camelCase topic file, and a script is kebab-case. Rename the file or the export; nothing renames them for you.",

package/src/rules/files/otherNames.ts

@@ -5,7 +5,7 @@ import { CAMEL, KEBAB } from "#naming/words.ts";
 import { defineRule, type Finding } from "#rule.ts";
 import { stylesheetImporters } from "./stylesheetImporters.ts";
 
-const DEFAULT_TOOL_OWNED: readonly string[] = [".*", "package.json", "tsconfig*.json", "biome.json", "biome.jsonc", "*.config.*", "migrations/"];
+const DEFAULT_TOOL_OWNED: readonly string[] = [".*", "package.json", "tsconfig*.json", "biome.json", "biome.jsonc", "*.config.*"];
 
 const CONVENTIONAL: ReadonlySet<string> = new Set(["AGENTS", "CHANGELOG", "CLAUDE", "CONTRIBUTING", "LICENSE", "README", "SECURITY", "SKILL"]);