eslint-plugin-zod 3.5.1 → 3.5.3

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -1,87 +1,98 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const meta_js_1 = require("./meta.cjs");
-const array_style_js_1 = require("./rules/array-style.cjs");
-const consistent_import_source_js_1 = require("./rules/consistent-import-source.cjs");
-const consistent_import_js_1 = require("./rules/consistent-import.cjs");
-const consistent_object_schema_type_js_1 = require("./rules/consistent-object-schema-type.cjs");
-const no_any_schema_js_1 = require("./rules/no-any-schema.cjs");
-const no_empty_custom_schema_js_1 = require("./rules/no-empty-custom-schema.cjs");
-const no_number_schema_with_int_js_1 = require("./rules/no-number-schema-with-int.cjs");
-const no_optional_and_default_together_js_1 = require("./rules/no-optional-and-default-together.cjs");
-const no_string_schema_with_uuid_js_1 = require("./rules/no-string-schema-with-uuid.cjs");
-const no_throw_in_refine_js_1 = require("./rules/no-throw-in-refine.cjs");
-const no_unknown_schema_js_1 = require("./rules/no-unknown-schema.cjs");
-const prefer_enum_over_literal_union_js_1 = require("./rules/prefer-enum-over-literal-union.cjs");
-const prefer_meta_last_js_1 = require("./rules/prefer-meta-last.cjs");
-const prefer_meta_js_1 = require("./rules/prefer-meta.cjs");
-const prefer_namespace_import_js_1 = require("./rules/prefer-namespace-import.cjs");
-const prefer_string_schema_with_trim_js_1 = require("./rules/prefer-string-schema-with-trim.cjs");
-const require_brand_type_parameter_js_1 = require("./rules/require-brand-type-parameter.cjs");
-const require_error_message_js_1 = require("./rules/require-error-message.cjs");
-const require_schema_suffix_js_1 = require("./rules/require-schema-suffix.cjs");
-const schema_error_property_style_js_1 = require("./rules/schema-error-property-style.cjs");
+const require_meta = require("./meta.cjs");
+const require_array_style = require("./rules/array-style.cjs");
+const require_consistent_import_source = require("./rules/consistent-import-source.cjs");
+const require_consistent_import = require("./rules/consistent-import.cjs");
+const require_consistent_object_schema_type = require("./rules/consistent-object-schema-type.cjs");
+const require_no_any_schema = require("./rules/no-any-schema.cjs");
+const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_number_schema_with_int = require("./rules/no-number-schema-with-int.cjs");
+const require_no_optional_and_default_together = require("./rules/no-optional-and-default-together.cjs");
+const require_no_string_schema_with_uuid = require("./rules/no-string-schema-with-uuid.cjs");
+const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
+const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
+const require_prefer_enum_over_literal_union = require("./rules/prefer-enum-over-literal-union.cjs");
+const require_prefer_meta_last = require("./rules/prefer-meta-last.cjs");
+const require_prefer_meta = require("./rules/prefer-meta.cjs");
+const require_prefer_namespace_import = require("./rules/prefer-namespace-import.cjs");
+const require_prefer_string_schema_with_trim = require("./rules/prefer-string-schema-with-trim.cjs");
+const require_require_brand_type_parameter = require("./rules/require-brand-type-parameter.cjs");
+const require_require_error_message = require("./rules/require-error-message.cjs");
+const require_require_schema_suffix = require("./rules/require-schema-suffix.cjs");
+const require_schema_error_property_style = require("./rules/schema-error-property-style.cjs");
+//#region src/index.ts
 const eslintPluginZod = {
-    meta: {
-        name: meta_js_1.PLUGIN_NAME,
-        version: meta_js_1.PLUGIN_VERSION,
-    },
-    rules: {
-        'array-style': array_style_js_1.arrayStyle,
-        'consistent-import-source': consistent_import_source_js_1.consistentImportSource,
-        'consistent-import': consistent_import_js_1.consistentImport,
-        'consistent-object-schema-type': consistent_object_schema_type_js_1.consistentObjectSchemaType,
-        'no-any-schema': no_any_schema_js_1.noAnySchema,
-        'no-empty-custom-schema': no_empty_custom_schema_js_1.noEmptyCustomSchema,
-        'no-number-schema-with-int': no_number_schema_with_int_js_1.noNumberSchemaWithInt,
-        'no-string-schema-with-uuid': no_string_schema_with_uuid_js_1.noStringSchemaWithUuid,
-        'no-optional-and-default-together': no_optional_and_default_together_js_1.noOptionalAndDefaultTogether,
-        'no-throw-in-refine': no_throw_in_refine_js_1.noThrowInRefine,
-        'no-unknown-schema': no_unknown_schema_js_1.noUnknownSchema,
-        'prefer-enum-over-literal-union': prefer_enum_over_literal_union_js_1.preferEnumOverLiteralUnion,
-        'prefer-meta': prefer_meta_js_1.preferMeta,
-        'prefer-meta-last': prefer_meta_last_js_1.preferMetaLast,
-        'prefer-namespace-import': prefer_namespace_import_js_1.preferNamespaceImport,
-        'prefer-string-schema-with-trim': prefer_string_schema_with_trim_js_1.preferStringSchemaWithTrim,
-        'require-brand-type-parameter': require_brand_type_parameter_js_1.requireBrandTypeParameter,
-        'require-error-message': require_error_message_js_1.requireErrorMessage,
-        'require-schema-suffix': require_schema_suffix_js_1.requireSchemaSuffix,
-        'schema-error-property-style': schema_error_property_style_js_1.schemaErrorPropertyStyle,
-    },
+	meta: {
+		name: require_meta.PLUGIN_NAME,
+		version: require_meta.PLUGIN_VERSION
+	},
+	rules: {
+		"array-style": require_array_style.arrayStyle,
+		"consistent-import-source": require_consistent_import_source.consistentImportSource,
+		"consistent-import": require_consistent_import.consistentImport,
+		"consistent-object-schema-type": require_consistent_object_schema_type.consistentObjectSchemaType,
+		"no-any-schema": require_no_any_schema.noAnySchema,
+		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-number-schema-with-int": require_no_number_schema_with_int.noNumberSchemaWithInt,
+		"no-string-schema-with-uuid": require_no_string_schema_with_uuid.noStringSchemaWithUuid,
+		"no-optional-and-default-together": require_no_optional_and_default_together.noOptionalAndDefaultTogether,
+		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
+		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
+		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
+		"prefer-meta": require_prefer_meta.preferMeta,
+		"prefer-meta-last": require_prefer_meta_last.preferMetaLast,
+		"prefer-namespace-import": require_prefer_namespace_import.preferNamespaceImport,
+		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
+		"require-brand-type-parameter": require_require_brand_type_parameter.requireBrandTypeParameter,
+		"require-error-message": require_require_error_message.requireErrorMessage,
+		"require-schema-suffix": require_require_schema_suffix.requireSchemaSuffix,
+		"schema-error-property-style": require_schema_error_property_style.schemaErrorPropertyStyle
+	}
 };
 const baseConfig = {
-    name: `${meta_js_1.PLUGIN_NAME}/recommended`,
-    files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
-    plugins: {
-        zod: eslintPluginZod,
-    },
+	name: `${require_meta.PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { zod: eslintPluginZod }
 };
-const recommendedConfig = Object.assign(Object.assign({}, baseConfig), { rules: {
-        'zod/array-style': 'error',
-        'zod/consistent-import': 'error',
-        'zod/no-any-schema': 'error',
-        'zod/no-empty-custom-schema': 'error',
-        'zod/no-number-schema-with-int': 'error',
-        'zod/no-string-schema-with-uuid': 'error',
-        'zod/no-optional-and-default-together': 'error',
-        'zod/no-throw-in-refine': 'error',
-        'zod/prefer-enum-over-literal-union': 'error',
-        'zod/prefer-meta': 'error',
-        'zod/prefer-meta-last': 'error',
-        'zod/prefer-string-schema-with-trim': 'error',
-        'zod/require-brand-type-parameter': 'error',
-        'zod/require-error-message': 'error',
-        'zod/require-schema-suffix': 'error',
-    } });
-const recommendedConfigMini = Object.assign(Object.assign({}, baseConfig), { rules: {
-        'zod/no-any-schema': 'error',
-        'zod/prefer-meta': 'error',
-        'zod/require-brand-type-parameter': 'error',
-        'zod/require-error-message': 'error',
-        'zod/require-schema-suffix': 'error',
-    } });
-exports.default = Object.assign(Object.assign({}, eslintPluginZod), { configs: {
-        recommended: recommendedConfig,
-        recommendedMini: recommendedConfigMini,
-    } });
-module.exports = exports.default;
+const recommendedConfig = {
+	...baseConfig,
+	rules: {
+		"zod/array-style": "error",
+		"zod/consistent-import": "error",
+		"zod/no-any-schema": "error",
+		"zod/no-empty-custom-schema": "error",
+		"zod/no-number-schema-with-int": "error",
+		"zod/no-string-schema-with-uuid": "error",
+		"zod/no-optional-and-default-together": "error",
+		"zod/no-throw-in-refine": "error",
+		"zod/prefer-enum-over-literal-union": "error",
+		"zod/prefer-meta": "error",
+		"zod/prefer-meta-last": "error",
+		"zod/prefer-string-schema-with-trim": "error",
+		"zod/require-brand-type-parameter": "error",
+		"zod/require-error-message": "error",
+		"zod/require-schema-suffix": "error"
+	}
+};
+const recommendedConfigMini = {
+	...baseConfig,
+	rules: {
+		"zod/no-any-schema": "error",
+		"zod/prefer-meta": "error",
+		"zod/require-brand-type-parameter": "error",
+		"zod/require-error-message": "error",
+		"zod/require-schema-suffix": "error"
+	}
+};
+var src_default = {
+	...eslintPluginZod,
+	configs: {
+		recommended: recommendedConfig,
+		recommendedMini: recommendedConfigMini
+	}
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-plugin-zod/issues/49
+*/
+//#endregion
+module.exports = src_default;

package/dist/index.d.cts

@@ -1,22 +1,23 @@
+//#region src/index.d.ts
 interface CompatibleConfig {
-    name?: string;
-    rules?: object;
-    plugins?: Record<string, CompatiblePlugin>;
+  name?: string;
+  rules?: object;
+  plugins?: Record<string, CompatiblePlugin>;
 }
 interface CompatiblePlugin {
-    meta: {
-        name: string;
-        version: string;
-    };
+  meta: {
+    name: string;
+    version: string;
+  };
 }
 declare const _default: {
-    configs: {
-        recommended: CompatibleConfig;
-        recommendedMini: CompatibleConfig;
-    };
-    meta: {
-        name: string;
-        version: string;
-    };
+  configs: {
+    recommended: CompatibleConfig;
+    recommendedMini: CompatibleConfig;
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
 };
-export = _default;
+export = _default;

package/dist/index.d.mts

@@ -0,0 +1,24 @@
+//#region src/index.d.ts
+interface CompatibleConfig {
+  name?: string;
+  rules?: object;
+  plugins?: Record<string, CompatiblePlugin>;
+}
+interface CompatiblePlugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+}
+declare const _default: {
+  configs: {
+    recommended: CompatibleConfig;
+    recommendedMini: CompatibleConfig;
+  };
+  meta: {
+    name: string;
+    version: string;
+  };
+};
+//#endregion
+export { _default as default };

package/dist/index.mjs

@@ -0,0 +1,98 @@
+import { PLUGIN_NAME, PLUGIN_VERSION } from "./meta.mjs";
+import { arrayStyle } from "./rules/array-style.mjs";
+import { consistentImportSource } from "./rules/consistent-import-source.mjs";
+import { consistentImport } from "./rules/consistent-import.mjs";
+import { consistentObjectSchemaType } from "./rules/consistent-object-schema-type.mjs";
+import { noAnySchema } from "./rules/no-any-schema.mjs";
+import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noNumberSchemaWithInt } from "./rules/no-number-schema-with-int.mjs";
+import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.mjs";
+import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.mjs";
+import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
+import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
+import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
+import { preferMetaLast } from "./rules/prefer-meta-last.mjs";
+import { preferMeta } from "./rules/prefer-meta.mjs";
+import { preferNamespaceImport } from "./rules/prefer-namespace-import.mjs";
+import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.mjs";
+import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.mjs";
+import { requireErrorMessage } from "./rules/require-error-message.mjs";
+import { requireSchemaSuffix } from "./rules/require-schema-suffix.mjs";
+import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.mjs";
+//#region src/index.ts
+const eslintPluginZod = {
+	meta: {
+		name: PLUGIN_NAME,
+		version: PLUGIN_VERSION
+	},
+	rules: {
+		"array-style": arrayStyle,
+		"consistent-import-source": consistentImportSource,
+		"consistent-import": consistentImport,
+		"consistent-object-schema-type": consistentObjectSchemaType,
+		"no-any-schema": noAnySchema,
+		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-number-schema-with-int": noNumberSchemaWithInt,
+		"no-string-schema-with-uuid": noStringSchemaWithUuid,
+		"no-optional-and-default-together": noOptionalAndDefaultTogether,
+		"no-throw-in-refine": noThrowInRefine,
+		"no-unknown-schema": noUnknownSchema,
+		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
+		"prefer-meta": preferMeta,
+		"prefer-meta-last": preferMetaLast,
+		"prefer-namespace-import": preferNamespaceImport,
+		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
+		"require-brand-type-parameter": requireBrandTypeParameter,
+		"require-error-message": requireErrorMessage,
+		"require-schema-suffix": requireSchemaSuffix,
+		"schema-error-property-style": schemaErrorPropertyStyle
+	}
+};
+const baseConfig = {
+	name: `${PLUGIN_NAME}/recommended`,
+	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
+	plugins: { zod: eslintPluginZod }
+};
+const recommendedConfig = {
+	...baseConfig,
+	rules: {
+		"zod/array-style": "error",
+		"zod/consistent-import": "error",
+		"zod/no-any-schema": "error",
+		"zod/no-empty-custom-schema": "error",
+		"zod/no-number-schema-with-int": "error",
+		"zod/no-string-schema-with-uuid": "error",
+		"zod/no-optional-and-default-together": "error",
+		"zod/no-throw-in-refine": "error",
+		"zod/prefer-enum-over-literal-union": "error",
+		"zod/prefer-meta": "error",
+		"zod/prefer-meta-last": "error",
+		"zod/prefer-string-schema-with-trim": "error",
+		"zod/require-brand-type-parameter": "error",
+		"zod/require-error-message": "error",
+		"zod/require-schema-suffix": "error"
+	}
+};
+const recommendedConfigMini = {
+	...baseConfig,
+	rules: {
+		"zod/no-any-schema": "error",
+		"zod/prefer-meta": "error",
+		"zod/require-brand-type-parameter": "error",
+		"zod/require-error-message": "error",
+		"zod/require-schema-suffix": "error"
+	}
+};
+var src_default = {
+	...eslintPluginZod,
+	configs: {
+		recommended: recommendedConfig,
+		recommendedMini: recommendedConfigMini
+	}
+};
+/**
+* why `satisfies`?
+* @see https://github.com/marcalexiei/eslint-plugin-zod/issues/49
+*/
+//#endregion
+export { src_default as default };

package/dist/meta.cjs

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PLUGIN_VERSION = exports.PLUGIN_NAME = void 0;
-exports.getRuleURL = getRuleURL;
-const node_fs_1 = require("node:fs");
-const packageJSON = JSON.parse((0, node_fs_1.readFileSync)(new URL('../package.json', require("url").pathToFileURL(__filename)), 'utf8'));
-const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage, } = packageJSON;
-exports.PLUGIN_NAME = PLUGIN_NAME;
-exports.PLUGIN_VERSION = PLUGIN_VERSION;
-const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, '');
+require("./_virtual/_rolldown/runtime.cjs");
+let node_fs = require("node:fs");
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+/** @see https://github.com/marcalexiei/eslint-plugin-zod/pull/97 */
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, "");
 function getRuleURL(ruleID) {
-    return `${PLUGIN_HOMEPAGE}/blob/HEAD/docs/rules/${ruleID}.md`;
+	return `${PLUGIN_HOMEPAGE}/blob/HEAD/docs/rules/${ruleID}.md`;
 }
+//#endregion
+exports.PLUGIN_NAME = PLUGIN_NAME;
+exports.PLUGIN_VERSION = PLUGIN_VERSION;
+exports.getRuleURL = getRuleURL;

package/dist/meta.mjs

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+//#region src/meta.ts
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+/** @see https://github.com/marcalexiei/eslint-plugin-zod/pull/97 */
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, "");
+function getRuleURL(ruleID) {
+	return `${PLUGIN_HOMEPAGE}/blob/HEAD/docs/rules/${ruleID}.md`;
+}
+//#endregion
+export { PLUGIN_NAME, PLUGIN_VERSION, getRuleURL };

package/dist/rules/array-style.cjs

@@ -1,102 +1,89 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayStyle = void 0;
-const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
-const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-const ZOD_ARRAY_STYLES = ['function', 'method'];
-const defaultOptions = { style: 'function' };
-const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
-exports.arrayStyle = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'array-style',
-    meta: {
-        type: 'suggestion',
-        fixable: 'code',
-        docs: {
-            zodImportAllowedSource,
-            description: 'Enforce consistent Zod array style',
-        },
-        messages: {
-            useFunction: 'Use z.array(schema) instead of schema.array().',
-            useMethod: 'Use schema.array() instead of z.array(schema).',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    style: {
-                        description: 'Decides which style for zod array function',
-                        type: 'string',
-                        enum: ZOD_ARRAY_STYLES,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [defaultOptions],
-    create(context, [{ style }]) {
-        const { sourceCode } = context;
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchema = detectZodSchemaRootNode(node);
-                if (!zodSchema) {
-                    return;
-                }
-                const { schemaDecl, schemaType } = zodSchema;
-                if (style === 'method') {
-                    if (schemaType === 'array') {
-                        if (schemaDecl === 'namespace') {
-                            context.report({
-                                node,
-                                messageId: 'useMethod',
-                                fix(fixer) {
-                                    const chain = collectZodChainMethods(node);
-                                    const arrayCall = chain.find((c) => c.name === 'array');
-                                    if (!arrayCall) {
-                                        return null;
-                                    }
-                                    const arg = arrayCall.node.arguments.at(0);
-                                    if (!arg) {
-                                        return null;
-                                    }
-                                    const argText = sourceCode.getText(arg);
-                                    return fixer.replaceText(arrayCall.node, `${argText}.array()`);
-                                },
-                            });
-                            return;
-                        }
-                        context.report({
-                            node,
-                            messageId: 'useMethod',
-                        });
-                    }
-                    return;
-                }
-                const methods = collectZodChainMethods(node);
-                const arrayMethod = methods.find((it) => it.name === 'array' &&
-                    it.node.arguments.length === 0);
-                if (arrayMethod) {
-                    const arrayNode = arrayMethod.node;
-                    if (schemaDecl === 'namespace') {
-                        context.report({
-                            node,
-                            messageId: 'useFunction',
-                            fix(fixer) {
-                                const callee = arrayNode.callee;
-                                const objText = sourceCode.getText(callee.object);
-                                return fixer.replaceText(node, `z.array(${objText})`);
-                            },
-                        });
-                        return;
-                    }
-                    context.report({
-                        node,
-                        messageId: 'useFunction',
-                    });
-                }
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+//#region src/rules/array-style.ts
+const ZOD_ARRAY_STYLES = ["function", "method"];
+const defaultOptions = { style: "function" };
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const arrayStyle = require_create_plugin_rule.createZodPluginRule({
+	name: "array-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent Zod array style"
+		},
+		messages: {
+			useFunction: "Use z.array(schema) instead of schema.array().",
+			useMethod: "Use schema.array() instead of z.array(schema)."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style for zod array function",
+				type: "string",
+				enum: ZOD_ARRAY_STYLES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ style }]) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchema = detectZodSchemaRootNode(node);
+				if (!zodSchema) return;
+				const { schemaDecl, schemaType } = zodSchema;
+				if (style === "method") {
+					if (schemaType === "array") {
+						if (schemaDecl === "namespace") {
+							context.report({
+								node,
+								messageId: "useMethod",
+								fix(fixer) {
+									const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
+									if (!arrayCall) return null;
+									const arg = arrayCall.node.arguments.at(0);
+									if (!arg) return null;
+									const argText = sourceCode.getText(arg);
+									return fixer.replaceText(arrayCall.node, `${argText}.array()`);
+								}
+							});
+							return;
+						}
+						context.report({
+							node,
+							messageId: "useMethod"
+						});
+					}
+					return;
+				}
+				const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
+				if (arrayMethod) {
+					const arrayNode = arrayMethod.node;
+					if (schemaDecl === "namespace") {
+						context.report({
+							node,
+							messageId: "useFunction",
+							fix(fixer) {
+								const callee = arrayNode.callee;
+								const objText = sourceCode.getText(callee.object);
+								return fixer.replaceText(arrayNode, `z.array(${objText})`);
+							}
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "useFunction"
+					});
+				}
+			}
+		};
+	}
 });
+//#endregion
+exports.arrayStyle = arrayStyle;