@shivaedev/quality 0.22.0 → 0.24.0

package/src/report/stale.ts

@@ -8,31 +8,39 @@ interface StaleFiles {
 	readonly registry: string;
 }
 
-const section = (label: string, file: string, guidance: string, lines: readonly string[]): readonly string[] =>
-	lines.length === 0 ? [] : [[`${label} ${file}: ${plural(lines.length, "stale entry", "stale entries")}`, `  ${guidance}`, ...lines].join("\n")];
+function section(label: string, file: string, guidance: string, lines: readonly string[]): readonly string[] {
+	return lines.length === 0
+		? []
+		: [[`${label} ${file}: ${plural(lines.length, "stale entry", "stale entries")}`, `  ${guidance}`, ...lines].join("\n")];
+}
 
-const baselineLine = ({ entry, problem }: StaleBaselineEntry): string => `  ${entry.rule} ${entry.file} ${problem}.`;
+function baselineLine({ entry, problem }: StaleBaselineEntry): string {
+	return `  ${entry.rule} ${entry.file} ${problem}.`;
+}
 
-const registryLine = ({ entry, problem }: StaleRegistryEntry): string =>
-	`  ${entry.rule} ${entry.file}${entry.subject === undefined ? "" : ` (${entry.subject})`} ${problem}.`;
+function registryLine({ entry, problem }: StaleRegistryEntry): string {
+	return `  ${entry.rule} ${entry.file}${entry.subject === undefined ? "" : ` (${entry.subject})`} ${problem}.`;
+}
 
-export const staleSections = (outcome: Outcome, files: StaleFiles): readonly string[] => [
-	...section(
-		"error",
-		files.baseline,
-		"An entry for a rule that is off or unknown covers nothing. Run `quality baseline prune` to drop it.",
-		outcome.staleBaseline.map(baselineLine),
-	),
-	...section(
-		"note",
-		files.baseline,
-		"These pass, and `quality baseline tighten` lowers them when their files change. `quality baseline prune` lowers them all.",
-		outcome.looseBaseline.map(baselineLine),
-	),
-	...section(
-		"error",
-		files.registry,
-		"Every registered exception must still apply. Remove the entries whose exception is gone.",
-		outcome.staleRegistry.map(registryLine),
-	),
-];
+export function staleSections(outcome: Outcome, files: StaleFiles): readonly string[] {
+	return [
+		...section(
+			"error",
+			files.baseline,
+			"An entry for a rule that is off or unknown covers nothing. Run `quality baseline prune` to drop it.",
+			outcome.staleBaseline.map(baselineLine),
+		),
+		...section(
+			"note",
+			files.baseline,
+			"These pass, and `quality baseline tighten` lowers them when their files change. `quality baseline prune` lowers them all.",
+			outcome.looseBaseline.map(baselineLine),
+		),
+		...section(
+			"error",
+			files.registry,
+			"Every registered exception must still apply. Remove the entries whose exception is gone.",
+			outcome.staleRegistry.map(registryLine),
+		),
+	];
+}

package/src/rule.ts

@@ -28,35 +28,35 @@ export interface RuleInputs {
 	readonly sources: readonly SourceFile[];
 }
 
-export interface RuleContext<Options> extends RuleInputs {
-	readonly options: Options;
+export interface RuleContext<TOptions> extends RuleInputs {
+	readonly options: TOptions;
 }
 
 export type Configured =
 	| { readonly _tag: "Invalid"; readonly issues: readonly string[] }
 	| { readonly _tag: "Ready"; readonly check: (inputs: RuleInputs) => Promise<Findings> };
 
-export interface Rule<Id extends string = string, Input = unknown> {
+export interface Rule<TId extends string = string, TInput = unknown> {
 	// Bivariance keeps rules with different options in one list; configure validates its input at runtime.
-	configure: Bivariant<(options: Input | undefined) => Promise<Configured>>;
+	configure: Bivariant<(options: TInput | undefined) => Promise<Configured>>;
 	readonly description: string;
 	readonly family?: boolean;
-	readonly id: Id;
+	readonly id: TId;
 	readonly registrable?: boolean;
 }
 
-interface RuleDefinition<Id extends string, Options> {
-	readonly check: (context: RuleContext<Options>) => Findings | PromiseLike<Findings>;
+interface RuleDefinition<TId extends string, TOptions> {
+	readonly check: (context: RuleContext<TOptions>) => Findings | PromiseLike<Findings>;
 	readonly description: string;
-	readonly id: Id;
+	readonly id: TId;
 	readonly registrable?: false;
 }
 
-interface RuleDefinitionWithOptions<Id extends string, Input, Options> extends RuleDefinition<Id, Options> {
-	readonly options: StandardSchemaV1<Input, Options>;
+interface RuleDefinitionWithOptions<TId extends string, TInput, TOptions> extends RuleDefinition<TId, TOptions> {
+	readonly options: StandardSchemaV1<TInput, TOptions>;
 }
 
-interface RuleDefinitionWithoutOptions<Id extends string> extends RuleDefinition<Id, undefined> {
+interface RuleDefinitionWithoutOptions<TId extends string> extends RuleDefinition<TId, undefined> {
 	readonly options?: undefined;
 }
 
@@ -68,9 +68,12 @@ const noOptions: StandardSchemaV1<undefined, undefined> = {
 	},
 };
 
-const configureWith =
-	<Input, Options>(schema: StandardSchemaV1<Input, Options>, check: RuleDefinition<string, Options>["check"], absent: unknown) =>
-	async (options: unknown): Promise<Configured> => {
+function configureWith<TInput, TOptions>(
+	schema: StandardSchemaV1<TInput, TOptions>,
+	check: RuleDefinition<string, TOptions>["check"],
+	absent: unknown,
+) {
+	return async (options: unknown): Promise<Configured> => {
 		const result = await schema["~standard"].validate(options ?? absent);
 		if (result.issues !== undefined) {
 			return { _tag: "Invalid", issues: result.issues.map(describeIssue) };
@@ -78,12 +81,15 @@ const configureWith =
 		const value = result.value;
 		return { _tag: "Ready", check: async (inputs) => check({ ...inputs, options: value }) };
 	};
+}
 
-export function defineRule<const Id extends string, Input, Options>(definition: RuleDefinitionWithOptions<Id, Input, Options>): Rule<Id, Input>;
-export function defineRule<const Id extends string>(definition: RuleDefinitionWithoutOptions<Id>): Rule<Id, undefined>;
-export function defineRule<const Id extends string, Input, Options>(
-	definition: RuleDefinitionWithOptions<Id, Input, Options> | RuleDefinitionWithoutOptions<Id>,
-): Rule<Id, Input> | Rule<Id, undefined> {
+export function defineRule<const TId extends string, TInput, TOptions>(
+	definition: RuleDefinitionWithOptions<TId, TInput, TOptions>,
+): Rule<TId, TInput>;
+export function defineRule<const TId extends string>(definition: RuleDefinitionWithoutOptions<TId>): Rule<TId, undefined>;
+export function defineRule<const TId extends string, TInput, TOptions>(
+	definition: RuleDefinitionWithOptions<TId, TInput, TOptions> | RuleDefinitionWithoutOptions<TId>,
+): Rule<TId, TInput> | Rule<TId, undefined> {
 	const configure =
 		definition.options === undefined
 			? configureWith(noOptions, definition.check, undefined)

package/src/rules/built-in.ts

@@ -17,6 +17,7 @@ import { noTestCode } from "#rules/imports/noTestCode.ts";
 import { importsResolvable } from "#rules/imports/resolvable.ts";
 import { importsRuntime } from "#rules/imports/runtime.ts";
 import { storySetup } from "#rules/stories/setup.ts";
+import { storySpecs } from "#rules/stories/specs.ts";
 import { biomeOverrides } from "#rules/suppressions/biome-overrides.ts";
 import { biomeRecommended } from "#rules/suppressions/biomeRecommended.ts";
 import { noDoubleCast } from "#rules/suppressions/no-double-cast.ts";
@@ -27,9 +28,13 @@ import { testsFollow } from "#rules/test-names/follow.ts";
 import { biome } from "./biome.ts";
 import { manifestsSorted } from "./manifests-sorted.ts";
 import { maxLines } from "./max-lines.ts";
+import { maxDepth } from "./maxDepth.ts";
+import { noBarrel } from "./noBarrel.ts";
 
 export const builtInRules = [
 	maxLines,
+	maxDepth,
+	noBarrel,
 	noJsdoc,
 	noLineReference,
 	noPrReference,
@@ -58,4 +63,5 @@ export const builtInRules = [
 	testsFollow,
 	testsColocated,
 	storySetup,
+	storySpecs,
 ] as const;

package/src/rules/comments/kinds.ts

@@ -15,21 +15,28 @@ const DIRECTIVES: readonly RegExp[] = [
 
 const TRIPLE_SLASH = /^\/\/\/\s*</u;
 
-const contentOf = (comment: SourceComment): readonly string[] => comment.body.filter((line) => line !== "");
+function contentOf(comment: SourceComment): readonly string[] {
+	return comment.body.filter((line) => line !== "");
+}
 
-const startsWithTag = (line: string, tags: readonly string[]): boolean =>
-	tags.some((tag) => line === tag || line.startsWith(`${tag} `) || line.startsWith(`${tag}\t`));
+function startsWithTag(line: string, tags: readonly string[]): boolean {
+	return tags.some((tag) => line === tag || line.startsWith(`${tag} `) || line.startsWith(`${tag}\t`));
+}
 
-export const textOf = (comment: SourceComment): string => comment.body.join("\n");
+export function textOf(comment: SourceComment): string {
+	return comment.body.join("\n");
+}
 
-export const isJsdoc = (comment: SourceComment): boolean => comment.kind === "block" && comment.text.startsWith("/**") && comment.text !== "/**/";
+export function isJsdoc(comment: SourceComment): boolean {
+	return comment.kind === "block" && comment.text.startsWith("/**") && comment.text !== "/**/";
+}
 
-export const isPragma = (comment: SourceComment, pragmas: readonly string[]): boolean => {
+export function isPragma(comment: SourceComment, pragmas: readonly string[]): boolean {
 	const content = contentOf(comment);
 	return content.length > 0 && content.every((line) => startsWithTag(line, pragmas));
-};
+}
 
-export const isDirective = (comment: SourceComment): boolean => {
+export function isDirective(comment: SourceComment): boolean {
 	const first = contentOf(comment)[0] ?? "";
 	return TRIPLE_SLASH.test(comment.text) || DIRECTIVES.some((directive) => directive.test(first));
-};
+}

package/src/rules/comments/max-per-file.ts

@@ -9,18 +9,22 @@ const MaxPerFileOptions = Schema.Struct({
 	max: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(2)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(2))),
 });
 
-const continues = (previous: SourceComment | undefined, comment: SourceComment): boolean =>
-	previous !== undefined
-	&& previous.kind === "line"
-	&& comment.kind === "line"
-	&& previous.ownLine
-	&& comment.ownLine
-	&& comment.line === previous.endLine + 1;
+function continues(previous: SourceComment | undefined, comment: SourceComment): boolean {
+	return (
+		previous !== undefined
+		&& previous.kind === "line"
+		&& comment.kind === "line"
+		&& previous.ownLine
+		&& comment.ownLine
+		&& comment.line === previous.endLine + 1
+	);
+}
 
-const commentBlocks = (comments: readonly SourceComment[]): readonly SourceComment[] =>
-	comments.filter((comment, index) => !continues(comments[index - 1], comment));
+function commentBlocks(comments: readonly SourceComment[]): readonly SourceComment[] {
+	return comments.filter((comment, index) => !continues(comments[index - 1], comment));
+}
 
-const overCap = (file: SourceFile, max: number, allow: readonly string[]): readonly Finding[] => {
+function overCap(file: SourceFile, max: number, allow: readonly string[]): readonly Finding[] {
 	const counted = commentsOf(file).filter((comment) => !(isDirective(comment) || isPragma(comment, allow)));
 	const blocks = commentBlocks(counted);
 	const first = blocks[max];
@@ -35,7 +39,7 @@ const overCap = (file: SourceFile, max: number, allow: readonly string[]): reado
 					threshold: max,
 				},
 			];
-};
+}
 
 export const maxPerFile = defineRule({
 	check: ({ options, sources }) => sources.flatMap((file) => overCap(file, options.max, options.allow)),

package/src/rules/comments/pattern-rule.ts

@@ -9,13 +9,13 @@ interface PatternRule<Id extends string> {
 	readonly patterns: readonly RegExp[];
 }
 
-const firstMatch = (comment: SourceComment, patterns: readonly RegExp[]): string | undefined => {
+function firstMatch(comment: SourceComment, patterns: readonly RegExp[]): string | undefined {
 	const text = textOf(comment);
 	return patterns.map((pattern) => pattern.exec(text)?.[0]).find((match) => match !== undefined);
-};
+}
 
-export const definePatternRule = <const Id extends string>({ description, id, message, patterns }: PatternRule<Id>): Rule<Id, undefined> =>
-	defineRule({
+export function definePatternRule<const Id extends string>({ description, id, message, patterns }: PatternRule<Id>): Rule<Id, undefined> {
+	return defineRule({
 		check: ({ sources }) =>
 			sources.flatMap((file) =>
 				commentsOf(file).flatMap((comment): readonly Finding[] => {
@@ -26,3 +26,4 @@ export const definePatternRule = <const Id extends string>({ description, id, me
 		description,
 		id,
 	});
+}

package/src/rules/comments/scan.ts

@@ -13,15 +13,15 @@ export interface SourceComment {
 
 const DECLARATION = /\.d\.[cm]?ts$/u;
 
-const commentRanges = (source: ts.SourceFile): readonly ts.CommentRange[] => {
+function commentRanges(source: ts.SourceFile): readonly ts.CommentRange[] {
 	const ranges = new Map<number, ts.CommentRange>();
 	const jsxText: ts.Node[] = [];
-	const add = (found: readonly ts.CommentRange[] | undefined) => {
+	function add(found: readonly ts.CommentRange[] | undefined) {
 		for (const range of found ?? []) {
 			ranges.set(range.pos, range);
 		}
-	};
-	const visit = (node: ts.Node) => {
+	}
+	function visit(node: ts.Node) {
 		if (node.kind === ts.SyntaxKind.JsxText) {
 			jsxText.push(node);
 		}
@@ -30,22 +30,23 @@ const commentRanges = (source: ts.SourceFile): readonly ts.CommentRange[] => {
 		for (const child of node.getChildren(source)) {
 			visit(child);
 		}
-	};
+	}
 	visit(source);
 	return [...ranges.values()]
 		.filter((range) => !jsxText.some((text) => range.pos >= text.pos && range.pos < text.end))
 		.sort((left, right) => left.pos - right.pos);
-};
+}
 
-export const bodyOf = (kind: SourceComment["kind"], text: string): readonly string[] =>
-	kind === "line"
+export function bodyOf(kind: SourceComment["kind"], text: string): readonly string[] {
+	return kind === "line"
 		? [text.slice(2).trim()]
 		: text
 				.slice(2, -2)
 				.split("\n")
 				.map((line) => line.trim().replace(/^\*(?=\s|$)\s*/u, ""));
+}
 
-const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment => {
+function toComment(source: ts.SourceFile, range: ts.CommentRange): SourceComment {
 	const kind = range.kind === ts.SyntaxKind.SingleLineCommentTrivia ? "line" : "block";
 	const text = source.text.slice(range.pos, range.end);
 	const start = source.getLineAndCharacterOfPosition(range.pos);
@@ -58,16 +59,16 @@ const toComment = (source: ts.SourceFile, range: ts.CommentRange): SourceComment
 		ownLine: source.text.slice(lineStart, range.pos).trim() === "",
 		text,
 	};
-};
+}
 
 const scanned = new WeakMap<SourceFile, readonly SourceComment[]>();
 
-const scan = (file: SourceFile): readonly SourceComment[] => {
+function scan(file: SourceFile): readonly SourceComment[] {
 	const source = parse(file);
 	return source === undefined ? [] : commentRanges(source).map((range) => toComment(source, range));
-};
+}
 
-export const scanComments = (file: SourceFile): readonly SourceComment[] => {
+export function scanComments(file: SourceFile): readonly SourceComment[] {
 	const cached = scanned.get(file);
 	if (cached !== undefined) {
 		return cached;
@@ -75,6 +76,8 @@ export const scanComments = (file: SourceFile): readonly SourceComment[] => {
 	const comments = scan(file);
 	scanned.set(file, comments);
 	return comments;
-};
+}
 
-export const commentsOf = (file: SourceFile): readonly SourceComment[] => (DECLARATION.test(file.path) ? [] : scanComments(file));
+export function commentsOf(file: SourceFile): readonly SourceComment[] {
+	return DECLARATION.test(file.path) ? [] : scanComments(file);
+}

package/src/rules/max-lines.ts

@@ -11,8 +11,8 @@ const MaxLinesOptions = Schema.Struct({
 	test: Limit.check(Schema.isLessThanOrEqualTo(300)).pipe(Schema.withDecodingDefaultKey(Effect.succeed(300))),
 });
 
-const oversized = (file: SourceFile, limit: number): readonly Finding[] =>
-	file.lines.length <= limit
+function oversized(file: SourceFile, limit: number): readonly Finding[] {
+	return file.lines.length <= limit
 		? []
 		: [
 				{
@@ -22,6 +22,7 @@ const oversized = (file: SourceFile, limit: number): readonly Finding[] =>
 					threshold: limit,
 				},
 			];
+}
 
 export const maxLines = defineRule({
 	check: ({ options, sources }) =>

package/src/rules/maxDepth.ts

@@ -0,0 +1,24 @@
+import { defineRule, type Finding, type SourceFile } from "#rule.ts";
+
+const DECLARATION = /\.d\.[cm]?ts$/u;
+const TOO_DEEP = /^\t{8,}/u;
+
+function findingsOf(file: SourceFile): readonly Finding[] {
+	return file.lines.flatMap((text, index) =>
+		TOO_DEEP.test(text)
+			? [
+					{
+						file: file.path,
+						line: index + 1,
+						message: "Indentation is 8+ tabs deep. Extract a named function or component.",
+					},
+				]
+			: [],
+	);
+}
+
+export const maxDepth = defineRule({
+	check: ({ sources }) => sources.filter((file) => !DECLARATION.test(file.path)).flatMap(findingsOf),
+	description: "Extract a named function or component before indentation reaches eight tabs.",
+	id: "nesting/max-depth",
+});

package/src/rules/noBarrel.ts

@@ -0,0 +1,16 @@
+import { posix } from "node:path";
+import { defineRule } from "#rule.ts";
+
+const BARREL_FILE = /^index\.tsx?$/u;
+
+export const noBarrel = defineRule({
+	check: ({ sources }) =>
+		sources
+			.filter((file) => BARREL_FILE.test(posix.basename(file.path)))
+			.map((file) => ({
+				file: file.path,
+				message: "index.ts and index.tsx modules are banned. Name the module after its purpose and import it directly.",
+			})),
+	description: "Name TypeScript modules after their purpose instead of index.ts or index.tsx.",
+	id: "structure/no-barrel",
+});

package/src/rules/stories/origins.ts

@@ -0,0 +1,147 @@
+import { join } from "node:path";
+import ts from "typescript";
+import type { ImportGraph } from "#imports/graph.ts";
+import type { RuleInputs } from "#rule.ts";
+import { storyProgram } from "./program.ts";
+
+type Origin = "factory" | "kit" | "story" | "plain" | "suite" | "vitest" | "stories" | "function" | undefined;
+
+function importFrom(node: ts.Node): string | undefined {
+	for (let current: ts.Node | undefined = node; current !== undefined; current = current.parent) {
+		if (ts.isImportDeclaration(current) && ts.isStringLiteral(current.moduleSpecifier)) {
+			return current.moduleSpecifier.text;
+		}
+	}
+	return undefined;
+}
+
+function moduleOrigin(from: string | undefined): Origin {
+	if (from === "vitest" || from === "@effect/vitest") {
+		return "vitest";
+	}
+	return from === "@shivaedev/test-story" || from === "@shivaedev/test-story/storyKit.ts" ? "stories" : undefined;
+}
+
+function imported(name: string, from: string | undefined): Origin {
+	const namespace = moduleOrigin(from);
+	if (name === "storyKit" && namespace === "stories") {
+		return "factory";
+	}
+	if ((name === "describe" || name === "suite") && namespace === "vitest") {
+		return "suite";
+	}
+	return (name === "it" || name === "test") && namespace === "vitest" ? "plain" : undefined;
+}
+
+export function storyOrigins(inputs: RuleInputs, graph: ImportGraph) {
+	const program = storyProgram(inputs, graph);
+	const checker = program.getTypeChecker();
+	const visiting = new Set<ts.Node>();
+	const known = new Map<ts.Node, Origin>();
+
+	function binding(node: ts.BindingElement): Origin {
+		if (!ts.isVariableDeclaration(node.parent.parent)) {
+			return undefined;
+		}
+		const value = node.parent.parent.initializer;
+		const name = node.propertyName ?? node.name;
+		return value !== undefined && (ts.isIdentifier(name) || ts.isStringLiteral(name)) ? member(value, name.text) : undefined;
+	}
+
+	function declaration(node: ts.Node): Origin {
+		if (ts.isImportSpecifier(node)) {
+			return imported((node.propertyName ?? node.name).text, importFrom(node));
+		}
+		if (ts.isNamespaceImport(node)) {
+			return moduleOrigin(importFrom(node));
+		}
+		if (ts.isVariableDeclaration(node) || ts.isPropertyAssignment(node)) {
+			return node.initializer === undefined ? undefined : origin(node.initializer);
+		}
+		return localBinding(node);
+	}
+
+	function localBinding(node: ts.Node): Origin {
+		if (ts.isShorthandPropertyAssignment(node)) {
+			return symbol(checker.getShorthandAssignmentValueSymbol(node));
+		}
+		return ts.isBindingElement(node) ? binding(node) : undefined;
+	}
+
+	function symbol(value: ts.Symbol | undefined): Origin {
+		if (value === undefined) {
+			return undefined;
+		}
+		const direct = value.declarations?.map(visit).find((result) => result !== undefined);
+		return direct ?? (value.flags & ts.SymbolFlags.Alias ? symbol(checker.getAliasedSymbol(value)) : undefined);
+	}
+
+	function object(node: ts.ObjectLiteralExpression): Origin {
+		for (const property of [...node.properties].reverse()) {
+			if (property.name?.getText() === "it") {
+				return visit(property) === "story" ? "kit" : undefined;
+			}
+			if (ts.isSpreadAssignment(property) && visit(property.expression) === "kit") {
+				return "kit";
+			}
+		}
+		return undefined;
+	}
+
+	function member(value: ts.Expression, name: string): Origin {
+		const receiver = visit(value);
+		if (receiver === "kit" && name === "it") {
+			return "story";
+		}
+		if (receiver === "story" || receiver === "plain" || receiver === "suite") {
+			return receiver;
+		}
+		const from = receiver === "vitest" ? "vitest" : undefined;
+		return imported(name, receiver === "stories" ? "@shivaedev/test-story/storyKit.ts" : from);
+	}
+
+	function identifier(node: ts.Identifier): Origin {
+		if (node.text === "describe" || node.text === "suite") {
+			return symbol(checker.getSymbolAtLocation(node)) ?? "suite";
+		}
+		const value = checker.getSymbolAtLocation(node);
+		return symbol(value) ?? (value === undefined && (node.text === "it" || node.text === "test") ? "plain" : undefined);
+	}
+
+	function origin(node: ts.Node): Origin {
+		if (ts.isFunctionLike(node)) {
+			return "function";
+		}
+		if (ts.isObjectLiteralExpression(node)) {
+			return object(node);
+		}
+		return expression(node);
+	}
+
+	function expression(node: ts.Node): Origin {
+		if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+			return visit(node.expression);
+		}
+		if (ts.isCallExpression(node)) {
+			const callee = visit(node.expression);
+			return callee === "factory" ? "kit" : callee;
+		}
+		if (ts.isPropertyAccessExpression(node)) {
+			return member(node.expression, node.name.text) ?? symbol(checker.getSymbolAtLocation(node.name));
+		}
+		return ts.isIdentifier(node) ? identifier(node) : declaration(node);
+	}
+
+	function visit(node: ts.Node): Origin {
+		if (visiting.has(node) || known.has(node)) {
+			return known.get(node);
+		}
+		visiting.add(node);
+		const result = origin(node);
+		visiting.delete(node);
+		known.set(node, result);
+		return result;
+	}
+
+	return { origin: visit, source: (path: string) => program.getSourceFile(join(inputs.root, path)) };
+}

package/src/rules/stories/prerequisites.ts

@@ -0,0 +1,37 @@
+import { posix } from "node:path";
+import type { WorkspacePackage } from "#imports/workspace.ts";
+import type { RuleInputs } from "#rule.ts";
+
+const DEPENDENCIES = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"];
+
+function object(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function manifest(text: string | undefined): Record<string, unknown> {
+	const value: unknown = JSON.parse(text ?? "{}");
+	return object(value) ? value : {};
+}
+
+export async function storyPrerequisites(inputs: RuleInputs, packages: readonly WorkspacePackage[]): Promise<ReadonlySet<string>> {
+	const root = manifest(await inputs.readText("package.json"));
+	const members = typeof root.name === "string" ? [...packages, { directory: "", name: root.name }] : packages;
+	const byName = new Map(members.map((member) => [member.name, member]));
+	const pending = ["@shivaedev/test-story"];
+	const directories = new Set<string>();
+	while (pending.length > 0) {
+		const current = byName.get(pending.pop() ?? "");
+		if (current === undefined || directories.has(current.directory)) {
+			continue;
+		}
+		directories.add(current.directory);
+		const value = manifest(await inputs.readText(posix.join(current.directory, "package.json")));
+		for (const key of DEPENDENCIES) {
+			const dependencies = value[key];
+			if (object(dependencies)) {
+				pending.push(...Object.keys(dependencies).filter((name) => byName.has(name)));
+			}
+		}
+	}
+	return directories;
+}

package/src/rules/stories/program.ts

@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import ts from "typescript";
+import type { ImportGraph } from "#imports/graph.ts";
+import type { RuleInputs } from "#rule.ts";
+
+export function storyProgram(inputs: RuleInputs, graph: ImportGraph): ts.Program {
+	const sources = new Map(inputs.sources.map((file) => [join(inputs.root, file.path), file.text]));
+	const targets = new Map(
+		graph.edges.flatMap((edge) =>
+			edge.to.kind === "file" ? [[`${join(inputs.root, edge.from)}:${edge.specifier}`, join(inputs.root, edge.to.path)] as const] : [],
+		),
+	);
+	const options: ts.CompilerOptions = { allowJs: true, noLib: true, types: [] };
+	const host: ts.CompilerHost = {
+		...ts.createCompilerHost(options),
+		fileExists: (path) => sources.has(path),
+		getSourceFile: (path) => {
+			const text = sources.get(path);
+			return text === undefined ? undefined : ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+		},
+		readFile: (path) => sources.get(path),
+		resolveModuleNames: (names, from) =>
+			names.map((name) => {
+				const path = targets.get(`${from}:${name}`);
+				return path === undefined ? undefined : { extension: ts.Extension.Ts, resolvedFileName: path };
+			}),
+	};
+	return ts.createProgram([...sources.keys()], options, host);
+}