eslint-plugin-flawless 1.0.0 → 1.1.0

package/dist/index.d.mts

@@ -1,4 +1,5 @@
 import { TSESLint } from "@typescript-eslint/utils";
+import ts9 from "typescript";
 import { Linter } from "eslint";
 //#region src/util.d.ts
 interface PluginDocumentation {
@@ -207,6 +208,22 @@ interface MatchRegex {
   match: boolean;
   regex: string;
 }
+/**
+ * Object-form entry in a selector's `types` array. At least one of `name` or
+ * `returns` must be present (enforced by the rule schema).
+ */
+interface TypeReference {
+  /** Symbol name the value's type must resolve to. */
+  name?: string;
+  /** Module specifier the matched symbol must be declared in. */
+  from?: string;
+  /**
+   * Matches callable types by return type: at least one call signature's
+   * return type must satisfy this nested matcher.
+   */
+  returns?: TypeReference;
+}
+type TypeMatcher = TypeModifierString | TypeReference;
 interface NamingSelector {
   custom?: MatchRegex;
   filter?: MatchRegex | string;
@@ -223,7 +240,7 @@ interface NamingSelector {
   selector: Array<IndividualAndMetaSelectorsString> | IndividualAndMetaSelectorsString;
   suffix?: Array<string>;
   trailingUnderscore?: UnderscoreOptionString;
-  types?: Array<TypeModifierString>;
+  types?: Array<TypeMatcher>;
 }
 //#endregion
 //#region src/rules/naming-convention/rule.d.ts
@@ -403,4 +420,4 @@ type RuleOptions = { [K in keyof RuleDefinitions]: NonNullable<RuleDefinitions[K
 type Rules = { [K in keyof RuleOptions]: Linter.RuleEntry<RuleOptions[K]>; };
 type RuleDefinitions = typeof plugin.rules;
 //#endregion
-export { RuleOptions, Rules, _default as default };
+export { RuleOptions, Rules, type TypeMatcher, type TypeReference, _default as default };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-DFLOyhkl.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-B-YWsemf.mjs";
 //#region src/configs/index.ts
 const configs = { recommended: {
 	plugins: { [PLUGIN_NAME]: plugin },

package/dist/oxlint.mjs

@@ -1,4 +1,4 @@
-import { n as plugin, t as PLUGIN_NAME } from "./plugin-DFLOyhkl.mjs";
+import { n as plugin, t as PLUGIN_NAME } from "./plugin-B-YWsemf.mjs";
 import { definePlugin } from "@oxlint/plugins";
 //#region src/oxlint.ts
 /**

package/dist/{plugin-DFLOyhkl.mjs → plugin-B-YWsemf.mjs}

@@ -6,16 +6,15 @@ import { fileURLToPath } from "node:url";
 import { createSyncFn } from "synckit";
 import { RuleCreator, getParserServices } from "@typescript-eslint/utils/eslint-utils";
 import { findVariable, isArrowToken, isOpeningParenToken } from "@typescript-eslint/utils/ast-utils";
-import { DefinitionType, ImplicitLibVariable, PatternVisitor, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
-import { requiresQuoting } from "@typescript-eslint/type-utils";
+import ts9, { ScriptTarget, TypeFlags, isIdentifierPart, isIdentifierStart } from "typescript";
+import { DefinitionType, ImplicitLibVariable, ScopeType, Visitor } from "@typescript-eslint/scope-manager";
 import assert from "node:assert";
 import { getStaticJSONValue, parseForESLint } from "jsonc-eslint-parser";
 import * as core from "@eslint-react/core";
-import ts9 from "typescript";
 import { getStaticTOMLValue } from "toml-eslint-parser";
 //#region package.json
 var name = "eslint-plugin-flawless";
-var version = "1.0.0";
+var version = "1.1.0";
 var repository = {
 	"url": "git+https://github.com/christopher-buss/eslint-plugin-flawless.git",
 	"type": "git"
@@ -1539,6 +1538,77 @@ function isUsedVariable(variable) {
 	});
 }
 //#endregion
+//#region src/rules/naming-convention/utils/contextual-type.ts
+/**
+* Determines if an object literal member's name is dictated by the contextual
+* type of the enclosing object literal (e.g. `{ ... } satisfies
+* Partial<Service>`). In that case the name is not the author's choice - it is
+* required by the declared type, which is itself validated at its declaration
+* site - so naming validation should be skipped.
+*
+* @param node - The non-computed object literal property or method node.
+* @param services - Parser services (may lack type information).
+* @param cache - Per-file cache of contextual types keyed by object literal.
+* @returns True if the member name is required by a contextual type.
+*/
+function isDictatedByContextualType(node, services, cache) {
+	if (!services.program || node.parent.type !== AST_NODE_TYPES.ObjectExpression) return false;
+	const checker = services.program.getTypeChecker();
+	const tsObject = services.esTreeNodeToTSNodeMap.get(node.parent);
+	const candidates = getCandidateTypes(node.parent, tsObject, checker, cache);
+	if (candidates === null) return false;
+	const name = node.key.type === AST_NODE_TYPES.Identifier ? node.key.name : String(node.key.value);
+	return candidates.some((candidate) => {
+		const property = checker.getPropertyOfType(candidate, name);
+		return property !== void 0 && !isDeclaredWithinLiteral(property, tsObject);
+	});
+}
+/**
+* Resolves the contextual type of an object literal into its candidate
+* constituent types, cached per object literal.
+*
+* Union arms are checked individually because `getPropertyOfType` on a union
+* only finds properties present in every arm, while a name dictated by a
+* single arm still isn't the author's choice.
+*
+* @param objectNode - The enclosing object literal (ESTree).
+* @param tsObject - The corresponding TypeScript node.
+* @param checker - The type checker.
+* @param cache - Per-file cache of contextual types keyed by object literal.
+* @returns The candidate types, or null if there is no contextual type.
+*/
+function getCandidateTypes(objectNode, tsObject, checker, cache) {
+	const cached = cache.get(objectNode);
+	if (cached !== void 0) return cached;
+	const contextualType = checker.getContextualType(tsObject);
+	let candidates = null;
+	if (contextualType !== void 0) {
+		const nonNullable = contextualType.getNonNullableType();
+		candidates = (nonNullable.isUnion() ? nonNullable.types : [nonNullable]).map((arm) => checker.getApparentType(arm));
+	}
+	cache.set(objectNode, candidates);
+	return candidates;
+}
+/**
+* Guards against self-inference: in generic calls like `identity({ Name: 1 })`
+* the contextual type is inferred from the literal itself, so the property
+* symbol's declarations all live inside the literal - the name is still the
+* author's choice. Transient symbols without declarations (such as those from
+* mapped types like `Partial<T>`) originate from the contextual type and count
+* as dictated.
+*
+* @param symbol - The property symbol found on a candidate contextual type.
+* @param literal - The object literal being checked.
+* @returns True if every declaration of the symbol lies inside the literal.
+*/
+function isDeclaredWithinLiteral(symbol, literal) {
+	const declarations = symbol.declarations ?? [];
+	if (declarations.length === 0) return false;
+	return declarations.every((declaration) => {
+		return declaration.getSourceFile() === literal.getSourceFile() && declaration.pos >= literal.pos && declaration.end <= literal.end;
+	});
+}
+//#endregion
 //#region src/rules/naming-convention/utils/enums.ts
 const Selector = {
 	variable: 1,
@@ -1607,6 +1677,8 @@ const TypeModifier = {
 	array: 2097152
 };
 const TypeModifierValueToKey = Object.fromEntries(Object.entries(TypeModifier).map(([key, value]) => [value, key]));
+const TYPE_REFERENCE_LOOSE_WEIGHT = 1 << 22;
+const TYPE_REFERENCE_STRICT_WEIGHT = 1 << 23;
 const UnderscoreOption = {
 	forbid: 1,
 	allow: 2,
@@ -1887,31 +1959,130 @@ function createValidator(type, context, allConfigs) {
 		return false;
 	}
 }
-const SelectorsAllowedToHaveTypes = Selector.variable | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor;
+const SelectorsAllowedToHaveTypes = Selector.variable | Selector.function | Selector.parameter | Selector.classProperty | Selector.objectLiteralProperty | Selector.typeProperty | Selector.parameterProperty | Selector.classicAccessor | Selector.classMethod | Selector.objectLiteralMethod | Selector.typeMethod;
 function isAllTypesMatch(type, callback) {
 	if (type.isUnion()) return type.types.every((inner) => callback(inner));
 	return callback(type);
 }
+function isAnyType(type) {
+	return (type.flags & TypeFlags.Any) !== 0;
+}
+function symbolMatchesTypeReference(symbol, reference) {
+	if (symbol === void 0 || reference.name === void 0 || symbol.name !== reference.name) return false;
+	if (reference.from === void 0) return true;
+	const { declarations } = symbol;
+	if (!declarations || declarations.length === 0) return false;
+	for (const declaration of declarations) {
+		const { fileName } = declaration.getSourceFile();
+		if (moduleSpecifierMatches(fileName, reference.from)) return true;
+	}
+	return false;
+}
+function matchesNamedTypeReference(type, reference) {
+	if (isAnyType(type)) return false;
+	if (symbolMatchesTypeReference(type.aliasSymbol, reference)) return true;
+	if (symbolMatchesTypeReference(type.symbol, reference)) return true;
+	if (type.isIntersection() || type.isUnion()) {
+		for (const inner of type.types) if (matchesNamedTypeReference(inner, reference)) return true;
+	}
+	return false;
+}
+function matchesReturnTypeReference(type, reference) {
+	if (isAnyType(type)) return false;
+	for (const signature of type.getCallSignatures()) if (matchesTypeReference(signature.getReturnType(), reference)) return true;
+	if (type.isIntersection() || type.isUnion()) {
+		for (const inner of type.types) if (matchesReturnTypeReference(inner, reference)) return true;
+	}
+	return false;
+}
+function matchesTypeReference(type, reference) {
+	if (isAnyType(type)) return false;
+	if (reference.name === void 0 && reference.returns === void 0) return false;
+	if (reference.name !== void 0 && !matchesNamedTypeReference(type, reference)) return false;
+	if (reference.returns !== void 0 && !matchesReturnTypeReference(type, reference.returns)) return false;
+	return true;
+}
 function isCorrectType(node, config, context, selector) {
 	if (config.types === void 0) return true;
 	if ((SelectorsAllowedToHaveTypes & selector) === 0) return true;
 	const services = getParserServices(context);
 	const checker = services.program.getTypeChecker();
 	const type = services.getTypeAtLocation(node).getNonNullableType();
-	for (const allowedType of config.types) switch (allowedType) {
-		case TypeModifier.array:
-			if (isAllTypesMatch(type, (inner) => checker.isArrayType(inner) || checker.isTupleType(inner))) return true;
-			break;
-		case TypeModifier.boolean:
-		case TypeModifier.number:
-		case TypeModifier.string:
-			if (checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(type))) === TypeModifierValueToKey[allowedType]) return true;
-			break;
-		case TypeModifier.function:
-			if (isAllTypesMatch(type, (inner) => inner.getCallSignatures().length > 0)) return true;
-			break;
+	const predicates = [];
+	for (const allowedType of config.types) {
+		if (typeof allowedType === "object") {
+			predicates.push((inner) => matchesTypeReference(inner, allowedType));
+			continue;
+		}
+		switch (allowedType) {
+			case TypeModifier.array:
+				predicates.push((inner) => checker.isArrayType(inner) || checker.isTupleType(inner));
+				break;
+			case TypeModifier.boolean:
+			case TypeModifier.number:
+			case TypeModifier.string:
+				predicates.push((inner) => {
+					return checker.typeToString(checker.getWidenedType(checker.getBaseTypeOfLiteralType(inner))) === TypeModifierValueToKey[allowedType];
+				});
+				break;
+			case TypeModifier.function:
+				predicates.push((inner) => inner.getCallSignatures().length > 0);
+				break;
+		}
 	}
-	return false;
+	return isAllTypesMatch(type, (inner) => predicates.some((predicate) => predicate(inner)));
+}
+const BACKSLASH_PATTERN = /\\/gu;
+const TYPESCRIPT_EXTENSION_PATTERN = /\.d\.ts$|\.tsx?$/u;
+const WINDOWS_DRIVE_PATTERN = /^[A-Za-z]:\//u;
+const LEADING_DOT_OR_SLASH_PATTERN = /^(\.\/|\/)/u;
+/**
+* Path-form specifiers start with `.`, `/`, or a Windows drive letter (e.g.
+* `C:/`).
+*
+* @param specifier - The module specifier to classify.
+* @returns True if the specifier should be treated as a filesystem path rather
+*   than a package name.
+*/
+function looksLikePath(specifier) {
+	if (specifier.startsWith(".")) return true;
+	if (specifier.startsWith("/")) return true;
+	return WINDOWS_DRIVE_PATTERN.test(specifier);
+}
+/**
+* Checks whether a declaration's source file matches a module specifier.
+*
+* Two specifier shapes are supported:
+*
+* 1. **Bare package specifier** (e.g. `"@rbxts/jecs"`, `"lodash"`) — matches
+*    when the declaration's file path contains `/node_modules/<specifier>/` as
+*    a substring. Handles flat and pnpm-style layouts (pnpm paths still contain
+*    a final `/node_modules/<specifier>/` segment after the virtual store
+*    directory). **Not** supported: Yarn Plug'n'Play (no `node_modules` on
+*    disk), vendored packages outside `node_modules`, or types provided by
+*    separate `@types/*` packages.
+* 2. **Path specifier** (starts with `.`, `/`, or a Windows drive letter) —
+*    matches against the normalized declaration path with `.d.ts` / `.tsx?`
+*    stripped. Windows absolute paths require exact equality. POSIX-style
+*    absolute or relative paths are normalized to a bare tail and matched as a
+*    suffix; this means `"./shared/network"` matches a declaration at
+*    `<root>/shared/network.ts`.
+*
+* @param declarationFile - Path of the file declaring the matched symbol.
+* @param specifier - The `from` module specifier from the rule config.
+* @returns True if the declaration file matches the specifier.
+*/
+function moduleSpecifierMatches(declarationFile, specifier) {
+	const normalizedFile = declarationFile.replace(BACKSLASH_PATTERN, "/");
+	const normalizedSpecifier = specifier.replace(BACKSLASH_PATTERN, "/");
+	if (looksLikePath(normalizedSpecifier)) {
+		const stripped = normalizedFile.replace(TYPESCRIPT_EXTENSION_PATTERN, "");
+		if (WINDOWS_DRIVE_PATTERN.test(normalizedSpecifier)) return stripped === normalizedSpecifier;
+		const tail = normalizedSpecifier.replace(LEADING_DOT_OR_SLASH_PATTERN, "");
+		if (stripped === tail) return true;
+		return stripped.endsWith(`/${tail}`);
+	}
+	return normalizedFile.includes(`/node_modules/${normalizedSpecifier}/`);
 }
 //#endregion
 //#region src/rules/naming-convention/utils/parse-options.ts
@@ -1919,10 +2090,22 @@ function parseOptions(context) {
 	const normalizedOptions = context.options.flatMap(normalizeOption);
 	return Object.fromEntries(Object.keys(Selector).map((key) => [key, createValidator(key, context, normalizedOptions)]));
 }
+/**
+* A type-reference matcher counts as "strict" for sorting when any level of it
+* (including nested `returns` matchers) constrains the declaring module.
+*
+* @param reference - The matcher to inspect.
+* @returns True if the matcher carries a `from` constraint at any depth.
+*/
+function hasFromConstraint(reference) {
+	if (reference.from !== void 0) return true;
+	return reference.returns !== void 0 && hasFromConstraint(reference.returns);
+}
 function normalizeOption(option) {
 	let weight = 0;
 	if (option.modifiers) for (const modifier of option.modifiers) weight |= Modifier[modifier];
-	if (option.types) for (const type of option.types) weight |= TypeModifier[type];
+	if (option.types) for (const type of option.types) if (typeof type === "string") weight |= TypeModifier[type];
+	else weight |= hasFromConstraint(type) ? TYPE_REFERENCE_STRICT_WEIGHT : TYPE_REFERENCE_LOOSE_WEIGHT;
 	if (option.filter !== void 0) weight |= 1 << 30;
 	const normalizedOption = {
 		custom: option.custom ? {
@@ -1943,7 +2126,7 @@ function normalizeOption(option) {
 		prefix: option.prefix && option.prefix.length > 0 ? option.prefix : void 0,
 		suffix: option.suffix && option.suffix.length > 0 ? option.suffix : void 0,
 		trailingUnderscore: option.trailingUnderscore !== void 0 ? UnderscoreOption[option.trailingUnderscore] : void 0,
-		types: option.types?.map((type) => TypeModifier[type]) ?? void 0
+		types: option.types?.map((type) => typeof type === "string" ? TypeModifier[type] : type) ?? void 0
 	};
 	return (Array.isArray(option.selector) ? option.selector : [option.selector]).map((selector) => {
 		return {
@@ -1981,9 +2164,39 @@ const $DEFS = {
 		},
 		type: "array"
 	},
-	typeModifiers: {
+	typeMatcher: { oneOf: [{
+		description: "Built-in type modifier matching by widened TS type.",
 		enum: Object.keys(TypeModifier),
 		type: "string"
+	}, { $ref: "#/$defs/typeReferenceMatcher" }] },
+	typeReferenceMatcher: {
+		additionalProperties: false,
+		anyOf: [{
+			required: ["name"],
+			type: "object"
+		}, {
+			required: ["returns"],
+			type: "object"
+		}],
+		dependencies: { from: ["name"] },
+		description: "Type-reference matcher. Matches when the variable's type resolves to a symbol with the given `name`; if `from` is supplied, the symbol's declaration must also live in a file the specifier resolves to. `returns` instead (or additionally) matches callable types by the return type of their call signatures.",
+		properties: {
+			name: {
+				description: "Symbol name to match (compared against the type's `aliasSymbol` then `symbol`).",
+				minLength: 1,
+				type: "string"
+			},
+			from: {
+				description: "Module specifier the type must originate from. Bare package name (e.g. `@rbxts/jecs`) matches `/node_modules/<from>/` in the declaration path. Path-form (starts with `.`, `/`, or a Windows drive letter) matches the declaration path with extension stripped. Omit to match any source.",
+				minLength: 1,
+				type: "string"
+			},
+			returns: {
+				$ref: "#/$defs/typeReferenceMatcher",
+				description: "Nested matcher applied to call-signature return types. The type matches when at least one call signature's return type satisfies it. Lets anonymous function types (which have no symbol name) be matched, e.g. React components typed `(props: P) => ReactNode`."
+			}
+		},
+		type: "object"
 	},
 	underscoreOptions: {
 		enum: Object.keys(UnderscoreOption),
@@ -2023,7 +2236,7 @@ function selectorSchema(selectorString, allowType, modifiers) {
 	};
 	if (allowType) selector["types"] = {
 		additionalItems: false,
-		items: { $ref: "#/$defs/typeModifiers" },
+		items: { $ref: "#/$defs/typeMatcher" },
 		type: "array"
 	};
 	return [{
@@ -2065,7 +2278,7 @@ function selectorsSchema() {
 			},
 			types: {
 				additionalItems: false,
-				items: { $ref: "#/$defs/typeModifiers" },
+				items: { $ref: "#/$defs/typeMatcher" },
 				type: "array"
 			}
 		},
@@ -2088,7 +2301,7 @@ const SCHEMA = {
 			"unused",
 			"async"
 		]),
-		...selectorSchema("function", false, [
+		...selectorSchema("function", true, [
 			"exported",
 			"global",
 			"unused",
@@ -2148,7 +2361,7 @@ const SCHEMA = {
 			"override",
 			"async"
 		]),
-		...selectorSchema("classMethod", false, [
+		...selectorSchema("classMethod", true, [
 			"abstract",
 			"private",
 			"#private",
@@ -2159,13 +2372,13 @@ const SCHEMA = {
 			"override",
 			"async"
 		]),
-		...selectorSchema("objectLiteralMethod", false, [
+		...selectorSchema("objectLiteralMethod", true, [
 			"public",
 			"requiresQuotes",
 			"async"
 		]),
-		...selectorSchema("typeMethod", false, ["public", "requiresQuotes"]),
-		...selectorSchema("method", false, [
+		...selectorSchema("typeMethod", true, ["public", "requiresQuotes"]),
+		...selectorSchema("method", true, [
 			"abstract",
 			"private",
 			"#private",
@@ -2258,22 +2471,13 @@ const camelCaseNamingConfig = [
 function create$4(contextWithoutDefaults) {
 	const context = contextWithoutDefaults.options.length > 0 ? contextWithoutDefaults : Object.setPrototypeOf({ options: camelCaseNamingConfig }, contextWithoutDefaults);
 	const validators = parseOptions(context);
-	const compilerOptions = getParserServices(context, true).program?.getCompilerOptions() ?? {};
+	const services = getParserServices(context, true);
+	const compilerOptions = services.program?.getCompilerOptions() ?? {};
+	const contextualTypeCache = /* @__PURE__ */ new WeakMap();
 	function handleMember(validator, { key }, modifiers) {
-		if (requiresQuoting$1(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+		if (requiresQuoting(key, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
 		validator(key, modifiers);
 	}
-	function getMemberModifiers(node) {
-		const modifiers = /* @__PURE__ */ new Set();
-		if ("key" in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) modifiers.add(Modifier["#private"]);
-		else if (node.accessibility) modifiers.add(Modifier[node.accessibility]);
-		else modifiers.add(Modifier.public);
-		if (node.static) modifiers.add(Modifier.static);
-		if ("readonly" in node && node.readonly) modifiers.add(Modifier.readonly);
-		if ("override" in node && node.override) modifiers.add(Modifier.override);
-		if (node.type === AST_NODE_TYPES.TSAbstractPropertyDefinition || node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.TSAbstractAccessorProperty) modifiers.add(Modifier.abstract);
-		return modifiers;
-	}
 	const { unusedVariables } = collectVariables(context);
 	function isUnused(name, initialScope) {
 		let variable = null;
@@ -2286,52 +2490,6 @@ function create$4(contextWithoutDefaults) {
 		if (!variable) return false;
 		return unusedVariables.has(variable);
 	}
-	function isDestructured(id) {
-		return id.parent.type === AST_NODE_TYPES.Property && id.parent.shorthand || id.parent.type === AST_NODE_TYPES.AssignmentPattern && id.parent.parent.type === AST_NODE_TYPES.Property && id.parent.parent.shorthand;
-	}
-	function isAsyncMemberOrProperty(propertyOrMemberNode) {
-		return Boolean("value" in propertyOrMemberNode && propertyOrMemberNode.value && "async" in propertyOrMemberNode.value && propertyOrMemberNode.value.async);
-	}
-	function isAsyncVariableIdentifier(id) {
-		return Boolean("async" in id.parent && id.parent.async || "init" in id.parent && id.parent.init && "async" in id.parent.init && id.parent.init.async);
-	}
-	/**
-	* Determines if a VariableDeclarator represents an object-style enum declaration.
-	*
-	* Object-style enums are const assertions applied to object expressions, commonly
-	* used as an alternative to TypeScript enums. Examples:
-	* - `const Colors = { RED: 'red', BLUE: 'blue' } as const`
-	* - `const Status = <const>{ OK: 200, ERROR: 500 }`.
-	*
-	* @param node - The VariableDeclarator AST node to check.
-	* @param parent - The parent VariableDeclaration node.
-	* @returns True if this represents an object-style enum declaration.
-	*/
-	function isObjectStyleEnumDeclaration(node, parent) {
-		if (parent.kind !== "const") return false;
-		if (!node.init) return false;
-		if (node.init.type === AST_NODE_TYPES.TSAsExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
-		if (node.init.type === AST_NODE_TYPES.TSTypeAssertion && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
-		return false;
-	}
-	/**
-	* Checks if a method name exists in any of the implemented interfaces.
-	*
-	* @param implementsList - List of implemented interfaces.
-	* @param methodName - Name of the method to check.
-	* @param checker - TypeScript type checker.
-	* @param services - Parser services.
-	* @returns True if the method name is found in any interface.
-	*/
-	function checkInterfacesForMethod(implementsList, methodName, checker, services) {
-		for (const implementsClause of implementsList) {
-			const interfaceType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(implementsClause));
-			if (!interfaceType.getSymbol()) continue;
-			const interfaceMembers = checker.getPropertiesOfType(interfaceType);
-			for (const member of interfaceMembers) if (member.name === methodName) return true;
-		}
-		return false;
-	}
 	/**
 	* Determines if a class method is implementing an interface method.
 	*
@@ -2339,7 +2497,6 @@ function create$4(contextWithoutDefaults) {
 	* @returns True if the method is implementing an interface method.
 	*/
 	function isImplementingInterfaceMethod(node) {
-		const services = getParserServices(context, true);
 		if (!services.program) return false;
 		const checker = services.program.getTypeChecker();
 		let parentClass = null;
@@ -2367,6 +2524,7 @@ function create$4(contextWithoutDefaults) {
 		},
 		":not(ObjectPattern) > Property[computed = false][kind = \"init\"][value.type != \"ArrowFunctionExpression\"][value.type != \"FunctionExpression\"][value.type != \"TSEmptyBodyFunctionExpression\"]": {
 			handler: (node, validator) => {
+				if (isDictatedByContextualType(node, services, contextualTypeCache)) return;
 				handleMember(validator, node, /* @__PURE__ */ new Set([Modifier.public]));
 			},
 			validator: validators.objectLiteralProperty
@@ -2403,6 +2561,7 @@ function create$4(contextWithoutDefaults) {
 			"Property[computed = false][kind = \"init\"][value.type = \"TSEmptyBodyFunctionExpression\"]"
 		].join(", ")]: {
 			handler: (node, validator) => {
+				if (node.type === AST_NODE_TYPES.Property && isDictatedByContextualType(node, services, contextualTypeCache)) return;
 				const modifiers = /* @__PURE__ */ new Set([Modifier.public]);
 				if (isAsyncMemberOrProperty(node)) modifiers.add(Modifier.async);
 				handleMember(validator, node, modifiers);
@@ -2494,7 +2653,7 @@ function create$4(contextWithoutDefaults) {
 		"TSEnumMember": {
 			handler: ({ id }, validator) => {
 				const modifiers = /* @__PURE__ */ new Set();
-				if (requiresQuoting$1(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
+				if (requiresQuoting(id, compilerOptions.target)) modifiers.add(Modifier.requiresQuotes);
 				validator(id, modifiers);
 			},
 			validator: validators.enumMember
@@ -2589,13 +2748,70 @@ const namingConvention = createEslintRule({
 		type: "suggestion"
 	}
 });
+/**
+* Checks if a method name exists in any of the implemented interfaces.
+*
+* @param implementsList - List of implemented interfaces.
+* @param methodName - Name of the method to check.
+* @param checker - TypeScript type checker.
+* @param services - Parser services.
+* @returns True if the method name is found in any interface.
+*/
+function checkInterfacesForMethod(implementsList, methodName, checker, services) {
+	for (const implementsClause of implementsList) {
+		const interfaceType = checker.getTypeAtLocation(services.esTreeNodeToTSNodeMap.get(implementsClause));
+		if (!interfaceType.getSymbol()) continue;
+		const interfaceMembers = checker.getPropertiesOfType(interfaceType);
+		for (const member of interfaceMembers) if (member.name === methodName) return true;
+	}
+	return false;
+}
 function getIdentifiersFromPattern(pattern) {
 	const identifiers = [];
-	new PatternVisitor({}, pattern, (id) => {
-		identifiers.push(id);
-	}).visit(pattern);
+	const stack = [pattern];
+	for (const node of stack) switch (node.type) {
+		case AST_NODE_TYPES.ArrayPattern:
+			for (const element of node.elements) if (element !== null) stack.push(element);
+			break;
+		case AST_NODE_TYPES.AssignmentPattern:
+			stack.push(node.left);
+			break;
+		case AST_NODE_TYPES.Identifier:
+			identifiers.push(node);
+			break;
+		case AST_NODE_TYPES.ObjectPattern:
+			for (const property of node.properties) stack.push(property);
+			break;
+		case AST_NODE_TYPES.Property:
+			stack.push(node.value);
+			break;
+		case AST_NODE_TYPES.RestElement:
+			stack.push(node.argument);
+			break;
+		default: break;
+	}
 	return identifiers;
 }
+function getMemberModifiers(node) {
+	const modifiers = /* @__PURE__ */ new Set();
+	if ("key" in node && node.key.type === AST_NODE_TYPES.PrivateIdentifier) modifiers.add(Modifier["#private"]);
+	else if (node.accessibility) modifiers.add(Modifier[node.accessibility]);
+	else modifiers.add(Modifier.public);
+	if (node.static) modifiers.add(Modifier.static);
+	if ("readonly" in node && node.readonly) modifiers.add(Modifier.readonly);
+	if ("override" in node && node.override) modifiers.add(Modifier.override);
+	if (node.type === AST_NODE_TYPES.TSAbstractPropertyDefinition || node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.TSAbstractAccessorProperty) modifiers.add(Modifier.abstract);
+	return modifiers;
+}
+function isAsyncMemberOrProperty(propertyOrMemberNode) {
+	return Boolean("value" in propertyOrMemberNode && propertyOrMemberNode.value && "async" in propertyOrMemberNode.value && propertyOrMemberNode.value.async);
+}
+function isAsyncVariableIdentifier(id) {
+	return Boolean("async" in id.parent && id.parent.async || "init" in id.parent && id.parent.init && "async" in id.parent.init && id.parent.init.async);
+}
+function isDestructured(id) {
+	return id.parent.type === AST_NODE_TYPES.Property && id.parent.shorthand || id.parent.type === AST_NODE_TYPES.AssignmentPattern && id.parent.parent.type === AST_NODE_TYPES.Property && id.parent.parent.shorthand;
+}
 function isExported(node, name, scope) {
 	if (node?.parent?.type === AST_NODE_TYPES.ExportDefaultDeclaration || node?.parent?.type === AST_NODE_TYPES.ExportNamedDeclaration) return true;
 	if (scope === null) return false;
@@ -2610,8 +2826,39 @@ function isGlobal(scope) {
 	if (scope === null) return false;
 	return scope.type === TSESLint.Scope.ScopeType.global || scope.type === TSESLint.Scope.ScopeType.module;
 }
-function requiresQuoting$1(node, target) {
-	return requiresQuoting(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target);
+/**
+* Determines if a VariableDeclarator represents an object-style enum declaration.
+*
+* Object-style enums are const assertions applied to object expressions, commonly
+* used as an alternative to TypeScript enums. Examples:
+* - `const Colors = { RED: 'red', BLUE: 'blue' } as const`
+* - `const Status = <const>{ OK: 200, ERROR: 500 }`.
+*
+* @param node - The VariableDeclarator AST node to check.
+* @param parent - The parent VariableDeclaration node.
+* @returns True if this represents an object-style enum declaration.
+*/
+function isObjectStyleEnumDeclaration(node, parent) {
+	if (parent.kind !== "const") return false;
+	if (!node.init) return false;
+	if (node.init.type === AST_NODE_TYPES.TSAsExpression && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+	if (node.init.type === AST_NODE_TYPES.TSTypeAssertion && node.init.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && node.init.typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier && node.init.typeAnnotation.typeName.name === "const" && node.init.expression.type === AST_NODE_TYPES.ObjectExpression) return true;
+	return false;
+}
+function isValidIdentifierText(name, languageVersion) {
+	if (name.length === 0) return false;
+	const firstCodePoint = name.codePointAt(0);
+	if (firstCodePoint === void 0 || !isIdentifierStart(firstCodePoint, languageVersion)) return false;
+	let index = firstCodePoint > 65535 ? 2 : 1;
+	while (index < name.length) {
+		const codePoint = name.codePointAt(index);
+		if (codePoint === void 0 || !isIdentifierPart(codePoint, languageVersion)) return false;
+		index += codePoint > 65535 ? 2 : 1;
+	}
+	return true;
+}
+function requiresQuoting(node, target) {
+	return !isValidIdentifierText(node.type === AST_NODE_TYPES.Identifier || node.type === AST_NODE_TYPES.PrivateIdentifier ? node.name : `${node.value}`, target ?? ScriptTarget.Latest);
 }
 //#endregion
 //#region src/rules/no-export-default-arrow/rule.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-flawless",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Your ESLint plugin description",
   "keywords": [
     "eslint",
@@ -38,7 +38,6 @@
     "@eslint-react/core": "5.10.0",
     "@oxlint/plugins": "1.73.0",
     "@typescript-eslint/scope-manager": "8.62.1",
-    "@typescript-eslint/type-utils": "8.62.1",
     "@typescript-eslint/utils": "8.62.1",
     "jsonc-eslint-parser": "3.1.0",
     "oxc-parser": "0.112.0",