caseparser 1.1.0 → 2.0.1

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/dist/index.js ADDED
@@ -0,0 +1,387 @@
1
+ "use strict";
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
6
+ 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
+ var __export = (target, all) => {
21
+ for (var name in all)
22
+ __defProp(target, name, { get: all[name], enumerable: true });
23
+ };
24
+ var __copyProps = (to, from, except, desc) => {
25
+ if (from && typeof from === "object" || typeof from === "function") {
26
+ for (let key of __getOwnPropNames(from))
27
+ if (!__hasOwnProp.call(to, key) && key !== except)
28
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
29
+ }
30
+ return to;
31
+ };
32
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
33
+
34
+ // src/index.ts
35
+ var src_exports = {};
36
+ __export(src_exports, {
37
+ default: () => src_default
38
+ });
39
+ module.exports = __toCommonJS(src_exports);
40
+
41
+ // src/camelCase/index.ts
42
+ var camelCase_exports = {};
43
+ __export(camelCase_exports, {
44
+ camelToDash: () => camelToDash,
45
+ camelToPascal: () => camelToPascal,
46
+ camelToSnake: () => camelToSnake,
47
+ camelToUpperDash: () => camelToUpperDash,
48
+ camelToUpperSnake: () => camelToUpperSnake
49
+ });
50
+
51
+ // src/utils.ts
52
+ function isString(data) {
53
+ return typeof data === "string";
54
+ }
55
+ function isObject(data) {
56
+ return Object.prototype.toString.call(data) === "[object Object]";
57
+ }
58
+ function isArray(data) {
59
+ return Object.prototype.toString.call(data) === "[object Array]";
60
+ }
61
+
62
+ // src/parser/parser.ts
63
+ var STRING_PARSER = {
64
+ camelToSnake: (str) => str.replace(/([A-Z])/g, (g) => "_" + g[0].toLowerCase()),
65
+ camelToDash: (str) => str.replace(/([A-Z])/g, (g) => "-" + g[0].toLowerCase()),
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);
97
+ }
98
+ function convertJson(data, parser) {
99
+ return isArray(data) ? convertJsonArray(data, parser) : convertObjectKeys(data, parser);
100
+ }
101
+ function convertJsonArray(data, parser) {
102
+ return data.map((item) => isArray(item) || isObject(item) ? convertObjectKeys(item, parser) : item) || [];
103
+ }
104
+ function convertObjectKeys(data, parser) {
105
+ const resultObject = {};
106
+ for (const property in data) {
107
+ const element = data[property];
108
+ const key = parser(property);
109
+ resultObject[key] = isArray(element) || isObject(element) ? convertJson(element, parser) : resultObject[key] = element;
110
+ }
111
+ return resultObject;
112
+ }
113
+
114
+ // src/camelCase/camelCase.ts
115
+ function camelToDash(input) {
116
+ if (input === null || input === void 0)
117
+ return null;
118
+ if (isString(input))
119
+ return convertStringKey(input, "camelToDash");
120
+ return convertJson(input, camelToDash);
121
+ }
122
+ function camelToSnake(input) {
123
+ if (input === null || input === void 0)
124
+ return null;
125
+ if (isString(input))
126
+ return convertStringKey(input, "camelToSnake");
127
+ return convertJson(input, camelToSnake);
128
+ }
129
+ function camelToPascal(input) {
130
+ if (input === null || input === void 0)
131
+ return null;
132
+ if (isString(input))
133
+ return convertStringKey(input, "camelToPascal");
134
+ return convertJson(input, camelToPascal);
135
+ }
136
+ function camelToUpperSnake(input) {
137
+ if (input === null || input === void 0)
138
+ return null;
139
+ if (isString(input))
140
+ return convertStringKey(input, "camelToUpperSnake");
141
+ return convertJson(input, camelToUpperSnake);
142
+ }
143
+ function camelToUpperDash(input) {
144
+ if (input === null || input === void 0)
145
+ return null;
146
+ if (isString(input))
147
+ return convertStringKey(input, "camelToUpperDash");
148
+ return convertJson(input, camelToUpperDash);
149
+ }
150
+
151
+ // src/dashCase/index.ts
152
+ var dashCase_exports = {};
153
+ __export(dashCase_exports, {
154
+ dashToCamel: () => dashToCamel,
155
+ dashToPascal: () => dashToPascal,
156
+ dashToSnake: () => dashToSnake,
157
+ dashToUpperDash: () => dashToUpperDash,
158
+ dashToUpperSnake: () => dashToUpperSnake
159
+ });
160
+
161
+ // src/dashCase/dashCase.ts
162
+ function dashToSnake(input) {
163
+ if (input === null || input === void 0)
164
+ return null;
165
+ if (isString(input))
166
+ return convertStringKey(input, "dashToSnake");
167
+ return convertJson(input, dashToSnake);
168
+ }
169
+ function dashToCamel(input) {
170
+ if (input === null || input === void 0)
171
+ return null;
172
+ if (isString(input))
173
+ return convertStringKey(input, "dashToCamel");
174
+ return convertJson(input, dashToCamel);
175
+ }
176
+ function dashToPascal(input) {
177
+ if (input === null || input === void 0)
178
+ return null;
179
+ if (isString(input))
180
+ return convertStringKey(input, "dashToPascal");
181
+ return convertJson(input, dashToPascal);
182
+ }
183
+ function dashToUpperSnake(input) {
184
+ if (input === null || input === void 0)
185
+ return null;
186
+ if (isString(input))
187
+ return convertStringKey(input, "dashToUpperSnake");
188
+ return convertJson(input, dashToUpperSnake);
189
+ }
190
+ function dashToUpperDash(input) {
191
+ if (input === null || input === void 0)
192
+ return null;
193
+ if (isString(input))
194
+ return convertStringKey(input, "dashToUpperDash");
195
+ return convertJson(input, dashToUpperDash);
196
+ }
197
+
198
+ // src/pascalCase/index.ts
199
+ var pascalCase_exports = {};
200
+ __export(pascalCase_exports, {
201
+ pascalToCamel: () => pascalToCamel,
202
+ pascalToDash: () => pascalToDash,
203
+ pascalToSnake: () => pascalToSnake,
204
+ pascalToUpperDash: () => pascalToUpperDash,
205
+ pascalToUpperSnake: () => pascalToUpperSnake
206
+ });
207
+
208
+ // src/pascalCase/pascalCase.ts
209
+ function pascalToCamel(input) {
210
+ if (input === null || input === void 0)
211
+ return null;
212
+ if (isString(input))
213
+ return convertStringKey(input, "pascalToCamel");
214
+ return convertJson(input, pascalToCamel);
215
+ }
216
+ function pascalToSnake(input) {
217
+ if (input === null || input === void 0)
218
+ return null;
219
+ if (isString(input))
220
+ return convertStringKey(input, "pascalToSnake");
221
+ return convertJson(input, pascalToSnake);
222
+ }
223
+ function pascalToDash(input) {
224
+ if (input === null || input === void 0)
225
+ return null;
226
+ if (isString(input))
227
+ return convertStringKey(input, "pascalToDash");
228
+ return convertJson(input, pascalToDash);
229
+ }
230
+ function pascalToUpperSnake(input) {
231
+ if (input === null || input === void 0)
232
+ return null;
233
+ if (isString(input))
234
+ return convertStringKey(input, "pascalToUpperSnake");
235
+ return convertJson(input, pascalToUpperSnake);
236
+ }
237
+ function pascalToUpperDash(input) {
238
+ if (input === null || input === void 0)
239
+ return null;
240
+ if (isString(input))
241
+ return convertStringKey(input, "pascalToUpperDash");
242
+ return convertJson(input, pascalToUpperDash);
243
+ }
244
+
245
+ // src/snakeCase/index.ts
246
+ var snakeCase_exports = {};
247
+ __export(snakeCase_exports, {
248
+ snakeToCamel: () => snakeToCamel,
249
+ snakeToDash: () => snakeToDash,
250
+ snakeToPascal: () => snakeToPascal,
251
+ snakeToUpperDash: () => snakeToUpperDash,
252
+ snakeToUpperSnake: () => snakeToUpperSnake
253
+ });
254
+
255
+ // src/snakeCase/snakeCase.ts
256
+ function snakeToCamel(input) {
257
+ if (input === null || input === void 0)
258
+ return null;
259
+ if (isString(input))
260
+ return convertStringKey(input, "snakeToCamel");
261
+ return convertJson(input, snakeToCamel);
262
+ }
263
+ function snakeToDash(input) {
264
+ if (input === null || input === void 0)
265
+ return null;
266
+ if (isString(input))
267
+ return convertStringKey(input, "snakeToDash");
268
+ return convertJson(input, snakeToDash);
269
+ }
270
+ function snakeToPascal(input) {
271
+ if (input === null || input === void 0)
272
+ return null;
273
+ if (isString(input))
274
+ return convertStringKey(input, "snakeToPascal");
275
+ return convertJson(input, snakeToPascal);
276
+ }
277
+ function snakeToUpperSnake(input) {
278
+ if (input === null || input === void 0)
279
+ return null;
280
+ if (isString(input))
281
+ return convertStringKey(input, "snakeToUpperSnake");
282
+ return convertJson(input, snakeToUpperSnake);
283
+ }
284
+ function snakeToUpperDash(input) {
285
+ if (input === null || input === void 0)
286
+ return null;
287
+ if (isString(input))
288
+ return convertStringKey(input, "snakeToUpperDash");
289
+ return convertJson(input, snakeToUpperDash);
290
+ }
291
+
292
+ // src/upperDashCase/index.ts
293
+ var upperDashCase_exports = {};
294
+ __export(upperDashCase_exports, {
295
+ upperDashToCamel: () => upperDashToCamel,
296
+ upperDashToDash: () => upperDashToDash,
297
+ upperDashToPascal: () => upperDashToPascal,
298
+ upperDashToSnake: () => upperDashToSnake,
299
+ upperDashToUpperSnake: () => upperDashToUpperSnake
300
+ });
301
+
302
+ // src/upperDashCase/upperDashCase.ts
303
+ function upperDashToCamel(input) {
304
+ if (input === null || input === void 0)
305
+ return null;
306
+ if (isString(input))
307
+ return convertStringKey(input, "upperDashToCamel");
308
+ return convertJson(input, upperDashToCamel);
309
+ }
310
+ function upperDashToSnake(input) {
311
+ if (input === null || input === void 0)
312
+ return null;
313
+ if (isString(input))
314
+ return convertStringKey(input, "upperDashToSnake");
315
+ return convertJson(input, upperDashToSnake);
316
+ }
317
+ function upperDashToDash(input) {
318
+ if (input === null || input === void 0)
319
+ return null;
320
+ if (isString(input))
321
+ return convertStringKey(input, "upperDashToDash");
322
+ return convertJson(input, upperDashToDash);
323
+ }
324
+ function upperDashToPascal(input) {
325
+ if (input === null || input === void 0)
326
+ return null;
327
+ if (isString(input))
328
+ return convertStringKey(input, "upperDashToPascal");
329
+ return convertJson(input, upperDashToPascal);
330
+ }
331
+ function upperDashToUpperSnake(input) {
332
+ if (input === null || input === void 0)
333
+ return null;
334
+ if (isString(input))
335
+ return convertStringKey(input, "upperDashToUpperSnake");
336
+ return convertJson(input, upperDashToUpperSnake);
337
+ }
338
+
339
+ // src/upperSnakeCase/index.ts
340
+ var upperSnakeCase_exports = {};
341
+ __export(upperSnakeCase_exports, {
342
+ upperSnakeToCamel: () => upperSnakeToCamel,
343
+ upperSnakeToDash: () => upperSnakeToDash,
344
+ upperSnakeToPascal: () => upperSnakeToPascal,
345
+ upperSnakeToSnake: () => upperSnakeToSnake,
346
+ upperSnakeToUpperDash: () => upperSnakeToUpperDash
347
+ });
348
+
349
+ // src/upperSnakeCase/upperSnakeCase.ts
350
+ function upperSnakeToCamel(input) {
351
+ if (input === null || input === void 0)
352
+ return null;
353
+ if (isString(input))
354
+ return convertStringKey(input, "upperSnakeToCamel");
355
+ return convertJson(input, upperSnakeToCamel);
356
+ }
357
+ function upperSnakeToSnake(input) {
358
+ if (input === null || input === void 0)
359
+ return null;
360
+ if (isString(input))
361
+ return convertStringKey(input, "upperSnakeToSnake");
362
+ return convertJson(input, upperSnakeToSnake);
363
+ }
364
+ function upperSnakeToDash(input) {
365
+ if (input === null || input === void 0)
366
+ return null;
367
+ if (isString(input))
368
+ return convertStringKey(input, "upperSnakeToDash");
369
+ return convertJson(input, upperSnakeToDash);
370
+ }
371
+ function upperSnakeToPascal(input) {
372
+ if (input === null || input === void 0)
373
+ return null;
374
+ if (isString(input))
375
+ return convertStringKey(input, "upperSnakeToPascal");
376
+ return convertJson(input, upperSnakeToPascal);
377
+ }
378
+ function upperSnakeToUpperDash(input) {
379
+ if (input === null || input === void 0)
380
+ return null;
381
+ if (isString(input))
382
+ return convertStringKey(input, "upperSnakeToUpperDash");
383
+ return convertJson(input, upperSnakeToUpperDash);
384
+ }
385
+
386
+ // src/index.ts
387
+ var src_default = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, camelCase_exports), dashCase_exports), pascalCase_exports), snakeCase_exports), upperDashCase_exports), upperSnakeCase_exports);