@fenge/eslint-config 0.1.1 → 0.1.2
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/CHANGELOG.md +10 -0
- package/README.md +1 -3
- package/dist/config/javascript.d.ts +375 -23
- package/dist/config/javascript.d.ts.map +1 -1
- package/dist/config/javascript.js +7 -6
- package/dist/config/typescript.d.ts +374 -24
- package/dist/config/typescript.d.ts.map +1 -1
- package/dist/config/typescript.js +2 -2
- package/package.json +7 -7
- package/src/config/javascript.ts +6 -5
- package/src/config/typescript.ts +1 -1
- package/src/eslint.config.spec.ts +80 -2
|
@@ -26,19 +26,382 @@ export declare function typescript(project?: string): readonly [{
|
|
|
26
26
|
readonly "@fenge-ts": typeof fengeTsPlugin;
|
|
27
27
|
readonly fp: unknown;
|
|
28
28
|
readonly n: import("eslint").ESLint.Plugin & {
|
|
29
|
-
configs:
|
|
30
|
-
'recommended-module': import("eslint").ESLint.ConfigData;
|
|
31
|
-
'recommended-script': import("eslint").ESLint.ConfigData;
|
|
32
|
-
recommended: import("eslint").ESLint.ConfigData;
|
|
33
|
-
'flat/recommended-module': import("eslint").Linter.FlatConfig;
|
|
34
|
-
'flat/recommended-script': import("eslint").Linter.FlatConfig;
|
|
35
|
-
'flat/recommended': import("eslint").Linter.FlatConfig;
|
|
36
|
-
'flat/mixed-esm-and-cjs': import("eslint").Linter.FlatConfig[];
|
|
37
|
-
};
|
|
29
|
+
configs: import("eslint-plugin-n").Configs;
|
|
38
30
|
};
|
|
39
31
|
readonly import: unknown;
|
|
40
32
|
readonly promise: unknown;
|
|
41
|
-
readonly react:
|
|
33
|
+
readonly react: {
|
|
34
|
+
deprecatedRules: Partial<{
|
|
35
|
+
'boolean-prop-naming': import("eslint").Rule.RuleModule;
|
|
36
|
+
'button-has-type': import("eslint").Rule.RuleModule;
|
|
37
|
+
'checked-requires-onchange-or-readonly': import("eslint").Rule.RuleModule;
|
|
38
|
+
'default-props-match-prop-types': import("eslint").Rule.RuleModule;
|
|
39
|
+
'destructuring-assignment': import("eslint").Rule.RuleModule;
|
|
40
|
+
'display-name': import("eslint").Rule.RuleModule;
|
|
41
|
+
'forbid-component-props': import("eslint").Rule.RuleModule;
|
|
42
|
+
'forbid-dom-props': import("eslint").Rule.RuleModule;
|
|
43
|
+
'forbid-elements': import("eslint").Rule.RuleModule;
|
|
44
|
+
'forbid-foreign-prop-types': import("eslint").Rule.RuleModule;
|
|
45
|
+
'forbid-prop-types': import("eslint").Rule.RuleModule;
|
|
46
|
+
'forward-ref-uses-ref': {
|
|
47
|
+
meta: {
|
|
48
|
+
docs: {
|
|
49
|
+
description: string;
|
|
50
|
+
category: string;
|
|
51
|
+
recommended: boolean;
|
|
52
|
+
url: string;
|
|
53
|
+
};
|
|
54
|
+
messages: {
|
|
55
|
+
missingRefParameter: string;
|
|
56
|
+
addRefParameter: string;
|
|
57
|
+
removeForwardRef: string;
|
|
58
|
+
};
|
|
59
|
+
schema: undefined[];
|
|
60
|
+
type: string;
|
|
61
|
+
hasSuggestions: boolean;
|
|
62
|
+
};
|
|
63
|
+
create(context: any): {
|
|
64
|
+
"FunctionExpression, ArrowFunctionExpression"(node: any): void;
|
|
65
|
+
};
|
|
66
|
+
};
|
|
67
|
+
'function-component-definition': import("eslint").Rule.RuleModule;
|
|
68
|
+
'hook-use-state': import("eslint").Rule.RuleModule;
|
|
69
|
+
'iframe-missing-sandbox': import("eslint").Rule.RuleModule;
|
|
70
|
+
'jsx-boolean-value': import("eslint").Rule.RuleModule;
|
|
71
|
+
'jsx-child-element-spacing': import("eslint").Rule.RuleModule;
|
|
72
|
+
'jsx-closing-bracket-location': import("eslint").Rule.RuleModule;
|
|
73
|
+
'jsx-closing-tag-location': import("eslint").Rule.RuleModule;
|
|
74
|
+
'jsx-curly-spacing': import("eslint").Rule.RuleModule;
|
|
75
|
+
'jsx-curly-newline': import("eslint").Rule.RuleModule;
|
|
76
|
+
'jsx-equals-spacing': import("eslint").Rule.RuleModule;
|
|
77
|
+
'jsx-filename-extension': import("eslint").Rule.RuleModule;
|
|
78
|
+
'jsx-first-prop-new-line': import("eslint").Rule.RuleModule;
|
|
79
|
+
'jsx-handler-names': import("eslint").Rule.RuleModule;
|
|
80
|
+
'jsx-indent': import("eslint").Rule.RuleModule;
|
|
81
|
+
'jsx-indent-props': import("eslint").Rule.RuleModule;
|
|
82
|
+
'jsx-key': import("eslint").Rule.RuleModule;
|
|
83
|
+
'jsx-max-depth': import("eslint").Rule.RuleModule;
|
|
84
|
+
'jsx-max-props-per-line': import("eslint").Rule.RuleModule;
|
|
85
|
+
'jsx-newline': import("eslint").Rule.RuleModule;
|
|
86
|
+
'jsx-no-bind': import("eslint").Rule.RuleModule;
|
|
87
|
+
'jsx-no-comment-textnodes': import("eslint").Rule.RuleModule;
|
|
88
|
+
'jsx-no-constructed-context-values': import("eslint").Rule.RuleModule;
|
|
89
|
+
'jsx-no-duplicate-props': import("eslint").Rule.RuleModule;
|
|
90
|
+
'jsx-no-leaked-render': import("eslint").Rule.RuleModule;
|
|
91
|
+
'jsx-no-literals': {
|
|
92
|
+
meta: import("eslint").Rule.RuleMetaData;
|
|
93
|
+
create(context: any): (false & {
|
|
94
|
+
Literal(node: any): void;
|
|
95
|
+
JSXAttribute(node: any): void;
|
|
96
|
+
JSXText(node: any): void;
|
|
97
|
+
TemplateLiteral(node: any): void;
|
|
98
|
+
}) | ({
|
|
99
|
+
ImportDeclaration(node: any): void;
|
|
100
|
+
VariableDeclaration(node: any): void;
|
|
101
|
+
} & {
|
|
102
|
+
Literal(node: any): void;
|
|
103
|
+
JSXAttribute(node: any): void;
|
|
104
|
+
JSXText(node: any): void;
|
|
105
|
+
TemplateLiteral(node: any): void;
|
|
106
|
+
});
|
|
107
|
+
};
|
|
108
|
+
'jsx-no-script-url': import("eslint").Rule.RuleModule;
|
|
109
|
+
'jsx-no-target-blank': import("eslint").Rule.RuleModule;
|
|
110
|
+
'jsx-no-useless-fragment': import("eslint").Rule.RuleModule;
|
|
111
|
+
'jsx-one-expression-per-line': import("eslint").Rule.RuleModule;
|
|
112
|
+
'jsx-no-undef': import("eslint").Rule.RuleModule;
|
|
113
|
+
'jsx-curly-brace-presence': import("eslint").Rule.RuleModule;
|
|
114
|
+
'jsx-pascal-case': import("eslint").Rule.RuleModule;
|
|
115
|
+
'jsx-fragments': import("eslint").Rule.RuleModule;
|
|
116
|
+
'jsx-props-no-multi-spaces': import("eslint").Rule.RuleModule;
|
|
117
|
+
'jsx-props-no-spreading': import("eslint").Rule.RuleModule;
|
|
118
|
+
'jsx-props-no-spread-multi': {
|
|
119
|
+
meta: {
|
|
120
|
+
docs: {
|
|
121
|
+
description: string;
|
|
122
|
+
category: string;
|
|
123
|
+
recommended: boolean;
|
|
124
|
+
url: string;
|
|
125
|
+
};
|
|
126
|
+
messages: {
|
|
127
|
+
noMultiSpreading: string;
|
|
128
|
+
};
|
|
129
|
+
};
|
|
130
|
+
create(context: any): {
|
|
131
|
+
JSXOpeningElement(node: any): void;
|
|
132
|
+
};
|
|
133
|
+
};
|
|
134
|
+
'jsx-sort-default-props': import("eslint").Rule.RuleModule;
|
|
135
|
+
'jsx-sort-props': import("eslint").Rule.RuleModule;
|
|
136
|
+
'jsx-space-before-closing': import("eslint").Rule.RuleModule;
|
|
137
|
+
'jsx-tag-spacing': import("eslint").Rule.RuleModule;
|
|
138
|
+
'jsx-uses-react': import("eslint").Rule.RuleModule;
|
|
139
|
+
'jsx-uses-vars': import("eslint").Rule.RuleModule;
|
|
140
|
+
'jsx-wrap-multilines': import("eslint").Rule.RuleModule;
|
|
141
|
+
'no-invalid-html-attribute': import("eslint").Rule.RuleModule;
|
|
142
|
+
'no-access-state-in-setstate': import("eslint").Rule.RuleModule;
|
|
143
|
+
'no-adjacent-inline-elements': import("eslint").Rule.RuleModule;
|
|
144
|
+
'no-array-index-key': import("eslint").Rule.RuleModule;
|
|
145
|
+
'no-arrow-function-lifecycle': import("eslint").Rule.RuleModule;
|
|
146
|
+
'no-children-prop': import("eslint").Rule.RuleModule;
|
|
147
|
+
'no-danger': import("eslint").Rule.RuleModule;
|
|
148
|
+
'no-danger-with-children': import("eslint").Rule.RuleModule;
|
|
149
|
+
'no-deprecated': import("eslint").Rule.RuleModule;
|
|
150
|
+
'no-did-mount-set-state': import("eslint").Rule.RuleModule;
|
|
151
|
+
'no-did-update-set-state': import("eslint").Rule.RuleModule;
|
|
152
|
+
'no-direct-mutation-state': import("eslint").Rule.RuleModule;
|
|
153
|
+
'no-find-dom-node': import("eslint").Rule.RuleModule;
|
|
154
|
+
'no-is-mounted': import("eslint").Rule.RuleModule;
|
|
155
|
+
'no-multi-comp': import("eslint").Rule.RuleModule;
|
|
156
|
+
'no-namespace': import("eslint").Rule.RuleModule;
|
|
157
|
+
'no-set-state': import("eslint").Rule.RuleModule;
|
|
158
|
+
'no-string-refs': import("eslint").Rule.RuleModule;
|
|
159
|
+
'no-redundant-should-component-update': import("eslint").Rule.RuleModule;
|
|
160
|
+
'no-render-return-value': import("eslint").Rule.RuleModule;
|
|
161
|
+
'no-this-in-sfc': import("eslint").Rule.RuleModule;
|
|
162
|
+
'no-typos': import("eslint").Rule.RuleModule;
|
|
163
|
+
'no-unescaped-entities': import("eslint").Rule.RuleModule;
|
|
164
|
+
'no-unknown-property': import("eslint").Rule.RuleModule;
|
|
165
|
+
'no-unsafe': import("eslint").Rule.RuleModule;
|
|
166
|
+
'no-unstable-nested-components': import("eslint").Rule.RuleModule;
|
|
167
|
+
'no-unused-class-component-methods': import("eslint").Rule.RuleModule;
|
|
168
|
+
'no-unused-prop-types': import("eslint").Rule.RuleModule;
|
|
169
|
+
'no-unused-state': import("eslint").Rule.RuleModule;
|
|
170
|
+
'no-object-type-as-default-prop': import("eslint").Rule.RuleModule;
|
|
171
|
+
'no-will-update-set-state': import("eslint").Rule.RuleModule;
|
|
172
|
+
'prefer-es6-class': import("eslint").Rule.RuleModule;
|
|
173
|
+
'prefer-exact-props': import("eslint").Rule.RuleModule;
|
|
174
|
+
'prefer-read-only-props': import("eslint").Rule.RuleModule;
|
|
175
|
+
'prefer-stateless-function': import("eslint").Rule.RuleModule;
|
|
176
|
+
'prop-types': import("eslint").Rule.RuleModule;
|
|
177
|
+
'react-in-jsx-scope': import("eslint").Rule.RuleModule;
|
|
178
|
+
'require-default-props': import("eslint").Rule.RuleModule;
|
|
179
|
+
'require-optimization': import("eslint").Rule.RuleModule;
|
|
180
|
+
'require-render-return': import("eslint").Rule.RuleModule;
|
|
181
|
+
'self-closing-comp': import("eslint").Rule.RuleModule;
|
|
182
|
+
'sort-comp': import("eslint").Rule.RuleModule;
|
|
183
|
+
'sort-default-props': import("eslint").Rule.RuleModule;
|
|
184
|
+
'sort-prop-types': import("eslint").Rule.RuleModule;
|
|
185
|
+
'state-in-constructor': import("eslint").Rule.RuleModule;
|
|
186
|
+
'static-property-placement': import("eslint").Rule.RuleModule;
|
|
187
|
+
'style-prop-object': import("eslint").Rule.RuleModule;
|
|
188
|
+
'void-dom-elements-no-children': import("eslint").Rule.RuleModule;
|
|
189
|
+
}>;
|
|
190
|
+
rules: {
|
|
191
|
+
'boolean-prop-naming': import("eslint").Rule.RuleModule;
|
|
192
|
+
'button-has-type': import("eslint").Rule.RuleModule;
|
|
193
|
+
'checked-requires-onchange-or-readonly': import("eslint").Rule.RuleModule;
|
|
194
|
+
'default-props-match-prop-types': import("eslint").Rule.RuleModule;
|
|
195
|
+
'destructuring-assignment': import("eslint").Rule.RuleModule;
|
|
196
|
+
'display-name': import("eslint").Rule.RuleModule;
|
|
197
|
+
'forbid-component-props': import("eslint").Rule.RuleModule;
|
|
198
|
+
'forbid-dom-props': import("eslint").Rule.RuleModule;
|
|
199
|
+
'forbid-elements': import("eslint").Rule.RuleModule;
|
|
200
|
+
'forbid-foreign-prop-types': import("eslint").Rule.RuleModule;
|
|
201
|
+
'forbid-prop-types': import("eslint").Rule.RuleModule;
|
|
202
|
+
'forward-ref-uses-ref': {
|
|
203
|
+
meta: {
|
|
204
|
+
docs: {
|
|
205
|
+
description: string;
|
|
206
|
+
category: string;
|
|
207
|
+
recommended: boolean;
|
|
208
|
+
url: string;
|
|
209
|
+
};
|
|
210
|
+
messages: {
|
|
211
|
+
missingRefParameter: string;
|
|
212
|
+
addRefParameter: string;
|
|
213
|
+
removeForwardRef: string;
|
|
214
|
+
};
|
|
215
|
+
schema: undefined[];
|
|
216
|
+
type: string;
|
|
217
|
+
hasSuggestions: boolean;
|
|
218
|
+
};
|
|
219
|
+
create(context: any): {
|
|
220
|
+
"FunctionExpression, ArrowFunctionExpression"(node: any): void;
|
|
221
|
+
};
|
|
222
|
+
};
|
|
223
|
+
'function-component-definition': import("eslint").Rule.RuleModule;
|
|
224
|
+
'hook-use-state': import("eslint").Rule.RuleModule;
|
|
225
|
+
'iframe-missing-sandbox': import("eslint").Rule.RuleModule;
|
|
226
|
+
'jsx-boolean-value': import("eslint").Rule.RuleModule;
|
|
227
|
+
'jsx-child-element-spacing': import("eslint").Rule.RuleModule;
|
|
228
|
+
'jsx-closing-bracket-location': import("eslint").Rule.RuleModule;
|
|
229
|
+
'jsx-closing-tag-location': import("eslint").Rule.RuleModule;
|
|
230
|
+
'jsx-curly-spacing': import("eslint").Rule.RuleModule;
|
|
231
|
+
'jsx-curly-newline': import("eslint").Rule.RuleModule;
|
|
232
|
+
'jsx-equals-spacing': import("eslint").Rule.RuleModule;
|
|
233
|
+
'jsx-filename-extension': import("eslint").Rule.RuleModule;
|
|
234
|
+
'jsx-first-prop-new-line': import("eslint").Rule.RuleModule;
|
|
235
|
+
'jsx-handler-names': import("eslint").Rule.RuleModule;
|
|
236
|
+
'jsx-indent': import("eslint").Rule.RuleModule;
|
|
237
|
+
'jsx-indent-props': import("eslint").Rule.RuleModule;
|
|
238
|
+
'jsx-key': import("eslint").Rule.RuleModule;
|
|
239
|
+
'jsx-max-depth': import("eslint").Rule.RuleModule;
|
|
240
|
+
'jsx-max-props-per-line': import("eslint").Rule.RuleModule;
|
|
241
|
+
'jsx-newline': import("eslint").Rule.RuleModule;
|
|
242
|
+
'jsx-no-bind': import("eslint").Rule.RuleModule;
|
|
243
|
+
'jsx-no-comment-textnodes': import("eslint").Rule.RuleModule;
|
|
244
|
+
'jsx-no-constructed-context-values': import("eslint").Rule.RuleModule;
|
|
245
|
+
'jsx-no-duplicate-props': import("eslint").Rule.RuleModule;
|
|
246
|
+
'jsx-no-leaked-render': import("eslint").Rule.RuleModule;
|
|
247
|
+
'jsx-no-literals': {
|
|
248
|
+
meta: import("eslint").Rule.RuleMetaData;
|
|
249
|
+
create(context: any): (false & {
|
|
250
|
+
Literal(node: any): void;
|
|
251
|
+
JSXAttribute(node: any): void;
|
|
252
|
+
JSXText(node: any): void;
|
|
253
|
+
TemplateLiteral(node: any): void;
|
|
254
|
+
}) | ({
|
|
255
|
+
ImportDeclaration(node: any): void;
|
|
256
|
+
VariableDeclaration(node: any): void;
|
|
257
|
+
} & {
|
|
258
|
+
Literal(node: any): void;
|
|
259
|
+
JSXAttribute(node: any): void;
|
|
260
|
+
JSXText(node: any): void;
|
|
261
|
+
TemplateLiteral(node: any): void;
|
|
262
|
+
});
|
|
263
|
+
};
|
|
264
|
+
'jsx-no-script-url': import("eslint").Rule.RuleModule;
|
|
265
|
+
'jsx-no-target-blank': import("eslint").Rule.RuleModule;
|
|
266
|
+
'jsx-no-useless-fragment': import("eslint").Rule.RuleModule;
|
|
267
|
+
'jsx-one-expression-per-line': import("eslint").Rule.RuleModule;
|
|
268
|
+
'jsx-no-undef': import("eslint").Rule.RuleModule;
|
|
269
|
+
'jsx-curly-brace-presence': import("eslint").Rule.RuleModule;
|
|
270
|
+
'jsx-pascal-case': import("eslint").Rule.RuleModule;
|
|
271
|
+
'jsx-fragments': import("eslint").Rule.RuleModule;
|
|
272
|
+
'jsx-props-no-multi-spaces': import("eslint").Rule.RuleModule;
|
|
273
|
+
'jsx-props-no-spreading': import("eslint").Rule.RuleModule;
|
|
274
|
+
'jsx-props-no-spread-multi': {
|
|
275
|
+
meta: {
|
|
276
|
+
docs: {
|
|
277
|
+
description: string;
|
|
278
|
+
category: string;
|
|
279
|
+
recommended: boolean;
|
|
280
|
+
url: string;
|
|
281
|
+
};
|
|
282
|
+
messages: {
|
|
283
|
+
noMultiSpreading: string;
|
|
284
|
+
};
|
|
285
|
+
};
|
|
286
|
+
create(context: any): {
|
|
287
|
+
JSXOpeningElement(node: any): void;
|
|
288
|
+
};
|
|
289
|
+
};
|
|
290
|
+
'jsx-sort-default-props': import("eslint").Rule.RuleModule;
|
|
291
|
+
'jsx-sort-props': import("eslint").Rule.RuleModule;
|
|
292
|
+
'jsx-space-before-closing': import("eslint").Rule.RuleModule;
|
|
293
|
+
'jsx-tag-spacing': import("eslint").Rule.RuleModule;
|
|
294
|
+
'jsx-uses-react': import("eslint").Rule.RuleModule;
|
|
295
|
+
'jsx-uses-vars': import("eslint").Rule.RuleModule;
|
|
296
|
+
'jsx-wrap-multilines': import("eslint").Rule.RuleModule;
|
|
297
|
+
'no-invalid-html-attribute': import("eslint").Rule.RuleModule;
|
|
298
|
+
'no-access-state-in-setstate': import("eslint").Rule.RuleModule;
|
|
299
|
+
'no-adjacent-inline-elements': import("eslint").Rule.RuleModule;
|
|
300
|
+
'no-array-index-key': import("eslint").Rule.RuleModule;
|
|
301
|
+
'no-arrow-function-lifecycle': import("eslint").Rule.RuleModule;
|
|
302
|
+
'no-children-prop': import("eslint").Rule.RuleModule;
|
|
303
|
+
'no-danger': import("eslint").Rule.RuleModule;
|
|
304
|
+
'no-danger-with-children': import("eslint").Rule.RuleModule;
|
|
305
|
+
'no-deprecated': import("eslint").Rule.RuleModule;
|
|
306
|
+
'no-did-mount-set-state': import("eslint").Rule.RuleModule;
|
|
307
|
+
'no-did-update-set-state': import("eslint").Rule.RuleModule;
|
|
308
|
+
'no-direct-mutation-state': import("eslint").Rule.RuleModule;
|
|
309
|
+
'no-find-dom-node': import("eslint").Rule.RuleModule;
|
|
310
|
+
'no-is-mounted': import("eslint").Rule.RuleModule;
|
|
311
|
+
'no-multi-comp': import("eslint").Rule.RuleModule;
|
|
312
|
+
'no-namespace': import("eslint").Rule.RuleModule;
|
|
313
|
+
'no-set-state': import("eslint").Rule.RuleModule;
|
|
314
|
+
'no-string-refs': import("eslint").Rule.RuleModule;
|
|
315
|
+
'no-redundant-should-component-update': import("eslint").Rule.RuleModule;
|
|
316
|
+
'no-render-return-value': import("eslint").Rule.RuleModule;
|
|
317
|
+
'no-this-in-sfc': import("eslint").Rule.RuleModule;
|
|
318
|
+
'no-typos': import("eslint").Rule.RuleModule;
|
|
319
|
+
'no-unescaped-entities': import("eslint").Rule.RuleModule;
|
|
320
|
+
'no-unknown-property': import("eslint").Rule.RuleModule;
|
|
321
|
+
'no-unsafe': import("eslint").Rule.RuleModule;
|
|
322
|
+
'no-unstable-nested-components': import("eslint").Rule.RuleModule;
|
|
323
|
+
'no-unused-class-component-methods': import("eslint").Rule.RuleModule;
|
|
324
|
+
'no-unused-prop-types': import("eslint").Rule.RuleModule;
|
|
325
|
+
'no-unused-state': import("eslint").Rule.RuleModule;
|
|
326
|
+
'no-object-type-as-default-prop': import("eslint").Rule.RuleModule;
|
|
327
|
+
'no-will-update-set-state': import("eslint").Rule.RuleModule;
|
|
328
|
+
'prefer-es6-class': import("eslint").Rule.RuleModule;
|
|
329
|
+
'prefer-exact-props': import("eslint").Rule.RuleModule;
|
|
330
|
+
'prefer-read-only-props': import("eslint").Rule.RuleModule;
|
|
331
|
+
'prefer-stateless-function': import("eslint").Rule.RuleModule;
|
|
332
|
+
'prop-types': import("eslint").Rule.RuleModule;
|
|
333
|
+
'react-in-jsx-scope': import("eslint").Rule.RuleModule;
|
|
334
|
+
'require-default-props': import("eslint").Rule.RuleModule;
|
|
335
|
+
'require-optimization': import("eslint").Rule.RuleModule;
|
|
336
|
+
'require-render-return': import("eslint").Rule.RuleModule;
|
|
337
|
+
'self-closing-comp': import("eslint").Rule.RuleModule;
|
|
338
|
+
'sort-comp': import("eslint").Rule.RuleModule;
|
|
339
|
+
'sort-default-props': import("eslint").Rule.RuleModule;
|
|
340
|
+
'sort-prop-types': import("eslint").Rule.RuleModule;
|
|
341
|
+
'state-in-constructor': import("eslint").Rule.RuleModule;
|
|
342
|
+
'static-property-placement': import("eslint").Rule.RuleModule;
|
|
343
|
+
'style-prop-object': import("eslint").Rule.RuleModule;
|
|
344
|
+
'void-dom-elements-no-children': import("eslint").Rule.RuleModule;
|
|
345
|
+
};
|
|
346
|
+
configs: {
|
|
347
|
+
recommended: {
|
|
348
|
+
plugins: ["react"];
|
|
349
|
+
parserOptions: {
|
|
350
|
+
ecmaFeatures: {
|
|
351
|
+
jsx: boolean;
|
|
352
|
+
};
|
|
353
|
+
};
|
|
354
|
+
rules: {
|
|
355
|
+
"react/display-name": number;
|
|
356
|
+
"react/jsx-key": number;
|
|
357
|
+
"react/jsx-no-comment-textnodes": number;
|
|
358
|
+
"react/jsx-no-duplicate-props": number;
|
|
359
|
+
"react/jsx-no-target-blank": number;
|
|
360
|
+
"react/jsx-no-undef": number;
|
|
361
|
+
"react/jsx-uses-react": number;
|
|
362
|
+
"react/jsx-uses-vars": number;
|
|
363
|
+
"react/no-children-prop": number;
|
|
364
|
+
"react/no-danger-with-children": number;
|
|
365
|
+
"react/no-deprecated": number;
|
|
366
|
+
"react/no-direct-mutation-state": number;
|
|
367
|
+
"react/no-find-dom-node": number;
|
|
368
|
+
"react/no-is-mounted": number;
|
|
369
|
+
"react/no-render-return-value": number;
|
|
370
|
+
"react/no-string-refs": number;
|
|
371
|
+
"react/no-unescaped-entities": number;
|
|
372
|
+
"react/no-unknown-property": number;
|
|
373
|
+
"react/no-unsafe": number;
|
|
374
|
+
"react/prop-types": number;
|
|
375
|
+
"react/react-in-jsx-scope": number;
|
|
376
|
+
"react/require-render-return": number;
|
|
377
|
+
};
|
|
378
|
+
};
|
|
379
|
+
all: {
|
|
380
|
+
plugins: ["react"];
|
|
381
|
+
parserOptions: {
|
|
382
|
+
ecmaFeatures: {
|
|
383
|
+
jsx: boolean;
|
|
384
|
+
};
|
|
385
|
+
};
|
|
386
|
+
rules: Record<"boolean-prop-naming" | "button-has-type" | "checked-requires-onchange-or-readonly" | "default-props-match-prop-types" | "destructuring-assignment" | "display-name" | "forbid-component-props" | "forbid-dom-props" | "forbid-elements" | "forbid-foreign-prop-types" | "forbid-prop-types" | "prop-types" | "forward-ref-uses-ref" | "function-component-definition" | "hook-use-state" | "iframe-missing-sandbox" | "jsx-boolean-value" | "jsx-child-element-spacing" | "jsx-closing-bracket-location" | "jsx-closing-tag-location" | "jsx-curly-spacing" | "jsx-curly-newline" | "jsx-equals-spacing" | "jsx-filename-extension" | "jsx-first-prop-new-line" | "jsx-handler-names" | "jsx-indent" | "jsx-indent-props" | "jsx-key" | "jsx-max-depth" | "jsx-max-props-per-line" | "jsx-newline" | "jsx-no-bind" | "jsx-no-comment-textnodes" | "jsx-no-constructed-context-values" | "jsx-no-duplicate-props" | "jsx-no-leaked-render" | "jsx-no-literals" | "jsx-no-script-url" | "jsx-no-target-blank" | "jsx-no-useless-fragment" | "jsx-one-expression-per-line" | "jsx-no-undef" | "jsx-curly-brace-presence" | "jsx-pascal-case" | "jsx-fragments" | "jsx-props-no-multi-spaces" | "jsx-props-no-spreading" | "jsx-props-no-spread-multi" | "sort-default-props" | "jsx-sort-default-props" | "jsx-sort-props" | "jsx-tag-spacing" | "jsx-space-before-closing" | "jsx-uses-react" | "jsx-uses-vars" | "jsx-wrap-multilines" | "no-invalid-html-attribute" | "no-access-state-in-setstate" | "no-adjacent-inline-elements" | "no-array-index-key" | "no-arrow-function-lifecycle" | "no-children-prop" | "no-danger" | "no-danger-with-children" | "no-deprecated" | "no-direct-mutation-state" | "no-find-dom-node" | "no-is-mounted" | "no-multi-comp" | "no-namespace" | "no-set-state" | "no-string-refs" | "no-redundant-should-component-update" | "no-render-return-value" | "no-this-in-sfc" | "no-typos" | "no-unescaped-entities" | "no-unknown-property" | "no-unsafe" | "no-unstable-nested-components" | "no-unused-class-component-methods" | "no-unused-prop-types" | "no-unused-state" | "no-object-type-as-default-prop" | "prefer-es6-class" | "prefer-exact-props" | "prefer-read-only-props" | "prefer-stateless-function" | "react-in-jsx-scope" | "require-default-props" | "require-optimization" | "require-render-return" | "self-closing-comp" | "sort-comp" | "sort-prop-types" | "state-in-constructor" | "static-property-placement" | "style-prop-object" | "void-dom-elements-no-children" | "no-did-mount-set-state" | "no-did-update-set-state" | "no-will-update-set-state", 2 | "error">;
|
|
387
|
+
};
|
|
388
|
+
'jsx-runtime': {
|
|
389
|
+
plugins: ["react"];
|
|
390
|
+
parserOptions: {
|
|
391
|
+
ecmaFeatures: {
|
|
392
|
+
jsx: boolean;
|
|
393
|
+
};
|
|
394
|
+
jsxPragma: any;
|
|
395
|
+
};
|
|
396
|
+
rules: {
|
|
397
|
+
"react/react-in-jsx-scope": number;
|
|
398
|
+
"react/jsx-uses-react": number;
|
|
399
|
+
};
|
|
400
|
+
};
|
|
401
|
+
} & {
|
|
402
|
+
flat?: Record<string, import("eslint-plugin-react").ReactFlatConfig>;
|
|
403
|
+
};
|
|
404
|
+
};
|
|
42
405
|
readonly "react-hooks": unknown;
|
|
43
406
|
readonly sonarjs: typeof import("eslint-plugin-sonarjs");
|
|
44
407
|
readonly unicorn: import("eslint").ESLint.Plugin & {
|
|
@@ -155,7 +518,6 @@ export declare function typescript(project?: string): readonly [{
|
|
|
155
518
|
readonly "no-empty-function": "off";
|
|
156
519
|
readonly "no-invalid-this": "off";
|
|
157
520
|
readonly "no-shadow": "off";
|
|
158
|
-
readonly "lines-between-class-members": "off";
|
|
159
521
|
readonly "no-array-constructor": "off";
|
|
160
522
|
readonly "no-dupe-class-members": "off";
|
|
161
523
|
readonly "no-implied-eval": "off";
|
|
@@ -176,9 +538,6 @@ export declare function typescript(project?: string): readonly [{
|
|
|
176
538
|
readonly "@typescript-eslint/no-shadow": readonly ["error", {
|
|
177
539
|
readonly ignoreOnInitialization: true;
|
|
178
540
|
}];
|
|
179
|
-
readonly "@typescript-eslint/lines-between-class-members": readonly ["error", "always", {
|
|
180
|
-
readonly exceptAfterSingleLine: true;
|
|
181
|
-
}];
|
|
182
541
|
readonly "@typescript-eslint/no-array-constructor": "error";
|
|
183
542
|
readonly "@typescript-eslint/no-dupe-class-members": "error";
|
|
184
543
|
readonly "@typescript-eslint/no-implied-eval": "error";
|
|
@@ -334,6 +693,7 @@ export declare function typescript(project?: string): readonly [{
|
|
|
334
693
|
readonly "unicorn/no-unreadable-iife": "error";
|
|
335
694
|
readonly "unicorn/no-useless-spread": "error";
|
|
336
695
|
readonly "unicorn/prefer-array-flat-map": "error";
|
|
696
|
+
readonly "unicorn/prefer-export-from": "error";
|
|
337
697
|
readonly "unicorn/prefer-global-this": "error";
|
|
338
698
|
readonly "unicorn/prefer-includes": "error";
|
|
339
699
|
readonly "unicorn/prefer-module": "error";
|
|
@@ -465,16 +825,6 @@ export declare function typescript(project?: string): readonly [{
|
|
|
465
825
|
readonly 'prefer-regex-literals': readonly ["error", {
|
|
466
826
|
readonly disallowRedundantWrapping: true;
|
|
467
827
|
}];
|
|
468
|
-
readonly 'spaced-comment': readonly ["error", "always", {
|
|
469
|
-
readonly line: {
|
|
470
|
-
readonly markers: readonly ["*package", "!", "/", ",", "="];
|
|
471
|
-
};
|
|
472
|
-
readonly block: {
|
|
473
|
-
readonly balanced: true;
|
|
474
|
-
readonly markers: readonly ["*package", "!", ",", ":", "::", "flow-include"];
|
|
475
|
-
readonly exceptions: readonly ["*"];
|
|
476
|
-
};
|
|
477
|
-
}];
|
|
478
828
|
readonly 'symbol-description': "error";
|
|
479
829
|
readonly 'unicode-bom': readonly ["error", "never"];
|
|
480
830
|
readonly 'use-isnan': readonly ["error", {
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/config/typescript.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,aAAa,MAAM,yBAAyB,CAAC;AACzD,OAAO,QAAQ,MAAM,2BAA2B,CAAC;AACjD,OAAO,iBAAiB,MAAM,2BAA2B,CAAC;AAG1D,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM
|
|
1
|
+
{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../src/config/typescript.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,aAAa,MAAM,yBAAyB,CAAC;AACzD,OAAO,QAAQ,MAAM,2BAA2B,CAAC;AACjD,OAAO,iBAAiB,MAAM,2BAA2B,CAAC;AAG1D,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8CAchC,QAAQ;0CAEM,QACnB;gEAGA,QAAG;yDAEO,QAAQ;mDAEH,QACnB;uCAEI,QAAE;iDAEM,QACd;2CACiB,QAAQ;0CAEC,QACvB;oDAEc,QAAQ;4CAEJ,QAAQ;;;;;;;;;;;;;;;;;;;;;;wDAkBwB,QAAQ;yCACjC,QAAQ;iDAEX,QAAQ;4CACK,QAAQ;oDAExB,QAAQ;uDAGL,QAAQ;mDAEpB,QAAQ;4CAEW,QAAQ;4CACjB,QAAQ;6CACU,QAAQ;iDAEd,QAAQ;kDAGjC,QAAE;4CACJ,QAAG;qCAKL,QACH;2CAEyB,QACxB;kCACE,QAAO;wCACsB,QAC7B;iDAAwD,QAAQ;sCAA6C,QAAQ;sCAA6C,QAAQ;mDAEtK,QAAF;4DACc,QAAQ;iDACc,QACvC;+CAGiB,QACrB;;iCACyB,QAAQ;;;;;;;;;;;;;;;;4CAkB1B,QADO;8CAAqD,QAAQ;kDAAyD,QAAQ;sDAC3G,QAAQ;uCACR,QAAQ;mDACS,QAAQ;0CACtB,QAAQ;wCACxB,QAAQ;oDAEnB,QACJ;iDACsB,QAAQ;;;;;;;;;;;;;;;;;iDAexB,QAAL;yCACG,QACT;mDAEY,QAAQ;0CACgB,QAAQ;yCAEnC,QAAD;wCAEI,QAAQ;8CAGR,QAAQ;oDAEX,QACN;sDAEc,QAAQ;sDAGA,QAAQ;6CACa,QAC1C;sDAEqC,QAAQ;2CACL,QAC1C;oCACwB,QAAQ;kDAEU,QAAQ;wCACxB,QAAQ;iDACR,QAAQ;kDACb,QAAQ;mDACF,QAAQ;2CACjB,QAAQ;wCAEnB,QACV;wCAEQ,QACR;uCAA8C,QAAQ;uCACT,QAAQ;yCACnB,QAAQ;+DAElC,QAAD;iDACC,QAAI;yCACJ,QAAM;mCACN,QAAI;gDAAuD,QACnE;8CAAqD,QACrD;oCAA2C,QAAQ;wDAE3C,QAAG;4DACG,QAAQ;+CACZ,QAAD;0CAC8B,QAAQ;yDACpC,QAAQ;mDACX,QAAQ;2CAAkD,QAC9D;6CAAoD,QAAQ;iDACb,QAAQ;oDACP,QAAQ;qCACtB,QAAQ;6CACJ,QAAQ;gDACC,QAAO;+CACN,QAAQ;gDAEpD,QAAD;4CAAmD,QACtD;oCAA2C,QAC/C;6CAEqB,QAAQ;0CAEhB,QAAQ;+CAET,QAAH;oDAGG,QAAQ;4CACZ,QAAD;wDACC,QAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAtNiB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0P/B"}
|
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import process from "node:process";
|
|
2
2
|
import * as fengeTsPlugin from "@fenge/eslint-plugin-ts";
|
|
3
3
|
import tsParser from "@typescript-eslint/parser";
|
|
4
|
-
import deprecationPlugin from "eslint-plugin-deprecation";
|
|
4
|
+
import deprecationPlugin from "eslint-plugin-deprecation"; // TODO: Remove this plugin and use `@typescript-eslint/no-deprecated` when eslint upgraded to 9.
|
|
5
5
|
import { javascript } from "./javascript.js";
|
|
6
6
|
export function typescript(project) {
|
|
7
7
|
const jsConfig = javascript()[0];
|
|
@@ -235,4 +235,4 @@ export function typescript(project) {
|
|
|
235
235
|
},
|
|
236
236
|
];
|
|
237
237
|
}
|
|
238
|
-
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../src/config/typescript.ts"],"names":[],"mappings":"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","sourcesContent":["import process from \"node:process\";\nimport * as fengeTsPlugin from \"@fenge/eslint-plugin-ts\";\nimport tsParser from \"@typescript-eslint/parser\";\nimport deprecationPlugin from \"eslint-plugin-deprecation\";\nimport { javascript } from \"./javascript.js\";\n\nexport function typescript(project?: string) {\n  const jsConfig = javascript()[0];\n\n  const getTsExtensionRules = () => {\n    // https://typescript-eslint.io/rules/?=extension\n    const extensionRuleKeys = [\n      \"block-spacing\",\n      \"brace-style\",\n      \"class-methods-use-this\",\n      \"comma-dangle\",\n      \"comma-spacing\",\n      \"consistent-return\",\n      \"default-param-last\",\n      \"dot-notation\",\n      \"func-call-spacing\",\n      \"indent\",\n      \"init-declarations\",\n      \"key-spacing\",\n      \"keyword-spacing\",\n      \"lines-around-comment\",\n      \"lines-between-class-members\",\n      \"max-params\",\n      \"no-array-constructor\",\n      \"no-dupe-class-members\",\n      \"no-empty-function\",\n      \"no-extra-parens\",\n      \"no-extra-semi\",\n      \"no-implied-eval\",\n      \"no-invalid-this\",\n      \"no-loop-func\",\n      // \"no-loss-of-precision\",\n      \"no-magic-numbers\",\n      \"no-redeclare\",\n      \"no-restricted-imports\",\n      \"no-shadow\",\n      \"no-throw-literal\",\n      \"no-unused-expressions\",\n      \"no-unused-vars\",\n      \"no-use-before-define\",\n      \"no-useless-constructor\",\n      \"object-curly-spacing\",\n      \"only-throw-error\", // this rule based on 'eslint/no-throw-literal'\n      \"padding-line-between-statements\",\n      \"prefer-destructuring\",\n      \"prefer-promise-reject-errors\",\n      \"quotes\",\n      \"require-await\",\n      \"return-await\", // this rule based on 'eslint/no-return-await' instead of 'eslint/return-await'\n      \"semi\",\n      \"space-before-blocks\",\n      \"space-before-function-paren\",\n      \"space-infix-ops\",\n    ] as const;\n    type ExtensionRuleKey = (typeof extensionRuleKeys)[number];\n    type JsConfigRuleKey = keyof typeof jsConfig.rules;\n\n    type JsExtensionKey = Extract<ExtensionRuleKey, JsConfigRuleKey>; // Extract\n    type TsExtensionKey = `@typescript-eslint/${JsExtensionKey}`;\n\n    type GetJsKey<T extends TsExtensionKey> =\n      T extends `@typescript-eslint/${infer K}` ? K : never;\n    type JsResult = {\n      [Key in JsExtensionKey]: \"off\";\n    };\n    type TsResult = {\n      [Key in TsExtensionKey]: (typeof jsConfig.rules)[GetJsKey<Key>];\n    };\n    type Result = JsResult & TsResult;\n\n    const extensionRuleKeySet = new Set<string>(extensionRuleKeys);\n    return Object.entries(jsConfig.rules)\n      .filter(([key]) => extensionRuleKeySet.has(key))\n      .reduce(\n        (prev, [jsRuleKey, jsRuleValue]) => ({\n          ...prev,\n          [jsRuleKey]: \"off\",\n          [`@typescript-eslint/${jsRuleKey}`]: jsRuleValue,\n        }),\n        {} as Result,\n      );\n  };\n\n  return [\n    {\n      ...jsConfig,\n      name: \"fenge/typescript\",\n      files: [\"**/*.{ts,cts,mts,tsx}\"],\n      languageOptions: {\n        ...jsConfig.languageOptions,\n        parser: tsParser, // Unfortunately parser cannot be a string. Eslint should support it. https://eslint.org/docs/latest/use/configure/configuration-files-new#configuring-a-custom-parser-and-its-options\n        parserOptions: {\n          ...jsConfig.languageOptions.parserOptions,\n          tsconfigRootDir: process.cwd(),\n          project: project ?? \"tsconfig.json\",\n        },\n      },\n      plugins: {\n        ...jsConfig.plugins,\n        deprecation: deprecationPlugin,\n        \"@fenge-ts\": fengeTsPlugin,\n      },\n      rules: {\n        ...jsConfig.rules,\n        ...getTsExtensionRules(),\n\n        // deprecation\n        \"deprecation/deprecation\": \"error\",\n        // fenge\n        \"@fenge-ts/exact-map-set-type\": \"error\",\n        \"@fenge-ts/no-const-enum\": \"error\",\n        \"@fenge-ts/no-declares-in-ts-file\": \"error\",\n        \"@fenge-ts/no-export-assignment\": \"error\",\n        \"@fenge-ts/no-property-decorator\": \"error\",\n        \"@fenge-ts/no-untyped-empty-array\": \"error\",\n        // typescript\n        \"@typescript-eslint/adjacent-overload-signatures\": \"error\",\n        // \"@typescript-eslint/array-type\": [\"error\", 'array-simple'], // The default option is 'array'. Not very sure if we need to change the option. So disabled it.\n        \"@typescript-eslint/await-thenable\": \"error\",\n        \"@typescript-eslint/ban-types\": \"error\",\n        \"@typescript-eslint/consistent-generic-constructors\": \"error\",\n        \"@typescript-eslint/consistent-indexed-object-style\": \"error\",\n        \"@typescript-eslint/consistent-type-assertions\": [\n          \"error\",\n          {\n            assertionStyle: \"as\",\n            objectLiteralTypeAssertions: \"allow-as-parameter\",\n          },\n        ],\n        \"@typescript-eslint/consistent-type-definitions\": [\n          \"error\",\n          \"interface\",\n        ], // TODO should we change to 'type'?\n        \"@typescript-eslint/consistent-type-exports\": \"error\",\n        // \"@typescript-eslint/consistent-type-imports\": \"error,\n        \"@typescript-eslint/dot-notation\": [\"error\", { allowKeywords: true }],\n        \"@typescript-eslint/method-signature-style\": \"error\",\n        \"@typescript-eslint/naming-convention\": [\n          \"error\",\n          {\n            selector: \"function\",\n            format: [\"camelCase\", \"PascalCase\"],\n          },\n          {\n            selector: \"variable\",\n            types: [\"function\"],\n            format: [\"camelCase\", \"PascalCase\"], // decorators need PascalCase\n          },\n          {\n            selector: \"class\",\n            format: [\"PascalCase\"],\n          },\n          {\n            selector: \"interface\",\n            format: [\"PascalCase\"],\n          },\n          {\n            selector: \"typeAlias\",\n            format: [\"PascalCase\"],\n          },\n          {\n            selector: \"typeParameter\",\n            format: [\"UPPER_CASE\", \"PascalCase\"],\n          },\n        ],\n        \"@typescript-eslint/no-array-delete\": \"error\",\n        \"@typescript-eslint/no-base-to-string\": [\n          \"error\",\n          { ignoredTypeNames: [] },\n        ],\n        \"@typescript-eslint/no-confusing-non-null-assertion\": \"error\",\n        \"@typescript-eslint/no-duplicate-enum-values\": \"error\",\n        \"@typescript-eslint/no-duplicate-type-constituents\": \"error\",\n        \"@typescript-eslint/no-empty-object-type\": \"error\",\n        \"@typescript-eslint/no-extra-non-null-assertion\": \"error\",\n        \"@typescript-eslint/no-floating-promises\": [\n          \"error\",\n          {\n            ignoreVoid: false,\n          },\n        ],\n        \"@typescript-eslint/no-for-in-array\": \"error\",\n        \"@typescript-eslint/no-import-type-side-effects\": \"error\",\n        \"@typescript-eslint/no-inferrable-types\": \"error\",\n        \"@typescript-eslint/no-misused-new\": \"error\",\n        \"@typescript-eslint/no-misused-promises\": \"error\",\n        \"@typescript-eslint/no-mixed-enums\": \"error\",\n        \"@typescript-eslint/no-namespace\": \"error\",\n        \"@typescript-eslint/no-non-null-asserted-optional-chain\": \"error\",\n        \"@typescript-eslint/no-non-null-assertion\": \"error\",\n        \"@typescript-eslint/no-require-imports\": \"error\",\n        \"@typescript-eslint/no-this-alias\": \"error\",\n        \"@typescript-eslint/no-unnecessary-condition\": \"error\",\n        \"@typescript-eslint/no-unnecessary-parameter-property-assignment\":\n          \"error\",\n        \"@typescript-eslint/no-unnecessary-template-expression\": \"error\", // js also need this rule\n        \"@typescript-eslint/no-unnecessary-type-assertion\": \"error\",\n        \"@typescript-eslint/no-unnecessary-type-constraint\": \"error\",\n        \"@typescript-eslint/no-unsafe-declaration-merging\": \"error\",\n        // '@typescript-eslint/no-unsafe-function-type': \"error\",\n        // \"@typescript-eslint/no-wrapper-object-types\": \"error\",\n        \"@typescript-eslint/only-throw-error\": \"error\",\n        \"@typescript-eslint/prefer-as-const\": \"error\",\n        \"@typescript-eslint/prefer-function-type\": \"error\",\n        \"@typescript-eslint/prefer-optional-chain\": \"error\",\n        \"@typescript-eslint/prefer-readonly\": \"error\",\n        \"@typescript-eslint/prefer-ts-expect-error\": \"error\",\n        \"@typescript-eslint/restrict-plus-operands\": [\n          \"error\",\n          {\n            // allowAny: false,\n            allowBoolean: false,\n            allowNullish: false,\n            allowNumberAndString: false,\n            allowRegExp: false,\n          },\n        ],\n        // \"@typescript-eslint/restrict-template-expressions\": \"error\",\n        \"@typescript-eslint/return-await\": [\"error\", \"always\"],\n        \"@typescript-eslint/switch-exhaustiveness-check\": [\n          \"error\",\n          { requireDefaultForNonUnion: true },\n        ],\n        \"@typescript-eslint/unbound-method\": \"error\",\n        \"@typescript-eslint/unified-signatures\": \"error\",\n      },\n    },\n    {\n      name: \"fenge/typescript/config\",\n      files: [\"**/*.config.{ts,cts,mts,tsx}\"],\n      rules: {\n        \"import/no-default-export\": \"off\",\n      },\n    },\n    {\n      name: \"fenge/typescript/declaration\",\n      files: [\"**/*.d.{ts,cts,mts,tsx}\"],\n      rules: {\n        \"import/no-default-export\": \"off\",\n      },\n    },\n    {\n      // https://github.com/motemen/minimatch-cheat-sheet\n      name: \"fenge/typescript/test\",\n      files: [\n        \"**/__tests__/**/*.{ts,cts,mts,tsx}\",\n        \"**/*.{test,spec}.{ts,cts,mts,tsx}\",\n      ],\n      rules: {\n        \"@typescript-eslint/no-floating-promises\": \"off\",\n        \"@typescript-eslint/unbound-method\": \"off\",\n        \"esm/no-phantom-dep-imports\": [\"error\", { allowDevDependencies: true }],\n      },\n    },\n  ] as const;\n}\n"]}
|
|
238
|
+
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typescript.js","sourceRoot":"","sources":["../../src/config/typescript.ts"],"names":[],"mappings":"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","sourcesContent":["import process from \"node:process\";\nimport * as fengeTsPlugin from \"@fenge/eslint-plugin-ts\";\nimport tsParser from \"@typescript-eslint/parser\";\nimport deprecationPlugin from \"eslint-plugin-deprecation\"; // TODO: Remove this plugin and use `@typescript-eslint/no-deprecated` when eslint upgraded to 9.\nimport { javascript } from \"./javascript.js\";\n\nexport function typescript(project?: string) {\n  const jsConfig = javascript()[0];\n\n  const getTsExtensionRules = () => {\n    // https://typescript-eslint.io/rules/?=extension\n    const extensionRuleKeys = [\n      \"block-spacing\",\n      \"brace-style\",\n      \"class-methods-use-this\",\n      \"comma-dangle\",\n      \"comma-spacing\",\n      \"consistent-return\",\n      \"default-param-last\",\n      \"dot-notation\",\n      \"func-call-spacing\",\n      \"indent\",\n      \"init-declarations\",\n      \"key-spacing\",\n      \"keyword-spacing\",\n      \"lines-around-comment\",\n      \"lines-between-class-members\",\n      \"max-params\",\n      \"no-array-constructor\",\n      \"no-dupe-class-members\",\n      \"no-empty-function\",\n      \"no-extra-parens\",\n      \"no-extra-semi\",\n      \"no-implied-eval\",\n      \"no-invalid-this\",\n      \"no-loop-func\",\n      // \"no-loss-of-precision\",\n      \"no-magic-numbers\",\n      \"no-redeclare\",\n      \"no-restricted-imports\",\n      \"no-shadow\",\n      \"no-throw-literal\",\n      \"no-unused-expressions\",\n      \"no-unused-vars\",\n      \"no-use-before-define\",\n      \"no-useless-constructor\",\n      \"object-curly-spacing\",\n      \"only-throw-error\", // this rule based on 'eslint/no-throw-literal'\n      \"padding-line-between-statements\",\n      \"prefer-destructuring\",\n      \"prefer-promise-reject-errors\",\n      \"quotes\",\n      \"require-await\",\n      \"return-await\", // this rule based on 'eslint/no-return-await' instead of 'eslint/return-await'\n      \"semi\",\n      \"space-before-blocks\",\n      \"space-before-function-paren\",\n      \"space-infix-ops\",\n    ] as const;\n    type ExtensionRuleKey = (typeof extensionRuleKeys)[number];\n    type JsConfigRuleKey = keyof typeof jsConfig.rules;\n\n    type JsExtensionKey = Extract<ExtensionRuleKey, JsConfigRuleKey>; // Extract\n    type TsExtensionKey = `@typescript-eslint/${JsExtensionKey}`;\n\n    type GetJsKey<T extends TsExtensionKey> =\n      T extends `@typescript-eslint/${infer K}` ? K : never;\n    type JsResult = {\n      [Key in JsExtensionKey]: \"off\";\n    };\n    type TsResult = {\n      [Key in TsExtensionKey]: (typeof jsConfig.rules)[GetJsKey<Key>];\n    };\n    type Result = JsResult & TsResult;\n\n    const extensionRuleKeySet = new Set<string>(extensionRuleKeys);\n    return Object.entries(jsConfig.rules)\n      .filter(([key]) => extensionRuleKeySet.has(key))\n      .reduce(\n        (prev, [jsRuleKey, jsRuleValue]) => ({\n          ...prev,\n          [jsRuleKey]: \"off\",\n          [`@typescript-eslint/${jsRuleKey}`]: jsRuleValue,\n        }),\n        {} as Result,\n      );\n  };\n\n  return [\n    {\n      ...jsConfig,\n      name: \"fenge/typescript\",\n      files: [\"**/*.{ts,cts,mts,tsx}\"],\n      languageOptions: {\n        ...jsConfig.languageOptions,\n        parser: tsParser, // Unfortunately parser cannot be a string. Eslint should support it. https://eslint.org/docs/latest/use/configure/configuration-files-new#configuring-a-custom-parser-and-its-options\n        parserOptions: {\n          ...jsConfig.languageOptions.parserOptions,\n          tsconfigRootDir: process.cwd(),\n          project: project ?? \"tsconfig.json\",\n        },\n      },\n      plugins: {\n        ...jsConfig.plugins,\n        deprecation: deprecationPlugin,\n        \"@fenge-ts\": fengeTsPlugin,\n      },\n      rules: {\n        ...jsConfig.rules,\n        ...getTsExtensionRules(),\n\n        // deprecation\n        \"deprecation/deprecation\": \"error\",\n        // fenge\n        \"@fenge-ts/exact-map-set-type\": \"error\",\n        \"@fenge-ts/no-const-enum\": \"error\",\n        \"@fenge-ts/no-declares-in-ts-file\": \"error\",\n        \"@fenge-ts/no-export-assignment\": \"error\",\n        \"@fenge-ts/no-property-decorator\": \"error\",\n        \"@fenge-ts/no-untyped-empty-array\": \"error\",\n        // typescript\n        \"@typescript-eslint/adjacent-overload-signatures\": \"error\",\n        // \"@typescript-eslint/array-type\": [\"error\", 'array-simple'], // The default option is 'array'. Not very sure if we need to change the option. So disabled it.\n        \"@typescript-eslint/await-thenable\": \"error\",\n        \"@typescript-eslint/ban-types\": \"error\",\n        \"@typescript-eslint/consistent-generic-constructors\": \"error\",\n        \"@typescript-eslint/consistent-indexed-object-style\": \"error\",\n        \"@typescript-eslint/consistent-type-assertions\": [\n          \"error\",\n          {\n            assertionStyle: \"as\",\n            objectLiteralTypeAssertions: \"allow-as-parameter\",\n          },\n        ],\n        \"@typescript-eslint/consistent-type-definitions\": [\n          \"error\",\n          \"interface\",\n        ], // TODO should we change to 'type'?\n        \"@typescript-eslint/consistent-type-exports\": \"error\",\n        // \"@typescript-eslint/consistent-type-imports\": \"error,\n        \"@typescript-eslint/dot-notation\": [\"error\", { allowKeywords: true }],\n        \"@typescript-eslint/method-signature-style\": \"error\",\n        \"@typescript-eslint/naming-convention\": [\n          \"error\",\n          {\n            selector: \"function\",\n            format: [\"camelCase\", \"PascalCase\"],\n          },\n          {\n            selector: \"variable\",\n            types: [\"function\"],\n            format: [\"camelCase\", \"PascalCase\"], // decorators need PascalCase\n          },\n          {\n            selector: \"class\",\n            format: [\"PascalCase\"],\n          },\n          {\n            selector: \"interface\",\n            format: [\"PascalCase\"],\n          },\n          {\n            selector: \"typeAlias\",\n            format: [\"PascalCase\"],\n          },\n          {\n            selector: \"typeParameter\",\n            format: [\"UPPER_CASE\", \"PascalCase\"],\n          },\n        ],\n        \"@typescript-eslint/no-array-delete\": \"error\",\n        \"@typescript-eslint/no-base-to-string\": [\n          \"error\",\n          { ignoredTypeNames: [] },\n        ],\n        \"@typescript-eslint/no-confusing-non-null-assertion\": \"error\",\n        \"@typescript-eslint/no-duplicate-enum-values\": \"error\",\n        \"@typescript-eslint/no-duplicate-type-constituents\": \"error\",\n        \"@typescript-eslint/no-empty-object-type\": \"error\",\n        \"@typescript-eslint/no-extra-non-null-assertion\": \"error\",\n        \"@typescript-eslint/no-floating-promises\": [\n          \"error\",\n          {\n            ignoreVoid: false,\n          },\n        ],\n        \"@typescript-eslint/no-for-in-array\": \"error\",\n        \"@typescript-eslint/no-import-type-side-effects\": \"error\",\n        \"@typescript-eslint/no-inferrable-types\": \"error\",\n        \"@typescript-eslint/no-misused-new\": \"error\",\n        \"@typescript-eslint/no-misused-promises\": \"error\",\n        \"@typescript-eslint/no-mixed-enums\": \"error\",\n        \"@typescript-eslint/no-namespace\": \"error\",\n        \"@typescript-eslint/no-non-null-asserted-optional-chain\": \"error\",\n        \"@typescript-eslint/no-non-null-assertion\": \"error\",\n        \"@typescript-eslint/no-require-imports\": \"error\",\n        \"@typescript-eslint/no-this-alias\": \"error\",\n        \"@typescript-eslint/no-unnecessary-condition\": \"error\",\n        \"@typescript-eslint/no-unnecessary-parameter-property-assignment\":\n          \"error\",\n        \"@typescript-eslint/no-unnecessary-template-expression\": \"error\", // js also need this rule\n        \"@typescript-eslint/no-unnecessary-type-assertion\": \"error\",\n        \"@typescript-eslint/no-unnecessary-type-constraint\": \"error\",\n        \"@typescript-eslint/no-unsafe-declaration-merging\": \"error\",\n        // '@typescript-eslint/no-unsafe-function-type': \"error\",\n        // \"@typescript-eslint/no-wrapper-object-types\": \"error\",\n        \"@typescript-eslint/only-throw-error\": \"error\",\n        \"@typescript-eslint/prefer-as-const\": \"error\",\n        \"@typescript-eslint/prefer-function-type\": \"error\",\n        \"@typescript-eslint/prefer-optional-chain\": \"error\",\n        \"@typescript-eslint/prefer-readonly\": \"error\",\n        \"@typescript-eslint/prefer-ts-expect-error\": \"error\",\n        \"@typescript-eslint/restrict-plus-operands\": [\n          \"error\",\n          {\n            // allowAny: false,\n            allowBoolean: false,\n            allowNullish: false,\n            allowNumberAndString: false,\n            allowRegExp: false,\n          },\n        ],\n        // \"@typescript-eslint/restrict-template-expressions\": \"error\",\n        \"@typescript-eslint/return-await\": [\"error\", \"always\"],\n        \"@typescript-eslint/switch-exhaustiveness-check\": [\n          \"error\",\n          { requireDefaultForNonUnion: true },\n        ],\n        \"@typescript-eslint/unbound-method\": \"error\",\n        \"@typescript-eslint/unified-signatures\": \"error\",\n      },\n    },\n    {\n      name: \"fenge/typescript/config\",\n      files: [\"**/*.config.{ts,cts,mts,tsx}\"],\n      rules: {\n        \"import/no-default-export\": \"off\",\n      },\n    },\n    {\n      name: \"fenge/typescript/declaration\",\n      files: [\"**/*.d.{ts,cts,mts,tsx}\"],\n      rules: {\n        \"import/no-default-export\": \"off\",\n      },\n    },\n    {\n      // https://github.com/motemen/minimatch-cheat-sheet\n      name: \"fenge/typescript/test\",\n      files: [\n        \"**/__tests__/**/*.{ts,cts,mts,tsx}\",\n        \"**/*.{test,spec}.{ts,cts,mts,tsx}\",\n      ],\n      rules: {\n        \"@typescript-eslint/no-floating-promises\": \"off\",\n        \"@typescript-eslint/unbound-method\": \"off\",\n        \"esm/no-phantom-dep-imports\": [\"error\", { allowDevDependencies: true }],\n      },\n    },\n  ] as const;\n}\n"]}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@fenge/eslint-config",
|
|
3
|
-
"version": "0.1.
|
|
3
|
+
"version": "0.1.2",
|
|
4
4
|
"description": "A super strict eslint config for linting js/ts/package.json.",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"opinionated",
|
|
@@ -27,22 +27,22 @@
|
|
|
27
27
|
"@typescript-eslint/parser": "7.16.1",
|
|
28
28
|
"confusing-browser-globals": "1.0.11",
|
|
29
29
|
"eslint-plugin-deprecation": "3.0.0",
|
|
30
|
-
"eslint-plugin-es-x": "8.
|
|
30
|
+
"eslint-plugin-es-x": "8.1.0",
|
|
31
31
|
"eslint-plugin-fp": "2.3.0",
|
|
32
32
|
"eslint-plugin-import": "2.31.0",
|
|
33
|
-
"eslint-plugin-n": "17.
|
|
33
|
+
"eslint-plugin-n": "17.12.0",
|
|
34
34
|
"eslint-plugin-promise": "7.1.0",
|
|
35
|
-
"eslint-plugin-react": "7.37.
|
|
35
|
+
"eslint-plugin-react": "7.37.2",
|
|
36
36
|
"eslint-plugin-react-hooks": "5.0.0",
|
|
37
37
|
"eslint-plugin-simple-import-sort": "12.1.1",
|
|
38
38
|
"eslint-plugin-sonarjs": "1.0.4",
|
|
39
39
|
"eslint-plugin-unicorn": "56.0.0",
|
|
40
|
-
"globals": "15.
|
|
40
|
+
"globals": "15.12.0",
|
|
41
41
|
"@fenge/eslint-plugin": "0.1.1",
|
|
42
42
|
"@fenge/eslint-plugin-ts": "0.1.0",
|
|
43
43
|
"eslint-plugin-esm": "0.2.1",
|
|
44
44
|
"eslint-plugin-pkg-json": "0.1.1",
|
|
45
|
-
"eslint-plugin-publint": "0.0.
|
|
45
|
+
"eslint-plugin-publint": "0.0.4"
|
|
46
46
|
},
|
|
47
47
|
"devDependencies": {
|
|
48
48
|
"@swc-node/register": "1.10.0",
|
|
@@ -54,6 +54,6 @@
|
|
|
54
54
|
},
|
|
55
55
|
"scripts": {
|
|
56
56
|
"build": "tsc -p tsconfig.build.json",
|
|
57
|
-
"test": "
|
|
57
|
+
"test": "node --test --import @swc-node/register/esm-register \"**/*.spec.ts\""
|
|
58
58
|
}
|
|
59
59
|
}
|
package/src/config/javascript.ts
CHANGED
|
@@ -90,7 +90,7 @@ export function javascript() {
|
|
|
90
90
|
// }],
|
|
91
91
|
// 'key-spacing': ['error', { beforeColon: false, afterColon: true }],
|
|
92
92
|
// 'keyword-spacing': ['error', { before: true, after: true }],
|
|
93
|
-
'lines-between-class-members': ['error', 'always', { exceptAfterSingleLine: true }],
|
|
93
|
+
// 'lines-between-class-members': ['error', 'always', { exceptAfterSingleLine: true }],
|
|
94
94
|
// 'multiline-ternary': ['error', 'always-multiline'],
|
|
95
95
|
'new-cap': ['error', { newIsCap: true, capIsNew: false, properties: true }],
|
|
96
96
|
// 'new-parens': 'error',
|
|
@@ -218,10 +218,10 @@ export function javascript() {
|
|
|
218
218
|
// 'space-in-parens': ['error', 'never'],
|
|
219
219
|
// 'space-infix-ops': 'error',
|
|
220
220
|
// 'space-unary-ops': ['error', { words: true, nonwords: false }],
|
|
221
|
-
'spaced-comment': ['error', 'always', {
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
}],
|
|
221
|
+
// 'spaced-comment': ['error', 'always', {
|
|
222
|
+
// line: { markers: ['*package', '!', '/', ',', '='] },
|
|
223
|
+
// block: { balanced: true, markers: ['*package', '!', ',', ':', '::', 'flow-include'], exceptions: ['*'] }
|
|
224
|
+
// }],
|
|
225
225
|
'symbol-description': 'error',
|
|
226
226
|
// 'template-curly-spacing': ['error', 'never'],
|
|
227
227
|
// 'template-tag-spacing': ['error', 'never'],
|
|
@@ -439,6 +439,7 @@ export function javascript() {
|
|
|
439
439
|
"unicorn/no-unreadable-iife": "error",
|
|
440
440
|
"unicorn/no-useless-spread": "error",
|
|
441
441
|
"unicorn/prefer-array-flat-map": "error",
|
|
442
|
+
"unicorn/prefer-export-from": "error",
|
|
442
443
|
"unicorn/prefer-global-this": "error",
|
|
443
444
|
"unicorn/prefer-includes": "error",
|
|
444
445
|
"unicorn/prefer-module": "error",
|