@kazupon/eslint-config 0.8.0 → 0.9.0

package/dist/types/gens/yml.d.ts

@@ -0,0 +1,375 @@
+import type { Linter } from 'eslint';
+export interface YmlRules {
+    /**
+     * require or disallow block style mappings.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-mapping.html
+     */
+    'yml/block-mapping'?: Linter.RuleEntry<YmlBlockMapping>;
+    /**
+     * enforce consistent line breaks after `:` indicator
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-mapping-colon-indicator-newline.html
+     */
+    'yml/block-mapping-colon-indicator-newline'?: Linter.RuleEntry<YmlBlockMappingColonIndicatorNewline>;
+    /**
+     * enforce consistent line breaks after `?` indicator
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-mapping-question-indicator-newline.html
+     */
+    'yml/block-mapping-question-indicator-newline'?: Linter.RuleEntry<YmlBlockMappingQuestionIndicatorNewline>;
+    /**
+     * require or disallow block style sequences.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-sequence.html
+     */
+    'yml/block-sequence'?: Linter.RuleEntry<YmlBlockSequence>;
+    /**
+     * enforce consistent line breaks after `-` indicator
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/block-sequence-hyphen-indicator-newline.html
+     */
+    'yml/block-sequence-hyphen-indicator-newline'?: Linter.RuleEntry<YmlBlockSequenceHyphenIndicatorNewline>;
+    /**
+     * enforce YAML file extension
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/file-extension.html
+     */
+    'yml/file-extension'?: Linter.RuleEntry<YmlFileExtension>;
+    /**
+     * enforce consistent line breaks inside braces
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-mapping-curly-newline.html
+     */
+    'yml/flow-mapping-curly-newline'?: Linter.RuleEntry<YmlFlowMappingCurlyNewline>;
+    /**
+     * enforce consistent spacing inside braces
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-mapping-curly-spacing.html
+     */
+    'yml/flow-mapping-curly-spacing'?: Linter.RuleEntry<YmlFlowMappingCurlySpacing>;
+    /**
+     * enforce linebreaks after opening and before closing flow sequence brackets
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-sequence-bracket-newline.html
+     */
+    'yml/flow-sequence-bracket-newline'?: Linter.RuleEntry<YmlFlowSequenceBracketNewline>;
+    /**
+     * enforce consistent spacing inside flow sequence brackets
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/flow-sequence-bracket-spacing.html
+     */
+    'yml/flow-sequence-bracket-spacing'?: Linter.RuleEntry<YmlFlowSequenceBracketSpacing>;
+    /**
+     * enforce consistent indentation
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/indent.html
+     */
+    'yml/indent'?: Linter.RuleEntry<YmlIndent>;
+    /**
+     * enforce naming convention to key names
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/key-name-casing.html
+     */
+    'yml/key-name-casing'?: Linter.RuleEntry<YmlKeyNameCasing>;
+    /**
+     * enforce consistent spacing between keys and values in mapping pairs
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/key-spacing.html
+     */
+    'yml/key-spacing'?: Linter.RuleEntry<YmlKeySpacing>;
+    /**
+     * disallow empty document
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-document.html
+     */
+    'yml/no-empty-document'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow empty mapping keys
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-key.html
+     */
+    'yml/no-empty-key'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow empty mapping values
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-mapping-value.html
+     */
+    'yml/no-empty-mapping-value'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow empty sequence entries
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-empty-sequence-entry.html
+     */
+    'yml/no-empty-sequence-entry'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow irregular whitespace
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-irregular-whitespace.html
+     */
+    'yml/no-irregular-whitespace'?: Linter.RuleEntry<YmlNoIrregularWhitespace>;
+    /**
+     * disallow multiple empty lines
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-multiple-empty-lines.html
+     */
+    'yml/no-multiple-empty-lines'?: Linter.RuleEntry<YmlNoMultipleEmptyLines>;
+    /**
+     * disallow tabs for indentation.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-tab-indent.html
+     */
+    'yml/no-tab-indent'?: Linter.RuleEntry<[]>;
+    /**
+     * disallow trailing zeros for floats
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/no-trailing-zeros.html
+     */
+    'yml/no-trailing-zeros'?: Linter.RuleEntry<[]>;
+    /**
+     * require or disallow plain style scalar.
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/plain-scalar.html
+     */
+    'yml/plain-scalar'?: Linter.RuleEntry<YmlPlainScalar>;
+    /**
+     * enforce the consistent use of either double, or single quotes
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/quotes.html
+     */
+    'yml/quotes'?: Linter.RuleEntry<YmlQuotes>;
+    /**
+     * disallow mapping keys other than strings
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/require-string-key.html
+     */
+    'yml/require-string-key'?: Linter.RuleEntry<[]>;
+    /**
+     * require mapping keys to be sorted
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-keys.html
+     */
+    'yml/sort-keys'?: Linter.RuleEntry<YmlSortKeys>;
+    /**
+     * require sequence values to be sorted
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/sort-sequence-values.html
+     */
+    'yml/sort-sequence-values'?: Linter.RuleEntry<YmlSortSequenceValues>;
+    /**
+     * enforce consistent spacing after the `#` in a comment
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/spaced-comment.html
+     */
+    'yml/spaced-comment'?: Linter.RuleEntry<YmlSpacedComment>;
+    /**
+     * disallow parsing errors in Vue custom blocks
+     * @see https://ota-meshi.github.io/eslint-plugin-yml/rules/vue-custom-block/no-parsing-error.html
+     */
+    'yml/vue-custom-block/no-parsing-error'?: Linter.RuleEntry<[]>;
+}
+type YmlBlockMapping = [] | [
+    (("always" | "never") | {
+        singleline?: ("always" | "never" | "ignore");
+        multiline?: ("always" | "never" | "ignore");
+    })
+];
+type YmlBlockMappingColonIndicatorNewline = [] | [("always" | "never")];
+type YmlBlockMappingQuestionIndicatorNewline = [] | [("always" | "never")];
+type YmlBlockSequence = [] | [
+    (("always" | "never") | {
+        singleline?: ("always" | "never" | "ignore");
+        multiline?: ("always" | "never" | "ignore");
+    })
+];
+type YmlBlockSequenceHyphenIndicatorNewline = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        nestedHyphen?: ("always" | "never");
+        blockMapping?: ("always" | "never");
+    }
+];
+type YmlFileExtension = [] | [
+    {
+        extension?: ("yaml" | "yml");
+        caseSensitive?: boolean;
+    }
+];
+type YmlFlowMappingCurlyNewline = [] | [
+    (("always" | "never") | {
+        multiline?: boolean;
+        minProperties?: number;
+        consistent?: boolean;
+    })
+];
+type YmlFlowMappingCurlySpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        arraysInObjects?: boolean;
+        objectsInObjects?: boolean;
+    }
+];
+type YmlFlowSequenceBracketNewline = [] | [
+    (("always" | "never" | "consistent") | {
+        multiline?: boolean;
+        minItems?: (number | null);
+    })
+];
+type YmlFlowSequenceBracketSpacing = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        singleValue?: boolean;
+        objectsInArrays?: boolean;
+        arraysInArrays?: boolean;
+    }
+];
+type YmlIndent = [] | [number] | [
+    number,
+    {
+        indentBlockSequences?: boolean;
+        indicatorValueIndent?: number;
+    }
+];
+type YmlKeyNameCasing = [] | [
+    {
+        camelCase?: boolean;
+        PascalCase?: boolean;
+        SCREAMING_SNAKE_CASE?: boolean;
+        "kebab-case"?: boolean;
+        snake_case?: boolean;
+        ignores?: string[];
+    }
+];
+type YmlKeySpacing = [] | [
+    ({
+        align?: (("colon" | "value") | {
+            on?: ("colon" | "value");
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        });
+        mode?: ("strict" | "minimum");
+        beforeColon?: boolean;
+        afterColon?: boolean;
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            align?: (("colon" | "value") | {
+                on?: ("colon" | "value");
+                mode?: ("strict" | "minimum");
+                beforeColon?: boolean;
+                afterColon?: boolean;
+            });
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    } | {
+        singleLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        multiLine?: {
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+        align?: {
+            on?: ("colon" | "value");
+            mode?: ("strict" | "minimum");
+            beforeColon?: boolean;
+            afterColon?: boolean;
+        };
+    })
+];
+type YmlNoIrregularWhitespace = [] | [
+    {
+        skipComments?: boolean;
+        skipQuotedScalars?: boolean;
+    }
+];
+type YmlNoMultipleEmptyLines = [] | [
+    {
+        max: number;
+        maxEOF?: number;
+        maxBOF?: number;
+    }
+];
+type YmlPlainScalar = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        ignorePatterns?: string[];
+    }
+];
+type YmlQuotes = [] | [
+    {
+        prefer?: ("double" | "single");
+        avoidEscape?: boolean;
+    }
+];
+type YmlSortKeys = ([
+    {
+        pathPattern: string;
+        hasProperties?: string[];
+        order: ((string | {
+            keyPattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minKeys?: number;
+        allowLineSeparatedGroups?: boolean;
+    },
+    ...({
+        pathPattern: string;
+        hasProperties?: string[];
+        order: ((string | {
+            keyPattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minKeys?: number;
+        allowLineSeparatedGroups?: boolean;
+    })[]
+] | [] | [("asc" | "desc")] | [
+    ("asc" | "desc"),
+    {
+        caseSensitive?: boolean;
+        natural?: boolean;
+        minKeys?: number;
+        allowLineSeparatedGroups?: boolean;
+    }
+]);
+type YmlSortSequenceValues = [
+    {
+        pathPattern: string;
+        order: ((string | {
+            valuePattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minValues?: number;
+    },
+    ...({
+        pathPattern: string;
+        order: ((string | {
+            valuePattern?: string;
+            order?: {
+                type?: ("asc" | "desc");
+                caseSensitive?: boolean;
+                natural?: boolean;
+            };
+        })[] | {
+            type?: ("asc" | "desc");
+            caseSensitive?: boolean;
+            natural?: boolean;
+        });
+        minValues?: number;
+    })[]
+];
+type YmlSpacedComment = [] | [("always" | "never")] | [
+    ("always" | "never"),
+    {
+        exceptions?: string[];
+        markers?: string[];
+    }
+];
+export {};

package/dist/types/index.d.cts

@@ -0,0 +1,14 @@
+export * from './utils';
+export * from './overrides';
+export * from './gens/javascript';
+export * from './gens/unicorn';
+export * from './gens/comments';
+export * from './gens/jsdoc';
+export * from './gens/jsonc';
+export * from './gens/promise';
+export * from './gens/prettier';
+export * from './gens/regexp';
+export * from './gens/typescript';
+export * from './gens/vue';
+export * from './gens/yml';
+export * from './gens/eslint';

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export * from './utils';
+export * from './overrides';
+export * from './gens/javascript';
+export * from './gens/unicorn';
+export * from './gens/comments';
+export * from './gens/jsdoc';
+export * from './gens/jsonc';
+export * from './gens/promise';
+export * from './gens/prettier';
+export * from './gens/regexp';
+export * from './gens/typescript';
+export * from './gens/vue';
+export * from './gens/yml';
+export * from './gens/eslint';

package/dist/types/overrides.d.cts

@@ -0,0 +1,6 @@
+import type { Linter, ESLint } from 'eslint';
+export interface OverridesOptions<Rules = Linter.FlatConfig['rules']> {
+    files?: Linter.FlatConfig['files'];
+    rules?: Rules;
+    parserOptions?: ESLint.Environment['parserOptions'];
+}

package/dist/types/overrides.d.ts

@@ -0,0 +1,6 @@
+import type { Linter, ESLint } from 'eslint';
+export interface OverridesOptions<Rules = Linter.FlatConfig['rules']> {
+    files?: Linter.FlatConfig['files'];
+    rules?: Rules;
+    parserOptions?: ESLint.Environment['parserOptions'];
+}

package/dist/types/utils.d.cts

@@ -0,0 +1,4 @@
+export type Awaitable<T> = T | Promise<T>;
+export type InteropModuleDefault<T> = T extends {
+    default: infer U;
+} ? U : T;

package/dist/types/utils.d.ts

@@ -0,0 +1,4 @@
+export type Awaitable<T> = T | Promise<T>;
+export type InteropModuleDefault<T> = T extends {
+    default: infer U;
+} ? U : T;

package/dist/utils.d.cts

@@ -1,4 +1,25 @@
 import type { Awaitable, InteropModuleDefault } from './types';
-export declare function toArray<T>(value: ((T) | ((T)[]))): (T)[];
+/**
+ * convert to array
+ * @param {T[]} value a value
+ * @returns {T[]} convrted array
+ */
+export declare function toArray<T>(value: T | T[]): T[];
+/**
+ * pascalize string
+ * @param {string} value a string value
+ * @returns {string} pascalized string
+ */
+export declare function pascalize(value: string): string;
+/**
+ * resolve module with interop default
+ * @param {Awaitable<T>} mod a module
+ * @returns {Promise<InteropModuleDefault<T>>} resolved module
+ */
 export declare function interopDefault<T>(mod: Awaitable<T>): Promise<InteropModuleDefault<T>>;
+/**
+ * load eslint plugin
+ * @param {string} name plugin name
+ * @returns {Promise<T>} loaded plugin
+ */
 export declare function loadPlugin<T = unknown>(name: string): Promise<T>;

package/dist/utils.d.ts

@@ -1,4 +1,25 @@
 import type { Awaitable, InteropModuleDefault } from './types';
-export declare function toArray<T>(value: ((T) | ((T)[]))): (T)[];
+/**
+ * convert to array
+ * @param {T[]} value a value
+ * @returns {T[]} convrted array
+ */
+export declare function toArray<T>(value: T | T[]): T[];
+/**
+ * pascalize string
+ * @param {string} value a string value
+ * @returns {string} pascalized string
+ */
+export declare function pascalize(value: string): string;
+/**
+ * resolve module with interop default
+ * @param {Awaitable<T>} mod a module
+ * @returns {Promise<InteropModuleDefault<T>>} resolved module
+ */
 export declare function interopDefault<T>(mod: Awaitable<T>): Promise<InteropModuleDefault<T>>;
+/**
+ * load eslint plugin
+ * @param {string} name plugin name
+ * @returns {Promise<T>} loaded plugin
+ */
 export declare function loadPlugin<T = unknown>(name: string): Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kazupon/eslint-config",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "ESLint config for @kazupon",
   "keywords": [
     "config",
@@ -36,8 +36,8 @@
     }
   },
   "dependencies": {
-    "@eslint/js": "^9.0.0",
     "@eslint-community/eslint-plugin-eslint-comments": "^4.3.0",
+    "@eslint/js": "^9.0.0",
     "eslint-flat-config-utils": "^0.2.5",
     "globals": "^15.8.0"
   },
@@ -96,6 +96,7 @@
     "eslint-plugin-unicorn": "^54.0.0",
     "eslint-plugin-vue": "^9.27.0",
     "eslint-plugin-yml": "^1.14.0",
+    "eslint-typegen": "^0.2.4",
     "gh-changelogen": "^0.2.8",
     "lint-staged": "^15.2.7",
     "npm-run-all2": "^6.2.2",
@@ -131,6 +132,7 @@
     "fix:eslint": "eslint . --fix",
     "dev": "pnpx @eslint/config-inspector --config eslint.config.ts",
     "test": "vitest",
+    "typegen": "pnpx tsx scripts/typegen.ts",
     "build": "tsdown",
     "build:inspector": "pnpm build && pnpx @eslint/config-inspector build",
     "typecheck": "tsc -p ."