caseparser 3.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 +110 -135
- package/dist/index.cjs +924 -0
- package/dist/index.d.cts +652 -0
- package/dist/index.d.ts +624 -48
- package/dist/index.js +821 -271
- package/package.json +52 -23
- package/.nvmrc +0 -1
- package/CHANGELOG.md +0 -40
- package/dist/index.mjs +0 -262
package/dist/index.d.cts
ADDED
|
@@ -0,0 +1,652 @@
|
|
|
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 CamelToTrain<T extends string> = DashToTrain<CamelToDash<T>>;
|
|
8
|
+
type CamelToDot<T extends string> = DashToDot<CamelToDash<T>>;
|
|
9
|
+
type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
|
|
10
|
+
type DashToPascal<T extends string> = Capitalize<DashToCamel<T>>;
|
|
11
|
+
type DashToSnake<T extends string> = T extends `${infer L}-${infer R}` ? `${L}_${DashToSnake<R>}` : T;
|
|
12
|
+
type DashToUpperDash<T extends string> = Uppercase<T>;
|
|
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;
|
|
16
|
+
type PascalToCamel<T extends string> = Uncapitalize<T>;
|
|
17
|
+
type PascalToDash<T extends string> = CamelToDash<Uncapitalize<T>>;
|
|
18
|
+
type PascalToSnake<T extends string> = CamelToSnake<Uncapitalize<T>>;
|
|
19
|
+
type PascalToUpperDash<T extends string> = Uppercase<PascalToDash<T>>;
|
|
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>>;
|
|
23
|
+
type SnakeToCamel<T extends string> = T extends `${infer L}_${infer R}` ? `${L}${Capitalize<SnakeToCamel<R>>}` : T;
|
|
24
|
+
type SnakeToDash<T extends string> = T extends `${infer L}_${infer R}` ? `${L}-${SnakeToDash<R>}` : T;
|
|
25
|
+
type SnakeToPascal<T extends string> = Capitalize<SnakeToCamel<T>>;
|
|
26
|
+
type SnakeToUpperDash<T extends string> = Uppercase<SnakeToDash<T>>;
|
|
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>>;
|
|
30
|
+
type UpperDashToCamel<T extends string> = DashToCamel<Lowercase<T>>;
|
|
31
|
+
type UpperDashToDash<T extends string> = Lowercase<T>;
|
|
32
|
+
type UpperDashToPascal<T extends string> = Capitalize<UpperDashToCamel<T>>;
|
|
33
|
+
type UpperDashToSnake<T extends string> = DashToSnake<UpperDashToDash<T>>;
|
|
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>>;
|
|
37
|
+
type UpperSnakeToCamel<T extends string> = SnakeToCamel<Lowercase<T>>;
|
|
38
|
+
type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
|
|
39
|
+
type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
|
|
40
|
+
type UpperSnakeToSnake<T extends string> = Lowercase<T>;
|
|
41
|
+
type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
|
|
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";
|
|
66
|
+
/** Identifies a conversion, e.g. `'CamelToSnake'`. */
|
|
67
|
+
type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType | ParserTrainType | ParserDotType;
|
|
68
|
+
/** Flattens an intersection/mapped type so editors show the resulting keys. */
|
|
69
|
+
type Prettify<T> = { [K in keyof T]: T[K]; } & {};
|
|
70
|
+
/**
|
|
71
|
+
* The type returned by a conversion: strings stay `string`, and object keys
|
|
72
|
+
* (deeply, including inside arrays) are renamed according to the conversion `P`.
|
|
73
|
+
*/
|
|
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;
|
|
75
|
+
//#endregion
|
|
76
|
+
//#region src/camelCase/camelCase.d.ts
|
|
77
|
+
/**
|
|
78
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to dash-case.
|
|
79
|
+
*
|
|
80
|
+
* @example
|
|
81
|
+
* ```ts
|
|
82
|
+
* camelToDash('helloWorld'); // 'hello-world'
|
|
83
|
+
* camelToDash({ firstName: 'John' }); // { 'first-name': 'John' }
|
|
84
|
+
* ```
|
|
85
|
+
*/
|
|
86
|
+
export declare function camelToDash<T extends object | string>(input: T): Result<T, "CamelToDash">;
|
|
87
|
+
/**
|
|
88
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to snake_case.
|
|
89
|
+
*
|
|
90
|
+
* @example
|
|
91
|
+
* ```ts
|
|
92
|
+
* camelToSnake('helloWorld'); // 'hello_world'
|
|
93
|
+
* camelToSnake({ firstName: 'John' }); // { first_name: 'John' }
|
|
94
|
+
* ```
|
|
95
|
+
*/
|
|
96
|
+
export declare function camelToSnake<T extends object | string>(input: T): Result<T, "CamelToSnake">;
|
|
97
|
+
/**
|
|
98
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to PascalCase.
|
|
99
|
+
*
|
|
100
|
+
* @example
|
|
101
|
+
* ```ts
|
|
102
|
+
* camelToPascal('helloWorld'); // 'HelloWorld'
|
|
103
|
+
* camelToPascal({ firstName: 'John' }); // { FirstName: 'John' }
|
|
104
|
+
* ```
|
|
105
|
+
*/
|
|
106
|
+
export declare function camelToPascal<T extends object | string>(input: T): Result<T, "CamelToPascal">;
|
|
107
|
+
/**
|
|
108
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER_SNAKE_CASE.
|
|
109
|
+
*
|
|
110
|
+
* @example
|
|
111
|
+
* ```ts
|
|
112
|
+
* camelToUpperSnake('helloWorld'); // 'HELLO_WORLD'
|
|
113
|
+
* camelToUpperSnake({ firstName: 'John' }); // { FIRST_NAME: 'John' }
|
|
114
|
+
* ```
|
|
115
|
+
*/
|
|
116
|
+
export declare function camelToUpperSnake<T extends object | string>(input: T): Result<T, "CamelToUpperSnake">;
|
|
117
|
+
/**
|
|
118
|
+
* Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER-DASH-CASE.
|
|
119
|
+
*
|
|
120
|
+
* @example
|
|
121
|
+
* ```ts
|
|
122
|
+
* camelToUpperDash('helloWorld'); // 'HELLO-WORLD'
|
|
123
|
+
* camelToUpperDash({ firstName: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
124
|
+
* ```
|
|
125
|
+
*/
|
|
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">;
|
|
147
|
+
//#endregion
|
|
148
|
+
//#region src/dashCase/dashCase.d.ts
|
|
149
|
+
/**
|
|
150
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to snake_case.
|
|
151
|
+
*
|
|
152
|
+
* @example
|
|
153
|
+
* ```ts
|
|
154
|
+
* dashToSnake('hello-world'); // 'hello_world'
|
|
155
|
+
* dashToSnake({ 'first-name': 'John' }); // { first_name: 'John' }
|
|
156
|
+
* ```
|
|
157
|
+
*/
|
|
158
|
+
export declare function dashToSnake<T extends object | string>(input: T): Result<T, "DashToSnake">;
|
|
159
|
+
/**
|
|
160
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to camelCase.
|
|
161
|
+
*
|
|
162
|
+
* @example
|
|
163
|
+
* ```ts
|
|
164
|
+
* dashToCamel('hello-world'); // 'helloWorld'
|
|
165
|
+
* dashToCamel({ 'first-name': 'John' }); // { firstName: 'John' }
|
|
166
|
+
* ```
|
|
167
|
+
*/
|
|
168
|
+
export declare function dashToCamel<T extends object | string>(input: T): Result<T, "DashToCamel">;
|
|
169
|
+
/**
|
|
170
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to PascalCase.
|
|
171
|
+
*
|
|
172
|
+
* @example
|
|
173
|
+
* ```ts
|
|
174
|
+
* dashToPascal('hello-world'); // 'HelloWorld'
|
|
175
|
+
* dashToPascal({ 'first-name': 'John' }); // { FirstName: 'John' }
|
|
176
|
+
* ```
|
|
177
|
+
*/
|
|
178
|
+
export declare function dashToPascal<T extends object | string>(input: T): Result<T, "DashToPascal">;
|
|
179
|
+
/**
|
|
180
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER_SNAKE_CASE.
|
|
181
|
+
*
|
|
182
|
+
* @example
|
|
183
|
+
* ```ts
|
|
184
|
+
* dashToUpperSnake('hello-world'); // 'HELLO_WORLD'
|
|
185
|
+
* dashToUpperSnake({ 'first-name': 'John' }); // { FIRST_NAME: 'John' }
|
|
186
|
+
* ```
|
|
187
|
+
*/
|
|
188
|
+
export declare function dashToUpperSnake<T extends object | string>(input: T): Result<T, "DashToUpperSnake">;
|
|
189
|
+
/**
|
|
190
|
+
* Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER-DASH-CASE.
|
|
191
|
+
*
|
|
192
|
+
* @example
|
|
193
|
+
* ```ts
|
|
194
|
+
* dashToUpperDash('hello-world'); // 'HELLO-WORLD'
|
|
195
|
+
* dashToUpperDash({ 'first-name': 'John' }); // { 'FIRST-NAME': 'John' }
|
|
196
|
+
* ```
|
|
197
|
+
*/
|
|
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">;
|
|
219
|
+
//#endregion
|
|
220
|
+
//#region src/pascalCase/pascalCase.d.ts
|
|
221
|
+
/**
|
|
222
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to camelCase.
|
|
223
|
+
*
|
|
224
|
+
* @example
|
|
225
|
+
* ```ts
|
|
226
|
+
* pascalToCamel('HelloWorld'); // 'helloWorld'
|
|
227
|
+
* pascalToCamel({ FirstName: 'John' }); // { firstName: 'John' }
|
|
228
|
+
* ```
|
|
229
|
+
*/
|
|
230
|
+
export declare function pascalToCamel<T extends object | string>(input: T): Result<T, "PascalToCamel">;
|
|
231
|
+
/**
|
|
232
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to snake_case.
|
|
233
|
+
*
|
|
234
|
+
* @example
|
|
235
|
+
* ```ts
|
|
236
|
+
* pascalToSnake('HelloWorld'); // 'hello_world'
|
|
237
|
+
* pascalToSnake({ FirstName: 'John' }); // { first_name: 'John' }
|
|
238
|
+
* ```
|
|
239
|
+
*/
|
|
240
|
+
export declare function pascalToSnake<T extends object | string>(input: T): Result<T, "PascalToSnake">;
|
|
241
|
+
/**
|
|
242
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to dash-case.
|
|
243
|
+
*
|
|
244
|
+
* @example
|
|
245
|
+
* ```ts
|
|
246
|
+
* pascalToDash('HelloWorld'); // 'hello-world'
|
|
247
|
+
* pascalToDash({ FirstName: 'John' }); // { 'first-name': 'John' }
|
|
248
|
+
* ```
|
|
249
|
+
*/
|
|
250
|
+
export declare function pascalToDash<T extends object | string>(input: T): Result<T, "PascalToDash">;
|
|
251
|
+
/**
|
|
252
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER_SNAKE_CASE.
|
|
253
|
+
*
|
|
254
|
+
* @example
|
|
255
|
+
* ```ts
|
|
256
|
+
* pascalToUpperSnake('HelloWorld'); // 'HELLO_WORLD'
|
|
257
|
+
* pascalToUpperSnake({ FirstName: 'John' }); // { FIRST_NAME: 'John' }
|
|
258
|
+
* ```
|
|
259
|
+
*/
|
|
260
|
+
export declare function pascalToUpperSnake<T extends object | string>(input: T): Result<T, "PascalToUpperSnake">;
|
|
261
|
+
/**
|
|
262
|
+
* Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER-DASH-CASE.
|
|
263
|
+
*
|
|
264
|
+
* @example
|
|
265
|
+
* ```ts
|
|
266
|
+
* pascalToUpperDash('HelloWorld'); // 'HELLO-WORLD'
|
|
267
|
+
* pascalToUpperDash({ FirstName: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
268
|
+
* ```
|
|
269
|
+
*/
|
|
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">;
|
|
291
|
+
//#endregion
|
|
292
|
+
//#region src/snakeCase/snakeCase.d.ts
|
|
293
|
+
/**
|
|
294
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to camelCase.
|
|
295
|
+
*
|
|
296
|
+
* @example
|
|
297
|
+
* ```ts
|
|
298
|
+
* snakeToCamel('hello_world'); // 'helloWorld'
|
|
299
|
+
* snakeToCamel({ first_name: 'John' }); // { firstName: 'John' }
|
|
300
|
+
* ```
|
|
301
|
+
*/
|
|
302
|
+
export declare function snakeToCamel<T extends object | string>(input: T): Result<T, "SnakeToCamel">;
|
|
303
|
+
/**
|
|
304
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to dash-case.
|
|
305
|
+
*
|
|
306
|
+
* @example
|
|
307
|
+
* ```ts
|
|
308
|
+
* snakeToDash('hello_world'); // 'hello-world'
|
|
309
|
+
* snakeToDash({ first_name: 'John' }); // { 'first-name': 'John' }
|
|
310
|
+
* ```
|
|
311
|
+
*/
|
|
312
|
+
export declare function snakeToDash<T extends object | string>(input: T): Result<T, "SnakeToDash">;
|
|
313
|
+
/**
|
|
314
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to PascalCase.
|
|
315
|
+
*
|
|
316
|
+
* @example
|
|
317
|
+
* ```ts
|
|
318
|
+
* snakeToPascal('hello_world'); // 'HelloWorld'
|
|
319
|
+
* snakeToPascal({ first_name: 'John' }); // { FirstName: 'John' }
|
|
320
|
+
* ```
|
|
321
|
+
*/
|
|
322
|
+
export declare function snakeToPascal<T extends object | string>(input: T): Result<T, "SnakeToPascal">;
|
|
323
|
+
/**
|
|
324
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER_SNAKE_CASE.
|
|
325
|
+
*
|
|
326
|
+
* @example
|
|
327
|
+
* ```ts
|
|
328
|
+
* snakeToUpperSnake('hello_world'); // 'HELLO_WORLD'
|
|
329
|
+
* snakeToUpperSnake({ first_name: 'John' }); // { FIRST_NAME: 'John' }
|
|
330
|
+
* ```
|
|
331
|
+
*/
|
|
332
|
+
export declare function snakeToUpperSnake<T extends object | string>(input: T): Result<T, "SnakeToUpperSnake">;
|
|
333
|
+
/**
|
|
334
|
+
* Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER-DASH-CASE.
|
|
335
|
+
*
|
|
336
|
+
* @example
|
|
337
|
+
* ```ts
|
|
338
|
+
* snakeToUpperDash('hello_world'); // 'HELLO-WORLD'
|
|
339
|
+
* snakeToUpperDash({ first_name: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
340
|
+
* ```
|
|
341
|
+
*/
|
|
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">;
|
|
507
|
+
//#endregion
|
|
508
|
+
//#region src/upperDashCase/upperDashCase.d.ts
|
|
509
|
+
/**
|
|
510
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to camelCase.
|
|
511
|
+
*
|
|
512
|
+
* @example
|
|
513
|
+
* ```ts
|
|
514
|
+
* upperDashToCamel('HELLO-WORLD'); // 'helloWorld'
|
|
515
|
+
* upperDashToCamel({ 'FIRST-NAME': 'John' }); // { firstName: 'John' }
|
|
516
|
+
* ```
|
|
517
|
+
*/
|
|
518
|
+
export declare function upperDashToCamel<T extends object | string>(input: T): Result<T, "UpperDashToCamel">;
|
|
519
|
+
/**
|
|
520
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to snake_case.
|
|
521
|
+
*
|
|
522
|
+
* @example
|
|
523
|
+
* ```ts
|
|
524
|
+
* upperDashToSnake('HELLO-WORLD'); // 'hello_world'
|
|
525
|
+
* upperDashToSnake({ 'FIRST-NAME': 'John' }); // { first_name: 'John' }
|
|
526
|
+
* ```
|
|
527
|
+
*/
|
|
528
|
+
export declare function upperDashToSnake<T extends object | string>(input: T): Result<T, "UpperDashToSnake">;
|
|
529
|
+
/**
|
|
530
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to dash-case.
|
|
531
|
+
*
|
|
532
|
+
* @example
|
|
533
|
+
* ```ts
|
|
534
|
+
* upperDashToDash('HELLO-WORLD'); // 'hello-world'
|
|
535
|
+
* upperDashToDash({ 'FIRST-NAME': 'John' }); // { 'first-name': 'John' }
|
|
536
|
+
* ```
|
|
537
|
+
*/
|
|
538
|
+
export declare function upperDashToDash<T extends object | string>(input: T): Result<T, "UpperDashToDash">;
|
|
539
|
+
/**
|
|
540
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to PascalCase.
|
|
541
|
+
*
|
|
542
|
+
* @example
|
|
543
|
+
* ```ts
|
|
544
|
+
* upperDashToPascal('HELLO-WORLD'); // 'HelloWorld'
|
|
545
|
+
* upperDashToPascal({ 'FIRST-NAME': 'John' }); // { FirstName: 'John' }
|
|
546
|
+
* ```
|
|
547
|
+
*/
|
|
548
|
+
export declare function upperDashToPascal<T extends object | string>(input: T): Result<T, "UpperDashToPascal">;
|
|
549
|
+
/**
|
|
550
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to UPPER_SNAKE_CASE.
|
|
551
|
+
*
|
|
552
|
+
* @example
|
|
553
|
+
* ```ts
|
|
554
|
+
* upperDashToUpperSnake('HELLO-WORLD'); // 'HELLO_WORLD'
|
|
555
|
+
* upperDashToUpperSnake({ 'FIRST-NAME': 'John' }); // { FIRST_NAME: 'John' }
|
|
556
|
+
* ```
|
|
557
|
+
*/
|
|
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">;
|
|
579
|
+
//#endregion
|
|
580
|
+
//#region src/upperSnakeCase/upperSnakeCase.d.ts
|
|
581
|
+
/**
|
|
582
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to camelCase.
|
|
583
|
+
*
|
|
584
|
+
* @example
|
|
585
|
+
* ```ts
|
|
586
|
+
* upperSnakeToCamel('HELLO_WORLD'); // 'helloWorld'
|
|
587
|
+
* upperSnakeToCamel({ FIRST_NAME: 'John' }); // { firstName: 'John' }
|
|
588
|
+
* ```
|
|
589
|
+
*/
|
|
590
|
+
export declare function upperSnakeToCamel<T extends object | string>(input: T): Result<T, "UpperSnakeToCamel">;
|
|
591
|
+
/**
|
|
592
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to snake_case.
|
|
593
|
+
*
|
|
594
|
+
* @example
|
|
595
|
+
* ```ts
|
|
596
|
+
* upperSnakeToSnake('HELLO_WORLD'); // 'hello_world'
|
|
597
|
+
* upperSnakeToSnake({ FIRST_NAME: 'John' }); // { first_name: 'John' }
|
|
598
|
+
* ```
|
|
599
|
+
*/
|
|
600
|
+
export declare function upperSnakeToSnake<T extends object | string>(input: T): Result<T, "UpperSnakeToSnake">;
|
|
601
|
+
/**
|
|
602
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to dash-case.
|
|
603
|
+
*
|
|
604
|
+
* @example
|
|
605
|
+
* ```ts
|
|
606
|
+
* upperSnakeToDash('HELLO_WORLD'); // 'hello-world'
|
|
607
|
+
* upperSnakeToDash({ FIRST_NAME: 'John' }); // { 'first-name': 'John' }
|
|
608
|
+
* ```
|
|
609
|
+
*/
|
|
610
|
+
export declare function upperSnakeToDash<T extends object | string>(input: T): Result<T, "UpperSnakeToDash">;
|
|
611
|
+
/**
|
|
612
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to PascalCase.
|
|
613
|
+
*
|
|
614
|
+
* @example
|
|
615
|
+
* ```ts
|
|
616
|
+
* upperSnakeToPascal('HELLO_WORLD'); // 'HelloWorld'
|
|
617
|
+
* upperSnakeToPascal({ FIRST_NAME: 'John' }); // { FirstName: 'John' }
|
|
618
|
+
* ```
|
|
619
|
+
*/
|
|
620
|
+
export declare function upperSnakeToPascal<T extends object | string>(input: T): Result<T, "UpperSnakeToPascal">;
|
|
621
|
+
/**
|
|
622
|
+
* Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to UPPER-DASH-CASE.
|
|
623
|
+
*
|
|
624
|
+
* @example
|
|
625
|
+
* ```ts
|
|
626
|
+
* upperSnakeToUpperDash('HELLO_WORLD'); // 'HELLO-WORLD'
|
|
627
|
+
* upperSnakeToUpperDash({ FIRST_NAME: 'John' }); // { 'FIRST-NAME': 'John' }
|
|
628
|
+
* ```
|
|
629
|
+
*/
|
|
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">;
|
|
651
|
+
//#endregion
|
|
652
|
+
export type { ParserType, Prettify, Result };
|