camelcase/index.d.ts at main · sindresorhus/camelcase · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
export type Options = {
	/**
	Uppercase the first character: `foo-bar` → `FooBar`

	@default false

	@example
	```
	import camelCase from 'camelcase';

	camelCase('foo-bar', {pascalCase: true});
	//=> 'FooBar'

	camelCase('foo-bar', {pascalCase: false});
	//=> 'fooBar'
	```
	*/
	readonly pascalCase?: boolean;

	/**
	Preserve consecutive uppercase characters: `foo-BAR` → `FooBAR`

	@default false

	@example
	```
	import camelCase from 'camelcase';

	camelCase('foo-BAR', {preserveConsecutiveUppercase: true});
	//=> 'fooBAR'

	camelCase('foo-BAR', {preserveConsecutiveUppercase: false});
	//=> 'fooBar'
	````
	*/
	readonly preserveConsecutiveUppercase?: boolean;

	/**
	Controls whether letters immediately following digits are treated as word boundaries.

	**When `true` (default):**
	Capitalize the first letter immediately following a numeric sequence, unless a separator intervenes. This aligns with most utilities, such as Lodash.

	**When `false`:**
	Do not treat digits as word boundaries. Preserve the original case of letters immediately following digits. Separators still create word boundaries. This follows the Google Java Style Guide which treats numbers as non-boundary characters.

	@default true

	@example
	```
	import camelCase from 'camelcase';

	camelCase('foo2bar', {capitalizeAfterNumber: true});
	//=> 'foo2Bar'  (capitalizes 'b' after digit)

	camelCase('foo2bar', {capitalizeAfterNumber: false});
	//=> 'foo2bar'  (preserves lowercase 'b')

	// Preserves original case after numbers when false
	camelCase('Textures_3d', {capitalizeAfterNumber: false});
	//=> 'textures3d'  (preserves lowercase 'd')

	camelCase('Textures_3D', {capitalizeAfterNumber: false});
	//=> 'textures3D'  (preserves uppercase 'D')

	// Separators still create boundaries
	camelCase('foo_2_bar', {capitalizeAfterNumber: false});
	//=> 'foo2Bar'  ('bar' follows separator, not digit)
	```
	*/
	readonly capitalizeAfterNumber?: boolean;

	/**
	The locale parameter indicates the locale to be used to convert to upper/lower case according to any locale-specific case mappings. If multiple locales are given in an array, the best available locale is used.

	Default: The host environment’s current locale.

	@example
	```
	import camelCase from 'camelcase';

	camelCase('lorem-ipsum', {locale: 'en-US'});
	//=> 'loremIpsum'

	camelCase('lorem-ipsum', {locale: 'tr-TR'});
	//=> 'loremİpsum'

	camelCase('lorem-ipsum', {locale: ['en-US', 'en-GB']});
	//=> 'loremIpsum'

	camelCase('lorem-ipsum', {locale: ['tr', 'TR', 'tr-TR']});
	//=> 'loremİpsum'
	```

	Setting `locale: false` ignores the platform locale and uses the [Unicode Default Case Conversion](https://unicode-org.github.io/icu/userguide/transforms/casemappings.html#simple-single-character-case-mapping) algorithm:

	@example
	```
	import camelCase from 'camelcase';

	// On a platform with `tr-TR`.`

	camelCase('lorem-ipsum');
	//=> 'loremİpsum'

	camelCase('lorem-ipsum', {locale: false});
	//=> 'loremIpsum'
	```
	*/
	readonly locale?: false | string | readonly string[];
};

/**
Convert a dash/dot/underscore/space separated string to camelCase or PascalCase: `foo-bar` → `fooBar`.

Correctly handles Unicode strings.

@param input - The string to convert to camel case.

@example
```
import camelCase from 'camelcase';

camelCase('foo-bar');
//=> 'fooBar'

camelCase('foo_bar');
//=> 'fooBar'

camelCase('Foo-Bar');
//=> 'fooBar'

camelCase('розовый_пушистый_единорог');
//=> 'розовыйПушистыйЕдинорог'

camelCase('foo bar');
//=> 'fooBar'

console.log(process.argv[3]);
//=> '--foo-bar'
camelCase(process.argv[3]);
//=> 'fooBar'

camelCase(['foo', 'bar']);
//=> 'fooBar'

camelCase(['__foo__', '--bar']);
//=> '__fooBar'
```
*/
export default function camelcase(
	input: string | readonly string[],
	options?: Options
): string;