DEPRECATED
This rule has been deprecated in favour of the naming-convention
rule. It will be removed in a future version of this plugin.
Rule Details
This rule extends the base eslint/camelcase
rule. It adds support for numerous TypeScript features.
How to use
{
// note you must disable the base rule as it can report incorrect errors
"camelcase": "off",
"@typescript-eslint/camelcase": ["error"]
}
Options
See eslint/camelcase
options. This rule adds the following options:
interface Options extends BaseCamelcaseOptions {
genericType?: 'always' | 'never';
}
const defaultOptions: Options = {
...baseCamelcaseDefaultOptions,
genericType: 'never',
};
"genericType": "never"
(default) does not check generic identifiers
"genericType": "always"
enforces camelCase style for generic identifiers
genericType: "always"
Examples of incorrect code for this rule with the default { "genericType": "always" }
option:
/* eslint @typescript-eslint/camelcase: ["error", { "genericType": "always" }] */
interface Foo<t_foo> {}
function foo<t_foo>() {}
class Foo<t_foo> {}
type Foo<t_foo> = {};
class Foo {
method<t_foo>() {}
}
interface Foo<t_foo extends object> {}
function foo<t_foo extends object>() {}
class Foo<t_foo extends object> {}
type Foo<t_foo extends object> = {};
class Foo {
method<t_foo extends object>() {}
}
interface Foo<t_foo = object> {}
function foo<t_foo = object>() {}
class Foo<t_foo = object> {}
type Foo<t_foo = object> = {};
class Foo {
method<t_foo = object>() {}
}
Examples of correct code for this rule with the default { "genericType": "always" }
option:
/* eslint @typescript-eslint/camelcase: ["error", { "genericType": "always" }] */
interface Foo<T> {}
function foo<t>() {}
class Foo<T> {}
type Foo<T> = {};
class Foo {
method<T>() {}
}
interface Foo<T extends object> {}
function foo<T extends object>() {}
class Foo<T extends object> {}
type Foo<T extends object> = {};
class Foo {
method<T extends object>() {}
}
interface Foo<T = object> {}
function foo<T = object>() {}
class Foo<T = object> {}
type Foo<T = object> = {};
class Foo {
method<T = object>() {}
}
genericType: "never"
Examples of correct code for this rule with the { "genericType": "never" }
option:
/* eslint @typescript-eslint/camelcase: ["error", { "genericType": "never" }] */
interface Foo<t_foo> {}
function foo<t_foo>() {}
class Foo<t_foo> {}
type Foo<t_foo> = {};
class Foo {
method<t_foo>() {}
}
interface Foo<t_foo extends object> {}
function foo<t_foo extends object>() {}
class Foo<t_foo extends object> {}
type Foo<t_foo extends object> = {};
class Foo {
method<t_foo extends object>() {}
}
interface Foo<t_foo = object> {}
function foo<t_foo = object>() {}
class Foo<t_foo = object> {}
type Foo<t_foo = object> = {};
class Foo {
method<t_foo = object>() {}
}
Taken with ❤️ from ESLint core