@kazupon/eslint-config 0.27.0 → 0.28.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -0
- package/dist/index.d.ts +1792 -13
- package/dist/index.js +58 -1
- package/package.json +2 -1
package/dist/index.d.ts
CHANGED
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
import { FlatConfigComposer } from 'eslint-flat-config-utils';
|
|
2
2
|
import { Awaitable } from '@kazupon/jts-utils/types';
|
|
3
3
|
import { Linter, ESLint } from 'eslint';
|
|
4
|
+
import { StylisticCustomizeOptions } from '@stylistic/eslint-plugin';
|
|
4
5
|
|
|
5
6
|
/**
|
|
6
7
|
* define eslint configurations
|
|
@@ -6949,6 +6950,1726 @@ type RegexpUnicodeProperty = [] | [
|
|
|
6949
6950
|
}
|
|
6950
6951
|
];
|
|
6951
6952
|
|
|
6953
|
+
interface StylisticRules {
|
|
6954
|
+
/**
|
|
6955
|
+
* Enforce linebreaks after opening and before closing array brackets
|
|
6956
|
+
* @see https://eslint.style/rules/js/array-bracket-newline
|
|
6957
|
+
*/
|
|
6958
|
+
'@stylistic/array-bracket-newline'?: Linter.RuleEntry<StylisticArrayBracketNewline>;
|
|
6959
|
+
/**
|
|
6960
|
+
* Enforce consistent spacing inside array brackets
|
|
6961
|
+
* @see https://eslint.style/rules/js/array-bracket-spacing
|
|
6962
|
+
*/
|
|
6963
|
+
'@stylistic/array-bracket-spacing'?: Linter.RuleEntry<StylisticArrayBracketSpacing>;
|
|
6964
|
+
/**
|
|
6965
|
+
* Enforce line breaks after each array element
|
|
6966
|
+
* @see https://eslint.style/rules/js/array-element-newline
|
|
6967
|
+
*/
|
|
6968
|
+
'@stylistic/array-element-newline'?: Linter.RuleEntry<StylisticArrayElementNewline>;
|
|
6969
|
+
/**
|
|
6970
|
+
* Require parentheses around arrow function arguments
|
|
6971
|
+
* @see https://eslint.style/rules/js/arrow-parens
|
|
6972
|
+
*/
|
|
6973
|
+
'@stylistic/arrow-parens'?: Linter.RuleEntry<StylisticArrowParens>;
|
|
6974
|
+
/**
|
|
6975
|
+
* Enforce consistent spacing before and after the arrow in arrow functions
|
|
6976
|
+
* @see https://eslint.style/rules/js/arrow-spacing
|
|
6977
|
+
*/
|
|
6978
|
+
'@stylistic/arrow-spacing'?: Linter.RuleEntry<StylisticArrowSpacing>;
|
|
6979
|
+
/**
|
|
6980
|
+
* Disallow or enforce spaces inside of blocks after opening block and before closing block
|
|
6981
|
+
* @see https://eslint.style/rules/ts/block-spacing
|
|
6982
|
+
*/
|
|
6983
|
+
'@stylistic/block-spacing'?: Linter.RuleEntry<StylisticBlockSpacing>;
|
|
6984
|
+
/**
|
|
6985
|
+
* Enforce consistent brace style for blocks
|
|
6986
|
+
* @see https://eslint.style/rules/ts/brace-style
|
|
6987
|
+
*/
|
|
6988
|
+
'@stylistic/brace-style'?: Linter.RuleEntry<StylisticBraceStyle>;
|
|
6989
|
+
/**
|
|
6990
|
+
* Require or disallow trailing commas
|
|
6991
|
+
* @see https://eslint.style/rules/ts/comma-dangle
|
|
6992
|
+
*/
|
|
6993
|
+
'@stylistic/comma-dangle'?: Linter.RuleEntry<StylisticCommaDangle>;
|
|
6994
|
+
/**
|
|
6995
|
+
* Enforce consistent spacing before and after commas
|
|
6996
|
+
* @see https://eslint.style/rules/ts/comma-spacing
|
|
6997
|
+
*/
|
|
6998
|
+
'@stylistic/comma-spacing'?: Linter.RuleEntry<StylisticCommaSpacing>;
|
|
6999
|
+
/**
|
|
7000
|
+
* Enforce consistent comma style
|
|
7001
|
+
* @see https://eslint.style/rules/js/comma-style
|
|
7002
|
+
*/
|
|
7003
|
+
'@stylistic/comma-style'?: Linter.RuleEntry<StylisticCommaStyle>;
|
|
7004
|
+
/**
|
|
7005
|
+
* Enforce consistent spacing inside computed property brackets
|
|
7006
|
+
* @see https://eslint.style/rules/js/computed-property-spacing
|
|
7007
|
+
*/
|
|
7008
|
+
'@stylistic/computed-property-spacing'?: Linter.RuleEntry<StylisticComputedPropertySpacing>;
|
|
7009
|
+
/**
|
|
7010
|
+
* Enforce consistent line breaks after opening and before closing braces
|
|
7011
|
+
* @see https://eslint.style/rules/plus/curly-newline
|
|
7012
|
+
*/
|
|
7013
|
+
'@stylistic/curly-newline'?: Linter.RuleEntry<StylisticCurlyNewline>;
|
|
7014
|
+
/**
|
|
7015
|
+
* Enforce consistent newlines before and after dots
|
|
7016
|
+
* @see https://eslint.style/rules/js/dot-location
|
|
7017
|
+
*/
|
|
7018
|
+
'@stylistic/dot-location'?: Linter.RuleEntry<StylisticDotLocation>;
|
|
7019
|
+
/**
|
|
7020
|
+
* Require or disallow newline at the end of files
|
|
7021
|
+
* @see https://eslint.style/rules/js/eol-last
|
|
7022
|
+
*/
|
|
7023
|
+
'@stylistic/eol-last'?: Linter.RuleEntry<StylisticEolLast>;
|
|
7024
|
+
/**
|
|
7025
|
+
* Require or disallow spacing between function identifiers and their invocations
|
|
7026
|
+
* @see https://eslint.style/rules/ts/function-call-spacing
|
|
7027
|
+
*/
|
|
7028
|
+
'@stylistic/func-call-spacing'?: Linter.RuleEntry<StylisticFuncCallSpacing>;
|
|
7029
|
+
/**
|
|
7030
|
+
* Enforce line breaks between arguments of a function call
|
|
7031
|
+
* @see https://eslint.style/rules/js/function-call-argument-newline
|
|
7032
|
+
*/
|
|
7033
|
+
'@stylistic/function-call-argument-newline'?: Linter.RuleEntry<StylisticFunctionCallArgumentNewline>;
|
|
7034
|
+
/**
|
|
7035
|
+
* Require or disallow spacing between function identifiers and their invocations
|
|
7036
|
+
* @see https://eslint.style/rules/ts/function-call-spacing
|
|
7037
|
+
*/
|
|
7038
|
+
'@stylistic/function-call-spacing'?: Linter.RuleEntry<StylisticFunctionCallSpacing>;
|
|
7039
|
+
/**
|
|
7040
|
+
* Enforce consistent line breaks inside function parentheses
|
|
7041
|
+
* @see https://eslint.style/rules/js/function-paren-newline
|
|
7042
|
+
*/
|
|
7043
|
+
'@stylistic/function-paren-newline'?: Linter.RuleEntry<StylisticFunctionParenNewline>;
|
|
7044
|
+
/**
|
|
7045
|
+
* Enforce consistent spacing around `*` operators in generator functions
|
|
7046
|
+
* @see https://eslint.style/rules/js/generator-star-spacing
|
|
7047
|
+
*/
|
|
7048
|
+
'@stylistic/generator-star-spacing'?: Linter.RuleEntry<StylisticGeneratorStarSpacing>;
|
|
7049
|
+
/**
|
|
7050
|
+
* Enforce the location of arrow function bodies
|
|
7051
|
+
* @see https://eslint.style/rules/js/implicit-arrow-linebreak
|
|
7052
|
+
*/
|
|
7053
|
+
'@stylistic/implicit-arrow-linebreak'?: Linter.RuleEntry<StylisticImplicitArrowLinebreak>;
|
|
7054
|
+
/**
|
|
7055
|
+
* Enforce consistent indentation
|
|
7056
|
+
* @see https://eslint.style/rules/ts/indent
|
|
7057
|
+
*/
|
|
7058
|
+
'@stylistic/indent'?: Linter.RuleEntry<StylisticIndent>;
|
|
7059
|
+
/**
|
|
7060
|
+
* Indentation for binary operators
|
|
7061
|
+
* @see https://eslint.style/rules/plus/indent-binary-ops
|
|
7062
|
+
*/
|
|
7063
|
+
'@stylistic/indent-binary-ops'?: Linter.RuleEntry<StylisticIndentBinaryOps>;
|
|
7064
|
+
/**
|
|
7065
|
+
* Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
|
|
7066
|
+
* @see https://eslint.style/rules/jsx/jsx-child-element-spacing
|
|
7067
|
+
*/
|
|
7068
|
+
'@stylistic/jsx-child-element-spacing'?: Linter.RuleEntry<[]>;
|
|
7069
|
+
/**
|
|
7070
|
+
* Enforce closing bracket location in JSX
|
|
7071
|
+
* @see https://eslint.style/rules/jsx/jsx-closing-bracket-location
|
|
7072
|
+
*/
|
|
7073
|
+
'@stylistic/jsx-closing-bracket-location'?: Linter.RuleEntry<StylisticJsxClosingBracketLocation>;
|
|
7074
|
+
/**
|
|
7075
|
+
* Enforce closing tag location for multiline JSX
|
|
7076
|
+
* @see https://eslint.style/rules/jsx/jsx-closing-tag-location
|
|
7077
|
+
*/
|
|
7078
|
+
'@stylistic/jsx-closing-tag-location'?: Linter.RuleEntry<StylisticJsxClosingTagLocation>;
|
|
7079
|
+
/**
|
|
7080
|
+
* Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes
|
|
7081
|
+
* @see https://eslint.style/rules/jsx/jsx-curly-brace-presence
|
|
7082
|
+
*/
|
|
7083
|
+
'@stylistic/jsx-curly-brace-presence'?: Linter.RuleEntry<StylisticJsxCurlyBracePresence>;
|
|
7084
|
+
/**
|
|
7085
|
+
* Enforce consistent linebreaks in curly braces in JSX attributes and expressions
|
|
7086
|
+
* @see https://eslint.style/rules/jsx/jsx-curly-newline
|
|
7087
|
+
*/
|
|
7088
|
+
'@stylistic/jsx-curly-newline'?: Linter.RuleEntry<StylisticJsxCurlyNewline>;
|
|
7089
|
+
/**
|
|
7090
|
+
* Enforce or disallow spaces inside of curly braces in JSX attributes and expressions
|
|
7091
|
+
* @see https://eslint.style/rules/jsx/jsx-curly-spacing
|
|
7092
|
+
*/
|
|
7093
|
+
'@stylistic/jsx-curly-spacing'?: Linter.RuleEntry<StylisticJsxCurlySpacing>;
|
|
7094
|
+
/**
|
|
7095
|
+
* Enforce or disallow spaces around equal signs in JSX attributes
|
|
7096
|
+
* @see https://eslint.style/rules/jsx/jsx-equals-spacing
|
|
7097
|
+
*/
|
|
7098
|
+
'@stylistic/jsx-equals-spacing'?: Linter.RuleEntry<StylisticJsxEqualsSpacing>;
|
|
7099
|
+
/**
|
|
7100
|
+
* Enforce proper position of the first property in JSX
|
|
7101
|
+
* @see https://eslint.style/rules/jsx/jsx-first-prop-new-line
|
|
7102
|
+
*/
|
|
7103
|
+
'@stylistic/jsx-first-prop-new-line'?: Linter.RuleEntry<StylisticJsxFirstPropNewLine>;
|
|
7104
|
+
/**
|
|
7105
|
+
* Enforce line breaks before and after JSX elements when they are used as arguments to a function.
|
|
7106
|
+
* @see https://eslint.style/rules/jsx/jsx-function-call-newline
|
|
7107
|
+
*/
|
|
7108
|
+
'@stylistic/jsx-function-call-newline'?: Linter.RuleEntry<StylisticJsxFunctionCallNewline>;
|
|
7109
|
+
/**
|
|
7110
|
+
* Enforce JSX indentation. Deprecated, use `indent` rule instead.
|
|
7111
|
+
* @see https://eslint.style/rules/jsx/jsx-indent
|
|
7112
|
+
* @deprecated
|
|
7113
|
+
*/
|
|
7114
|
+
'@stylistic/jsx-indent'?: Linter.RuleEntry<StylisticJsxIndent>;
|
|
7115
|
+
/**
|
|
7116
|
+
* Enforce props indentation in JSX
|
|
7117
|
+
* @see https://eslint.style/rules/jsx/jsx-indent-props
|
|
7118
|
+
*/
|
|
7119
|
+
'@stylistic/jsx-indent-props'?: Linter.RuleEntry<StylisticJsxIndentProps>;
|
|
7120
|
+
/**
|
|
7121
|
+
* Enforce maximum of props on a single line in JSX
|
|
7122
|
+
* @see https://eslint.style/rules/jsx/jsx-max-props-per-line
|
|
7123
|
+
*/
|
|
7124
|
+
'@stylistic/jsx-max-props-per-line'?: Linter.RuleEntry<StylisticJsxMaxPropsPerLine>;
|
|
7125
|
+
/**
|
|
7126
|
+
* Require or prevent a new line after jsx elements and expressions.
|
|
7127
|
+
* @see https://eslint.style/rules/jsx/jsx-newline
|
|
7128
|
+
*/
|
|
7129
|
+
'@stylistic/jsx-newline'?: Linter.RuleEntry<StylisticJsxNewline>;
|
|
7130
|
+
/**
|
|
7131
|
+
* Require one JSX element per line
|
|
7132
|
+
* @see https://eslint.style/rules/jsx/jsx-one-expression-per-line
|
|
7133
|
+
*/
|
|
7134
|
+
'@stylistic/jsx-one-expression-per-line'?: Linter.RuleEntry<StylisticJsxOneExpressionPerLine>;
|
|
7135
|
+
/**
|
|
7136
|
+
* Enforce PascalCase for user-defined JSX components
|
|
7137
|
+
* @see https://eslint.style/rules/jsx/jsx-pascal-case
|
|
7138
|
+
*/
|
|
7139
|
+
'@stylistic/jsx-pascal-case'?: Linter.RuleEntry<StylisticJsxPascalCase>;
|
|
7140
|
+
/**
|
|
7141
|
+
* Disallow multiple spaces between inline JSX props
|
|
7142
|
+
* @see https://eslint.style/rules/jsx/jsx-props-no-multi-spaces
|
|
7143
|
+
*/
|
|
7144
|
+
'@stylistic/jsx-props-no-multi-spaces'?: Linter.RuleEntry<[]>;
|
|
7145
|
+
/**
|
|
7146
|
+
* Enforce the consistent use of either double or single quotes in JSX attributes
|
|
7147
|
+
* @see https://eslint.style/rules/js/jsx-quotes
|
|
7148
|
+
*/
|
|
7149
|
+
'@stylistic/jsx-quotes'?: Linter.RuleEntry<StylisticJsxQuotes>;
|
|
7150
|
+
/**
|
|
7151
|
+
* Disallow extra closing tags for components without children
|
|
7152
|
+
* @see https://eslint.style/rules/jsx/jsx-self-closing-comp
|
|
7153
|
+
*/
|
|
7154
|
+
'@stylistic/jsx-self-closing-comp'?: Linter.RuleEntry<StylisticJsxSelfClosingComp>;
|
|
7155
|
+
/**
|
|
7156
|
+
* Enforce props alphabetical sorting
|
|
7157
|
+
* @see https://eslint.style/rules/jsx/jsx-sort-props
|
|
7158
|
+
*/
|
|
7159
|
+
'@stylistic/jsx-sort-props'?: Linter.RuleEntry<StylisticJsxSortProps>;
|
|
7160
|
+
/**
|
|
7161
|
+
* Enforce whitespace in and around the JSX opening and closing brackets
|
|
7162
|
+
* @see https://eslint.style/rules/jsx/jsx-tag-spacing
|
|
7163
|
+
*/
|
|
7164
|
+
'@stylistic/jsx-tag-spacing'?: Linter.RuleEntry<StylisticJsxTagSpacing>;
|
|
7165
|
+
/**
|
|
7166
|
+
* Disallow missing parentheses around multiline JSX
|
|
7167
|
+
* @see https://eslint.style/rules/jsx/jsx-wrap-multilines
|
|
7168
|
+
*/
|
|
7169
|
+
'@stylistic/jsx-wrap-multilines'?: Linter.RuleEntry<StylisticJsxWrapMultilines>;
|
|
7170
|
+
/**
|
|
7171
|
+
* Enforce consistent spacing between property names and type annotations in types and interfaces
|
|
7172
|
+
* @see https://eslint.style/rules/ts/key-spacing
|
|
7173
|
+
*/
|
|
7174
|
+
'@stylistic/key-spacing'?: Linter.RuleEntry<StylisticKeySpacing>;
|
|
7175
|
+
/**
|
|
7176
|
+
* Enforce consistent spacing before and after keywords
|
|
7177
|
+
* @see https://eslint.style/rules/ts/keyword-spacing
|
|
7178
|
+
*/
|
|
7179
|
+
'@stylistic/keyword-spacing'?: Linter.RuleEntry<StylisticKeywordSpacing>;
|
|
7180
|
+
/**
|
|
7181
|
+
* Enforce position of line comments
|
|
7182
|
+
* @see https://eslint.style/rules/js/line-comment-position
|
|
7183
|
+
*/
|
|
7184
|
+
'@stylistic/line-comment-position'?: Linter.RuleEntry<StylisticLineCommentPosition>;
|
|
7185
|
+
/**
|
|
7186
|
+
* Enforce consistent linebreak style
|
|
7187
|
+
* @see https://eslint.style/rules/js/linebreak-style
|
|
7188
|
+
*/
|
|
7189
|
+
'@stylistic/linebreak-style'?: Linter.RuleEntry<StylisticLinebreakStyle>;
|
|
7190
|
+
/**
|
|
7191
|
+
* Require empty lines around comments
|
|
7192
|
+
* @see https://eslint.style/rules/ts/lines-around-comment
|
|
7193
|
+
*/
|
|
7194
|
+
'@stylistic/lines-around-comment'?: Linter.RuleEntry<StylisticLinesAroundComment>;
|
|
7195
|
+
/**
|
|
7196
|
+
* Require or disallow an empty line between class members
|
|
7197
|
+
* @see https://eslint.style/rules/ts/lines-between-class-members
|
|
7198
|
+
*/
|
|
7199
|
+
'@stylistic/lines-between-class-members'?: Linter.RuleEntry<StylisticLinesBetweenClassMembers>;
|
|
7200
|
+
/**
|
|
7201
|
+
* Enforce a maximum line length
|
|
7202
|
+
* @see https://eslint.style/rules/js/max-len
|
|
7203
|
+
*/
|
|
7204
|
+
'@stylistic/max-len'?: Linter.RuleEntry<StylisticMaxLen>;
|
|
7205
|
+
/**
|
|
7206
|
+
* Enforce a maximum number of statements allowed per line
|
|
7207
|
+
* @see https://eslint.style/rules/js/max-statements-per-line
|
|
7208
|
+
*/
|
|
7209
|
+
'@stylistic/max-statements-per-line'?: Linter.RuleEntry<StylisticMaxStatementsPerLine>;
|
|
7210
|
+
/**
|
|
7211
|
+
* Require a specific member delimiter style for interfaces and type literals
|
|
7212
|
+
* @see https://eslint.style/rules/ts/member-delimiter-style
|
|
7213
|
+
*/
|
|
7214
|
+
'@stylistic/member-delimiter-style'?: Linter.RuleEntry<StylisticMemberDelimiterStyle>;
|
|
7215
|
+
/**
|
|
7216
|
+
* Enforce a particular style for multiline comments
|
|
7217
|
+
* @see https://eslint.style/rules/js/multiline-comment-style
|
|
7218
|
+
*/
|
|
7219
|
+
'@stylistic/multiline-comment-style'?: Linter.RuleEntry<StylisticMultilineCommentStyle>;
|
|
7220
|
+
/**
|
|
7221
|
+
* Enforce newlines between operands of ternary expressions
|
|
7222
|
+
* @see https://eslint.style/rules/js/multiline-ternary
|
|
7223
|
+
*/
|
|
7224
|
+
'@stylistic/multiline-ternary'?: Linter.RuleEntry<StylisticMultilineTernary>;
|
|
7225
|
+
/**
|
|
7226
|
+
* Enforce or disallow parentheses when invoking a constructor with no arguments
|
|
7227
|
+
* @see https://eslint.style/rules/js/new-parens
|
|
7228
|
+
*/
|
|
7229
|
+
'@stylistic/new-parens'?: Linter.RuleEntry<StylisticNewParens>;
|
|
7230
|
+
/**
|
|
7231
|
+
* Require a newline after each call in a method chain
|
|
7232
|
+
* @see https://eslint.style/rules/js/newline-per-chained-call
|
|
7233
|
+
*/
|
|
7234
|
+
'@stylistic/newline-per-chained-call'?: Linter.RuleEntry<StylisticNewlinePerChainedCall>;
|
|
7235
|
+
/**
|
|
7236
|
+
* Disallow arrow functions where they could be confused with comparisons
|
|
7237
|
+
* @see https://eslint.style/rules/js/no-confusing-arrow
|
|
7238
|
+
*/
|
|
7239
|
+
'@stylistic/no-confusing-arrow'?: Linter.RuleEntry<StylisticNoConfusingArrow>;
|
|
7240
|
+
/**
|
|
7241
|
+
* Disallow unnecessary parentheses
|
|
7242
|
+
* @see https://eslint.style/rules/ts/no-extra-parens
|
|
7243
|
+
*/
|
|
7244
|
+
'@stylistic/no-extra-parens'?: Linter.RuleEntry<StylisticNoExtraParens>;
|
|
7245
|
+
/**
|
|
7246
|
+
* Disallow unnecessary semicolons
|
|
7247
|
+
* @see https://eslint.style/rules/ts/no-extra-semi
|
|
7248
|
+
*/
|
|
7249
|
+
'@stylistic/no-extra-semi'?: Linter.RuleEntry<[]>;
|
|
7250
|
+
/**
|
|
7251
|
+
* Disallow leading or trailing decimal points in numeric literals
|
|
7252
|
+
* @see https://eslint.style/rules/js/no-floating-decimal
|
|
7253
|
+
*/
|
|
7254
|
+
'@stylistic/no-floating-decimal'?: Linter.RuleEntry<[]>;
|
|
7255
|
+
/**
|
|
7256
|
+
* Disallow mixed binary operators
|
|
7257
|
+
* @see https://eslint.style/rules/js/no-mixed-operators
|
|
7258
|
+
*/
|
|
7259
|
+
'@stylistic/no-mixed-operators'?: Linter.RuleEntry<StylisticNoMixedOperators>;
|
|
7260
|
+
/**
|
|
7261
|
+
* Disallow mixed spaces and tabs for indentation
|
|
7262
|
+
* @see https://eslint.style/rules/js/no-mixed-spaces-and-tabs
|
|
7263
|
+
*/
|
|
7264
|
+
'@stylistic/no-mixed-spaces-and-tabs'?: Linter.RuleEntry<StylisticNoMixedSpacesAndTabs>;
|
|
7265
|
+
/**
|
|
7266
|
+
* Disallow multiple spaces
|
|
7267
|
+
* @see https://eslint.style/rules/js/no-multi-spaces
|
|
7268
|
+
*/
|
|
7269
|
+
'@stylistic/no-multi-spaces'?: Linter.RuleEntry<StylisticNoMultiSpaces>;
|
|
7270
|
+
/**
|
|
7271
|
+
* Disallow multiple empty lines
|
|
7272
|
+
* @see https://eslint.style/rules/js/no-multiple-empty-lines
|
|
7273
|
+
*/
|
|
7274
|
+
'@stylistic/no-multiple-empty-lines'?: Linter.RuleEntry<StylisticNoMultipleEmptyLines>;
|
|
7275
|
+
/**
|
|
7276
|
+
* Disallow all tabs
|
|
7277
|
+
* @see https://eslint.style/rules/js/no-tabs
|
|
7278
|
+
*/
|
|
7279
|
+
'@stylistic/no-tabs'?: Linter.RuleEntry<StylisticNoTabs>;
|
|
7280
|
+
/**
|
|
7281
|
+
* Disallow trailing whitespace at the end of lines
|
|
7282
|
+
* @see https://eslint.style/rules/js/no-trailing-spaces
|
|
7283
|
+
*/
|
|
7284
|
+
'@stylistic/no-trailing-spaces'?: Linter.RuleEntry<StylisticNoTrailingSpaces>;
|
|
7285
|
+
/**
|
|
7286
|
+
* Disallow whitespace before properties
|
|
7287
|
+
* @see https://eslint.style/rules/js/no-whitespace-before-property
|
|
7288
|
+
*/
|
|
7289
|
+
'@stylistic/no-whitespace-before-property'?: Linter.RuleEntry<[]>;
|
|
7290
|
+
/**
|
|
7291
|
+
* Enforce the location of single-line statements
|
|
7292
|
+
* @see https://eslint.style/rules/js/nonblock-statement-body-position
|
|
7293
|
+
*/
|
|
7294
|
+
'@stylistic/nonblock-statement-body-position'?: Linter.RuleEntry<StylisticNonblockStatementBodyPosition>;
|
|
7295
|
+
/**
|
|
7296
|
+
* Enforce consistent line breaks after opening and before closing braces
|
|
7297
|
+
* @see https://eslint.style/rules/ts/object-curly-newline
|
|
7298
|
+
*/
|
|
7299
|
+
'@stylistic/object-curly-newline'?: Linter.RuleEntry<StylisticObjectCurlyNewline>;
|
|
7300
|
+
/**
|
|
7301
|
+
* Enforce consistent spacing inside braces
|
|
7302
|
+
* @see https://eslint.style/rules/ts/object-curly-spacing
|
|
7303
|
+
*/
|
|
7304
|
+
'@stylistic/object-curly-spacing'?: Linter.RuleEntry<StylisticObjectCurlySpacing>;
|
|
7305
|
+
/**
|
|
7306
|
+
* Enforce placing object properties on separate lines
|
|
7307
|
+
* @see https://eslint.style/rules/ts/object-property-newline
|
|
7308
|
+
*/
|
|
7309
|
+
'@stylistic/object-property-newline'?: Linter.RuleEntry<StylisticObjectPropertyNewline>;
|
|
7310
|
+
/**
|
|
7311
|
+
* Require or disallow newlines around variable declarations
|
|
7312
|
+
* @see https://eslint.style/rules/js/one-var-declaration-per-line
|
|
7313
|
+
*/
|
|
7314
|
+
'@stylistic/one-var-declaration-per-line'?: Linter.RuleEntry<StylisticOneVarDeclarationPerLine>;
|
|
7315
|
+
/**
|
|
7316
|
+
* Enforce consistent linebreak style for operators
|
|
7317
|
+
* @see https://eslint.style/rules/js/operator-linebreak
|
|
7318
|
+
*/
|
|
7319
|
+
'@stylistic/operator-linebreak'?: Linter.RuleEntry<StylisticOperatorLinebreak>;
|
|
7320
|
+
/**
|
|
7321
|
+
* Require or disallow padding within blocks
|
|
7322
|
+
* @see https://eslint.style/rules/js/padded-blocks
|
|
7323
|
+
*/
|
|
7324
|
+
'@stylistic/padded-blocks'?: Linter.RuleEntry<StylisticPaddedBlocks>;
|
|
7325
|
+
/**
|
|
7326
|
+
* Require or disallow padding lines between statements
|
|
7327
|
+
* @see https://eslint.style/rules/ts/padding-line-between-statements
|
|
7328
|
+
*/
|
|
7329
|
+
'@stylistic/padding-line-between-statements'?: Linter.RuleEntry<StylisticPaddingLineBetweenStatements>;
|
|
7330
|
+
/**
|
|
7331
|
+
* Require quotes around object literal, type literal, interfaces and enums property names
|
|
7332
|
+
* @see https://eslint.style/rules/ts/quote-props
|
|
7333
|
+
*/
|
|
7334
|
+
'@stylistic/quote-props'?: Linter.RuleEntry<StylisticQuoteProps>;
|
|
7335
|
+
/**
|
|
7336
|
+
* Enforce the consistent use of either backticks, double, or single quotes
|
|
7337
|
+
* @see https://eslint.style/rules/ts/quotes
|
|
7338
|
+
*/
|
|
7339
|
+
'@stylistic/quotes'?: Linter.RuleEntry<StylisticQuotes>;
|
|
7340
|
+
/**
|
|
7341
|
+
* Enforce spacing between rest and spread operators and their expressions
|
|
7342
|
+
* @see https://eslint.style/rules/js/rest-spread-spacing
|
|
7343
|
+
*/
|
|
7344
|
+
'@stylistic/rest-spread-spacing'?: Linter.RuleEntry<StylisticRestSpreadSpacing>;
|
|
7345
|
+
/**
|
|
7346
|
+
* Require or disallow semicolons instead of ASI
|
|
7347
|
+
* @see https://eslint.style/rules/ts/semi
|
|
7348
|
+
*/
|
|
7349
|
+
'@stylistic/semi'?: Linter.RuleEntry<StylisticSemi>;
|
|
7350
|
+
/**
|
|
7351
|
+
* Enforce consistent spacing before and after semicolons
|
|
7352
|
+
* @see https://eslint.style/rules/ts/semi-spacing
|
|
7353
|
+
*/
|
|
7354
|
+
'@stylistic/semi-spacing'?: Linter.RuleEntry<StylisticSemiSpacing>;
|
|
7355
|
+
/**
|
|
7356
|
+
* Enforce location of semicolons
|
|
7357
|
+
* @see https://eslint.style/rules/js/semi-style
|
|
7358
|
+
*/
|
|
7359
|
+
'@stylistic/semi-style'?: Linter.RuleEntry<StylisticSemiStyle>;
|
|
7360
|
+
/**
|
|
7361
|
+
* Enforce consistent spacing before blocks
|
|
7362
|
+
* @see https://eslint.style/rules/ts/space-before-blocks
|
|
7363
|
+
*/
|
|
7364
|
+
'@stylistic/space-before-blocks'?: Linter.RuleEntry<StylisticSpaceBeforeBlocks>;
|
|
7365
|
+
/**
|
|
7366
|
+
* Enforce consistent spacing before function parenthesis
|
|
7367
|
+
* @see https://eslint.style/rules/ts/space-before-function-paren
|
|
7368
|
+
*/
|
|
7369
|
+
'@stylistic/space-before-function-paren'?: Linter.RuleEntry<StylisticSpaceBeforeFunctionParen>;
|
|
7370
|
+
/**
|
|
7371
|
+
* Enforce consistent spacing inside parentheses
|
|
7372
|
+
* @see https://eslint.style/rules/js/space-in-parens
|
|
7373
|
+
*/
|
|
7374
|
+
'@stylistic/space-in-parens'?: Linter.RuleEntry<StylisticSpaceInParens>;
|
|
7375
|
+
/**
|
|
7376
|
+
* Require spacing around infix operators
|
|
7377
|
+
* @see https://eslint.style/rules/ts/space-infix-ops
|
|
7378
|
+
*/
|
|
7379
|
+
'@stylistic/space-infix-ops'?: Linter.RuleEntry<StylisticSpaceInfixOps>;
|
|
7380
|
+
/**
|
|
7381
|
+
* Enforce consistent spacing before or after unary operators
|
|
7382
|
+
* @see https://eslint.style/rules/js/space-unary-ops
|
|
7383
|
+
*/
|
|
7384
|
+
'@stylistic/space-unary-ops'?: Linter.RuleEntry<StylisticSpaceUnaryOps>;
|
|
7385
|
+
/**
|
|
7386
|
+
* Enforce consistent spacing after the `//` or `/*` in a comment
|
|
7387
|
+
* @see https://eslint.style/rules/js/spaced-comment
|
|
7388
|
+
*/
|
|
7389
|
+
'@stylistic/spaced-comment'?: Linter.RuleEntry<StylisticSpacedComment>;
|
|
7390
|
+
/**
|
|
7391
|
+
* Enforce spacing around colons of switch statements
|
|
7392
|
+
* @see https://eslint.style/rules/js/switch-colon-spacing
|
|
7393
|
+
*/
|
|
7394
|
+
'@stylistic/switch-colon-spacing'?: Linter.RuleEntry<StylisticSwitchColonSpacing>;
|
|
7395
|
+
/**
|
|
7396
|
+
* Require or disallow spacing around embedded expressions of template strings
|
|
7397
|
+
* @see https://eslint.style/rules/js/template-curly-spacing
|
|
7398
|
+
*/
|
|
7399
|
+
'@stylistic/template-curly-spacing'?: Linter.RuleEntry<StylisticTemplateCurlySpacing>;
|
|
7400
|
+
/**
|
|
7401
|
+
* Require or disallow spacing between template tags and their literals
|
|
7402
|
+
* @see https://eslint.style/rules/js/template-tag-spacing
|
|
7403
|
+
*/
|
|
7404
|
+
'@stylistic/template-tag-spacing'?: Linter.RuleEntry<StylisticTemplateTagSpacing>;
|
|
7405
|
+
/**
|
|
7406
|
+
* Require consistent spacing around type annotations
|
|
7407
|
+
* @see https://eslint.style/rules/ts/type-annotation-spacing
|
|
7408
|
+
*/
|
|
7409
|
+
'@stylistic/type-annotation-spacing'?: Linter.RuleEntry<StylisticTypeAnnotationSpacing>;
|
|
7410
|
+
/**
|
|
7411
|
+
* Enforces consistent spacing inside TypeScript type generics
|
|
7412
|
+
* @see https://eslint.style/rules/plus/type-generic-spacing
|
|
7413
|
+
*/
|
|
7414
|
+
'@stylistic/type-generic-spacing'?: Linter.RuleEntry<[]>;
|
|
7415
|
+
/**
|
|
7416
|
+
* Expect space before the type declaration in the named tuple
|
|
7417
|
+
* @see https://eslint.style/rules/plus/type-named-tuple-spacing
|
|
7418
|
+
*/
|
|
7419
|
+
'@stylistic/type-named-tuple-spacing'?: Linter.RuleEntry<[]>;
|
|
7420
|
+
/**
|
|
7421
|
+
* Require parentheses around immediate `function` invocations
|
|
7422
|
+
* @see https://eslint.style/rules/js/wrap-iife
|
|
7423
|
+
*/
|
|
7424
|
+
'@stylistic/wrap-iife'?: Linter.RuleEntry<StylisticWrapIife>;
|
|
7425
|
+
/**
|
|
7426
|
+
* Require parenthesis around regex literals
|
|
7427
|
+
* @see https://eslint.style/rules/js/wrap-regex
|
|
7428
|
+
*/
|
|
7429
|
+
'@stylistic/wrap-regex'?: Linter.RuleEntry<[]>;
|
|
7430
|
+
/**
|
|
7431
|
+
* Require or disallow spacing around the `*` in `yield*` expressions
|
|
7432
|
+
* @see https://eslint.style/rules/js/yield-star-spacing
|
|
7433
|
+
*/
|
|
7434
|
+
'@stylistic/yield-star-spacing'?: Linter.RuleEntry<StylisticYieldStarSpacing>;
|
|
7435
|
+
}
|
|
7436
|
+
type StylisticArrayBracketNewline = [] | [
|
|
7437
|
+
(("always" | "never" | "consistent") | {
|
|
7438
|
+
multiline?: boolean;
|
|
7439
|
+
minItems?: (number | null);
|
|
7440
|
+
})
|
|
7441
|
+
];
|
|
7442
|
+
type StylisticArrayBracketSpacing = [] | [("always" | "never")] | [
|
|
7443
|
+
("always" | "never"),
|
|
7444
|
+
{
|
|
7445
|
+
singleValue?: boolean;
|
|
7446
|
+
objectsInArrays?: boolean;
|
|
7447
|
+
arraysInArrays?: boolean;
|
|
7448
|
+
}
|
|
7449
|
+
];
|
|
7450
|
+
type StylisticArrayElementNewline = [] | [
|
|
7451
|
+
(_StylisticArrayElementNewlineBasicConfig | {
|
|
7452
|
+
ArrayExpression?: _StylisticArrayElementNewlineBasicConfig;
|
|
7453
|
+
ArrayPattern?: _StylisticArrayElementNewlineBasicConfig;
|
|
7454
|
+
})
|
|
7455
|
+
];
|
|
7456
|
+
type _StylisticArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
|
|
7457
|
+
consistent?: boolean;
|
|
7458
|
+
multiline?: boolean;
|
|
7459
|
+
minItems?: (number | null);
|
|
7460
|
+
});
|
|
7461
|
+
type StylisticArrowParens = [] | [("always" | "as-needed")] | [
|
|
7462
|
+
("always" | "as-needed"),
|
|
7463
|
+
{
|
|
7464
|
+
requireForBlockBody?: boolean;
|
|
7465
|
+
}
|
|
7466
|
+
];
|
|
7467
|
+
type StylisticArrowSpacing = [] | [
|
|
7468
|
+
{
|
|
7469
|
+
before?: boolean;
|
|
7470
|
+
after?: boolean;
|
|
7471
|
+
}
|
|
7472
|
+
];
|
|
7473
|
+
type StylisticBlockSpacing = [] | [("always" | "never")];
|
|
7474
|
+
type StylisticBraceStyle = [] | [("1tbs" | "stroustrup" | "allman")] | [
|
|
7475
|
+
("1tbs" | "stroustrup" | "allman"),
|
|
7476
|
+
{
|
|
7477
|
+
allowSingleLine?: boolean;
|
|
7478
|
+
}
|
|
7479
|
+
];
|
|
7480
|
+
type StylisticCommaDangle = [] | [
|
|
7481
|
+
(_StylisticCommaDangleValue | {
|
|
7482
|
+
arrays?: _StylisticCommaDangleValueWithIgnore;
|
|
7483
|
+
objects?: _StylisticCommaDangleValueWithIgnore;
|
|
7484
|
+
imports?: _StylisticCommaDangleValueWithIgnore;
|
|
7485
|
+
exports?: _StylisticCommaDangleValueWithIgnore;
|
|
7486
|
+
functions?: _StylisticCommaDangleValueWithIgnore;
|
|
7487
|
+
importAttributes?: _StylisticCommaDangleValueWithIgnore;
|
|
7488
|
+
dynamicImports?: _StylisticCommaDangleValueWithIgnore;
|
|
7489
|
+
enums?: _StylisticCommaDangleValueWithIgnore;
|
|
7490
|
+
generics?: _StylisticCommaDangleValueWithIgnore;
|
|
7491
|
+
tuples?: _StylisticCommaDangleValueWithIgnore;
|
|
7492
|
+
})
|
|
7493
|
+
];
|
|
7494
|
+
type _StylisticCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
|
|
7495
|
+
type _StylisticCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore");
|
|
7496
|
+
type StylisticCommaSpacing = [] | [
|
|
7497
|
+
{
|
|
7498
|
+
before?: boolean;
|
|
7499
|
+
after?: boolean;
|
|
7500
|
+
}
|
|
7501
|
+
];
|
|
7502
|
+
type StylisticCommaStyle = [] | [("first" | "last")] | [
|
|
7503
|
+
("first" | "last"),
|
|
7504
|
+
{
|
|
7505
|
+
exceptions?: {
|
|
7506
|
+
[k: string]: boolean | undefined;
|
|
7507
|
+
};
|
|
7508
|
+
}
|
|
7509
|
+
];
|
|
7510
|
+
type StylisticComputedPropertySpacing = [] | [("always" | "never")] | [
|
|
7511
|
+
("always" | "never"),
|
|
7512
|
+
{
|
|
7513
|
+
enforceForClassMembers?: boolean;
|
|
7514
|
+
}
|
|
7515
|
+
];
|
|
7516
|
+
type StylisticCurlyNewline = [] | [
|
|
7517
|
+
(("always" | "never") | {
|
|
7518
|
+
IfStatementConsequent?: (("always" | "never") | {
|
|
7519
|
+
multiline?: boolean;
|
|
7520
|
+
minElements?: number;
|
|
7521
|
+
consistent?: boolean;
|
|
7522
|
+
});
|
|
7523
|
+
IfStatementAlternative?: (("always" | "never") | {
|
|
7524
|
+
multiline?: boolean;
|
|
7525
|
+
minElements?: number;
|
|
7526
|
+
consistent?: boolean;
|
|
7527
|
+
});
|
|
7528
|
+
DoWhileStatement?: (("always" | "never") | {
|
|
7529
|
+
multiline?: boolean;
|
|
7530
|
+
minElements?: number;
|
|
7531
|
+
consistent?: boolean;
|
|
7532
|
+
});
|
|
7533
|
+
ForInStatement?: (("always" | "never") | {
|
|
7534
|
+
multiline?: boolean;
|
|
7535
|
+
minElements?: number;
|
|
7536
|
+
consistent?: boolean;
|
|
7537
|
+
});
|
|
7538
|
+
ForOfStatement?: (("always" | "never") | {
|
|
7539
|
+
multiline?: boolean;
|
|
7540
|
+
minElements?: number;
|
|
7541
|
+
consistent?: boolean;
|
|
7542
|
+
});
|
|
7543
|
+
ForStatement?: (("always" | "never") | {
|
|
7544
|
+
multiline?: boolean;
|
|
7545
|
+
minElements?: number;
|
|
7546
|
+
consistent?: boolean;
|
|
7547
|
+
});
|
|
7548
|
+
WhileStatement?: (("always" | "never") | {
|
|
7549
|
+
multiline?: boolean;
|
|
7550
|
+
minElements?: number;
|
|
7551
|
+
consistent?: boolean;
|
|
7552
|
+
});
|
|
7553
|
+
SwitchStatement?: (("always" | "never") | {
|
|
7554
|
+
multiline?: boolean;
|
|
7555
|
+
minElements?: number;
|
|
7556
|
+
consistent?: boolean;
|
|
7557
|
+
});
|
|
7558
|
+
SwitchCase?: (("always" | "never") | {
|
|
7559
|
+
multiline?: boolean;
|
|
7560
|
+
minElements?: number;
|
|
7561
|
+
consistent?: boolean;
|
|
7562
|
+
});
|
|
7563
|
+
TryStatementBlock?: (("always" | "never") | {
|
|
7564
|
+
multiline?: boolean;
|
|
7565
|
+
minElements?: number;
|
|
7566
|
+
consistent?: boolean;
|
|
7567
|
+
});
|
|
7568
|
+
TryStatementHandler?: (("always" | "never") | {
|
|
7569
|
+
multiline?: boolean;
|
|
7570
|
+
minElements?: number;
|
|
7571
|
+
consistent?: boolean;
|
|
7572
|
+
});
|
|
7573
|
+
TryStatementFinalizer?: (("always" | "never") | {
|
|
7574
|
+
multiline?: boolean;
|
|
7575
|
+
minElements?: number;
|
|
7576
|
+
consistent?: boolean;
|
|
7577
|
+
});
|
|
7578
|
+
BlockStatement?: (("always" | "never") | {
|
|
7579
|
+
multiline?: boolean;
|
|
7580
|
+
minElements?: number;
|
|
7581
|
+
consistent?: boolean;
|
|
7582
|
+
});
|
|
7583
|
+
ArrowFunctionExpression?: (("always" | "never") | {
|
|
7584
|
+
multiline?: boolean;
|
|
7585
|
+
minElements?: number;
|
|
7586
|
+
consistent?: boolean;
|
|
7587
|
+
});
|
|
7588
|
+
FunctionDeclaration?: (("always" | "never") | {
|
|
7589
|
+
multiline?: boolean;
|
|
7590
|
+
minElements?: number;
|
|
7591
|
+
consistent?: boolean;
|
|
7592
|
+
});
|
|
7593
|
+
FunctionExpression?: (("always" | "never") | {
|
|
7594
|
+
multiline?: boolean;
|
|
7595
|
+
minElements?: number;
|
|
7596
|
+
consistent?: boolean;
|
|
7597
|
+
});
|
|
7598
|
+
Property?: (("always" | "never") | {
|
|
7599
|
+
multiline?: boolean;
|
|
7600
|
+
minElements?: number;
|
|
7601
|
+
consistent?: boolean;
|
|
7602
|
+
});
|
|
7603
|
+
ClassBody?: (("always" | "never") | {
|
|
7604
|
+
multiline?: boolean;
|
|
7605
|
+
minElements?: number;
|
|
7606
|
+
consistent?: boolean;
|
|
7607
|
+
});
|
|
7608
|
+
StaticBlock?: (("always" | "never") | {
|
|
7609
|
+
multiline?: boolean;
|
|
7610
|
+
minElements?: number;
|
|
7611
|
+
consistent?: boolean;
|
|
7612
|
+
});
|
|
7613
|
+
WithStatement?: (("always" | "never") | {
|
|
7614
|
+
multiline?: boolean;
|
|
7615
|
+
minElements?: number;
|
|
7616
|
+
consistent?: boolean;
|
|
7617
|
+
});
|
|
7618
|
+
TSEnumBody?: (("always" | "never") | {
|
|
7619
|
+
multiline?: boolean;
|
|
7620
|
+
minElements?: number;
|
|
7621
|
+
consistent?: boolean;
|
|
7622
|
+
});
|
|
7623
|
+
TSInterfaceBody?: (("always" | "never") | {
|
|
7624
|
+
multiline?: boolean;
|
|
7625
|
+
minElements?: number;
|
|
7626
|
+
consistent?: boolean;
|
|
7627
|
+
});
|
|
7628
|
+
TSModuleBlock?: (("always" | "never") | {
|
|
7629
|
+
multiline?: boolean;
|
|
7630
|
+
minElements?: number;
|
|
7631
|
+
consistent?: boolean;
|
|
7632
|
+
});
|
|
7633
|
+
multiline?: boolean;
|
|
7634
|
+
minElements?: number;
|
|
7635
|
+
consistent?: boolean;
|
|
7636
|
+
})
|
|
7637
|
+
];
|
|
7638
|
+
type StylisticDotLocation = [] | [("object" | "property")];
|
|
7639
|
+
type StylisticEolLast = [] | [("always" | "never" | "unix" | "windows")];
|
|
7640
|
+
type StylisticFuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
|
|
7641
|
+
"always",
|
|
7642
|
+
{
|
|
7643
|
+
allowNewlines?: boolean;
|
|
7644
|
+
optionalChain?: {
|
|
7645
|
+
before?: boolean;
|
|
7646
|
+
after?: boolean;
|
|
7647
|
+
};
|
|
7648
|
+
}
|
|
7649
|
+
]);
|
|
7650
|
+
type StylisticFunctionCallArgumentNewline = [] | [("always" | "never" | "consistent")];
|
|
7651
|
+
type StylisticFunctionCallSpacing = ([] | ["never"] | [] | ["always"] | [
|
|
7652
|
+
"always",
|
|
7653
|
+
{
|
|
7654
|
+
allowNewlines?: boolean;
|
|
7655
|
+
optionalChain?: {
|
|
7656
|
+
before?: boolean;
|
|
7657
|
+
after?: boolean;
|
|
7658
|
+
};
|
|
7659
|
+
}
|
|
7660
|
+
]);
|
|
7661
|
+
type StylisticFunctionParenNewline = [] | [
|
|
7662
|
+
(("always" | "never" | "consistent" | "multiline" | "multiline-arguments") | {
|
|
7663
|
+
minItems?: number;
|
|
7664
|
+
})
|
|
7665
|
+
];
|
|
7666
|
+
type StylisticGeneratorStarSpacing = [] | [
|
|
7667
|
+
(("before" | "after" | "both" | "neither") | {
|
|
7668
|
+
before?: boolean;
|
|
7669
|
+
after?: boolean;
|
|
7670
|
+
named?: (("before" | "after" | "both" | "neither") | {
|
|
7671
|
+
before?: boolean;
|
|
7672
|
+
after?: boolean;
|
|
7673
|
+
});
|
|
7674
|
+
anonymous?: (("before" | "after" | "both" | "neither") | {
|
|
7675
|
+
before?: boolean;
|
|
7676
|
+
after?: boolean;
|
|
7677
|
+
});
|
|
7678
|
+
method?: (("before" | "after" | "both" | "neither") | {
|
|
7679
|
+
before?: boolean;
|
|
7680
|
+
after?: boolean;
|
|
7681
|
+
});
|
|
7682
|
+
})
|
|
7683
|
+
];
|
|
7684
|
+
type StylisticImplicitArrowLinebreak = [] | [("beside" | "below")];
|
|
7685
|
+
type StylisticIndent = [] | [("tab" | number)] | [
|
|
7686
|
+
("tab" | number),
|
|
7687
|
+
{
|
|
7688
|
+
SwitchCase?: number;
|
|
7689
|
+
VariableDeclarator?: ((number | ("first" | "off")) | {
|
|
7690
|
+
var?: (number | ("first" | "off"));
|
|
7691
|
+
let?: (number | ("first" | "off"));
|
|
7692
|
+
const?: (number | ("first" | "off"));
|
|
7693
|
+
});
|
|
7694
|
+
outerIIFEBody?: (number | "off");
|
|
7695
|
+
MemberExpression?: (number | "off");
|
|
7696
|
+
FunctionDeclaration?: {
|
|
7697
|
+
parameters?: (number | ("first" | "off"));
|
|
7698
|
+
body?: number;
|
|
7699
|
+
};
|
|
7700
|
+
FunctionExpression?: {
|
|
7701
|
+
parameters?: (number | ("first" | "off"));
|
|
7702
|
+
body?: number;
|
|
7703
|
+
};
|
|
7704
|
+
StaticBlock?: {
|
|
7705
|
+
body?: number;
|
|
7706
|
+
};
|
|
7707
|
+
CallExpression?: {
|
|
7708
|
+
arguments?: (number | ("first" | "off"));
|
|
7709
|
+
};
|
|
7710
|
+
ArrayExpression?: (number | ("first" | "off"));
|
|
7711
|
+
ObjectExpression?: (number | ("first" | "off"));
|
|
7712
|
+
ImportDeclaration?: (number | ("first" | "off"));
|
|
7713
|
+
flatTernaryExpressions?: boolean;
|
|
7714
|
+
offsetTernaryExpressions?: boolean;
|
|
7715
|
+
offsetTernaryExpressionsOffsetCallExpressions?: boolean;
|
|
7716
|
+
ignoredNodes?: string[];
|
|
7717
|
+
ignoreComments?: boolean;
|
|
7718
|
+
tabLength?: number;
|
|
7719
|
+
}
|
|
7720
|
+
];
|
|
7721
|
+
type StylisticIndentBinaryOps = [] | [(number | "tab")];
|
|
7722
|
+
type StylisticJsxClosingBracketLocation = [] | [
|
|
7723
|
+
(("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | {
|
|
7724
|
+
location?: ("after-props" | "props-aligned" | "tag-aligned" | "line-aligned");
|
|
7725
|
+
} | {
|
|
7726
|
+
nonEmpty?: (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | false);
|
|
7727
|
+
selfClosing?: (("after-props" | "props-aligned" | "tag-aligned" | "line-aligned") | false);
|
|
7728
|
+
})
|
|
7729
|
+
];
|
|
7730
|
+
type StylisticJsxClosingTagLocation = [] | [("tag-aligned" | "line-aligned")];
|
|
7731
|
+
type StylisticJsxCurlyBracePresence = [] | [
|
|
7732
|
+
({
|
|
7733
|
+
props?: ("always" | "never" | "ignore");
|
|
7734
|
+
children?: ("always" | "never" | "ignore");
|
|
7735
|
+
propElementValues?: ("always" | "never" | "ignore");
|
|
7736
|
+
} | ("always" | "never" | "ignore"))
|
|
7737
|
+
];
|
|
7738
|
+
type StylisticJsxCurlyNewline = [] | [
|
|
7739
|
+
(("consistent" | "never") | {
|
|
7740
|
+
singleline?: ("consistent" | "require" | "forbid");
|
|
7741
|
+
multiline?: ("consistent" | "require" | "forbid");
|
|
7742
|
+
})
|
|
7743
|
+
];
|
|
7744
|
+
type StylisticJsxCurlySpacing = [] | [
|
|
7745
|
+
((_StylisticJsxCurlySpacing_BasicConfig & {
|
|
7746
|
+
attributes?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
|
|
7747
|
+
children?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
|
|
7748
|
+
[k: string]: unknown | undefined;
|
|
7749
|
+
}) | ("always" | "never"))
|
|
7750
|
+
] | [
|
|
7751
|
+
((_StylisticJsxCurlySpacing_BasicConfig & {
|
|
7752
|
+
attributes?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
|
|
7753
|
+
children?: _StylisticJsxCurlySpacingBasicConfigOrBoolean;
|
|
7754
|
+
[k: string]: unknown | undefined;
|
|
7755
|
+
}) | ("always" | "never")),
|
|
7756
|
+
{
|
|
7757
|
+
allowMultiline?: boolean;
|
|
7758
|
+
spacing?: {
|
|
7759
|
+
objectLiterals?: ("always" | "never");
|
|
7760
|
+
[k: string]: unknown | undefined;
|
|
7761
|
+
};
|
|
7762
|
+
}
|
|
7763
|
+
];
|
|
7764
|
+
type _StylisticJsxCurlySpacingBasicConfigOrBoolean = (_StylisticJsxCurlySpacing_BasicConfig | boolean);
|
|
7765
|
+
interface _StylisticJsxCurlySpacing_BasicConfig {
|
|
7766
|
+
when?: ("always" | "never");
|
|
7767
|
+
allowMultiline?: boolean;
|
|
7768
|
+
spacing?: {
|
|
7769
|
+
objectLiterals?: ("always" | "never");
|
|
7770
|
+
[k: string]: unknown | undefined;
|
|
7771
|
+
};
|
|
7772
|
+
[k: string]: unknown | undefined;
|
|
7773
|
+
}
|
|
7774
|
+
type StylisticJsxEqualsSpacing = [] | [("always" | "never")];
|
|
7775
|
+
type StylisticJsxFirstPropNewLine = [] | [("always" | "never" | "multiline" | "multiline-multiprop" | "multiprop")];
|
|
7776
|
+
type StylisticJsxFunctionCallNewline = [] | [("always" | "multiline")];
|
|
7777
|
+
type StylisticJsxIndent = [] | [("tab" | number)] | [
|
|
7778
|
+
("tab" | number),
|
|
7779
|
+
{
|
|
7780
|
+
checkAttributes?: boolean;
|
|
7781
|
+
indentLogicalExpressions?: boolean;
|
|
7782
|
+
}
|
|
7783
|
+
];
|
|
7784
|
+
type StylisticJsxIndentProps = [] | [
|
|
7785
|
+
(("tab" | "first") | number | {
|
|
7786
|
+
indentMode?: (("tab" | "first") | number);
|
|
7787
|
+
ignoreTernaryOperator?: boolean;
|
|
7788
|
+
[k: string]: unknown | undefined;
|
|
7789
|
+
})
|
|
7790
|
+
];
|
|
7791
|
+
type StylisticJsxMaxPropsPerLine = [] | [
|
|
7792
|
+
({
|
|
7793
|
+
maximum?: {
|
|
7794
|
+
single?: number;
|
|
7795
|
+
multi?: number;
|
|
7796
|
+
[k: string]: unknown | undefined;
|
|
7797
|
+
};
|
|
7798
|
+
} | {
|
|
7799
|
+
maximum?: number;
|
|
7800
|
+
when?: ("always" | "multiline");
|
|
7801
|
+
})
|
|
7802
|
+
];
|
|
7803
|
+
type StylisticJsxNewline = [] | [
|
|
7804
|
+
{
|
|
7805
|
+
prevent?: boolean;
|
|
7806
|
+
allowMultilines?: boolean;
|
|
7807
|
+
}
|
|
7808
|
+
];
|
|
7809
|
+
type StylisticJsxOneExpressionPerLine = [] | [
|
|
7810
|
+
{
|
|
7811
|
+
allow?: ("none" | "literal" | "single-child" | "single-line" | "non-jsx");
|
|
7812
|
+
}
|
|
7813
|
+
];
|
|
7814
|
+
type StylisticJsxPascalCase = [] | [
|
|
7815
|
+
{
|
|
7816
|
+
allowAllCaps?: boolean;
|
|
7817
|
+
allowLeadingUnderscore?: boolean;
|
|
7818
|
+
allowNamespace?: boolean;
|
|
7819
|
+
ignore?: string[];
|
|
7820
|
+
}
|
|
7821
|
+
];
|
|
7822
|
+
type StylisticJsxQuotes = [] | [("prefer-single" | "prefer-double")];
|
|
7823
|
+
type StylisticJsxSelfClosingComp = [] | [
|
|
7824
|
+
{
|
|
7825
|
+
component?: boolean;
|
|
7826
|
+
html?: boolean;
|
|
7827
|
+
}
|
|
7828
|
+
];
|
|
7829
|
+
type StylisticJsxSortProps = [] | [
|
|
7830
|
+
{
|
|
7831
|
+
callbacksLast?: boolean;
|
|
7832
|
+
shorthandFirst?: boolean;
|
|
7833
|
+
shorthandLast?: boolean;
|
|
7834
|
+
multiline?: ("ignore" | "first" | "last");
|
|
7835
|
+
ignoreCase?: boolean;
|
|
7836
|
+
noSortAlphabetically?: boolean;
|
|
7837
|
+
reservedFirst?: (unknown[] | boolean);
|
|
7838
|
+
locale?: string;
|
|
7839
|
+
}
|
|
7840
|
+
];
|
|
7841
|
+
type StylisticJsxTagSpacing = [] | [
|
|
7842
|
+
{
|
|
7843
|
+
closingSlash?: ("always" | "never" | "allow");
|
|
7844
|
+
beforeSelfClosing?: ("always" | "proportional-always" | "never" | "allow");
|
|
7845
|
+
afterOpening?: ("always" | "allow-multiline" | "never" | "allow");
|
|
7846
|
+
beforeClosing?: ("always" | "proportional-always" | "never" | "allow");
|
|
7847
|
+
}
|
|
7848
|
+
];
|
|
7849
|
+
type StylisticJsxWrapMultilines = [] | [
|
|
7850
|
+
{
|
|
7851
|
+
declaration?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7852
|
+
assignment?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7853
|
+
return?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7854
|
+
arrow?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7855
|
+
condition?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7856
|
+
logical?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7857
|
+
prop?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7858
|
+
propertyValue?: ((true | false | "ignore" | "parens" | "parens-new-line") | (true | false | "ignore" | "parens" | "parens-new-line"));
|
|
7859
|
+
}
|
|
7860
|
+
];
|
|
7861
|
+
type StylisticKeySpacing = [] | [
|
|
7862
|
+
({
|
|
7863
|
+
align?: (("colon" | "value") | {
|
|
7864
|
+
mode?: ("strict" | "minimum");
|
|
7865
|
+
on?: ("colon" | "value");
|
|
7866
|
+
beforeColon?: boolean;
|
|
7867
|
+
afterColon?: boolean;
|
|
7868
|
+
});
|
|
7869
|
+
mode?: ("strict" | "minimum");
|
|
7870
|
+
beforeColon?: boolean;
|
|
7871
|
+
afterColon?: boolean;
|
|
7872
|
+
ignoredNodes?: ("ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportNamedDeclaration" | "ExportAllDeclaration" | "TSTypeLiteral" | "TSInterfaceBody" | "ClassBody")[];
|
|
7873
|
+
} | {
|
|
7874
|
+
singleLine?: {
|
|
7875
|
+
mode?: ("strict" | "minimum");
|
|
7876
|
+
beforeColon?: boolean;
|
|
7877
|
+
afterColon?: boolean;
|
|
7878
|
+
};
|
|
7879
|
+
multiLine?: {
|
|
7880
|
+
align?: (("colon" | "value") | {
|
|
7881
|
+
mode?: ("strict" | "minimum");
|
|
7882
|
+
on?: ("colon" | "value");
|
|
7883
|
+
beforeColon?: boolean;
|
|
7884
|
+
afterColon?: boolean;
|
|
7885
|
+
});
|
|
7886
|
+
mode?: ("strict" | "minimum");
|
|
7887
|
+
beforeColon?: boolean;
|
|
7888
|
+
afterColon?: boolean;
|
|
7889
|
+
};
|
|
7890
|
+
} | {
|
|
7891
|
+
singleLine?: {
|
|
7892
|
+
mode?: ("strict" | "minimum");
|
|
7893
|
+
beforeColon?: boolean;
|
|
7894
|
+
afterColon?: boolean;
|
|
7895
|
+
};
|
|
7896
|
+
multiLine?: {
|
|
7897
|
+
mode?: ("strict" | "minimum");
|
|
7898
|
+
beforeColon?: boolean;
|
|
7899
|
+
afterColon?: boolean;
|
|
7900
|
+
};
|
|
7901
|
+
align?: {
|
|
7902
|
+
mode?: ("strict" | "minimum");
|
|
7903
|
+
on?: ("colon" | "value");
|
|
7904
|
+
beforeColon?: boolean;
|
|
7905
|
+
afterColon?: boolean;
|
|
7906
|
+
};
|
|
7907
|
+
})
|
|
7908
|
+
];
|
|
7909
|
+
type StylisticKeywordSpacing = [] | [
|
|
7910
|
+
{
|
|
7911
|
+
before?: boolean;
|
|
7912
|
+
after?: boolean;
|
|
7913
|
+
overrides?: {
|
|
7914
|
+
abstract?: {
|
|
7915
|
+
before?: boolean;
|
|
7916
|
+
after?: boolean;
|
|
7917
|
+
};
|
|
7918
|
+
as?: {
|
|
7919
|
+
before?: boolean;
|
|
7920
|
+
after?: boolean;
|
|
7921
|
+
};
|
|
7922
|
+
async?: {
|
|
7923
|
+
before?: boolean;
|
|
7924
|
+
after?: boolean;
|
|
7925
|
+
};
|
|
7926
|
+
await?: {
|
|
7927
|
+
before?: boolean;
|
|
7928
|
+
after?: boolean;
|
|
7929
|
+
};
|
|
7930
|
+
boolean?: {
|
|
7931
|
+
before?: boolean;
|
|
7932
|
+
after?: boolean;
|
|
7933
|
+
};
|
|
7934
|
+
break?: {
|
|
7935
|
+
before?: boolean;
|
|
7936
|
+
after?: boolean;
|
|
7937
|
+
};
|
|
7938
|
+
byte?: {
|
|
7939
|
+
before?: boolean;
|
|
7940
|
+
after?: boolean;
|
|
7941
|
+
};
|
|
7942
|
+
case?: {
|
|
7943
|
+
before?: boolean;
|
|
7944
|
+
after?: boolean;
|
|
7945
|
+
};
|
|
7946
|
+
catch?: {
|
|
7947
|
+
before?: boolean;
|
|
7948
|
+
after?: boolean;
|
|
7949
|
+
};
|
|
7950
|
+
char?: {
|
|
7951
|
+
before?: boolean;
|
|
7952
|
+
after?: boolean;
|
|
7953
|
+
};
|
|
7954
|
+
class?: {
|
|
7955
|
+
before?: boolean;
|
|
7956
|
+
after?: boolean;
|
|
7957
|
+
};
|
|
7958
|
+
const?: {
|
|
7959
|
+
before?: boolean;
|
|
7960
|
+
after?: boolean;
|
|
7961
|
+
};
|
|
7962
|
+
continue?: {
|
|
7963
|
+
before?: boolean;
|
|
7964
|
+
after?: boolean;
|
|
7965
|
+
};
|
|
7966
|
+
debugger?: {
|
|
7967
|
+
before?: boolean;
|
|
7968
|
+
after?: boolean;
|
|
7969
|
+
};
|
|
7970
|
+
default?: {
|
|
7971
|
+
before?: boolean;
|
|
7972
|
+
after?: boolean;
|
|
7973
|
+
};
|
|
7974
|
+
delete?: {
|
|
7975
|
+
before?: boolean;
|
|
7976
|
+
after?: boolean;
|
|
7977
|
+
};
|
|
7978
|
+
do?: {
|
|
7979
|
+
before?: boolean;
|
|
7980
|
+
after?: boolean;
|
|
7981
|
+
};
|
|
7982
|
+
double?: {
|
|
7983
|
+
before?: boolean;
|
|
7984
|
+
after?: boolean;
|
|
7985
|
+
};
|
|
7986
|
+
else?: {
|
|
7987
|
+
before?: boolean;
|
|
7988
|
+
after?: boolean;
|
|
7989
|
+
};
|
|
7990
|
+
enum?: {
|
|
7991
|
+
before?: boolean;
|
|
7992
|
+
after?: boolean;
|
|
7993
|
+
};
|
|
7994
|
+
export?: {
|
|
7995
|
+
before?: boolean;
|
|
7996
|
+
after?: boolean;
|
|
7997
|
+
};
|
|
7998
|
+
extends?: {
|
|
7999
|
+
before?: boolean;
|
|
8000
|
+
after?: boolean;
|
|
8001
|
+
};
|
|
8002
|
+
false?: {
|
|
8003
|
+
before?: boolean;
|
|
8004
|
+
after?: boolean;
|
|
8005
|
+
};
|
|
8006
|
+
final?: {
|
|
8007
|
+
before?: boolean;
|
|
8008
|
+
after?: boolean;
|
|
8009
|
+
};
|
|
8010
|
+
finally?: {
|
|
8011
|
+
before?: boolean;
|
|
8012
|
+
after?: boolean;
|
|
8013
|
+
};
|
|
8014
|
+
float?: {
|
|
8015
|
+
before?: boolean;
|
|
8016
|
+
after?: boolean;
|
|
8017
|
+
};
|
|
8018
|
+
for?: {
|
|
8019
|
+
before?: boolean;
|
|
8020
|
+
after?: boolean;
|
|
8021
|
+
};
|
|
8022
|
+
from?: {
|
|
8023
|
+
before?: boolean;
|
|
8024
|
+
after?: boolean;
|
|
8025
|
+
};
|
|
8026
|
+
function?: {
|
|
8027
|
+
before?: boolean;
|
|
8028
|
+
after?: boolean;
|
|
8029
|
+
};
|
|
8030
|
+
get?: {
|
|
8031
|
+
before?: boolean;
|
|
8032
|
+
after?: boolean;
|
|
8033
|
+
};
|
|
8034
|
+
goto?: {
|
|
8035
|
+
before?: boolean;
|
|
8036
|
+
after?: boolean;
|
|
8037
|
+
};
|
|
8038
|
+
if?: {
|
|
8039
|
+
before?: boolean;
|
|
8040
|
+
after?: boolean;
|
|
8041
|
+
};
|
|
8042
|
+
implements?: {
|
|
8043
|
+
before?: boolean;
|
|
8044
|
+
after?: boolean;
|
|
8045
|
+
};
|
|
8046
|
+
import?: {
|
|
8047
|
+
before?: boolean;
|
|
8048
|
+
after?: boolean;
|
|
8049
|
+
};
|
|
8050
|
+
in?: {
|
|
8051
|
+
before?: boolean;
|
|
8052
|
+
after?: boolean;
|
|
8053
|
+
};
|
|
8054
|
+
instanceof?: {
|
|
8055
|
+
before?: boolean;
|
|
8056
|
+
after?: boolean;
|
|
8057
|
+
};
|
|
8058
|
+
int?: {
|
|
8059
|
+
before?: boolean;
|
|
8060
|
+
after?: boolean;
|
|
8061
|
+
};
|
|
8062
|
+
interface?: {
|
|
8063
|
+
before?: boolean;
|
|
8064
|
+
after?: boolean;
|
|
8065
|
+
};
|
|
8066
|
+
let?: {
|
|
8067
|
+
before?: boolean;
|
|
8068
|
+
after?: boolean;
|
|
8069
|
+
};
|
|
8070
|
+
long?: {
|
|
8071
|
+
before?: boolean;
|
|
8072
|
+
after?: boolean;
|
|
8073
|
+
};
|
|
8074
|
+
native?: {
|
|
8075
|
+
before?: boolean;
|
|
8076
|
+
after?: boolean;
|
|
8077
|
+
};
|
|
8078
|
+
new?: {
|
|
8079
|
+
before?: boolean;
|
|
8080
|
+
after?: boolean;
|
|
8081
|
+
};
|
|
8082
|
+
null?: {
|
|
8083
|
+
before?: boolean;
|
|
8084
|
+
after?: boolean;
|
|
8085
|
+
};
|
|
8086
|
+
of?: {
|
|
8087
|
+
before?: boolean;
|
|
8088
|
+
after?: boolean;
|
|
8089
|
+
};
|
|
8090
|
+
package?: {
|
|
8091
|
+
before?: boolean;
|
|
8092
|
+
after?: boolean;
|
|
8093
|
+
};
|
|
8094
|
+
private?: {
|
|
8095
|
+
before?: boolean;
|
|
8096
|
+
after?: boolean;
|
|
8097
|
+
};
|
|
8098
|
+
protected?: {
|
|
8099
|
+
before?: boolean;
|
|
8100
|
+
after?: boolean;
|
|
8101
|
+
};
|
|
8102
|
+
public?: {
|
|
8103
|
+
before?: boolean;
|
|
8104
|
+
after?: boolean;
|
|
8105
|
+
};
|
|
8106
|
+
return?: {
|
|
8107
|
+
before?: boolean;
|
|
8108
|
+
after?: boolean;
|
|
8109
|
+
};
|
|
8110
|
+
satisfies?: {
|
|
8111
|
+
before?: boolean;
|
|
8112
|
+
after?: boolean;
|
|
8113
|
+
};
|
|
8114
|
+
set?: {
|
|
8115
|
+
before?: boolean;
|
|
8116
|
+
after?: boolean;
|
|
8117
|
+
};
|
|
8118
|
+
short?: {
|
|
8119
|
+
before?: boolean;
|
|
8120
|
+
after?: boolean;
|
|
8121
|
+
};
|
|
8122
|
+
static?: {
|
|
8123
|
+
before?: boolean;
|
|
8124
|
+
after?: boolean;
|
|
8125
|
+
};
|
|
8126
|
+
super?: {
|
|
8127
|
+
before?: boolean;
|
|
8128
|
+
after?: boolean;
|
|
8129
|
+
};
|
|
8130
|
+
switch?: {
|
|
8131
|
+
before?: boolean;
|
|
8132
|
+
after?: boolean;
|
|
8133
|
+
};
|
|
8134
|
+
synchronized?: {
|
|
8135
|
+
before?: boolean;
|
|
8136
|
+
after?: boolean;
|
|
8137
|
+
};
|
|
8138
|
+
this?: {
|
|
8139
|
+
before?: boolean;
|
|
8140
|
+
after?: boolean;
|
|
8141
|
+
};
|
|
8142
|
+
throw?: {
|
|
8143
|
+
before?: boolean;
|
|
8144
|
+
after?: boolean;
|
|
8145
|
+
};
|
|
8146
|
+
throws?: {
|
|
8147
|
+
before?: boolean;
|
|
8148
|
+
after?: boolean;
|
|
8149
|
+
};
|
|
8150
|
+
transient?: {
|
|
8151
|
+
before?: boolean;
|
|
8152
|
+
after?: boolean;
|
|
8153
|
+
};
|
|
8154
|
+
true?: {
|
|
8155
|
+
before?: boolean;
|
|
8156
|
+
after?: boolean;
|
|
8157
|
+
};
|
|
8158
|
+
try?: {
|
|
8159
|
+
before?: boolean;
|
|
8160
|
+
after?: boolean;
|
|
8161
|
+
};
|
|
8162
|
+
typeof?: {
|
|
8163
|
+
before?: boolean;
|
|
8164
|
+
after?: boolean;
|
|
8165
|
+
};
|
|
8166
|
+
var?: {
|
|
8167
|
+
before?: boolean;
|
|
8168
|
+
after?: boolean;
|
|
8169
|
+
};
|
|
8170
|
+
void?: {
|
|
8171
|
+
before?: boolean;
|
|
8172
|
+
after?: boolean;
|
|
8173
|
+
};
|
|
8174
|
+
volatile?: {
|
|
8175
|
+
before?: boolean;
|
|
8176
|
+
after?: boolean;
|
|
8177
|
+
};
|
|
8178
|
+
while?: {
|
|
8179
|
+
before?: boolean;
|
|
8180
|
+
after?: boolean;
|
|
8181
|
+
};
|
|
8182
|
+
with?: {
|
|
8183
|
+
before?: boolean;
|
|
8184
|
+
after?: boolean;
|
|
8185
|
+
};
|
|
8186
|
+
yield?: {
|
|
8187
|
+
before?: boolean;
|
|
8188
|
+
after?: boolean;
|
|
8189
|
+
};
|
|
8190
|
+
type?: {
|
|
8191
|
+
before?: boolean;
|
|
8192
|
+
after?: boolean;
|
|
8193
|
+
};
|
|
8194
|
+
};
|
|
8195
|
+
}
|
|
8196
|
+
];
|
|
8197
|
+
type StylisticLineCommentPosition = [] | [
|
|
8198
|
+
(("above" | "beside") | {
|
|
8199
|
+
position?: ("above" | "beside");
|
|
8200
|
+
ignorePattern?: string;
|
|
8201
|
+
applyDefaultPatterns?: boolean;
|
|
8202
|
+
applyDefaultIgnorePatterns?: boolean;
|
|
8203
|
+
})
|
|
8204
|
+
];
|
|
8205
|
+
type StylisticLinebreakStyle = [] | [("unix" | "windows")];
|
|
8206
|
+
type StylisticLinesAroundComment = [] | [
|
|
8207
|
+
{
|
|
8208
|
+
beforeBlockComment?: boolean;
|
|
8209
|
+
afterBlockComment?: boolean;
|
|
8210
|
+
beforeLineComment?: boolean;
|
|
8211
|
+
afterLineComment?: boolean;
|
|
8212
|
+
allowBlockStart?: boolean;
|
|
8213
|
+
allowBlockEnd?: boolean;
|
|
8214
|
+
allowClassStart?: boolean;
|
|
8215
|
+
allowClassEnd?: boolean;
|
|
8216
|
+
allowObjectStart?: boolean;
|
|
8217
|
+
allowObjectEnd?: boolean;
|
|
8218
|
+
allowArrayStart?: boolean;
|
|
8219
|
+
allowArrayEnd?: boolean;
|
|
8220
|
+
allowInterfaceStart?: boolean;
|
|
8221
|
+
allowInterfaceEnd?: boolean;
|
|
8222
|
+
allowTypeStart?: boolean;
|
|
8223
|
+
allowTypeEnd?: boolean;
|
|
8224
|
+
allowEnumStart?: boolean;
|
|
8225
|
+
allowEnumEnd?: boolean;
|
|
8226
|
+
allowModuleStart?: boolean;
|
|
8227
|
+
allowModuleEnd?: boolean;
|
|
8228
|
+
ignorePattern?: string;
|
|
8229
|
+
applyDefaultIgnorePatterns?: boolean;
|
|
8230
|
+
afterHashbangComment?: boolean;
|
|
8231
|
+
}
|
|
8232
|
+
];
|
|
8233
|
+
type StylisticLinesBetweenClassMembers = [] | [
|
|
8234
|
+
({
|
|
8235
|
+
enforce: [
|
|
8236
|
+
{
|
|
8237
|
+
blankLine: ("always" | "never");
|
|
8238
|
+
prev: ("method" | "field" | "*");
|
|
8239
|
+
next: ("method" | "field" | "*");
|
|
8240
|
+
},
|
|
8241
|
+
...({
|
|
8242
|
+
blankLine: ("always" | "never");
|
|
8243
|
+
prev: ("method" | "field" | "*");
|
|
8244
|
+
next: ("method" | "field" | "*");
|
|
8245
|
+
})[]
|
|
8246
|
+
];
|
|
8247
|
+
} | ("always" | "never"))
|
|
8248
|
+
] | [
|
|
8249
|
+
({
|
|
8250
|
+
enforce: [
|
|
8251
|
+
{
|
|
8252
|
+
blankLine: ("always" | "never");
|
|
8253
|
+
prev: ("method" | "field" | "*");
|
|
8254
|
+
next: ("method" | "field" | "*");
|
|
8255
|
+
},
|
|
8256
|
+
...({
|
|
8257
|
+
blankLine: ("always" | "never");
|
|
8258
|
+
prev: ("method" | "field" | "*");
|
|
8259
|
+
next: ("method" | "field" | "*");
|
|
8260
|
+
})[]
|
|
8261
|
+
];
|
|
8262
|
+
} | ("always" | "never")),
|
|
8263
|
+
{
|
|
8264
|
+
exceptAfterSingleLine?: boolean;
|
|
8265
|
+
exceptAfterOverload?: boolean;
|
|
8266
|
+
}
|
|
8267
|
+
];
|
|
8268
|
+
type StylisticMaxLen = [] | [
|
|
8269
|
+
({
|
|
8270
|
+
code?: number;
|
|
8271
|
+
comments?: number;
|
|
8272
|
+
tabWidth?: number;
|
|
8273
|
+
ignorePattern?: string;
|
|
8274
|
+
ignoreComments?: boolean;
|
|
8275
|
+
ignoreStrings?: boolean;
|
|
8276
|
+
ignoreUrls?: boolean;
|
|
8277
|
+
ignoreTemplateLiterals?: boolean;
|
|
8278
|
+
ignoreRegExpLiterals?: boolean;
|
|
8279
|
+
ignoreTrailingComments?: boolean;
|
|
8280
|
+
} | number)
|
|
8281
|
+
] | [
|
|
8282
|
+
({
|
|
8283
|
+
code?: number;
|
|
8284
|
+
comments?: number;
|
|
8285
|
+
tabWidth?: number;
|
|
8286
|
+
ignorePattern?: string;
|
|
8287
|
+
ignoreComments?: boolean;
|
|
8288
|
+
ignoreStrings?: boolean;
|
|
8289
|
+
ignoreUrls?: boolean;
|
|
8290
|
+
ignoreTemplateLiterals?: boolean;
|
|
8291
|
+
ignoreRegExpLiterals?: boolean;
|
|
8292
|
+
ignoreTrailingComments?: boolean;
|
|
8293
|
+
} | number),
|
|
8294
|
+
({
|
|
8295
|
+
code?: number;
|
|
8296
|
+
comments?: number;
|
|
8297
|
+
tabWidth?: number;
|
|
8298
|
+
ignorePattern?: string;
|
|
8299
|
+
ignoreComments?: boolean;
|
|
8300
|
+
ignoreStrings?: boolean;
|
|
8301
|
+
ignoreUrls?: boolean;
|
|
8302
|
+
ignoreTemplateLiterals?: boolean;
|
|
8303
|
+
ignoreRegExpLiterals?: boolean;
|
|
8304
|
+
ignoreTrailingComments?: boolean;
|
|
8305
|
+
} | number)
|
|
8306
|
+
] | [
|
|
8307
|
+
({
|
|
8308
|
+
code?: number;
|
|
8309
|
+
comments?: number;
|
|
8310
|
+
tabWidth?: number;
|
|
8311
|
+
ignorePattern?: string;
|
|
8312
|
+
ignoreComments?: boolean;
|
|
8313
|
+
ignoreStrings?: boolean;
|
|
8314
|
+
ignoreUrls?: boolean;
|
|
8315
|
+
ignoreTemplateLiterals?: boolean;
|
|
8316
|
+
ignoreRegExpLiterals?: boolean;
|
|
8317
|
+
ignoreTrailingComments?: boolean;
|
|
8318
|
+
} | number),
|
|
8319
|
+
({
|
|
8320
|
+
code?: number;
|
|
8321
|
+
comments?: number;
|
|
8322
|
+
tabWidth?: number;
|
|
8323
|
+
ignorePattern?: string;
|
|
8324
|
+
ignoreComments?: boolean;
|
|
8325
|
+
ignoreStrings?: boolean;
|
|
8326
|
+
ignoreUrls?: boolean;
|
|
8327
|
+
ignoreTemplateLiterals?: boolean;
|
|
8328
|
+
ignoreRegExpLiterals?: boolean;
|
|
8329
|
+
ignoreTrailingComments?: boolean;
|
|
8330
|
+
} | number),
|
|
8331
|
+
{
|
|
8332
|
+
code?: number;
|
|
8333
|
+
comments?: number;
|
|
8334
|
+
tabWidth?: number;
|
|
8335
|
+
ignorePattern?: string;
|
|
8336
|
+
ignoreComments?: boolean;
|
|
8337
|
+
ignoreStrings?: boolean;
|
|
8338
|
+
ignoreUrls?: boolean;
|
|
8339
|
+
ignoreTemplateLiterals?: boolean;
|
|
8340
|
+
ignoreRegExpLiterals?: boolean;
|
|
8341
|
+
ignoreTrailingComments?: boolean;
|
|
8342
|
+
}
|
|
8343
|
+
];
|
|
8344
|
+
type StylisticMaxStatementsPerLine = [] | [
|
|
8345
|
+
{
|
|
8346
|
+
max?: number;
|
|
8347
|
+
ignoredNodes?: ("BreakStatement" | "ClassDeclaration" | "ContinueStatement" | "DebuggerStatement" | "DoWhileStatement" | "ExpressionStatement" | "ForInStatement" | "ForOfStatement" | "ForStatement" | "FunctionDeclaration" | "IfStatement" | "ImportDeclaration" | "LabeledStatement" | "ReturnStatement" | "SwitchStatement" | "ThrowStatement" | "TryStatement" | "VariableDeclaration" | "WhileStatement" | "WithStatement" | "ExportNamedDeclaration" | "ExportDefaultDeclaration" | "ExportAllDeclaration")[];
|
|
8348
|
+
}
|
|
8349
|
+
];
|
|
8350
|
+
type StylisticMemberDelimiterStyle = [] | [
|
|
8351
|
+
{
|
|
8352
|
+
multiline?: {
|
|
8353
|
+
delimiter?: ("none" | "semi" | "comma");
|
|
8354
|
+
requireLast?: boolean;
|
|
8355
|
+
};
|
|
8356
|
+
singleline?: {
|
|
8357
|
+
delimiter?: ("semi" | "comma");
|
|
8358
|
+
requireLast?: boolean;
|
|
8359
|
+
};
|
|
8360
|
+
overrides?: {
|
|
8361
|
+
interface?: _StylisticMemberDelimiterStyle_DelimiterConfig;
|
|
8362
|
+
typeLiteral?: _StylisticMemberDelimiterStyle_DelimiterConfig;
|
|
8363
|
+
};
|
|
8364
|
+
multilineDetection?: ("brackets" | "last-member");
|
|
8365
|
+
}
|
|
8366
|
+
];
|
|
8367
|
+
interface _StylisticMemberDelimiterStyle_DelimiterConfig {
|
|
8368
|
+
multiline?: {
|
|
8369
|
+
delimiter?: ("none" | "semi" | "comma");
|
|
8370
|
+
requireLast?: boolean;
|
|
8371
|
+
};
|
|
8372
|
+
singleline?: {
|
|
8373
|
+
delimiter?: ("semi" | "comma");
|
|
8374
|
+
requireLast?: boolean;
|
|
8375
|
+
};
|
|
8376
|
+
}
|
|
8377
|
+
type StylisticMultilineCommentStyle = ([] | [("starred-block" | "bare-block")] | [] | ["separate-lines"] | [
|
|
8378
|
+
"separate-lines",
|
|
8379
|
+
{
|
|
8380
|
+
checkJSDoc?: boolean;
|
|
8381
|
+
}
|
|
8382
|
+
]);
|
|
8383
|
+
type StylisticMultilineTernary = [] | [("always" | "always-multiline" | "never")] | [
|
|
8384
|
+
("always" | "always-multiline" | "never"),
|
|
8385
|
+
{
|
|
8386
|
+
ignoreJSX?: boolean;
|
|
8387
|
+
[k: string]: unknown | undefined;
|
|
8388
|
+
}
|
|
8389
|
+
];
|
|
8390
|
+
type StylisticNewParens = [] | [("always" | "never")];
|
|
8391
|
+
type StylisticNewlinePerChainedCall = [] | [
|
|
8392
|
+
{
|
|
8393
|
+
ignoreChainWithDepth?: number;
|
|
8394
|
+
}
|
|
8395
|
+
];
|
|
8396
|
+
type StylisticNoConfusingArrow = [] | [
|
|
8397
|
+
{
|
|
8398
|
+
allowParens?: boolean;
|
|
8399
|
+
onlyOneSimpleParam?: boolean;
|
|
8400
|
+
}
|
|
8401
|
+
];
|
|
8402
|
+
type StylisticNoExtraParens = ([] | ["functions"] | [] | ["all"] | [
|
|
8403
|
+
"all",
|
|
8404
|
+
{
|
|
8405
|
+
conditionalAssign?: boolean;
|
|
8406
|
+
ternaryOperandBinaryExpressions?: boolean;
|
|
8407
|
+
nestedBinaryExpressions?: boolean;
|
|
8408
|
+
returnAssign?: boolean;
|
|
8409
|
+
ignoreJSX?: ("none" | "all" | "single-line" | "multi-line");
|
|
8410
|
+
enforceForArrowConditionals?: boolean;
|
|
8411
|
+
enforceForSequenceExpressions?: boolean;
|
|
8412
|
+
enforceForNewInMemberExpressions?: boolean;
|
|
8413
|
+
enforceForFunctionPrototypeMethods?: boolean;
|
|
8414
|
+
allowParensAfterCommentPattern?: string;
|
|
8415
|
+
nestedConditionalExpressions?: boolean;
|
|
8416
|
+
}
|
|
8417
|
+
]);
|
|
8418
|
+
type StylisticNoMixedOperators = [] | [
|
|
8419
|
+
{
|
|
8420
|
+
groups?: [("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"), ...(("+" | "-" | "*" | "/" | "%" | "**" | "&" | "|" | "^" | "~" | "<<" | ">>" | ">>>" | "==" | "!=" | "===" | "!==" | ">" | ">=" | "<" | "<=" | "&&" | "||" | "in" | "instanceof" | "?:" | "??"))[]][];
|
|
8421
|
+
allowSamePrecedence?: boolean;
|
|
8422
|
+
}
|
|
8423
|
+
];
|
|
8424
|
+
type StylisticNoMixedSpacesAndTabs = [] | [("smart-tabs" | boolean)];
|
|
8425
|
+
type StylisticNoMultiSpaces = [] | [
|
|
8426
|
+
{
|
|
8427
|
+
exceptions?: {
|
|
8428
|
+
[k: string]: boolean;
|
|
8429
|
+
};
|
|
8430
|
+
ignoreEOLComments?: boolean;
|
|
8431
|
+
includeTabs?: boolean;
|
|
8432
|
+
}
|
|
8433
|
+
];
|
|
8434
|
+
type StylisticNoMultipleEmptyLines = [] | [
|
|
8435
|
+
{
|
|
8436
|
+
max: number;
|
|
8437
|
+
maxEOF?: number;
|
|
8438
|
+
maxBOF?: number;
|
|
8439
|
+
}
|
|
8440
|
+
];
|
|
8441
|
+
type StylisticNoTabs = [] | [
|
|
8442
|
+
{
|
|
8443
|
+
allowIndentationTabs?: boolean;
|
|
8444
|
+
}
|
|
8445
|
+
];
|
|
8446
|
+
type StylisticNoTrailingSpaces = [] | [
|
|
8447
|
+
{
|
|
8448
|
+
skipBlankLines?: boolean;
|
|
8449
|
+
ignoreComments?: boolean;
|
|
8450
|
+
}
|
|
8451
|
+
];
|
|
8452
|
+
type StylisticNonblockStatementBodyPosition = [] | [("beside" | "below" | "any")] | [
|
|
8453
|
+
("beside" | "below" | "any"),
|
|
8454
|
+
{
|
|
8455
|
+
overrides?: {
|
|
8456
|
+
if?: ("beside" | "below" | "any");
|
|
8457
|
+
else?: ("beside" | "below" | "any");
|
|
8458
|
+
while?: ("beside" | "below" | "any");
|
|
8459
|
+
do?: ("beside" | "below" | "any");
|
|
8460
|
+
for?: ("beside" | "below" | "any");
|
|
8461
|
+
};
|
|
8462
|
+
}
|
|
8463
|
+
];
|
|
8464
|
+
type StylisticObjectCurlyNewline = [] | [
|
|
8465
|
+
((("always" | "never") | {
|
|
8466
|
+
multiline?: boolean;
|
|
8467
|
+
minProperties?: number;
|
|
8468
|
+
consistent?: boolean;
|
|
8469
|
+
}) | {
|
|
8470
|
+
ObjectExpression?: (("always" | "never") | {
|
|
8471
|
+
multiline?: boolean;
|
|
8472
|
+
minProperties?: number;
|
|
8473
|
+
consistent?: boolean;
|
|
8474
|
+
});
|
|
8475
|
+
ObjectPattern?: (("always" | "never") | {
|
|
8476
|
+
multiline?: boolean;
|
|
8477
|
+
minProperties?: number;
|
|
8478
|
+
consistent?: boolean;
|
|
8479
|
+
});
|
|
8480
|
+
ImportDeclaration?: (("always" | "never") | {
|
|
8481
|
+
multiline?: boolean;
|
|
8482
|
+
minProperties?: number;
|
|
8483
|
+
consistent?: boolean;
|
|
8484
|
+
});
|
|
8485
|
+
ExportDeclaration?: (("always" | "never") | {
|
|
8486
|
+
multiline?: boolean;
|
|
8487
|
+
minProperties?: number;
|
|
8488
|
+
consistent?: boolean;
|
|
8489
|
+
});
|
|
8490
|
+
TSTypeLiteral?: (("always" | "never") | {
|
|
8491
|
+
multiline?: boolean;
|
|
8492
|
+
minProperties?: number;
|
|
8493
|
+
consistent?: boolean;
|
|
8494
|
+
});
|
|
8495
|
+
TSInterfaceBody?: (("always" | "never") | {
|
|
8496
|
+
multiline?: boolean;
|
|
8497
|
+
minProperties?: number;
|
|
8498
|
+
consistent?: boolean;
|
|
8499
|
+
});
|
|
8500
|
+
})
|
|
8501
|
+
];
|
|
8502
|
+
type StylisticObjectCurlySpacing = [] | [("always" | "never")] | [
|
|
8503
|
+
("always" | "never"),
|
|
8504
|
+
{
|
|
8505
|
+
arraysInObjects?: boolean;
|
|
8506
|
+
objectsInObjects?: boolean;
|
|
8507
|
+
}
|
|
8508
|
+
];
|
|
8509
|
+
type StylisticObjectPropertyNewline = [] | [
|
|
8510
|
+
{
|
|
8511
|
+
allowAllPropertiesOnSameLine?: boolean;
|
|
8512
|
+
allowMultiplePropertiesPerLine?: boolean;
|
|
8513
|
+
}
|
|
8514
|
+
];
|
|
8515
|
+
type StylisticOneVarDeclarationPerLine = [] | [("always" | "initializations")];
|
|
8516
|
+
type StylisticOperatorLinebreak = [] | [(("after" | "before" | "none") | null)] | [
|
|
8517
|
+
(("after" | "before" | "none") | null),
|
|
8518
|
+
{
|
|
8519
|
+
overrides?: {
|
|
8520
|
+
[k: string]: ("after" | "before" | "none" | "ignore") | undefined;
|
|
8521
|
+
};
|
|
8522
|
+
}
|
|
8523
|
+
];
|
|
8524
|
+
type StylisticPaddedBlocks = [] | [
|
|
8525
|
+
(("always" | "never" | "start" | "end") | {
|
|
8526
|
+
blocks?: ("always" | "never" | "start" | "end");
|
|
8527
|
+
switches?: ("always" | "never" | "start" | "end");
|
|
8528
|
+
classes?: ("always" | "never" | "start" | "end");
|
|
8529
|
+
})
|
|
8530
|
+
] | [
|
|
8531
|
+
(("always" | "never" | "start" | "end") | {
|
|
8532
|
+
blocks?: ("always" | "never" | "start" | "end");
|
|
8533
|
+
switches?: ("always" | "never" | "start" | "end");
|
|
8534
|
+
classes?: ("always" | "never" | "start" | "end");
|
|
8535
|
+
}),
|
|
8536
|
+
{
|
|
8537
|
+
allowSingleLineBlocks?: boolean;
|
|
8538
|
+
}
|
|
8539
|
+
];
|
|
8540
|
+
type _StylisticPaddingLineBetweenStatementsPaddingType = ("any" | "never" | "always");
|
|
8541
|
+
type _StylisticPaddingLineBetweenStatementsStatementType = (("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload") | [("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"), ...(("*" | "block-like" | "exports" | "require" | "directive" | "expression" | "iife" | "multiline-block-like" | "multiline-expression" | "multiline-const" | "multiline-export" | "multiline-let" | "multiline-var" | "singleline-const" | "singleline-export" | "singleline-let" | "singleline-var" | "block" | "empty" | "function" | "ts-method" | "break" | "case" | "class" | "const" | "continue" | "debugger" | "default" | "do" | "export" | "for" | "if" | "import" | "let" | "return" | "switch" | "throw" | "try" | "var" | "while" | "with" | "cjs-export" | "cjs-import" | "enum" | "interface" | "type" | "function-overload"))[]]);
|
|
8542
|
+
type StylisticPaddingLineBetweenStatements = {
|
|
8543
|
+
blankLine: _StylisticPaddingLineBetweenStatementsPaddingType;
|
|
8544
|
+
prev: _StylisticPaddingLineBetweenStatementsStatementType;
|
|
8545
|
+
next: _StylisticPaddingLineBetweenStatementsStatementType;
|
|
8546
|
+
}[];
|
|
8547
|
+
type StylisticQuoteProps = ([] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [] | [("always" | "as-needed" | "consistent" | "consistent-as-needed")] | [
|
|
8548
|
+
("always" | "as-needed" | "consistent" | "consistent-as-needed"),
|
|
8549
|
+
{
|
|
8550
|
+
keywords?: boolean;
|
|
8551
|
+
unnecessary?: boolean;
|
|
8552
|
+
numbers?: boolean;
|
|
8553
|
+
}
|
|
8554
|
+
]);
|
|
8555
|
+
type StylisticQuotes = [] | [("single" | "double" | "backtick")] | [
|
|
8556
|
+
("single" | "double" | "backtick"),
|
|
8557
|
+
("avoid-escape" | {
|
|
8558
|
+
avoidEscape?: boolean;
|
|
8559
|
+
allowTemplateLiterals?: (boolean | ("never" | "avoidEscape" | "always"));
|
|
8560
|
+
ignoreStringLiterals?: boolean;
|
|
8561
|
+
})
|
|
8562
|
+
];
|
|
8563
|
+
type StylisticRestSpreadSpacing = [] | [("always" | "never")];
|
|
8564
|
+
type StylisticSemi = ([] | ["never"] | [
|
|
8565
|
+
"never",
|
|
8566
|
+
{
|
|
8567
|
+
beforeStatementContinuationChars?: ("always" | "any" | "never");
|
|
8568
|
+
}
|
|
8569
|
+
] | [] | ["always"] | [
|
|
8570
|
+
"always",
|
|
8571
|
+
{
|
|
8572
|
+
omitLastInOneLineBlock?: boolean;
|
|
8573
|
+
omitLastInOneLineClassBody?: boolean;
|
|
8574
|
+
}
|
|
8575
|
+
]);
|
|
8576
|
+
type StylisticSemiSpacing = [] | [
|
|
8577
|
+
{
|
|
8578
|
+
before?: boolean;
|
|
8579
|
+
after?: boolean;
|
|
8580
|
+
}
|
|
8581
|
+
];
|
|
8582
|
+
type StylisticSemiStyle = [] | [("last" | "first")];
|
|
8583
|
+
type StylisticSpaceBeforeBlocks = [] | [
|
|
8584
|
+
(("always" | "never") | {
|
|
8585
|
+
keywords?: ("always" | "never" | "off");
|
|
8586
|
+
functions?: ("always" | "never" | "off");
|
|
8587
|
+
classes?: ("always" | "never" | "off");
|
|
8588
|
+
})
|
|
8589
|
+
];
|
|
8590
|
+
type StylisticSpaceBeforeFunctionParen = [] | [
|
|
8591
|
+
(("always" | "never") | {
|
|
8592
|
+
anonymous?: ("always" | "never" | "ignore");
|
|
8593
|
+
named?: ("always" | "never" | "ignore");
|
|
8594
|
+
asyncArrow?: ("always" | "never" | "ignore");
|
|
8595
|
+
})
|
|
8596
|
+
];
|
|
8597
|
+
type StylisticSpaceInParens = [] | [("always" | "never")] | [
|
|
8598
|
+
("always" | "never"),
|
|
8599
|
+
{
|
|
8600
|
+
exceptions?: ("{}" | "[]" | "()" | "empty")[];
|
|
8601
|
+
}
|
|
8602
|
+
];
|
|
8603
|
+
type StylisticSpaceInfixOps = [] | [
|
|
8604
|
+
{
|
|
8605
|
+
int32Hint?: boolean;
|
|
8606
|
+
ignoreTypes?: boolean;
|
|
8607
|
+
}
|
|
8608
|
+
];
|
|
8609
|
+
type StylisticSpaceUnaryOps = [] | [
|
|
8610
|
+
{
|
|
8611
|
+
words?: boolean;
|
|
8612
|
+
nonwords?: boolean;
|
|
8613
|
+
overrides?: {
|
|
8614
|
+
[k: string]: boolean | undefined;
|
|
8615
|
+
};
|
|
8616
|
+
}
|
|
8617
|
+
];
|
|
8618
|
+
type StylisticSpacedComment = [] | [("always" | "never")] | [
|
|
8619
|
+
("always" | "never"),
|
|
8620
|
+
{
|
|
8621
|
+
exceptions?: string[];
|
|
8622
|
+
markers?: string[];
|
|
8623
|
+
line?: {
|
|
8624
|
+
exceptions?: string[];
|
|
8625
|
+
markers?: string[];
|
|
8626
|
+
};
|
|
8627
|
+
block?: {
|
|
8628
|
+
exceptions?: string[];
|
|
8629
|
+
markers?: string[];
|
|
8630
|
+
balanced?: boolean;
|
|
8631
|
+
};
|
|
8632
|
+
}
|
|
8633
|
+
];
|
|
8634
|
+
type StylisticSwitchColonSpacing = [] | [
|
|
8635
|
+
{
|
|
8636
|
+
before?: boolean;
|
|
8637
|
+
after?: boolean;
|
|
8638
|
+
}
|
|
8639
|
+
];
|
|
8640
|
+
type StylisticTemplateCurlySpacing = [] | [("always" | "never")];
|
|
8641
|
+
type StylisticTemplateTagSpacing = [] | [("always" | "never")];
|
|
8642
|
+
type StylisticTypeAnnotationSpacing = [] | [
|
|
8643
|
+
{
|
|
8644
|
+
before?: boolean;
|
|
8645
|
+
after?: boolean;
|
|
8646
|
+
overrides?: {
|
|
8647
|
+
colon?: _StylisticTypeAnnotationSpacing_SpacingConfig;
|
|
8648
|
+
arrow?: _StylisticTypeAnnotationSpacing_SpacingConfig;
|
|
8649
|
+
variable?: _StylisticTypeAnnotationSpacing_SpacingConfig;
|
|
8650
|
+
parameter?: _StylisticTypeAnnotationSpacing_SpacingConfig;
|
|
8651
|
+
property?: _StylisticTypeAnnotationSpacing_SpacingConfig;
|
|
8652
|
+
returnType?: _StylisticTypeAnnotationSpacing_SpacingConfig;
|
|
8653
|
+
};
|
|
8654
|
+
}
|
|
8655
|
+
];
|
|
8656
|
+
interface _StylisticTypeAnnotationSpacing_SpacingConfig {
|
|
8657
|
+
before?: boolean;
|
|
8658
|
+
after?: boolean;
|
|
8659
|
+
}
|
|
8660
|
+
type StylisticWrapIife = [] | [("outside" | "inside" | "any")] | [
|
|
8661
|
+
("outside" | "inside" | "any"),
|
|
8662
|
+
{
|
|
8663
|
+
functionPrototypeMethods?: boolean;
|
|
8664
|
+
}
|
|
8665
|
+
];
|
|
8666
|
+
type StylisticYieldStarSpacing = [] | [
|
|
8667
|
+
(("before" | "after" | "both" | "neither") | {
|
|
8668
|
+
before?: boolean;
|
|
8669
|
+
after?: boolean;
|
|
8670
|
+
})
|
|
8671
|
+
];
|
|
8672
|
+
|
|
6952
8673
|
interface SvelteRules {
|
|
6953
8674
|
/**
|
|
6954
8675
|
* disallow conditionals where the type is always truthy or always falsy
|
|
@@ -11083,7 +12804,7 @@ interface VueRules {
|
|
|
11083
12804
|
*/
|
|
11084
12805
|
'vue/jsx-uses-vars'?: Linter.RuleEntry<[]>;
|
|
11085
12806
|
/**
|
|
11086
|
-
* Enforce consistent spacing between
|
|
12807
|
+
* Enforce consistent spacing between property names and type annotations in types and interfaces in `<template>`
|
|
11087
12808
|
* @see https://eslint.vuejs.org/rules/key-spacing.html
|
|
11088
12809
|
*/
|
|
11089
12810
|
'vue/key-spacing'?: Linter.RuleEntry<VueKeySpacing>;
|
|
@@ -11770,7 +13491,7 @@ interface VueRules {
|
|
|
11770
13491
|
*/
|
|
11771
13492
|
'vue/prop-name-casing'?: Linter.RuleEntry<VuePropNameCasing>;
|
|
11772
13493
|
/**
|
|
11773
|
-
* Require quotes around object literal property names in `<template>`
|
|
13494
|
+
* Require quotes around object literal, type literal, interfaces and enums property names in `<template>`
|
|
11774
13495
|
* @see https://eslint.vuejs.org/rules/quote-props.html
|
|
11775
13496
|
*/
|
|
11776
13497
|
'vue/quote-props'?: Linter.RuleEntry<VueQuoteProps>;
|
|
@@ -12292,6 +14013,7 @@ type VueArrayElementNewline = [] | [
|
|
|
12292
14013
|
})
|
|
12293
14014
|
];
|
|
12294
14015
|
type _VueArrayElementNewlineBasicConfig = (("always" | "never" | "consistent") | {
|
|
14016
|
+
consistent?: boolean;
|
|
12295
14017
|
multiline?: boolean;
|
|
12296
14018
|
minItems?: (number | null);
|
|
12297
14019
|
});
|
|
@@ -12368,10 +14090,15 @@ type VueCommaDangle = [] | [
|
|
|
12368
14090
|
imports?: _VueCommaDangleValueWithIgnore;
|
|
12369
14091
|
exports?: _VueCommaDangleValueWithIgnore;
|
|
12370
14092
|
functions?: _VueCommaDangleValueWithIgnore;
|
|
14093
|
+
importAttributes?: _VueCommaDangleValueWithIgnore;
|
|
14094
|
+
dynamicImports?: _VueCommaDangleValueWithIgnore;
|
|
14095
|
+
enums?: _VueCommaDangleValueWithIgnore;
|
|
14096
|
+
generics?: _VueCommaDangleValueWithIgnore;
|
|
14097
|
+
tuples?: _VueCommaDangleValueWithIgnore;
|
|
12371
14098
|
})
|
|
12372
14099
|
];
|
|
12373
14100
|
type _VueCommaDangleValue = ("always-multiline" | "always" | "never" | "only-multiline");
|
|
12374
|
-
type _VueCommaDangleValueWithIgnore = ("always-multiline" | "always" | "
|
|
14101
|
+
type _VueCommaDangleValueWithIgnore = ("always-multiline" | "always" | "never" | "only-multiline" | "ignore");
|
|
12375
14102
|
type VueCommaSpacing = [] | [
|
|
12376
14103
|
{
|
|
12377
14104
|
before?: boolean;
|
|
@@ -12444,6 +14171,10 @@ type VueFuncCallSpacing = ([] | ["never"] | [] | ["always"] | [
|
|
|
12444
14171
|
"always",
|
|
12445
14172
|
{
|
|
12446
14173
|
allowNewlines?: boolean;
|
|
14174
|
+
optionalChain?: {
|
|
14175
|
+
before?: boolean;
|
|
14176
|
+
after?: boolean;
|
|
14177
|
+
};
|
|
12447
14178
|
}
|
|
12448
14179
|
]);
|
|
12449
14180
|
type VueHtmlButtonHasType = [] | [
|
|
@@ -12539,6 +14270,7 @@ type VueKeySpacing = [] | [
|
|
|
12539
14270
|
mode?: ("strict" | "minimum");
|
|
12540
14271
|
beforeColon?: boolean;
|
|
12541
14272
|
afterColon?: boolean;
|
|
14273
|
+
ignoredNodes?: ("ObjectExpression" | "ObjectPattern" | "ImportDeclaration" | "ExportNamedDeclaration" | "ExportAllDeclaration" | "TSTypeLiteral" | "TSInterfaceBody" | "ClassBody")[];
|
|
12542
14274
|
} | {
|
|
12543
14275
|
singleLine?: {
|
|
12544
14276
|
mode?: ("strict" | "minimum");
|
|
@@ -12776,6 +14508,10 @@ type VueKeywordSpacing = [] | [
|
|
|
12776
14508
|
before?: boolean;
|
|
12777
14509
|
after?: boolean;
|
|
12778
14510
|
};
|
|
14511
|
+
satisfies?: {
|
|
14512
|
+
before?: boolean;
|
|
14513
|
+
after?: boolean;
|
|
14514
|
+
};
|
|
12779
14515
|
set?: {
|
|
12780
14516
|
before?: boolean;
|
|
12781
14517
|
after?: boolean;
|
|
@@ -12852,6 +14588,10 @@ type VueKeywordSpacing = [] | [
|
|
|
12852
14588
|
before?: boolean;
|
|
12853
14589
|
after?: boolean;
|
|
12854
14590
|
};
|
|
14591
|
+
type?: {
|
|
14592
|
+
before?: boolean;
|
|
14593
|
+
after?: boolean;
|
|
14594
|
+
};
|
|
12855
14595
|
};
|
|
12856
14596
|
}
|
|
12857
14597
|
];
|
|
@@ -12995,7 +14735,13 @@ type VueMultilineHtmlElementContentNewline = [] | [
|
|
|
12995
14735
|
allowEmptyLines?: boolean;
|
|
12996
14736
|
}
|
|
12997
14737
|
];
|
|
12998
|
-
type VueMultilineTernary = [] | [("always" | "always-multiline" | "never")]
|
|
14738
|
+
type VueMultilineTernary = [] | [("always" | "always-multiline" | "never")] | [
|
|
14739
|
+
("always" | "always-multiline" | "never"),
|
|
14740
|
+
{
|
|
14741
|
+
ignoreJSX?: boolean;
|
|
14742
|
+
[k: string]: unknown | undefined;
|
|
14743
|
+
}
|
|
14744
|
+
];
|
|
12999
14745
|
type VueMustacheInterpolationSpacing = [] | [("always" | "never")];
|
|
13000
14746
|
type VueNewLineBetweenMultiLineProperty = [] | [
|
|
13001
14747
|
{
|
|
@@ -13077,6 +14823,7 @@ type VueNoExtraParens = ([] | ["functions"] | [] | ["all"] | [
|
|
|
13077
14823
|
enforceForNewInMemberExpressions?: boolean;
|
|
13078
14824
|
enforceForFunctionPrototypeMethods?: boolean;
|
|
13079
14825
|
allowParensAfterCommentPattern?: string;
|
|
14826
|
+
nestedConditionalExpressions?: boolean;
|
|
13080
14827
|
}
|
|
13081
14828
|
]);
|
|
13082
14829
|
type VueNoImplicitCoercion = [] | [
|
|
@@ -13337,6 +15084,16 @@ type VueObjectCurlyNewline = [] | [
|
|
|
13337
15084
|
minProperties?: number;
|
|
13338
15085
|
consistent?: boolean;
|
|
13339
15086
|
});
|
|
15087
|
+
TSTypeLiteral?: (("always" | "never") | {
|
|
15088
|
+
multiline?: boolean;
|
|
15089
|
+
minProperties?: number;
|
|
15090
|
+
consistent?: boolean;
|
|
15091
|
+
});
|
|
15092
|
+
TSInterfaceBody?: (("always" | "never") | {
|
|
15093
|
+
multiline?: boolean;
|
|
15094
|
+
minProperties?: number;
|
|
15095
|
+
consistent?: boolean;
|
|
15096
|
+
});
|
|
13340
15097
|
})
|
|
13341
15098
|
];
|
|
13342
15099
|
type VueObjectCurlySpacing = [] | [("always" | "never")] | [
|
|
@@ -13366,8 +15123,8 @@ type VueObjectShorthand = ([] | [("always" | "methods" | "properties" | "never"
|
|
|
13366
15123
|
avoidExplicitReturnArrows?: boolean;
|
|
13367
15124
|
}
|
|
13368
15125
|
]);
|
|
13369
|
-
type VueOperatorLinebreak = [] | [("after" | "before" | "none" | null)] | [
|
|
13370
|
-
("after" | "before" | "none" | null),
|
|
15126
|
+
type VueOperatorLinebreak = [] | [(("after" | "before" | "none") | null)] | [
|
|
15127
|
+
(("after" | "before" | "none") | null),
|
|
13371
15128
|
{
|
|
13372
15129
|
overrides?: {
|
|
13373
15130
|
[k: string]: ("after" | "before" | "none" | "ignore") | undefined;
|
|
@@ -13498,6 +15255,7 @@ type VueSpaceInParens = [] | [("always" | "never")] | [
|
|
|
13498
15255
|
type VueSpaceInfixOps = [] | [
|
|
13499
15256
|
{
|
|
13500
15257
|
int32Hint?: boolean;
|
|
15258
|
+
ignoreTypes?: boolean;
|
|
13501
15259
|
}
|
|
13502
15260
|
];
|
|
13503
15261
|
type VueSpaceUnaryOps = [] | [
|
|
@@ -14016,7 +15774,7 @@ type YmlSpacedComment = [] | [("always" | "never")] | [
|
|
|
14016
15774
|
|
|
14017
15775
|
declare module 'eslint' {
|
|
14018
15776
|
namespace Linter {
|
|
14019
|
-
interface RulesRecord extends CommentsRules, CssRules, ImportsRules, JavascriptRules, JsdocRules, JsoncRules, MarkdownRules, PrettierRules, PromiseRules, ReactRules, RegexpRules, SvelteRules, TomlRules, TypescriptRules, UnicornRules, VitestRules, VueRules, YmlRules {
|
|
15777
|
+
interface RulesRecord extends CommentsRules, CssRules, ImportsRules, JavascriptRules, JsdocRules, JsoncRules, MarkdownRules, PrettierRules, PromiseRules, ReactRules, RegexpRules, StylisticRules, SvelteRules, TomlRules, TypescriptRules, UnicornRules, VitestRules, VueRules, YmlRules {
|
|
14020
15778
|
}
|
|
14021
15779
|
}
|
|
14022
15780
|
}
|
|
@@ -14050,6 +15808,10 @@ interface CssOptions {
|
|
|
14050
15808
|
* @description if 'tailwind', it will enable [Tailwind Syntax](https://github.com/eslint/css?tab=readme-ov-file#configuring-tailwind-syntax), otherwise it will enable [custom syntax](https://github.com/eslint/css?tab=readme-ov-file#configuring-custom-syntax)
|
|
14051
15809
|
* @default false
|
|
14052
15810
|
*/
|
|
15811
|
+
/**
|
|
15812
|
+
* TODO: If this issue is resolved, we should define more strict types for customSyntax
|
|
15813
|
+
* https://github.com/eslint/css/issues/56
|
|
15814
|
+
*/
|
|
14053
15815
|
customSyntax?: false | 'tailwind' | Record<string, any>;
|
|
14054
15816
|
}
|
|
14055
15817
|
/**
|
|
@@ -14078,7 +15840,7 @@ interface ImportsOptions {
|
|
|
14078
15840
|
}
|
|
14079
15841
|
/**
|
|
14080
15842
|
* `eslint-plugin-import-x`, `eslint-plugin-unused-imports` and overrides configuration options
|
|
14081
|
-
* @description
|
|
15843
|
+
* @description if you want to use this preset, you need to put after `javascript` and `typescript` presets**
|
|
14082
15844
|
* @param {ImportsOptions & OverridesOptions} options
|
|
14083
15845
|
* import configuration options
|
|
14084
15846
|
* @returns {Promise<Linter.Config[]>}
|
|
@@ -14093,10 +15855,8 @@ interface JavaScriptOptions {
|
|
|
14093
15855
|
}
|
|
14094
15856
|
/**
|
|
14095
15857
|
* `@eslint/js` and overrides configuration options
|
|
14096
|
-
* @param {JavaScriptOptions & OverridesOptions} options
|
|
14097
|
-
* eslint
|
|
14098
|
-
* @returns {Promise<Linter.Config[]>}
|
|
14099
|
-
* eslint flat configurations with `@eslint/js` and overrides
|
|
15858
|
+
* @param {JavaScriptOptions & OverridesOptions} options eslint configuration options for JavaScript
|
|
15859
|
+
* @returns {Promise<Linter.Config[]>} eslint flat configurations with `@eslint/js` and overrides
|
|
14100
15860
|
*/
|
|
14101
15861
|
declare function javascript(options?: JavaScriptOptions & OverridesOptions<JavascriptRules>): Promise<Linter.Config[]>;
|
|
14102
15862
|
|
|
@@ -14319,6 +16079,25 @@ interface RegexpOptions {
|
|
|
14319
16079
|
*/
|
|
14320
16080
|
declare function regexp(options?: RegexpOptions & OverridesOptions<RegexpRules>): Promise<Linter.Config[]>;
|
|
14321
16081
|
|
|
16082
|
+
/**
|
|
16083
|
+
* stylistic eslint plugin configuration options
|
|
16084
|
+
*/
|
|
16085
|
+
interface StylisticOptions {
|
|
16086
|
+
/**
|
|
16087
|
+
* stylistic customize options
|
|
16088
|
+
* @see https://eslint.style/guide/config-presets#configuration-factory
|
|
16089
|
+
*/
|
|
16090
|
+
customize?: StylisticCustomizeOptions;
|
|
16091
|
+
}
|
|
16092
|
+
/**
|
|
16093
|
+
* `@stylistic/eslint-plugin` and overrides configuration options
|
|
16094
|
+
* @param {StylisticOptions & OverridesOptions} options
|
|
16095
|
+
* stylistic eslint plugin configuration options
|
|
16096
|
+
* @returns {Promise<Linter.Config[]>}
|
|
16097
|
+
* eslint flat configurations with `@stylistic/eslint-plugin` and overrides
|
|
16098
|
+
*/
|
|
16099
|
+
declare function stylistic(options?: StylisticOptions & OverridesOptions<StylisticRules>): Promise<Linter.Config[]>;
|
|
16100
|
+
|
|
14322
16101
|
/**
|
|
14323
16102
|
* Svelte configuration options
|
|
14324
16103
|
*/
|
|
@@ -14461,4 +16240,4 @@ interface YmlOptions {
|
|
|
14461
16240
|
declare function yml(options?: YmlOptions & OverridesOptions<YmlRules>): Promise<Linter.Config[]>;
|
|
14462
16241
|
declare const yaml: typeof yml;
|
|
14463
16242
|
|
|
14464
|
-
export { type CommentsOptions, type CommentsRules, type CssOptions, type CssRules, type ImportsOptions, type ImportsRules, type JavaScriptOptions, type JavascriptRules, type JsDocumentOptions, type JsdocRules, type JsoncOptions, type JsoncRules, type MarkdownOptions, type MarkdownRules, type OverridesOptions, type PrettierOptions, type PrettierRules, type PromiseOptions, type PromiseRules, type ReactOptions, type ReactRules, type RegexpOptions, type RegexpRules, type SvelteRules, type SvelteScriptOptions, type TomlOptions, type TomlRules, type TypeScriptOptions, type TypeScriptParserOptions, type TypeScriptProjectServiceOptions, type TypescriptRules, type UnicornOptions, type UnicornRules, type VitestOptions, type VitestRules, type VueI18nOptions, type VueRules, type VueScriptOptions, type YmlOptions, type YmlRules, comments, css, defineConfig, imports, javascript, jsdoc, jsonc, markdown, md, prettier, promise, react, regexp, svelte, toml, typescript, unicorn, vitest, vue, yaml, yml };
|
|
16243
|
+
export { type CommentsOptions, type CommentsRules, type CssOptions, type CssRules, type ImportsOptions, type ImportsRules, type JavaScriptOptions, type JavascriptRules, type JsDocumentOptions, type JsdocRules, type JsoncOptions, type JsoncRules, type MarkdownOptions, type MarkdownRules, type OverridesOptions, type PrettierOptions, type PrettierRules, type PromiseOptions, type PromiseRules, type ReactOptions, type ReactRules, type RegexpOptions, type RegexpRules, type StylisticOptions, type StylisticRules, type SvelteRules, type SvelteScriptOptions, type TomlOptions, type TomlRules, type TypeScriptOptions, type TypeScriptParserOptions, type TypeScriptProjectServiceOptions, type TypescriptRules, type UnicornOptions, type UnicornRules, type VitestOptions, type VitestRules, type VueI18nOptions, type VueRules, type VueScriptOptions, type YmlOptions, type YmlRules, comments, css, defineConfig, imports, javascript, jsdoc, jsonc, markdown, md, prettier, promise, react, regexp, stylistic, svelte, toml, typescript, unicorn, vitest, vue, yaml, yml };
|