@storm-software/eslint 0.170.155 → 0.170.156

package/dist/preset.js

@@ -1,8 +1,344 @@
-export { preset_default as default, defaultPluginRenaming, defineConfig, getConfig, getOverrides, preset, resolveSubOptions } from './chunk-XSM4AYON.js';
-import './chunk-Y5JY2DPL.js';
-import './chunk-F7ZJ6N35.js';
-import './chunk-T6GDWDAB.js';
-import './chunk-XFFMMX6A.js';
-import './chunk-I4ZWVHOG.js';
-import './chunk-JBIA43L4.js';
-import './chunk-2TYJ2VM7.js';
+import { FlatConfigComposer } from 'eslint-flat-config-utils';
+import { isPackageExists } from 'local-pkg';
+import { ignores, javascript, node, imports, nx, perfectionist, secrets, typescript, banner, prettier, cspell, unicorn, jsdoc, tsdoc, jsx, zod, stylistic, regexp, test, graphql, react, reactNative, next, storybook, unocss, astro, pnpm, jsonc, sortTsconfig, sortPackageJson, yaml, toml, markdown, mdx, formatters, disables } from './configs';
+import { isInEditorEnv, interopDefault } from './utils/helpers';
+import { getTsConfigPath } from './utils/tsconfig';
+import { detectPackageManager } from './utils/package-manager';
+import { bun } from './configs/bun';
+
+const flatConfigProps = [
+  "name",
+  "languageOptions",
+  "linterOptions",
+  "processor",
+  "plugins",
+  "rules",
+  "settings"
+];
+const defaultPluginRenaming = {
+  "@eslint-react": "react",
+  "@eslint-react/dom": "react-dom",
+  "@eslint-react/hooks-extra": "react-hooks-extra",
+  "@eslint-react/naming-convention": "react-naming-convention",
+  "@stylistic": "style",
+  "@typescript-eslint": "ts",
+  "import-x": "import",
+  n: "node",
+  vitest: "test",
+  yml: "yaml"
+};
+function resolveSubOptions(options, key) {
+  return typeof options[key] === "boolean" ? {} : options[key] || {};
+}
+function getOverrides(options, key) {
+  const sub = resolveSubOptions(options, key);
+  return "overrides" in sub ? sub.overrides : {};
+}
+function preset(options, ...userConfigs) {
+  const {
+    name,
+    globals = {},
+    banner: enableBanner = true,
+    astro: enableAstro = false,
+    autoRenamePlugins = true,
+    componentExts = [],
+    gitignore: enableGitignore = true,
+    jsx: enableJsx = true,
+    mdx: enableMdx = false,
+    cspell: enableCSpell = true,
+    react: enableReact = false,
+    "react-native": enableReactNative = false,
+    regexp: enableRegexp = true,
+    next: enableNext = false,
+    graphql: enableGraphQL = false,
+    storybook: enableStorybook = false,
+    typescript: enableTypeScript = isPackageExists("typescript"),
+    unicorn: enableUnicorn = true,
+    jsdoc: enableJSDoc = false,
+    tsdoc: enableTSDoc = true,
+    test: enableTest = true,
+    unocss: enableUnoCSS = false,
+    zod: enableZod = false,
+    bun: enableBun,
+    pnpm: enablePnpm
+  } = options;
+  const packageManager = detectPackageManager();
+  let isInEditor = options.isInEditor;
+  if (!isInEditor) {
+    isInEditor = isInEditorEnv();
+    if (isInEditor) {
+      console.log(
+        "[@storm-software/eslint] Detected running in editor, some rules are disabled."
+      );
+    }
+  }
+  const stylisticOptions = !options.stylistic ? false : typeof options.stylistic === "object" ? options.stylistic : {};
+  if (stylisticOptions && !("jsx" in stylisticOptions)) {
+    stylisticOptions.jsx = enableJsx;
+  }
+  const configs = [];
+  if (enableGitignore) {
+    if (typeof enableGitignore !== "boolean") {
+      configs.push(
+        interopDefault(import('eslint-config-flat-gitignore')).then((r) => [
+          r({
+            name: "storm/gitignore",
+            ...enableGitignore
+          })
+        ])
+      );
+    } else {
+      configs.push(
+        interopDefault(import('eslint-config-flat-gitignore')).then((r) => [
+          r({
+            name: "storm/gitignore",
+            strict: false
+          })
+        ])
+      );
+    }
+  }
+  configs.push(
+    ignores(options.ignores),
+    javascript({
+      globals,
+      isInEditor,
+      overrides: getOverrides(options, "javascript")
+    }),
+    node(),
+    imports({
+      stylistic: stylisticOptions
+    }),
+    nx(resolveSubOptions(options, "nx")),
+    perfectionist(),
+    secrets({ json: options.jsonc !== false })
+  );
+  let typescriptOptions = {};
+  if (enableTypeScript) {
+    typescriptOptions = resolveSubOptions(options, "typescript");
+    if (typescriptOptions.tsconfigPath !== false) {
+      typescriptOptions.tsconfigPath = getTsConfigPath(
+        typescriptOptions.tsconfigPath,
+        options.type
+      );
+    }
+  }
+  if (enableTypeScript) {
+    configs.push(
+      typescript({
+        ...typescriptOptions,
+        tsconfigPath: typescriptOptions.tsconfigPath === false ? void 0 : typescriptOptions.tsconfigPath,
+        componentExts,
+        overrides: getOverrides(options, "typescript"),
+        type: options.type
+      })
+    );
+  }
+  if (enableBanner) {
+    configs.push(
+      banner({
+        ...resolveSubOptions(options, "banner"),
+        name,
+        overrides: getOverrides(options, "banner")
+      })
+    );
+  }
+  if (!stylisticOptions) {
+    configs.push(prettier());
+  }
+  if (enableCSpell) {
+    configs.push(cspell(resolveSubOptions(options, "cspell")));
+  }
+  if (enableUnicorn) {
+    configs.push(unicorn(enableUnicorn === true ? {} : enableUnicorn));
+  }
+  if (enableJSDoc) {
+    configs.push(
+      jsdoc({
+        ...resolveSubOptions(options, "jsdoc"),
+        overrides: getOverrides(options, "jsdoc")
+      })
+    );
+  }
+  if (enableTSDoc) {
+    configs.push(
+      tsdoc({
+        ...resolveSubOptions(options, "tsdoc"),
+        overrides: getOverrides(options, "tsdoc")
+      })
+    );
+  }
+  if (enableJsx) {
+    configs.push(jsx());
+  }
+  if (enableZod) {
+    configs.push(
+      zod({
+        overrides: getOverrides(options, "zod")
+      })
+    );
+  }
+  if (stylisticOptions) {
+    configs.push(
+      stylistic({
+        ...stylisticOptions,
+        lineEndings: stylisticOptions.lineEndings ?? "unix",
+        lessOpinionated: options.lessOpinionated,
+        overrides: getOverrides(options, "stylistic")
+      })
+    );
+  }
+  if (enableRegexp) {
+    configs.push(regexp(typeof enableRegexp === "boolean" ? {} : enableRegexp));
+  }
+  if (enableTest) {
+    configs.push(
+      test({
+        isInEditor,
+        overrides: getOverrides(options, "test")
+      })
+    );
+  }
+  if (enableGraphQL) {
+    configs.push(graphql(resolveSubOptions(options, "graphql")));
+  }
+  if (enableReact) {
+    configs.push(
+      react({
+        ...typescriptOptions,
+        tsconfigPath: typescriptOptions.tsconfigPath === false ? void 0 : typescriptOptions.tsconfigPath,
+        ...typeof enableReact === "boolean" ? { strict: false } : enableReact,
+        overrides: getOverrides(options, "react")
+      })
+    );
+  }
+  if (enableReactNative) {
+    configs.push(
+      reactNative({
+        ...resolveSubOptions(options, "react-native"),
+        overrides: getOverrides(options, "react-native")
+      })
+    );
+  }
+  if (enableNext) {
+    configs.push(next(resolveSubOptions(options, "next")));
+  }
+  if (enableStorybook) {
+    configs.push(storybook(resolveSubOptions(options, "storybook")));
+  }
+  if (enableUnoCSS) {
+    configs.push(
+      unocss({
+        ...resolveSubOptions(options, "unocss"),
+        overrides: getOverrides(options, "unocss")
+      })
+    );
+  }
+  if (enableAstro) {
+    configs.push(
+      astro({
+        overrides: getOverrides(options, "astro"),
+        stylistic: stylisticOptions
+      })
+    );
+  }
+  if (enablePnpm ?? packageManager !== "bun") {
+    configs.push(
+      pnpm({
+        overrides: getOverrides(options, "pnpm"),
+        ignore: typeof enablePnpm !== "boolean" ? enablePnpm?.ignore : void 0
+      })
+    );
+  }
+  if (enableBun ?? packageManager === "bun") {
+    configs.push(bun({
+      overrides: getOverrides(options, "bun"),
+      ignore: typeof enableBun !== "boolean" ? enableBun?.ignore : void 0
+    }));
+  }
+  if (options.jsonc ?? true) {
+    configs.push(
+      jsonc({
+        overrides: getOverrides(options, "jsonc"),
+        stylistic: stylisticOptions
+      }),
+      sortTsconfig()
+    );
+    if (stylisticOptions) {
+      configs.push(sortPackageJson());
+    }
+  }
+  if (options.yaml ?? true) {
+    configs.push(
+      yaml({
+        overrides: getOverrides(options, "yaml"),
+        stylistic: stylisticOptions
+      })
+    );
+  }
+  if (options.toml ?? true) {
+    configs.push(
+      toml({
+        overrides: getOverrides(options, "toml"),
+        stylistic: stylisticOptions
+      })
+    );
+  }
+  if (options.markdown === true) {
+    configs.push(
+      markdown({
+        componentExts,
+        overrides: getOverrides(options, "markdown")
+      })
+    );
+  }
+  if (enableMdx) {
+    configs.push(
+      mdx({
+        overrides: getOverrides(options, "mdx")
+      })
+    );
+  }
+  if (options.formatters) {
+    configs.push(
+      formatters(
+        options.formatters,
+        typeof stylisticOptions === "boolean" ? {} : stylisticOptions
+      )
+    );
+  }
+  configs.push(disables());
+  if ("files" in options) {
+    throw new Error(
+      '[@storm-software/eslint] The first argument should not contain the "files" property as the options are supposed to be global. Place it in the second or later config instead.'
+    );
+  }
+  const fusedConfig = flatConfigProps.reduce((acc, key) => {
+    if (key in options) {
+      acc[key] = options[key];
+    }
+    return acc;
+  }, {});
+  if (Object.keys(fusedConfig).length) configs.push([fusedConfig]);
+  let composer = new FlatConfigComposer();
+  composer = composer.append(
+    ...configs,
+    ...userConfigs
+  );
+  if (autoRenamePlugins) {
+    composer = composer.renamePlugins(defaultPluginRenaming);
+  }
+  if (isInEditor) {
+    composer = composer.disableRulesFix(["test/no-only-tests"], {
+      builtinRules: () => import(["eslint", "use-at-your-own-risk"].join("/")).then(
+        (r) => r.builtinRules
+      )
+    });
+  }
+  return composer;
+}
+const getConfig = preset;
+const defineConfig = preset;
+var preset_default = preset;
+
+export { preset_default as default, defaultPluginRenaming, defineConfig, getConfig, getOverrides, preset, resolveSubOptions };

package/dist/types.cjs

@@ -1,2 +1,12 @@
 'use strict';
 
+var typegen_d = require('./typegen.d');
+
+
+
+Object.keys(typegen_d).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return typegen_d[k]; }
+	});
+});

package/dist/types.js

@@ -1,4 +1 @@
-import { init_esm_shims } from './chunk-2TYJ2VM7.js';
-
-// src/types.ts
-init_esm_shims();
+export * from './typegen.d';

package/dist/utils/combine.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-// src/utils/combine.ts
 async function combine(...configs) {
   const resolved = await Promise.all(configs);
   return resolved.flat();

package/dist/utils/combine.js

@@ -1,7 +1,3 @@
-import { init_esm_shims } from '../chunk-2TYJ2VM7.js';
-
-// src/utils/combine.ts
-init_esm_shims();
 async function combine(...configs) {
   const resolved = await Promise.all(configs);
   return resolved.flat();

package/dist/utils/correct-paths.cjs

@@ -1,21 +1,20 @@
 'use strict';
 
-// src/utils/correct-paths.ts
-var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
   if (!input) {
     return input;
   }
   return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
-var _UNC_REGEX = /^[/\\]{2}/;
-var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-var _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-var _EXTNAME_RE = /.(\.[^./]+|\.)$/;
-var _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
-var sep = "/";
-var correctPaths = function(path) {
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const sep = "/";
+const correctPaths = function(path) {
   if (!path || path.length === 0) {
     return ".";
   }
@@ -44,7 +43,7 @@ var correctPaths = function(path) {
   }
   return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
 };
-var joinPaths = function(...segments) {
+const joinPaths = function(...segments) {
   let path = "";
   for (const seg of segments) {
     if (!seg) {
@@ -71,7 +70,7 @@ function cwd() {
   }
   return "/";
 }
-var resolve = function(...arguments_) {
+const resolve = function(...arguments_) {
   arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
   let resolvedPath = "";
   let resolvedAbsolute = false;
@@ -148,18 +147,18 @@ function normalizeString(path, allowAboveRoot) {
   }
   return res;
 }
-var isAbsolute = function(p) {
+const isAbsolute = function(p) {
   return _IS_ABSOLUTE_RE.test(p);
 };
-var toNamespacedPath = function(p) {
+const toNamespacedPath = function(p) {
   return normalizeWindowsPath(p);
 };
-var extname = function(p) {
+const extname = function(p) {
   if (p === "..") return "";
   const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
   return match && match[1] || "";
 };
-var relative = function(from, to) {
+const relative = function(from, to) {
   const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
   const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
   if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) {
@@ -175,14 +174,14 @@ var relative = function(from, to) {
   }
   return [..._from.map(() => ".."), ..._to].join("/");
 };
-var dirname = function(p) {
+const dirname = function(p) {
   const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
   if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
     segments[0] += "/";
   }
   return segments.join("/") || (isAbsolute(p) ? "/" : ".");
 };
-var format = function(p) {
+const format = function(p) {
   const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
   const segments = [p.root, p.dir, p.base ?? (p.name ?? "") + ext].filter(
     Boolean
@@ -191,7 +190,7 @@ var format = function(p) {
     p.root ? resolve(...segments) : segments.join("/")
   );
 };
-var basename = function(p, extension) {
+const basename = function(p, extension) {
   const segments = normalizeWindowsPath(p).split("/");
   let lastSegment = "";
   for (let i = segments.length - 1; i >= 0; i--) {
@@ -203,7 +202,7 @@ var basename = function(p, extension) {
   }
   return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
 };
-var parse = function(p) {
+const parse = function(p) {
   const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
   const base = basename(p);
   const extension = extname(base);