caseparser 2.0.3 → 3.0.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 +15 -0
- package/README.md +57 -60
- package/dist/index.d.ts +75 -33
- package/dist/index.js +60 -68
- package/dist/index.mjs +30 -77
- package/package.json +1 -1
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,20 @@
|
|
|
1
1
|
# caseparser
|
|
2
2
|
|
|
3
|
+
## 3.0.0
|
|
4
|
+
|
|
5
|
+
### Major Changes
|
|
6
|
+
|
|
7
|
+
- e608e9d: \* This version enable bundlers to eliminate unused code (treeshake).
|
|
8
|
+
- Bump @babel/traverse from 7.21.4 to 7.23.2
|
|
9
|
+
- Bump postcss from 8.4.21 to 8.4.31
|
|
10
|
+
- Bump vite from 4.2.1 to 4.4.8
|
|
11
|
+
|
|
12
|
+
## 2.1.0
|
|
13
|
+
|
|
14
|
+
### Minor Changes
|
|
15
|
+
|
|
16
|
+
- c48dd7a: Adding typing inference based on parameter's type
|
|
17
|
+
|
|
3
18
|
## 2.0.3
|
|
4
19
|
|
|
5
20
|
### 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,71 +21,17 @@ 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
|
|
83
|
-
import
|
|
29
|
+
import { camelToSnake } from 'caseparser';
|
|
84
30
|
|
|
85
|
-
|
|
31
|
+
camelToSnake('loremIpsumIsSimplyDummyTextOfThePrintingAndTypesettingIndustry');
|
|
86
32
|
```
|
|
87
33
|
Will result:
|
|
88
|
-
```
|
|
34
|
+
```ts
|
|
89
35
|
'lorem_ipsum_is_simply_dummy_text_of_the_printing_and_typesetting_industry'
|
|
90
36
|
```
|
|
91
37
|
<br/>
|
|
@@ -93,7 +39,7 @@ Will result:
|
|
|
93
39
|
###### Example 2
|
|
94
40
|
Passing **JSON** as parameter:
|
|
95
41
|
```js
|
|
96
|
-
import
|
|
42
|
+
import { camelToSnake } from 'caseparser';
|
|
97
43
|
|
|
98
44
|
const data = [
|
|
99
45
|
{
|
|
@@ -115,7 +61,7 @@ const data = [
|
|
|
115
61
|
]
|
|
116
62
|
}
|
|
117
63
|
];
|
|
118
|
-
const result =
|
|
64
|
+
const result = camelToSnake(data);
|
|
119
65
|
```
|
|
120
66
|
Will Result:
|
|
121
67
|
```json
|
|
@@ -141,6 +87,57 @@ Will Result:
|
|
|
141
87
|
]
|
|
142
88
|
```
|
|
143
89
|
|
|
90
|
+
## Conversion Types
|
|
91
|
+
|
|
92
|
+
###### camelCase to ...
|
|
93
|
+
```js
|
|
94
|
+
camelToDash(data);
|
|
95
|
+
camelToPascal(data);
|
|
96
|
+
camelToSnake(data);
|
|
97
|
+
camelToUpperDash(data);
|
|
98
|
+
camelToUpperSnake(data);
|
|
99
|
+
```
|
|
100
|
+
###### snakeCase to ...
|
|
101
|
+
```js
|
|
102
|
+
snakeToCamel(data);
|
|
103
|
+
snakeToDash(data);
|
|
104
|
+
snakeToPascal(data);
|
|
105
|
+
snakeToUpperDash(data);
|
|
106
|
+
snakeToUpperSnake(data);
|
|
107
|
+
```
|
|
108
|
+
###### dashCase to ...
|
|
109
|
+
```js
|
|
110
|
+
dashToCamel(data);
|
|
111
|
+
dashToPascal(data);
|
|
112
|
+
dashToSnake(data);
|
|
113
|
+
dashToUpperDash(data);
|
|
114
|
+
dashToUpperSnake(data);
|
|
115
|
+
```
|
|
116
|
+
###### pascalCase to ...
|
|
117
|
+
```js
|
|
118
|
+
pascalToCamel(data);
|
|
119
|
+
pascalToDash(data);
|
|
120
|
+
pascalToSnake(data);
|
|
121
|
+
pascalToUpperDash(data);
|
|
122
|
+
pascalToUpperSnake(data);
|
|
123
|
+
```
|
|
124
|
+
###### upperSnakeCase to ...
|
|
125
|
+
```js
|
|
126
|
+
upperSnakeToCamel(data);
|
|
127
|
+
upperSnakeToDash(data);
|
|
128
|
+
upperSnakeToPascal(data);
|
|
129
|
+
upperSnakeToSnake(data);
|
|
130
|
+
upperSnakeToUpperDash(data);
|
|
131
|
+
```
|
|
132
|
+
###### upperDashCase to ...
|
|
133
|
+
```js
|
|
134
|
+
upperDashToCamel(data);
|
|
135
|
+
upperDashToDash(data);
|
|
136
|
+
upperDashToPascal(data);
|
|
137
|
+
upperDashToSnake(data);
|
|
138
|
+
upperDashToUpperSnake(data);
|
|
139
|
+
```
|
|
140
|
+
|
|
144
141
|
## License
|
|
145
142
|
The MIT License (MIT)
|
|
146
143
|
|
package/dist/index.d.ts
CHANGED
|
@@ -1,34 +1,76 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
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;
|
|
33
39
|
|
|
34
|
-
|
|
40
|
+
declare function camelToDash<T extends object | string>(input: T): Result<T, "CamelToDash">;
|
|
41
|
+
declare function camelToSnake<T extends object | string>(input: T): Result<T, "CamelToSnake">;
|
|
42
|
+
declare function camelToPascal<T extends object | string>(input: T): Result<T, "CamelToPascal">;
|
|
43
|
+
declare function camelToUpperSnake<T extends object | string>(input: T): Result<T, "CamelToUpperSnake">;
|
|
44
|
+
declare function camelToUpperDash<T extends object | string>(input: T): Result<T, "CamelToUpperDash">;
|
|
45
|
+
|
|
46
|
+
declare function dashToSnake<T extends object | string>(input: T): Result<T, "DashToSnake">;
|
|
47
|
+
declare function dashToCamel<T extends object | string>(input: T): Result<T, "DashToCamel">;
|
|
48
|
+
declare function dashToPascal<T extends object | string>(input: T): Result<T, "DashToPascal">;
|
|
49
|
+
declare function dashToUpperSnake<T extends object | string>(input: T): Result<T, "DashToUpperSnake">;
|
|
50
|
+
declare function dashToUpperDash<T extends object | string>(input: T): Result<T, "DashToUpperDash">;
|
|
51
|
+
|
|
52
|
+
declare function pascalToCamel<T extends object | string>(input: T): Result<T, "PascalToCamel">;
|
|
53
|
+
declare function pascalToSnake<T extends object | string>(input: T): Result<T, "PascalToSnake">;
|
|
54
|
+
declare function pascalToDash<T extends object | string>(input: T): Result<T, "PascalToDash">;
|
|
55
|
+
declare function pascalToUpperSnake<T extends object | string>(input: T): Result<T, "PascalToUpperSnake">;
|
|
56
|
+
declare function pascalToUpperDash<T extends object | string>(input: T): Result<T, "PascalToUpperDash">;
|
|
57
|
+
|
|
58
|
+
declare function snakeToCamel<T extends object | string>(input: T): Result<T, "SnakeToCamel">;
|
|
59
|
+
declare function snakeToDash<T extends object | string>(input: T): Result<T, "SnakeToDash">;
|
|
60
|
+
declare function snakeToPascal<T extends object | string>(input: T): Result<T, "SnakeToPascal">;
|
|
61
|
+
declare function snakeToUpperSnake<T extends object | string>(input: T): Result<T, "SnakeToUpperSnake">;
|
|
62
|
+
declare function snakeToUpperDash<T extends object | string>(input: T): Result<T, "SnakeToUpperDash">;
|
|
63
|
+
|
|
64
|
+
declare function upperDashToCamel<T extends object | string>(input: T): Result<T, "UpperDashToCamel">;
|
|
65
|
+
declare function upperDashToSnake<T extends object | string>(input: T): Result<T, "UpperDashToSnake">;
|
|
66
|
+
declare function upperDashToDash<T extends object | string>(input: T): Result<T, "UpperDashToDash">;
|
|
67
|
+
declare function upperDashToPascal<T extends object | string>(input: T): Result<T, "UpperDashToPascal">;
|
|
68
|
+
declare function upperDashToUpperSnake<T extends object | string>(input: T): Result<T, "UpperDashToUpperSnake">;
|
|
69
|
+
|
|
70
|
+
declare function upperSnakeToCamel<T extends object | string>(input: T): Result<T, "UpperSnakeToCamel">;
|
|
71
|
+
declare function upperSnakeToSnake<T extends object | string>(input: T): Result<T, "UpperSnakeToSnake">;
|
|
72
|
+
declare function upperSnakeToDash<T extends object | string>(input: T): Result<T, "UpperSnakeToDash">;
|
|
73
|
+
declare function upperSnakeToPascal<T extends object | string>(input: T): Result<T, "UpperSnakeToPascal">;
|
|
74
|
+
declare function upperSnakeToUpperDash<T extends object | string>(input: T): Result<T, "UpperSnakeToUpperDash">;
|
|
75
|
+
|
|
76
|
+
export { camelToDash, camelToPascal, camelToSnake, camelToUpperDash, camelToUpperSnake, dashToCamel, dashToPascal, dashToSnake, dashToUpperDash, dashToUpperSnake, pascalToCamel, pascalToDash, pascalToSnake, pascalToUpperDash, pascalToUpperSnake, snakeToCamel, snakeToDash, snakeToPascal, snakeToUpperDash, snakeToUpperSnake, upperDashToCamel, upperDashToDash, upperDashToPascal, upperDashToSnake, upperDashToUpperSnake, upperSnakeToCamel, upperSnakeToDash, upperSnakeToPascal, upperSnakeToSnake, upperSnakeToUpperDash };
|
package/dist/index.js
CHANGED
|
@@ -20,19 +20,38 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
|
|
|
20
20
|
// src/index.ts
|
|
21
21
|
var src_exports = {};
|
|
22
22
|
__export(src_exports, {
|
|
23
|
-
default: () => src_default
|
|
24
|
-
});
|
|
25
|
-
module.exports = __toCommonJS(src_exports);
|
|
26
|
-
|
|
27
|
-
// src/camelCase/index.ts
|
|
28
|
-
var camelCase_exports = {};
|
|
29
|
-
__export(camelCase_exports, {
|
|
30
23
|
camelToDash: () => camelToDash,
|
|
31
24
|
camelToPascal: () => camelToPascal,
|
|
32
25
|
camelToSnake: () => camelToSnake,
|
|
33
26
|
camelToUpperDash: () => camelToUpperDash,
|
|
34
|
-
camelToUpperSnake: () => camelToUpperSnake
|
|
27
|
+
camelToUpperSnake: () => camelToUpperSnake,
|
|
28
|
+
dashToCamel: () => dashToCamel,
|
|
29
|
+
dashToPascal: () => dashToPascal,
|
|
30
|
+
dashToSnake: () => dashToSnake,
|
|
31
|
+
dashToUpperDash: () => dashToUpperDash,
|
|
32
|
+
dashToUpperSnake: () => dashToUpperSnake,
|
|
33
|
+
pascalToCamel: () => pascalToCamel,
|
|
34
|
+
pascalToDash: () => pascalToDash,
|
|
35
|
+
pascalToSnake: () => pascalToSnake,
|
|
36
|
+
pascalToUpperDash: () => pascalToUpperDash,
|
|
37
|
+
pascalToUpperSnake: () => pascalToUpperSnake,
|
|
38
|
+
snakeToCamel: () => snakeToCamel,
|
|
39
|
+
snakeToDash: () => snakeToDash,
|
|
40
|
+
snakeToPascal: () => snakeToPascal,
|
|
41
|
+
snakeToUpperDash: () => snakeToUpperDash,
|
|
42
|
+
snakeToUpperSnake: () => snakeToUpperSnake,
|
|
43
|
+
upperDashToCamel: () => upperDashToCamel,
|
|
44
|
+
upperDashToDash: () => upperDashToDash,
|
|
45
|
+
upperDashToPascal: () => upperDashToPascal,
|
|
46
|
+
upperDashToSnake: () => upperDashToSnake,
|
|
47
|
+
upperDashToUpperSnake: () => upperDashToUpperSnake,
|
|
48
|
+
upperSnakeToCamel: () => upperSnakeToCamel,
|
|
49
|
+
upperSnakeToDash: () => upperSnakeToDash,
|
|
50
|
+
upperSnakeToPascal: () => upperSnakeToPascal,
|
|
51
|
+
upperSnakeToSnake: () => upperSnakeToSnake,
|
|
52
|
+
upperSnakeToUpperDash: () => upperSnakeToUpperDash
|
|
35
53
|
});
|
|
54
|
+
module.exports = __toCommonJS(src_exports);
|
|
36
55
|
|
|
37
56
|
// src/utils.ts
|
|
38
57
|
function isString(input) {
|
|
@@ -180,16 +199,6 @@ function camelToUpperDash(input) {
|
|
|
180
199
|
return converter(input, "CamelToUpperDash");
|
|
181
200
|
}
|
|
182
201
|
|
|
183
|
-
// src/dashCase/index.ts
|
|
184
|
-
var dashCase_exports = {};
|
|
185
|
-
__export(dashCase_exports, {
|
|
186
|
-
dashToCamel: () => dashToCamel,
|
|
187
|
-
dashToPascal: () => dashToPascal,
|
|
188
|
-
dashToSnake: () => dashToSnake,
|
|
189
|
-
dashToUpperDash: () => dashToUpperDash,
|
|
190
|
-
dashToUpperSnake: () => dashToUpperSnake
|
|
191
|
-
});
|
|
192
|
-
|
|
193
202
|
// src/dashCase/dashCase.ts
|
|
194
203
|
function dashToSnake(input) {
|
|
195
204
|
return converter(input, "DashToSnake");
|
|
@@ -207,16 +216,6 @@ function dashToUpperDash(input) {
|
|
|
207
216
|
return converter(input, "DashToUpperDash");
|
|
208
217
|
}
|
|
209
218
|
|
|
210
|
-
// src/pascalCase/index.ts
|
|
211
|
-
var pascalCase_exports = {};
|
|
212
|
-
__export(pascalCase_exports, {
|
|
213
|
-
pascalToCamel: () => pascalToCamel,
|
|
214
|
-
pascalToDash: () => pascalToDash,
|
|
215
|
-
pascalToSnake: () => pascalToSnake,
|
|
216
|
-
pascalToUpperDash: () => pascalToUpperDash,
|
|
217
|
-
pascalToUpperSnake: () => pascalToUpperSnake
|
|
218
|
-
});
|
|
219
|
-
|
|
220
219
|
// src/pascalCase/pascalCase.ts
|
|
221
220
|
function pascalToCamel(input) {
|
|
222
221
|
return converter(input, "PascalToCamel");
|
|
@@ -234,16 +233,6 @@ function pascalToUpperDash(input) {
|
|
|
234
233
|
return converter(input, "PascalToUpperDash");
|
|
235
234
|
}
|
|
236
235
|
|
|
237
|
-
// src/snakeCase/index.ts
|
|
238
|
-
var snakeCase_exports = {};
|
|
239
|
-
__export(snakeCase_exports, {
|
|
240
|
-
snakeToCamel: () => snakeToCamel,
|
|
241
|
-
snakeToDash: () => snakeToDash,
|
|
242
|
-
snakeToPascal: () => snakeToPascal,
|
|
243
|
-
snakeToUpperDash: () => snakeToUpperDash,
|
|
244
|
-
snakeToUpperSnake: () => snakeToUpperSnake
|
|
245
|
-
});
|
|
246
|
-
|
|
247
236
|
// src/snakeCase/snakeCase.ts
|
|
248
237
|
function snakeToCamel(input) {
|
|
249
238
|
return converter(input, "SnakeToCamel");
|
|
@@ -261,16 +250,6 @@ function snakeToUpperDash(input) {
|
|
|
261
250
|
return converter(input, "SnakeToUpperDash");
|
|
262
251
|
}
|
|
263
252
|
|
|
264
|
-
// src/upperDashCase/index.ts
|
|
265
|
-
var upperDashCase_exports = {};
|
|
266
|
-
__export(upperDashCase_exports, {
|
|
267
|
-
upperDashToCamel: () => upperDashToCamel,
|
|
268
|
-
upperDashToDash: () => upperDashToDash,
|
|
269
|
-
upperDashToPascal: () => upperDashToPascal,
|
|
270
|
-
upperDashToSnake: () => upperDashToSnake,
|
|
271
|
-
upperDashToUpperSnake: () => upperDashToUpperSnake
|
|
272
|
-
});
|
|
273
|
-
|
|
274
253
|
// src/upperDashCase/upperDashCase.ts
|
|
275
254
|
function upperDashToCamel(input) {
|
|
276
255
|
return converter(input, "UpperDashToCamel");
|
|
@@ -288,16 +267,6 @@ function upperDashToUpperSnake(input) {
|
|
|
288
267
|
return converter(input, "UpperDashToUpperSnake");
|
|
289
268
|
}
|
|
290
269
|
|
|
291
|
-
// src/upperSnakeCase/index.ts
|
|
292
|
-
var upperSnakeCase_exports = {};
|
|
293
|
-
__export(upperSnakeCase_exports, {
|
|
294
|
-
upperSnakeToCamel: () => upperSnakeToCamel,
|
|
295
|
-
upperSnakeToDash: () => upperSnakeToDash,
|
|
296
|
-
upperSnakeToPascal: () => upperSnakeToPascal,
|
|
297
|
-
upperSnakeToSnake: () => upperSnakeToSnake,
|
|
298
|
-
upperSnakeToUpperDash: () => upperSnakeToUpperDash
|
|
299
|
-
});
|
|
300
|
-
|
|
301
270
|
// src/upperSnakeCase/upperSnakeCase.ts
|
|
302
271
|
function upperSnakeToCamel(input) {
|
|
303
272
|
return converter(input, "UpperSnakeToCamel");
|
|
@@ -314,13 +283,36 @@ function upperSnakeToPascal(input) {
|
|
|
314
283
|
function upperSnakeToUpperDash(input) {
|
|
315
284
|
return converter(input, "UpperSnakeToUpperDash");
|
|
316
285
|
}
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
286
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
287
|
+
0 && (module.exports = {
|
|
288
|
+
camelToDash,
|
|
289
|
+
camelToPascal,
|
|
290
|
+
camelToSnake,
|
|
291
|
+
camelToUpperDash,
|
|
292
|
+
camelToUpperSnake,
|
|
293
|
+
dashToCamel,
|
|
294
|
+
dashToPascal,
|
|
295
|
+
dashToSnake,
|
|
296
|
+
dashToUpperDash,
|
|
297
|
+
dashToUpperSnake,
|
|
298
|
+
pascalToCamel,
|
|
299
|
+
pascalToDash,
|
|
300
|
+
pascalToSnake,
|
|
301
|
+
pascalToUpperDash,
|
|
302
|
+
pascalToUpperSnake,
|
|
303
|
+
snakeToCamel,
|
|
304
|
+
snakeToDash,
|
|
305
|
+
snakeToPascal,
|
|
306
|
+
snakeToUpperDash,
|
|
307
|
+
snakeToUpperSnake,
|
|
308
|
+
upperDashToCamel,
|
|
309
|
+
upperDashToDash,
|
|
310
|
+
upperDashToPascal,
|
|
311
|
+
upperDashToSnake,
|
|
312
|
+
upperDashToUpperSnake,
|
|
313
|
+
upperSnakeToCamel,
|
|
314
|
+
upperSnakeToDash,
|
|
315
|
+
upperSnakeToPascal,
|
|
316
|
+
upperSnakeToSnake,
|
|
317
|
+
upperSnakeToUpperDash
|
|
318
|
+
});
|
package/dist/index.mjs
CHANGED
|
@@ -1,19 +1,3 @@
|
|
|
1
|
-
var __defProp = Object.defineProperty;
|
|
2
|
-
var __export = (target, all) => {
|
|
3
|
-
for (var name in all)
|
|
4
|
-
__defProp(target, name, { get: all[name], enumerable: true });
|
|
5
|
-
};
|
|
6
|
-
|
|
7
|
-
// src/camelCase/index.ts
|
|
8
|
-
var camelCase_exports = {};
|
|
9
|
-
__export(camelCase_exports, {
|
|
10
|
-
camelToDash: () => camelToDash,
|
|
11
|
-
camelToPascal: () => camelToPascal,
|
|
12
|
-
camelToSnake: () => camelToSnake,
|
|
13
|
-
camelToUpperDash: () => camelToUpperDash,
|
|
14
|
-
camelToUpperSnake: () => camelToUpperSnake
|
|
15
|
-
});
|
|
16
|
-
|
|
17
1
|
// src/utils.ts
|
|
18
2
|
function isString(input) {
|
|
19
3
|
return typeof input === "string";
|
|
@@ -160,16 +144,6 @@ function camelToUpperDash(input) {
|
|
|
160
144
|
return converter(input, "CamelToUpperDash");
|
|
161
145
|
}
|
|
162
146
|
|
|
163
|
-
// src/dashCase/index.ts
|
|
164
|
-
var dashCase_exports = {};
|
|
165
|
-
__export(dashCase_exports, {
|
|
166
|
-
dashToCamel: () => dashToCamel,
|
|
167
|
-
dashToPascal: () => dashToPascal,
|
|
168
|
-
dashToSnake: () => dashToSnake,
|
|
169
|
-
dashToUpperDash: () => dashToUpperDash,
|
|
170
|
-
dashToUpperSnake: () => dashToUpperSnake
|
|
171
|
-
});
|
|
172
|
-
|
|
173
147
|
// src/dashCase/dashCase.ts
|
|
174
148
|
function dashToSnake(input) {
|
|
175
149
|
return converter(input, "DashToSnake");
|
|
@@ -187,16 +161,6 @@ function dashToUpperDash(input) {
|
|
|
187
161
|
return converter(input, "DashToUpperDash");
|
|
188
162
|
}
|
|
189
163
|
|
|
190
|
-
// src/pascalCase/index.ts
|
|
191
|
-
var pascalCase_exports = {};
|
|
192
|
-
__export(pascalCase_exports, {
|
|
193
|
-
pascalToCamel: () => pascalToCamel,
|
|
194
|
-
pascalToDash: () => pascalToDash,
|
|
195
|
-
pascalToSnake: () => pascalToSnake,
|
|
196
|
-
pascalToUpperDash: () => pascalToUpperDash,
|
|
197
|
-
pascalToUpperSnake: () => pascalToUpperSnake
|
|
198
|
-
});
|
|
199
|
-
|
|
200
164
|
// src/pascalCase/pascalCase.ts
|
|
201
165
|
function pascalToCamel(input) {
|
|
202
166
|
return converter(input, "PascalToCamel");
|
|
@@ -214,16 +178,6 @@ function pascalToUpperDash(input) {
|
|
|
214
178
|
return converter(input, "PascalToUpperDash");
|
|
215
179
|
}
|
|
216
180
|
|
|
217
|
-
// src/snakeCase/index.ts
|
|
218
|
-
var snakeCase_exports = {};
|
|
219
|
-
__export(snakeCase_exports, {
|
|
220
|
-
snakeToCamel: () => snakeToCamel,
|
|
221
|
-
snakeToDash: () => snakeToDash,
|
|
222
|
-
snakeToPascal: () => snakeToPascal,
|
|
223
|
-
snakeToUpperDash: () => snakeToUpperDash,
|
|
224
|
-
snakeToUpperSnake: () => snakeToUpperSnake
|
|
225
|
-
});
|
|
226
|
-
|
|
227
181
|
// src/snakeCase/snakeCase.ts
|
|
228
182
|
function snakeToCamel(input) {
|
|
229
183
|
return converter(input, "SnakeToCamel");
|
|
@@ -241,16 +195,6 @@ function snakeToUpperDash(input) {
|
|
|
241
195
|
return converter(input, "SnakeToUpperDash");
|
|
242
196
|
}
|
|
243
197
|
|
|
244
|
-
// src/upperDashCase/index.ts
|
|
245
|
-
var upperDashCase_exports = {};
|
|
246
|
-
__export(upperDashCase_exports, {
|
|
247
|
-
upperDashToCamel: () => upperDashToCamel,
|
|
248
|
-
upperDashToDash: () => upperDashToDash,
|
|
249
|
-
upperDashToPascal: () => upperDashToPascal,
|
|
250
|
-
upperDashToSnake: () => upperDashToSnake,
|
|
251
|
-
upperDashToUpperSnake: () => upperDashToUpperSnake
|
|
252
|
-
});
|
|
253
|
-
|
|
254
198
|
// src/upperDashCase/upperDashCase.ts
|
|
255
199
|
function upperDashToCamel(input) {
|
|
256
200
|
return converter(input, "UpperDashToCamel");
|
|
@@ -268,16 +212,6 @@ function upperDashToUpperSnake(input) {
|
|
|
268
212
|
return converter(input, "UpperDashToUpperSnake");
|
|
269
213
|
}
|
|
270
214
|
|
|
271
|
-
// src/upperSnakeCase/index.ts
|
|
272
|
-
var upperSnakeCase_exports = {};
|
|
273
|
-
__export(upperSnakeCase_exports, {
|
|
274
|
-
upperSnakeToCamel: () => upperSnakeToCamel,
|
|
275
|
-
upperSnakeToDash: () => upperSnakeToDash,
|
|
276
|
-
upperSnakeToPascal: () => upperSnakeToPascal,
|
|
277
|
-
upperSnakeToSnake: () => upperSnakeToSnake,
|
|
278
|
-
upperSnakeToUpperDash: () => upperSnakeToUpperDash
|
|
279
|
-
});
|
|
280
|
-
|
|
281
215
|
// src/upperSnakeCase/upperSnakeCase.ts
|
|
282
216
|
function upperSnakeToCamel(input) {
|
|
283
217
|
return converter(input, "UpperSnakeToCamel");
|
|
@@ -294,16 +228,35 @@ function upperSnakeToPascal(input) {
|
|
|
294
228
|
function upperSnakeToUpperDash(input) {
|
|
295
229
|
return converter(input, "UpperSnakeToUpperDash");
|
|
296
230
|
}
|
|
297
|
-
|
|
298
|
-
// src/index.ts
|
|
299
|
-
var src_default = {
|
|
300
|
-
...camelCase_exports,
|
|
301
|
-
...dashCase_exports,
|
|
302
|
-
...pascalCase_exports,
|
|
303
|
-
...snakeCase_exports,
|
|
304
|
-
...upperDashCase_exports,
|
|
305
|
-
...upperSnakeCase_exports
|
|
306
|
-
};
|
|
307
231
|
export {
|
|
308
|
-
|
|
232
|
+
camelToDash,
|
|
233
|
+
camelToPascal,
|
|
234
|
+
camelToSnake,
|
|
235
|
+
camelToUpperDash,
|
|
236
|
+
camelToUpperSnake,
|
|
237
|
+
dashToCamel,
|
|
238
|
+
dashToPascal,
|
|
239
|
+
dashToSnake,
|
|
240
|
+
dashToUpperDash,
|
|
241
|
+
dashToUpperSnake,
|
|
242
|
+
pascalToCamel,
|
|
243
|
+
pascalToDash,
|
|
244
|
+
pascalToSnake,
|
|
245
|
+
pascalToUpperDash,
|
|
246
|
+
pascalToUpperSnake,
|
|
247
|
+
snakeToCamel,
|
|
248
|
+
snakeToDash,
|
|
249
|
+
snakeToPascal,
|
|
250
|
+
snakeToUpperDash,
|
|
251
|
+
snakeToUpperSnake,
|
|
252
|
+
upperDashToCamel,
|
|
253
|
+
upperDashToDash,
|
|
254
|
+
upperDashToPascal,
|
|
255
|
+
upperDashToSnake,
|
|
256
|
+
upperDashToUpperSnake,
|
|
257
|
+
upperSnakeToCamel,
|
|
258
|
+
upperSnakeToDash,
|
|
259
|
+
upperSnakeToPascal,
|
|
260
|
+
upperSnakeToSnake,
|
|
261
|
+
upperSnakeToUpperDash
|
|
309
262
|
};
|
package/package.json
CHANGED