@pobammer-ts/small-rules 2.2.1 → 2.4.0

package/dist/index.d.ts

@@ -379,9 +379,15 @@ declare const smallRules: import("oxlint-plugin-utilities").Plugin<{
   }], "noRecursive", undefined>;
   "no-redundant-aspect-ratio-constraint": import("oxlint-plugin-utilities").CreateRule<readonly [], "redundantAspectRatioConstraint", undefined>;
   "no-render-helper-functions": import("oxlint-plugin-utilities").CreateRule<readonly [], "noRenderHelper", undefined>;
-  "no-restricted-property-assignment": import("oxlint-plugin-utilities").CreateOnceRule<readonly [{
+  "no-restricted-property-assignment": import("oxlint-plugin-utilities").CreateRule<readonly [{
     readonly additionalProperties: false;
     readonly properties: {
+      readonly allowFiles: {
+        readonly items: {
+          readonly type: "string";
+        };
+        readonly type: "array";
+      };
       readonly checkComputed: {
         readonly default: true;
         readonly type: "boolean";

package/dist/index.js

@@ -5,6 +5,7 @@ import { parseSync } from "oxc-parser";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { ResolverFactory } from "oxc-resolver";
 import { type } from "arktype";
+import { Minimatch, minimatch } from "minimatch";
 //#region src/rules/array-type-generic.ts
 function toGenericArrayType(typeNode, sourceCode) {
 	if (typeNode.type === "TSParenthesizedType") return toGenericArrayType(typeNode.typeAnnotation, sourceCode);
@@ -112,6 +113,197 @@ function hasShadowedBinding(sourceCode, node, name) {
 	return false;
 }
 //#endregion
+//#region src/utilities/oxc-utilities.ts
+const COMPONENT_NAME_PATTERN = /^[A-Z]/v;
+const KEY_OF_NODE = new Set([
+	"end",
+	"loc",
+	"parent",
+	"range",
+	"start",
+	"type"
+]);
+function isNode$1(value) {
+	return isRecord(value) && isStringRaw(value.type);
+}
+function isKeyOfNode(key) {
+	return KEY_OF_NODE.has(key);
+}
+function isComponentName(name) {
+	return COMPONENT_NAME_PATTERN.test(name);
+}
+function isVariableDeclarator(node) {
+	return node.type === "VariableDeclarator";
+}
+function getTypeAnnotationFromBinding(binding) {
+	return isTsTypeAnnotation(binding.typeAnnotation) ? binding.typeAnnotation : void 0;
+}
+function isTsTypeAnnotation(value) {
+	return isRecord(value) && "type" in value && value.type === "TSTypeAnnotation";
+}
+function isIdentifierNamed$1(node, name) {
+	return node.type === "Identifier" && node.name === name;
+}
+function isReactNamedCall(node, identifiers, reactNamespaces, name) {
+	if (node.callee.type === "Identifier") return identifiers.has(node.callee.name);
+	if (node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier") return false;
+	return reactNamespaces.has(node.callee.object.name) && getMemberPropertyName(node.callee) === name;
+}
+function isUseMemoCall(node, memoIdentifiers, reactNamespaces) {
+	return isReactNamedCall(node, memoIdentifiers, reactNamespaces, "useMemo");
+}
+function getImportedName({ imported }) {
+	return imported.type === "Identifier" ? imported.name : imported.value;
+}
+function hasName(node) {
+	return node.type === "Identifier" && isStringRaw(node.name);
+}
+function isIdentifierName(node) {
+	return node.type === "Identifier";
+}
+function isJsxIdentifier$1(node) {
+	return node.type === "JSXIdentifier" && "name" in node;
+}
+function isJsxOpeningExpression(node) {
+	return node.type === "JSXOpeningElement";
+}
+function isImportDeclaration(node) {
+	return node.type === "ImportDeclaration";
+}
+function isStringLiteral(node) {
+	return node.type === "Literal" && isStringRaw(node.value);
+}
+function isCallExpression$1(node) {
+	return node.type === "CallExpression";
+}
+function isImportSpecifier$1(node) {
+	return node.type === "ImportSpecifier";
+}
+function isExportSpecifier(node) {
+	return node.type === "ExportSpecifier";
+}
+function isProperty(node) {
+	return node.type === "Property";
+}
+function isMemberExpression(node) {
+	return node.type === "MemberExpression";
+}
+function isAssignmentExpression(node) {
+	return node.type === "AssignmentExpression";
+}
+function isUnaryExpression(node) {
+	return node.type === "UnaryExpression";
+}
+function isBinaryExpression(node) {
+	return node.type === "BinaryExpression";
+}
+function isLogicalExpression(node) {
+	return node.type === "LogicalExpression";
+}
+function isConditionalExpression(node) {
+	return node.type === "ConditionalExpression";
+}
+function isSequenceExpression(node) {
+	return node.type === "SequenceExpression";
+}
+function isMethodDefinition(node) {
+	return node.type === "MethodDefinition" || node.type === "TSAbstractMethodDefinition";
+}
+function isPropertyDefinition(node) {
+	return node.type === "PropertyDefinition" || node.type === "TSAbstractPropertyDefinition";
+}
+function isImportDefaultSpecifier(node) {
+	return node.type === "ImportDefaultSpecifier";
+}
+function isImportNamespaceSpecifier(node) {
+	return node.type === "ImportNamespaceSpecifier";
+}
+function isVariableDeclaration(node) {
+	return node.type === "VariableDeclaration";
+}
+function isExportNamedDeclaration(node) {
+	return node.type === "ExportNamedDeclaration";
+}
+function isFunctionDeclaration(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function isCallbackFunction(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
+}
+function isAnyFunction(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+function isNamedGlobalCall(node, name) {
+	return isIdentifierNamed$1(node.callee, name);
+}
+function isClass(node) {
+	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
+}
+function isTsTypeAliasDeclaration(node) {
+	return node.type === "TSTypeAliasDeclaration";
+}
+function isTsPropertySignature(node) {
+	return node.type === "TSPropertySignature";
+}
+function isLiteral(node) {
+	return node.type === "Literal";
+}
+function isArrowFunctionExpression(node) {
+	return node.type === "ArrowFunctionExpression";
+}
+function isFunction(node) {
+	return isFunctionDeclaration(node) || isArrowFunctionExpression(node);
+}
+function isTsQualifiedName(node) {
+	return node.type === "TSQualifiedName";
+}
+function isNumericLiteral(node) {
+	return node.type === "Literal" && isNumberRaw(node.value);
+}
+function isNewExpression(node) {
+	return node.type === "NewExpression";
+}
+function isArrayExpression(node) {
+	return node.type === "ArrayExpression";
+}
+function isObjectExpression(node) {
+	return node.type === "ObjectExpression";
+}
+function isObjectPattern(node) {
+	return node.type === "ObjectPattern";
+}
+function isTemplateLiteral(node) {
+	return node.type === "TemplateLiteral";
+}
+function isExpressionStatement(node) {
+	return node.type === "ExpressionStatement";
+}
+function isTsTypeAssertion(node) {
+	return node.type === "TSTypeAssertion";
+}
+function isTsAsExpression(node) {
+	return node.type === "TSAsExpression";
+}
+function isAssignmentPattern(node) {
+	return node.type === "AssignmentPattern";
+}
+function isThisExpression(node) {
+	return node.type === "ThisExpression";
+}
+function isStaticRequire(node) {
+	if (!isCallExpression$1(node) || node.optional) return false;
+	const { callee } = node;
+	if (!isIdentifierName(callee) || callee.name !== "require" || node.arguments.length !== 1) return false;
+	const [argument] = node.arguments;
+	return argument !== void 0 && isStringLiteral(argument);
+}
+function isBindingIdentifier(node) {
+	return node.type === "Identifier";
+}
+function isExpressionNode(node) {
+	return node.type !== "PrivateIdentifier";
+}
+//#endregion
 //#region src/rules/ban-instances.ts
 function getJsxAttributeName$2(name) {
 	return name.type === "JSXIdentifier" ? name.name : name.name.name;
@@ -162,7 +354,7 @@ function getEnclosingFunctionScope(scope) {
 	return currentScope;
 }
 function getInstanceClassName(node) {
-	if (node.callee.type !== "Identifier" || node.callee.name !== "Instance") return void 0;
+	if (!isNamedGlobalCall(node, "Instance")) return void 0;
 	const [firstArgument] = node.arguments;
 	if (firstArgument?.type !== "Literal" || !isStringRaw(firstArgument.value)) return void 0;
 	return firstArgument.value;
@@ -326,191 +518,6 @@ const banInstances = defineRule({
 	}
 });
 //#endregion
-//#region src/utilities/oxc-utilities.ts
-const COMPONENT_NAME_PATTERN = /^[A-Z]/v;
-const KEY_OF_NODE = new Set([
-	"end",
-	"loc",
-	"parent",
-	"range",
-	"start",
-	"type"
-]);
-function isNode$1(value) {
-	return isRecord(value) && isStringRaw(value.type);
-}
-function isKeyOfNode(key) {
-	return KEY_OF_NODE.has(key);
-}
-function isComponentName(name) {
-	return COMPONENT_NAME_PATTERN.test(name);
-}
-function isVariableDeclarator(node) {
-	return node.type === "VariableDeclarator";
-}
-function getTypeAnnotationFromBinding(binding) {
-	return isTsTypeAnnotation(binding.typeAnnotation) ? binding.typeAnnotation : void 0;
-}
-function isTsTypeAnnotation(value) {
-	return isRecord(value) && "type" in value && value.type === "TSTypeAnnotation";
-}
-function isIdentifierNamed$1(node, name) {
-	return node.type === "Identifier" && node.name === name;
-}
-function isReactNamedCall(node, identifiers, reactNamespaces, name) {
-	if (node.callee.type === "Identifier") return identifiers.has(node.callee.name);
-	if (node.callee.type !== "MemberExpression" || node.callee.object.type !== "Identifier") return false;
-	return reactNamespaces.has(node.callee.object.name) && getMemberPropertyName(node.callee) === name;
-}
-function isUseMemoCall(node, memoIdentifiers, reactNamespaces) {
-	return isReactNamedCall(node, memoIdentifiers, reactNamespaces, "useMemo");
-}
-function getImportedName({ imported }) {
-	return imported.type === "Identifier" ? imported.name : imported.value;
-}
-function hasName(node) {
-	return node.type === "Identifier" && isStringRaw(node.name);
-}
-function isIdentifierName(node) {
-	return node.type === "Identifier";
-}
-function isJsxIdentifier$1(node) {
-	return node.type === "JSXIdentifier" && "name" in node;
-}
-function isJsxOpeningExpression(node) {
-	return node.type === "JSXOpeningElement";
-}
-function isImportDeclaration(node) {
-	return node.type === "ImportDeclaration";
-}
-function isStringLiteral(node) {
-	return node.type === "Literal" && isStringRaw(node.value);
-}
-function isCallExpression$1(node) {
-	return node.type === "CallExpression";
-}
-function isImportSpecifier$1(node) {
-	return node.type === "ImportSpecifier";
-}
-function isExportSpecifier(node) {
-	return node.type === "ExportSpecifier";
-}
-function isProperty(node) {
-	return node.type === "Property";
-}
-function isMemberExpression(node) {
-	return node.type === "MemberExpression";
-}
-function isAssignmentExpression(node) {
-	return node.type === "AssignmentExpression";
-}
-function isUnaryExpression(node) {
-	return node.type === "UnaryExpression";
-}
-function isBinaryExpression(node) {
-	return node.type === "BinaryExpression";
-}
-function isLogicalExpression(node) {
-	return node.type === "LogicalExpression";
-}
-function isConditionalExpression(node) {
-	return node.type === "ConditionalExpression";
-}
-function isSequenceExpression(node) {
-	return node.type === "SequenceExpression";
-}
-function isMethodDefinition(node) {
-	return node.type === "MethodDefinition" || node.type === "TSAbstractMethodDefinition";
-}
-function isPropertyDefinition(node) {
-	return node.type === "PropertyDefinition" || node.type === "TSAbstractPropertyDefinition";
-}
-function isImportDefaultSpecifier(node) {
-	return node.type === "ImportDefaultSpecifier";
-}
-function isImportNamespaceSpecifier(node) {
-	return node.type === "ImportNamespaceSpecifier";
-}
-function isVariableDeclaration(node) {
-	return node.type === "VariableDeclaration";
-}
-function isExportNamedDeclaration(node) {
-	return node.type === "ExportNamedDeclaration";
-}
-function isFunctionDeclaration(node) {
-	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
-}
-function isCallbackFunction(node) {
-	return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
-}
-function isClass(node) {
-	return node.type === "ClassDeclaration" || node.type === "ClassExpression";
-}
-function isTsTypeAliasDeclaration(node) {
-	return node.type === "TSTypeAliasDeclaration";
-}
-function isTsPropertySignature(node) {
-	return node.type === "TSPropertySignature";
-}
-function isLiteral(node) {
-	return node.type === "Literal";
-}
-function isArrowFunctionExpression(node) {
-	return node.type === "ArrowFunctionExpression";
-}
-function isFunction(node) {
-	return isFunctionDeclaration(node) || isArrowFunctionExpression(node);
-}
-function isTsQualifiedName(node) {
-	return node.type === "TSQualifiedName";
-}
-function isNumericLiteral(node) {
-	return node.type === "Literal" && isNumberRaw(node.value);
-}
-function isNewExpression(node) {
-	return node.type === "NewExpression";
-}
-function isArrayExpression(node) {
-	return node.type === "ArrayExpression";
-}
-function isObjectExpression(node) {
-	return node.type === "ObjectExpression";
-}
-function isObjectPattern(node) {
-	return node.type === "ObjectPattern";
-}
-function isTemplateLiteral(node) {
-	return node.type === "TemplateLiteral";
-}
-function isExpressionStatement(node) {
-	return node.type === "ExpressionStatement";
-}
-function isTsTypeAssertion(node) {
-	return node.type === "TSTypeAssertion";
-}
-function isTsAsExpression(node) {
-	return node.type === "TSAsExpression";
-}
-function isAssignmentPattern(node) {
-	return node.type === "AssignmentPattern";
-}
-function isThisExpression(node) {
-	return node.type === "ThisExpression";
-}
-function isStaticRequire(node) {
-	if (!isCallExpression$1(node) || node.optional) return false;
-	const { callee } = node;
-	if (!isIdentifierName(callee) || callee.name !== "require" || node.arguments.length !== 1) return false;
-	const [argument] = node.arguments;
-	return argument !== void 0 && isStringLiteral(argument);
-}
-function isBindingIdentifier(node) {
-	return node.type === "Identifier";
-}
-function isExpressionNode(node) {
-	return node.type !== "PrivateIdentifier";
-}
-//#endregion
 //#region src/rules/ban-react-fc.ts
 const BANNED_FC_NAMES = new Set([
 	"FC",
@@ -2597,7 +2604,7 @@ function isPromiseChainCall(node) {
 }
 function isAsyncIife({ callee }) {
 	const unwrapped = unwrapExpression(callee);
-	return (unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "FunctionExpression") && unwrapped.async;
+	return isCallbackFunction(unwrapped) && unwrapped.async;
 }
 function getThisAsyncMethodName({ callee }, asyncMethods) {
 	if (callee.type !== "MemberExpression" || callee.object.type !== "ThisExpression" || callee.property.type !== "Identifier") return;
@@ -2614,7 +2621,7 @@ function getLocalVariableAssignment(node) {
 	return parent.id.type === "Identifier" ? parent.id.name : void 0;
 }
 function isNonIifeFunction(node) {
-	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return false;
+	if (!isCallbackFunction(node)) return false;
 	if (node.parent.type === "ParenthesizedExpression" && node.parent.parent.type === "CallExpression" && node.parent.parent.callee === node.parent) return false;
 	return node.parent.type !== "CallExpression" || node.parent.callee !== node;
 }
@@ -2765,7 +2772,7 @@ const noColor3Constructor = defineRule({
 	create(context) {
 		const options = normalizeOptions$4(context.options[0]);
 		return { NewExpression(node) {
-			if (node.callee.type !== "Identifier" || node.callee.name !== "Color3") return;
+			if (!isNamedGlobalCall(node, "Color3")) return;
 			const parameters = node.arguments;
 			if (parameters.length === 0) return;
 			const collected = collectNumericComponents(parameters);
@@ -3445,14 +3452,6 @@ const LOOP_TYPES = new Set([
 function isLoopNode(node) {
 	return LOOP_TYPES.has(node.type);
 }
-const FUNCTION_BOUNDARY_TYPES$1 = new Set([
-	"ArrowFunctionExpression",
-	"FunctionDeclaration",
-	"FunctionExpression"
-]);
-function isFunctionBoundary(node) {
-	return FUNCTION_BOUNDARY_TYPES$1.has(node.type);
-}
 function findLabeledStatementBody$1(labelName, startingNode) {
 	let current = startingNode;
 	while (current !== null) {
@@ -3466,7 +3465,7 @@ function breaksTargetLoop(statement, loopNode) {
 	if (statement.label) return findLabeledStatementBody$1(statement.label.name, statement.parent) === loopNode;
 	let current = statement.parent;
 	while (current !== null) {
-		if (current.type === "Program" || isFunctionBoundary(current) || current.type === "SwitchStatement") return false;
+		if (current.type === "Program" || isAnyFunction(current) || current.type === "SwitchStatement") return false;
 		if (isLoopNode(current)) return current === loopNode;
 		current = current.parent;
 	}
@@ -5533,7 +5532,7 @@ function hasAspectRatioConstraintInSubtree(node) {
 function getFunctionComponentName(node) {
 	if (node.type === "FunctionDeclaration") return node.id?.name;
 	/* v8 ignore next -- @preserve only named declarations and assigned function expressions are inspected as components. */
-	if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+	if (isCallbackFunction(node)) {
 		const { parent } = node;
 		/* v8 ignore next -- @preserve assigned function components have identifier variable declarator parents. */
 		if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") return parent.id.name;
@@ -5804,35 +5803,72 @@ const noRenderHelperFunctions = defineRule({
 });
 //#endregion
 //#region src/rules/no-restricted-property-assignment.ts
-function isRestriction(value) {
-	if (!isRecord(value)) return false;
-	if (!isStringRaw(value.object)) return false;
-	if (!Array.isArray(value.properties)) return false;
-	if (!value.properties.every((property) => isStringRaw(property))) return false;
-	return value.message === void 0 || isStringRaw(value.message);
-}
-function isRuleOptions(value) {
-	if (!isRecord(value)) return false;
-	if (!Array.isArray(value.restrictions)) return false;
-	if (!value.restrictions.every(isRestriction)) return false;
-	return value.checkComputed === void 0 || typeof value.checkComputed === "boolean";
-}
-function isMemberExpressionTarget(node) {
-	return node.type === "MemberExpression";
+const isRestriction = type({
+	"message?": "string | undefined",
+	object: "string",
+	properties: type("string[]").readonly()
+}).readonly();
+const isRuleOptions = type({
+	"allowFiles?": type("string[]").readonly().or("undefined"),
+	"checkComputed?": "boolean | undefined",
+	restrictions: isRestriction.array().readonly()
+}).readonly();
+const FILE_MATCH_OPTIONS = { matchBase: true };
+const NAME_MATCH_OPTIONS = {
+	dot: true,
+	magicalBraces: true
+};
+function compileMatcher(pattern, options) {
+	const matcher = new Minimatch(pattern, options);
+	const hasMagic = matcher.hasMagic();
+	return {
+		hasMagic,
+		matches: hasMagic ? (value) => matcher.match(value) : (value) => value === pattern
+	};
+}
+function createPropertyMatcher(patterns) {
+	const literalPatterns = /* @__PURE__ */ new Set();
+	const globMatchers = [];
+	for (const pattern of patterns) {
+		const matcher = compileMatcher(pattern, NAME_MATCH_OPTIONS);
+		if (matcher.hasMagic) globMatchers.push(matcher.matches);
+		else literalPatterns.add(pattern);
+	}
+	return (property) => literalPatterns.has(property) || globMatchers.some((matcher) => matcher(property));
+}
+function compileRestriction(restriction) {
+	return {
+		matchesObject: compileMatcher(restriction.object, NAME_MATCH_OPTIONS).matches,
+		matchesProperty: createPropertyMatcher(restriction.properties),
+		message: restriction.message
+	};
+}
+function getEffectiveOptions(context) {
+	const [options] = context.options;
+	if (!isRuleOptions.allows(options)) return {
+		checkComputed: true,
+		isAllowedFile: false,
+		restrictions: []
+	};
+	const { allowFiles, checkComputed, restrictions } = options;
+	const isAllowedFile = allowFiles?.some((pattern) => minimatch(context.filename, pattern, FILE_MATCH_OPTIONS)) ?? false;
+	return {
+		checkComputed: checkComputed ?? true,
+		isAllowedFile,
+		restrictions: restrictions.map(compileRestriction)
+	};
 }
 const noRestrictedPropertyAssignment = defineRule({
-	createOnce(context) {
-		let restrictions = [];
-		let checkComputed = true;
+	create(context) {
+		const { checkComputed, isAllowedFile, restrictions } = getEffectiveOptions(context);
 		function reportIfRestricted(node, reportNode) {
-			if (!isMemberExpressionTarget(node)) return;
-			if (node.computed && !checkComputed) return;
-			if (node.object.type !== "Identifier") return;
+			if (isAllowedFile || !isMemberExpression(node)) return;
+			if (node.computed && !checkComputed || node.object.type !== "Identifier") return;
 			const property = getMemberPropertyName(node);
 			if (property === void 0) return;
 			for (const restriction of restrictions) {
-				if (restriction.object !== node.object.name) continue;
-				if (restriction.properties.includes("*") || restriction.properties.includes(property)) {
+				if (!restriction.matchesObject(node.object.name)) continue;
+				if (restriction.matchesProperty(property)) {
 					if (restriction.message === void 0) context.report({
 						data: {
 							object: node.object.name,
@@ -5854,17 +5890,6 @@ const noRestrictedPropertyAssignment = defineRule({
 			AssignmentExpression(node) {
 				reportIfRestricted(node.left, node);
 			},
-			before() {
-				const [options] = context.options;
-				if (!isRuleOptions(options)) {
-					restrictions = [];
-					checkComputed = true;
-					return;
-				}
-				const { checkComputed: nextCheckComputed, restrictions: nextRestrictions } = options;
-				restrictions = nextRestrictions;
-				checkComputed = nextCheckComputed ?? true;
-			},
 			UpdateExpression(node) {
 				reportIfRestricted(node.argument, node);
 			}
@@ -5882,6 +5907,10 @@ const noRestrictedPropertyAssignment = defineRule({
 		schema: [{
 			additionalProperties: false,
 			properties: {
+				allowFiles: {
+					items: { type: "string" },
+					type: "array"
+				},
 				checkComputed: {
 					default: true,
 					type: "boolean"
@@ -5990,7 +6019,7 @@ function isStaticComponentVariable(variable, name) {
 		if (definition.node.type !== "VariableDeclarator") continue;
 		const initializer = definition.node.init ?? void 0;
 		if (initializer === void 0) continue;
-		if (initializer.type === "ArrowFunctionExpression" || initializer.type === "FunctionExpression" || initializer.type === "ClassExpression") return true;
+		if (isCallbackFunction(initializer) || initializer.type === "ClassExpression") return true;
 	}
 	return false;
 }
@@ -6383,9 +6412,14 @@ function collectAllScopes(root) {
 function isFunctionLikeInitializer(node) {
 	return isCallbackFunction(node) || node.type === "ClassExpression";
 }
+const OBJECT_LIKE_INITIALIZER_TYPES = new Set([
+	"ArrayExpression",
+	"ObjectExpression",
+	"JSXElement",
+	"JSXFragment"
+]);
 function isObjectLikeInitializer(initializer, patterns, sourceCode) {
-	if (initializer.type === "ArrayExpression" || initializer.type === "ObjectExpression") return true;
-	if (initializer.type === "JSXElement" || initializer.type === "JSXFragment") return true;
+	if (OBJECT_LIKE_INITIALIZER_TYPES.has(initializer.type)) return true;
 	if (initializer.type !== "CallExpression" && initializer.type !== "NewExpression") return false;
 	const candidateText = sourceCode.getText(initializer.callee);
 	for (const pattern of patterns) if (pattern.test(candidateText)) return true;
@@ -22043,7 +22077,7 @@ function getSequenceKeypointName(sequenceName) {
 }
 function getKeypointValue(node, keypointName, time) {
 	if (node.type !== "NewExpression") return void 0;
-	if (node.callee.type !== "Identifier" || node.callee.name !== keypointName) return void 0;
+	if (!isNamedGlobalCall(node, keypointName)) return void 0;
 	if (node.arguments.length !== 2) return void 0;
 	const [timeArgument, valueArgument] = node.arguments;
 	/* v8 ignore next -- @preserve length was checked above; this only guards malformed AST tuples. */
@@ -22702,7 +22736,7 @@ function collectArguments(parameters) {
 const preferUDim2Shorthand = defineRule({
 	create(context) {
 		return { NewExpression(node) {
-			if (node.callee.type !== "Identifier" || node.callee.name !== "UDim2") return;
+			if (!isNamedGlobalCall(node, "UDim2")) return;
 			const collected = collectArguments(node.arguments);
 			if (collected === void 0) return;
 			const [scaleXNode, offsetXNode, scaleYNode, offsetYNode] = node.arguments;
@@ -25198,7 +25232,6 @@ const EMPTY_CALLBACK_USAGE = {
 	memoization: false
 };
 const SHOULD_ASCEND_TYPES = new Set(["ConditionalExpression", "LogicalExpression"]);
-const IS_FUNCTION_EXPRESSION = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
 const CONTROL_FLOW_TYPES = new Set([
 	"BlockStatement",
 	"CatchClause",
@@ -25223,13 +25256,10 @@ function ascendPastWrappers(node) {
 	while (current !== void 0 && WRAPPER_PARENT_TYPES.has(current.type)) current = getParent(current);
 	return current;
 }
-function isFunctionLikeNode(node) {
-	return node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration";
-}
 function getEnclosingFunctionLike(node) {
 	let current = getParent(node);
 	while (current !== void 0) {
-		if (isFunctionLikeNode(current)) return current;
+		if (isAnyFunction(current)) return current;
 		current = getParent(current);
 	}
 }
@@ -25336,7 +25366,7 @@ function isFunctionReturnStatement(parent) {
 	while (currentNode !== void 0 && CONTROL_FLOW_TYPES.has(currentNode.type)) currentNode = ascendPastWrappers(getParent(currentNode));
 	/* v8 ignore next -- @preserve return statements that contain JSX are parser-nested inside a function body. */
 	if (currentNode === void 0) return false;
-	return IS_FUNCTION_EXPRESSION.has(currentNode.type) || currentNode.type === "FunctionDeclaration";
+	return isAnyFunction(currentNode);
 }
 function isTopLevelReturn(node) {
 	if (!isTopLevelFunctionReturn(node)) return false;
@@ -26116,11 +26146,6 @@ const strictComponentBoundaries = defineRule({
 });
 //#endregion
 //#region src/rules/use-exhaustive-dependencies.ts
-const FUNCTION_DECLARATIONS = new Set([
-	"ArrowFunctionExpression",
-	"FunctionDeclaration",
-	"FunctionExpression"
-]);
 const UNSTABLE_VALUES = new Set([
 	"ArrayExpression",
 	"ArrowFunctionExpression",
@@ -26429,7 +26454,7 @@ function isDeclaredInComponentBody(variable, closureNode) {
 	/* v8 ignore next -- @preserve hook closure nodes are nested inside their containing component function. */
 	let parent = closureNode.parent ?? void 0;
 	while (parent) {
-		if (FUNCTION_DECLARATIONS.has(parent.type)) {
+		if (isAnyFunction(parent)) {
 			const functionParent = parent;
 			if (variable.defs.some((definition) => {
 				if (definition.type !== "Parameter") return false;
@@ -26625,7 +26650,7 @@ function reportUnnecessaryDependency(context, dependencies, dependency, dependen
 	});
 }
 function isCallbackFunctionNode(node) {
-	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration";
+	return node !== void 0 && isAnyFunction(node);
 }
 function getRequiredCaptures(captures, stableHooks) {
 	return captures.filter((capture) => capture.forceDependency || !isStableValue(capture.variable, capture.name, stableHooks));
@@ -26792,7 +26817,7 @@ const useExhaustiveDependencies = defineRule({
 		}
 		function resolveClosureFunction(closureArgument, callExpression) {
 			if (closureArgument.type === "ArrowFunctionExpression") return closureArgument;
-			if (!(FUNCTION_DECLARATIONS.has(closureArgument.type) || closureArgument.type === "Identifier")) return void 0;
+			if (!(isAnyFunction(closureArgument) || closureArgument.type === "Identifier")) return void 0;
 			const resolved = resolveFunctionReference(closureArgument, getScope(callExpression));
 			return isCallbackFunctionNode(resolved) ? resolved : void 0;
 		}
@@ -26925,17 +26950,12 @@ function isHookCall(node) {
 	const hookName = getHookName$1(node);
 	return hookName !== void 0 && isReactHookName(hookName);
 }
-const FUNCTION_BOUNDARIES = new Set([
-	"ArrowFunctionExpression",
-	"FunctionDeclaration",
-	"FunctionExpression"
-]);
 function isInFinallyBlock(node) {
 	let current = node.parent;
 	const maxDepth = 20;
 	let inFinallyBlock = false;
 	for (let depth = 0; depth < maxDepth && current !== null; depth += 1) {
-		if (FUNCTION_BOUNDARIES.has(current.type)) break;
+		if (isAnyFunction(current)) break;
 		if (current.type === "TryStatement") {
 			let checkNode = node;
 			while (checkNode !== null && checkNode !== current) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pobammer-ts/small-rules",
-	"version": "2.2.1",
+	"version": "2.4.0",
 	"description": "Various Oxlint-native rules for linting roblox-ts projects.",
 	"keywords": [
 		"lint",
@@ -70,6 +70,7 @@
 	"dependencies": {
 		"arktype": "2.2.1",
 		"ignore": "7.0.5",
+		"minimatch": "10.2.5",
 		"oxc-parser": "0.138.0",
 		"oxc-resolver": "11.21.3",
 		"oxlint-plugin-utilities": "1.1.0"