caseparser 4.0.0 → 4.1.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 +70 -142
- package/dist/index.cjs +395 -1
- package/dist/index.d.cts +300 -8
- package/dist/index.d.ts +300 -8
- package/dist/index.js +370 -2
- package/package.json +15 -7
package/dist/index.d.cts
CHANGED
|
@@ -4,46 +4,74 @@ type CamelToPascal<T extends string> = Capitalize<T>;
|
|
|
4
4
|
type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "_" : ""}${Lowercase<L>}${CamelToSnake<R>}` : T;
|
|
5
5
|
type CamelToUpperDash<T extends string> = Uppercase<CamelToDash<T>>;
|
|
6
6
|
type CamelToUpperSnake<T extends string> = Uppercase<CamelToSnake<T>>;
|
|
7
|
+
type CamelToTrain<T extends string> = DashToTrain<CamelToDash<T>>;
|
|
8
|
+
type CamelToDot<T extends string> = DashToDot<CamelToDash<T>>;
|
|
7
9
|
type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
|
|
8
10
|
type DashToPascal<T extends string> = Capitalize<DashToCamel<T>>;
|
|
9
11
|
type DashToSnake<T extends string> = T extends `${infer L}-${infer R}` ? `${L}_${DashToSnake<R>}` : T;
|
|
10
12
|
type DashToUpperDash<T extends string> = Uppercase<T>;
|
|
11
13
|
type DashToUpperSnake<T extends string> = Uppercase<DashToSnake<T>>;
|
|
14
|
+
type DashToTrain<T extends string> = T extends `${infer L}-${infer R}` ? `${Capitalize<L>}-${DashToTrain<R>}` : Capitalize<T>;
|
|
15
|
+
type DashToDot<T extends string> = T extends `${infer L}-${infer R}` ? `${L}.${DashToDot<R>}` : T;
|
|
12
16
|
type PascalToCamel<T extends string> = Uncapitalize<T>;
|
|
13
17
|
type PascalToDash<T extends string> = CamelToDash<Uncapitalize<T>>;
|
|
14
18
|
type PascalToSnake<T extends string> = CamelToSnake<Uncapitalize<T>>;
|
|
15
19
|
type PascalToUpperDash<T extends string> = Uppercase<PascalToDash<T>>;
|
|
16
20
|
type PascalToUpperSnake<T extends string> = Uppercase<PascalToSnake<T>>;
|
|
21
|
+
type PascalToTrain<T extends string> = DashToTrain<PascalToDash<T>>;
|
|
22
|
+
type PascalToDot<T extends string> = DashToDot<PascalToDash<T>>;
|
|
17
23
|
type SnakeToCamel<T extends string> = T extends `${infer L}_${infer R}` ? `${L}${Capitalize<SnakeToCamel<R>>}` : T;
|
|
18
24
|
type SnakeToDash<T extends string> = T extends `${infer L}_${infer R}` ? `${L}-${SnakeToDash<R>}` : T;
|
|
19
25
|
type SnakeToPascal<T extends string> = Capitalize<SnakeToCamel<T>>;
|
|
20
26
|
type SnakeToUpperDash<T extends string> = Uppercase<SnakeToDash<T>>;
|
|
21
27
|
type SnakeToUpperSnake<T extends string> = Uppercase<T>;
|
|
28
|
+
type SnakeToTrain<T extends string> = DashToTrain<SnakeToDash<T>>;
|
|
29
|
+
type SnakeToDot<T extends string> = DashToDot<SnakeToDash<T>>;
|
|
22
30
|
type UpperDashToCamel<T extends string> = DashToCamel<Lowercase<T>>;
|
|
23
31
|
type UpperDashToDash<T extends string> = Lowercase<T>;
|
|
24
32
|
type UpperDashToPascal<T extends string> = Capitalize<UpperDashToCamel<T>>;
|
|
25
33
|
type UpperDashToSnake<T extends string> = DashToSnake<UpperDashToDash<T>>;
|
|
26
34
|
type UpperDashToUpperSnake<T extends string> = Uppercase<UpperDashToSnake<T>>;
|
|
35
|
+
type UpperDashToTrain<T extends string> = DashToTrain<UpperDashToDash<T>>;
|
|
36
|
+
type UpperDashToDot<T extends string> = DashToDot<UpperDashToDash<T>>;
|
|
27
37
|
type UpperSnakeToCamel<T extends string> = SnakeToCamel<Lowercase<T>>;
|
|
28
38
|
type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
|
|
29
39
|
type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
|
|
30
40
|
type UpperSnakeToSnake<T extends string> = Lowercase<T>;
|
|
31
41
|
type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
|
|
32
|
-
type
|
|
33
|
-
type
|
|
34
|
-
type
|
|
35
|
-
type
|
|
36
|
-
type
|
|
37
|
-
type
|
|
42
|
+
type UpperSnakeToTrain<T extends string> = DashToTrain<UpperSnakeToDash<T>>;
|
|
43
|
+
type UpperSnakeToDot<T extends string> = DashToDot<UpperSnakeToDash<T>>;
|
|
44
|
+
type TrainToCamel<T extends string> = DashToCamel<TrainToDash<T>>;
|
|
45
|
+
type TrainToDash<T extends string> = Lowercase<T>;
|
|
46
|
+
type TrainToDot<T extends string> = DashToDot<TrainToDash<T>>;
|
|
47
|
+
type TrainToPascal<T extends string> = DashToPascal<TrainToDash<T>>;
|
|
48
|
+
type TrainToSnake<T extends string> = DashToSnake<TrainToDash<T>>;
|
|
49
|
+
type TrainToUpperDash<T extends string> = Uppercase<T>;
|
|
50
|
+
type TrainToUpperSnake<T extends string> = DashToUpperSnake<TrainToDash<T>>;
|
|
51
|
+
type DotToCamel<T extends string> = DashToCamel<DotToDash<T>>;
|
|
52
|
+
type DotToDash<T extends string> = T extends `${infer L}.${infer R}` ? `${L}-${DotToDash<R>}` : T;
|
|
53
|
+
type DotToPascal<T extends string> = DashToPascal<DotToDash<T>>;
|
|
54
|
+
type DotToSnake<T extends string> = DashToSnake<DotToDash<T>>;
|
|
55
|
+
type DotToTrain<T extends string> = DashToTrain<DotToDash<T>>;
|
|
56
|
+
type DotToUpperDash<T extends string> = Uppercase<DotToDash<T>>;
|
|
57
|
+
type DotToUpperSnake<T extends string> = DashToUpperSnake<DotToDash<T>>;
|
|
58
|
+
type ParserCamelType = "CamelToDash" | "CamelToPascal" | "CamelToSnake" | "CamelToUpperDash" | "CamelToUpperSnake" | "CamelToTrain" | "CamelToDot";
|
|
59
|
+
type ParserDashType = "DashToCamel" | "DashToPascal" | "DashToSnake" | "DashToUpperDash" | "DashToUpperSnake" | "DashToTrain" | "DashToDot";
|
|
60
|
+
type ParserPascalType = "PascalToCamel" | "PascalToDash" | "PascalToSnake" | "PascalToUpperDash" | "PascalToUpperSnake" | "PascalToTrain" | "PascalToDot";
|
|
61
|
+
type ParserSnakeType = "SnakeToCamel" | "SnakeToDash" | "SnakeToPascal" | "SnakeToUpperDash" | "SnakeToUpperSnake" | "SnakeToTrain" | "SnakeToDot";
|
|
62
|
+
type ParserUpperDashType = "UpperDashToCamel" | "UpperDashToDash" | "UpperDashToPascal" | "UpperDashToSnake" | "UpperDashToUpperSnake" | "UpperDashToTrain" | "UpperDashToDot";
|
|
63
|
+
type ParserUpperSnakeType = "UpperSnakeToCamel" | "UpperSnakeToDash" | "UpperSnakeToPascal" | "UpperSnakeToSnake" | "UpperSnakeToUpperDash" | "UpperSnakeToTrain" | "UpperSnakeToDot";
|
|
64
|
+
type ParserTrainType = "TrainToCamel" | "TrainToDash" | "TrainToDot" | "TrainToPascal" | "TrainToSnake" | "TrainToUpperDash" | "TrainToUpperSnake";
|
|
65
|
+
type ParserDotType = "DotToCamel" | "DotToDash" | "DotToPascal" | "DotToSnake" | "DotToTrain" | "DotToUpperDash" | "DotToUpperSnake";
|
|
38
66
|
/** Identifies a conversion, e.g. `'CamelToSnake'`. */
|
|
39
|
-
type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType;
|
|
67
|
+
type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType | ParserTrainType | ParserDotType;
|
|
40
68
|
/** Flattens an intersection/mapped type so editors show the resulting keys. */
|
|
41
69
|
type Prettify<T> = { [K in keyof T]: T[K]; } & {};
|
|
42
70
|
/**
|
|
43
71
|
* The type returned by a conversion: strings stay `string`, and object keys
|
|
44
72
|
* (deeply, including inside arrays) are renamed according to the conversion `P`.
|
|
45
73
|
*/
|
|
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;
|
|
74
|
+
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> : P extends "CamelToTrain" ? CamelToTrain<K & string> : P extends "CamelToDot" ? CamelToDot<K & string> : P extends "PascalToTrain" ? PascalToTrain<K & string> : P extends "PascalToDot" ? PascalToDot<K & string> : P extends "SnakeToTrain" ? SnakeToTrain<K & string> : P extends "SnakeToDot" ? SnakeToDot<K & string> : P extends "DashToTrain" ? DashToTrain<K & string> : P extends "DashToDot" ? DashToDot<K & string> : P extends "UpperSnakeToTrain" ? UpperSnakeToTrain<K & string> : P extends "UpperSnakeToDot" ? UpperSnakeToDot<K & string> : P extends "UpperDashToTrain" ? UpperDashToTrain<K & string> : P extends "UpperDashToDot" ? UpperDashToDot<K & string> : P extends "TrainToCamel" ? TrainToCamel<K & string> : P extends "TrainToPascal" ? TrainToPascal<K & string> : P extends "TrainToSnake" ? TrainToSnake<K & string> : P extends "TrainToDash" ? TrainToDash<K & string> : P extends "TrainToUpperSnake" ? TrainToUpperSnake<K & string> : P extends "TrainToUpperDash" ? TrainToUpperDash<K & string> : P extends "TrainToDot" ? TrainToDot<K & string> : P extends "DotToCamel" ? DotToCamel<K & string> : P extends "DotToPascal" ? DotToPascal<K & string> : P extends "DotToSnake" ? DotToSnake<K & string> : P extends "DotToDash" ? DotToDash<K & string> : P extends "DotToUpperSnake" ? DotToUpperSnake<K & string> : P extends "DotToUpperDash" ? DotToUpperDash<K & string> : P extends "DotToTrain" ? DotToTrain<K & string> : never]: Result<T[K], P>; }> : T;
|
|
47
75
|
//#endregion
|
|
48
76
|
//#region src/camelCase/camelCase.d.ts
|
|
49
77
|
/**
|
|
@@ -96,6 +124,26 @@ export declare function camelToUpperSnake<T extends object | string>(input: T):
|
|
|
96
124
|
* ```
|
|
97
125
|
*/
|
|
98
126
|
export declare function camelToUpperDash<T extends object | string>(input: T): Result<T, "CamelToUpperDash">;
|
|
127
|
+
/**
|
|
128
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to Train-Case.
|
|
129
|
+
*
|
|
130
|
+
* @example
|
|
131
|
+
* ```ts
|
|
132
|
+
* camelToTrain('helloWorld'); // 'Hello-World'
|
|
133
|
+
* camelToTrain({ firstName: 'John' }); // { 'First-Name': 'John' }
|
|
134
|
+
* ```
|
|
135
|
+
*/
|
|
136
|
+
export declare function camelToTrain<T extends object | string>(input: T): Result<T, "CamelToTrain">;
|
|
137
|
+
/**
|
|
138
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to dot.case.
|
|
139
|
+
*
|
|
140
|
+
* @example
|
|
141
|
+
* ```ts
|
|
142
|
+
* camelToDot('helloWorld'); // 'hello.world'
|
|
143
|
+
* camelToDot({ firstName: 'John' }); // { 'first.name': 'John' }
|
|
144
|
+
* ```
|
|
145
|
+
*/
|
|
146
|
+
export declare function camelToDot<T extends object | string>(input: T): Result<T, "CamelToDot">;
|
|
99
147
|
//#endregion
|
|
100
148
|
//#region src/dashCase/dashCase.d.ts
|
|
101
149
|
/**
|
|
@@ -148,6 +196,26 @@ export declare function dashToUpperSnake<T extends object | string>(input: T): R
|
|
|
148
196
|
* ```
|
|
149
197
|
*/
|
|
150
198
|
export declare function dashToUpperDash<T extends object | string>(input: T): Result<T, "DashToUpperDash">;
|
|
199
|
+
/**
|
|
200
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to Train-Case.
|
|
201
|
+
*
|
|
202
|
+
* @example
|
|
203
|
+
* ```ts
|
|
204
|
+
* dashToTrain('hello-world'); // 'Hello-World'
|
|
205
|
+
* dashToTrain({ 'first-name': 'John' }); // { 'First-Name': 'John' }
|
|
206
|
+
* ```
|
|
207
|
+
*/
|
|
208
|
+
export declare function dashToTrain<T extends object | string>(input: T): Result<T, "DashToTrain">;
|
|
209
|
+
/**
|
|
210
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to dot.case.
|
|
211
|
+
*
|
|
212
|
+
* @example
|
|
213
|
+
* ```ts
|
|
214
|
+
* dashToDot('hello-world'); // 'hello.world'
|
|
215
|
+
* dashToDot({ 'first-name': 'John' }); // { 'first.name': 'John' }
|
|
216
|
+
* ```
|
|
217
|
+
*/
|
|
218
|
+
export declare function dashToDot<T extends object | string>(input: T): Result<T, "DashToDot">;
|
|
151
219
|
//#endregion
|
|
152
220
|
//#region src/pascalCase/pascalCase.d.ts
|
|
153
221
|
/**
|
|
@@ -200,6 +268,26 @@ export declare function pascalToUpperSnake<T extends object | string>(input: T):
|
|
|
200
268
|
* ```
|
|
201
269
|
*/
|
|
202
270
|
export declare function pascalToUpperDash<T extends object | string>(input: T): Result<T, "PascalToUpperDash">;
|
|
271
|
+
/**
|
|
272
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to Train-Case.
|
|
273
|
+
*
|
|
274
|
+
* @example
|
|
275
|
+
* ```ts
|
|
276
|
+
* pascalToTrain('HelloWorld'); // 'Hello-World'
|
|
277
|
+
* pascalToTrain({ FirstName: 'John' }); // { 'First-Name': 'John' }
|
|
278
|
+
* ```
|
|
279
|
+
*/
|
|
280
|
+
export declare function pascalToTrain<T extends object | string>(input: T): Result<T, "PascalToTrain">;
|
|
281
|
+
/**
|
|
282
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to dot.case.
|
|
283
|
+
*
|
|
284
|
+
* @example
|
|
285
|
+
* ```ts
|
|
286
|
+
* pascalToDot('HelloWorld'); // 'hello.world'
|
|
287
|
+
* pascalToDot({ FirstName: 'John' }); // { 'first.name': 'John' }
|
|
288
|
+
* ```
|
|
289
|
+
*/
|
|
290
|
+
export declare function pascalToDot<T extends object | string>(input: T): Result<T, "PascalToDot">;
|
|
203
291
|
//#endregion
|
|
204
292
|
//#region src/snakeCase/snakeCase.d.ts
|
|
205
293
|
/**
|
|
@@ -252,6 +340,170 @@ export declare function snakeToUpperSnake<T extends object | string>(input: T):
|
|
|
252
340
|
* ```
|
|
253
341
|
*/
|
|
254
342
|
export declare function snakeToUpperDash<T extends object | string>(input: T): Result<T, "SnakeToUpperDash">;
|
|
343
|
+
/**
|
|
344
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to Train-Case.
|
|
345
|
+
*
|
|
346
|
+
* @example
|
|
347
|
+
* ```ts
|
|
348
|
+
* snakeToTrain('hello_world'); // 'Hello-World'
|
|
349
|
+
* snakeToTrain({ first_name: 'John' }); // { 'First-Name': 'John' }
|
|
350
|
+
* ```
|
|
351
|
+
*/
|
|
352
|
+
export declare function snakeToTrain<T extends object | string>(input: T): Result<T, "SnakeToTrain">;
|
|
353
|
+
/**
|
|
354
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to dot.case.
|
|
355
|
+
*
|
|
356
|
+
* @example
|
|
357
|
+
* ```ts
|
|
358
|
+
* snakeToDot('hello_world'); // 'hello.world'
|
|
359
|
+
* snakeToDot({ first_name: 'John' }); // { 'first.name': 'John' }
|
|
360
|
+
* ```
|
|
361
|
+
*/
|
|
362
|
+
export declare function snakeToDot<T extends object | string>(input: T): Result<T, "SnakeToDot">;
|
|
363
|
+
//#endregion
|
|
364
|
+
//#region src/trainCase/trainCase.d.ts
|
|
365
|
+
/**
|
|
366
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to camelCase.
|
|
367
|
+
*
|
|
368
|
+
* @example
|
|
369
|
+
* ```ts
|
|
370
|
+
* trainToCamel('Hello-World'); // 'helloWorld'
|
|
371
|
+
* trainToCamel({ 'First-Name': 'John' }); // { firstName: 'John' }
|
|
372
|
+
* ```
|
|
373
|
+
*/
|
|
374
|
+
export declare function trainToCamel<T extends object | string>(input: T): Result<T, "TrainToCamel">;
|
|
375
|
+
/**
|
|
376
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to PascalCase.
|
|
377
|
+
*
|
|
378
|
+
* @example
|
|
379
|
+
* ```ts
|
|
380
|
+
* trainToPascal('Hello-World'); // 'HelloWorld'
|
|
381
|
+
* trainToPascal({ 'First-Name': 'John' }); // { FirstName: 'John' }
|
|
382
|
+
* ```
|
|
383
|
+
*/
|
|
384
|
+
export declare function trainToPascal<T extends object | string>(input: T): Result<T, "TrainToPascal">;
|
|
385
|
+
/**
|
|
386
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to snake_case.
|
|
387
|
+
*
|
|
388
|
+
* @example
|
|
389
|
+
* ```ts
|
|
390
|
+
* trainToSnake('Hello-World'); // 'hello_world'
|
|
391
|
+
* trainToSnake({ 'First-Name': 'John' }); // { first_name: 'John' }
|
|
392
|
+
* ```
|
|
393
|
+
*/
|
|
394
|
+
export declare function trainToSnake<T extends object | string>(input: T): Result<T, "TrainToSnake">;
|
|
395
|
+
/**
|
|
396
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to dash-case.
|
|
397
|
+
*
|
|
398
|
+
* @example
|
|
399
|
+
* ```ts
|
|
400
|
+
* trainToDash('Hello-World'); // 'hello-world'
|
|
401
|
+
* trainToDash({ 'First-Name': 'John' }); // { 'first-name': 'John' }
|
|
402
|
+
* ```
|
|
403
|
+
*/
|
|
404
|
+
export declare function trainToDash<T extends object | string>(input: T): Result<T, "TrainToDash">;
|
|
405
|
+
/**
|
|
406
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to UPPER_SNAKE_CASE.
|
|
407
|
+
*
|
|
408
|
+
* @example
|
|
409
|
+
* ```ts
|
|
410
|
+
* trainToUpperSnake('Hello-World'); // 'HELLO_WORLD'
|
|
411
|
+
* trainToUpperSnake({ 'First-Name': 'John' }); // { FIRST_NAME: 'John' }
|
|
412
|
+
* ```
|
|
413
|
+
*/
|
|
414
|
+
export declare function trainToUpperSnake<T extends object | string>(input: T): Result<T, "TrainToUpperSnake">;
|
|
415
|
+
/**
|
|
416
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to UPPER-DASH-CASE.
|
|
417
|
+
*
|
|
418
|
+
* @example
|
|
419
|
+
* ```ts
|
|
420
|
+
* trainToUpperDash('Hello-World'); // 'HELLO-WORLD'
|
|
421
|
+
* trainToUpperDash({ 'First-Name': 'John' }); // { 'FIRST-NAME': 'John' }
|
|
422
|
+
* ```
|
|
423
|
+
*/
|
|
424
|
+
export declare function trainToUpperDash<T extends object | string>(input: T): Result<T, "TrainToUpperDash">;
|
|
425
|
+
/**
|
|
426
|
+
* Converts a string, or the keys of an object/array (deeply), from Train-Case to dot.case.
|
|
427
|
+
*
|
|
428
|
+
* @example
|
|
429
|
+
* ```ts
|
|
430
|
+
* trainToDot('Hello-World'); // 'hello.world'
|
|
431
|
+
* trainToDot({ 'First-Name': 'John' }); // { 'first.name': 'John' }
|
|
432
|
+
* ```
|
|
433
|
+
*/
|
|
434
|
+
export declare function trainToDot<T extends object | string>(input: T): Result<T, "TrainToDot">;
|
|
435
|
+
//#endregion
|
|
436
|
+
//#region src/dotCase/dotCase.d.ts
|
|
437
|
+
/**
|
|
438
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to camelCase.
|
|
439
|
+
*
|
|
440
|
+
* @example
|
|
441
|
+
* ```ts
|
|
442
|
+
* dotToCamel('hello.world'); // 'helloWorld'
|
|
443
|
+
* dotToCamel({ 'first.name': 'John' }); // { firstName: 'John' }
|
|
444
|
+
* ```
|
|
445
|
+
*/
|
|
446
|
+
export declare function dotToCamel<T extends object | string>(input: T): Result<T, "DotToCamel">;
|
|
447
|
+
/**
|
|
448
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to PascalCase.
|
|
449
|
+
*
|
|
450
|
+
* @example
|
|
451
|
+
* ```ts
|
|
452
|
+
* dotToPascal('hello.world'); // 'HelloWorld'
|
|
453
|
+
* dotToPascal({ 'first.name': 'John' }); // { FirstName: 'John' }
|
|
454
|
+
* ```
|
|
455
|
+
*/
|
|
456
|
+
export declare function dotToPascal<T extends object | string>(input: T): Result<T, "DotToPascal">;
|
|
457
|
+
/**
|
|
458
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to snake_case.
|
|
459
|
+
*
|
|
460
|
+
* @example
|
|
461
|
+
* ```ts
|
|
462
|
+
* dotToSnake('hello.world'); // 'hello_world'
|
|
463
|
+
* dotToSnake({ 'first.name': 'John' }); // { first_name: 'John' }
|
|
464
|
+
* ```
|
|
465
|
+
*/
|
|
466
|
+
export declare function dotToSnake<T extends object | string>(input: T): Result<T, "DotToSnake">;
|
|
467
|
+
/**
|
|
468
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to dash-case.
|
|
469
|
+
*
|
|
470
|
+
* @example
|
|
471
|
+
* ```ts
|
|
472
|
+
* dotToDash('hello.world'); // 'hello-world'
|
|
473
|
+
* dotToDash({ 'first.name': 'John' }); // { 'first-name': 'John' }
|
|
474
|
+
* ```
|
|
475
|
+
*/
|
|
476
|
+
export declare function dotToDash<T extends object | string>(input: T): Result<T, "DotToDash">;
|
|
477
|
+
/**
|
|
478
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to UPPER_SNAKE_CASE.
|
|
479
|
+
*
|
|
480
|
+
* @example
|
|
481
|
+
* ```ts
|
|
482
|
+
* dotToUpperSnake('hello.world'); // 'HELLO_WORLD'
|
|
483
|
+
* dotToUpperSnake({ 'first.name': 'John' }); // { FIRST_NAME: 'John' }
|
|
484
|
+
* ```
|
|
485
|
+
*/
|
|
486
|
+
export declare function dotToUpperSnake<T extends object | string>(input: T): Result<T, "DotToUpperSnake">;
|
|
487
|
+
/**
|
|
488
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to UPPER-DASH-CASE.
|
|
489
|
+
*
|
|
490
|
+
* @example
|
|
491
|
+
* ```ts
|
|
492
|
+
* dotToUpperDash('hello.world'); // 'HELLO-WORLD'
|
|
493
|
+
* dotToUpperDash({ 'first.name': 'John' }); // { 'FIRST-NAME': 'John' }
|
|
494
|
+
* ```
|
|
495
|
+
*/
|
|
496
|
+
export declare function dotToUpperDash<T extends object | string>(input: T): Result<T, "DotToUpperDash">;
|
|
497
|
+
/**
|
|
498
|
+
* Converts a string, or the keys of an object/array (deeply), from dot.case to Train-Case.
|
|
499
|
+
*
|
|
500
|
+
* @example
|
|
501
|
+
* ```ts
|
|
502
|
+
* dotToTrain('hello.world'); // 'Hello-World'
|
|
503
|
+
* dotToTrain({ 'first.name': 'John' }); // { 'First-Name': 'John' }
|
|
504
|
+
* ```
|
|
505
|
+
*/
|
|
506
|
+
export declare function dotToTrain<T extends object | string>(input: T): Result<T, "DotToTrain">;
|
|
255
507
|
//#endregion
|
|
256
508
|
//#region src/upperDashCase/upperDashCase.d.ts
|
|
257
509
|
/**
|
|
@@ -304,6 +556,26 @@ export declare function upperDashToPascal<T extends object | string>(input: T):
|
|
|
304
556
|
* ```
|
|
305
557
|
*/
|
|
306
558
|
export declare function upperDashToUpperSnake<T extends object | string>(input: T): Result<T, "UpperDashToUpperSnake">;
|
|
559
|
+
/**
|
|
560
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to Train-Case.
|
|
561
|
+
*
|
|
562
|
+
* @example
|
|
563
|
+
* ```ts
|
|
564
|
+
* upperDashToTrain('HELLO-WORLD'); // 'Hello-World'
|
|
565
|
+
* upperDashToTrain({ 'FIRST-NAME': 'John' }); // { 'First-Name': 'John' }
|
|
566
|
+
* ```
|
|
567
|
+
*/
|
|
568
|
+
export declare function upperDashToTrain<T extends object | string>(input: T): Result<T, "UpperDashToTrain">;
|
|
569
|
+
/**
|
|
570
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to dot.case.
|
|
571
|
+
*
|
|
572
|
+
* @example
|
|
573
|
+
* ```ts
|
|
574
|
+
* upperDashToDot('HELLO-WORLD'); // 'hello.world'
|
|
575
|
+
* upperDashToDot({ 'FIRST-NAME': 'John' }); // { 'first.name': 'John' }
|
|
576
|
+
* ```
|
|
577
|
+
*/
|
|
578
|
+
export declare function upperDashToDot<T extends object | string>(input: T): Result<T, "UpperDashToDot">;
|
|
307
579
|
//#endregion
|
|
308
580
|
//#region src/upperSnakeCase/upperSnakeCase.d.ts
|
|
309
581
|
/**
|
|
@@ -356,5 +628,25 @@ export declare function upperSnakeToPascal<T extends object | string>(input: T):
|
|
|
356
628
|
* ```
|
|
357
629
|
*/
|
|
358
630
|
export declare function upperSnakeToUpperDash<T extends object | string>(input: T): Result<T, "UpperSnakeToUpperDash">;
|
|
631
|
+
/**
|
|
632
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to Train-Case.
|
|
633
|
+
*
|
|
634
|
+
* @example
|
|
635
|
+
* ```ts
|
|
636
|
+
* upperSnakeToTrain('HELLO_WORLD'); // 'Hello-World'
|
|
637
|
+
* upperSnakeToTrain({ FIRST_NAME: 'John' }); // { 'First-Name': 'John' }
|
|
638
|
+
* ```
|
|
639
|
+
*/
|
|
640
|
+
export declare function upperSnakeToTrain<T extends object | string>(input: T): Result<T, "UpperSnakeToTrain">;
|
|
641
|
+
/**
|
|
642
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to dot.case.
|
|
643
|
+
*
|
|
644
|
+
* @example
|
|
645
|
+
* ```ts
|
|
646
|
+
* upperSnakeToDot('HELLO_WORLD'); // 'hello.world'
|
|
647
|
+
* upperSnakeToDot({ FIRST_NAME: 'John' }); // { 'first.name': 'John' }
|
|
648
|
+
* ```
|
|
649
|
+
*/
|
|
650
|
+
export declare function upperSnakeToDot<T extends object | string>(input: T): Result<T, "UpperSnakeToDot">;
|
|
359
651
|
//#endregion
|
|
360
652
|
export type { ParserType, Prettify, Result };
|