@deslop/coding-standards 0.1.761 → 0.1.804

package/dist/oxlint.js

@@ -1,4 +1,4 @@
-import { $n as isReadonlyObject, An as symbol, B as some$1, Bn as hasProperty, C as flatMap$1, D as getSomes, E as get$1, F as map$1, Fn as optimize, Gn as isNotNull, H as take, Jn as isNullish, K as remove, Kn as isNotNullish, L as of, Ln as string, M as join, Mn as combine, N as last, Nn as hash, O as isArrayEmpty, On as byReferenceUnsafe, Pn as number, R as prepend, U as fromEntries, V as sort, Vn as isBoolean, W as get$2, Y as fromOption, Yn as isNumber, _ as every, _t as orElse, a as startsWith, at as firstSomeOf, b as findFirst, bn as NodeInspectSymbol, c as TaggedError, d as appendAll, er as isString, f as contains$1, ft as isSome, g as ensure, gr as pipeArguments, gt as none, h as empty, ht as match, i as Order, it as filter, k as isArrayNonEmpty, kn as equals, lr as dual, lt as getOrElse, m as dropRight, mt as map, n as make$2, nt as contains, ot as flatMap, p as dedupe, pr as pipe, q as values, r as update, rt as exists, st as fromNullishOr, t as get$3, tt as all, u as append, v as filter$1, vt as some, w as flatten, x as findFirstIndex, y as filterMap, yt as zipWith, zn as symbol$1 } from "./MutableRef-DT4DAKeI.mjs";
+import { $ as fromOption, $n as isNullish$1, A as getSomes, Bn as optimize, C as findFirst, Ct as some, D as flatten, E as flatMap$1, Fn as symbol, G as sort, Gn as hasProperty, H as prepend, Hn as string, I as join, J as get$2, K as take, Kn as isBoolean, L as last, Ln as combine, M as isArrayEmpty, N as isArrayNonEmpty, Nn as byReferenceUnsafe, Pn as equals, Rn as hash, S as filterMap, St as orElse, Tn as NodeInspectSymbol, V as of, W as some$1, Wn as symbol$1, X as remove, Xn as isNotNull, Z as values, Zn as isNotNullish, _ as dropRight, _t as isSome, a as includes, ar as isString, at as all, b as every, bt as match$1, c as startsWith, ct as filter, d as TaggedError, dt as flatten$1, er as isNumber, ft as fromNullishOr, g as dedupe, h as contains$1, i as Order, ir as isReadonlyObject, j as head, k as get$1, lt as firstSomeOf, m as appendAll, mr as dual, mt as getOrElse, n as make$2, o as match, ot as contains, p as append, pt as fromUndefinedOr, q as fromEntries, r as update, s as split, st as exists, t as get$3, ut as flatMap, v as empty, vr as pipe, w as findFirstIndex, wt as zipWith, x as filter$1, xr as pipeArguments, xt as none, y as ensure, yt as map, z as map$1, zn as number } from "./MutableRef-NhSl8G9M.mjs";
 //#region ../../node_modules/.pnpm/effect@4.0.0/node_modules/effect/dist/internal/graph.js
 /** @internal */
 const TypeId = "~effect/Graph";
@@ -612,7 +612,7 @@ Object.freeze({
 	}
 });
 //#endregion
-//#region ../../node_modules/.pnpm/oxlint@1.85.0_oxlint-tsgolint@7.0.2003_vite-plus@1.0.0_@opentelemetry+api@1.9.1_@types+_4709a04ba252a52ff927b8b254462122/node_modules/oxlint/dist/index.js
+//#region ../../node_modules/.pnpm/oxlint@1.85.0_oxlint-tsgolint@7.0.2003_vite-plus@1.0.0_@opentelemetry+api@1.9.1_@types+_bd1fc584f29238a6938d999624a6e509/node_modules/oxlint/dist/index.js
 /**
 * Define an Oxlint configuration with type inference.
 *
@@ -668,16 +668,11 @@ function importedMember(input) {
 		source: "effect"
 	}) && (input.propertyName === void 0 || contains(memberName(input.node), input.propertyName));
 }
-function effectBuilderName(input) {
-	const builder = input.node.type === "CallExpression" ? input.node.callee : input.node;
-	return builder.type === "MemberExpression" && importedMember({
-		context: input.context,
-		importedName: "Effect",
-		node: builder
-	}) ? memberName(builder) : none();
+function matches(regExp) {
+	return (text) => isSome(pipe(text, match(regExp)));
 }
 function isSchemaOperationName(name) {
-	return /^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u.test(name);
+	return matches(/^(?:(?:decode|encode)(?:Unknown)?(?:Effect|Exit|Option|Promise|Result|Sync)|asserts|is)$/u)(name);
 }
 function isSchemaOperationCall(input) {
 	if (input.node.callee.type !== "MemberExpression" || !importedMember({
@@ -795,7 +790,7 @@ function suspendSeeds(input) {
 	return pipe(suspendedTypeName({
 		context: input.context,
 		node: input.node
-	}), match({
+	}), match$1({
 		onNone: () => seeds,
 		onSome: (name) => prepend(seeds, name)
 	}));
@@ -866,7 +861,7 @@ function testedValue(node) {
 function isSingletonArray(input) {
 	if (input.node.type !== "ArrayExpression" || input.node.elements.length !== 1) return false;
 	const element = input.node.elements[0];
-	if (isNullish(element) || element.type === "SpreadElement") return false;
+	if (isNullish$1(element) || element.type === "SpreadElement") return false;
 	return input.context.sourceCode.getText(element) === input.context.sourceCode.getText(input.value);
 }
 function restatesArrayEnsure(input) {
@@ -892,33 +887,10 @@ const noArrayWrapTernary = defineRule({
 });
 //#endregion
 //#region src/rules/no-constant-function.ts
-function returnsConstant(node) {
-	const returned = returnedExpression(node);
-	return isNotNullish(returned) && (returned.type === "Literal" || returned.type === "Identifier" || returned.type === "MemberExpression" || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions));
-}
-function functionScope(input) {
-	if (input.scope.block === input.node) return some(input.scope);
-	return findFirst(input.scope.childScopes, (child) => child.block === input.node);
-}
-function scopeReferences(scope) {
-	return appendAll(scope.references, flatMap$1(scope.childScopes, scopeReferences));
-}
-function isImportedVariable(variable) {
-	return isArrayNonEmpty(variable.defs) && every(variable.defs, (definition) => definition.type === "ImportBinding");
-}
-function resolvesToImport(reference) {
-	return pipe(variableFromScope({
-		name: reference.identifier.name,
-		scope: reference.from
-	}), exists(isImportedVariable));
-}
 function isConstantFunction(input) {
-	if (input.node.async || input.node.generator || isNotNullish(input.node.typeParameters)) return false;
-	if (some$1(input.spans, (span) => span.start >= input.node.start && span.end <= input.node.end)) return false;
-	return returnsConstant(input.node) && pipe(functionScope({
-		node: input.node,
-		scope: input.context.sourceCode.getScope(input.node)
-	}), exists((scope) => every(scopeReferences(scope), resolvesToImport))) && pipe(bindingName(input.node), flatMap((name) => variableFromScope({
+	if (input.node.async || input.node.generator || isArrayNonEmpty(input.node.params) || isNotNullish(input.node.typeParameters)) return false;
+	const returned = returnedExpression(input.node);
+	return isNotNullish(returned) && (returned.type === "Literal" && !hasProperty(returned, "regex") || returned.type === "TemplateLiteral" && isArrayEmpty(returned.expressions)) && pipe(bindingName(input.node), flatMap((name) => variableFromScope({
 		name,
 		scope: input.context.sourceCode.getScope(input.node)
 	})), exists((variable) => every(filter$1(variable.references, (reference) => reference.isRead()), (reference) => reference.identifier.parent.type === "CallExpression" && reference.identifier.parent.callee === reference.identifier)));
@@ -928,20 +900,15 @@ function isConstBound(node) {
 }
 const noConstantFunction = defineRule({
 	create: (context) => {
-		const spans = make$2(empty());
-		function mark(node) {
-			update(spans, append(node));
-		}
 		function report(node) {
 			if (isConstantFunction({
 				context,
-				node,
-				spans: get$3(spans)
+				node
 			}) && !singleUseThunk({
 				context,
 				node
 			})) context.report({
-				message: "This function reads nothing but imports, so it is a value: hold its result in a const.",
+				message: "Inline this argument-free literal return at its call sites.",
 				node
 			});
 		}
@@ -952,31 +919,32 @@ const noConstantFunction = defineRule({
 			"FunctionDeclaration:exit": report,
 			"FunctionExpression:exit": (node) => {
 				if (isConstBound(node)) report(node);
-			},
-			JSXElement: mark,
-			JSXFragment: mark,
-			ThisExpression: mark
+			}
 		};
 	},
 	meta: { type: "problem" }
 });
 //#endregion
 //#region src/rules/no-deep-pipe.ts
-function isPipeCall(node) {
-	return node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "pipe";
+function isPipeCall(context, node) {
+	return node.type === "CallExpression" && node.callee.type === "Identifier" && isImportBinding({
+		context,
+		importedName: "pipe",
+		node: node.callee,
+		source: "effect"
+	});
 }
-function enclosingPipes(node) {
+function enclosingPipes(context, node) {
 	if (node.type === "Program" || contains$1([
 		"ArrowFunctionExpression",
 		"FunctionDeclaration",
 		"FunctionExpression"
 	], node.type)) return 0;
-	const nested = isPipeCall(node.parent) && some$1(node.parent.arguments, (argument) => argument === node);
-	return enclosingPipes(node.parent) + (nested ? 1 : 0);
+	return enclosingPipes(context, node.parent) + (isPipeCall(context, node.parent) && some$1(node.parent.arguments, (argument) => argument === node) ? 1 : 0);
 }
 const noDeepPipe = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
-		if (isPipeCall(node) && enclosingPipes(node) >= 3) context.report({
+		if (isPipeCall(context, node) && enclosingPipes(context, node) >= 3) context.report({
 			message: "Flatten this pipeline; pipe calls nest at most three deep.",
 			node
 		});
@@ -985,23 +953,59 @@ const noDeepPipe = defineRule({
 });
 //#endregion
 //#region src/rules/no-destructured-parameter.ts
-function isPattern(node) {
-	const target = node.type === "AssignmentPattern" ? node.left : node;
-	if (target.type === "ArrayPattern") return true;
+function namedTuple(input) {
+	if (contains$1(input.seen, input.node)) return false;
+	if (input.node.type === "TSTupleType") return isArrayNonEmpty(input.node.elementTypes) && every(input.node.elementTypes, (element) => element.type === "TSNamedTupleMember");
+	if (input.node.type === "TSParenthesizedType" || input.node.type === "TSTypeOperator" && input.node.operator === "readonly") return namedTuple({
+		...input,
+		node: input.node.typeAnnotation,
+		seen: append(input.seen, input.node)
+	});
+	if (input.node.type !== "TSTypeReference" || input.node.typeName.type !== "Identifier") return false;
+	return pipe(variableFromScope({
+		name: input.node.typeName.name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), exists((variable) => some$1(variable.defs, (definition) => definition.node.type === "TSTypeAliasDeclaration" && namedTuple({
+		context: input.context,
+		node: definition.node.typeAnnotation,
+		seen: append(input.seen, input.node)
+	}))));
+}
+function component(node) {
+	const name = (node.type === "ArrowFunctionExpression" ? void 0 : node.id) ?? (node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier" ? node.parent.id : void 0);
+	if (name === void 0 || !matches(/^[A-Z]/u)(name.name) || node.params.length !== 1 || node.body === null) return false;
+	if (node.body.type === "JSXElement" || node.body.type === "JSXFragment") return true;
+	return node.body.type === "BlockStatement" && some$1(node.body.body, (statement) => statement.type === "ReturnStatement" && (statement.argument?.type === "JSXElement" || statement.argument?.type === "JSXFragment"));
+}
+function isPattern(input) {
+	const target = input.node.type === "AssignmentPattern" ? input.node.left : input.node;
+	if (target.type === "ArrayPattern") return !exists(fromNullishOr(target.typeAnnotation), (annotation) => namedTuple({
+		context: input.context,
+		node: annotation.typeAnnotation,
+		seen: []
+	}));
 	if (target.type !== "ObjectPattern") return false;
 	const named = filter$1(target.properties, (property) => property.type === "Property");
-	return !(named.length === 1 && named[0]?.key.type === "Identifier" && named[0].key.name === "ref" && some$1(target.properties, (property) => property.type === "RestElement"));
+	return !(input.component && named.length === 1 && named[0]?.key.type === "Identifier" && named[0].key.name === "ref" && some$1(target.properties, (property) => property.type === "RestElement"));
 }
 const noDestructuredParameter = defineRule({
 	create: (context) => {
 		function reportParameters(node) {
-			for (const parameter of filter$1(node.params, isPattern)) context.report({
+			for (const parameter of filter$1(node.params, (candidate) => isPattern({
+				component: component(node),
+				context,
+				node: candidate
+			}))) context.report({
 				message: "Take the value whole and read its fields instead of destructuring it.",
 				node: parameter
 			});
 		}
 		function reportLoopVariable(node) {
-			if (node.left.type === "VariableDeclaration" && some$1(node.left.declarations, (declarator) => isPattern(declarator.id))) context.report({
+			if (node.left.type === "VariableDeclaration" && some$1(node.left.declarations, (declarator) => isPattern({
+				component: false,
+				context,
+				node: declarator.id
+			}))) context.report({
 				message: "Take the value whole and read its fields instead of destructuring it.",
 				node: node.left
 			});
@@ -1098,7 +1102,7 @@ function receiverName(node) {
 	return node.type === "MemberExpression" ? memberName(node) : none();
 }
 function isErrorMessage(node) {
-	return node?.type === "MemberExpression" && contains(memberName(node), "message") && exists(receiverName(node.object), (name) => /^(?:e|err|error|failure|cause|exception)$|Error$/iu.test(name));
+	return node?.type === "MemberExpression" && contains(memberName(node), "message") && exists(receiverName(node.object), matches(/^(?:e|err|error|failure|cause|exception)$|Error$/iu));
 }
 function expectsMessage(node) {
 	const subject = node.object.type === "MemberExpression" && contains(memberName(node.object), "not") ? node.object.object : node.object;
@@ -1125,50 +1129,26 @@ const noErrorMessageAssertion = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
-//#region src/rules/no-fail-in-generator.ts
-function insideEffectGenerator(input) {
-	if (input.node.type === "Program") return false;
-	if ((input.node.type === "ArrowFunctionExpression" || input.node.type === "FunctionDeclaration" || input.node.type === "FunctionExpression") && !input.node.generator) return false;
-	if (input.node.type === "FunctionExpression" && input.node.generator && input.node.parent.type === "CallExpression" && exists(effectBuilderName({
-		context: input.context,
-		node: input.node.parent.callee
-	}), (name) => contains$1([
-		"fn",
-		"fnUntraced",
-		"gen"
-	], name))) return true;
-	return insideEffectGenerator({
-		context: input.context,
-		node: input.node.parent
-	});
-}
-const noFailInGenerator = defineRule({
-	create: (context) => ({ CallExpression: (node) => {
-		if (node.callee.type === "MemberExpression" && importedMember({
-			context,
-			importedName: "Effect",
-			node: node.callee,
-			propertyName: "fail"
-		}) && node.parent.type === "YieldExpression" && node.parent.delegate && node.arguments[0]?.type !== "NewExpression" && insideEffectGenerator({
-			context,
-			node
-		})) context.report({
-			message: "Yield the error instead: return yield* E.make(...).",
-			node
-		});
-	} }),
-	meta: { type: "problem" }
-});
-//#endregion
 //#region src/rules/no-fake-ref-state.ts
 function propertyName(node) {
 	if (!node.computed && node.key.type === "Identifier") return some(node.key.name);
 	if (node.key.type === "Literal" && isString(node.key.value)) return some(node.key.value);
 	return none();
 }
+function hasUnusedSetter(input) {
+	const declaration = input.node.parent;
+	if (declaration.type !== "VariableDeclarator" || declaration.id.type !== "ArrayPattern") return false;
+	const setter = declaration.id.elements[1];
+	if (isNullish$1(setter)) return true;
+	if (setter.type !== "Identifier") return false;
+	return pipe(variableFromScope({
+		name: setter.name,
+		scope: input.context.sourceCode.getScope(setter)
+	}), exists((variable) => !some$1(variable.references, (reference) => reference.isRead())));
+}
 function isFakeRefState(input) {
-	if (!isReactUseState(input) || input.node.arguments[0]?.type !== "ArrowFunctionExpression" || input.node.arguments[0].body.type !== "ObjectExpression") return false;
-	return some$1(input.node.arguments[0].body.properties, (property) => property.type === "Property" && contains(propertyName(property), "current"));
+	if (!isReactUseState(input) || input.node.arguments[0]?.type !== "ArrowFunctionExpression" || input.node.arguments[0].body.type !== "ObjectExpression" || input.node.arguments[0].body.properties.length !== 1 || !hasUnusedSetter(input)) return false;
+	return some$1(input.node.arguments[0].body.properties, (property) => property.type === "Property" && contains(propertyName(property), "current") && property.value.type === "Literal" && property.value.value === null);
 }
 const noFakeRefState = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
@@ -1232,10 +1212,10 @@ function check(input) {
 		subject: input.node.right
 	})]), map(of));
 }
-function report(input) {
+function report$1(input) {
 	const predicate = input.node.returnType?.typeAnnotation;
 	const returned = returnedExpression(input.node);
-	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish(returned)) return;
+	if (predicate?.type !== "TSTypePredicate" || predicate.asserts || predicate.parameterName.type !== "Identifier" || isNullish$1(returned)) return;
 	const name = pipe(check({
 		name: predicate.parameterName.name,
 		node: returned
@@ -1272,19 +1252,19 @@ function report(input) {
 const noHandWrittenGuard = defineRule({
 	create: (context) => ({
 		ArrowFunctionExpression: (node) => {
-			report({
+			report$1({
 				context,
 				node
 			});
 		},
 		FunctionDeclaration: (node) => {
-			report({
+			report$1({
 				context,
 				node
 			});
 		},
 		FunctionExpression: (node) => {
-			report({
+			report$1({
 				context,
 				node
 			});
@@ -1387,6 +1367,13 @@ const nativeMethods = [
 	"values",
 	"with"
 ];
+function freshRegExpFlags(input) {
+	if (input.node.type === "Literal" && hasProperty(input.node, "regex")) return some(pipe(input.context.sourceCode.getText(input.node), split("/"), last));
+	if (input.node.type !== "NewExpression" && input.node.type !== "CallExpression" || input.node.callee.type !== "Identifier" || input.node.callee.name !== "RegExp") return none();
+	const flags = input.node.arguments[1];
+	if (flags === void 0) return some(some(""));
+	return some(flags.type === "Literal" && isString(flags.value) ? some(flags.value) : none());
+}
 const noNativeMethodCall = defineRule({
 	create: (context) => ({ CallExpression: (node) => {
 		if (node.callee.type !== "MemberExpression" || node.callee.object.type === "Identifier" && (node.callee.object.name === "path" || isImportBinding({
@@ -1395,6 +1382,17 @@ const noNativeMethodCall = defineRule({
 			source: /^(?:effect(?:\/|$)|@effect\/)/u
 		}))) return;
 		const receiver = node.callee.object;
+		const regExpFlags = freshRegExpFlags({
+			context,
+			node: receiver
+		});
+		if (isSome(regExpFlags) && exists(memberName(node.callee), (name) => name === "test" || name === "exec" && exists(flatten$1(regExpFlags), (flags) => !pipe(flags, includes("g"))))) {
+			context.report({
+				message: "Match with String.match, which returns an Option, instead of a native RegExp method.",
+				node: node.callee
+			});
+			return;
+		}
 		pipe(memberName(node.callee), filter((name) => contains$1(nativeMethods, name)), filter((name) => !contains$1([
 			"entries",
 			"keys",
@@ -1409,6 +1407,50 @@ const noNativeMethodCall = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-nullish-ternary.ts
+const nullishPredicates = [
+	"isNotNull",
+	"isNotNullish",
+	"isNotUndefined",
+	"isNull",
+	"isNullish",
+	"isUndefined"
+];
+function isNullish(input) {
+	if (input.node.type === "Literal") return input.node.value === null;
+	return input.node.type === "Identifier" && input.node.name === "undefined";
+}
+function testsNullish(input) {
+	if (input.node.type === "UnaryExpression" && input.node.operator === "!") return testsNullish({
+		context: input.context,
+		node: input.node.argument
+	});
+	if (input.node.type === "BinaryExpression" && (input.node.operator === "===" || input.node.operator === "!==")) return isNullish({
+		context: input.context,
+		node: input.node.left
+	}) || isNullish({
+		context: input.context,
+		node: input.node.right
+	});
+	return input.node.type === "CallExpression" && input.node.callee.type === "MemberExpression" && importedMember({
+		context: input.context,
+		importedName: "Predicate",
+		node: input.node.callee
+	}) && exists(memberName(input.node.callee), (name) => contains$1(nullishPredicates, name));
+}
+const noNullishTernary = defineRule({
+	create: (context) => ({ ConditionalExpression: (node) => {
+		if (testsNullish({
+			context,
+			node: node.test
+		})) context.report({
+			message: "Use ?? for a default, or Option for a value that may be absent, instead of a nullish ternary.",
+			node
+		});
+	} }),
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-option-value-access.ts
 function checks(input) {
 	if (input.test.type === "LogicalExpression" && input.test.operator === input.operator) return checks({
@@ -1435,8 +1477,7 @@ function exits(node) {
 function earlyExit(input) {
 	const parent = input.node.parent;
 	if (parent?.type !== "BlockStatement" && parent?.type !== "Program") return false;
-	const index = findFirstIndex(parent.body, (statement) => statement === input.node);
-	return some$1(take(parent.body, getOrElse(index, () => 0)), (statement) => statement.type === "IfStatement" && exits(statement.consequent) && checks({
+	return some$1(take(parent.body, getOrElse(findFirstIndex(parent.body, (statement) => statement === input.node), () => 0)), (statement) => statement.type === "IfStatement" && exits(statement.consequent) && checks({
 		...input,
 		name: "isNone",
 		operator: "||",
@@ -1492,18 +1533,43 @@ function insideCycleType(input) {
 		node: input.node.parent
 	});
 }
-function referencedName(node) {
-	if (node.type !== "TSTypeReference") return none();
-	if (node.typeName.type === "Identifier") return some(node.typeName.name);
-	return node.typeName.type === "TSQualifiedName" ? some(node.typeName.right.name) : none();
+function typeDeclarations(input) {
+	if (input.name.type === "Identifier") return pipe(variableFromScope({
+		name: input.name.name,
+		scope: input.context.sourceCode.getScope(input.name)
+	}), flatMap((variable) => variable.scope.block.type === "ClassDeclaration" && some$1(variable.defs, (definition) => definition.node === variable.scope.block) ? variableFromScope({
+		name: variable.name,
+		scope: variable.scope.upper
+	}) : some(variable)), map((variable) => map$1(variable.defs, (definition) => definition.node)), getOrElse(() => empty()));
+	if (input.name.type !== "TSQualifiedName") return [];
+	const name = input.name;
+	return pipe(typeDeclarations({
+		context: input.context,
+		name: name.left
+	}), flatMap$1((declaration) => {
+		if (declaration.type !== "TSModuleDeclaration" || declaration.body === null) return [];
+		return pipe(declaration.body.body, map$1(statementDeclaration), filter$1((node) => node !== null));
+	}), filter$1((declaration) => (declaration.type === "TSTypeAliasDeclaration" || declaration.type === "TSModuleDeclaration") && declaration.id.type === "Identifier" && declaration.id.name === name.right.name));
 }
 function shapeLiterals(input) {
 	if (input.type.type === "TSTypeLiteral") return [input.type];
-	return pipe(referencedName(input.type), filter((name) => !contains$1(input.seen, name)), map((name) => pipe(input.aliases, filter$1((alias) => alias.id.name === name), flatMap$1((alias) => shapeLiterals({
-		aliases: input.aliases,
-		seen: append(input.seen, name),
+	if (input.type.type === "TSUnionType" || input.type.type === "TSIntersectionType") return flatMap$1(input.type.types, (type) => shapeLiterals({
+		...input,
+		type
+	}));
+	if (input.type.type === "TSParenthesizedType") return shapeLiterals({
+		...input,
+		type: input.type.typeAnnotation
+	});
+	if (input.type.type !== "TSTypeReference") return [];
+	return pipe(typeDeclarations({
+		context: input.context,
+		name: input.type.typeName
+	}), filter$1((declaration) => declaration.type === "TSTypeAliasDeclaration"), filter$1((alias) => !contains$1(input.seen, alias)), flatMap$1((alias) => shapeLiterals({
+		...input,
+		seen: append(input.seen, alias),
 		type: alias.typeAnnotation
-	})))), getOrElse(() => empty()));
+	})));
 }
 const noReadonlyTypeSyntax = defineRule({
 	create: (context) => {
@@ -1512,7 +1578,6 @@ const noReadonlyTypeSyntax = defineRule({
 			program: context.sourceCode.ast
 		});
 		const shapes = make$2(empty());
-		const aliases = make$2(empty());
 		const properties = make$2(empty());
 		const methods = make$2(empty());
 		function exempt(node) {
@@ -1532,7 +1597,7 @@ const noReadonlyTypeSyntax = defineRule({
 			},
 			"Program:exit": () => {
 				const literals = pipe(get$3(shapes), flatMap$1((shape) => shapeLiterals({
-					aliases: get$3(aliases),
+					context,
 					seen: [],
 					type: shape
 				})));
@@ -1572,9 +1637,6 @@ const noReadonlyTypeSyntax = defineRule({
 			TSPropertySignature: (node) => {
 				update(properties, append(node));
 			},
-			TSTypeAliasDeclaration: (node) => {
-				update(aliases, append(node));
-			},
 			TSTypeOperator: (node) => {
 				if (node.operator === "readonly" && !exempt(node)) context.report({
 					message: "Use a mutable type shape.",
@@ -1597,7 +1659,7 @@ function isExported(node) {
 	if (node.parent.type === "ExportNamedDeclaration" || node.parent.type === "ExportDefaultDeclaration") return true;
 	return node.parent.type === "VariableDeclarator" && node.parent.parent.type === "VariableDeclaration" && node.parent.parent.parent.type === "ExportNamedDeclaration";
 }
-function inferredIdentically$1(input) {
+function inferredIdentically(input) {
 	const text = input.context.sourceCode.getText;
 	const body = input.node.body;
 	if (body === null) return false;
@@ -1619,11 +1681,11 @@ const noRedundantReturnType = defineRule({
 		function exit(node) {
 			const frame = last(get$3(frames));
 			update(frames, dropRight(1));
-			if (node.async || node.generator || isNullish(node.returnType)) return;
-			if (inferredIdentically$1({
+			if (node.async || node.generator || isNullish$1(node.returnType)) return;
+			if (inferredIdentically({
 				context,
 				node,
-				returns: match(frame, {
+				returns: match$1(frame, {
 					onNone: () => empty(),
 					onSome: (top) => top.returns
 				}),
@@ -1641,7 +1703,7 @@ const noRedundantReturnType = defineRule({
 			FunctionExpression: enter,
 			"FunctionExpression:exit": exit,
 			ReturnStatement: (node) => {
-				update(frames, (stack) => pipe(last(stack), match({
+				update(frames, (stack) => pipe(last(stack), match$1({
 					onNone: () => stack,
 					onSome: (top) => append(dropRight(stack, 1), { returns: append(top.returns, node) })
 				})));
@@ -1710,18 +1772,10 @@ const noRedundantUseRefNullType = defineRule({
 });
 //#endregion
 //#region src/rules/no-redundant-variable-annotation.ts
-function isStringLiteral(node) {
-	return node.type === "Literal" && isString(node.value);
-}
-function inferredIdentically(input) {
-	const text = input.context.sourceCode.getText;
-	if (input.init.type === "TSAsExpression") return text(input.init.typeAnnotation) === text(input.type);
-	return input.init.type === "ConditionalExpression" && input.type.type === "TSStringKeyword" && isStringLiteral(input.init.consequent) && isStringLiteral(input.init.alternate);
-}
 const noRedundantVariableAnnotation = defineRule({
 	create: (context) => ({ VariableDeclarator: (node) => {
 		const annotation = node.id.typeAnnotation;
-		if (node.init === null || isNullish(annotation)) return;
+		if (node.init === null || isNullish$1(annotation)) return;
 		if (node.init.type === "ArrayExpression" && isArrayEmpty(node.init.elements)) {
 			context.report({
 				message: "Write Array.empty<T>() instead of annotating an empty array.",
@@ -1729,11 +1783,7 @@ const noRedundantVariableAnnotation = defineRule({
 			});
 			return;
 		}
-		if (inferredIdentically({
-			context,
-			init: node.init,
-			type: annotation.typeAnnotation
-		})) context.report({
+		if (node.init.type === "TSAsExpression" && context.sourceCode.getText(node.init.typeAnnotation) === context.sourceCode.getText(annotation.typeAnnotation)) context.report({
 			message: "Drop this annotation; inference gives the same type.",
 			node: annotation
 		});
@@ -1792,7 +1842,10 @@ function shippedSchema(input) {
 		node: input.filter.callee
 	});
 	const [value, ...rest] = input.filter.arguments;
-	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && (entry.only === void 0 ? value === void 0 : value?.type === "Literal" && value.value === entry.only)), map((entry) => entry.schema));
+	return pipe(shipped, findFirst((entry) => contains(base, entry.base) && contains(check, entry.check) && isArrayEmpty(rest) && match$1(fromUndefinedOr(entry.only), {
+		onNone: () => value === void 0,
+		onSome: (only) => value?.type === "Literal" && value.value === only
+	})), map((entry) => entry.schema));
 }
 function pipedBase(node) {
 	const parent = node.parent;
@@ -1846,6 +1899,104 @@ const noRenamedImport = defineRule({
 	meta: { type: "problem" }
 });
 //#endregion
+//#region src/rules/no-single-use-value.ts
+const repeating = [
+	"ArrowFunctionExpression",
+	"DoWhileStatement",
+	"ForInStatement",
+	"ForOfStatement",
+	"ForStatement",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"WhileStatement"
+];
+function runsOnce(input) {
+	const node = input.node;
+	const child = input.child;
+	if ((node.type === "ForOfStatement" || node.type === "ForInStatement") && node.right === child || node.type === "IfStatement" && node.test === child || node.type === "ConditionalExpression" && node.test === child || node.type === "LogicalExpression" && node.left === child) return climb({
+		...input,
+		node
+	});
+	if (contains$1(repeating, node.type) || node.type === "IfStatement" || node.type === "ConditionalExpression" || node.type === "LogicalExpression" || node.type === "ChainExpression" || node.type === "SwitchStatement" || node.type === "TryStatement") return false;
+	return climb({
+		...input,
+		node
+	});
+}
+function climb(input) {
+	if (input.node === input.statement) return true;
+	if (isNullish$1(input.node.parent)) return false;
+	return runsOnce({
+		child: input.node,
+		node: input.node.parent,
+		statement: input.statement
+	});
+}
+function insideConditional(input) {
+	if (input.node === input.statement) return false;
+	if (input.node.type === "ConditionalExpression") return true;
+	return isNotNullish(input.node.parent) && insideConditional({
+		...input,
+		node: input.node.parent
+	});
+}
+function candidate(node) {
+	const declaration = node.parent;
+	const init = node.init;
+	return declaration.type === "VariableDeclaration" && declaration.kind === "const" && declaration.declarations.length === 1 && declaration.parent.type === "BlockStatement" && node.id.type === "Identifier" && node.id.typeAnnotation === null && init !== null && !contains$1(["ArrowFunctionExpression", "FunctionExpression"], init.type) && !(init.type === "Literal" && !hasProperty(init, "regex")) && !(init.type === "TemplateLiteral" && isArrayEmpty(init.expressions));
+}
+function report(input) {
+	const declaration = input.node.parent;
+	const init = input.node.init;
+	if (declaration.type !== "VariableDeclaration" || declaration.parent.type !== "BlockStatement" || input.node.id.type !== "Identifier" || init === null || pipe(input.context.sourceCode.getText(init), includes("\n"))) return;
+	const statements = declaration.parent.body;
+	const name = input.node.id.name;
+	pipe(findFirstIndex(statements, (statement) => statement === declaration), flatMap((index) => get$1(statements, index + 1)), flatMap((next) => pipe(variableFromScope({
+		name,
+		scope: input.context.sourceCode.getScope(input.node)
+	}), map((variable) => filter$1(variable.references, (reference) => reference.isRead())), filter((reads) => reads.length === 1), flatMap(head), map((reference) => reference.identifier), filter((read) => read.range[0] >= next.range[0] && read.range[1] <= next.range[1] && climb({
+		node: read,
+		statement: next
+	}) && !(init.type === "ConditionalExpression" && insideConditional({
+		node: read,
+		statement: next
+	})) && !some$1(input.effects, (effect) => effect.range[0] >= next.range[0] && effect.range[1] <= read.range[0])))), map(() => {
+		input.context.report({
+			message: "Inline this value into the next statement, its only use.",
+			node: input.node
+		});
+	}));
+}
+const noSingleUseValue = defineRule({
+	create: (context) => {
+		const effects = make$2(empty());
+		const candidates = make$2(empty());
+		function effect(node) {
+			update(effects, append(node));
+		}
+		return {
+			AssignmentExpression: effect,
+			AwaitExpression: effect,
+			CallExpression: effect,
+			NewExpression: effect,
+			"Program:exit": () => {
+				for (const node of get$3(candidates)) report({
+					context,
+					effects: get$3(effects),
+					node
+				});
+			},
+			TaggedTemplateExpression: effect,
+			UpdateExpression: effect,
+			VariableDeclarator: (node) => {
+				if (candidate(node)) update(candidates, append(node));
+			},
+			YieldExpression: effect
+		};
+	},
+	meta: { type: "problem" }
+});
+//#endregion
 //#region src/rules/no-stored-schema-operation.ts
 function storedSchemaOperation(node) {
 	return node.parent.type === "VariableDeclarator" && node.parent.init === node || node.parent.type === "Property" && node.parent.value === node || node.parent.type === "PropertyDefinition" && node.parent.value === node || node.parent.type === "ArrayExpression" || node.parent.type === "AssignmentExpression" && node.parent.right === node;
@@ -1890,7 +2041,7 @@ function forwardedCall(input) {
 function exactForwardingFunction(node) {
 	const names = pipe(node.params, map$1(parameterName), getSomes);
 	const returned = returnedExpression(node);
-	if (isArrayEmpty(names) || names.length !== node.params.length || isNullish(returned)) return false;
+	if (isArrayEmpty(names) || names.length !== node.params.length || isNullish$1(returned)) return false;
 	if (returned.type === "Identifier") return names.length === 1 && returned.name === names[0];
 	return (returned.type === "CallExpression" || returned.type === "NewExpression") && returned.callee.type === "Identifier" && forwardedCall({
 		names,
@@ -1915,8 +2066,7 @@ function unexportedBindingName(node) {
 }
 function singleCallerWrapper(input) {
 	const names = pipe(input.node.params, map$1(parameterName), getSomes);
-	const returned = returnedExpression(input.node);
-	if (input.node.async || input.node.generator || input.node.returnType?.typeAnnotation.type === "TSTypePredicate" || isArrayEmpty(names) || names.length !== input.node.params.length || returned?.type !== "CallExpression") return false;
+	if (input.node.async || input.node.generator || input.node.returnType?.typeAnnotation.type === "TSTypePredicate" || isArrayEmpty(names) || names.length !== input.node.params.length || returnedExpression(input.node)?.type !== "CallExpression") return false;
 	return pipe(unexportedBindingName(input.node), flatMap((name) => variableFromScope({
 		name,
 		scope: input.context.sourceCode.getScope(input.node)
@@ -2072,11 +2222,11 @@ const noUndestructuredUseState = defineRule({
 //#region src/rules/no-unexplained-disable.ts
 const noUnexplainedDisable = defineRule({
 	create: (context) => ({ Program: () => {
-		for (const comment of context.sourceCode.getAllComments()) if (/^\s*(?:eslint|oxlint)-disable\S*\s(?:(?!\s--\s).)*\bsort-keys\b/u.test(comment.value)) context.report({
+		for (const comment of context.sourceCode.getAllComments()) if (matches(/^\s*(?:eslint|oxlint)-disable\S*\s(?:(?!\s--\s).)*\bsort-keys\b/u)(comment.value)) context.report({
 			message: "Sort the keys, starting a new sorted group after a blank line; never disable sort-keys.",
 			node: comment
 		});
-		else if (/^\s*(?:eslint-disable|oxlint-disable|@effect-diagnostics)/u.test(comment.value) && !/\s--\s*\S/u.test(comment.value)) context.report({
+		else if (matches(/^\s*(?:eslint-disable|oxlint-disable|@effect-diagnostics)/u)(comment.value) && !matches(/\s--\s*\S/u)(comment.value)) context.report({
 			message: "Give this disable a `-- reason`.",
 			node: comment
 		});
@@ -2153,7 +2303,7 @@ function schemaDefinitionMember(node) {
 	return none();
 }
 function isSchemaDefinitionName(name) {
-	return !isSchemaOperationName(name) && !/^to[A-Z]/u.test(name);
+	return !isSchemaOperationName(name) && !matches(/^(?:is|to)[A-Z]/u)(name) && !matches(/^makeFilter(?:Group)?$/u)(name);
 }
 function isSchemaDefinition(input) {
 	if (input.node.type === "CallExpression" && input.node.callee.type === "Identifier" && isImportBinding({
@@ -2192,7 +2342,7 @@ function namedTypeAlias(input) {
 	return pipe(input.typeStatement, flatMap(typeAlias), filter((declaration) => declaration.id.name === input.name));
 }
 function reportSchemaVariable(input) {
-	if (input.variable.id.type !== "Identifier" || !/^[A-Z]/u.test(input.variable.id.name)) return;
+	if (input.variable.id.type !== "Identifier" || !matches(/^[A-Z]/u)(input.variable.id.name)) return;
 	if (input.variable.init === null || !isSchemaDefinition({
 		context: input.context,
 		node: input.variable.init
@@ -2361,12 +2511,12 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-double-nullish-check": "error",
 		"@deslop/coding-standards/no-effect-property-arrow": "error",
 		"@deslop/coding-standards/no-error-message-assertion": "error",
-		"@deslop/coding-standards/no-fail-in-generator": "error",
 		"@deslop/coding-standards/no-fake-ref-state": "error",
 		"@deslop/coding-standards/no-hand-written-guard": "error",
 		"@deslop/coding-standards/no-let": "error",
 		"@deslop/coding-standards/no-native-emptiness-check": "error",
 		"@deslop/coding-standards/no-native-method-call": "error",
+		"@deslop/coding-standards/no-nullish-ternary": "error",
 		"@deslop/coding-standards/no-option-value-access": "error",
 		"@deslop/coding-standards/no-readonly-type-syntax": "error",
 		"@deslop/coding-standards/no-redundant-return-type": "error",
@@ -2375,6 +2525,7 @@ const oxlint = defineConfig({
 		"@deslop/coding-standards/no-redundant-variable-annotation": "error",
 		"@deslop/coding-standards/no-reinvented-schema": "error",
 		"@deslop/coding-standards/no-renamed-import": "error",
+		"@deslop/coding-standards/no-single-use-value": "error",
 		"@deslop/coding-standards/no-stored-schema-operation": "error",
 		"@deslop/coding-standards/no-switch-statement": "error",
 		"@deslop/coding-standards/no-trivial-indirection": "error",
@@ -2638,6 +2789,7 @@ const oxlint = defineConfig({
 		"max-depth": ["error", 3],
 		"max-nested-callbacks": ["error", 6],
 		"no-cond-assign": "error",
+		"no-constant-binary-expression": "error",
 		"no-continue": "error",
 		"no-control-regex": "error",
 		"no-debugger": "error",
@@ -2651,6 +2803,7 @@ const oxlint = defineConfig({
 		"no-invalid-regexp": "error",
 		"no-iterator": "error",
 		"no-lonely-if": "error",
+		"no-loss-of-precision": "error",
 		"no-misleading-character-class": "error",
 		"no-multi-assign": "error",
 		"no-negated-condition": "error",
@@ -2888,6 +3041,7 @@ const oxlint = defineConfig({
 		"no-unneeded-ternary": "error",
 		"no-unreachable-loop": "error",
 		"no-unsafe-finally": "error",
+		"no-unsafe-optional-chaining": ["error", { disallowArithmeticOperators: true }],
 		"no-unused-expressions": "error",
 		"no-useless-assignment": "error",
 		"no-useless-backreference": "error",
@@ -2899,6 +3053,7 @@ const oxlint = defineConfig({
 		"no-useless-escape": "error",
 		"no-useless-rename": "error",
 		"no-useless-return": "error",
+		"no-var": "error",
 		"no-void": "error",
 		"object-shorthand": "error",
 		"oxc/branches-sharing-code": "error",
@@ -2910,6 +3065,7 @@ const oxlint = defineConfig({
 		"prefer-template": "error",
 		"require-unicode-regexp": "error",
 		"react-doctor/no-call-component-as-function": "error",
+		"react-doctor/no-controlled-input-value-without-state-update": "error",
 		"react-doctor/no-create-context-in-render": "error",
 		"react-doctor/no-default-props": "error",
 		"react-doctor/no-inline-exhaustive-style": "error",
@@ -3048,12 +3204,12 @@ var oxlint_default = definePlugin({
 		"no-double-nullish-check": noDoubleNullishCheck,
 		"no-effect-property-arrow": noEffectPropertyArrow,
 		"no-error-message-assertion": noErrorMessageAssertion,
-		"no-fail-in-generator": noFailInGenerator,
 		"no-fake-ref-state": noFakeRefState,
 		"no-hand-written-guard": noHandWrittenGuard,
 		"no-let": noLet,
 		"no-native-emptiness-check": noNativeEmptinessCheck,
 		"no-native-method-call": noNativeMethodCall,
+		"no-nullish-ternary": noNullishTernary,
 		"no-option-value-access": noOptionValueAccess,
 		"no-readonly-type-syntax": noReadonlyTypeSyntax,
 		"no-redundant-return-type": noRedundantReturnType,
@@ -3062,6 +3218,7 @@ var oxlint_default = definePlugin({
 		"no-redundant-variable-annotation": noRedundantVariableAnnotation,
 		"no-reinvented-schema": noReinventedSchema,
 		"no-renamed-import": noRenamedImport,
+		"no-single-use-value": noSingleUseValue,
 		"no-stored-schema-operation": noStoredSchemaOperation,
 		"no-switch-statement": noSwitchStatement,
 		"no-trivial-indirection": noTrivialIndirection,