@jsse/eslint-config 0.4.9 → 0.4.11

package/dist/esm/plugins.js

@@ -1,97 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment,@typescript-eslint/explicit-function-return-type */
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-import { interopDefault } from "./utils.js";
-// @ts-expect-error - bad types
-export { default as pluginEslintComments } from "@eslint-community/eslint-plugin-eslint-comments";
-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 { default as pluginImportLite } from "eslint-plugin-import-lite";
-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() {
-    const pluginUnicorn = await interopDefault(import("eslint-plugin-unicorn"));
-    return {
-        pluginUnicorn,
-    };
-}
-export async function importPluginReact() {
-    const pluginReact = await interopDefault(import("eslint-plugin-react"));
-    return {
-        pluginReact,
-    };
-}
-export async function importPluginReactHooks() {
-    const pluginReactHooks = await interopDefault(import("eslint-plugin-react-hooks"));
-    return {
-        pluginReactHooks,
-    };
-}
-export async function importPluginReactRefresh() {
-    const pluginReactRefresh = await interopDefault(import("eslint-plugin-react-refresh"));
-    return {
-        pluginReactRefresh,
-    };
-}
-export async function importReactPlugins() {
-    const [pluginReact, pluginReactHooks, pluginReactRefresh] = await Promise.all([
-        interopDefault(import("eslint-plugin-react")),
-        interopDefault(import("eslint-plugin-react-hooks")),
-        interopDefault(import("eslint-plugin-react-refresh")),
-    ]);
-    return { pluginReact, pluginReactHooks, pluginReactRefresh };
-}
-export async function importParserJsonc() {
-    const parserJsonc = await interopDefault(import("jsonc-eslint-parser"));
-    return {
-        parserJsonc,
-    };
-}
-export async function importPluginJsonc() {
-    const pluginJsonc = await interopDefault(import("eslint-plugin-jsonc"));
-    return {
-        pluginJsonc,
-    };
-}
-export async function importJsoncLibs() {
-    const [{ parserJsonc }, { pluginJsonc }] = await Promise.all([
-        importParserJsonc(),
-        importPluginJsonc(),
-    ]);
-    return { parserJsonc, pluginJsonc };
-}
-export async function importYmlLibs() {
-    const [pluginYaml, parserYaml] = await Promise.all([
-        interopDefault(import("eslint-plugin-yml")),
-        interopDefault(import("yaml-eslint-parser")),
-    ]);
-    return { parserYaml, pluginYaml };
-}
-export async function importPluginMarkdown() {
-    const pluginMarkdown = await interopDefault(import("@eslint/markdown"));
-    return {
-        pluginMarkdown,
-    };
-}
-export async function importPluginJsdoc() {
-    const pluginJsdoc = await interopDefault(import("eslint-plugin-jsdoc"));
-    // get the import path
-    return {
-        pluginJsdoc,
-    };
-}
-export async function importPluginTsdoc() {
-    const pluginTsdoc = (await interopDefault(import("eslint-plugin-tsdoc")));
-    return {
-        pluginTsdoc,
-    };
-}
-export async function importPluginStylistic() {
-    const pluginStylistic = await interopDefault(import("@stylistic/eslint-plugin"));
-    return { pluginStylistic };
-}

package/dist/esm/presets.d.ts

@@ -1,18 +0,0 @@
-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,75 +0,0 @@
-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,
-        typescript: {
-            tsconfig: ["./tsconfig.json", "./tsconfig.eslint.json"],
-        },
-        ...options,
-    }, 
-    // 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,287 +0,0 @@
-import type { ParserOptions } from "@typescript-eslint/parser";
-import type { Linter } from "eslint";
-import type { FlatGitignoreOptions } from "eslint-config-flat-gitignore";
-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.
-     *
-     * @see [Using plugins in your configuration](https://eslint.org/docs/latest/user-guide/configuring/configuration-files-new#using-plugins-in-your-configuration)
-     */
-    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 = Config & {
-    name: string;
-};
-export type OptionsCommon = {
-    debug?: boolean;
-    /**
-     * The prefix for the name of the config item.
-     *
-     * @default "jsse"
-     */
-    rootName?: string;
-    /**
-     * Type of the project. `lib` will enable more strict rules for libraries.
-     *
-     * @default 'lib'
-     */
-    type?: "app" | "lib";
-};
-export type OptionsComponentExts = {
-    /**
-     * Additional extensions for components.
-     *
-     * @example ['vue']
-     * @default []
-     */
-    componentExts?: string[];
-};
-export type EslintConfigFn<T = undefined> = (options?: T) => Promise<Config[]>;
-export type OptionsFiles = {
-    /**
-     * Override the `files` option to provide custom globs.
-     */
-    files?: string[];
-};
-export type OptionsTypeScriptParserOptions = {
-    /**
-     * Additional parser options for TypeScript.
-     */
-    parserOptions?: Partial<ParserOptions>;
-    /**
-     * Flag to use `projectService` for type-aware linting (default: `false`).
-     *
-     * If `true` use fancy new `projectService` for type-aware linting
-     * If `false` use classic `project` configuration
-     */
-    useProjectService?: boolean;
-    /**
-     * Glob patterns for files that should be type aware.
-     * @default ['**\/*.{ts,tsx}']
-     */
-    filesTypeAware?: string[];
-    /**
-     * Glob patterns for files that should not be type aware.
-     * @default ['**\/*.md\/**']
-     */
-    ignoresTypeAware?: string[];
-};
-export type OptionsTypeScriptWithTypes = {
-    /**
-     * When this options is provided, type aware rules will be enabled.
-     * @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);
-export type OptionsHasTypeScript = {
-    typescript?: boolean;
-};
-export type OptionsStylistic = {
-    stylistic?: boolean | StylisticConfig;
-};
-export type StylisticConfig = {
-    indent?: number | "tab";
-    quotes?: "single" | "double";
-    jsx?: boolean;
-};
-export type OptionsPrefix = {
-    prefix?: {
-        from: string;
-        to: string;
-    };
-};
-export type OptionsOverrides = {
-    overrides?: Config["rules"];
-};
-export type OptionsIsInEditor = {
-    isInEditor?: boolean;
-};
-export type OptionsReact = {
-    react?: boolean;
-    reactRefresh?: boolean;
-};
-/**
- * Tailwind CSS ESLint settings
- */
-export type TailwindEslintSettings = {
-    /**
-     * call expressions to check for tailwind classes
-     * @default ["classnames", "clsx", "ctl", "cn", "cx", "twMerge", "twJoin"]
-     */
-    callees: string[];
-    classRegex: string;
-    config: string;
-    cssFiles: string[];
-    cssFilesRefreshRate: number;
-    removeDuplicates: boolean;
-    skipClassAttribute: boolean;
-    tags: string[];
-    whitelist: string[];
-};
-export type TailwindOptions = Partial<TailwindEslintSettings> | boolean | undefined;
-export type OptionsConfig = {
-    /**
-     * Enable debug mode.
-     */
-    debug?: boolean;
-    /**
-     * Enable reporting of unused disable directives.
-     *
-     * @default true
-     */
-    reportUnusedDisableDirectives?: boolean;
-    /**
-     * Array of rules to turn off.
-     */
-    off?: string[];
-    /**
-     * Enable `eslint-plugin-command`
-     *
-     * @default true
-     */
-    command?: boolean;
-    /**
-     * Enable fast mode.
-     *
-     * This will disable some rules to speed up linting.
-     */
-    fast?: boolean;
-    /**
-     * Enable Prettier config rules to disable conflicting ESLint rules
-     *
-     * THIS DOES NOT ENABLE PRETTIER FORMATTING. YOU DO THAT, BUT I
-     * RECOMMEND USING PRETTIER TO FORMAT AND NOT THE ESLINT PRETTIER
-     * 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.
-     * @default "jsse"
-     */
-    rootId?: string;
-    /**
-     * Optional function to run before the final config is returned.
-     */
-    preReturn?: (configs: Config[]) => Config[] | Awaitable<Config[]>;
-    /**
-     * Enable gitignore support.
-     *
-     * Passing an object to configure the options.
-     *
-     * @see https://github.com/antfu/eslint-config-flat-gitignore
-     * @default true
-     */
-    gitignore?: boolean | FlatGitignoreOptions;
-    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[];
-    /**
-     * Enable TypeScript support.
-     *
-     * Passing an object to enable TypeScript Language Server support.
-     *
-     * @default auto-detect based on the dependencies
-     */
-    typescript?: boolean | OptionsTypeScriptWithTypes;
-    /**
-     * Forcibly disable type aware rules
-     */
-    typeAware?: boolean;
-    react?: boolean;
-    reactRefresh?: boolean;
-    /**
-     * Enable JSX related rules.
-     *
-     * Currently only stylistic rules are included.
-     *
-     * @default true
-     */
-    jsx?: boolean;
-    /**
-     * Enable test support.
-     *
-     * @default true
-     */
-    test?: boolean;
-    /**
-     * Enable JSONC support.
-     *
-     * @default true
-     */
-    jsonc?: boolean;
-    /**
-     * Enable YAML support.
-     *
-     * @default true
-     */
-    yaml?: boolean;
-    /**
-     * Enable Markdown support.
-     *
-     * @default true
-     */
-    markdown?: boolean;
-    /**
-     * Enable stylistic rules.
-     *
-     * @default true
-     */
-    stylistic?: boolean | StylisticConfig;
-    /**
-     * Control to disable some rules in editors.
-     * @default auto-detect based on the process.env
-     */
-    isInEditor?: boolean;
-    /**
-     * Provide overrides for rules for each integration.
-     */
-    overrides?: {
-        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> = {
-    [K in keyof T as K extends `${FromPref}${infer Rest}` ? `${ToPref}${Rest}` : K]: T[K];
-};

package/dist/esm/types.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/utils.d.ts

@@ -1,51 +0,0 @@
-import type { Linter } from "eslint";
-import type { Awaitable, Config } from "./types.js";
-/**
- * Combine array and non-array configs into a single array.
- */
-export declare function combine(...configs: Awaitable<Config | Config[]>[]): Promise<Config[]>;
-/**
- * Combine array and non-array configs into a single array.
- */
-export declare function combineAsync<T>(...configs: Awaitable<T | T[]>[]): Promise<T[]>;
-export declare function renameRules<TRule = unknown>(rules: Record<string, TRule>, from: string, to: string): Record<string, TRule>;
-export declare function interopDefault<T>(m: Awaitable<T>): Promise<T extends {
-    default: infer U;
-} ? U : T>;
-export declare function isCI(): boolean;
-export declare function isInEditor(): boolean;
-/**
- * Make an array of strings unique maintaining order.
- * @param strings strings to make unique
- * @returns unique strings
- */
-export declare function uniqueStrings(...strings: (string | string[])[]): string[];
-export declare const parserPlain: {
-    meta: {
-        name: string;
-    };
-    parseForESLint: (code: string) => {
-        ast: {
-            body: never[];
-            comments: never[];
-            loc: {
-                end: number;
-                start: number;
-            };
-            range: number[];
-            tokens: never[];
-            type: string;
-        };
-        scopeManager: undefined;
-        services: {
-            isPlain: boolean;
-        };
-        visitorKeys: {
-            Program: never[];
-        };
-    };
-};
-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 Config>(configs: T[]): T[];
-export declare function warn2error<T extends Config>(configs: T[]): T[];

package/dist/esm/utils.js

@@ -1,156 +0,0 @@
-import process from "node:process";
-import { log } from "./log.js";
-/**
- * Combine array and non-array configs into a single array.
- */
-export async function combine(...configs) {
-    const resolved = await Promise.all(configs);
-    return resolved.flat();
-}
-/**
- * Combine array and non-array configs into a single array.
- */
-export async function combineAsync(...configs) {
-    const resolved = await Promise.all(configs);
-    return resolved.flatMap((config) => Array.isArray(config) ? config : [config]);
-}
-export function renameRules(rules, from, to) {
-    if (from === to) {
-        return rules;
-    }
-    return Object.fromEntries(Object.entries(rules).map(([key, value]) => {
-        if (key.startsWith(from)) {
-            return [to + key.slice(from.length), value];
-        }
-        return [key, value];
-    }));
-}
-export async function interopDefault(m) {
-    const resolved = await m;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
-    return resolved.default || resolved;
-}
-export function isCI() {
-    return !!process.env.CI;
-}
-export function isInEditor() {
-    return !!((process.env.VSCODE_PID || process.env.JETBRAINS_IDE) && !isCI());
-}
-/**
- * Make an array of strings unique maintaining order.
- * @param strings strings to make unique
- * @returns unique strings
- */
-export function uniqueStrings(...strings) {
-    const set = new Set();
-    for (const item of strings) {
-        if (typeof item === "string") {
-            set.add(item);
-        }
-        else {
-            for (const str of item) {
-                set.add(str);
-            }
-        }
-    }
-    return [...set];
-}
-export const parserPlain = {
-    meta: {
-        name: "parser-plain",
-    },
-    parseForESLint: (code) => ({
-        ast: {
-            body: [],
-            comments: [],
-            loc: { end: code.length, start: 0 },
-            range: [0, code.length],
-            tokens: [],
-            type: "Program",
-        },
-        scopeManager: undefined,
-        services: { isPlain: true },
-        visitorKeys: {
-            Program: [],
-        },
-    }),
-};
-export function turnOffRules(configs, off) {
-    if (off.length > 0) {
-        // turrning off rules
-        // duplicate off rules
-        for (const rule of off) {
-            log.debug(`turning-off: ${rule}`);
-        }
-        const currentlyActiveRules = new Set();
-        for (const config of configs) {
-            for (const rule of Object.keys(config.rules ?? {}))
-                currentlyActiveRules.add(rule);
-        }
-        // warn if off is not in currentlyActiveRules
-        for (const rule of off) {
-            if (!currentlyActiveRules.has(rule)) {
-                log.info(`Rule \`${rule}\` is not active in the current config, you can remove it from the off list`);
-            }
-        }
-        for (const config of configs) {
-            // turn off each rule...
-            const cfgRules = config.rules;
-            if (cfgRules) {
-                for (const rule of off) {
-                    if (cfgRules[rule] !== undefined &&
-                        cfgRules[rule] !== "off" &&
-                        cfgRules[rule] !== 0) {
-                        cfgRules[rule] = "off";
-                    }
-                }
-            }
-        }
-    }
-    return configs;
-}
-export function changeRuleEntrySeverity(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-ruleConfig, level) {
-    if (Array.isArray(ruleConfig)) {
-        // here its [level, options]
-        if (ruleConfig[0] !== level) {
-            ruleConfig[0] = level;
-        }
-        return ruleConfig;
-    }
-    return level;
-}
-export function error2warn(configs) {
-    for (const config of configs) {
-        if (config.rules) {
-            config.rules = Object.fromEntries(Object.entries(config.rules).map(([key, value]) => {
-                if (value === "error" || value === 2) {
-                    return [key, changeRuleEntrySeverity(value, "warn")];
-                }
-                if (Array.isArray(value) &&
-                    (value[0] === "error" || value[0] === 2)) {
-                    return [key, changeRuleEntrySeverity(value, "warn")];
-                }
-                return [key, value];
-            }));
-        }
-    }
-    return configs;
-}
-export function warn2error(configs) {
-    for (const config of configs) {
-        if (config.rules) {
-            config.rules = Object.fromEntries(Object.entries(config.rules).map(([key, value]) => {
-                if (value === "warn" || value === 1) {
-                    return [key, changeRuleEntrySeverity(value, "error")];
-                }
-                if (Array.isArray(value) && (value[0] === "warn" || value[0] === 1)) {
-                    return [key, changeRuleEntrySeverity(value, "error")];
-                }
-                return [key, value];
-            }));
-        }
-    }
-    return configs;
-}

package/dist/version-DNhPWuQE.js

@@ -1,5 +0,0 @@
-//#region src/generated/version.ts
-const VERSION = "0.4.9";
-
-//#endregion
-export { VERSION };