@jsse/eslint-config 0.3.7 → 0.4.1

package/dist/esm/plugins.js

@@ -1,4 +1,3 @@
-import { err, ok } from "neverthrow";
 /* eslint-disable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/explicit-function-return-type */
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-nocheck
@@ -8,9 +7,11 @@ export { default as pluginEslintComments } from "@eslint-community/eslint-plugin
 export { default as pluginTs } from "@typescript-eslint/eslint-plugin";
 export * as parserTs from "@typescript-eslint/parser";
 export { default as pluginAntfu } from "eslint-plugin-antfu";
+export { default as pluginDeMorgan } from "eslint-plugin-de-morgan";
 export * as pluginImport from "eslint-plugin-import-x";
 export { default as pluginN } from "eslint-plugin-n";
 export { default as pluginPerfectionist } from "eslint-plugin-perfectionist";
+export { default as pluginPnpm } from "eslint-plugin-pnpm";
 export { default as pluginUnicorn } from "eslint-plugin-unicorn";
 export { default as pluginUnusedImports } from "eslint-plugin-unused-imports";
 export async function importPluginUnicorn() {
@@ -94,18 +95,3 @@ export async function importPluginStylistic() {
     const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
     return { pluginStylistic };
 }
-export async function importPluginTailwind() {
-    const pluginTailwind = await interopDefault(
-    // @ts-expect-error - bad types
-    import("eslint-plugin-tailwindcss"));
-    return { pluginTailwind };
-}
-export async function safeImportPluginTailwind() {
-    try {
-        const plugin = await importPluginTailwind();
-        return ok(plugin);
-    }
-    catch (e) {
-        return err(new Error(`Failed to import \`eslint-plugin-tailwindcss\`. You might need to install it. ${e}`));
-    }
-}

package/dist/esm/presets.d.ts

@@ -1,2 +1,18 @@
+import type { Config } from "./types.js";
 import { type DefineConfig } from "./define-config.js";
 export declare const jsseReact: DefineConfig;
+/** Ignore common files and include javascript support */
+export declare const presetJavascript: () => Promise<Config[]>;
+/** Includes markdown, yaml + `presetJsonc` support */
+export declare const presetLangsExtensions: () => Promise<Config[]>;
+/** Includes `presetJavaScript` and typescript support */
+export declare const presetBasic: () => Promise<Config[]>;
+/**
+ * Includes
+ * - `presetBasic` (JS+TS) support
+ * - `presetLangsExtensions` (markdown, yaml, jsonc) support
+ * - Vue support
+ * - UnoCSS support (`uno.config.ts` is required)
+ * - Prettier support
+ */
+export declare const presetAll: () => Promise<Config[]>;

package/dist/esm/presets.js

@@ -1,12 +1,75 @@
+import { command, eslintComments, ignores, imports, javascript, jsdoc, jsonc, markdown, n, sortPackageJson, sortTsconfig, typescript, unicorn, yml, } from "./config-fns.js";
+import { deMorgan } from "./configs/de-morgan.js";
 import { jsse } from "./define-config.js";
+const makePresetFn = (cfgFunctions) => {
+    return async () => {
+        const results = await Promise.allSettled(cfgFunctions.map((fn) => fn()));
+        const ok = [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const err = [];
+        for (const result of results) {
+            if (result.status === "fulfilled") {
+                ok.push(...result.value);
+            }
+            else {
+                err.push(result.reason);
+            }
+        }
+        if (err.length > 0) {
+            const errorMessage = `Some preset functions failed: ${err
+                .map((e) => {
+                return e instanceof Error ? e.message : JSON.stringify(e);
+            })
+                .join(", ")}`;
+            throw new Error(errorMessage);
+        }
+        return ok;
+    };
+};
 export const jsseReact = (options, ...configs) => {
     return jsse({
         react: true,
         reactRefresh: true,
-        tailwind: true,
         typescript: {
             tsconfig: ["./tsconfig.json", "./tsconfig.eslint.json"],
         },
         ...options,
-    }, ...configs);
+    }, 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    ...configs);
 };
+/** Ignore common files and include javascript support */
+export const presetJavascript = makePresetFn([
+    ignores,
+    javascript,
+    eslintComments,
+    imports,
+    unicorn,
+    n,
+    jsdoc,
+    deMorgan,
+]);
+/** Includes basic json(c) file support and sorting json keys */
+const presetJsonc = makePresetFn([
+    jsonc,
+    sortPackageJson,
+    sortTsconfig,
+    // ...sortPnpmWorkspace(),
+]);
+/** Includes markdown, yaml + `presetJsonc` support */
+export const presetLangsExtensions = makePresetFn([markdown, yml, presetJsonc]);
+/** Includes `presetJavaScript` and typescript support */
+export const presetBasic = makePresetFn([presetJavascript, typescript]);
+/**
+ * Includes
+ * - `presetBasic` (JS+TS) support
+ * - `presetLangsExtensions` (markdown, yaml, jsonc) support
+ * - Vue support
+ * - UnoCSS support (`uno.config.ts` is required)
+ * - Prettier support
+ */
+export const presetAll = makePresetFn([
+    presetBasic,
+    presetLangsExtensions,
+    command,
+]);

package/dist/esm/types.d.ts

@@ -1,16 +1,8 @@
 import type { ParserOptions } from "@typescript-eslint/parser";
 import type { Linter } from "eslint";
 import type { FlatGitignoreOptions } from "eslint-config-flat-gitignore";
-import type { RuleOptionsUnion as RuleOptions } from "./generated/rule-options.js";
-export type Awaitable<T> = T | Promise<T>;
-export type UnPromise<T> = T extends Promise<infer U> ? U : T;
-export type Rules = RuleOptions;
-export type LanguageOptions = Linter.Config["languageOptions"];
-export type TypedFlatConfigItem = Omit<Linter.Config<Linter.RulesRecord & Rules>, "plugins"> & {
-    /**
-     * Custom name of each config item
-     */
-    name?: string;
+import type { RuleOptionsUnion as Rules } from "./generated/rule-options.js";
+export type Config = Omit<Linter.Config<Linter.RulesRecord & Rules>, "plugins"> & {
     /**
      * An object containing a name-value mapping of plugin names to plugin objects. When `files` is specified, these plugins are only available to the matching files.
      *
@@ -18,8 +10,11 @@ export type TypedFlatConfigItem = Omit<Linter.Config<Linter.RulesRecord & Rules>
      */
     plugins?: Record<string, any>;
 };
+export type Awaitable<T> = T | Promise<T>;
+export type UnPromise<T> = T extends Promise<infer U> ? U : T;
+export type LanguageOptions = Linter.Config["languageOptions"];
 export type RuleName = keyof Rules;
-export type TypedFlatConfigItemWithId = TypedFlatConfigItem & {
+export type TypedFlatConfigItemWithId = Config & {
     name: string;
 };
 export type OptionsCommon = {
@@ -46,8 +41,7 @@ export type OptionsComponentExts = {
      */
     componentExts?: string[];
 };
-export type PromiseFlatConfigItem = Promise<TypedFlatConfigItemWithId[]>;
-export type EslintConfigFn<T = undefined> = (options?: T) => PromiseFlatConfigItem;
+export type EslintConfigFn<T = undefined> = (options?: T) => Promise<Config[]>;
 export type OptionsFiles = {
     /**
      * Override the `files` option to provide custom globs.
@@ -83,6 +77,18 @@ export type OptionsTypeScriptWithTypes = {
      * @see https://typescript-eslint.io/linting/typed-linting/
      */
     tsconfig?: string | string[];
+    /**
+     * Override type aware rules.
+     */
+    overridesTypeAware?: Config["rules"];
+    /**
+     * strict vs recommended configs
+     * @default false
+     */
+    strict?: boolean;
+    /**
+     * typeAware
+     */
     typeAware?: boolean;
 };
 export type OptionsTypescript = (OptionsTypeScriptWithTypes & OptionsOverrides) | (OptionsTypeScriptParserOptions & OptionsOverrides);
@@ -104,7 +110,7 @@ export type OptionsPrefix = {
     };
 };
 export type OptionsOverrides = {
-    overrides?: TypedFlatConfigItem["rules"];
+    overrides?: Config["rules"];
 };
 export type OptionsIsInEditor = {
     isInEditor?: boolean;
@@ -167,6 +173,19 @@ export type OptionsConfig = {
      * PLUGIN!.
      */
     prettier?: boolean;
+    /**
+     * Enable eslint-plugin-pnpm.
+     *
+     * @default false
+     */
+    pnpm?: boolean;
+    /**
+     * Enable Tailwind CSS support.
+     *
+     * Passing an object to configure the options.
+     *
+     * @default true
+     */
     tailwind?: TailwindOptions;
     /**
      * The prefix for the name of the config item.
@@ -176,7 +195,7 @@ export type OptionsConfig = {
     /**
      * Optional function to run before the final config is returned.
      */
-    preReturn?: (configs: TypedFlatConfigItem[]) => TypedFlatConfigItem[] | Awaitable<TypedFlatConfigItem[]>;
+    preReturn?: (configs: Config[]) => Config[] | Awaitable<Config[]>;
     /**
      * Enable gitignore support.
      *
@@ -189,9 +208,11 @@ export type OptionsConfig = {
     tsPrefix?: string;
     /**
      * Glob patterns for ADDITIONAL tsconfig files to lint (aka sort)
+     *
+     * Has nothing to do with `@typescript-eslint/parser` or `typescript-eslint/eslint-plugin`
+     * @default ['tsconfig.json', 'tsconfig.*.json']
      */
     extendTsconfigLintGlobs?: string[];
-    typeAware?: boolean;
     /**
      * Enable TypeScript support.
      *
@@ -200,6 +221,10 @@ export type OptionsConfig = {
      * @default auto-detect based on the dependencies
      */
     typescript?: boolean | OptionsTypeScriptWithTypes;
+    /**
+     * Forcibly disable type aware rules
+     */
+    typeAware?: boolean;
     react?: boolean;
     reactRefresh?: boolean;
     /**
@@ -249,12 +274,12 @@ export type OptionsConfig = {
      * Provide overrides for rules for each integration.
      */
     overrides?: {
-        javascript?: TypedFlatConfigItem["rules"];
-        typescript?: TypedFlatConfigItem["rules"];
-        test?: TypedFlatConfigItem["rules"];
-        jsonc?: TypedFlatConfigItem["rules"];
-        markdown?: TypedFlatConfigItem["rules"];
-        yaml?: TypedFlatConfigItem["rules"];
+        javascript?: Config["rules"];
+        typescript?: Config["rules"];
+        test?: Config["rules"];
+        jsonc?: Config["rules"];
+        markdown?: Config["rules"];
+        yaml?: Config["rules"];
     };
 } & OptionsComponentExts & OptionsTypeScriptParserOptions;
 export type RenamePefix<T extends Record<string, unknown>, FromPref extends string, ToPref extends string> = {

package/dist/esm/utils.d.ts

@@ -1,9 +1,9 @@
 import type { Linter } from "eslint";
-import type { Awaitable, TypedFlatConfigItem } from "./types.js";
+import type { Awaitable, Config } from "./types.js";
 /**
  * Combine array and non-array configs into a single array.
  */
-export declare function combine(...configs: Awaitable<TypedFlatConfigItem | TypedFlatConfigItem[]>[]): Promise<TypedFlatConfigItem[]>;
+export declare function combine(...configs: Awaitable<Config | Config[]>[]): Promise<Config[]>;
 /**
  * Combine array and non-array configs into a single array.
  */
@@ -45,7 +45,7 @@ export declare const parserPlain: {
         };
     };
 };
-export declare function turnOffRules(configs: TypedFlatConfigItem[], off: string[]): TypedFlatConfigItem[];
+export declare function turnOffRules(configs: Config[], off: string[]): Config[];
 export declare function changeRuleEntrySeverity(ruleConfig: Linter.RuleEntry<any>, level: Linter.RuleSeverity): Linter.RuleEntry<any>;
-export declare function error2warn<T extends TypedFlatConfigItem>(configs: T[]): T[];
-export declare function warn2error<T extends TypedFlatConfigItem>(configs: T[]): T[];
+export declare function error2warn<T extends Config>(configs: T[]): T[];
+export declare function warn2error<T extends Config>(configs: T[]): T[];

package/dist/esm/utils.js

@@ -76,7 +76,7 @@ export const parserPlain = {
     }),
 };
 export function turnOffRules(configs, off) {
-    if (off && off.length > 0) {
+    if (off.length > 0) {
         // turrning off rules
         // duplicate off rules
         for (const rule of off) {