caseparser 2.0.1 → 2.0.3
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/CHANGELOG.md +12 -0
- package/README.md +26 -24
- package/dist/index.d.ts +31 -40
- package/dist/index.js +157 -218
- package/dist/index.mjs +157 -219
- package/package.json +1 -1
- package/.editorconfig +0 -12
- package/.prettierrc +0 -8
- package/playground.ts +0 -9
package/dist/index.js
CHANGED
|
@@ -2,21 +2,7 @@
|
|
|
2
2
|
var __defProp = Object.defineProperty;
|
|
3
3
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
4
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
-
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
6
5
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
7
|
-
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
8
|
-
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
9
|
-
var __spreadValues = (a, b) => {
|
|
10
|
-
for (var prop in b || (b = {}))
|
|
11
|
-
if (__hasOwnProp.call(b, prop))
|
|
12
|
-
__defNormalProp(a, prop, b[prop]);
|
|
13
|
-
if (__getOwnPropSymbols)
|
|
14
|
-
for (var prop of __getOwnPropSymbols(b)) {
|
|
15
|
-
if (__propIsEnum.call(b, prop))
|
|
16
|
-
__defNormalProp(a, prop, b[prop]);
|
|
17
|
-
}
|
|
18
|
-
return a;
|
|
19
|
-
};
|
|
20
6
|
var __export = (target, all) => {
|
|
21
7
|
for (var name in all)
|
|
22
8
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
@@ -49,103 +35,149 @@ __export(camelCase_exports, {
|
|
|
49
35
|
});
|
|
50
36
|
|
|
51
37
|
// src/utils.ts
|
|
52
|
-
function isString(
|
|
53
|
-
return typeof
|
|
38
|
+
function isString(input) {
|
|
39
|
+
return typeof input === "string";
|
|
54
40
|
}
|
|
55
|
-
function isObject(
|
|
56
|
-
return
|
|
41
|
+
function isObject(input) {
|
|
42
|
+
return typeof input === "object" && input?.constructor === Object;
|
|
57
43
|
}
|
|
58
|
-
function isArray(
|
|
59
|
-
return
|
|
44
|
+
function isArray(input) {
|
|
45
|
+
return Array.isArray(input);
|
|
60
46
|
}
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
camelToPascal: (str) => str.replace(/(^\w)/g, (g) => g[0].toUpperCase()),
|
|
67
|
-
camelToUpperSnake: (str) => str.replace(/([A-Z])/g, (g) => "_" + g[0]).toUpperCase(),
|
|
68
|
-
camelToUpperDash: (str) => str.replace(/([A-Z])/g, (g) => "-" + g[0]).toUpperCase(),
|
|
69
|
-
dashToCamel: (str) => str.replace(/(\-\w)/g, (g) => g[1].toUpperCase()),
|
|
70
|
-
dashToSnake: (str) => str.replace(/(\-)/g, "_"),
|
|
71
|
-
dashToPascal: (str) => str.replace(/(^\w)|(\-\w)/g, (g) => g[0] !== "-" ? g[0].toUpperCase() : g[1].toUpperCase()),
|
|
72
|
-
dashToUpperSnake: (str) => str.replace(/(\-)/g, (g) => "_").toUpperCase(),
|
|
73
|
-
dashToUpperDash: (str) => str.toUpperCase(),
|
|
74
|
-
pascalToCamel: (str) => str.replace(/(^[A-Z])/g, (g) => g[0].toLowerCase()),
|
|
75
|
-
pascalToSnake: (str) => str.replace(/(?=^[A-Z])|([A-Z])/g, (g) => g[0] ? "_" + g[0].toLowerCase() : "").toLowerCase(),
|
|
76
|
-
pascalToDash: (str) => str.replace(/(?=^[A-Z])|([A-Z])/g, (g) => g[0] ? "-" + g[0].toLowerCase() : "").toLowerCase(),
|
|
77
|
-
pascalToUpperSnake: (str) => str.replace(/(?=^[A-Z])|([A-Z])/g, (g) => g[0] ? "_" + g[0] : "").toUpperCase(),
|
|
78
|
-
pascalToUpperDash: (str) => str.replace(/(?=^[A-Z])|([A-Z])/g, (g) => g[0] ? "-" + g[0] : "").toUpperCase(),
|
|
79
|
-
snakeToCamel: (str) => str.replace(/(\_\w)/g, (g) => g[1].toUpperCase()),
|
|
80
|
-
snakeToDash: (str) => str.replace(/(\_)/g, "-"),
|
|
81
|
-
snakeToPascal: (str) => str.replace(/(^\w)|(\_\w)/g, (g) => g[0] !== "_" ? g[0].toUpperCase() : g[1].toUpperCase()),
|
|
82
|
-
snakeToUpperSnake: (str) => str.toUpperCase(),
|
|
83
|
-
snakeToUpperDash: (str) => str.replace(/(\_)/g, "-").toUpperCase(),
|
|
84
|
-
upperSnakeToCamel: (str) => convertStringKey(str.toLowerCase(), "snakeToCamel"),
|
|
85
|
-
upperSnakeToSnake: (str) => str.toLowerCase(),
|
|
86
|
-
upperSnakeToDash: (str) => convertStringKey(str.toLowerCase(), "snakeToDash"),
|
|
87
|
-
upperSnakeToPascal: (str) => convertStringKey(str.toLowerCase(), "snakeToPascal"),
|
|
88
|
-
upperSnakeToUpperDash: (str) => str.replace(/(\_)/g, "-"),
|
|
89
|
-
upperDashToCamel: (str) => convertStringKey(str.toLowerCase(), "dashToCamel"),
|
|
90
|
-
upperDashToSnake: (str) => convertStringKey(str.toLowerCase(), "dashToSnake"),
|
|
91
|
-
upperDashToDash: (str) => str.toLowerCase(),
|
|
92
|
-
upperDashToPascal: (str) => convertStringKey(str.toLowerCase(), "dashToPascal"),
|
|
93
|
-
upperDashToUpperSnake: (str) => str.replace(/(\-)/g, "_")
|
|
94
|
-
};
|
|
95
|
-
function convertStringKey(str, type) {
|
|
96
|
-
return STRING_PARSER[type](str);
|
|
47
|
+
function Lowercase(str) {
|
|
48
|
+
return str.toLowerCase();
|
|
49
|
+
}
|
|
50
|
+
function Uppercase(str) {
|
|
51
|
+
return str.toUpperCase();
|
|
97
52
|
}
|
|
98
|
-
function
|
|
99
|
-
return
|
|
53
|
+
function Capitalize(str) {
|
|
54
|
+
return str.charAt(0).toUpperCase() + str.slice(1);
|
|
100
55
|
}
|
|
101
|
-
function
|
|
102
|
-
return
|
|
56
|
+
function Uncapitalize(str) {
|
|
57
|
+
return str.charAt(0).toLowerCase() + str.slice(1);
|
|
103
58
|
}
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
59
|
+
|
|
60
|
+
// src/parser/stringParser.ts
|
|
61
|
+
var CamelToDash = (str) => str.replace(/([A-Z])/g, (g) => "-" + g[0].toLowerCase());
|
|
62
|
+
var CamelToPascal = (str) => Capitalize(str);
|
|
63
|
+
var CamelToSnake = (str) => str.replace(/([A-Z])/g, (g) => "_" + g[0].toLowerCase());
|
|
64
|
+
var CamelToUpperDash = (str) => Uppercase(CamelToDash(str));
|
|
65
|
+
var CamelToUpperSnake = (str) => Uppercase(CamelToSnake(str));
|
|
66
|
+
var DashToCamel = (str) => str.replace(/(\-\w)/g, (g) => g[1].toUpperCase());
|
|
67
|
+
var DashToPascal = (str) => Capitalize(DashToCamel(str));
|
|
68
|
+
var DashToSnake = (str) => str.replace(/(\-)/g, "_");
|
|
69
|
+
var DashToUpperDash = (str) => Uppercase(str);
|
|
70
|
+
var DashToUpperSnake = (str) => Uppercase(DashToSnake(str));
|
|
71
|
+
var PascalToCamel = (str) => Uncapitalize(str);
|
|
72
|
+
var PascalToDash = (str) => CamelToDash(Uncapitalize(str));
|
|
73
|
+
var PascalToSnake = (str) => CamelToSnake(Uncapitalize(str));
|
|
74
|
+
var PascalToUpperDash = (str) => Uppercase(PascalToDash(str));
|
|
75
|
+
var PascalToUpperSnake = (str) => Uppercase(PascalToSnake(str));
|
|
76
|
+
var SnakeToCamel = (str) => str.replace(/(\_\w)/g, (g) => g[1].toUpperCase());
|
|
77
|
+
var SnakeToDash = (str) => str.replace(/(\_)/g, "-");
|
|
78
|
+
var SnakeToPascal = (str) => Capitalize(SnakeToCamel(str));
|
|
79
|
+
var SnakeToUpperDash = (str) => Uppercase(SnakeToDash(str));
|
|
80
|
+
var SnakeToUpperSnake = (str) => Uppercase(str);
|
|
81
|
+
var UpperDashToCamel = (str) => DashToCamel(Lowercase(str));
|
|
82
|
+
var UpperDashToDash = (str) => Lowercase(str);
|
|
83
|
+
var UpperDashToPascal = (str) => Capitalize(UpperDashToCamel(str));
|
|
84
|
+
var UpperDashToSnake = (str) => DashToSnake(UpperDashToDash(str));
|
|
85
|
+
var UpperDashToUpperSnake = (str) => Uppercase(UpperDashToSnake(str));
|
|
86
|
+
var UpperSnakeToCamel = (str) => SnakeToCamel(Lowercase(str));
|
|
87
|
+
var UpperSnakeToDash = (str) => str.replace(/(\_)/g, "-").toLowerCase();
|
|
88
|
+
var UpperSnakeToPascal = (str) => SnakeToPascal(Lowercase(str));
|
|
89
|
+
var UpperSnakeToSnake = (str) => Lowercase(str);
|
|
90
|
+
var UpperSnakeToUpperDash = (str) => Uppercase(UpperSnakeToDash(str));
|
|
91
|
+
function parse(input, type) {
|
|
92
|
+
return {
|
|
93
|
+
CamelToDash,
|
|
94
|
+
CamelToPascal,
|
|
95
|
+
CamelToSnake,
|
|
96
|
+
CamelToUpperDash,
|
|
97
|
+
CamelToUpperSnake,
|
|
98
|
+
DashToCamel,
|
|
99
|
+
DashToSnake,
|
|
100
|
+
DashToPascal,
|
|
101
|
+
DashToUpperSnake,
|
|
102
|
+
DashToUpperDash,
|
|
103
|
+
PascalToCamel,
|
|
104
|
+
PascalToSnake,
|
|
105
|
+
PascalToDash,
|
|
106
|
+
PascalToUpperSnake,
|
|
107
|
+
PascalToUpperDash,
|
|
108
|
+
SnakeToCamel,
|
|
109
|
+
SnakeToDash,
|
|
110
|
+
SnakeToPascal,
|
|
111
|
+
SnakeToUpperSnake,
|
|
112
|
+
SnakeToUpperDash,
|
|
113
|
+
UpperSnakeToCamel,
|
|
114
|
+
UpperSnakeToSnake,
|
|
115
|
+
UpperSnakeToDash,
|
|
116
|
+
UpperSnakeToPascal,
|
|
117
|
+
UpperSnakeToUpperDash,
|
|
118
|
+
UpperDashToCamel,
|
|
119
|
+
UpperDashToSnake,
|
|
120
|
+
UpperDashToDash,
|
|
121
|
+
UpperDashToPascal,
|
|
122
|
+
UpperDashToUpperSnake
|
|
123
|
+
}[type](input);
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
// src/parser/objectParser.ts
|
|
127
|
+
function objectParser(input, type) {
|
|
128
|
+
const result = {};
|
|
129
|
+
for (const property in input) {
|
|
130
|
+
const parsedKey = parse(property, type);
|
|
131
|
+
const value = input[property];
|
|
132
|
+
if (isArray(value)) {
|
|
133
|
+
result[parsedKey] = arrayParser(value, type);
|
|
134
|
+
} else if (isObject(value)) {
|
|
135
|
+
result[parsedKey] = objectParser(value, type);
|
|
136
|
+
} else {
|
|
137
|
+
result[parsedKey] = value;
|
|
138
|
+
}
|
|
110
139
|
}
|
|
111
|
-
return
|
|
140
|
+
return result;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
// src/parser/arrayParser.ts
|
|
144
|
+
function arrayParser(input, type) {
|
|
145
|
+
return input.map((item) => {
|
|
146
|
+
if (isArray(item))
|
|
147
|
+
return arrayParser(item, type);
|
|
148
|
+
if (isObject(item))
|
|
149
|
+
return objectParser(item, type);
|
|
150
|
+
return item;
|
|
151
|
+
});
|
|
152
|
+
}
|
|
153
|
+
|
|
154
|
+
// src/parser/parser.ts
|
|
155
|
+
function converter(input, type) {
|
|
156
|
+
let result;
|
|
157
|
+
if (isString(input))
|
|
158
|
+
result = parse(input, type);
|
|
159
|
+
if (isArray(input))
|
|
160
|
+
result = arrayParser(input, type);
|
|
161
|
+
if (isObject(input))
|
|
162
|
+
result = objectParser(input, type);
|
|
163
|
+
return result;
|
|
112
164
|
}
|
|
113
165
|
|
|
114
166
|
// src/camelCase/camelCase.ts
|
|
115
167
|
function camelToDash(input) {
|
|
116
|
-
|
|
117
|
-
return null;
|
|
118
|
-
if (isString(input))
|
|
119
|
-
return convertStringKey(input, "camelToDash");
|
|
120
|
-
return convertJson(input, camelToDash);
|
|
168
|
+
return converter(input, "CamelToDash");
|
|
121
169
|
}
|
|
122
170
|
function camelToSnake(input) {
|
|
123
|
-
|
|
124
|
-
return null;
|
|
125
|
-
if (isString(input))
|
|
126
|
-
return convertStringKey(input, "camelToSnake");
|
|
127
|
-
return convertJson(input, camelToSnake);
|
|
171
|
+
return converter(input, "CamelToSnake");
|
|
128
172
|
}
|
|
129
173
|
function camelToPascal(input) {
|
|
130
|
-
|
|
131
|
-
return null;
|
|
132
|
-
if (isString(input))
|
|
133
|
-
return convertStringKey(input, "camelToPascal");
|
|
134
|
-
return convertJson(input, camelToPascal);
|
|
174
|
+
return converter(input, "CamelToPascal");
|
|
135
175
|
}
|
|
136
176
|
function camelToUpperSnake(input) {
|
|
137
|
-
|
|
138
|
-
return null;
|
|
139
|
-
if (isString(input))
|
|
140
|
-
return convertStringKey(input, "camelToUpperSnake");
|
|
141
|
-
return convertJson(input, camelToUpperSnake);
|
|
177
|
+
return converter(input, "CamelToUpperSnake");
|
|
142
178
|
}
|
|
143
179
|
function camelToUpperDash(input) {
|
|
144
|
-
|
|
145
|
-
return null;
|
|
146
|
-
if (isString(input))
|
|
147
|
-
return convertStringKey(input, "camelToUpperDash");
|
|
148
|
-
return convertJson(input, camelToUpperDash);
|
|
180
|
+
return converter(input, "CamelToUpperDash");
|
|
149
181
|
}
|
|
150
182
|
|
|
151
183
|
// src/dashCase/index.ts
|
|
@@ -160,39 +192,19 @@ __export(dashCase_exports, {
|
|
|
160
192
|
|
|
161
193
|
// src/dashCase/dashCase.ts
|
|
162
194
|
function dashToSnake(input) {
|
|
163
|
-
|
|
164
|
-
return null;
|
|
165
|
-
if (isString(input))
|
|
166
|
-
return convertStringKey(input, "dashToSnake");
|
|
167
|
-
return convertJson(input, dashToSnake);
|
|
195
|
+
return converter(input, "DashToSnake");
|
|
168
196
|
}
|
|
169
197
|
function dashToCamel(input) {
|
|
170
|
-
|
|
171
|
-
return null;
|
|
172
|
-
if (isString(input))
|
|
173
|
-
return convertStringKey(input, "dashToCamel");
|
|
174
|
-
return convertJson(input, dashToCamel);
|
|
198
|
+
return converter(input, "DashToCamel");
|
|
175
199
|
}
|
|
176
200
|
function dashToPascal(input) {
|
|
177
|
-
|
|
178
|
-
return null;
|
|
179
|
-
if (isString(input))
|
|
180
|
-
return convertStringKey(input, "dashToPascal");
|
|
181
|
-
return convertJson(input, dashToPascal);
|
|
201
|
+
return converter(input, "DashToPascal");
|
|
182
202
|
}
|
|
183
203
|
function dashToUpperSnake(input) {
|
|
184
|
-
|
|
185
|
-
return null;
|
|
186
|
-
if (isString(input))
|
|
187
|
-
return convertStringKey(input, "dashToUpperSnake");
|
|
188
|
-
return convertJson(input, dashToUpperSnake);
|
|
204
|
+
return converter(input, "DashToUpperSnake");
|
|
189
205
|
}
|
|
190
206
|
function dashToUpperDash(input) {
|
|
191
|
-
|
|
192
|
-
return null;
|
|
193
|
-
if (isString(input))
|
|
194
|
-
return convertStringKey(input, "dashToUpperDash");
|
|
195
|
-
return convertJson(input, dashToUpperDash);
|
|
207
|
+
return converter(input, "DashToUpperDash");
|
|
196
208
|
}
|
|
197
209
|
|
|
198
210
|
// src/pascalCase/index.ts
|
|
@@ -207,39 +219,19 @@ __export(pascalCase_exports, {
|
|
|
207
219
|
|
|
208
220
|
// src/pascalCase/pascalCase.ts
|
|
209
221
|
function pascalToCamel(input) {
|
|
210
|
-
|
|
211
|
-
return null;
|
|
212
|
-
if (isString(input))
|
|
213
|
-
return convertStringKey(input, "pascalToCamel");
|
|
214
|
-
return convertJson(input, pascalToCamel);
|
|
222
|
+
return converter(input, "PascalToCamel");
|
|
215
223
|
}
|
|
216
224
|
function pascalToSnake(input) {
|
|
217
|
-
|
|
218
|
-
return null;
|
|
219
|
-
if (isString(input))
|
|
220
|
-
return convertStringKey(input, "pascalToSnake");
|
|
221
|
-
return convertJson(input, pascalToSnake);
|
|
225
|
+
return converter(input, "PascalToSnake");
|
|
222
226
|
}
|
|
223
227
|
function pascalToDash(input) {
|
|
224
|
-
|
|
225
|
-
return null;
|
|
226
|
-
if (isString(input))
|
|
227
|
-
return convertStringKey(input, "pascalToDash");
|
|
228
|
-
return convertJson(input, pascalToDash);
|
|
228
|
+
return converter(input, "PascalToDash");
|
|
229
229
|
}
|
|
230
230
|
function pascalToUpperSnake(input) {
|
|
231
|
-
|
|
232
|
-
return null;
|
|
233
|
-
if (isString(input))
|
|
234
|
-
return convertStringKey(input, "pascalToUpperSnake");
|
|
235
|
-
return convertJson(input, pascalToUpperSnake);
|
|
231
|
+
return converter(input, "PascalToUpperSnake");
|
|
236
232
|
}
|
|
237
233
|
function pascalToUpperDash(input) {
|
|
238
|
-
|
|
239
|
-
return null;
|
|
240
|
-
if (isString(input))
|
|
241
|
-
return convertStringKey(input, "pascalToUpperDash");
|
|
242
|
-
return convertJson(input, pascalToUpperDash);
|
|
234
|
+
return converter(input, "PascalToUpperDash");
|
|
243
235
|
}
|
|
244
236
|
|
|
245
237
|
// src/snakeCase/index.ts
|
|
@@ -254,39 +246,19 @@ __export(snakeCase_exports, {
|
|
|
254
246
|
|
|
255
247
|
// src/snakeCase/snakeCase.ts
|
|
256
248
|
function snakeToCamel(input) {
|
|
257
|
-
|
|
258
|
-
return null;
|
|
259
|
-
if (isString(input))
|
|
260
|
-
return convertStringKey(input, "snakeToCamel");
|
|
261
|
-
return convertJson(input, snakeToCamel);
|
|
249
|
+
return converter(input, "SnakeToCamel");
|
|
262
250
|
}
|
|
263
251
|
function snakeToDash(input) {
|
|
264
|
-
|
|
265
|
-
return null;
|
|
266
|
-
if (isString(input))
|
|
267
|
-
return convertStringKey(input, "snakeToDash");
|
|
268
|
-
return convertJson(input, snakeToDash);
|
|
252
|
+
return converter(input, "SnakeToDash");
|
|
269
253
|
}
|
|
270
254
|
function snakeToPascal(input) {
|
|
271
|
-
|
|
272
|
-
return null;
|
|
273
|
-
if (isString(input))
|
|
274
|
-
return convertStringKey(input, "snakeToPascal");
|
|
275
|
-
return convertJson(input, snakeToPascal);
|
|
255
|
+
return converter(input, "SnakeToPascal");
|
|
276
256
|
}
|
|
277
257
|
function snakeToUpperSnake(input) {
|
|
278
|
-
|
|
279
|
-
return null;
|
|
280
|
-
if (isString(input))
|
|
281
|
-
return convertStringKey(input, "snakeToUpperSnake");
|
|
282
|
-
return convertJson(input, snakeToUpperSnake);
|
|
258
|
+
return converter(input, "SnakeToUpperSnake");
|
|
283
259
|
}
|
|
284
260
|
function snakeToUpperDash(input) {
|
|
285
|
-
|
|
286
|
-
return null;
|
|
287
|
-
if (isString(input))
|
|
288
|
-
return convertStringKey(input, "snakeToUpperDash");
|
|
289
|
-
return convertJson(input, snakeToUpperDash);
|
|
261
|
+
return converter(input, "SnakeToUpperDash");
|
|
290
262
|
}
|
|
291
263
|
|
|
292
264
|
// src/upperDashCase/index.ts
|
|
@@ -301,39 +273,19 @@ __export(upperDashCase_exports, {
|
|
|
301
273
|
|
|
302
274
|
// src/upperDashCase/upperDashCase.ts
|
|
303
275
|
function upperDashToCamel(input) {
|
|
304
|
-
|
|
305
|
-
return null;
|
|
306
|
-
if (isString(input))
|
|
307
|
-
return convertStringKey(input, "upperDashToCamel");
|
|
308
|
-
return convertJson(input, upperDashToCamel);
|
|
276
|
+
return converter(input, "UpperDashToCamel");
|
|
309
277
|
}
|
|
310
278
|
function upperDashToSnake(input) {
|
|
311
|
-
|
|
312
|
-
return null;
|
|
313
|
-
if (isString(input))
|
|
314
|
-
return convertStringKey(input, "upperDashToSnake");
|
|
315
|
-
return convertJson(input, upperDashToSnake);
|
|
279
|
+
return converter(input, "UpperDashToSnake");
|
|
316
280
|
}
|
|
317
281
|
function upperDashToDash(input) {
|
|
318
|
-
|
|
319
|
-
return null;
|
|
320
|
-
if (isString(input))
|
|
321
|
-
return convertStringKey(input, "upperDashToDash");
|
|
322
|
-
return convertJson(input, upperDashToDash);
|
|
282
|
+
return converter(input, "UpperDashToDash");
|
|
323
283
|
}
|
|
324
284
|
function upperDashToPascal(input) {
|
|
325
|
-
|
|
326
|
-
return null;
|
|
327
|
-
if (isString(input))
|
|
328
|
-
return convertStringKey(input, "upperDashToPascal");
|
|
329
|
-
return convertJson(input, upperDashToPascal);
|
|
285
|
+
return converter(input, "UpperDashToPascal");
|
|
330
286
|
}
|
|
331
287
|
function upperDashToUpperSnake(input) {
|
|
332
|
-
|
|
333
|
-
return null;
|
|
334
|
-
if (isString(input))
|
|
335
|
-
return convertStringKey(input, "upperDashToUpperSnake");
|
|
336
|
-
return convertJson(input, upperDashToUpperSnake);
|
|
288
|
+
return converter(input, "UpperDashToUpperSnake");
|
|
337
289
|
}
|
|
338
290
|
|
|
339
291
|
// src/upperSnakeCase/index.ts
|
|
@@ -348,40 +300,27 @@ __export(upperSnakeCase_exports, {
|
|
|
348
300
|
|
|
349
301
|
// src/upperSnakeCase/upperSnakeCase.ts
|
|
350
302
|
function upperSnakeToCamel(input) {
|
|
351
|
-
|
|
352
|
-
return null;
|
|
353
|
-
if (isString(input))
|
|
354
|
-
return convertStringKey(input, "upperSnakeToCamel");
|
|
355
|
-
return convertJson(input, upperSnakeToCamel);
|
|
303
|
+
return converter(input, "UpperSnakeToCamel");
|
|
356
304
|
}
|
|
357
305
|
function upperSnakeToSnake(input) {
|
|
358
|
-
|
|
359
|
-
return null;
|
|
360
|
-
if (isString(input))
|
|
361
|
-
return convertStringKey(input, "upperSnakeToSnake");
|
|
362
|
-
return convertJson(input, upperSnakeToSnake);
|
|
306
|
+
return converter(input, "UpperSnakeToSnake");
|
|
363
307
|
}
|
|
364
308
|
function upperSnakeToDash(input) {
|
|
365
|
-
|
|
366
|
-
return null;
|
|
367
|
-
if (isString(input))
|
|
368
|
-
return convertStringKey(input, "upperSnakeToDash");
|
|
369
|
-
return convertJson(input, upperSnakeToDash);
|
|
309
|
+
return converter(input, "UpperSnakeToDash");
|
|
370
310
|
}
|
|
371
311
|
function upperSnakeToPascal(input) {
|
|
372
|
-
|
|
373
|
-
return null;
|
|
374
|
-
if (isString(input))
|
|
375
|
-
return convertStringKey(input, "upperSnakeToPascal");
|
|
376
|
-
return convertJson(input, upperSnakeToPascal);
|
|
312
|
+
return converter(input, "UpperSnakeToPascal");
|
|
377
313
|
}
|
|
378
314
|
function upperSnakeToUpperDash(input) {
|
|
379
|
-
|
|
380
|
-
return null;
|
|
381
|
-
if (isString(input))
|
|
382
|
-
return convertStringKey(input, "upperSnakeToUpperDash");
|
|
383
|
-
return convertJson(input, upperSnakeToUpperDash);
|
|
315
|
+
return converter(input, "UpperSnakeToUpperDash");
|
|
384
316
|
}
|
|
385
317
|
|
|
386
318
|
// src/index.ts
|
|
387
|
-
var src_default =
|
|
319
|
+
var src_default = {
|
|
320
|
+
...camelCase_exports,
|
|
321
|
+
...dashCase_exports,
|
|
322
|
+
...pascalCase_exports,
|
|
323
|
+
...snakeCase_exports,
|
|
324
|
+
...upperDashCase_exports,
|
|
325
|
+
...upperSnakeCase_exports
|
|
326
|
+
};
|