@shivaedev/quality 0.22.0 → 0.24.0

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

@@ -10,33 +10,37 @@ const BRIDGES: ReadonlyMap<ts.SyntaxKind, string> = new Map([
 
 type Assertion = ts.AsExpression | ts.TypeAssertion;
 
-const isAssertion = (node: ts.Node): node is Assertion => ts.isAsExpression(node) || ts.isTypeAssertionExpression(node);
+function isAssertion(node: ts.Node): node is Assertion {
+	return ts.isAsExpression(node) || ts.isTypeAssertionExpression(node);
+}
 
-const unwrapped = (node: ts.Expression): ts.Expression => (ts.isParenthesizedExpression(node) ? unwrapped(node.expression) : node);
+function unwrapped(node: ts.Expression): ts.Expression {
+	return ts.isParenthesizedExpression(node) ? unwrapped(node.expression) : node;
+}
 
-const bridgeOf = (node: Assertion): string | undefined => {
+function bridgeOf(node: Assertion): string | undefined {
 	const inner = unwrapped(node.expression);
 	return isAssertion(inner) ? BRIDGES.get(inner.type.kind) : undefined;
-};
+}
 
-const castsIn = (path: string, source: ts.SourceFile): readonly Finding[] => {
+function castsIn(path: string, source: ts.SourceFile): readonly Finding[] {
 	const findings: Finding[] = [];
-	const visit = (node: ts.Node): void => {
+	function visit(node: ts.Node): void {
 		const bridge = isAssertion(node) ? bridgeOf(node) : undefined;
 		if (bridge !== undefined) {
 			const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line + 1;
 			findings.push({ file: path, line, message: `Casts through "${bridge}" to reach a type the value does not have.` });
 		}
 		ts.forEachChild(node, visit);
-	};
+	}
 	visit(source);
 	return findings;
-};
+}
 
-const doubleCasts = (file: SourceFile): readonly Finding[] => {
+function doubleCasts(file: SourceFile): readonly Finding[] {
 	const source = parse(file);
 	return source === undefined ? [] : castsIn(file.path, source);
-};
+}
 
 export const noDoubleCast = defineRule({
 	check: ({ sources }) => sources.flatMap(doubleCasts),

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

@@ -11,17 +11,18 @@ interface Site extends Finding {
 	readonly subject: string;
 }
 
-const sitesIn = (file: string, comments: readonly SourceComment[]): readonly Site[] =>
-	comments.flatMap((comment) => {
+function sitesIn(file: string, comments: readonly SourceComment[]): readonly Site[] {
+	return 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<readonly Site[]> => {
+async function stylesheetSites({ 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] ?? "")));
-};
+}
 
 function allowed(site: Site): boolean {
 	return site.subject === TYPE_TEST_DIRECTIVE && TYPE_TEST.test(site.file);

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

@@ -6,11 +6,15 @@ 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, "giu");
+function tokensOf(path: string): RegExp {
+	return new RegExp(LINE_COMMENTS.test(path) ? `${TOKENS}|\\/\\/[^\\n]*` : TOKENS, "giu");
+}
 
-const lineOf = (text: string, offset: number): number => text.slice(0, offset).split("\n").length;
+function lineOf(text: string, offset: number): number {
+	return text.slice(0, offset).split("\n").length;
+}
 
-const toComment = (text: string, token: string, offset: number): SourceComment => {
+function toComment(text: string, token: string, offset: number): SourceComment {
 	const kind = token.startsWith("//") ? "line" : "block";
 	const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
 	return {
@@ -21,7 +25,8 @@ const toComment = (text: string, token: string, offset: number): SourceComment =
 		ownLine: text.slice(lineStart, offset).trim() === "",
 		text: token,
 	};
-};
+}
 
-export const stylesheetComments = (path: string, text: string): readonly SourceComment[] =>
-	[...text.matchAll(tokensOf(path))].flatMap((match) => (match[0].startsWith("/") ? [toComment(text, match[0], match.index)] : []));
+export function stylesheetComments(path: string, text: string): readonly SourceComment[] {
+	return [...text.matchAll(tokensOf(path))].flatMap((match) => (match[0].startsWith("/") ? [toComment(text, match[0], match.index)] : []));
+}

package/src/rules/syntax.ts

@@ -8,7 +8,7 @@ const SCRIPT_KINDS: ReadonlyArray<readonly [RegExp, ts.ScriptKind]> = [
 	[/\.jsx$/u, ts.ScriptKind.JSX],
 ];
 
-export const parse = (file: SourceFile): ts.SourceFile | undefined => {
+export function parse(file: SourceFile): ts.SourceFile | undefined {
 	const kind = SCRIPT_KINDS.find(([pattern]) => pattern.test(file.path))?.[1];
 	return kind === undefined ? undefined : ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, true, kind);
-};
+}

package/src/standard-schema.ts

@@ -1,15 +1,15 @@
 // The Standard Schema V1 contract (standardschema.dev), copied as the specification recommends. Rule options accept any
 // conforming schema, so a consumer's own Effect version, or another schema library, validates them.
-export interface StandardSchemaV1<Input = unknown, Output = Input> {
+export interface StandardSchemaV1<TInput = unknown, TOutput = TInput> {
 	readonly "~standard": {
 		readonly version: 1;
 		readonly vendor: string;
-		readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
-		readonly types?: { readonly input: Input; readonly output: Output } | undefined;
+		readonly validate: (value: unknown) => StandardResult<TOutput> | Promise<StandardResult<TOutput>>;
+		readonly types?: { readonly input: TInput; readonly output: TOutput } | undefined;
 	};
 }
 
-export type StandardResult<Output> = { readonly value: Output; readonly issues?: undefined } | { readonly issues: readonly StandardIssue[] };
+export type StandardResult<TOutput> = { readonly value: TOutput; readonly issues?: undefined } | { readonly issues: readonly StandardIssue[] };
 
 export interface StandardIssue {
 	readonly message: string;