eslint-plugin-th-rules 3.1.0 → 3.1.2

package/dist/configs/bundles/recommended-react.d.ts

@@ -1,2 +1,4 @@
 import { type Linter } from 'eslint';
-export declare const recommendedReact: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+export declare const recommendedReact: Linter.Config[];
+export default recommendedReact;
+//# sourceMappingURL=recommended-react.d.ts.map

package/dist/configs/bundles/recommended-react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended-react.d.ts","sourceRoot":"","sources":["../../../src/configs/bundles/recommended-react.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,QAAQ,CAAC;AAKnC,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAMvB,CAAC;AAEtB,eAAe,gBAAgB,CAAC"}

package/dist/configs/bundles/recommended-react.js

@@ -7,6 +7,7 @@ export const recommendedReact = resolveFlatConfig([
     ...recommended,
     react.configs.flat.recommended,
     react.configs.flat['jsx-runtime'],
-    reactHooks.configs.recommended,
+    reactHooks.configs.flat.recommended,
     ...coreReact,
 ]);
+export default recommendedReact;

package/dist/configs/bundles/recommended-typescript-react.d.ts

@@ -1,2 +1,4 @@
 import { type Linter } from 'eslint';
-export declare const recommendedTypescriptReact: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+export declare const recommendedTypescriptReact: Linter.Config[];
+export default recommendedTypescriptReact;
+//# sourceMappingURL=recommended-typescript-react.d.ts.map

package/dist/configs/bundles/recommended-typescript-react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended-typescript-react.d.ts","sourceRoot":"","sources":["../../../src/configs/bundles/recommended-typescript-react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,QAAQ,CAAC;AAMnC,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAAC,MAAM,EAIjC,CAAC;AAEtB,eAAe,0BAA0B,CAAC"}

package/dist/configs/bundles/recommended-typescript-react.js

@@ -7,3 +7,4 @@ export const recommendedTypescriptReact = resolveFlatConfig([
     ...recommendedTypescript,
     ...recommendedReact,
 ]);
+export default recommendedTypescriptReact;

package/dist/configs/bundles/recommended-typescript.d.ts

@@ -1,2 +1,4 @@
 import { type Linter } from 'eslint';
-export declare const recommendedTypescript: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+export declare const recommendedTypescript: Linter.Config[];
+export default recommendedTypescript;
+//# sourceMappingURL=recommended-typescript.d.ts.map

package/dist/configs/bundles/recommended-typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended-typescript.d.ts","sourceRoot":"","sources":["../../../src/configs/bundles/recommended-typescript.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,QAAQ,CAAC;AAInC,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAG5B,CAAC;AAEtB,eAAe,qBAAqB,CAAC"}

package/dist/configs/bundles/recommended-typescript.js

@@ -5,3 +5,4 @@ export const recommendedTypescript = resolveFlatConfig([
     ...recommended,
     ...coreTypescript,
 ]);
+export default recommendedTypescript;

package/dist/configs/bundles/recommended.d.ts

@@ -1,2 +1,4 @@
 import { type Linter } from 'eslint';
-export declare const recommended: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+export declare const recommended: Linter.Config[];
+export default recommended;
+//# sourceMappingURL=recommended.d.ts.map

package/dist/configs/bundles/recommended.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended.d.ts","sourceRoot":"","sources":["../../../src/configs/bundles/recommended.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,KAAK,MAAM,EAAC,MAAM,QAAQ,CAAC;AAKnC,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAIlB,CAAC;AAEtB,eAAe,WAAW,CAAC"}

package/dist/configs/bundles/recommended.js

@@ -7,3 +7,4 @@ export const recommended = resolveFlatConfig([
     ...externalsBase,
     ...externalsOpinionated,
 ]);
+export default recommended;

package/dist/configs/core/base.d.ts

@@ -1,2 +1,4 @@
 import { type ConfigWithExtends } from 'typescript-eslint';
 export declare const coreBase: ConfigWithExtends[];
+export default coreBase;
+//# sourceMappingURL=base.d.ts.map

package/dist/configs/core/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/configs/core/base.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAGzD,eAAO,MAAM,QAAQ,EAAE,iBAAiB,EAwBvC,CAAC;AAEF,eAAe,QAAQ,CAAC"}

package/dist/configs/core/base.js

@@ -15,9 +15,13 @@ export const coreBase = [
                 ...globals.jest,
             },
         },
-        rules: Object.keys(plugin.rules).reduce((acc, ruleName) => {
-            acc[`th-rules/${ruleName}`] = 'error';
-            return acc;
-        }, {}),
+        rules: (() => {
+            const rules = {};
+            for (const ruleName of Object.keys(plugin.rules)) {
+                rules[`th-rules/${ruleName}`] = 'error';
+            }
+            return rules;
+        })(),
     },
 ];
+export default coreBase;

package/dist/configs/core/react.d.ts

@@ -1,2 +1,4 @@
 import { type ConfigWithExtends } from 'typescript-eslint';
 export declare const coreReact: ConfigWithExtends[];
+export default coreReact;
+//# sourceMappingURL=react.d.ts.map

package/dist/configs/core/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../../src/configs/core/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,eAAO,MAAM,SAAS,EAAE,iBAAiB,EAOxC,CAAC;AACF,eAAe,SAAS,CAAC"}

package/dist/configs/core/react.js

@@ -6,3 +6,4 @@ export const coreReact = [
         },
     },
 ];
+export default coreReact;

package/dist/configs/core/typescript.d.ts

@@ -1,2 +1,4 @@
 import { type ConfigWithExtends } from 'typescript-eslint';
 export declare const coreTypescript: ConfigWithExtends[];
+export default coreTypescript;
+//# sourceMappingURL=typescript.d.ts.map

package/dist/configs/core/typescript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/configs/core/typescript.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAExE,eAAO,MAAM,cAAc,EAAE,iBAAiB,EAiB7C,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/configs/core/typescript.js

@@ -17,3 +17,4 @@ export const coreTypescript = [
         },
     },
 ];
+export default coreTypescript;

package/dist/configs/externals/base.d.ts

@@ -1,2 +1,4 @@
 import { type ConfigWithExtends } from 'typescript-eslint';
 export declare const externalsBase: ConfigWithExtends[];
+export default externalsBase;
+//# sourceMappingURL=base.d.ts.map

package/dist/configs/externals/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/configs/externals/base.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,KAAK,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,eAAO,MAAM,aAAa,EAAE,iBAAiB,EAW5C,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/configs/externals/base.js

@@ -14,3 +14,4 @@ export const externalsBase = [
         rules: {},
     },
 ];
+export default externalsBase;

package/dist/configs/externals/opinionated.d.ts

@@ -1,2 +1,4 @@
-import { ConfigWithExtends } from "typescript-eslint";
+import { type ConfigWithExtends } from 'typescript-eslint';
 export declare const externalsOpinionated: ConfigWithExtends[];
+export default externalsOpinionated;
+//# sourceMappingURL=opinionated.d.ts.map

package/dist/configs/externals/opinionated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opinionated.d.ts","sourceRoot":"","sources":["../../../src/configs/externals/opinionated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAEzD,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,EAWnD,CAAC;AAEF,eAAe,oBAAoB,CAAC"}

package/dist/configs/externals/opinionated.js

@@ -10,3 +10,4 @@ export const externalsOpinionated = [
         },
     },
 ];
+export default externalsOpinionated;

package/dist/index.d.ts

@@ -1,22 +1,18 @@
-export { rules } from './plugin.js';
+import { type Linter, type Rule } from 'eslint';
+export declare const configs: {
+    recommended: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+    recommendedReact: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+    recommendedTypescript: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+    recommendedTypescriptReact: Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
+};
 export { coreBase } from './configs/core/base.js';
 export { coreTypescript } from './configs/core/typescript.js';
 export { coreReact } from './configs/core/react.js';
 export { externalsBase } from './configs/externals/base.js';
 export { externalsOpinionated } from './configs/externals/opinionated.js';
-export declare const configs: {
-    recommended: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-    recommendedReact: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-    recommendedTypescript: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-    recommendedTypescriptReact: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-};
-declare const _default: {
-    rules: any;
-    configs: {
-        recommended: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-        recommendedReact: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-        recommendedTypescript: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-        recommendedTypescriptReact: import("eslint").Linter.Config<import("@eslint/core", { with: { "resolution-mode": "require" } }).RulesConfig>[];
-    };
+declare const index: {
+    rules: Record<string, Rule.RuleModule>;
+    configs: Record<string, Linter.Config[]>;
 };
-export default _default;
+export default index;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,KAAK,MAAM,EAAE,KAAK,IAAI,EAAC,MAAM,QAAQ,CAAC;AAQ9C,eAAO,MAAM,OAAO;;;;;CAKnB,CAAC;AAEF,OAAO,EAAC,QAAQ,EAAC,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAC,cAAc,EAAC,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAC,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAClD,OAAO,EAAC,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAC,oBAAoB,EAAC,MAAM,oCAAoC,CAAC;AAExE,QAAA,MAAM,KAAK,EAAkC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAA;CAAC,CAAC;AAChI,eAAe,KAAK,CAAC"}

package/dist/index.js

@@ -1,20 +1,19 @@
-import { rules } from './plugin.js';
-// Public bundles
+/* eslint-disable import-x/order */
 import { recommended } from './configs/bundles/recommended.js';
 import { recommendedReact } from './configs/bundles/recommended-react.js';
 import { recommendedTypescript } from './configs/bundles/recommended-typescript.js';
 import { recommendedTypescriptReact } from './configs/bundles/recommended-typescript-react.js';
-// Internal layers (named exports only)
-export { rules } from './plugin.js';
-export { coreBase } from './configs/core/base.js';
-export { coreTypescript } from './configs/core/typescript.js';
-export { coreReact } from './configs/core/react.js';
-export { externalsBase } from './configs/externals/base.js';
-export { externalsOpinionated } from './configs/externals/opinionated.js';
+import { rules } from './plugin.js';
 export const configs = {
     recommended,
     recommendedReact,
     recommendedTypescript,
     recommendedTypescriptReact,
 };
-export default { rules, configs };
+export { coreBase } from './configs/core/base.js';
+export { coreTypescript } from './configs/core/typescript.js';
+export { coreReact } from './configs/core/react.js';
+export { externalsBase } from './configs/externals/base.js';
+export { externalsOpinionated } from './configs/externals/opinionated.js';
+const index = { rules, configs };
+export default index;

package/dist/plugin.d.ts

@@ -1,5 +1,82 @@
-export declare const rules: any;
-export declare const plugin: {
-    rules: any;
+export declare const rules: {
+    noBooleanCoercion: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    noComments: import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentNotAllowed", [({
+        allow?: string[];
+        disallow?: string[];
+    } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    noDefaultExport: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    noDestructuring: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
+        maximumDestructuredVariables: number;
+        maximumLineLength: number;
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    preferIsEmpty: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    schemasInSchemasFile: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
+        allowedSuffixes: string[];
+        onlyWhenAssigned: boolean;
+        allowInTests: boolean;
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    topLevelFunctions: import("@typescript-eslint/utils/ts-eslint").RuleModule<"arrow" | "funcExpr" | "anonDecl", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+    typesInDts: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveToDts", [{
+        allowEnums: boolean;
+        allowDeclare: boolean;
+    }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
+};
+declare const plugin: {
+    rules: {
+        noBooleanCoercion: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty" | "useIsNil", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        noComments: import("@typescript-eslint/utils/ts-eslint").RuleModule<"commentNotAllowed", [({
+            allow?: string[];
+            disallow?: string[];
+        } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        noDefaultExport: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unnamed", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        noDestructuring: import("@typescript-eslint/utils/ts-eslint").RuleModule<"tooDeep" | "tooMany" | "tooLong", [{
+            maximumDestructuredVariables: number;
+            maximumLineLength: number;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        preferIsEmpty: import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsEmpty", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        schemasInSchemasFile: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveSchema", [{
+            allowedSuffixes: string[];
+            onlyWhenAssigned: boolean;
+            allowInTests: boolean;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        topLevelFunctions: import("@typescript-eslint/utils/ts-eslint").RuleModule<"arrow" | "funcExpr" | "anonDecl", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        typesInDts: import("@typescript-eslint/utils/ts-eslint").RuleModule<"moveToDts", [{
+            allowEnums: boolean;
+            allowDeclare: boolean;
+        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+    };
 };
 export default plugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASjB,CAAC;AAEF,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAU,CAAC;AACvB,eAAe,MAAM,CAAC"}

package/dist/plugin.js

@@ -1,14 +1,20 @@
-import { readdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const rulesDir = join(__dirname, 'rules');
-const ruleFiles = readdirSync(rulesDir).filter(file => file.endsWith('.js'));
-export const rules = Object.fromEntries(await Promise.all(ruleFiles.map(async (file) => {
-    const ruleName = file.replace('.js', '');
-    const ruleModule = await import(`./rules/${file}`);
-    return [ruleName, ruleModule.default];
-})));
-export const plugin = { rules };
+import noBooleanCoercion from './rules/no-boolean-coercion.js';
+import noComments from './rules/no-comments.js';
+import noDefaultExport from './rules/no-default-export.js';
+import noDestructuring from './rules/no-destructuring.js';
+import preferIsEmpty from './rules/prefer-is-empty.js';
+import schemasInSchemasFile from './rules/schemas-in-schemas-file.js';
+import topLevelFunctions from './rules/top-level-functions.js';
+import typesInDts from './rules/types-in-dts.js';
+export const rules = {
+    noBooleanCoercion,
+    noComments,
+    noDefaultExport,
+    noDestructuring,
+    preferIsEmpty,
+    schemasInSchemasFile,
+    topLevelFunctions,
+    typesInDts,
+};
+const plugin = { rules };
 export default plugin;

package/dist/rules/no-boolean-coercion.d.ts

@@ -1,5 +1,6 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-declare const _default: ESLintUtils.RuleModule<"useIsEmpty" | "useIsNil", [], unknown, ESLintUtils.RuleListener> & {
+declare const noBooleanCoercion: ESLintUtils.RuleModule<"useIsEmpty" | "useIsNil", [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };
-export default _default;
+export default noBooleanCoercion;
+//# sourceMappingURL=no-boolean-coercion.d.ts.map

package/dist/rules/no-boolean-coercion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-boolean-coercion.d.ts","sourceRoot":"","sources":["../../src/rules/no-boolean-coercion.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,WAAW,EAEX,MAAM,0BAA0B,CAAC;AAIlC,QAAA,MAAM,iBAAiB;;CAiHrB,CAAC;AACH,eAAe,iBAAiB,CAAC"}

package/dist/rules/no-boolean-coercion.js

@@ -1,6 +1,6 @@
 import { ESLintUtils, } from '@typescript-eslint/utils';
 const createRule = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/no-boolean-coercion.md');
-export default createRule({
+const noBooleanCoercion = createRule({
     name: 'no-boolean-coercion',
     meta: {
         type: 'problem',
@@ -19,9 +19,6 @@ export default createRule({
         const { sourceCode } = context;
         const services = ESLintUtils.getParserServices(context);
         const checker = services?.program?.getTypeChecker?.();
-        // --------------------------------------------------------------------
-        // Helpers
-        // --------------------------------------------------------------------
         function isBooleanCall(node) {
             return (node.type === 'CallExpression'
                 && node.callee.type === 'Identifier'
@@ -73,9 +70,6 @@ export default createRule({
                 ],
             });
         }
-        // --------------------------------------------------------------------
-        // Visitors
-        // --------------------------------------------------------------------
         return {
             CallExpression(node) {
                 if (isBooleanCall(node)) {
@@ -96,3 +90,4 @@ export default createRule({
         };
     },
 });
+export default noBooleanCoercion;

package/dist/rules/no-comments.d.ts

@@ -9,3 +9,4 @@ declare const noComments: ESLintUtils.RuleModule<"commentNotAllowed", Options, u
     name: string;
 };
 export default noComments;
+//# sourceMappingURL=no-comments.d.ts.map

package/dist/rules/no-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-comments.d.ts","sourceRoot":"","sources":["../../src/rules/no-comments.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AAEpE,KAAK,OAAO,GAAG;IACb;QACC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH,CAAC;AAYF,QAAA,MAAM,UAAU;;CAoFd,CAAC;AACH,eAAe,UAAU,CAAC"}

package/dist/rules/no-comments.js

@@ -43,7 +43,6 @@ const noComments = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/
         const userDisallowedPatterns = (option.disallow ?? []).map(pattern => new RegExp(pattern));
         function isCommentAllowed(comment) {
             const text = comment.value.trim();
-            // Allow JSDoc
             if (comment.type === 'Block' && comment.value.startsWith('*')) {
                 return true;
             }

package/dist/rules/no-default-export.d.ts

@@ -3,3 +3,4 @@ declare const noDefaultExport: ESLintUtils.RuleModule<"unnamed", [], unknown, ES
     name: string;
 };
 export default noDefaultExport;
+//# sourceMappingURL=no-default-export.d.ts.map

package/dist/rules/no-default-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-default-export.d.ts","sourceRoot":"","sources":["../../src/rules/no-default-export.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AAEpE,QAAA,MAAM,eAAe;;CAmEnB,CAAC;AACH,eAAe,eAAe,CAAC"}

package/dist/rules/no-destructuring.d.ts

@@ -6,3 +6,4 @@ declare const noDestructuring: ESLintUtils.RuleModule<"tooDeep" | "tooMany" | "t
     name: string;
 };
 export default noDestructuring;
+//# sourceMappingURL=no-destructuring.d.ts.map

package/dist/rules/no-destructuring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-destructuring.d.ts","sourceRoot":"","sources":["../../src/rules/no-destructuring.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AAIpE,QAAA,MAAM,eAAe;;;;;CAwJnB,CAAC;AACH,eAAe,eAAe,CAAC"}

package/dist/rules/prefer-is-empty.d.ts

@@ -3,3 +3,4 @@ declare const preferIsEmpty: ESLintUtils.RuleModule<"useIsEmpty", [], unknown, E
     name: string;
 };
 export default preferIsEmpty;
+//# sourceMappingURL=prefer-is-empty.d.ts.map

package/dist/rules/prefer-is-empty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefer-is-empty.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-is-empty.ts"],"names":[],"mappings":"AAGA,OAAO,EAAiB,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AAEpF,QAAA,MAAM,aAAa;;CAiHjB,CAAC;AACH,eAAe,aAAa,CAAC"}

package/dist/rules/prefer-is-empty.js

@@ -1,4 +1,7 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+/* eslint-disable new-cap */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/naming-convention */
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/prefer-is-empty.md')({
     name: 'prefer-is-empty',
     meta: {
@@ -14,21 +17,18 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
         function isLengthAccess(node) {
-            return (Boolean(node)
-                && node.type === 'MemberExpression'
-                && node.property.type === 'Identifier'
+            return (node?.type === AST_NODE_TYPES.MemberExpression
+                && node.property.type === AST_NODE_TYPES.Identifier
                 && node.property.name === 'length'
                 && !node.computed);
         }
         function isNumericLiteral(node) {
-            return (Boolean(node)
-                && node.type === 'Literal'
+            return (node?.type === AST_NODE_TYPES.Literal
                 && typeof node.value === 'number');
         }
         function report(node, collectionNode, operator, value, isEmptyCheck) {
-            const collectionText = sourceCode.getText(collectionNode.object);
+            const collectionText = context.sourceCode.getText(collectionNode.object);
             const replacement = isEmptyCheck
                 ? `_.isEmpty(${collectionText})`
                 : `!_.isEmpty(${collectionText})`;
@@ -57,32 +57,29 @@ const preferIsEmpty = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh20
         }
         return {
             BinaryExpression(node) {
-                const { left, right, operator } = node;
-                if (isLengthAccess(left) && isNumericLiteral(right)) {
-                    const { value } = right;
-                    if ((operator === '===' && value === 0)
-                        || (operator === '<=' && value === 0)
-                        || (operator === '<' && value === 1)) {
-                        report(node, left, operator, value, true);
+                if (isLengthAccess(node.left) && isNumericLiteral(node.right)) {
+                    if ((node.operator === '===' && node.right.value === 0)
+                        || (node.operator === '<=' && node.right.value === 0)
+                        || (node.operator === '<' && node.right.value === 1)) {
+                        report(node, node.left, node.operator, node.right.value, true);
                         return;
                     }
-                    if ((operator === '>' && value === 0)
-                        || (operator === '>=' && value === 1)
-                        || ((operator === '!=' || operator === '!==') && value === 0)) {
-                        report(node, left, operator, value, false);
+                    if ((node.operator === '>' && node.right.value === 0)
+                        || (node.operator === '>=' && node.right.value === 1)
+                        || ((node.operator === '!=' || node.operator === '!==') && node.right.value === 0)) {
+                        report(node, node.left, node.operator, node.right.value, false);
                     }
                 }
-                if (isNumericLiteral(left) && isLengthAccess(right)) {
-                    const { value } = left;
-                    if ((operator === '===' && value === 0)
-                        || (operator === '>=' && value === 0)
-                        || (operator === '>' && value === 0)) {
-                        report(node, right, operator, value, true);
+                if (isNumericLiteral(node.left) && isLengthAccess(node.right)) {
+                    if ((node.operator === '===' && node.left.value === 0)
+                        || (node.operator === '>=' && node.left.value === 0)
+                        || (node.operator === '>' && node.left.value === 0)) {
+                        report(node, node.right, node.operator, node.left.value, true);
                         return;
                     }
-                    if ((operator === '<' && value === 1)
-                        || (operator === '<=' && value === 0)) {
-                        report(node, right, operator, value, false);
+                    if ((node.operator === '<' && node.left.value === 1)
+                        || (node.operator === '<=' && node.left.value === 0)) {
+                        report(node, node.right, node.operator, node.left.value, false);
                     }
                 }
             },

package/dist/rules/schemas-in-schemas-file.d.ts

@@ -7,3 +7,4 @@ declare const schemasInSchemasFile: ESLintUtils.RuleModule<"moveSchema", [{
     name: string;
 };
 export default schemasInSchemasFile;
+//# sourceMappingURL=schemas-in-schemas-file.d.ts.map

package/dist/rules/schemas-in-schemas-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-in-schemas-file.d.ts","sourceRoot":"","sources":["../../src/rules/schemas-in-schemas-file.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AAEpF,QAAA,MAAM,oBAAoB;;;;;;CA+LxB,CAAC;AACH,eAAe,oBAAoB,CAAC"}

package/dist/rules/schemas-in-schemas-file.js

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
+/* eslint-disable @typescript-eslint/naming-convention */
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
 const schemasInSchemasFile = ESLintUtils.RuleCreator(() => 'https://github.com/tomerh2001/eslint-plugin-th-rules/blob/main/docs/rules/schemas-in-schemas-file.md')({
     name: 'schemas-in-schemas-file',
     meta: {
@@ -33,9 +34,9 @@ const schemasInSchemasFile = ESLintUtils.RuleCreator(() => 'https://github.com/t
         },
     ],
     create(context, [options]) {
-        const allowedSuffixes = options.allowedSuffixes ?? ['.schemas.ts'];
-        const onlyWhenAssigned = Boolean(options.onlyWhenAssigned);
-        const allowInTests = Boolean(options.allowInTests);
+        const allowedSuffixes = options.allowedSuffixes && options.allowedSuffixes.length > 0 ? options.allowedSuffixes : ['.schemas.ts'];
+        const onlyWhenAssigned = options.onlyWhenAssigned ?? false;
+        const allowInTests = options.allowInTests ?? false;
         const zodIdentifiers = new Set();
         function filenameAllowed(filename) {
             if (!filename || filename === '<input>') {
@@ -48,67 +49,62 @@ const schemasInSchemasFile = ESLintUtils.RuleCreator(() => 'https://github.com/t
             return allowedSuffixes.some(suffix => filename.endsWith(suffix));
         }
         function isZodModuleImport(node) {
-            return (node.source.type === 'Literal'
-                && node.source.value === 'zod');
+            return (node.source.value === 'zod');
         }
         function collectZodIdentifiersFromImport(node) {
             if (!isZodModuleImport(node)) {
                 return;
             }
             for (const spec of node.specifiers) {
-                if (spec.type === 'ImportSpecifier'
-                    && spec.imported.type === 'Identifier'
-                    && spec.imported.name === 'z'
-                    && spec.local.type === 'Identifier') {
+                if (spec.type === AST_NODE_TYPES.ImportSpecifier
+                    && spec.imported.type === AST_NODE_TYPES.Identifier
+                    && spec.imported.name === 'z') {
                     zodIdentifiers.add(spec.local.name);
                 }
-                if (spec.type === 'ImportNamespaceSpecifier'
-                    && spec.local.type === 'Identifier') {
+                if (spec.type === AST_NODE_TYPES.ImportNamespaceSpecifier) {
                     zodIdentifiers.add(spec.local.name);
                 }
             }
         }
         function isZodBuilderCall(node) {
             const { callee } = node;
-            if (callee.type !== 'MemberExpression'
+            if (callee.type !== AST_NODE_TYPES.MemberExpression
                 || callee.computed) {
                 return false;
             }
             const { object } = callee;
             const { property } = callee;
-            return (object.type === 'Identifier'
+            return (object.type === AST_NODE_TYPES.Identifier
                 && zodIdentifiers.has(object.name)
-                && property.type === 'Identifier');
+                && property.type === AST_NODE_TYPES.Identifier);
         }
         function isZodChainedBuilderCall(node) {
             const { callee } = node;
-            if (callee.type !== 'MemberExpression'
+            if (callee.type !== AST_NODE_TYPES.MemberExpression
                 || callee.computed) {
                 return false;
             }
             let current = callee.object;
-            while (current.type === 'MemberExpression'
+            while (current.type === AST_NODE_TYPES.MemberExpression
                 && !current.computed) {
                 current = current.object;
             }
-            return (current.type === 'Identifier'
+            return (current.type === AST_NODE_TYPES.Identifier
                 && zodIdentifiers.has(current.name));
         }
         function getAssignmentTargetName(callNode) {
             const { parent } = callNode;
-            if (parent?.type === 'VariableDeclarator'
-                && parent.id.type === 'Identifier') {
+            if (parent.type === AST_NODE_TYPES.VariableDeclarator
+                && parent.id.type === AST_NODE_TYPES.Identifier) {
                 return parent.id.name;
             }
-            if (parent?.type === 'AssignmentExpression'
-                && parent.left.type === 'Identifier') {
+            if (parent.type === AST_NODE_TYPES.AssignmentExpression
+                && parent.left.type === AST_NODE_TYPES.Identifier) {
                 return parent.left.name;
             }
-            return null;
         }
         function report(node) {
-            const filename = context.getFilename();
-            if (filenameAllowed(filename)) {
+            if (filenameAllowed(context.filename)) {
                 return;
             }
             const targetName = getAssignmentTargetName(node);

package/dist/rules/top-level-functions.d.ts

@@ -3,3 +3,4 @@ declare const topLevelFunctions: ESLintUtils.RuleModule<"arrow" | "funcExpr" | "
     name: string;
 };
 export default topLevelFunctions;
+//# sourceMappingURL=top-level-functions.d.ts.map

package/dist/rules/top-level-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"top-level-functions.d.ts","sourceRoot":"","sources":["../../src/rules/top-level-functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AAEpE,QAAA,MAAM,iBAAiB;;CA8NrB,CAAC;AACH,eAAe,iBAAiB,CAAC"}

package/dist/rules/types-in-dts.d.ts

@@ -6,3 +6,4 @@ declare const typesInDts: ESLintUtils.RuleModule<"moveToDts", [{
     name: string;
 };
 export default typesInDts;
+//# sourceMappingURL=types-in-dts.d.ts.map

package/dist/rules/types-in-dts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-in-dts.d.ts","sourceRoot":"","sources":["../../src/rules/types-in-dts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAgB,MAAM,0BAA0B,CAAC;AASpE,QAAA,MAAM,UAAU;;;;;CAmGd,CAAC;AACH,eAAe,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-th-rules",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "A List of custom ESLint rules created by Tomer Horowitz",
   "keywords": [
     "eslint",
@@ -61,6 +61,7 @@
     "@typescript-eslint/eslint-plugin": "^8.53.0",
     "@typescript-eslint/parser": "^8.53.0",
     "@typescript-eslint/rule-tester": "^8.53.0",
+    "@typescript-eslint/utils": "^8.53.0",
     "bun-types": "latest",
     "eslint": "^9.39.2",
     "eslint-doc-generator": "^3.0.2",