oxlint-plugin-react-doctor 0.2.11-dev.b2934f9 → 0.2.11-dev.b5cf767

package/dist/index.d.ts

@@ -5542,74 +5542,6 @@ declare const REACT_DOCTOR_RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/zod-v4-no-deprecated-error-apis";
-  readonly id: "zod-v4-no-deprecated-error-apis";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
-}, {
-  readonly key: "react-doctor/zod-v4-no-deprecated-error-customization";
-  readonly id: "zod-v4-no-deprecated-error-customization";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
-}, {
-  readonly key: "react-doctor/zod-v4-no-deprecated-schema-apis";
-  readonly id: "zod-v4-no-deprecated-schema-apis";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
-}, {
-  readonly key: "react-doctor/zod-v4-prefer-top-level-string-formats";
-  readonly id: "zod-v4-prefer-top-level-string-formats";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
 }];
 declare const EXTERNAL_RULES: readonly [{
   readonly key: "react-hooks-js/set-state-in-render";
@@ -11082,74 +11014,6 @@ declare const RULES: readonly [{
     readonly recommendation?: string;
     readonly create: (context: RuleContext) => RuleVisitors;
   };
-}, {
-  readonly key: "react-doctor/zod-v4-no-deprecated-error-apis";
-  readonly id: "zod-v4-no-deprecated-error-apis";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
-}, {
-  readonly key: "react-doctor/zod-v4-no-deprecated-error-customization";
-  readonly id: "zod-v4-no-deprecated-error-customization";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
-}, {
-  readonly key: "react-doctor/zod-v4-no-deprecated-schema-apis";
-  readonly id: "zod-v4-no-deprecated-schema-apis";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
-}, {
-  readonly key: "react-doctor/zod-v4-prefer-top-level-string-formats";
-  readonly id: "zod-v4-prefer-top-level-string-formats";
-  readonly source: "react-doctor";
-  readonly originallyExternal: false;
-  readonly rule: {
-    readonly framework: "global";
-    readonly category: "Architecture";
-    readonly id: string;
-    readonly severity: RuleSeverity;
-    readonly requires?: ReadonlyArray<string>;
-    readonly disabledBy?: ReadonlyArray<string>;
-    readonly tags?: ReadonlyArray<string>;
-    readonly defaultEnabled?: boolean;
-    readonly recommendation?: string;
-    readonly create: (context: RuleContext) => RuleVisitors;
-  };
 }, {
   readonly key: "react-hooks-js/set-state-in-render";
   readonly source: "react-compiler";

package/dist/index.js

@@ -26668,7 +26668,6 @@ const REACT_NATIVE_TEXT_COMPONENT_KEYWORDS = new Set([
 	"Description",
 	"Body"
 ]);
-const REACT_NATIVE_TEXT_TRANSPARENT_COMPONENTS = new Set(["fbt", "fbs"]);
 const DEPRECATED_RN_MODULE_REPLACEMENTS = new Map([
 	["AsyncStorage", "@react-native-async-storage/async-storage"],
 	["Picker", "@react-native-picker/picker"],
@@ -27501,29 +27500,10 @@ const getRawTextDescription = (child) => {
 	}
 	return "text content";
 };
-const resolveTextBoundaryName = (openingElement) => {
-	if (isNodeOfType(openingElement.name, "JSXNamespacedName")) return openingElement.name.namespace.name;
-	return resolveJsxElementName(openingElement);
-};
 const isTextHandlingComponent = (elementName) => {
 	if (REACT_NATIVE_TEXT_COMPONENTS.has(elementName)) return true;
 	return [...REACT_NATIVE_TEXT_COMPONENT_KEYWORDS].some((keyword) => elementName.includes(keyword));
 };
-const isTransparentTextWrapper = (elementName) => elementName !== null && REACT_NATIVE_TEXT_TRANSPARENT_COMPONENTS.has(elementName);
-const isInsideTextHandlingComponent = (node) => {
-	let parentNode = node.parent;
-	while (parentNode) {
-		if (!isNodeOfType(parentNode, "JSXElement")) {
-			parentNode = parentNode.parent;
-			continue;
-		}
-		const parentName = resolveTextBoundaryName(parentNode.openingElement);
-		if (parentName && isTextHandlingComponent(parentName)) return true;
-		if (!isTransparentTextWrapper(parentName)) return false;
-		parentNode = parentNode.parent;
-	}
-	return false;
-};
 const rnNoRawText = defineRule({
 	id: "rn-no-raw-text",
 	requires: ["react-native"],
@@ -27537,10 +27517,9 @@ const rnNoRawText = defineRule({
 			},
 			JSXElement(node) {
 				if (isDomComponentFile) return;
-				const elementName = resolveTextBoundaryName(node.openingElement);
+				const elementName = resolveJsxElementName(node.openingElement);
 				if (elementName && isTextHandlingComponent(elementName)) return;
 				if (isInsidePlatformOsWebBranch(node)) return;
-				if (isTransparentTextWrapper(elementName) && isInsideTextHandlingComponent(node)) return;
 				for (const child of node.children ?? []) {
 					if (!isRawTextContent(child)) continue;
 					context.report({
@@ -33379,410 +33358,6 @@ const voidDomElementsNoChildren = defineRule({
 	})
 });
 //#endregion
-//#region src/plugin/rules/zod/utils/zod-ast.ts
-const ZOD_MODULE = "zod";
-const getStaticPropertyName = (member) => {
-	const property = member.property;
-	if (!member.computed && isNodeOfType(property, "Identifier")) return property.name;
-	if (member.computed && isNodeOfType(property, "Literal") && typeof property.value === "string") return property.value;
-	return null;
-};
-const getImportInfoForIdentifier = (identifier) => {
-	const specifier = findVariableInitializer(identifier, identifier.name)?.initializer;
-	if (!specifier) return null;
-	const declaration = specifier.parent;
-	if (!declaration || !isNodeOfType(declaration, "ImportDeclaration")) return null;
-	if (declaration.source?.value !== ZOD_MODULE) return null;
-	if (isNodeOfType(specifier, "ImportNamespaceSpecifier")) return {
-		imported: null,
-		isDefault: false,
-		isNamespace: true
-	};
-	if (isNodeOfType(specifier, "ImportDefaultSpecifier")) return {
-		imported: null,
-		isDefault: true,
-		isNamespace: false
-	};
-	if (isNodeOfType(specifier, "ImportSpecifier")) {
-		const imported = specifier.imported;
-		if (isNodeOfType(imported, "Identifier")) return {
-			imported: imported.name,
-			isDefault: false,
-			isNamespace: false
-		};
-		if (isNodeOfType(imported, "Literal") && typeof imported.value === "string") return {
-			imported: imported.value,
-			isDefault: false,
-			isNamespace: false
-		};
-	}
-	return null;
-};
-const isZodNamespaceIdentifier = (node) => {
-	const inner = stripParenExpression(node);
-	if (!isNodeOfType(inner, "Identifier")) return false;
-	const info = getImportInfoForIdentifier(inner);
-	return Boolean(info && (info.isNamespace || info.isDefault || info.imported === "z"));
-};
-const getZodNamedImport = (node) => {
-	const inner = stripParenExpression(node);
-	if (!isNodeOfType(inner, "Identifier")) return null;
-	const info = getImportInfoForIdentifier(inner);
-	if (!info || info.isNamespace || info.isDefault) return null;
-	return info.imported;
-};
-const getZodNamespaceMemberName = (node) => {
-	const inner = stripParenExpression(node);
-	if (!isNodeOfType(inner, "MemberExpression")) return null;
-	if (!isZodNamespaceIdentifier(inner.object)) return null;
-	return getStaticPropertyName(inner);
-};
-const isZodFactoryCall = (callExpression, factoryNames) => {
-	const factoryName = getZodFactoryCallName(callExpression);
-	return factoryName !== null && factoryNames.has(factoryName);
-};
-const getZodFactoryCallName = (callExpression) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (isNodeOfType(callee, "Identifier")) return getZodNamedImport(callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return null;
-	const memberName = getStaticPropertyName(callee);
-	if (memberName === null) return null;
-	if (!isZodNamespaceIdentifier(callee.object)) return null;
-	return memberName;
-};
-const getMethodCall = (callExpression) => {
-	const callee = stripParenExpression(callExpression.callee);
-	if (!isNodeOfType(callee, "MemberExpression")) return null;
-	const methodName = getStaticPropertyName(callee);
-	if (!methodName) return null;
-	return {
-		methodName,
-		receiver: callee.object
-	};
-};
-const isDirectMethodCallOnZodFactory = (callExpression, factoryNames, methodNames) => {
-	const methodCall = getMethodCall(callExpression);
-	if (!methodCall || !methodNames.has(methodCall.methodName)) return false;
-	const receiver = stripParenExpression(methodCall.receiver);
-	return isNodeOfType(receiver, "CallExpression") && isZodFactoryCall(receiver, factoryNames);
-};
-const isObjectExpressionWithAnyProperty = (node, propertyNames) => {
-	if (!node) return false;
-	const inner = stripParenExpression(node);
-	if (!isNodeOfType(inner, "ObjectExpression")) return false;
-	return inner.properties.some((property) => {
-		if (!isNodeOfType(property, "Property")) return false;
-		const key = property.key;
-		if (isNodeOfType(key, "Identifier")) return propertyNames.has(key.name);
-		return isNodeOfType(key, "Literal") && typeof key.value === "string" && propertyNames.has(key.value);
-	});
-};
-//#endregion
-//#region src/plugin/rules/zod/zod-v4-no-deprecated-error-apis.ts
-const DEPRECATED_ZOD_ERROR_MEMBERS = new Set([
-	"addIssue",
-	"addIssues",
-	"errors",
-	"flatten",
-	"formErrors",
-	"format"
-]);
-const ZOD_ERROR_API_MESSAGE = "Zod 4 removes or deprecates this ZodError API; use `error.issues` or the new top-level error formatting helpers.";
-const isZodErrorReference = (node) => {
-	const inner = stripParenExpression(node);
-	if (isNodeOfType(inner, "Identifier")) return getZodNamedImport(inner) === "ZodError";
-	if (!isNodeOfType(inner, "MemberExpression")) return false;
-	return getZodNamespaceMemberName(inner) === "ZodError";
-};
-const isDirectZodErrorValue = (node) => {
-	const inner = stripParenExpression(node);
-	if (isNodeOfType(inner, "NewExpression")) return isZodErrorReference(inner.callee);
-	if (!isNodeOfType(inner, "CallExpression")) return false;
-	const methodCall = getMethodCall(inner);
-	return methodCall?.methodName === "create" && isZodErrorReference(methodCall.receiver);
-};
-const isDeprecatedZodErrorMemberAccess = (node) => {
-	if (!isNodeOfType(node, "MemberExpression")) return false;
-	const memberExpression = node;
-	const propertyName = getStaticPropertyName(memberExpression);
-	return propertyName !== null && DEPRECATED_ZOD_ERROR_MEMBERS.has(propertyName) && isDirectZodErrorValue(memberExpression.object);
-};
-const isZodErrorCreateCall = (callExpression) => {
-	const methodCall = getMethodCall(callExpression);
-	return methodCall?.methodName === "create" && isZodErrorReference(methodCall.receiver);
-};
-const isReceiverOfDeprecatedZodErrorMember = (callExpression) => {
-	const parent = callExpression.parent;
-	if (!parent || !isNodeOfType(parent, "MemberExpression")) return false;
-	if (stripParenExpression(parent.object) !== callExpression) return false;
-	return isDeprecatedZodErrorMemberAccess(parent);
-};
-const zodV4NoDeprecatedErrorApis = defineRule({
-	id: "zod-v4-no-deprecated-error-apis",
-	requires: ["zod:4"],
-	tags: ["migration-hint"],
-	severity: "warn",
-	recommendation: "Replace deprecated ZodError helpers with the Zod 4 functions: `z.treeifyError()`, `z.flattenError()`, `z.prettifyError()`, or direct `error.issues` access.",
-	create: (context) => ({
-		CallExpression(node) {
-			if (isZodErrorCreateCall(node) && isReceiverOfDeprecatedZodErrorMember(node)) return;
-			if (!isZodErrorCreateCall(node) && !isDeprecatedZodErrorMemberAccess(node.callee)) return;
-			context.report({
-				node,
-				message: ZOD_ERROR_API_MESSAGE
-			});
-		},
-		MemberExpression(node) {
-			const parent = node.parent;
-			if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
-			if (!isDeprecatedZodErrorMemberAccess(node)) return;
-			context.report({
-				node,
-				message: ZOD_ERROR_API_MESSAGE
-			});
-		}
-	})
-});
-//#endregion
-//#region src/plugin/rules/zod/zod-v4-no-deprecated-error-customization.ts
-const ZOD_FACTORIES_WITH_ERROR_PARAMS = new Set([
-	"any",
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"enum",
-	"literal",
-	"map",
-	"nativeEnum",
-	"never",
-	"null",
-	"number",
-	"object",
-	"record",
-	"set",
-	"string",
-	"tuple",
-	"undefined",
-	"union",
-	"unknown",
-	"void"
-]);
-const DROPPED_ERROR_OPTION_PROPERTIES = new Set([
-	"errorMap",
-	"invalid_type_error",
-	"required_error"
-]);
-const FACTORIES_WITH_LEGACY_FIRST_ARG_MESSAGE = new Set([
-	"bigint",
-	"boolean",
-	"date",
-	"number",
-	"string"
-]);
-const ERROR_MAP_PROPERTY = new Set(["errorMap"]);
-const PARSE_METHODS = new Set([
-	"parse",
-	"safeParse",
-	"parseAsync",
-	"safeParseAsync"
-]);
-const firstArgumentIsMessageString = (callExpression) => {
-	const firstArgument = callExpression.arguments[0];
-	const inner = firstArgument ? stripParenExpression(firstArgument) : null;
-	return Boolean(inner && isNodeOfType(inner, "Literal") && typeof inner.value === "string");
-};
-const factoryUsesDeprecatedErrorParameter = (callExpression) => {
-	const factoryName = getZodFactoryCallName(callExpression);
-	if (factoryName === null || !ZOD_FACTORIES_WITH_ERROR_PARAMS.has(factoryName)) return false;
-	return FACTORIES_WITH_LEGACY_FIRST_ARG_MESSAGE.has(factoryName) && firstArgumentIsMessageString(callExpression) || callExpression.arguments.some((argument) => isObjectExpressionWithAnyProperty(argument, DROPPED_ERROR_OPTION_PROPERTIES));
-};
-const parseCallUsesErrorMap = (callExpression) => {
-	const methodCall = getMethodCall(callExpression);
-	if (!methodCall || !PARSE_METHODS.has(methodCall.methodName)) return false;
-	const receiver = stripParenExpression(methodCall.receiver);
-	if (!isNodeOfType(receiver, "CallExpression")) return false;
-	if (!isZodFactoryCall(receiver, ZOD_FACTORIES_WITH_ERROR_PARAMS)) return false;
-	return isObjectExpressionWithAnyProperty(callExpression.arguments[1], ERROR_MAP_PROPERTY);
-};
-const zodV4NoDeprecatedErrorCustomization = defineRule({
-	id: "zod-v4-no-deprecated-error-customization",
-	requires: ["zod:4"],
-	tags: ["migration-hint"],
-	severity: "warn",
-	recommendation: "Use Zod 4's unified `{ error }` callback/object customization instead of string message parameters, `invalid_type_error`, `required_error`, or `errorMap`.",
-	create: (context) => ({ CallExpression(node) {
-		if (!factoryUsesDeprecatedErrorParameter(node) && !parseCallUsesErrorMap(node)) return;
-		context.report({
-			node,
-			message: "Zod 4 replaces message parameters, `invalid_type_error`, `required_error`, and `errorMap` with the unified `error` API."
-		});
-	} })
-});
-//#endregion
-//#region src/plugin/rules/zod/zod-v4-no-deprecated-schema-apis.ts
-const OBJECT_FACTORY = new Set(["object"]);
-const OBJECT_METHODS = new Set([
-	"deepPartial",
-	"merge",
-	"nonstrict",
-	"passthrough",
-	"strict",
-	"strip"
-]);
-const NUMBER_FACTORY = new Set(["number"]);
-const NUMBER_METHODS = new Set(["safe"]);
-const FUNCTION_FACTORY = new Set(["function"]);
-const FUNCTION_CHAIN_METHODS = new Set(["args", "returns"]);
-const DEPRECATED_TOP_LEVEL_FACTORIES = new Set([
-	"nativeEnum",
-	"ostring",
-	"onumber",
-	"oboolean",
-	"oarray",
-	"promise"
-]);
-const FACTORIES_WITH_DROPPED_CREATE = new Set([
-	"any",
-	"array",
-	"bigint",
-	"boolean",
-	"date",
-	"enum",
-	"function",
-	"literal",
-	"map",
-	"nativeEnum",
-	"never",
-	"null",
-	"number",
-	"object",
-	"optional",
-	"promise",
-	"record",
-	"set",
-	"string",
-	"tuple",
-	"undefined",
-	"union",
-	"unknown",
-	"void"
-]);
-const ENUM_PROPERTY_ALIASES = new Set(["Enum", "Values"]);
-const ENUM_FACTORY = new Set(["enum"]);
-const RECORD_FACTORY = new Set(["record"]);
-const LITERAL_FACTORY = new Set(["literal"]);
-const reportSchemaMigration = (context, node) => {
-	context.report({
-		node,
-		message: "This Zod API is deprecated or changed in Zod 4; migrate to the recommended Zod 4 schema API."
-	});
-};
-const isCallToDeprecatedTopLevelFactory = (callExpression) => isZodFactoryCall(callExpression, DEPRECATED_TOP_LEVEL_FACTORIES);
-const isCallToDroppedCreateFactory = (callExpression) => {
-	const methodCall = getMethodCall(callExpression);
-	if (!methodCall || methodCall.methodName !== "create") return false;
-	const receiver = stripParenExpression(methodCall.receiver);
-	const namespaceMemberName = getZodNamespaceMemberName(receiver);
-	if (namespaceMemberName !== null) return FACTORIES_WITH_DROPPED_CREATE.has(namespaceMemberName);
-	if (!isNodeOfType(receiver, "Identifier")) return false;
-	const imported = getZodNamedImport(receiver);
-	return imported !== null && FACTORIES_WITH_DROPPED_CREATE.has(imported);
-};
-const isSingleArgumentRecordCall = (callExpression) => callExpression.arguments.length === 1 && isZodFactoryCall(callExpression, RECORD_FACTORY);
-const isDeprecatedFunctionChainCall = (callExpression) => isDirectMethodCallOnZodFactory(callExpression, FUNCTION_FACTORY, FUNCTION_CHAIN_METHODS);
-const isSymbolLiteralArgument = (node) => {
-	if (!node) return false;
-	const inner = stripParenExpression(node);
-	if (isNodeOfType(inner, "CallExpression")) {
-		const callee = stripParenExpression(inner.callee);
-		return isNodeOfType(callee, "Identifier") && callee.name === "Symbol";
-	}
-	if (!isNodeOfType(inner, "MemberExpression")) return false;
-	const object = stripParenExpression(inner.object);
-	return isNodeOfType(object, "Identifier") && object.name === "Symbol";
-};
-const isLiteralSymbolCall = (callExpression) => callExpression.arguments.length > 0 && isZodFactoryCall(callExpression, LITERAL_FACTORY) && isSymbolLiteralArgument(callExpression.arguments[0]);
-const isDroppedEnumAliasAccess = (memberExpression) => {
-	const propertyName = getStaticPropertyName(memberExpression);
-	if (propertyName === null || !ENUM_PROPERTY_ALIASES.has(propertyName)) return false;
-	const receiver = stripParenExpression(memberExpression.object);
-	return isNodeOfType(receiver, "CallExpression") && isZodFactoryCall(receiver, ENUM_FACTORY);
-};
-const isRefineSecondArgumentFunction = (callExpression) => {
-	const methodCall = getMethodCall(callExpression);
-	if (!methodCall || methodCall.methodName !== "refine") return false;
-	const receiver = stripParenExpression(methodCall.receiver);
-	if (!isNodeOfType(receiver, "CallExpression")) return false;
-	if (!isZodFactoryCall(receiver, FACTORIES_WITH_DROPPED_CREATE)) return false;
-	const secondArgument = callExpression.arguments[1];
-	return isNodeOfType(secondArgument, "FunctionExpression") || isNodeOfType(secondArgument, "ArrowFunctionExpression");
-};
-const isZodNamespaceImportMemberCreate = (memberExpression) => {
-	if (getStaticPropertyName(memberExpression) !== "create") return false;
-	const receiver = stripParenExpression(memberExpression.object);
-	if (!isNodeOfType(receiver, "MemberExpression")) return false;
-	const factoryName = getStaticPropertyName(receiver);
-	return factoryName !== null && FACTORIES_WITH_DROPPED_CREATE.has(factoryName) && isZodNamespaceIdentifier(receiver.object);
-};
-const zodV4NoDeprecatedSchemaApis = defineRule({
-	id: "zod-v4-no-deprecated-schema-apis",
-	requires: ["zod:4"],
-	tags: ["migration-hint"],
-	severity: "warn",
-	recommendation: "Migrate Zod 4 schema APIs that were deprecated, changed, or removed: use top-level factories such as `z.enum()`, object helpers such as `z.strictObject()`, the new `z.function({ input, output })` form, and explicit key/value schemas for `z.record()`.",
-	create: (context) => ({
-		CallExpression(node) {
-			if (isCallToDeprecatedTopLevelFactory(node) || isCallToDroppedCreateFactory(node) || isSingleArgumentRecordCall(node) || isLiteralSymbolCall(node) || isDeprecatedFunctionChainCall(node) || isDirectMethodCallOnZodFactory(node, OBJECT_FACTORY, OBJECT_METHODS) || isDirectMethodCallOnZodFactory(node, NUMBER_FACTORY, NUMBER_METHODS) || isRefineSecondArgumentFunction(node)) reportSchemaMigration(context, node);
-		},
-		MemberExpression(node) {
-			const parent = node.parent;
-			if (parent && isNodeOfType(parent, "CallExpression") && stripParenExpression(parent.callee) === node) return;
-			if (isDroppedEnumAliasAccess(node) || isZodNamespaceImportMemberCreate(node)) reportSchemaMigration(context, node);
-		}
-	})
-});
-//#endregion
-//#region src/plugin/rules/zod/zod-v4-prefer-top-level-string-formats.ts
-const ZOD_STRING_FACTORY = new Set(["string"]);
-const STRING_FORMAT_METHODS = new Set([
-	"base64",
-	"base64url",
-	"cidr",
-	"cidrv4",
-	"cidrv6",
-	"cuid",
-	"cuid2",
-	"date",
-	"datetime",
-	"duration",
-	"email",
-	"emoji",
-	"ip",
-	"ipv4",
-	"ipv6",
-	"jwt",
-	"nanoid",
-	"time",
-	"ulid",
-	"url",
-	"uuid"
-]);
-const zodV4PreferTopLevelStringFormats = defineRule({
-	id: "zod-v4-prefer-top-level-string-formats",
-	requires: ["zod:4"],
-	tags: ["migration-hint"],
-	severity: "warn",
-	recommendation: "Replace deprecated `z.string().<format>()` calls with Zod 4 top-level string format APIs like `z.email()`, `z.uuid()`, `z.ipv4()`, or `z.cidrv4()`.",
-	create: (context) => ({ CallExpression(node) {
-		if (!isDirectMethodCallOnZodFactory(node, ZOD_STRING_FACTORY, STRING_FORMAT_METHODS)) return;
-		context.report({
-			node,
-			message: "Zod 4 deprecates string format methods on `z.string()`; use the matching top-level Zod format API instead."
-		});
-	} })
-});
-//#endregion
 //#region src/plugin/rule-registry.ts
 const reactDoctorRules = [
 	{
@@ -37319,50 +36894,6 @@ const reactDoctorRules = [
 			framework: "global",
 			category: "Correctness"
 		}
-	},
-	{
-		key: "react-doctor/zod-v4-no-deprecated-error-apis",
-		id: "zod-v4-no-deprecated-error-apis",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...zodV4NoDeprecatedErrorApis,
-			framework: "global",
-			category: "Architecture"
-		}
-	},
-	{
-		key: "react-doctor/zod-v4-no-deprecated-error-customization",
-		id: "zod-v4-no-deprecated-error-customization",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...zodV4NoDeprecatedErrorCustomization,
-			framework: "global",
-			category: "Architecture"
-		}
-	},
-	{
-		key: "react-doctor/zod-v4-no-deprecated-schema-apis",
-		id: "zod-v4-no-deprecated-schema-apis",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...zodV4NoDeprecatedSchemaApis,
-			framework: "global",
-			category: "Architecture"
-		}
-	},
-	{
-		key: "react-doctor/zod-v4-prefer-top-level-string-formats",
-		id: "zod-v4-prefer-top-level-string-formats",
-		source: "react-doctor",
-		originallyExternal: false,
-		rule: {
-			...zodV4PreferTopLevelStringFormats,
-			framework: "global",
-			category: "Architecture"
-		}
 	}
 ];
 const ruleRegistry = Object.fromEntries(reactDoctorRules.map((rule) => [rule.id, rule.rule]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-react-doctor",
-  "version": "0.2.11-dev.b2934f9",
+  "version": "0.2.11-dev.b5cf767",
   "description": "oxlint plugin for React Doctor: diagnose React codebases for security, performance, correctness, accessibility, bundle-size, and architecture issues",
   "keywords": [
     "accessibility",