caseparser 2.1.0 → 4.0.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 +83 -36
- package/dist/index.cjs +530 -0
- package/dist/index.d.cts +360 -0
- package/dist/index.d.ts +332 -45
- package/dist/index.js +453 -279
- package/package.json +43 -22
- package/.nvmrc +0 -1
- package/CHANGELOG.md +0 -31
- package/dist/index.mjs +0 -309
package/dist/index.d.cts
ADDED
|
@@ -0,0 +1,360 @@
|
|
|
1
|
+
//#region src/types.d.ts
|
|
2
|
+
type CamelToDash<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "-" : ""}${Lowercase<L>}${CamelToDash<R>}` : T;
|
|
3
|
+
type CamelToPascal<T extends string> = Capitalize<T>;
|
|
4
|
+
type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "_" : ""}${Lowercase<L>}${CamelToSnake<R>}` : T;
|
|
5
|
+
type CamelToUpperDash<T extends string> = Uppercase<CamelToDash<T>>;
|
|
6
|
+
type CamelToUpperSnake<T extends string> = Uppercase<CamelToSnake<T>>;
|
|
7
|
+
type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
|
|
8
|
+
type DashToPascal<T extends string> = Capitalize<DashToCamel<T>>;
|
|
9
|
+
type DashToSnake<T extends string> = T extends `${infer L}-${infer R}` ? `${L}_${DashToSnake<R>}` : T;
|
|
10
|
+
type DashToUpperDash<T extends string> = Uppercase<T>;
|
|
11
|
+
type DashToUpperSnake<T extends string> = Uppercase<DashToSnake<T>>;
|
|
12
|
+
type PascalToCamel<T extends string> = Uncapitalize<T>;
|
|
13
|
+
type PascalToDash<T extends string> = CamelToDash<Uncapitalize<T>>;
|
|
14
|
+
type PascalToSnake<T extends string> = CamelToSnake<Uncapitalize<T>>;
|
|
15
|
+
type PascalToUpperDash<T extends string> = Uppercase<PascalToDash<T>>;
|
|
16
|
+
type PascalToUpperSnake<T extends string> = Uppercase<PascalToSnake<T>>;
|
|
17
|
+
type SnakeToCamel<T extends string> = T extends `${infer L}_${infer R}` ? `${L}${Capitalize<SnakeToCamel<R>>}` : T;
|
|
18
|
+
type SnakeToDash<T extends string> = T extends `${infer L}_${infer R}` ? `${L}-${SnakeToDash<R>}` : T;
|
|
19
|
+
type SnakeToPascal<T extends string> = Capitalize<SnakeToCamel<T>>;
|
|
20
|
+
type SnakeToUpperDash<T extends string> = Uppercase<SnakeToDash<T>>;
|
|
21
|
+
type SnakeToUpperSnake<T extends string> = Uppercase<T>;
|
|
22
|
+
type UpperDashToCamel<T extends string> = DashToCamel<Lowercase<T>>;
|
|
23
|
+
type UpperDashToDash<T extends string> = Lowercase<T>;
|
|
24
|
+
type UpperDashToPascal<T extends string> = Capitalize<UpperDashToCamel<T>>;
|
|
25
|
+
type UpperDashToSnake<T extends string> = DashToSnake<UpperDashToDash<T>>;
|
|
26
|
+
type UpperDashToUpperSnake<T extends string> = Uppercase<UpperDashToSnake<T>>;
|
|
27
|
+
type UpperSnakeToCamel<T extends string> = SnakeToCamel<Lowercase<T>>;
|
|
28
|
+
type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
|
|
29
|
+
type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
|
|
30
|
+
type UpperSnakeToSnake<T extends string> = Lowercase<T>;
|
|
31
|
+
type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
|
|
32
|
+
type ParserCamelType = "CamelToDash" | "CamelToPascal" | "CamelToSnake" | "CamelToUpperDash" | "CamelToUpperSnake";
|
|
33
|
+
type ParserDashType = "DashToCamel" | "DashToPascal" | "DashToSnake" | "DashToUpperDash" | "DashToUpperSnake";
|
|
34
|
+
type ParserPascalType = "PascalToCamel" | "PascalToDash" | "PascalToSnake" | "PascalToUpperDash" | "PascalToUpperSnake";
|
|
35
|
+
type ParserSnakeType = "SnakeToCamel" | "SnakeToDash" | "SnakeToPascal" | "SnakeToUpperDash" | "SnakeToUpperSnake";
|
|
36
|
+
type ParserUpperDashType = "UpperDashToCamel" | "UpperDashToDash" | "UpperDashToPascal" | "UpperDashToSnake" | "UpperDashToUpperSnake";
|
|
37
|
+
type ParserUpperSnakeType = "UpperSnakeToCamel" | "UpperSnakeToDash" | "UpperSnakeToPascal" | "UpperSnakeToSnake" | "UpperSnakeToUpperDash";
|
|
38
|
+
/** Identifies a conversion, e.g. `'CamelToSnake'`. */
|
|
39
|
+
type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType;
|
|
40
|
+
/** Flattens an intersection/mapped type so editors show the resulting keys. */
|
|
41
|
+
type Prettify<T> = { [K in keyof T]: T[K]; } & {};
|
|
42
|
+
/**
|
|
43
|
+
* The type returned by a conversion: strings stay `string`, and object keys
|
|
44
|
+
* (deeply, including inside arrays) are renamed according to the conversion `P`.
|
|
45
|
+
*/
|
|
46
|
+
type Result<T, P> = T extends string ? string : T extends Array<unknown> ? { [K in keyof T]: Result<T[K], P>; } : T extends object ? Prettify<{ [K in keyof T as P extends "CamelToDash" ? CamelToDash<K & string> : P extends "CamelToPascal" ? CamelToPascal<K & string> : P extends "CamelToSnake" ? CamelToSnake<K & string> : P extends "CamelToUpperDash" ? CamelToUpperDash<K & string> : P extends "CamelToUpperSnake" ? CamelToUpperSnake<K & string> : P extends "DashToCamel" ? DashToCamel<K & string> : P extends "DashToPascal" ? DashToPascal<K & string> : P extends "DashToSnake" ? DashToSnake<K & string> : P extends "DashToUpperDash" ? DashToUpperDash<K & string> : P extends "DashToUpperSnake" ? DashToUpperSnake<K & string> : P extends "PascalToCamel" ? PascalToCamel<K & string> : P extends "PascalToDash" ? PascalToDash<K & string> : P extends "PascalToSnake" ? PascalToSnake<K & string> : P extends "PascalToUpperDash" ? PascalToUpperDash<K & string> : P extends "PascalToUpperSnake" ? PascalToUpperSnake<K & string> : P extends "SnakeToCamel" ? SnakeToCamel<K & string> : P extends "SnakeToDash" ? SnakeToDash<K & string> : P extends "SnakeToPascal" ? SnakeToPascal<K & string> : P extends "SnakeToUpperDash" ? SnakeToUpperDash<K & string> : P extends "SnakeToUpperSnake" ? SnakeToUpperSnake<K & string> : P extends "UpperDashToCamel" ? UpperDashToCamel<K & string> : P extends "UpperDashToDash" ? UpperDashToDash<K & string> : P extends "UpperDashToPascal" ? UpperDashToPascal<K & string> : P extends "UpperDashToSnake" ? UpperDashToSnake<K & string> : P extends "UpperDashToUpperSnake" ? UpperDashToUpperSnake<K & string> : P extends "UpperSnakeToCamel" ? UpperSnakeToCamel<K & string> : P extends "UpperSnakeToDash" ? UpperSnakeToDash<K & string> : P extends "UpperSnakeToPascal" ? UpperSnakeToPascal<K & string> : P extends "UpperSnakeToSnake" ? UpperSnakeToSnake<K & string> : P extends "UpperSnakeToUpperDash" ? UpperSnakeToUpperDash<K & string> : never]: Result<T[K], P>; }> : T;
|
|
47
|
+
//#endregion
|
|
48
|
+
//#region src/camelCase/camelCase.d.ts
|
|
49
|
+
/**
|
|
50
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to dash-case.
|
|
51
|
+
*
|
|
52
|
+
* @example
|
|
53
|
+
* ```ts
|
|
54
|
+
* camelToDash('helloWorld'); // 'hello-world'
|
|
55
|
+
* camelToDash({ firstName: 'John' }); // { 'first-name': 'John' }
|
|
56
|
+
* ```
|
|
57
|
+
*/
|
|
58
|
+
export declare function camelToDash<T extends object | string>(input: T): Result<T, "CamelToDash">;
|
|
59
|
+
/**
|
|
60
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to snake_case.
|
|
61
|
+
*
|
|
62
|
+
* @example
|
|
63
|
+
* ```ts
|
|
64
|
+
* camelToSnake('helloWorld'); // 'hello_world'
|
|
65
|
+
* camelToSnake({ firstName: 'John' }); // { first_name: 'John' }
|
|
66
|
+
* ```
|
|
67
|
+
*/
|
|
68
|
+
export declare function camelToSnake<T extends object | string>(input: T): Result<T, "CamelToSnake">;
|
|
69
|
+
/**
|
|
70
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to PascalCase.
|
|
71
|
+
*
|
|
72
|
+
* @example
|
|
73
|
+
* ```ts
|
|
74
|
+
* camelToPascal('helloWorld'); // 'HelloWorld'
|
|
75
|
+
* camelToPascal({ firstName: 'John' }); // { FirstName: 'John' }
|
|
76
|
+
* ```
|
|
77
|
+
*/
|
|
78
|
+
export declare function camelToPascal<T extends object | string>(input: T): Result<T, "CamelToPascal">;
|
|
79
|
+
/**
|
|
80
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER_SNAKE_CASE.
|
|
81
|
+
*
|
|
82
|
+
* @example
|
|
83
|
+
* ```ts
|
|
84
|
+
* camelToUpperSnake('helloWorld'); // 'HELLO_WORLD'
|
|
85
|
+
* camelToUpperSnake({ firstName: 'John' }); // { FIRST_NAME: 'John' }
|
|
86
|
+
* ```
|
|
87
|
+
*/
|
|
88
|
+
export declare function camelToUpperSnake<T extends object | string>(input: T): Result<T, "CamelToUpperSnake">;
|
|
89
|
+
/**
|
|
90
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER-DASH-CASE.
|
|
91
|
+
*
|
|
92
|
+
* @example
|
|
93
|
+
* ```ts
|
|
94
|
+
* camelToUpperDash('helloWorld'); // 'HELLO-WORLD'
|
|
95
|
+
* camelToUpperDash({ firstName: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
96
|
+
* ```
|
|
97
|
+
*/
|
|
98
|
+
export declare function camelToUpperDash<T extends object | string>(input: T): Result<T, "CamelToUpperDash">;
|
|
99
|
+
//#endregion
|
|
100
|
+
//#region src/dashCase/dashCase.d.ts
|
|
101
|
+
/**
|
|
102
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to snake_case.
|
|
103
|
+
*
|
|
104
|
+
* @example
|
|
105
|
+
* ```ts
|
|
106
|
+
* dashToSnake('hello-world'); // 'hello_world'
|
|
107
|
+
* dashToSnake({ 'first-name': 'John' }); // { first_name: 'John' }
|
|
108
|
+
* ```
|
|
109
|
+
*/
|
|
110
|
+
export declare function dashToSnake<T extends object | string>(input: T): Result<T, "DashToSnake">;
|
|
111
|
+
/**
|
|
112
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to camelCase.
|
|
113
|
+
*
|
|
114
|
+
* @example
|
|
115
|
+
* ```ts
|
|
116
|
+
* dashToCamel('hello-world'); // 'helloWorld'
|
|
117
|
+
* dashToCamel({ 'first-name': 'John' }); // { firstName: 'John' }
|
|
118
|
+
* ```
|
|
119
|
+
*/
|
|
120
|
+
export declare function dashToCamel<T extends object | string>(input: T): Result<T, "DashToCamel">;
|
|
121
|
+
/**
|
|
122
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to PascalCase.
|
|
123
|
+
*
|
|
124
|
+
* @example
|
|
125
|
+
* ```ts
|
|
126
|
+
* dashToPascal('hello-world'); // 'HelloWorld'
|
|
127
|
+
* dashToPascal({ 'first-name': 'John' }); // { FirstName: 'John' }
|
|
128
|
+
* ```
|
|
129
|
+
*/
|
|
130
|
+
export declare function dashToPascal<T extends object | string>(input: T): Result<T, "DashToPascal">;
|
|
131
|
+
/**
|
|
132
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER_SNAKE_CASE.
|
|
133
|
+
*
|
|
134
|
+
* @example
|
|
135
|
+
* ```ts
|
|
136
|
+
* dashToUpperSnake('hello-world'); // 'HELLO_WORLD'
|
|
137
|
+
* dashToUpperSnake({ 'first-name': 'John' }); // { FIRST_NAME: 'John' }
|
|
138
|
+
* ```
|
|
139
|
+
*/
|
|
140
|
+
export declare function dashToUpperSnake<T extends object | string>(input: T): Result<T, "DashToUpperSnake">;
|
|
141
|
+
/**
|
|
142
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER-DASH-CASE.
|
|
143
|
+
*
|
|
144
|
+
* @example
|
|
145
|
+
* ```ts
|
|
146
|
+
* dashToUpperDash('hello-world'); // 'HELLO-WORLD'
|
|
147
|
+
* dashToUpperDash({ 'first-name': 'John' }); // { 'FIRST-NAME': 'John' }
|
|
148
|
+
* ```
|
|
149
|
+
*/
|
|
150
|
+
export declare function dashToUpperDash<T extends object | string>(input: T): Result<T, "DashToUpperDash">;
|
|
151
|
+
//#endregion
|
|
152
|
+
//#region src/pascalCase/pascalCase.d.ts
|
|
153
|
+
/**
|
|
154
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to camelCase.
|
|
155
|
+
*
|
|
156
|
+
* @example
|
|
157
|
+
* ```ts
|
|
158
|
+
* pascalToCamel('HelloWorld'); // 'helloWorld'
|
|
159
|
+
* pascalToCamel({ FirstName: 'John' }); // { firstName: 'John' }
|
|
160
|
+
* ```
|
|
161
|
+
*/
|
|
162
|
+
export declare function pascalToCamel<T extends object | string>(input: T): Result<T, "PascalToCamel">;
|
|
163
|
+
/**
|
|
164
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to snake_case.
|
|
165
|
+
*
|
|
166
|
+
* @example
|
|
167
|
+
* ```ts
|
|
168
|
+
* pascalToSnake('HelloWorld'); // 'hello_world'
|
|
169
|
+
* pascalToSnake({ FirstName: 'John' }); // { first_name: 'John' }
|
|
170
|
+
* ```
|
|
171
|
+
*/
|
|
172
|
+
export declare function pascalToSnake<T extends object | string>(input: T): Result<T, "PascalToSnake">;
|
|
173
|
+
/**
|
|
174
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to dash-case.
|
|
175
|
+
*
|
|
176
|
+
* @example
|
|
177
|
+
* ```ts
|
|
178
|
+
* pascalToDash('HelloWorld'); // 'hello-world'
|
|
179
|
+
* pascalToDash({ FirstName: 'John' }); // { 'first-name': 'John' }
|
|
180
|
+
* ```
|
|
181
|
+
*/
|
|
182
|
+
export declare function pascalToDash<T extends object | string>(input: T): Result<T, "PascalToDash">;
|
|
183
|
+
/**
|
|
184
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER_SNAKE_CASE.
|
|
185
|
+
*
|
|
186
|
+
* @example
|
|
187
|
+
* ```ts
|
|
188
|
+
* pascalToUpperSnake('HelloWorld'); // 'HELLO_WORLD'
|
|
189
|
+
* pascalToUpperSnake({ FirstName: 'John' }); // { FIRST_NAME: 'John' }
|
|
190
|
+
* ```
|
|
191
|
+
*/
|
|
192
|
+
export declare function pascalToUpperSnake<T extends object | string>(input: T): Result<T, "PascalToUpperSnake">;
|
|
193
|
+
/**
|
|
194
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER-DASH-CASE.
|
|
195
|
+
*
|
|
196
|
+
* @example
|
|
197
|
+
* ```ts
|
|
198
|
+
* pascalToUpperDash('HelloWorld'); // 'HELLO-WORLD'
|
|
199
|
+
* pascalToUpperDash({ FirstName: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
200
|
+
* ```
|
|
201
|
+
*/
|
|
202
|
+
export declare function pascalToUpperDash<T extends object | string>(input: T): Result<T, "PascalToUpperDash">;
|
|
203
|
+
//#endregion
|
|
204
|
+
//#region src/snakeCase/snakeCase.d.ts
|
|
205
|
+
/**
|
|
206
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to camelCase.
|
|
207
|
+
*
|
|
208
|
+
* @example
|
|
209
|
+
* ```ts
|
|
210
|
+
* snakeToCamel('hello_world'); // 'helloWorld'
|
|
211
|
+
* snakeToCamel({ first_name: 'John' }); // { firstName: 'John' }
|
|
212
|
+
* ```
|
|
213
|
+
*/
|
|
214
|
+
export declare function snakeToCamel<T extends object | string>(input: T): Result<T, "SnakeToCamel">;
|
|
215
|
+
/**
|
|
216
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to dash-case.
|
|
217
|
+
*
|
|
218
|
+
* @example
|
|
219
|
+
* ```ts
|
|
220
|
+
* snakeToDash('hello_world'); // 'hello-world'
|
|
221
|
+
* snakeToDash({ first_name: 'John' }); // { 'first-name': 'John' }
|
|
222
|
+
* ```
|
|
223
|
+
*/
|
|
224
|
+
export declare function snakeToDash<T extends object | string>(input: T): Result<T, "SnakeToDash">;
|
|
225
|
+
/**
|
|
226
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to PascalCase.
|
|
227
|
+
*
|
|
228
|
+
* @example
|
|
229
|
+
* ```ts
|
|
230
|
+
* snakeToPascal('hello_world'); // 'HelloWorld'
|
|
231
|
+
* snakeToPascal({ first_name: 'John' }); // { FirstName: 'John' }
|
|
232
|
+
* ```
|
|
233
|
+
*/
|
|
234
|
+
export declare function snakeToPascal<T extends object | string>(input: T): Result<T, "SnakeToPascal">;
|
|
235
|
+
/**
|
|
236
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER_SNAKE_CASE.
|
|
237
|
+
*
|
|
238
|
+
* @example
|
|
239
|
+
* ```ts
|
|
240
|
+
* snakeToUpperSnake('hello_world'); // 'HELLO_WORLD'
|
|
241
|
+
* snakeToUpperSnake({ first_name: 'John' }); // { FIRST_NAME: 'John' }
|
|
242
|
+
* ```
|
|
243
|
+
*/
|
|
244
|
+
export declare function snakeToUpperSnake<T extends object | string>(input: T): Result<T, "SnakeToUpperSnake">;
|
|
245
|
+
/**
|
|
246
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER-DASH-CASE.
|
|
247
|
+
*
|
|
248
|
+
* @example
|
|
249
|
+
* ```ts
|
|
250
|
+
* snakeToUpperDash('hello_world'); // 'HELLO-WORLD'
|
|
251
|
+
* snakeToUpperDash({ first_name: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
252
|
+
* ```
|
|
253
|
+
*/
|
|
254
|
+
export declare function snakeToUpperDash<T extends object | string>(input: T): Result<T, "SnakeToUpperDash">;
|
|
255
|
+
//#endregion
|
|
256
|
+
//#region src/upperDashCase/upperDashCase.d.ts
|
|
257
|
+
/**
|
|
258
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to camelCase.
|
|
259
|
+
*
|
|
260
|
+
* @example
|
|
261
|
+
* ```ts
|
|
262
|
+
* upperDashToCamel('HELLO-WORLD'); // 'helloWorld'
|
|
263
|
+
* upperDashToCamel({ 'FIRST-NAME': 'John' }); // { firstName: 'John' }
|
|
264
|
+
* ```
|
|
265
|
+
*/
|
|
266
|
+
export declare function upperDashToCamel<T extends object | string>(input: T): Result<T, "UpperDashToCamel">;
|
|
267
|
+
/**
|
|
268
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to snake_case.
|
|
269
|
+
*
|
|
270
|
+
* @example
|
|
271
|
+
* ```ts
|
|
272
|
+
* upperDashToSnake('HELLO-WORLD'); // 'hello_world'
|
|
273
|
+
* upperDashToSnake({ 'FIRST-NAME': 'John' }); // { first_name: 'John' }
|
|
274
|
+
* ```
|
|
275
|
+
*/
|
|
276
|
+
export declare function upperDashToSnake<T extends object | string>(input: T): Result<T, "UpperDashToSnake">;
|
|
277
|
+
/**
|
|
278
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to dash-case.
|
|
279
|
+
*
|
|
280
|
+
* @example
|
|
281
|
+
* ```ts
|
|
282
|
+
* upperDashToDash('HELLO-WORLD'); // 'hello-world'
|
|
283
|
+
* upperDashToDash({ 'FIRST-NAME': 'John' }); // { 'first-name': 'John' }
|
|
284
|
+
* ```
|
|
285
|
+
*/
|
|
286
|
+
export declare function upperDashToDash<T extends object | string>(input: T): Result<T, "UpperDashToDash">;
|
|
287
|
+
/**
|
|
288
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to PascalCase.
|
|
289
|
+
*
|
|
290
|
+
* @example
|
|
291
|
+
* ```ts
|
|
292
|
+
* upperDashToPascal('HELLO-WORLD'); // 'HelloWorld'
|
|
293
|
+
* upperDashToPascal({ 'FIRST-NAME': 'John' }); // { FirstName: 'John' }
|
|
294
|
+
* ```
|
|
295
|
+
*/
|
|
296
|
+
export declare function upperDashToPascal<T extends object | string>(input: T): Result<T, "UpperDashToPascal">;
|
|
297
|
+
/**
|
|
298
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to UPPER_SNAKE_CASE.
|
|
299
|
+
*
|
|
300
|
+
* @example
|
|
301
|
+
* ```ts
|
|
302
|
+
* upperDashToUpperSnake('HELLO-WORLD'); // 'HELLO_WORLD'
|
|
303
|
+
* upperDashToUpperSnake({ 'FIRST-NAME': 'John' }); // { FIRST_NAME: 'John' }
|
|
304
|
+
* ```
|
|
305
|
+
*/
|
|
306
|
+
export declare function upperDashToUpperSnake<T extends object | string>(input: T): Result<T, "UpperDashToUpperSnake">;
|
|
307
|
+
//#endregion
|
|
308
|
+
//#region src/upperSnakeCase/upperSnakeCase.d.ts
|
|
309
|
+
/**
|
|
310
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to camelCase.
|
|
311
|
+
*
|
|
312
|
+
* @example
|
|
313
|
+
* ```ts
|
|
314
|
+
* upperSnakeToCamel('HELLO_WORLD'); // 'helloWorld'
|
|
315
|
+
* upperSnakeToCamel({ FIRST_NAME: 'John' }); // { firstName: 'John' }
|
|
316
|
+
* ```
|
|
317
|
+
*/
|
|
318
|
+
export declare function upperSnakeToCamel<T extends object | string>(input: T): Result<T, "UpperSnakeToCamel">;
|
|
319
|
+
/**
|
|
320
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to snake_case.
|
|
321
|
+
*
|
|
322
|
+
* @example
|
|
323
|
+
* ```ts
|
|
324
|
+
* upperSnakeToSnake('HELLO_WORLD'); // 'hello_world'
|
|
325
|
+
* upperSnakeToSnake({ FIRST_NAME: 'John' }); // { first_name: 'John' }
|
|
326
|
+
* ```
|
|
327
|
+
*/
|
|
328
|
+
export declare function upperSnakeToSnake<T extends object | string>(input: T): Result<T, "UpperSnakeToSnake">;
|
|
329
|
+
/**
|
|
330
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to dash-case.
|
|
331
|
+
*
|
|
332
|
+
* @example
|
|
333
|
+
* ```ts
|
|
334
|
+
* upperSnakeToDash('HELLO_WORLD'); // 'hello-world'
|
|
335
|
+
* upperSnakeToDash({ FIRST_NAME: 'John' }); // { 'first-name': 'John' }
|
|
336
|
+
* ```
|
|
337
|
+
*/
|
|
338
|
+
export declare function upperSnakeToDash<T extends object | string>(input: T): Result<T, "UpperSnakeToDash">;
|
|
339
|
+
/**
|
|
340
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to PascalCase.
|
|
341
|
+
*
|
|
342
|
+
* @example
|
|
343
|
+
* ```ts
|
|
344
|
+
* upperSnakeToPascal('HELLO_WORLD'); // 'HelloWorld'
|
|
345
|
+
* upperSnakeToPascal({ FIRST_NAME: 'John' }); // { FirstName: 'John' }
|
|
346
|
+
* ```
|
|
347
|
+
*/
|
|
348
|
+
export declare function upperSnakeToPascal<T extends object | string>(input: T): Result<T, "UpperSnakeToPascal">;
|
|
349
|
+
/**
|
|
350
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to UPPER-DASH-CASE.
|
|
351
|
+
*
|
|
352
|
+
* @example
|
|
353
|
+
* ```ts
|
|
354
|
+
* upperSnakeToUpperDash('HELLO_WORLD'); // 'HELLO-WORLD'
|
|
355
|
+
* upperSnakeToUpperDash({ FIRST_NAME: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
356
|
+
* ```
|
|
357
|
+
*/
|
|
358
|
+
export declare function upperSnakeToUpperDash<T extends object | string>(input: T): Result<T, "UpperSnakeToUpperDash">;
|
|
359
|
+
//#endregion
|
|
360
|
+
export type { ParserType, Prettify, Result };
|