caseparser 2.0.2 → 2.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/CHANGELOG.md CHANGED
@@ -1,5 +1,17 @@
1
1
  # caseparser
2
2
 
3
+ ## 2.1.0
4
+
5
+ ### Minor Changes
6
+
7
+ - c48dd7a: Adding typing inference based on parameter's type
8
+
9
+ ## 2.0.3
10
+
11
+ ### Patch Changes
12
+
13
+ - a3ebdbd: Code impovements
14
+
3
15
  ## 2.0.2
4
16
 
5
17
  ### Patch Changes
package/README.md CHANGED
@@ -1,5 +1,5 @@
1
1
  # [CaseParser 2](https://github.com/NandoMB/caseparser)
2
- Convert **Strings** and **JSON (Object Keys)** from a **case type** to another one.
2
+ Convert **Strings** and **JSON (Object Keys)** from a **case type** to another one with **type inference** based on parameter's type.
3
3
 
4
4
 
5
5
  ###### Note:
@@ -21,62 +21,8 @@ npm add caseparser
21
21
  pnpm add caseparser
22
22
  ```
23
23
 
24
- ## Conversion Types
25
-
26
- ###### camelCase to ...
27
- ```js
28
- caseparser.camelToDash(data);
29
- caseparser.camelToPascal(data);
30
- caseparser.camelToSnake(data);
31
- caseparser.camelToUpperDash(data);
32
- caseparser.camelToUpperSnake(data);
33
- ```
34
- ###### snakeCase to ...
35
- ```js
36
- caseparser.snakeToCamel(data);
37
- caseparser.snakeToDash(data);
38
- caseparser.snakeToPascal(data);
39
- caseparser.snakeToUpperDash(data);
40
- caseparser.snakeToUpperSnake(data);
41
- ```
42
- ###### dashCase to ...
43
- ```js
44
- caseparser.dashToCamel(data);
45
- caseparser.dashToPascal(data);
46
- caseparser.dashToSnake(data);
47
- caseparser.dashToUpperDash(data);
48
- caseparser.dashToUpperSnake(data);
49
- ```
50
- ###### pascalCase to ...
51
- ```js
52
- caseparser.pascalToCamel(data);
53
- caseparser.pascalToDash(data);
54
- caseparser.pascalToSnake(data);
55
- caseparser.pascalToUpperDash(data);
56
- caseparser.pascalToUpperSnake(data);
57
- ```
58
- ###### upperSnakeCase to ...
59
- ```js
60
- caseparser.upperSnakeToCamel(data);
61
- caseparser.upperSnakeToDash(data);
62
- caseparser.upperSnakeToPascal(data);
63
- caseparser.upperSnakeToSnake(data);
64
- caseparser.upperSnakeToUpperDash(data);
65
- ```
66
- ###### upperDashCase to ...
67
- ```js
68
- caseparser.upperDashToCamel(data);
69
- caseparser.upperDashToDash(data);
70
- caseparser.upperDashToPascal(data);
71
- caseparser.upperDashToSnake(data);
72
- caseparser.upperDashToUpperSnake(data);
73
- ```
74
-
75
-
76
-
77
24
  ## How to use
78
25
 
79
-
80
26
  ###### Example 1
81
27
  Passing **String** as parameter:
82
28
  ```ts
@@ -85,7 +31,7 @@ import caseparser from 'caseparser';
85
31
  caseparser.camelToSnake('loremIpsumIsSimplyDummyTextOfThePrintingAndTypesettingIndustry');
86
32
  ```
87
33
  Will result:
88
- ```json
34
+ ```ts
89
35
  'lorem_ipsum_is_simply_dummy_text_of_the_printing_and_typesetting_industry'
90
36
  ```
91
37
  <br/>
@@ -141,6 +87,57 @@ Will Result:
141
87
  ]
142
88
  ```
143
89
 
90
+ ## Conversion Types
91
+
92
+ ###### camelCase to ...
93
+ ```js
94
+ caseparser.camelToDash(data);
95
+ caseparser.camelToPascal(data);
96
+ caseparser.camelToSnake(data);
97
+ caseparser.camelToUpperDash(data);
98
+ caseparser.camelToUpperSnake(data);
99
+ ```
100
+ ###### snakeCase to ...
101
+ ```js
102
+ caseparser.snakeToCamel(data);
103
+ caseparser.snakeToDash(data);
104
+ caseparser.snakeToPascal(data);
105
+ caseparser.snakeToUpperDash(data);
106
+ caseparser.snakeToUpperSnake(data);
107
+ ```
108
+ ###### dashCase to ...
109
+ ```js
110
+ caseparser.dashToCamel(data);
111
+ caseparser.dashToPascal(data);
112
+ caseparser.dashToSnake(data);
113
+ caseparser.dashToUpperDash(data);
114
+ caseparser.dashToUpperSnake(data);
115
+ ```
116
+ ###### pascalCase to ...
117
+ ```js
118
+ caseparser.pascalToCamel(data);
119
+ caseparser.pascalToDash(data);
120
+ caseparser.pascalToSnake(data);
121
+ caseparser.pascalToUpperDash(data);
122
+ caseparser.pascalToUpperSnake(data);
123
+ ```
124
+ ###### upperSnakeCase to ...
125
+ ```js
126
+ caseparser.upperSnakeToCamel(data);
127
+ caseparser.upperSnakeToDash(data);
128
+ caseparser.upperSnakeToPascal(data);
129
+ caseparser.upperSnakeToSnake(data);
130
+ caseparser.upperSnakeToUpperDash(data);
131
+ ```
132
+ ###### upperDashCase to ...
133
+ ```js
134
+ caseparser.upperDashToCamel(data);
135
+ caseparser.upperDashToDash(data);
136
+ caseparser.upperDashToPascal(data);
137
+ caseparser.upperDashToSnake(data);
138
+ caseparser.upperDashToUpperSnake(data);
139
+ ```
140
+
144
141
  ## License
145
142
  The MIT License (MIT)
146
143
 
package/dist/index.d.ts CHANGED
@@ -1,43 +1,73 @@
1
- type JsonValue = boolean | number | string | null | JsonObject | JsonArray;
2
- type JsonObject = {
3
- [key: string]: JsonValue;
4
- };
5
- type JsonArray = JsonValue[];
6
- type Json = JsonObject | JsonArray;
7
- type CaseParserInput = string | Json;
8
- type CaseParserOutput = string | Json;
1
+ type CamelToDash<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? '-' : ''}${Lowercase<L>}${CamelToDash<R>}` : T;
2
+ type CamelToPascal<T extends string> = Capitalize<T>;
3
+ type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? '_' : ''}${Lowercase<L>}${CamelToSnake<R>}` : T;
4
+ type CamelToUpperDash<T extends string> = Uppercase<CamelToDash<T>>;
5
+ type CamelToUpperSnake<T extends string> = Uppercase<CamelToSnake<T>>;
6
+ type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
7
+ type DashToPascal<T extends string> = Capitalize<DashToCamel<T>>;
8
+ type DashToSnake<T extends string> = T extends `${infer L}-${infer R}` ? `${L}_${DashToSnake<R>}` : T;
9
+ type DashToUpperDash<T extends string> = Uppercase<T>;
10
+ type DashToUpperSnake<T extends string> = Uppercase<DashToSnake<T>>;
11
+ type PascalToCamel<T extends string> = Uncapitalize<T>;
12
+ type PascalToDash<T extends string> = CamelToDash<Uncapitalize<T>>;
13
+ type PascalToSnake<T extends string> = CamelToSnake<Uncapitalize<T>>;
14
+ type PascalToUpperDash<T extends string> = Uppercase<PascalToDash<T>>;
15
+ type PascalToUpperSnake<T extends string> = Uppercase<PascalToSnake<T>>;
16
+ type SnakeToCamel<T extends string> = T extends `${infer L}_${infer R}` ? `${L}${Capitalize<SnakeToCamel<R>>}` : T;
17
+ type SnakeToDash<T extends string> = T extends `${infer L}_${infer R}` ? `${L}-${SnakeToDash<R>}` : T;
18
+ type SnakeToPascal<T extends string> = Capitalize<SnakeToCamel<T>>;
19
+ type SnakeToUpperDash<T extends string> = Uppercase<SnakeToDash<T>>;
20
+ type SnakeToUpperSnake<T extends string> = Uppercase<T>;
21
+ type UpperDashToCamel<T extends string> = DashToCamel<Lowercase<T>>;
22
+ type UpperDashToDash<T extends string> = Lowercase<T>;
23
+ type UpperDashToPascal<T extends string> = Capitalize<UpperDashToCamel<T>>;
24
+ type UpperDashToSnake<T extends string> = DashToSnake<UpperDashToDash<T>>;
25
+ type UpperDashToUpperSnake<T extends string> = Uppercase<UpperDashToSnake<T>>;
26
+ type UpperSnakeToCamel<T extends string> = SnakeToCamel<Lowercase<T>>;
27
+ type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
28
+ type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
29
+ type UpperSnakeToSnake<T extends string> = Lowercase<T>;
30
+ type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
31
+ type Prettify<T> = {
32
+ [K in keyof T]: T[K];
33
+ } & {};
34
+ type Result<T, P> = T extends string ? string : T extends Array<unknown> ? {
35
+ [K in keyof T]: Result<T[K], P>;
36
+ } : T extends object ? Prettify<{
37
+ [K in keyof T as P extends 'CamelToDash' ? CamelToDash<K & string> : P extends 'CamelToPascal' ? CamelToPascal<K & string> : P extends 'CamelToSnake' ? CamelToSnake<K & string> : P extends 'CamelToUpperDash' ? CamelToUpperDash<K & string> : P extends 'CamelToUpperSnake' ? CamelToUpperSnake<K & string> : P extends 'DashToCamel' ? DashToCamel<K & string> : P extends 'DashToPascal' ? DashToPascal<K & string> : P extends 'DashToSnake' ? DashToSnake<K & string> : P extends 'DashToUpperDash' ? DashToUpperDash<K & string> : P extends 'DashToUpperSnake' ? DashToUpperSnake<K & string> : P extends 'PascalToCamel' ? PascalToCamel<K & string> : P extends 'PascalToDash' ? PascalToDash<K & string> : P extends 'PascalToSnake' ? PascalToSnake<K & string> : P extends 'PascalToUpperDash' ? PascalToUpperDash<K & string> : P extends 'PascalToUpperSnake' ? PascalToUpperSnake<K & string> : P extends 'SnakeToCamel' ? SnakeToCamel<K & string> : P extends 'SnakeToDash' ? SnakeToDash<K & string> : P extends 'SnakeToPascal' ? SnakeToPascal<K & string> : P extends 'SnakeToUpperDash' ? SnakeToUpperDash<K & string> : P extends 'SnakeToUpperSnake' ? SnakeToUpperSnake<K & string> : P extends 'UpperDashToCamel' ? UpperDashToCamel<K & string> : P extends 'UpperDashToDash' ? UpperDashToDash<K & string> : P extends 'UpperDashToPascal' ? UpperDashToPascal<K & string> : P extends 'UpperDashToSnake' ? UpperDashToSnake<K & string> : P extends 'UpperDashToUpperSnake' ? UpperDashToUpperSnake<K & string> : P extends 'UpperSnakeToCamel' ? UpperSnakeToCamel<K & string> : P extends 'UpperSnakeToDash' ? UpperSnakeToDash<K & string> : P extends 'UpperSnakeToPascal' ? UpperSnakeToPascal<K & string> : P extends 'UpperSnakeToSnake' ? UpperSnakeToSnake<K & string> : P extends 'UpperSnakeToUpperDash' ? UpperSnakeToUpperDash<K & string> : never]: Result<T[K], P>;
38
+ }> : T;
9
39
 
10
40
  declare const _default: {
11
- upperSnakeToCamel(input: CaseParserInput): string | JsonObject | JsonArray | null;
12
- upperSnakeToSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
13
- upperSnakeToDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
14
- upperSnakeToPascal(input: CaseParserInput): string | JsonObject | JsonArray | null;
15
- upperSnakeToUpperDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
16
- upperDashToCamel(input: CaseParserInput): string | JsonObject | JsonArray | null;
17
- upperDashToSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
18
- upperDashToDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
19
- upperDashToPascal(input: CaseParserInput): string | JsonObject | JsonArray | null;
20
- upperDashToUpperSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
21
- snakeToCamel(input: CaseParserInput): string | JsonObject | JsonArray | null;
22
- snakeToDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
23
- snakeToPascal(input: CaseParserInput): string | JsonObject | JsonArray | null;
24
- snakeToUpperSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
25
- snakeToUpperDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
26
- pascalToCamel(input: CaseParserInput): string | JsonObject | JsonArray | null;
27
- pascalToSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
28
- pascalToDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
29
- pascalToUpperSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
30
- pascalToUpperDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
31
- dashToSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
32
- dashToCamel(input: CaseParserInput): string | JsonObject | JsonArray | null;
33
- dashToPascal(input: CaseParserInput): string | JsonObject | JsonArray | null;
34
- dashToUpperSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
35
- dashToUpperDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
36
- camelToDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
37
- camelToSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
38
- camelToPascal(input: CaseParserInput): string | JsonObject | JsonArray | null;
39
- camelToUpperSnake(input: CaseParserInput): string | JsonObject | JsonArray | null;
40
- camelToUpperDash(input: CaseParserInput): string | JsonObject | JsonArray | null;
41
+ upperSnakeToCamel<T extends string | object>(input: T): Result<T, "UpperSnakeToCamel">;
42
+ upperSnakeToSnake<T_1 extends string | object>(input: T_1): Result<T_1, "UpperSnakeToSnake">;
43
+ upperSnakeToDash<T_2 extends string | object>(input: T_2): Result<T_2, "UpperSnakeToDash">;
44
+ upperSnakeToPascal<T_3 extends string | object>(input: T_3): Result<T_3, "UpperSnakeToPascal">;
45
+ upperSnakeToUpperDash<T_4 extends string | object>(input: T_4): Result<T_4, "UpperSnakeToUpperDash">;
46
+ upperDashToCamel<T_5 extends string | object>(input: T_5): Result<T_5, "UpperDashToCamel">;
47
+ upperDashToSnake<T_6 extends string | object>(input: T_6): Result<T_6, "UpperDashToSnake">;
48
+ upperDashToDash<T_7 extends string | object>(input: T_7): Result<T_7, "UpperDashToDash">;
49
+ upperDashToPascal<T_8 extends string | object>(input: T_8): Result<T_8, "UpperDashToPascal">;
50
+ upperDashToUpperSnake<T_9 extends string | object>(input: T_9): Result<T_9, "UpperDashToUpperSnake">;
51
+ snakeToCamel<T_10 extends string | object>(input: T_10): Result<T_10, "SnakeToCamel">;
52
+ snakeToDash<T_11 extends string | object>(input: T_11): Result<T_11, "SnakeToDash">;
53
+ snakeToPascal<T_12 extends string | object>(input: T_12): Result<T_12, "SnakeToPascal">;
54
+ snakeToUpperSnake<T_13 extends string | object>(input: T_13): Result<T_13, "SnakeToUpperSnake">;
55
+ snakeToUpperDash<T_14 extends string | object>(input: T_14): Result<T_14, "SnakeToUpperDash">;
56
+ pascalToCamel<T_15 extends string | object>(input: T_15): Result<T_15, "PascalToCamel">;
57
+ pascalToSnake<T_16 extends string | object>(input: T_16): Result<T_16, "PascalToSnake">;
58
+ pascalToDash<T_17 extends string | object>(input: T_17): Result<T_17, "PascalToDash">;
59
+ pascalToUpperSnake<T_18 extends string | object>(input: T_18): Result<T_18, "PascalToUpperSnake">;
60
+ pascalToUpperDash<T_19 extends string | object>(input: T_19): Result<T_19, "PascalToUpperDash">;
61
+ dashToSnake<T_20 extends string | object>(input: T_20): Result<T_20, "DashToSnake">;
62
+ dashToCamel<T_21 extends string | object>(input: T_21): Result<T_21, "DashToCamel">;
63
+ dashToPascal<T_22 extends string | object>(input: T_22): Result<T_22, "DashToPascal">;
64
+ dashToUpperSnake<T_23 extends string | object>(input: T_23): Result<T_23, "DashToUpperSnake">;
65
+ dashToUpperDash<T_24 extends string | object>(input: T_24): Result<T_24, "DashToUpperDash">;
66
+ camelToDash<T_25 extends string | object>(input: T_25): Result<T_25, "CamelToDash">;
67
+ camelToSnake<T_26 extends string | object>(input: T_26): Result<T_26, "CamelToSnake">;
68
+ camelToPascal<T_27 extends string | object>(input: T_27): Result<T_27, "CamelToPascal">;
69
+ camelToUpperSnake<T_28 extends string | object>(input: T_28): Result<T_28, "CamelToUpperSnake">;
70
+ camelToUpperDash<T_29 extends string | object>(input: T_29): Result<T_29, "CamelToUpperDash">;
41
71
  };
42
72
 
43
- export { CaseParserInput, CaseParserOutput, _default as default };
73
+ export { _default as default };
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(data) {
53
- return typeof data === "string";
38
+ function isString(input) {
39
+ return typeof input === "string";
54
40
  }
55
- function isObject(data) {
56
- return Object.prototype.toString.call(data) === "[object Object]";
41
+ function isObject(input) {
42
+ return typeof input === "object" && input?.constructor === Object;
57
43
  }
58
- function isArray(data) {
59
- return Object.prototype.toString.call(data) === "[object Array]";
44
+ function isArray(input) {
45
+ return Array.isArray(input);
60
46
  }
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);
47
+ function Lowercase(str) {
48
+ return str.toLowerCase();
49
+ }
50
+ function Uppercase(str) {
51
+ return str.toUpperCase();
97
52
  }
98
- function convertJson(data, parser) {
99
- return isArray(data) ? convertJsonArray(data, parser) : convertObjectKeys(data, parser);
53
+ function Capitalize(str) {
54
+ return str.charAt(0).toUpperCase() + str.slice(1);
100
55
  }
101
- function convertJsonArray(data, parser) {
102
- return data.map((item) => isArray(item) || isObject(item) ? convertObjectKeys(item, parser) : item) || [];
56
+ function Uncapitalize(str) {
57
+ return str.charAt(0).toLowerCase() + str.slice(1);
103
58
  }
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;
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 resultObject;
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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 = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, camelCase_exports), dashCase_exports), pascalCase_exports), snakeCase_exports), upperDashCase_exports), upperSnakeCase_exports);
319
+ var src_default = {
320
+ ...camelCase_exports,
321
+ ...dashCase_exports,
322
+ ...pascalCase_exports,
323
+ ...snakeCase_exports,
324
+ ...upperDashCase_exports,
325
+ ...upperSnakeCase_exports
326
+ };
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(data) {
34
- return typeof data === "string";
18
+ function isString(input) {
19
+ return typeof input === "string";
35
20
  }
36
- function isObject(data) {
37
- return Object.prototype.toString.call(data) === "[object Object]";
21
+ function isObject(input) {
22
+ return typeof input === "object" && input?.constructor === Object;
38
23
  }
39
- function isArray(data) {
40
- return Object.prototype.toString.call(data) === "[object Array]";
24
+ function isArray(input) {
25
+ return Array.isArray(input);
41
26
  }
42
-
43
- // src/parser/parser.ts
44
- var STRING_PARSER = {
45
- camelToSnake: (str) => str.replace(/([A-Z])/g, (g) => "_" + g[0].toLowerCase()),
46
- camelToDash: (str) => str.replace(/([A-Z])/g, (g) => "-" + g[0].toLowerCase()),
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 convertJson(data, parser) {
80
- return isArray(data) ? convertJsonArray(data, parser) : convertObjectKeys(data, parser);
33
+ function Capitalize(str) {
34
+ return str.charAt(0).toUpperCase() + str.slice(1);
81
35
  }
82
- function convertJsonArray(data, parser) {
83
- return data.map((item) => isArray(item) || isObject(item) ? convertObjectKeys(item, parser) : item) || [];
36
+ function Uncapitalize(str) {
37
+ return str.charAt(0).toLowerCase() + str.slice(1);
84
38
  }
85
- function convertObjectKeys(data, parser) {
86
- const resultObject = {};
87
- for (const property in data) {
88
- const element = data[property];
89
- const key = parser(property);
90
- resultObject[key] = isArray(element) || isObject(element) ? convertJson(element, parser) : resultObject[key] = element;
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 resultObject;
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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
- if (input === null || input === void 0)
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 = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, camelCase_exports), dashCase_exports), pascalCase_exports), snakeCase_exports), upperDashCase_exports), upperSnakeCase_exports);
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
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "caseparser",
3
- "version": "2.0.2",
3
+ "version": "2.1.0",
4
4
  "description": "Convert Strings/Arrays/Objects from a type of case to another one.",
5
5
  "author": "Fernando Machado Bernardino <fernandombernardino@gmail.com>",
6
6
  "license": "MIT",