@aryaemami59/eslint-config 0.0.5 → 0.0.7

package/dist/index.cjs

@@ -1,345 +1,383 @@
-"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#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 __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	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(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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));
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  config: () => import_typescript_eslint.config,
-  configs: () => import_typescript_eslint.configs,
-  createESLintConfig: () => createESLintConfig,
-  disabledRules: () => disabledRules,
-  flatESLintConfig: () => flatESLintConfig,
-  globalIgnores: () => globalIgnores,
-  globals: () => globals,
-  js: () => import_js.default,
-  parser: () => import_typescript_eslint.parser,
-  plugin: () => import_typescript_eslint.plugin,
-  prettierConfig: () => import_flat.default,
-  vitestGlobals: () => vitestGlobals
-});
-module.exports = __toCommonJS(src_exports);
+//#endregion
+let _eslint_js = require("@eslint/js");
+_eslint_js = __toESM(_eslint_js);
+let eslint_config_prettier_flat = require("eslint-config-prettier/flat");
+eslint_config_prettier_flat = __toESM(eslint_config_prettier_flat);
+let globals = require("globals");
+globals = __toESM(globals);
+let eslint_config = require("eslint/config");
+let typescript_eslint = require("typescript-eslint");
 
-// src/disabledRules.ts
-var disabledRules = {
-  "no-undef": [0, { typeof: false }],
-  "@typescript-eslint/no-unused-vars": [
-    0,
-    {
-      args: "all",
-      argsIgnorePattern: "^_",
-      caughtErrors: "all",
-      caughtErrorsIgnorePattern: "^_",
-      destructuredArrayIgnorePattern: "^_",
-      varsIgnorePattern: "^_",
-      ignoreRestSiblings: true
-    }
-  ],
-  "@typescript-eslint/ban-ts-comment": [
-    0,
-    {
-      "ts-expect-error": "allow-with-description",
-      "ts-ignore": true,
-      "ts-nocheck": true,
-      "ts-check": false,
-      minimumDescriptionLength: 3
-    }
-  ]
+//#region src/disabledRules.ts
+/**
+* An object comprised of ESLint rules to disable.
+* These rules are disabled in {@linkcode flatESLintConfig}.
+*
+* @since 0.0.3
+* @public
+*/
+const disabledRules = {
+	"@typescript-eslint/ban-ts-comment": [0, {
+		minimumDescriptionLength: 3,
+		"ts-check": false,
+		"ts-expect-error": "allow-with-description",
+		"ts-ignore": true,
+		"ts-nocheck": true
+	}],
+	"@typescript-eslint/consistent-generic-constructors": [0],
+	"@typescript-eslint/no-unused-vars": [0, {
+		args: "after-used",
+		argsIgnorePattern: "^_",
+		caughtErrors: "all",
+		caughtErrorsIgnorePattern: "^_",
+		destructuredArrayIgnorePattern: "^_",
+		ignoreClassWithStaticInitBlock: false,
+		ignoreRestSiblings: false,
+		reportUsedIgnorePattern: false,
+		vars: "all",
+		varsIgnorePattern: "^_"
+	}],
+	"no-undef": [0, { typeof: false }]
 };
 
-// src/external.ts
-var import_js = __toESM(require("@eslint/js"), 1);
-var import_flat = __toESM(require("eslint-config-prettier/flat"), 1);
-var import_typescript_eslint = require("typescript-eslint");
+//#endregion
+//#region src/external.ts
+const { browser, node, nodeBuiltin, vitest } = globals.default;
 
-// src/packageName.ts
-var packageName = "@aryaemami59/eslint-config";
+//#endregion
+//#region package.json
+var name = "@aryaemami59/eslint-config";
 
-// src/globalIgnores.ts
-var globalIgnores = {
-  name: `${packageName}/global-ignores`,
-  ignores: [
-    "**/dist/",
-    "**/build/",
-    "**/lib/",
-    "**/coverage/",
-    "**/__snapshots__/",
-    "**/temp/",
-    "**/.temp/",
-    "**/.tmp/",
-    "**/.yalc/",
-    "**/.yarn/",
-    "**/.docusaurus/",
-    "**/.next/",
-    "**/.expo/",
-    "**/*.snap"
-  ]
+//#endregion
+//#region src/globalIgnores.ts
+/**
+* An object representing
+* {@link https://eslint.org/docs/latest/use/configure/ignore#ignoring-files | **global ignore patterns**}
+* for ESLint configuration.
+*
+* @since 0.0.3
+* @public
+*/
+const globalIgnores = {
+	ignores: [
+		"**/__snapshots__/",
+		"**/.docusaurus/",
+		"**/.expo/",
+		"**/.next/",
+		"**/.playwright/",
+		"**/.temp/",
+		"**/.tmp/",
+		"**/.turbo/",
+		"**/.wrangler/",
+		"**/.yalc/",
+		"**/.yarn/",
+		"**/*.snap",
+		"**/build/",
+		"**/coverage/",
+		"**/dist/",
+		"**/temp/"
+	],
+	name: `${name}/global-ignores`
 };
 
-// src/globals.ts
-var import_globals = __toESM(require("globals"), 1);
-var { browser, node, nodeBuiltin, vitest } = import_globals.default;
-var vitestGlobals = {
-  suite: "writable",
-  test: "writable",
-  chai: "writable",
-  describe: "writable",
-  it: "writable",
-  expectTypeOf: "writable",
-  assertType: "writable",
-  expect: "writable",
-  assert: "writable",
-  vitest: "writable",
-  vi: "writable",
-  beforeAll: "writable",
-  afterAll: "writable",
-  beforeEach: "writable",
-  afterEach: "writable",
-  onTestFailed: "writable",
-  onTestFinished: "writable"
+//#endregion
+//#region src/globals.ts
+/**
+* An object representing the
+* {@link https://vitest.dev/config/#globals | globals} provided by
+* {@link https://vitest.dev | **Vitest**} for use in testing.
+*
+* @since 0.0.3
+* @public
+*/
+const vitestGlobals = {
+	afterAll: "writable",
+	afterEach: "writable",
+	assert: "writable",
+	assertType: "writable",
+	beforeAll: "writable",
+	beforeEach: "writable",
+	chai: "writable",
+	describe: "writable",
+	expect: "writable",
+	expectTypeOf: "writable",
+	it: "writable",
+	onTestFailed: "writable",
+	onTestFinished: "writable",
+	suite: "writable",
+	test: "writable",
+	vi: "writable",
+	vitest: "writable"
 };
-var globals = /* @__PURE__ */ Object.assign(
-  {
-    ...browser,
-    ...node,
-    ...nodeBuiltin
-  },
-  {
-    ...vitest,
-    ...vitestGlobals
-  }
-);
+/**
+* An object that specifies which global
+* variables are available during linting.
+*
+* @since 0.0.3
+* @public
+*/
+const globals$1 = /* @__PURE__ */ Object.assign({
+	...browser,
+	...node,
+	...nodeBuiltin
+}, {
+	...vitest,
+	...vitestGlobals
+});
+
+//#endregion
+//#region src/shareableConfigs.ts
+/**
+* Flat ESLint configuration tailored for projects using TypeScript.
+*
+* @example
+* <caption>#### __ECMAScript Modules (ESM) usage inside a file like `eslint.config.mts` or `eslint.config.mjs`__</caption>
+*
+* ```ts
+* import { flatESLintConfig } from '@aryaemami59/eslint-config'
+*
+* export default flatESLintConfig
+* ```
+*
+* @example
+* <caption>#### __CommonJS (CJS) usage inside a file like `eslint.config.cts` or `eslint.config.cjs` (using `require`)__</caption>
+*
+* ```ts
+* const { flatESLintConfig } = require('@aryaemami59/eslint-config')
+*
+* module.exports = flatESLintConfig
+* ```
+*
+* @example
+* <caption>#### __CommonJS (CJS) usage inside a file like `eslint.config.cjs` or `eslint.config.cts` (using dynamic import)__</caption>
+*
+* ```ts
+* module.exports = (async () =>
+*   (await import('@aryaemami59/eslint-config')).flatESLintConfig)()
+* ```
+*
+* @example
+* <caption>#### __CommonJS (CJS) usage inside a file like `eslint.config.cts` (using import and export assignment)__</caption>
+*
+* ```ts
+* import eslintConfigModule = require('@aryaemami59/eslint-config')
+* import flatESLintConfig = eslintConfigModule.flatESLintConfig
+*
+* export = flatESLintConfig
+* ```
+*
+* @since 0.0.3
+* @public
+*/
+const flatESLintConfig = [
+	globalIgnores,
+	{
+		name: `${_eslint_js.default.meta.name}/recommended`,
+		..._eslint_js.default.configs.recommended
+	},
+	{
+		languageOptions: {
+			globals: globals$1,
+			parserOptions: {
+				ecmaVersion: "latest",
+				projectService: true
+			}
+		},
+		linterOptions: {
+			reportUnusedDisableDirectives: 2,
+			reportUnusedInlineConfigs: 2
+		},
+		name: `${name}/defaults/overrides`,
+		rules: {
+			"object-shorthand": [
+				2,
+				"always",
+				{
+					avoidExplicitReturnArrows: true,
+					avoidQuotes: true,
+					ignoreConstructors: true,
+					methodsIgnorePattern: ""
+				}
+			],
+			"sort-imports": [2, {
+				allowSeparatedGroups: true,
+				ignoreCase: false,
+				ignoreDeclarationSort: true,
+				ignoreMemberSort: false,
+				memberSyntaxSortOrder: [
+					"none",
+					"all",
+					"multiple",
+					"single"
+				]
+			}],
+			...disabledRules
+		}
+	},
+	{
+		files: ["**/*.cjs"],
+		languageOptions: { sourceType: "commonjs" },
+		name: `${name}/commonjs-files`,
+		rules: { "@typescript-eslint/no-require-imports": [0, {
+			allow: [],
+			allowAsImport: false
+		}] }
+	},
+	eslint_config_prettier_flat.default
+];
 
-// src/shareableConfigs.ts
-var flatESLintConfig = /* @__PURE__ */ (0, import_typescript_eslint.config)(
-  // `ignores` must be first.
-  // config with just `ignores` is the replacement for `.eslintignore`
-  globalIgnores,
-  {
-    name: `${import_js.default.meta.name}/recommended`,
-    ...import_js.default.configs.recommended
-  },
-  import_typescript_eslint.configs.recommended,
-  import_typescript_eslint.configs.stylistic,
-  {
-    name: `${packageName}/defaults/overrides`,
-    languageOptions: {
-      globals,
-      parserOptions: {
-        ecmaVersion: "latest",
-        projectService: true
-      }
-    },
-    rules: {
-      "@typescript-eslint/consistent-type-imports": [
-        2,
-        {
-          disallowTypeAnnotations: true,
-          fixStyle: "separate-type-imports",
-          prefer: "type-imports"
-        }
-      ],
-      "@typescript-eslint/consistent-type-exports": [
-        2,
-        { fixMixedExportsWithInlineTypeSpecifier: false }
-      ],
-      "@typescript-eslint/no-explicit-any": [
-        2,
-        {
-          fixToUnknown: false,
-          ignoreRestArgs: false
-        }
-      ],
-      "@typescript-eslint/no-empty-object-type": [
-        2,
-        {
-          allowInterfaces: "never",
-          allowObjectTypes: "never"
-        }
-      ],
-      "@typescript-eslint/no-restricted-types": [
-        2,
-        {
-          types: {
-            "{}": {
-              message: `
-- If you want to represent an empty object, use \`type EmptyObject = Record<string, never>\`.
-- If you want to represent an object literal, use either \`type AnyObject = Record<string, any>\` or \`object\`.
-- If you want to represent any non-nullish value, use \`type AnyNonNullishValue = NonNullable<unknown>\`.`,
-              suggest: [
-                "AnyNonNullishValue",
-                "EmptyObject",
-                "AnyObject",
-                "object",
-                "Record<string, never>",
-                "Record<string, any>",
-                "NonNullable<unknown>"
-              ]
-            }
-          }
-        }
-      ],
-      "@typescript-eslint/no-namespace": [
-        2,
-        {
-          allowDeclarations: false,
-          allowDefinitionFiles: true
-        }
-      ],
-      "@typescript-eslint/consistent-type-definitions": [2, "type"],
-      "sort-imports": [
-        2,
-        {
-          allowSeparatedGroups: true,
-          ignoreCase: false,
-          ignoreDeclarationSort: true,
-          ignoreMemberSort: false,
-          memberSyntaxSortOrder: ["none", "all", "multiple", "single"]
-        }
-      ],
-      "@typescript-eslint/unified-signatures": [
-        2,
-        {
-          ignoreDifferentlyNamedParameters: false,
-          ignoreOverloadsWithDifferentJSDoc: false
-        }
-      ],
-      "@typescript-eslint/no-unnecessary-type-parameters": [2],
-      "@typescript-eslint/no-invalid-void-type": [
-        2,
-        {
-          allowAsThisParameter: false,
-          allowInGenericTypeArguments: true
-        }
-      ],
-      "@typescript-eslint/no-confusing-void-expression": [
-        2,
-        {
-          ignoreArrowShorthand: false,
-          ignoreVoidOperator: false,
-          ignoreVoidReturningFunctions: false
-        }
-      ],
-      "@typescript-eslint/no-duplicate-type-constituents": [
-        2,
-        {
-          ignoreIntersections: false,
-          ignoreUnions: false
-        }
-      ],
-      "@typescript-eslint/require-await": [2],
-      "@typescript-eslint/no-redundant-type-constituents": [2],
-      "@typescript-eslint/no-unnecessary-type-arguments": [2],
-      "@typescript-eslint/no-unnecessary-type-assertion": [
-        2,
-        { typesToIgnore: [] }
-      ],
-      "@typescript-eslint/prefer-nullish-coalescing": [
-        2,
-        {
-          allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: false,
-          ignoreBooleanCoercion: false,
-          ignoreConditionalTests: true,
-          ignoreIfStatements: false,
-          ignoreMixedLogicalExpressions: false,
-          ignorePrimitives: {
-            bigint: false,
-            boolean: false,
-            number: false,
-            string: false
-          },
-          ignoreTernaryTests: false
-        }
-      ],
-      "@typescript-eslint/no-inferrable-types": [
-        2,
-        {
-          ignoreParameters: false,
-          ignoreProperties: false
-        }
-      ],
-      "@typescript-eslint/no-require-imports": [
-        2,
-        {
-          allow: [],
-          allowAsImport: true
-        }
-      ],
-      "object-shorthand": [
-        2,
-        "always",
-        {
-          avoidExplicitReturnArrows: true,
-          avoidQuotes: true,
-          ignoreConstructors: true,
-          methodsIgnorePattern: ""
-        }
-      ],
-      ...disabledRules
-    },
-    linterOptions: {
-      reportUnusedDisableDirectives: 2
-    }
-  },
-  {
-    name: `${packageName}/commonjs-files`,
-    files: ["**/*.cjs"],
-    languageOptions: {
-      sourceType: "commonjs"
-    },
-    rules: {
-      "@typescript-eslint/no-require-imports": [
-        0,
-        {
-          allow: [],
-          allowAsImport: false
-        }
-      ]
-    }
-  },
-  import_flat.default
-);
+//#endregion
+//#region src/utils.ts
+/**
+* A function that returns {@linkcode flatESLintConfig}
+* along with optional additional overrides.
+* It's made mainly to provide intellisense and eliminate
+* the need for manual type annotations using JSDoc comments.
+*
+* @param [additionalOverrides=[]] - **Optional** additional overrides to apply to the configuration.
+* @returns An augmented version of the default {@linkcode flatESLintConfig}, incorporating any provided overrides.
+*
+* @example
+* <caption>#### __ECMAScript Modules (ESM) usage inside a file like `eslint.config.mts` or `eslint.config.mjs`__</caption>
+*
+* ```ts
+* import { createESLintConfig } from '@aryaemami59/eslint-config'
+*
+* export default createESLintConfig([
+*   {
+*     rules: {
+*       'no-console': [0],
+*     },
+*   },
+*   {
+*     // ...Other additional overrides
+*   },
+* ])
+* ```
+*
+* @example
+* <caption>#### __CommonJS (CJS) usage inside a file like `eslint.config.cts` or `eslint.config.cjs` (using `require`)__</caption>
+*
+* ```ts
+* const { createESLintConfig } = require('@aryaemami59/eslint-config')
+*
+* module.exports = createESLintConfig([
+*   {
+*     rules: {
+*       'no-console': [0],
+*     },
+*   },
+*   {
+*     // ...Other additional overrides
+*   },
+* ])
+* ```
+*
+* @example
+* <caption>#### __CommonJS (CJS) usage inside a file like `eslint.config.cts` or `eslint.config.cjs` (using dynamic import)__</caption>
+*
+* ```ts
+* module.exports = (async () =>
+*   (await import('@aryaemami59/eslint-config')).createESLintConfig([
+*     {
+*       rules: {
+*         'no-console': [0],
+*       },
+*     },
+*     {
+*       // ...Other additional overrides
+*     },
+*   ]))()
+* ```
+*
+* @example
+* <caption>#### __CommonJS (CJS) usage inside a file like `eslint.config.cts` (using import and export assignment)__</caption>
+*
+* ```ts
+* import eslintConfigModule = require('@aryaemami59/eslint-config')
+* import createESLintConfig = eslintConfigModule.createESLintConfig
+*
+* export = createESLintConfig([
+*   {
+*     rules: {
+*       'no-console': [0],
+*     },
+*   },
+*   {
+*     // ...Other additional overrides
+*   },
+* ])
+* ```
+*
+* @since 0.0.3
+* @public
+*/
+const createESLintConfig = (additionalOverrides = []) => /* @__PURE__ */ (0, eslint_config.defineConfig)(...flatESLintConfig, ...additionalOverrides);
 
-// src/utils.ts
-var createESLintConfig = (additionalOverrides = []) => /* @__PURE__ */ (0, import_typescript_eslint.config)(...flatESLintConfig, ...additionalOverrides);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  config,
-  configs,
-  createESLintConfig,
-  disabledRules,
-  flatESLintConfig,
-  globalIgnores,
-  globals,
-  js,
-  parser,
-  plugin,
-  prettierConfig,
-  vitestGlobals
+//#endregion
+Object.defineProperty(exports, 'config', {
+  enumerable: true,
+  get: function () {
+    return typescript_eslint.config;
+  }
+});
+Object.defineProperty(exports, 'configs', {
+  enumerable: true,
+  get: function () {
+    return typescript_eslint.configs;
+  }
+});
+exports.createESLintConfig = createESLintConfig;
+Object.defineProperty(exports, 'defineConfig', {
+  enumerable: true,
+  get: function () {
+    return eslint_config.defineConfig;
+  }
+});
+exports.disabledRules = disabledRules;
+exports.flatESLintConfig = flatESLintConfig;
+exports.globalIgnores = globalIgnores;
+exports.globals = globals$1;
+exports.js = _eslint_js.default;
+Object.defineProperty(exports, 'parser', {
+  enumerable: true,
+  get: function () {
+    return typescript_eslint.parser;
+  }
+});
+Object.defineProperty(exports, 'plugin', {
+  enumerable: true,
+  get: function () {
+    return typescript_eslint.plugin;
+  }
 });
+exports.prettierConfig = eslint_config_prettier_flat.default;
+exports.vitestGlobals = vitestGlobals;
 //# sourceMappingURL=index.cjs.map