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