├── .editorconfig ├── .eslintignore ├── .eslintrc.js ├── .gitignore ├── .prettierrc ├── LICENSE ├── README.md ├── dist ├── js-convert-case.js └── js-convert-case.min.js ├── index.js ├── lib ├── index.d.ts ├── index.js └── modules │ ├── extends │ ├── camelcase-keys-object │ │ ├── index.d.ts │ │ └── index.js │ ├── kebabcase-keys-object │ │ ├── index.d.ts │ │ └── index.js │ ├── lowercase-keys-object │ │ ├── index.d.ts │ │ └── index.js │ ├── pascalcase-keys-object │ │ ├── index.d.ts │ │ └── index.js │ ├── snakecase-keys-object │ │ ├── index.d.ts │ │ └── index.js │ ├── uppercase-keys-object │ │ ├── index.d.ts │ │ └── index.js │ ├── utils.d.ts │ └── utils.js │ ├── js-camelcase │ ├── index.d.ts │ └── index.js │ ├── js-dotcase │ ├── index.d.ts │ └── index.js │ ├── js-headercase │ ├── index.d.ts │ └── index.js │ ├── js-kebabcase │ ├── index.d.ts │ └── index.js │ ├── js-pascalcase │ ├── index.d.ts │ └── index.js │ ├── js-pathcase │ ├── index.d.ts │ └── index.js │ ├── js-sentencecase │ ├── index.d.ts │ └── index.js │ ├── js-snakecase │ ├── index.d.ts │ └── index.js │ └── js-textcase │ ├── index.d.ts │ └── index.js ├── package.json ├── rollup.config.js ├── scripts └── build_release_binary.sh ├── src ├── index.ts └── modules │ ├── extends │ ├── camelcase-keys-object │ │ └── index.ts │ ├── kebabcase-keys-object │ │ └── index.ts │ ├── lowercase-keys-object │ │ └── index.ts │ ├── pascalcase-keys-object │ │ └── index.ts │ ├── snakecase-keys-object │ │ └── index.ts │ ├── uppercase-keys-object │ │ └── index.ts │ └── utils.ts │ ├── js-camelcase │ └── index.ts │ ├── js-dotcase │ └── index.ts │ ├── js-headercase │ └── index.ts │ ├── js-kebabcase │ └── index.ts │ ├── js-pascalcase │ └── index.ts │ ├── js-pathcase │ └── index.ts │ ├── js-sentencecase │ └── index.ts │ ├── js-snakecase │ └── index.ts │ └── js-textcase │ └── index.ts ├── test ├── browser │ ├── core.js │ ├── extends.js │ ├── index.html │ └── recursive.js ├── core │ └── index.js ├── example │ ├── index.js │ └── samples │ │ ├── camelKeys.json │ │ ├── lowerKeys.json │ │ ├── pascalKeys.json │ │ ├── snakeKeys.json │ │ └── upperKeys.json ├── extends │ └── index.js ├── prepublish │ ├── .babelrc │ ├── package.json │ ├── src │ │ ├── es5.js │ │ └── es6.js │ └── yarn.lock ├── recursive │ ├── _genexample.js │ ├── _shared.js │ ├── camelKeys.js │ ├── camelKeysArray.js │ ├── lowerKeys.js │ ├── lowerKeysArray.js │ ├── pascalKeys.js │ ├── pascalKeysArray.js │ ├── snakeKeys.js │ ├── snakeKeysArray.js │ ├── special │ │ └── objects.js │ ├── upperKeys.js │ └── upperKeysArray.js └── release │ ├── core.js │ ├── extends.js │ ├── package.json │ └── yarn.lock ├── tsconfig.json ├── tslint.json └── yarn.lock /.editorconfig: -------------------------------------------------------------------------------- 1 | # EditorConfig is awesome: http://EditorConfig.org 2 | 3 | # Howto with your editor: http://editorconfig.org/#download 4 | # Sublime: https://github.com/sindresorhus/editorconfig-sublime 5 | 6 | # top-most EditorConfig file 7 | root = true 8 | 9 | # Unix-style newlines with a newline ending every file 10 | [**] 11 | end_of_line = lf 12 | insert_final_newline = true 13 | 14 | # Standard at: https://github.com/felixge/node-style-guide 15 | [**.{js,json,jsx}] 16 | trim_trailing_whitespace = true 17 | indent_style = space 18 | indent_size = 2 19 | quote_type = single 20 | curly_bracket_next_line = false 21 | spaces_around_operators = true 22 | space_after_control_statements = true 23 | space_after_anonymous_functions = true 24 | spaces_in_brackets = false 25 | 26 | # No Standard. Please document a standard if different from .js 27 | [**.{yml,css,scss}] 28 | trim_trailing_whitespace = true 29 | indent_style = tab 30 | indent_size = 2 31 | 32 | [**.html] 33 | trim_trailing_whitespace = true 34 | indent_style = space 35 | indent_size = 2 36 | 37 | # No standard. Please document a standard if different from .js 38 | [**.md] 39 | indent_style = tab 40 | 41 | # Standard at: 42 | [Makefile] 43 | indent_style = tab 44 | 45 | # The indentation in package.json will always need to be 2 spaces 46 | # https://github.com/npm/npm/issues/4718 47 | [{package, bower}.json] 48 | indent_style = space 49 | indent_size = 2 50 | -------------------------------------------------------------------------------- /.eslintignore: -------------------------------------------------------------------------------- 1 | node_modules/* 2 | coverage/* 3 | dist/* 4 | dll/* 5 | build/* 6 | docs/lib/* 7 | *.min.js 8 | lib/* 9 | dist/* 10 | -------------------------------------------------------------------------------- /.eslintrc.js: -------------------------------------------------------------------------------- 1 | module.exports = { 2 | "extends": [ 3 | "airbnb", 4 | "plugin:jsx-a11y/recommended" 5 | ], 6 | "parser": "babel-eslint", 7 | "parserOptions": { 8 | "ecmaVersion": 9, 9 | "sourceType": "module", 10 | "ecmaFeatures": { 11 | "experimentalObjectRestSpread": true, 12 | "allowImportExportEverywhere": true, 13 | "jsx": true 14 | } 15 | }, 16 | "plugins": [ 17 | "react", 18 | "jsx-a11y", 19 | "import" 20 | ], 21 | "env": { 22 | browser: true, 23 | node: true, 24 | node: true, 25 | es6: true, 26 | browser: true, 27 | jasmine: true, 28 | mocha: true, 29 | jquery: true 30 | }, 31 | "rules": { 32 | 'camelcase': 0, 33 | 'comma-dangle': [2, 'never'], 34 | 'comma-spacing': [2, { before: false, after: true }], 35 | 'consistent-return': 0, 36 | 'curly': 0, 37 | 'default-case': 0, 38 | 'eqeqeq': [2, 'smart'], 39 | 'func-names': 0, 40 | 'guard-for-in': 0, 41 | 'indent': [2, 2, { SwitchCase: 1 }], 42 | 'key-spacing': [2, { beforeColon: false, afterColon: true }], 43 | 'keyword-spacing': [2, { before: true, after: true }], 44 | 'max-len': 0, 45 | 'new-cap': 0, 46 | 'no-bitwise': 0, 47 | 'no-caller': 2, 48 | 'no-console': 0, 49 | 'no-else-return': 0, 50 | 'no-empty-class': 0, 51 | 'no-multi-spaces': 2, 52 | 'no-param-reassign': 0, 53 | 'no-shadow': 0, 54 | 'no-spaced-func': 2, 55 | 'no-throw-literal': 2, 56 | 'no-trailing-spaces': 2, 57 | 'no-undef': 2, 58 | 'no-unneeded-ternary': 2, 59 | 'no-unreachable': 2, 60 | 'no-underscore-dangle': 0, 61 | 'no-unused-expressions': 0, 62 | 'no-unused-vars': 0, 63 | 'no-restricted-syntax': 0, 64 | 'no-use-before-define': [1, 'nofunc'], 65 | 'no-var': 0, 66 | 'object-curly-spacing': [2, 'always'], 67 | 'one-var': [0, 'never'], 68 | 'one-var-declaration-per-line': [2, 'always'], 69 | 'padded-blocks': 0, 70 | 'space-before-function-paren': [2, { 71 | 'anonymous': 'always', 72 | 'named': 'never', 73 | 'asyncArrow': 'always' 74 | }], 75 | 'space-in-parens': [2, 'never'], 76 | 'spaced-comment': [2, 'always'], 77 | 'strict': 0, 78 | 'quote-props': 0, 79 | 'quotes': [1, 'single'], 80 | 'wrap-iife': [2, 'outside'], 81 | 'vars-on-top': 0, 82 | 'global-require': 0, 83 | 'no-plusplus': 0, 84 | 'eqeqeq': 0, 85 | 'no-case-declarations': 0, 86 | 'class-methods-use-this': 0, 87 | 'prefer-destructuring': 0, 88 | 'no-alert': 0, 89 | 'no-mixed-operators': 0, 90 | 'object-property-newline': 0, 91 | 'no-nested-ternary': 0, 92 | // import plugin 93 | 'import/no-mutable-exports': 0, 94 | 'import/extensions': 0, 95 | 'import/first': 0, 96 | 'import/no-named-as-default': 0, 97 | // react plugin 98 | 'react/jsx-filename-extension': [1, { "extensions": [".js", ".jsx"] }], 99 | 'react/prefer-stateless-function': 0, 100 | 'react/forbid-prop-types': 0, 101 | 'react/jsx-max-props-per-line': 0, 102 | // jsx-a11y plugin 103 | 'jsx-a11y/href-no-hash': 0, 104 | 'jsx-a11y/anchor-is-valid': 0, 105 | 'jsx-a11y/img-redundant-alt': 0, 106 | 'jsx-a11y/label-has-for': 0 107 | }, 108 | 'globals': { 109 | angular: true, 110 | jsConvert: true, 111 | ScrollReveal: true, 112 | sr: true, 113 | by: true, 114 | browser: true, 115 | element: true, 116 | inject: true, 117 | io: true, 118 | moment: true, 119 | Modernizr: true, 120 | Promise: true, 121 | __TESTING__: true, 122 | _: false, 123 | ApplicationConfiguration: true 124 | } 125 | }; 126 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Logs 2 | logs 3 | *.log 4 | npm-debug.log* 5 | yarn-debug.log* 6 | yarn-error.log* 7 | 8 | # Runtime data 9 | pids 10 | *.pid 11 | *.seed 12 | *.pid.lock 13 | 14 | # Directory for instrumented libs generated by jscoverage/JSCover 15 | lib-cov 16 | 17 | # Coverage directory used by tools like istanbul 18 | coverage 19 | 20 | # nyc test coverage 21 | .nyc_output 22 | 23 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files) 24 | .grunt 25 | 26 | # Bower dependency directory (https://bower.io/) 27 | bower_components 28 | 29 | # node-waf configuration 30 | .lock-wscript 31 | 32 | # Compiled binary addons (https://nodejs.org/api/addons.html) 33 | build/Release 34 | 35 | # Dependency directories 36 | node_modules/ 37 | jspm_packages/ 38 | 39 | # Typescript v1 declaration files 40 | typings/ 41 | 42 | # Optional npm cache directory 43 | .npm 44 | 45 | # Optional eslint cache 46 | .eslintcache 47 | 48 | # Optional REPL history 49 | .node_repl_history 50 | 51 | # Output of 'npm pack' 52 | *.tgz 53 | 54 | # Yarn Integrity file 55 | .yarn-integrity 56 | 57 | # dotenv environment variables file 58 | .env 59 | 60 | # next.js build output 61 | .next 62 | 63 | # extension IDE 64 | .vscode 65 | 66 | # gem jekyll 67 | _site 68 | 69 | # macOS 70 | .DS_Store 71 | 72 | releases 73 | -------------------------------------------------------------------------------- /.prettierrc: -------------------------------------------------------------------------------- 1 | { 2 | "printWidth": 120, 3 | "trailingComma": "none", 4 | "singleQuote": true 5 | } 6 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # js-convert-case 2 | 3 | [![NPM version][npm-image]][npm-url] 4 | [![NPM downloads][downloads-image]][downloads-url] 5 | [![GitHub tag](https://img.shields.io/github/tag/huynhsamha/js-convert-case.svg)](https://GitHub.com/huynhsamha/js-convert-case/tags) 6 | ![File size](https://img.badgesize.io/huynhsamha/js-convert-case/master/dist/js-convert-case.min.js.svg?label=dist) 7 | [![MIT license](https://img.shields.io/badge/License-MIT-blue.svg)](https://lbesson.mit-license.org/) 8 | 9 | [npm-image]: https://img.shields.io/npm/v/js-convert-case.svg?style=flat 10 | [npm-url]: https://www.npmjs.com/package/js-convert-case 11 | [downloads-image]: https://img.shields.io/npm/dm/js-convert-case.svg?style=flat 12 | [downloads-url]: https://www.npmjs.com/package/js-convert-case 13 | 14 | ⛹️‍♂️ JavaScript Convert Cases Package 🏌️‍♀️ Use for both Node.JS and Browser 🎯🎯 15 | 16 | Convert String and Keys of Object between cases (camelCase, snake_case, PascalCase, dot.case, path/case, text case, Sentence case, Header Case, UPPERCASE, lowercase, kebab-case). 17 | 18 | 21 | 22 | View [Demo on GitHub here](https://huynhsamha.github.io/js-convert-case/). 23 | 24 | ## Installation 25 | 26 | ### Node.JS 27 | 28 | ```bash 29 | npm install --save js-convert-case 30 | # or 31 | yarn add js-convert-case 32 | ``` 33 | 34 | ### Browser 35 | 36 | Download file `js-convert-case.min.js` at [here](https://github.com/huynhsamha/js-convert-case/blob/master/dist/js-convert-case.min.js) or we can use CDN for NPM such as [unpkg](https://unpkg.com/) or [jsDelivr](https://www.jsdelivr.com/). 37 | 38 | ```html 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | ``` 48 | 49 | ## Usage 50 | 51 | ### Node.JS 52 | 53 | #### Syntax `require` 54 | 55 | ```js 56 | const jsConvert = require('js-convert-case'); 57 | // or 58 | const { toCamelCase, toDotCase, upperKeys, snakeKeys } = require('js-convert-case'); 59 | ``` 60 | 61 | #### Syntax `import` 62 | 63 | ```js 64 | import js-convert-case from 'js-convert-case'; 65 | // or 66 | import { toPascalCase, toPathCase, lowerKeys, camelKeys } from 'js-convert-case'; 67 | ``` 68 | 69 | #### Example 70 | 71 | ```js 72 | // Convert String 73 | console.log(jsConvert.toCamelCase('param-case')); // paramCase 74 | console.log(jsConvert.toSnakeCase('param-case')); // param_case 75 | console.log(jsConvert.toPascalCase('param-case')); // ParamCase 76 | console.log(jsConvert.toDotCase('param-case')); // param.case 77 | console.log(jsConvert.toPathCase('param-case')); // param/case 78 | console.log(jsConvert.toTextCase('param-case')); // param case 79 | console.log(jsConvert.toSentenceCase('param-case')); // Param case 80 | console.log(jsConvert.toHeaderCase('param-case')); // Param Case 81 | console.log(jsConvert.toLowerCase('param-case')); // param-case 82 | console.log(jsConvert.toUpperCase('param-case')); // PARAM-CASE 83 | console.log(jsConvert.toKebabCase('param-case')); // param-case 84 | 85 | // Convert Keys of Object 86 | const obj = { 87 | camelCase: 1, 88 | UPPERCASE: 2, 89 | lowercase: 3, 90 | snake_case: 4, 91 | PascalCase: 5, 92 | 'Title Case': 6, 93 | 'dot.case': 7, 94 | 'param-case': 8, 95 | 'Sentence case': 9, 96 | 'path/case': 10, 97 | 'Header-Case': 11 98 | }; 99 | 100 | console.log(jsConvert.lowerKeys(obj)); 101 | console.log(jsConvert.upperKeys(obj)); 102 | console.log(jsConvert.camelKeys(obj)); 103 | console.log(jsConvert.snakeKeys(obj)); 104 | console.log(jsConvert.pascalKeys(obj)); 105 | console.log(jsConvert.kebabKeys(obj)); 106 | ``` 107 | 108 | ### Browser 109 | 110 | After file `js-convert-case.min.js` is loaded, object `jsConvert` will be exported globally into `window` object. 111 | 112 | ```html 113 | 152 | ``` 153 | 154 | #### More examples 155 | 156 | You can see more examples in directory [`./test/browser`](./test/browser) 157 | 158 | ## API 159 | 160 | ### jsConvert 161 | 162 | **jsConvert** is an object containing function which converts cases. On browser, `jsConvert` is exported globally to `window` object, you can access by `jsConvert` or `window.jsConvert`. 163 | 164 | ### Available Methods 165 | 166 | #### Convert String 167 | 168 | - [`toCamelCase`](#tocamelcase) 169 | - [`toSnakeCase`](#tosnakecase) 170 | - [`toPascalCase`](#topascalcase) 171 | - [`toDotCase`](#todotcase) 172 | - [`toPathCase`](#topathcase) 173 | - [`toTextCase`](#totextcase) 174 | - [`toSentenceCase`](#tosentencecase) 175 | - [`toHeaderCase`](#toheadercase) 176 | - [`toKebabCase`](#tokebabcase) 177 | - [`toLowerCase`](#tolowercase) 178 | - [`toUpperCase`](#touppercase) 179 | 180 | #### Convert Keys of Object 181 | 182 | - [`lowerKeys`](#lowerkeys) 183 | - [`upperKeys`](#upperkeys) 184 | - [`camelKeys`](#camelkeys) 185 | - [`snakeKeys`](#snakekeys) 186 | - [`pascalKeys`](#pascalkeys) 187 | - [`kebabKeys`](#kebabkeys) 188 | 189 | #### toCamelCase 190 | 191 | Return as a string with the separators denoted by having the next letter capitalized. 192 | 193 | ```js 194 | console.log(jsConvert.toCamelCase('param-case')); // paramCase 195 | ``` 196 | 197 | #### toSnakeCase 198 | 199 | Return as a lower case, underscore separated string. 200 | 201 | ```js 202 | console.log(jsConvert.toSnakeCase('camelCase')); // camel_case 203 | ``` 204 | 205 | #### toPascalCase 206 | 207 | Return as a string denoted in the same fashion as `camelCase`, but with the first letter also capitalized. 208 | 209 | ```js 210 | console.log(jsConvert.toPascalCase('param-case')); // ParamCase 211 | ``` 212 | 213 | #### toDotCase 214 | 215 | Return as a lower case, period separated string. 216 | 217 | ```js 218 | console.log(jsConvert.toDotCase('Title Case')); // title.case 219 | ``` 220 | 221 | #### toPathCase 222 | 223 | Return as a lower case, slash separated string. 224 | 225 | ```js 226 | console.log(jsConvert.toPathCase('camelCase')); // camel/case 227 | ``` 228 | 229 | #### toTextCase 230 | 231 | Return the string without any casing (lower case, space separated). 232 | 233 | ```js 234 | console.log(jsConvert.toTextCase('camelCase')); // camel case 235 | ``` 236 | 237 | #### toSentenceCase 238 | 239 | Return as a lower case, space separated string with the first letter upper case. 240 | 241 | ```js 242 | console.log(jsConvert.toSentenceCase('camelCase')); // Camel case 243 | ``` 244 | 245 | #### toHeaderCase 246 | 247 | Return as a space separated string with the first character of every word upper cased. 248 | 249 | ```js 250 | console.log(jsConvert.toHeaderCase('param-case')); // Param Case 251 | ``` 252 | 253 | #### toKebabCase 254 | 255 | Return as a lower case, hyphen separated string. 256 | 257 | ```js 258 | console.log(jsConvert.toKebabCase('Title Case')); // title-case 259 | ``` 260 | 261 | #### toLowerCase 262 | 263 | Similar to `String.prototype.toLowerCase()` 264 | 265 | ```js 266 | console.log(jsConvert.toLowerCase('Title Case')); // title case 267 | ``` 268 | 269 | #### toUpperCase 270 | 271 | Similar to `String.prototype.toUpperCase()` 272 | 273 | ```js 274 | console.log(jsConvert.toUpperCase('param-case')); // PARAM-CASE 275 | ``` 276 | 277 | #### lowerKeys 278 | 279 | ```ts 280 | const lowerKeys(obj: any, { 281 | recursive: boolean = false, 282 | recursiveInArray: boolean = false, 283 | keepTypesOnRecursion: any[] = [] // example: Date 284 | }): object | null 285 | ``` 286 | 287 | Return a new object which keys is _lowercase_ format. Support lowerKeys **recursively**. Default is `false`. 288 | 289 | ```js 290 | console.log(jsConvert.lowerKeys(obj)); 291 | // or recursive 292 | console.log(jsConvert.lowerKeys(obj, { recursive: true })); 293 | // or recursive in sub-keys with value is an array 294 | console.log(jsConvert.lowerKeys(obj, { recursive: true, recursiveInArray: true })); 295 | 296 | /** 297 | { camelcase: 1, 298 | uppercase: 2, 299 | lowercase: 3, 300 | snake_case: 4, 301 | pascalcase: 5, 302 | 'title case': 6, 303 | 'dot.case': 7, 304 | 'param-case': 8, 305 | 'sentence case': 9, 306 | 'path/case': 10, 307 | 'header-case': 11 } 308 | **/ 309 | 310 | // All output are `null` 311 | console.log(jsConvert.lowerKeys(undefined)); 312 | console.log(jsConvert.lowerKeys(null)); 313 | console.log(jsConvert.lowerKeys(1)); 314 | console.log(jsConvert.lowerKeys('abc')); 315 | console.log(jsConvert.lowerKeys([1, 2, 3])); 316 | ``` 317 | 318 | #### upperKeys 319 | 320 | ```ts 321 | const upperKeys(obj: any, { 322 | recursive: boolean = false, 323 | recursiveInArray: boolean = false, 324 | keepTypesOnRecursion: any[] = [] // example: Date 325 | }): object | null 326 | ``` 327 | 328 | Return a new object which keys is _UPPERCASE_ format. Support upperKeys **recursively**. Default is `false` 329 | 330 | ```js 331 | console.log(jsConvert.upperKeys(obj)); 332 | // or recursive 333 | console.log(jsConvert.upperKeys(obj, { recursive: true })); 334 | // or recursive in sub-keys with value is an array 335 | console.log(jsConvert.upperKeys(obj, { recursive: true, recursiveInArray: true })); 336 | 337 | /** 338 | { CAMELCASE: 1, 339 | UPPERCASE: 2, 340 | LOWERCASE: 3, 341 | SNAKE_CASE: 4, 342 | PASCALCASE: 5, 343 | 'TITLE CASE': 6, 344 | 'DOT.CASE': 7, 345 | 'PARAM-CASE': 8, 346 | 'SENTENCE CASE': 9, 347 | 'PATH/CASE': 10, 348 | 'HEADER-CASE': 11 } 349 | **/ 350 | 351 | // All output are `null` 352 | console.log(jsConvert.upperKeys(undefined)); 353 | console.log(jsConvert.upperKeys(null)); 354 | console.log(jsConvert.upperKeys(1)); 355 | console.log(jsConvert.upperKeys('abc')); 356 | console.log(jsConvert.upperKeys([1, 2, 3])); 357 | ``` 358 | 359 | #### camelKeys 360 | 361 | ```ts 362 | const camelKeys(obj: any, { 363 | recursive: boolean = false, 364 | recursiveInArray: boolean = false, 365 | keepTypesOnRecursion: any[] = [] // example: Date 366 | }): object | null 367 | ``` 368 | 369 | Return a new object which keys is _camelCase_ format. Support camelKeys **recursively**. Default is `false`. 370 | 371 | ```js 372 | console.log(jsConvert.camelKeys(obj)); 373 | // or recursive 374 | console.log(jsConvert.camelKeys(obj, { recursive: true })); 375 | // or recursive in sub-keys with value is an array 376 | console.log(jsConvert.camelKeys(obj, { recursive: true, recursiveInArray: true })); 377 | 378 | /** 379 | { camelCase: 1, 380 | uppercase: 2, 381 | lowercase: 3, 382 | snakeCase: 4, 383 | pascalCase: 5, 384 | titleCase: 6, 385 | dotCase: 7, 386 | paramCase: 8, 387 | sentenceCase: 9, 388 | pathCase: 10, 389 | headerCase: 11 } 390 | **/ 391 | 392 | // All output are `null` 393 | console.log(jsConvert.camelKeys(undefined)); 394 | console.log(jsConvert.camelKeys(null)); 395 | console.log(jsConvert.camelKeys(1)); 396 | console.log(jsConvert.camelKeys('abc')); 397 | console.log(jsConvert.camelKeys([1, 2, 3])); 398 | ``` 399 | 400 | #### snakeKeys 401 | 402 | ```ts 403 | const snakeKeys(obj: any, { 404 | recursive: boolean = false, 405 | recursiveInArray: boolean = false, 406 | keepTypesOnRecursion: any[] = [] // example: Date 407 | }): object | null 408 | ``` 409 | 410 | Return a new object which keys is _snake_case_ format. Support snakeKeys **recursively**. Default is `false`. 411 | 412 | ```js 413 | console.log(jsConvert.snakeKeys(obj)); 414 | // or recursive 415 | console.log(jsConvert.snakeKeys(obj, { recursive: true })); 416 | // or recursive in sub-keys with value is an array 417 | console.log(jsConvert.snakeKeys(obj, { recursive: true, recursiveInArray: true })); 418 | 419 | /** 420 | { camel_case: 1, 421 | uppercase: 2, 422 | lowercase: 3, 423 | snake_case: 4, 424 | pascal_case: 5, 425 | title_case: 6, 426 | dot_case: 7, 427 | param_case: 8, 428 | sentence_case: 9, 429 | path_case: 10, 430 | header_case: 11 } 431 | **/ 432 | 433 | // All output are `null` 434 | console.log(jsConvert.snakeKeys(undefined)); 435 | console.log(jsConvert.snakeKeys(null)); 436 | console.log(jsConvert.snakeKeys(1)); 437 | console.log(jsConvert.snakeKeys('abc')); 438 | console.log(jsConvert.snakeKeys([1, 2, 3])); 439 | ``` 440 | 441 | #### pascalKeys 442 | 443 | ```ts 444 | const pascalKeys(obj: any, { 445 | recursive: boolean = false, 446 | recursiveInArray: boolean = false, 447 | keepTypesOnRecursion: any[] = [] // example: Date 448 | }): object | null 449 | ``` 450 | 451 | Return a new object which keys is _PascalCase_ format. Support pascalKeys **recursively**. Default is `false`. 452 | 453 | ```js 454 | console.log(jsConvert.pascalKeys(obj)); 455 | // or recursive 456 | console.log(jsConvert.pascalKeys(obj, { recursive: true })); 457 | // or recursive in sub-keys with value is an array 458 | console.log(jsConvert.pascalKeys(obj, { recursive: true, recursiveInArray: true })); 459 | 460 | /** 461 | { CamelCase: 1, 462 | Uppercase: 2, 463 | Lowercase: 3, 464 | SnakeCase: 4, 465 | PascalCase: 5, 466 | TitleCase: 6, 467 | DotCase: 7, 468 | ParamCase: 8, 469 | SentenceCase: 9, 470 | PathCase: 10, 471 | HeaderCase: 11 } 472 | **/ 473 | 474 | // All output are `null` 475 | console.log(jsConvert.pascalKeys(undefined)); 476 | console.log(jsConvert.pascalKeys(null)); 477 | console.log(jsConvert.pascalKeys(1)); 478 | console.log(jsConvert.pascalKeys('abc')); 479 | console.log(jsConvert.pascalKeys([1, 2, 3])); 480 | ``` 481 | 482 | #### kebabKeys 483 | 484 | ```ts 485 | const kebabKeys(obj: any, { 486 | recursive: boolean = false, 487 | recursiveInArray: boolean = false, 488 | keepTypesOnRecursion: any[] = [] // example: Date 489 | }): object | null 490 | ``` 491 | 492 | Return a new object which keys is _kebab-case_ format. Support kebabKeys **recursively**. Default is `false`. 493 | 494 | ```js 495 | console.log(jsConvert.kebabKeys(obj)); 496 | // or recursive 497 | console.log(jsConvert.kebabKeys(obj, { recursive: true })); 498 | // or recursive in sub-keys with value is an array 499 | console.log(jsConvert.kebabKeys(obj, { recursive: true, recursiveInArray: true })); 500 | 501 | /** 502 | { 'camel-case': 1, 503 | uppercase: 2, 504 | lowercase: 3, 505 | 'snake-case': 4, 506 | 'pascal-case': 5, 507 | 'title-case': 6, 508 | 'dot-case': 7, 509 | 'param-case': 8, 510 | 'sentence-case': 9, 511 | 'path-case': 10, 512 | 'header-case': 11 } 513 | **/ 514 | 515 | // All output are `null` 516 | console.log(jsConvert.kebabKeys(undefined)); 517 | console.log(jsConvert.kebabKeys(null)); 518 | console.log(jsConvert.kebabKeys(1)); 519 | console.log(jsConvert.kebabKeys('abc')); 520 | console.log(jsConvert.kebabKeys([1, 2, 3])); 521 | ``` 522 | 523 | ## Examples 524 | 525 | ### Convert string between cases 526 | 527 | ```js 528 | console.log(jsConvert.toCamelCase('param-case')); // paramCase 529 | console.log(jsConvert.toCamelCase('camelCase')); // camelCase 530 | console.log(jsConvert.toCamelCase('Title Case')); // titleCase 531 | 532 | console.log(jsConvert.toSnakeCase('param-case')); // param_case 533 | console.log(jsConvert.toSnakeCase('camelCase')); // camel_case 534 | console.log(jsConvert.toSnakeCase('Title Case')); // title_case 535 | 536 | console.log(jsConvert.toPascalCase('param-case')); // ParamCase 537 | console.log(jsConvert.toPascalCase('camelCase')); // CamelCase 538 | console.log(jsConvert.toPascalCase('Title Case')); // TitleCase 539 | 540 | console.log(jsConvert.toDotCase('param-case')); // param.case 541 | console.log(jsConvert.toDotCase('camelCase')); // camel.case 542 | console.log(jsConvert.toDotCase('Title Case')); // title.case 543 | 544 | console.log(jsConvert.toPathCase('param-case')); // param/case 545 | console.log(jsConvert.toPathCase('camelCase')); // camel/case 546 | console.log(jsConvert.toPathCase('Title Case')); // title/case 547 | 548 | console.log(jsConvert.toTextCase('param-case')); // param case 549 | console.log(jsConvert.toTextCase('camelCase')); // camel case 550 | console.log(jsConvert.toTextCase('Title Case')); // title case 551 | 552 | console.log(jsConvert.toSentenceCase('param-case')); // Param case 553 | console.log(jsConvert.toSentenceCase('camelCase')); // Camel case 554 | console.log(jsConvert.toSentenceCase('Title Case')); // Title case 555 | 556 | console.log(jsConvert.toHeaderCase('param-case')); // Param Case 557 | console.log(jsConvert.toHeaderCase('camelCase')); // Camel Case 558 | console.log(jsConvert.toHeaderCase('Title Case')); // Title Case 559 | 560 | console.log(jsConvert.toLowerCase('param-case')); // param-case 561 | console.log(jsConvert.toLowerCase('Title Case')); // title case 562 | console.log(jsConvert.toUpperCase('param-case')); // PARAM-CASE 563 | console.log(jsConvert.toUpperCase('Title Case')); // TITLE CASE 564 | 565 | console.log(jsConvert.toKebabCase('param-case')); // param-case 566 | console.log(jsConvert.toKebabCase('Title Case')); // title-case 567 | console.log(jsConvert.toKebabCase('param-case')); // PARAM-CASE 568 | console.log(jsConvert.toKebabCase('Title Case')); // TITLE-CASE 569 | ``` 570 | 571 | ### Speical values 572 | 573 | ```js 574 | console.log(jsConvert.toCamelCase('')); // => '' 575 | console.log(jsConvert.toSnakeCase(null)); // => '' 576 | console.log(jsConvert.toPascalCase(undefined)); // => '' 577 | ``` 578 | 579 | ### Complicated values 580 | 581 | ```js 582 | const str = 583 | '!@#$ -- Hello___world ..<>| \\ 123_ _456 &l sn_ca - cmCa - PcCa - dot.ca - txt ca - Sen ca - Hd Ca %^$^%&'; 584 | console.log(jsConvert.toCamelCase(str)); // => 'helloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 585 | console.log(jsConvert.toPascalCase(str)); // => 'HelloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 586 | console.log(jsConvert.toSnakeCase(str)); // => 'hello_world_123_456_l_sn_ca_cm_ca_pc_ca_dot_ca_txt_ca_sen_ca_hd_ca' 587 | console.log(jsConvert.toDotCase(str)); // => 'hello.world.123.456.l.sn.ca.cm.ca.pc.ca.dot.ca.txt.ca.sen.ca.hd.ca' 588 | console.log(jsConvert.toPathCase(str)); // => 'hello/world/123/456/l/sn/ca/cm/ca/pc/ca/dot/ca/txt/ca/sen/ca/hd/ca' 589 | console.log(jsConvert.toTextCase(str)); // => 'hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 590 | console.log(jsConvert.toSentenceCase(str)); // => 'Hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 591 | console.log(jsConvert.toHeaderCase(str)); // => 'Hello World 123 456 L Sn Ca Cm Ca Pc Ca Dot Ca Txt Ca Sen Ca Hd Ca' 592 | console.log(jsConvert.toKebabCase(str)); // => 'hello-world-123-456-l-sn-ca-cm-ca-pc-ca-dot-ca-txt-ca-sen-ca-hd-ca' 593 | ``` 594 | 595 | ### Recursive convert in object 596 | 597 | **Multi-leveled object** 598 | 599 | ```js 600 | const core = { 601 | camelCase: 1, 602 | UPPERCASE: 2, 603 | lowercase: 3, 604 | snake_case: 4, 605 | PascalCase: 5, 606 | 'Title Case': 6, 607 | 'dot.case': 7, 608 | 'param-case': 8, 609 | 'Sentence case': 9, 610 | 'path/case': 10, 611 | 'Header-Case': 11 612 | }; 613 | 614 | const obj = { 615 | ...core, 616 | lv1: { 617 | ...core, 618 | lv2: { 619 | ...core 620 | } 621 | } 622 | }; 623 | ``` 624 | 625 | **Example with `upperKeys`** 626 | 627 | ```js 628 | const res = jsConvert.upperKeys(obj, { recursive: true }); 629 | console.log(JSON.stringify(res)); 630 | ``` 631 | 632 | Output 633 | 634 | ```json 635 | { 636 | "CAMELCASE": 1, 637 | "UPPERCASE": 2, 638 | "LOWERCASE": 3, 639 | "SNAKE_CASE": 4, 640 | "PASCALCASE": 5, 641 | "TITLE CASE": 6, 642 | "DOT.CASE": 7, 643 | "PARAM-CASE": 8, 644 | "SENTENCE CASE": 9, 645 | "PATH/CASE": 10, 646 | "HEADER-CASE": 11, 647 | "LV1": { 648 | "CAMELCASE": 1, 649 | "UPPERCASE": 2, 650 | "LOWERCASE": 3, 651 | "SNAKE_CASE": 4, 652 | "PASCALCASE": 5, 653 | "TITLE CASE": 6, 654 | "DOT.CASE": 7, 655 | "PARAM-CASE": 8, 656 | "SENTENCE CASE": 9, 657 | "PATH/CASE": 10, 658 | "HEADER-CASE": 11, 659 | "LV2": { 660 | "CAMELCASE": 1, 661 | "UPPERCASE": 2, 662 | "LOWERCASE": 3, 663 | "SNAKE_CASE": 4, 664 | "PASCALCASE": 5, 665 | "TITLE CASE": 6, 666 | "DOT.CASE": 7, 667 | "PARAM-CASE": 8, 668 | "SENTENCE CASE": 9, 669 | "PATH/CASE": 10, 670 | "HEADER-CASE": 11 671 | } 672 | } 673 | } 674 | ``` 675 | 676 | **Example with `pascalKeys`** 677 | 678 | ```js 679 | const res = jsConvert.pascalKeys(obj, { recursive: true }); 680 | console.log(JSON.stringify(res)); 681 | ``` 682 | 683 | Output 684 | 685 | ```json 686 | { 687 | "CamelCase": 1, 688 | "Uppercase": 2, 689 | "Lowercase": 3, 690 | "SnakeCase": 4, 691 | "PascalCase": 5, 692 | "TitleCase": 6, 693 | "DotCase": 7, 694 | "ParamCase": 8, 695 | "SentenceCase": 9, 696 | "PathCase": 10, 697 | "HeaderCase": 11, 698 | "Lv1": { 699 | "CamelCase": 1, 700 | "Uppercase": 2, 701 | "Lowercase": 3, 702 | "SnakeCase": 4, 703 | "PascalCase": 5, 704 | "TitleCase": 6, 705 | "DotCase": 7, 706 | "ParamCase": 8, 707 | "SentenceCase": 9, 708 | "PathCase": 10, 709 | "HeaderCase": 11, 710 | "Lv2": { 711 | "CamelCase": 1, 712 | "Uppercase": 2, 713 | "Lowercase": 3, 714 | "SnakeCase": 4, 715 | "PascalCase": 5, 716 | "TitleCase": 6, 717 | "DotCase": 7, 718 | "ParamCase": 8, 719 | "SentenceCase": 9, 720 | "PathCase": 10, 721 | "HeaderCase": 11 722 | } 723 | } 724 | } 725 | ``` 726 | 727 | **Example with `snakeKeys` use recursive in array-sub-keys** 728 | 729 | ```js 730 | const obj = { 731 | camelCase: 1, 732 | PascalCase: { 733 | camelCase: [1, 'a', null, { PascalCase: 1 }, undefined], 734 | PascalCase: [{ PascalCase: [1] }, [1, { PascalCase: 2 }]], 735 | snake_case: { camelCase: [{ PascalCase: 1 }] } 736 | } 737 | }; 738 | 739 | const res = jsConvert.snakeKeys(obj, { recursive: true, recursiveInArray: true }); 740 | console.log(JSON.stringify(res)); 741 | ``` 742 | 743 | Output 744 | 745 | ```json 746 | { 747 | "camel_case": 1, 748 | "pascal_case": { 749 | "camel_case": [1, "a", null, { "pascal_case": 1 }, null], 750 | "pascal_case": [{ "pascal_case": [1] }, [1, { "pascal_case": 2 }]], 751 | "snake_case": { "camel_case": [{ "pascal_case": 1 }] } 752 | } 753 | } 754 | ``` 755 | 756 | _Note: You can browse more examples at folder [`./test/example`](./test/example)_. 757 | 758 | ## Dependencies 759 | 760 | No dependencies 761 | 762 | ## Development 763 | 764 | ### Quickstart 765 | 766 | - Clone the repository and enter the project 767 | 768 | ```bash 769 | git clone https://github.com/huynhsamha/js-convert-case.git 770 | cd js-convert-case 771 | ``` 772 | 773 | - Install dependencies 774 | 775 | ```bash 776 | yarn 777 | ``` 778 | 779 | - Lint and format source (directory `src`) 780 | 781 | ```bash 782 | yarn format # defined in package.json 783 | yarn lint # defined in package.json 784 | ``` 785 | 786 | - Build package for Node 787 | 788 | ```bash 789 | yarn dist:node # defined in package.json 790 | ``` 791 | 792 | Output directory is `dist` (defined in file `tsconfig.json`) 793 | 794 | - Build package for Browser 795 | 796 | ```bash 797 | yarn dist:browser # defined in package.json and rollup.config.js 798 | ``` 799 | 800 | - Build dist (both Node and Browser) 801 | 802 | ```bash 803 | yarn dist # defined in package.json 804 | ``` 805 | 806 | - Build release files 807 | 808 | ```bash 809 | yarn build:release:binary 810 | ``` 811 | 812 | ### Testing 813 | 814 | In directory `test`, we can test the package in environments NodeJS, Browser, pre-published NPM package and the released package. 815 | 816 | ## Buy me a coffee 817 | 818 | Donate to my paypal 819 | -------------------------------------------------------------------------------- /dist/js-convert-case.js: -------------------------------------------------------------------------------- 1 | var jsConvert = (function () { 2 | 'use strict'; 3 | 4 | var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; 5 | 6 | function unwrapExports (x) { 7 | return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; 8 | } 9 | 10 | function createCommonjsModule(fn, module) { 11 | return module = { exports: {} }, fn(module, module.exports), module.exports; 12 | } 13 | 14 | var jsCamelcase = createCommonjsModule(function (module, exports) { 15 | Object.defineProperty(exports, "__esModule", { value: true }); 16 | function toCamelCase(str) { 17 | if (str === void 0) { str = ''; } 18 | if (!str) 19 | return ''; 20 | return String(str) 21 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 22 | .replace(/[^A-Za-z0-9]+/g, '$') 23 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "$" + b; }) 24 | .toLowerCase() 25 | .replace(/(\$)(\w)/g, function (m, a, b) { return b.toUpperCase(); }); 26 | } 27 | exports.default = toCamelCase; 28 | }); 29 | 30 | unwrapExports(jsCamelcase); 31 | 32 | var jsSnakecase = createCommonjsModule(function (module, exports) { 33 | Object.defineProperty(exports, "__esModule", { value: true }); 34 | function toSnakeCase(str) { 35 | if (str === void 0) { str = ''; } 36 | if (!str) 37 | return ''; 38 | return String(str) 39 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 40 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + '_' + b.toLowerCase(); }) 41 | .replace(/[^A-Za-z0-9]+|_+/g, '_') 42 | .toLowerCase(); 43 | } 44 | exports.default = toSnakeCase; 45 | }); 46 | 47 | unwrapExports(jsSnakecase); 48 | 49 | var jsPascalcase = createCommonjsModule(function (module, exports) { 50 | Object.defineProperty(exports, "__esModule", { value: true }); 51 | function toPascalCase(str) { 52 | if (str === void 0) { str = ''; } 53 | if (!str) 54 | return ''; 55 | return String(str) 56 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '$') 57 | .replace(/[^A-Za-z0-9]+/g, '$') 58 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "$" + b; }) 59 | .toLowerCase() 60 | .replace(/(\$)(\w?)/g, function (m, a, b) { return b.toUpperCase(); }); 61 | } 62 | exports.default = toPascalCase; 63 | }); 64 | 65 | unwrapExports(jsPascalcase); 66 | 67 | var jsDotcase = createCommonjsModule(function (module, exports) { 68 | Object.defineProperty(exports, "__esModule", { value: true }); 69 | function toDotCase(str) { 70 | if (str === void 0) { str = ''; } 71 | if (!str) 72 | return ''; 73 | return String(str) 74 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 75 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 76 | .replace(/[^A-Za-z0-9]+|_+/g, '.') 77 | .toLowerCase(); 78 | } 79 | exports.default = toDotCase; 80 | }); 81 | 82 | unwrapExports(jsDotcase); 83 | 84 | var jsPathcase = createCommonjsModule(function (module, exports) { 85 | Object.defineProperty(exports, "__esModule", { value: true }); 86 | function toPathCase(str) { 87 | if (str === void 0) { str = ''; } 88 | if (!str) 89 | return ''; 90 | return String(str) 91 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 92 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 93 | .replace(/[^A-Za-z0-9]+|_+/g, '/') 94 | .toLowerCase(); 95 | } 96 | exports.default = toPathCase; 97 | }); 98 | 99 | unwrapExports(jsPathcase); 100 | 101 | var jsTextcase = createCommonjsModule(function (module, exports) { 102 | Object.defineProperty(exports, "__esModule", { value: true }); 103 | function toTextCase(str) { 104 | if (str === void 0) { str = ''; } 105 | if (!str) 106 | return ''; 107 | return String(str) 108 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 109 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + '_' + b.toLowerCase(); }) 110 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 111 | .toLowerCase(); 112 | } 113 | exports.default = toTextCase; 114 | }); 115 | 116 | unwrapExports(jsTextcase); 117 | 118 | var jsSentencecase = createCommonjsModule(function (module, exports) { 119 | Object.defineProperty(exports, "__esModule", { value: true }); 120 | function toSentenceCase(str) { 121 | if (str === void 0) { str = ''; } 122 | if (!str) 123 | return ''; 124 | var textcase = String(str) 125 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 126 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 127 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 128 | .toLowerCase(); 129 | return textcase.charAt(0).toUpperCase() + textcase.slice(1); 130 | } 131 | exports.default = toSentenceCase; 132 | }); 133 | 134 | unwrapExports(jsSentencecase); 135 | 136 | var jsHeadercase = createCommonjsModule(function (module, exports) { 137 | Object.defineProperty(exports, "__esModule", { value: true }); 138 | function toHeaderCase(str) { 139 | if (str === void 0) { str = ''; } 140 | if (!str) 141 | return ''; 142 | return String(str) 143 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 144 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 145 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 146 | .toLowerCase() 147 | .replace(/( ?)(\w+)( ?)/g, function (m, a, b, c) { return a + b.charAt(0).toUpperCase() + b.slice(1) + c; }); 148 | } 149 | exports.default = toHeaderCase; 150 | }); 151 | 152 | unwrapExports(jsHeadercase); 153 | 154 | var jsKebabcase = createCommonjsModule(function (module, exports) { 155 | Object.defineProperty(exports, "__esModule", { value: true }); 156 | function toKebabCase(str) { 157 | if (str === void 0) { str = ''; } 158 | if (!str) 159 | return ''; 160 | return String(str) 161 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 162 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 163 | .replace(/[^A-Za-z0-9]+|_+/g, '-') 164 | .toLowerCase(); 165 | } 166 | exports.default = toKebabCase; 167 | }); 168 | 169 | unwrapExports(jsKebabcase); 170 | 171 | var utils = createCommonjsModule(function (module, exports) { 172 | Object.defineProperty(exports, "__esModule", { value: true }); 173 | exports.belongToTypes = exports.isValidObject = exports.isArrayObject = exports.validateOptions = exports.DefaultOption = void 0; 174 | /** 175 | * Default options for convert function. This option is not recursive. 176 | */ 177 | exports.DefaultOption = { 178 | recursive: false, 179 | recursiveInArray: false, 180 | keepTypesOnRecursion: [] 181 | }; 182 | exports.validateOptions = function (opt) { 183 | if (opt === void 0) { opt = exports.DefaultOption; } 184 | if (opt.recursive == null) { 185 | opt = exports.DefaultOption; 186 | } 187 | else if (opt.recursiveInArray == null) { 188 | opt.recursiveInArray = false; 189 | } 190 | return opt; 191 | }; 192 | exports.isArrayObject = function (obj) { return obj != null && Array.isArray(obj); }; 193 | exports.isValidObject = function (obj) { return obj != null && typeof obj === 'object' && !Array.isArray(obj); }; 194 | exports.belongToTypes = function (obj, types) { return (types || []).some(function (Type) { return obj instanceof Type; }); }; 195 | }); 196 | 197 | unwrapExports(utils); 198 | var utils_1 = utils.belongToTypes; 199 | var utils_2 = utils.isValidObject; 200 | var utils_3 = utils.isArrayObject; 201 | var utils_4 = utils.validateOptions; 202 | var utils_5 = utils.DefaultOption; 203 | 204 | var lowercaseKeysObject = createCommonjsModule(function (module, exports) { 205 | var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () { 206 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 207 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 208 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 209 | r[k] = a[j]; 210 | return r; 211 | }; 212 | Object.defineProperty(exports, "__esModule", { value: true }); 213 | 214 | /** 215 | * Convert string keys in an object to lowercase format. 216 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 217 | * @param opt: (optional) Options parameter, default is non-recursive. 218 | */ 219 | function lowerKeys(obj, opt) { 220 | if (opt === void 0) { opt = utils.DefaultOption; } 221 | if (!utils.isValidObject(obj)) 222 | return null; 223 | opt = utils.validateOptions(opt); 224 | var res = {}; 225 | Object.keys(obj).forEach(function (key) { 226 | var value = obj[key]; 227 | var nkey = key.toLowerCase(); 228 | if (opt.recursive) { 229 | if (utils.isValidObject(value)) { 230 | if (!utils.belongToTypes(value, opt.keepTypesOnRecursion)) { 231 | value = lowerKeys(value, opt); 232 | } 233 | } 234 | else if (opt.recursiveInArray && utils.isArrayObject(value)) { 235 | value = __spreadArrays(value).map(function (v) { 236 | var ret = v; 237 | if (utils.isValidObject(v)) { 238 | // object in array 239 | if (!utils.belongToTypes(ret, opt.keepTypesOnRecursion)) { 240 | ret = lowerKeys(v, opt); 241 | } 242 | } 243 | else if (utils.isArrayObject(v)) { 244 | // array in array 245 | // workaround by using an object holding array value 246 | var temp = lowerKeys({ key: v }, opt); 247 | ret = temp.key; 248 | } 249 | return ret; 250 | }); 251 | } 252 | } 253 | res[nkey] = value; 254 | }); 255 | return res; 256 | } 257 | exports.default = lowerKeys; 258 | }); 259 | 260 | unwrapExports(lowercaseKeysObject); 261 | 262 | var uppercaseKeysObject = createCommonjsModule(function (module, exports) { 263 | var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () { 264 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 265 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 266 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 267 | r[k] = a[j]; 268 | return r; 269 | }; 270 | Object.defineProperty(exports, "__esModule", { value: true }); 271 | 272 | /** 273 | * Convert string keys in an object to UPPERCASE format. 274 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 275 | * @param opt: (optional) Options parameter, default is non-recursive. 276 | */ 277 | function upperKeys(obj, opt) { 278 | if (opt === void 0) { opt = utils.DefaultOption; } 279 | if (!utils.isValidObject(obj)) 280 | return null; 281 | opt = utils.validateOptions(opt); 282 | var res = {}; 283 | Object.keys(obj).forEach(function (key) { 284 | var value = obj[key]; 285 | var nkey = key.toUpperCase(); 286 | if (opt.recursive) { 287 | if (utils.isValidObject(value)) { 288 | if (!utils.belongToTypes(value, opt.keepTypesOnRecursion)) { 289 | value = upperKeys(value, opt); 290 | } 291 | } 292 | else if (opt.recursiveInArray && utils.isArrayObject(value)) { 293 | value = __spreadArrays(value).map(function (v) { 294 | var ret = v; 295 | if (utils.isValidObject(v)) { 296 | // object in array 297 | if (!utils.belongToTypes(ret, opt.keepTypesOnRecursion)) { 298 | ret = upperKeys(v, opt); 299 | } 300 | } 301 | else if (utils.isArrayObject(v)) { 302 | // array in array 303 | // workaround by using an object holding array value 304 | var temp = upperKeys({ key: v }, opt); 305 | ret = temp.key; 306 | } 307 | return ret; 308 | }); 309 | } 310 | } 311 | res[nkey] = value; 312 | }); 313 | return res; 314 | } 315 | exports.default = upperKeys; 316 | }); 317 | 318 | unwrapExports(uppercaseKeysObject); 319 | 320 | var camelcaseKeysObject = createCommonjsModule(function (module, exports) { 321 | var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () { 322 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 323 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 324 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 325 | r[k] = a[j]; 326 | return r; 327 | }; 328 | Object.defineProperty(exports, "__esModule", { value: true }); 329 | 330 | 331 | /** 332 | * Convert string keys in an object to camelCase format. 333 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 334 | * @param opt: (optional) Options parameter, default is non-recursive. 335 | */ 336 | function camelKeys(obj, opt) { 337 | if (opt === void 0) { opt = utils.DefaultOption; } 338 | if (!utils.isValidObject(obj)) 339 | return null; 340 | opt = utils.validateOptions(opt); 341 | var res = {}; 342 | Object.keys(obj).forEach(function (key) { 343 | var value = obj[key]; 344 | var nkey = jsCamelcase.default(key); 345 | if (opt.recursive) { 346 | if (utils.isValidObject(value)) { 347 | if (!utils.belongToTypes(value, opt.keepTypesOnRecursion)) { 348 | value = camelKeys(value, opt); 349 | } 350 | } 351 | else if (opt.recursiveInArray && utils.isArrayObject(value)) { 352 | value = __spreadArrays(value).map(function (v) { 353 | var ret = v; 354 | if (utils.isValidObject(v)) { 355 | // object in array 356 | if (!utils.belongToTypes(ret, opt.keepTypesOnRecursion)) { 357 | ret = camelKeys(v, opt); 358 | } 359 | } 360 | else if (utils.isArrayObject(v)) { 361 | // array in array 362 | // workaround by using an object holding array value 363 | var temp = camelKeys({ key: v }, opt); 364 | ret = temp.key; 365 | } 366 | return ret; 367 | }); 368 | } 369 | } 370 | res[nkey] = value; 371 | }); 372 | return res; 373 | } 374 | exports.default = camelKeys; 375 | }); 376 | 377 | unwrapExports(camelcaseKeysObject); 378 | 379 | var snakecaseKeysObject = createCommonjsModule(function (module, exports) { 380 | var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () { 381 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 382 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 383 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 384 | r[k] = a[j]; 385 | return r; 386 | }; 387 | Object.defineProperty(exports, "__esModule", { value: true }); 388 | 389 | 390 | /** 391 | * Convert string keys in an object to snake_case format. 392 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 393 | * @param opt: (optional) Options parameter, default is non-recursive. 394 | */ 395 | function snakeKeys(obj, opt) { 396 | if (opt === void 0) { opt = utils.DefaultOption; } 397 | if (!utils.isValidObject(obj)) 398 | return null; 399 | opt = utils.validateOptions(opt); 400 | var res = {}; 401 | Object.keys(obj).forEach(function (key) { 402 | var value = obj[key]; 403 | var nkey = jsSnakecase.default(key); 404 | if (opt.recursive) { 405 | if (utils.isValidObject(value)) { 406 | if (!utils.belongToTypes(value, opt.keepTypesOnRecursion)) { 407 | value = snakeKeys(value, opt); 408 | } 409 | } 410 | else if (opt.recursiveInArray && utils.isArrayObject(value)) { 411 | value = __spreadArrays(value).map(function (v) { 412 | var ret = v; 413 | if (utils.isValidObject(v)) { 414 | // object in array 415 | if (!utils.belongToTypes(ret, opt.keepTypesOnRecursion)) { 416 | ret = snakeKeys(v, opt); 417 | } 418 | } 419 | else if (utils.isArrayObject(v)) { 420 | // array in array 421 | // workaround by using an object holding array value 422 | var temp = snakeKeys({ key: v }, opt); 423 | ret = temp.key; 424 | } 425 | return ret; 426 | }); 427 | } 428 | } 429 | res[nkey] = value; 430 | }); 431 | return res; 432 | } 433 | exports.default = snakeKeys; 434 | }); 435 | 436 | unwrapExports(snakecaseKeysObject); 437 | 438 | var pascalcaseKeysObject = createCommonjsModule(function (module, exports) { 439 | var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () { 440 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 441 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 442 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 443 | r[k] = a[j]; 444 | return r; 445 | }; 446 | Object.defineProperty(exports, "__esModule", { value: true }); 447 | 448 | 449 | /** 450 | * Convert string keys in an object to PascalCase format. 451 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 452 | * @param opt: (optional) Options parameter, default is non-recursive. 453 | */ 454 | function pascalKeys(obj, opt) { 455 | if (opt === void 0) { opt = utils.DefaultOption; } 456 | if (!utils.isValidObject(obj)) 457 | return null; 458 | opt = utils.validateOptions(opt); 459 | var res = {}; 460 | Object.keys(obj).forEach(function (key) { 461 | var value = obj[key]; 462 | var nkey = jsPascalcase.default(key); 463 | if (opt.recursive) { 464 | if (utils.isValidObject(value)) { 465 | if (!utils.belongToTypes(value, opt.keepTypesOnRecursion)) { 466 | value = pascalKeys(value, opt); 467 | } 468 | } 469 | else if (opt.recursiveInArray && utils.isArrayObject(value)) { 470 | value = __spreadArrays(value).map(function (v) { 471 | var ret = v; 472 | if (utils.isValidObject(v)) { 473 | // object in array 474 | if (!utils.belongToTypes(ret, opt.keepTypesOnRecursion)) { 475 | ret = pascalKeys(v, opt); 476 | } 477 | } 478 | else if (utils.isArrayObject(v)) { 479 | // array in array 480 | // workaround by using an object holding array value 481 | var temp = pascalKeys({ key: v }, opt); 482 | ret = temp.key; 483 | } 484 | return ret; 485 | }); 486 | } 487 | } 488 | res[nkey] = value; 489 | }); 490 | return res; 491 | } 492 | exports.default = pascalKeys; 493 | }); 494 | 495 | unwrapExports(pascalcaseKeysObject); 496 | 497 | var kebabcaseKeysObject = createCommonjsModule(function (module, exports) { 498 | var __spreadArrays = (commonjsGlobal && commonjsGlobal.__spreadArrays) || function () { 499 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 500 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 501 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 502 | r[k] = a[j]; 503 | return r; 504 | }; 505 | Object.defineProperty(exports, "__esModule", { value: true }); 506 | 507 | 508 | /** 509 | * Convert string keys in an object to kebab-case format. 510 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 511 | * @param opt: (optional) Options parameter, default is non-recursive. 512 | */ 513 | function kebabKeys(obj, opt) { 514 | if (opt === void 0) { opt = utils.DefaultOption; } 515 | if (!utils.isValidObject(obj)) 516 | return null; 517 | opt = utils.validateOptions(opt); 518 | var res = {}; 519 | Object.keys(obj).forEach(function (key) { 520 | var value = obj[key]; 521 | var nkey = jsKebabcase.default(key); 522 | if (opt.recursive) { 523 | if (utils.isValidObject(value)) { 524 | if (!utils.belongToTypes(value, opt.keepTypesOnRecursion)) { 525 | value = kebabKeys(value, opt); 526 | } 527 | } 528 | else if (opt.recursiveInArray && utils.isArrayObject(value)) { 529 | value = __spreadArrays(value).map(function (v) { 530 | var ret = v; 531 | if (utils.isValidObject(v)) { 532 | // object in array 533 | if (!utils.belongToTypes(ret, opt.keepTypesOnRecursion)) { 534 | ret = kebabKeys(v, opt); 535 | } 536 | } 537 | else if (utils.isArrayObject(v)) { 538 | // array in array 539 | // workaround by using an object holding array value 540 | var temp = kebabKeys({ key: v }, opt); 541 | ret = temp.key; 542 | } 543 | return ret; 544 | }); 545 | } 546 | } 547 | res[nkey] = value; 548 | }); 549 | return res; 550 | } 551 | exports.default = kebabKeys; 552 | }); 553 | 554 | unwrapExports(kebabcaseKeysObject); 555 | 556 | var lib = createCommonjsModule(function (module, exports) { 557 | /** 558 | * Author: https://github.com/huynhsamha 559 | * Github: https://github.com/huynhsamha/js-convert-case 560 | * NPM Package: https://www.npmjs.com/package/js-convert-case 561 | */ 562 | Object.defineProperty(exports, "__esModule", { value: true }); 563 | exports.kebabKeys = exports.pascalKeys = exports.snakeKeys = exports.camelKeys = exports.upperKeys = exports.lowerKeys = exports.toLowerCase = exports.toUpperCase = exports.toKebabCase = exports.toHeaderCase = exports.toSentenceCase = exports.toTextCase = exports.toPathCase = exports.toDotCase = exports.toPascalCase = exports.toSnakeCase = exports.toCamelCase = void 0; 564 | 565 | exports.toCamelCase = jsCamelcase.default; 566 | 567 | exports.toSnakeCase = jsSnakecase.default; 568 | 569 | exports.toPascalCase = jsPascalcase.default; 570 | 571 | exports.toDotCase = jsDotcase.default; 572 | 573 | exports.toPathCase = jsPathcase.default; 574 | 575 | exports.toTextCase = jsTextcase.default; 576 | 577 | exports.toSentenceCase = jsSentencecase.default; 578 | 579 | exports.toHeaderCase = jsHeadercase.default; 580 | 581 | exports.toKebabCase = jsKebabcase.default; 582 | 583 | exports.lowerKeys = lowercaseKeysObject.default; 584 | 585 | exports.upperKeys = uppercaseKeysObject.default; 586 | 587 | exports.camelKeys = camelcaseKeysObject.default; 588 | 589 | exports.snakeKeys = snakecaseKeysObject.default; 590 | 591 | exports.pascalKeys = pascalcaseKeysObject.default; 592 | 593 | exports.kebabKeys = kebabcaseKeysObject.default; 594 | var toLowerCase = function (str) { return String(str || '').toLowerCase(); }; 595 | exports.toLowerCase = toLowerCase; 596 | var toUpperCase = function (str) { return String(str || '').toUpperCase(); }; 597 | exports.toUpperCase = toUpperCase; 598 | var jsConvert = { 599 | toCamelCase: jsCamelcase.default, 600 | toSnakeCase: jsSnakecase.default, 601 | toPascalCase: jsPascalcase.default, 602 | toDotCase: jsDotcase.default, 603 | toPathCase: jsPathcase.default, 604 | toTextCase: jsTextcase.default, 605 | toSentenceCase: jsSentencecase.default, 606 | toHeaderCase: jsHeadercase.default, 607 | toKebabCase: jsKebabcase.default, 608 | toUpperCase: toUpperCase, 609 | toLowerCase: toLowerCase, 610 | lowerKeys: lowercaseKeysObject.default, 611 | upperKeys: uppercaseKeysObject.default, 612 | camelKeys: camelcaseKeysObject.default, 613 | snakeKeys: snakecaseKeysObject.default, 614 | pascalKeys: pascalcaseKeysObject.default, 615 | kebabKeys: kebabcaseKeysObject.default 616 | }; 617 | exports.default = jsConvert; 618 | }); 619 | 620 | unwrapExports(lib); 621 | var lib_1 = lib.kebabKeys; 622 | var lib_2 = lib.pascalKeys; 623 | var lib_3 = lib.snakeKeys; 624 | var lib_4 = lib.camelKeys; 625 | var lib_5 = lib.upperKeys; 626 | var lib_6 = lib.lowerKeys; 627 | var lib_7 = lib.toLowerCase; 628 | var lib_8 = lib.toUpperCase; 629 | var lib_9 = lib.toKebabCase; 630 | var lib_10 = lib.toHeaderCase; 631 | var lib_11 = lib.toSentenceCase; 632 | var lib_12 = lib.toTextCase; 633 | var lib_13 = lib.toPathCase; 634 | var lib_14 = lib.toDotCase; 635 | var lib_15 = lib.toPascalCase; 636 | var lib_16 = lib.toSnakeCase; 637 | var lib_17 = lib.toCamelCase; 638 | 639 | var jsConvertCase = lib; 640 | 641 | return jsConvertCase; 642 | 643 | }()); 644 | -------------------------------------------------------------------------------- /dist/js-convert-case.min.js: -------------------------------------------------------------------------------- 1 | var jsConvert=function(){'use strict';function a(a){return a&&a.__esModule&&Object.prototype.hasOwnProperty.call(a,"default")?a["default"]:a}function b(a,b){return b={exports:{}},a(b,b.exports),b.exports}var c="undefined"==typeof globalThis?"undefined"==typeof window?"undefined"==typeof global?"undefined"==typeof self?{}:self:global:window:globalThis,d=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/[^A-Za-z0-9]+/g,"$").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"$"+a}).toLowerCase().replace(/(\$)(\w)/g,function(c,d,a){return a.toUpperCase()}):""}});a(d);var e=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g,"_").toLowerCase():""}});a(e);var f=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"$").replace(/[^A-Za-z0-9]+/g,"$").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"$"+a}).toLowerCase().replace(/(\$)(\w?)/g,function(c,d,a){return a.toUpperCase()}):""}});a(f);var g=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g,".").toLowerCase():""}});a(g);var h=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g,"/").toLowerCase():""}});a(h);var i=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g," ").toLowerCase():""}});a(i);var j=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){if(void 0===a&&(a=""),!a)return"";var b=(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g," ").toLowerCase();return b.charAt(0).toUpperCase()+b.slice(1)}});a(j);var k=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g," ").toLowerCase().replace(/( ?)(\w+)( ?)/g,function(d,e,a,b){return e+a.charAt(0).toUpperCase()+a.slice(1)+b}):""}});a(k);var l=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.default=function(a){return void 0===a&&(a=""),a?(a+"").replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g,"").replace(/([a-z])([A-Z])/g,function(c,d,a){return d+"_"+a.toLowerCase()}).replace(/[^A-Za-z0-9]+|_+/g,"-").toLowerCase():""}});a(l);var m=b(function(a,b){Object.defineProperty(b,"__esModule",{value:!0}),b.belongToTypes=b.isValidObject=b.isArrayObject=b.validateOptions=b.DefaultOption=void 0,b.DefaultOption={recursive:!1,recursiveInArray:!1,keepTypesOnRecursion:[]},b.validateOptions=function(a){return void 0===a&&(a=b.DefaultOption),null==a.recursive?a=b.DefaultOption:null==a.recursiveInArray&&(a.recursiveInArray=!1),a},b.isArrayObject=function(a){return null!=a&&Array.isArray(a)},b.isValidObject=function(a){return null!=a&&"object"==typeof a&&!Array.isArray(a)},b.belongToTypes=function(a,b){return(b||[]).some(function(b){return a instanceof b})}});a(m);var n=m.belongToTypes,o=m.isValidObject,p=m.isArrayObject,q=m.validateOptions,r=m.DefaultOption,s=b(function(a,b){function d(a,b){if(void 0===b&&(b=m.DefaultOption),!m.isValidObject(a))return null;b=m.validateOptions(b);var c={};return Object.keys(a).forEach(function(f){var g=a[f],h=f.toLowerCase();b.recursive&&(m.isValidObject(g)?!m.belongToTypes(g,b.keepTypesOnRecursion)&&(g=d(g,b)):b.recursiveInArray&&m.isArrayObject(g)&&(g=e(g).map(function(a){var c=a;if(m.isValidObject(a))m.belongToTypes(c,b.keepTypesOnRecursion)||(c=d(a,b));else if(m.isArrayObject(a)){var e=d({key:a},b);c=e.key}return c}))),c[h]=g}),c}var e=c&&c.__spreadArrays||function(){for(var b=0,c=0,d=arguments.length;c https://github.com/huynhsamha 3 | * Github: https://github.com/huynhsamha/js-convert-case 4 | * NPM Package: https://www.npmjs.com/package/js-convert-case 5 | */ 6 | import toCamelCase from './modules/js-camelcase'; 7 | import toSnakeCase from './modules/js-snakecase'; 8 | import toPascalCase from './modules/js-pascalcase'; 9 | import toDotCase from './modules/js-dotcase'; 10 | import toPathCase from './modules/js-pathcase'; 11 | import toTextCase from './modules/js-textcase'; 12 | import toSentenceCase from './modules/js-sentencecase'; 13 | import toHeaderCase from './modules/js-headercase'; 14 | import toKebabCase from './modules/js-kebabcase'; 15 | import lowerKeys from './modules/extends/lowercase-keys-object'; 16 | import upperKeys from './modules/extends/uppercase-keys-object'; 17 | import camelKeys from './modules/extends/camelcase-keys-object'; 18 | import snakeKeys from './modules/extends/snakecase-keys-object'; 19 | import pascalKeys from './modules/extends/pascalcase-keys-object'; 20 | import kebabKeys from './modules/extends/kebabcase-keys-object'; 21 | declare const toLowerCase: (str: string) => string; 22 | declare const toUpperCase: (str: string) => string; 23 | declare const jsConvert: { 24 | toCamelCase: typeof toCamelCase; 25 | toSnakeCase: typeof toSnakeCase; 26 | toPascalCase: typeof toPascalCase; 27 | toDotCase: typeof toDotCase; 28 | toPathCase: typeof toPathCase; 29 | toTextCase: typeof toTextCase; 30 | toSentenceCase: typeof toSentenceCase; 31 | toHeaderCase: typeof toHeaderCase; 32 | toKebabCase: typeof toKebabCase; 33 | toUpperCase: (str: string) => string; 34 | toLowerCase: (str: string) => string; 35 | lowerKeys: typeof lowerKeys; 36 | upperKeys: typeof upperKeys; 37 | camelKeys: typeof camelKeys; 38 | snakeKeys: typeof snakeKeys; 39 | pascalKeys: typeof pascalKeys; 40 | kebabKeys: typeof kebabKeys; 41 | }; 42 | export { toCamelCase, toSnakeCase, toPascalCase, toDotCase, toPathCase, toTextCase, toSentenceCase, toHeaderCase, toKebabCase, toUpperCase, toLowerCase, lowerKeys, upperKeys, camelKeys, snakeKeys, pascalKeys, kebabKeys }; 43 | export default jsConvert; 44 | -------------------------------------------------------------------------------- /lib/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | /** 3 | * Author: https://github.com/huynhsamha 4 | * Github: https://github.com/huynhsamha/js-convert-case 5 | * NPM Package: https://www.npmjs.com/package/js-convert-case 6 | */ 7 | Object.defineProperty(exports, "__esModule", { value: true }); 8 | exports.kebabKeys = exports.pascalKeys = exports.snakeKeys = exports.camelKeys = exports.upperKeys = exports.lowerKeys = exports.toLowerCase = exports.toUpperCase = exports.toKebabCase = exports.toHeaderCase = exports.toSentenceCase = exports.toTextCase = exports.toPathCase = exports.toDotCase = exports.toPascalCase = exports.toSnakeCase = exports.toCamelCase = void 0; 9 | var js_camelcase_1 = require("./modules/js-camelcase"); 10 | exports.toCamelCase = js_camelcase_1.default; 11 | var js_snakecase_1 = require("./modules/js-snakecase"); 12 | exports.toSnakeCase = js_snakecase_1.default; 13 | var js_pascalcase_1 = require("./modules/js-pascalcase"); 14 | exports.toPascalCase = js_pascalcase_1.default; 15 | var js_dotcase_1 = require("./modules/js-dotcase"); 16 | exports.toDotCase = js_dotcase_1.default; 17 | var js_pathcase_1 = require("./modules/js-pathcase"); 18 | exports.toPathCase = js_pathcase_1.default; 19 | var js_textcase_1 = require("./modules/js-textcase"); 20 | exports.toTextCase = js_textcase_1.default; 21 | var js_sentencecase_1 = require("./modules/js-sentencecase"); 22 | exports.toSentenceCase = js_sentencecase_1.default; 23 | var js_headercase_1 = require("./modules/js-headercase"); 24 | exports.toHeaderCase = js_headercase_1.default; 25 | var js_kebabcase_1 = require("./modules/js-kebabcase"); 26 | exports.toKebabCase = js_kebabcase_1.default; 27 | var lowercase_keys_object_1 = require("./modules/extends/lowercase-keys-object"); 28 | exports.lowerKeys = lowercase_keys_object_1.default; 29 | var uppercase_keys_object_1 = require("./modules/extends/uppercase-keys-object"); 30 | exports.upperKeys = uppercase_keys_object_1.default; 31 | var camelcase_keys_object_1 = require("./modules/extends/camelcase-keys-object"); 32 | exports.camelKeys = camelcase_keys_object_1.default; 33 | var snakecase_keys_object_1 = require("./modules/extends/snakecase-keys-object"); 34 | exports.snakeKeys = snakecase_keys_object_1.default; 35 | var pascalcase_keys_object_1 = require("./modules/extends/pascalcase-keys-object"); 36 | exports.pascalKeys = pascalcase_keys_object_1.default; 37 | var kebabcase_keys_object_1 = require("./modules/extends/kebabcase-keys-object"); 38 | exports.kebabKeys = kebabcase_keys_object_1.default; 39 | var toLowerCase = function (str) { return String(str || '').toLowerCase(); }; 40 | exports.toLowerCase = toLowerCase; 41 | var toUpperCase = function (str) { return String(str || '').toUpperCase(); }; 42 | exports.toUpperCase = toUpperCase; 43 | var jsConvert = { 44 | toCamelCase: js_camelcase_1.default, 45 | toSnakeCase: js_snakecase_1.default, 46 | toPascalCase: js_pascalcase_1.default, 47 | toDotCase: js_dotcase_1.default, 48 | toPathCase: js_pathcase_1.default, 49 | toTextCase: js_textcase_1.default, 50 | toSentenceCase: js_sentencecase_1.default, 51 | toHeaderCase: js_headercase_1.default, 52 | toKebabCase: js_kebabcase_1.default, 53 | toUpperCase: toUpperCase, 54 | toLowerCase: toLowerCase, 55 | lowerKeys: lowercase_keys_object_1.default, 56 | upperKeys: uppercase_keys_object_1.default, 57 | camelKeys: camelcase_keys_object_1.default, 58 | snakeKeys: snakecase_keys_object_1.default, 59 | pascalKeys: pascalcase_keys_object_1.default, 60 | kebabKeys: kebabcase_keys_object_1.default 61 | }; 62 | exports.default = jsConvert; 63 | -------------------------------------------------------------------------------- /lib/modules/extends/camelcase-keys-object/index.d.ts: -------------------------------------------------------------------------------- 1 | import { Options } from '../utils'; 2 | /** 3 | * Convert string keys in an object to camelCase format. 4 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 5 | * @param opt: (optional) Options parameter, default is non-recursive. 6 | */ 7 | export default function camelKeys(obj: any, opt?: Options): object | null; 8 | -------------------------------------------------------------------------------- /lib/modules/extends/camelcase-keys-object/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __spreadArrays = (this && this.__spreadArrays) || function () { 3 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 4 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 5 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 6 | r[k] = a[j]; 7 | return r; 8 | }; 9 | Object.defineProperty(exports, "__esModule", { value: true }); 10 | var utils_1 = require("../utils"); 11 | var js_camelcase_1 = require("../../js-camelcase"); 12 | /** 13 | * Convert string keys in an object to camelCase format. 14 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 15 | * @param opt: (optional) Options parameter, default is non-recursive. 16 | */ 17 | function camelKeys(obj, opt) { 18 | if (opt === void 0) { opt = utils_1.DefaultOption; } 19 | if (!utils_1.isValidObject(obj)) 20 | return null; 21 | opt = utils_1.validateOptions(opt); 22 | var res = {}; 23 | Object.keys(obj).forEach(function (key) { 24 | var value = obj[key]; 25 | var nkey = js_camelcase_1.default(key); 26 | if (opt.recursive) { 27 | if (utils_1.isValidObject(value)) { 28 | if (!utils_1.belongToTypes(value, opt.keepTypesOnRecursion)) { 29 | value = camelKeys(value, opt); 30 | } 31 | } 32 | else if (opt.recursiveInArray && utils_1.isArrayObject(value)) { 33 | value = __spreadArrays(value).map(function (v) { 34 | var ret = v; 35 | if (utils_1.isValidObject(v)) { 36 | // object in array 37 | if (!utils_1.belongToTypes(ret, opt.keepTypesOnRecursion)) { 38 | ret = camelKeys(v, opt); 39 | } 40 | } 41 | else if (utils_1.isArrayObject(v)) { 42 | // array in array 43 | // workaround by using an object holding array value 44 | var temp = camelKeys({ key: v }, opt); 45 | ret = temp.key; 46 | } 47 | return ret; 48 | }); 49 | } 50 | } 51 | res[nkey] = value; 52 | }); 53 | return res; 54 | } 55 | exports.default = camelKeys; 56 | -------------------------------------------------------------------------------- /lib/modules/extends/kebabcase-keys-object/index.d.ts: -------------------------------------------------------------------------------- 1 | import { Options } from '../utils'; 2 | /** 3 | * Convert string keys in an object to kebab-case format. 4 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 5 | * @param opt: (optional) Options parameter, default is non-recursive. 6 | */ 7 | export default function kebabKeys(obj: any, opt?: Options): object | null; 8 | -------------------------------------------------------------------------------- /lib/modules/extends/kebabcase-keys-object/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __spreadArrays = (this && this.__spreadArrays) || function () { 3 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 4 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 5 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 6 | r[k] = a[j]; 7 | return r; 8 | }; 9 | Object.defineProperty(exports, "__esModule", { value: true }); 10 | var utils_1 = require("../utils"); 11 | var js_kebabcase_1 = require("../../js-kebabcase"); 12 | /** 13 | * Convert string keys in an object to kebab-case format. 14 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 15 | * @param opt: (optional) Options parameter, default is non-recursive. 16 | */ 17 | function kebabKeys(obj, opt) { 18 | if (opt === void 0) { opt = utils_1.DefaultOption; } 19 | if (!utils_1.isValidObject(obj)) 20 | return null; 21 | opt = utils_1.validateOptions(opt); 22 | var res = {}; 23 | Object.keys(obj).forEach(function (key) { 24 | var value = obj[key]; 25 | var nkey = js_kebabcase_1.default(key); 26 | if (opt.recursive) { 27 | if (utils_1.isValidObject(value)) { 28 | if (!utils_1.belongToTypes(value, opt.keepTypesOnRecursion)) { 29 | value = kebabKeys(value, opt); 30 | } 31 | } 32 | else if (opt.recursiveInArray && utils_1.isArrayObject(value)) { 33 | value = __spreadArrays(value).map(function (v) { 34 | var ret = v; 35 | if (utils_1.isValidObject(v)) { 36 | // object in array 37 | if (!utils_1.belongToTypes(ret, opt.keepTypesOnRecursion)) { 38 | ret = kebabKeys(v, opt); 39 | } 40 | } 41 | else if (utils_1.isArrayObject(v)) { 42 | // array in array 43 | // workaround by using an object holding array value 44 | var temp = kebabKeys({ key: v }, opt); 45 | ret = temp.key; 46 | } 47 | return ret; 48 | }); 49 | } 50 | } 51 | res[nkey] = value; 52 | }); 53 | return res; 54 | } 55 | exports.default = kebabKeys; 56 | -------------------------------------------------------------------------------- /lib/modules/extends/lowercase-keys-object/index.d.ts: -------------------------------------------------------------------------------- 1 | import { Options } from '../utils'; 2 | /** 3 | * Convert string keys in an object to lowercase format. 4 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 5 | * @param opt: (optional) Options parameter, default is non-recursive. 6 | */ 7 | export default function lowerKeys(obj: any, opt?: Options): object | null; 8 | -------------------------------------------------------------------------------- /lib/modules/extends/lowercase-keys-object/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __spreadArrays = (this && this.__spreadArrays) || function () { 3 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 4 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 5 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 6 | r[k] = a[j]; 7 | return r; 8 | }; 9 | Object.defineProperty(exports, "__esModule", { value: true }); 10 | var utils_1 = require("../utils"); 11 | /** 12 | * Convert string keys in an object to lowercase format. 13 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 14 | * @param opt: (optional) Options parameter, default is non-recursive. 15 | */ 16 | function lowerKeys(obj, opt) { 17 | if (opt === void 0) { opt = utils_1.DefaultOption; } 18 | if (!utils_1.isValidObject(obj)) 19 | return null; 20 | opt = utils_1.validateOptions(opt); 21 | var res = {}; 22 | Object.keys(obj).forEach(function (key) { 23 | var value = obj[key]; 24 | var nkey = key.toLowerCase(); 25 | if (opt.recursive) { 26 | if (utils_1.isValidObject(value)) { 27 | if (!utils_1.belongToTypes(value, opt.keepTypesOnRecursion)) { 28 | value = lowerKeys(value, opt); 29 | } 30 | } 31 | else if (opt.recursiveInArray && utils_1.isArrayObject(value)) { 32 | value = __spreadArrays(value).map(function (v) { 33 | var ret = v; 34 | if (utils_1.isValidObject(v)) { 35 | // object in array 36 | if (!utils_1.belongToTypes(ret, opt.keepTypesOnRecursion)) { 37 | ret = lowerKeys(v, opt); 38 | } 39 | } 40 | else if (utils_1.isArrayObject(v)) { 41 | // array in array 42 | // workaround by using an object holding array value 43 | var temp = lowerKeys({ key: v }, opt); 44 | ret = temp.key; 45 | } 46 | return ret; 47 | }); 48 | } 49 | } 50 | res[nkey] = value; 51 | }); 52 | return res; 53 | } 54 | exports.default = lowerKeys; 55 | -------------------------------------------------------------------------------- /lib/modules/extends/pascalcase-keys-object/index.d.ts: -------------------------------------------------------------------------------- 1 | import { Options } from '../utils'; 2 | /** 3 | * Convert string keys in an object to PascalCase format. 4 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 5 | * @param opt: (optional) Options parameter, default is non-recursive. 6 | */ 7 | export default function pascalKeys(obj: any, opt?: Options): object | null; 8 | -------------------------------------------------------------------------------- /lib/modules/extends/pascalcase-keys-object/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __spreadArrays = (this && this.__spreadArrays) || function () { 3 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 4 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 5 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 6 | r[k] = a[j]; 7 | return r; 8 | }; 9 | Object.defineProperty(exports, "__esModule", { value: true }); 10 | var utils_1 = require("../utils"); 11 | var js_pascalcase_1 = require("../../js-pascalcase"); 12 | /** 13 | * Convert string keys in an object to PascalCase format. 14 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 15 | * @param opt: (optional) Options parameter, default is non-recursive. 16 | */ 17 | function pascalKeys(obj, opt) { 18 | if (opt === void 0) { opt = utils_1.DefaultOption; } 19 | if (!utils_1.isValidObject(obj)) 20 | return null; 21 | opt = utils_1.validateOptions(opt); 22 | var res = {}; 23 | Object.keys(obj).forEach(function (key) { 24 | var value = obj[key]; 25 | var nkey = js_pascalcase_1.default(key); 26 | if (opt.recursive) { 27 | if (utils_1.isValidObject(value)) { 28 | if (!utils_1.belongToTypes(value, opt.keepTypesOnRecursion)) { 29 | value = pascalKeys(value, opt); 30 | } 31 | } 32 | else if (opt.recursiveInArray && utils_1.isArrayObject(value)) { 33 | value = __spreadArrays(value).map(function (v) { 34 | var ret = v; 35 | if (utils_1.isValidObject(v)) { 36 | // object in array 37 | if (!utils_1.belongToTypes(ret, opt.keepTypesOnRecursion)) { 38 | ret = pascalKeys(v, opt); 39 | } 40 | } 41 | else if (utils_1.isArrayObject(v)) { 42 | // array in array 43 | // workaround by using an object holding array value 44 | var temp = pascalKeys({ key: v }, opt); 45 | ret = temp.key; 46 | } 47 | return ret; 48 | }); 49 | } 50 | } 51 | res[nkey] = value; 52 | }); 53 | return res; 54 | } 55 | exports.default = pascalKeys; 56 | -------------------------------------------------------------------------------- /lib/modules/extends/snakecase-keys-object/index.d.ts: -------------------------------------------------------------------------------- 1 | import { Options } from '../utils'; 2 | /** 3 | * Convert string keys in an object to snake_case format. 4 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 5 | * @param opt: (optional) Options parameter, default is non-recursive. 6 | */ 7 | export default function snakeKeys(obj: any, opt?: Options): object | null; 8 | -------------------------------------------------------------------------------- /lib/modules/extends/snakecase-keys-object/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __spreadArrays = (this && this.__spreadArrays) || function () { 3 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 4 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 5 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 6 | r[k] = a[j]; 7 | return r; 8 | }; 9 | Object.defineProperty(exports, "__esModule", { value: true }); 10 | var utils_1 = require("../utils"); 11 | var js_snakecase_1 = require("../../js-snakecase"); 12 | /** 13 | * Convert string keys in an object to snake_case format. 14 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 15 | * @param opt: (optional) Options parameter, default is non-recursive. 16 | */ 17 | function snakeKeys(obj, opt) { 18 | if (opt === void 0) { opt = utils_1.DefaultOption; } 19 | if (!utils_1.isValidObject(obj)) 20 | return null; 21 | opt = utils_1.validateOptions(opt); 22 | var res = {}; 23 | Object.keys(obj).forEach(function (key) { 24 | var value = obj[key]; 25 | var nkey = js_snakecase_1.default(key); 26 | if (opt.recursive) { 27 | if (utils_1.isValidObject(value)) { 28 | if (!utils_1.belongToTypes(value, opt.keepTypesOnRecursion)) { 29 | value = snakeKeys(value, opt); 30 | } 31 | } 32 | else if (opt.recursiveInArray && utils_1.isArrayObject(value)) { 33 | value = __spreadArrays(value).map(function (v) { 34 | var ret = v; 35 | if (utils_1.isValidObject(v)) { 36 | // object in array 37 | if (!utils_1.belongToTypes(ret, opt.keepTypesOnRecursion)) { 38 | ret = snakeKeys(v, opt); 39 | } 40 | } 41 | else if (utils_1.isArrayObject(v)) { 42 | // array in array 43 | // workaround by using an object holding array value 44 | var temp = snakeKeys({ key: v }, opt); 45 | ret = temp.key; 46 | } 47 | return ret; 48 | }); 49 | } 50 | } 51 | res[nkey] = value; 52 | }); 53 | return res; 54 | } 55 | exports.default = snakeKeys; 56 | -------------------------------------------------------------------------------- /lib/modules/extends/uppercase-keys-object/index.d.ts: -------------------------------------------------------------------------------- 1 | import { Options } from '../utils'; 2 | /** 3 | * Convert string keys in an object to UPPERCASE format. 4 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 5 | * @param opt: (optional) Options parameter, default is non-recursive. 6 | */ 7 | export default function upperKeys(obj: any, opt?: Options): object | null; 8 | -------------------------------------------------------------------------------- /lib/modules/extends/uppercase-keys-object/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | var __spreadArrays = (this && this.__spreadArrays) || function () { 3 | for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; 4 | for (var r = Array(s), k = 0, i = 0; i < il; i++) 5 | for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) 6 | r[k] = a[j]; 7 | return r; 8 | }; 9 | Object.defineProperty(exports, "__esModule", { value: true }); 10 | var utils_1 = require("../utils"); 11 | /** 12 | * Convert string keys in an object to UPPERCASE format. 13 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 14 | * @param opt: (optional) Options parameter, default is non-recursive. 15 | */ 16 | function upperKeys(obj, opt) { 17 | if (opt === void 0) { opt = utils_1.DefaultOption; } 18 | if (!utils_1.isValidObject(obj)) 19 | return null; 20 | opt = utils_1.validateOptions(opt); 21 | var res = {}; 22 | Object.keys(obj).forEach(function (key) { 23 | var value = obj[key]; 24 | var nkey = key.toUpperCase(); 25 | if (opt.recursive) { 26 | if (utils_1.isValidObject(value)) { 27 | if (!utils_1.belongToTypes(value, opt.keepTypesOnRecursion)) { 28 | value = upperKeys(value, opt); 29 | } 30 | } 31 | else if (opt.recursiveInArray && utils_1.isArrayObject(value)) { 32 | value = __spreadArrays(value).map(function (v) { 33 | var ret = v; 34 | if (utils_1.isValidObject(v)) { 35 | // object in array 36 | if (!utils_1.belongToTypes(ret, opt.keepTypesOnRecursion)) { 37 | ret = upperKeys(v, opt); 38 | } 39 | } 40 | else if (utils_1.isArrayObject(v)) { 41 | // array in array 42 | // workaround by using an object holding array value 43 | var temp = upperKeys({ key: v }, opt); 44 | ret = temp.key; 45 | } 46 | return ret; 47 | }); 48 | } 49 | } 50 | res[nkey] = value; 51 | }); 52 | return res; 53 | } 54 | exports.default = upperKeys; 55 | -------------------------------------------------------------------------------- /lib/modules/extends/utils.d.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Options parameter for convert function 3 | * 4 | * @param recursive: recursive if value of subkey is an object that is not an array 5 | * @param recursiveInArray: recursive if ${recursive} is `true` and value of subkey 6 | * is an array. All elements in array (value of subkey) will be recursive. 7 | * If ${recursiveInArray} is not set, default is `false`. 8 | * @param keepTypesOnRecursion: list of types will be keep value on recursion. 9 | * Example Date, RegExp. These types will be right-hand side of 'instanceof' operator. 10 | */ 11 | export interface Options { 12 | recursive: boolean; 13 | recursiveInArray?: boolean; 14 | keepTypesOnRecursion?: any[]; 15 | } 16 | /** 17 | * Default options for convert function. This option is not recursive. 18 | */ 19 | export declare const DefaultOption: Options; 20 | export declare const validateOptions: (opt?: Options) => Options; 21 | export declare const isArrayObject: (obj: any) => boolean; 22 | export declare const isValidObject: (obj: any) => boolean; 23 | export declare const belongToTypes: (obj: any, types?: any[] | undefined) => boolean; 24 | -------------------------------------------------------------------------------- /lib/modules/extends/utils.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | exports.belongToTypes = exports.isValidObject = exports.isArrayObject = exports.validateOptions = exports.DefaultOption = void 0; 4 | /** 5 | * Default options for convert function. This option is not recursive. 6 | */ 7 | exports.DefaultOption = { 8 | recursive: false, 9 | recursiveInArray: false, 10 | keepTypesOnRecursion: [] 11 | }; 12 | exports.validateOptions = function (opt) { 13 | if (opt === void 0) { opt = exports.DefaultOption; } 14 | if (opt.recursive == null) { 15 | opt = exports.DefaultOption; 16 | } 17 | else if (opt.recursiveInArray == null) { 18 | opt.recursiveInArray = false; 19 | } 20 | return opt; 21 | }; 22 | exports.isArrayObject = function (obj) { return obj != null && Array.isArray(obj); }; 23 | exports.isValidObject = function (obj) { return obj != null && typeof obj === 'object' && !Array.isArray(obj); }; 24 | exports.belongToTypes = function (obj, types) { return (types || []).some(function (Type) { return obj instanceof Type; }); }; 25 | -------------------------------------------------------------------------------- /lib/modules/js-camelcase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toCamelCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-camelcase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toCamelCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/[^A-Za-z0-9]+/g, '$') 10 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "$" + b; }) 11 | .toLowerCase() 12 | .replace(/(\$)(\w)/g, function (m, a, b) { return b.toUpperCase(); }); 13 | } 14 | exports.default = toCamelCase; 15 | -------------------------------------------------------------------------------- /lib/modules/js-dotcase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toDotCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-dotcase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toDotCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, '.') 11 | .toLowerCase(); 12 | } 13 | exports.default = toDotCase; 14 | -------------------------------------------------------------------------------- /lib/modules/js-headercase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toHeaderCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-headercase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toHeaderCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 11 | .toLowerCase() 12 | .replace(/( ?)(\w+)( ?)/g, function (m, a, b, c) { return a + b.charAt(0).toUpperCase() + b.slice(1) + c; }); 13 | } 14 | exports.default = toHeaderCase; 15 | -------------------------------------------------------------------------------- /lib/modules/js-kebabcase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toKebabCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-kebabcase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toKebabCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, '-') 11 | .toLowerCase(); 12 | } 13 | exports.default = toKebabCase; 14 | -------------------------------------------------------------------------------- /lib/modules/js-pascalcase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toPascalCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-pascalcase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toPascalCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '$') 9 | .replace(/[^A-Za-z0-9]+/g, '$') 10 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "$" + b; }) 11 | .toLowerCase() 12 | .replace(/(\$)(\w?)/g, function (m, a, b) { return b.toUpperCase(); }); 13 | } 14 | exports.default = toPascalCase; 15 | -------------------------------------------------------------------------------- /lib/modules/js-pathcase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toPathCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-pathcase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toPathCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, '/') 11 | .toLowerCase(); 12 | } 13 | exports.default = toPathCase; 14 | -------------------------------------------------------------------------------- /lib/modules/js-sentencecase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toSentenceCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-sentencecase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toSentenceCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | var textcase = String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + "_" + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 11 | .toLowerCase(); 12 | return textcase.charAt(0).toUpperCase() + textcase.slice(1); 13 | } 14 | exports.default = toSentenceCase; 15 | -------------------------------------------------------------------------------- /lib/modules/js-snakecase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toSnakeCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-snakecase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toSnakeCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + '_' + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, '_') 11 | .toLowerCase(); 12 | } 13 | exports.default = toSnakeCase; 14 | -------------------------------------------------------------------------------- /lib/modules/js-textcase/index.d.ts: -------------------------------------------------------------------------------- 1 | export default function toTextCase(str?: string): string; 2 | -------------------------------------------------------------------------------- /lib/modules/js-textcase/index.js: -------------------------------------------------------------------------------- 1 | "use strict"; 2 | Object.defineProperty(exports, "__esModule", { value: true }); 3 | function toTextCase(str) { 4 | if (str === void 0) { str = ''; } 5 | if (!str) 6 | return ''; 7 | return String(str) 8 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 9 | .replace(/([a-z])([A-Z])/g, function (m, a, b) { return a + '_' + b.toLowerCase(); }) 10 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 11 | .toLowerCase(); 12 | } 13 | exports.default = toTextCase; 14 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "js-convert-case", 3 | "version": "4.2.0", 4 | "description": "JavaScript Convert String and Keys of Object between cases (camelCase, snake_case, PascalCase, dot.case, path/case, text case, Sentence case, Header Case, UPPERCASE, lowercase, kebab-case). Use for both Node.JS and Browser", 5 | "scripts": { 6 | "build": "tsc", 7 | "format": "prettier --write \"src/**/*.ts\"", 8 | "lint": "tslint -p tsconfig.json", 9 | "rollup": "rollup -c", 10 | "clean": "yarn clean:node && yarn clean:browser", 11 | "dist": "yarn dist:browser", 12 | "clean:node": "rm -rf lib", 13 | "clean:browser": "rm -rf dist", 14 | "dist:node": "yarn clean:node && yarn format && yarn lint && yarn build", 15 | "dist:browser": "yarn dist:node && yarn clean:browser && yarn rollup", 16 | "build:release:binary": "./scripts/build_release_binary.sh $npm_package_version" 17 | }, 18 | "devDependencies": { 19 | "babel-eslint": "^8.2.6", 20 | "eslint": "^4.19.1", 21 | "eslint-config-airbnb": "^16.1.0", 22 | "eslint-plugin-import": "^2.13.0", 23 | "eslint-plugin-jsx-a11y": "^6.1.1", 24 | "eslint-plugin-react": "^7.10.0", 25 | "rollup": "^2.10.8", 26 | "rollup-plugin-babel-minify": "^10.0.0", 27 | "rollup-plugin-commonjs": "^10.1.0", 28 | "rollup-plugin-node-resolve": "^5.2.0", 29 | "prettier": "^2.0.5", 30 | "tslint": "^6.1.2", 31 | "tslint-config-prettier": "^1.18.0", 32 | "typescript": "^3.9.2" 33 | }, 34 | "files": [ 35 | "dist/**/*", 36 | "lib/**/*", 37 | "index.js" 38 | ], 39 | "types": "./lib/index.d.ts", 40 | "repository": { 41 | "type": "git", 42 | "url": "git+https://github.com/huynhsamha/js-convert-case.git" 43 | }, 44 | "author": { 45 | "name": "huynhsamha", 46 | "email": "huynhsamha@gmail.com", 47 | "url": "https://github.com/huynhsamha" 48 | }, 49 | "license": "MIT", 50 | "bugs": { 51 | "url": "https://github.com/huynhsamha/js-convert-case/issues" 52 | }, 53 | "homepage": "https://github.com/huynhsamha/js-convert-case", 54 | "contributors": [ 55 | "huynhsamha" 56 | ], 57 | "icon": "./docs/favicon.ico", 58 | "keywords": [ 59 | "js-convert-case", 60 | "jsConvert", 61 | "js-camelcase", 62 | "js-dotcase", 63 | "js-headercase", 64 | "js-pascalcase", 65 | "js-pathcase", 66 | "js-sentencecase", 67 | "js-snakecase", 68 | "js-textcase", 69 | "js-kebabcase", 70 | "lowercase-keys-object", 71 | "uppercase-keys-object", 72 | "snakecase-keys-object", 73 | "camelcase-keys-object", 74 | "pascalcase-keys-object", 75 | "kebabcase-keys-object" 76 | ] 77 | } 78 | -------------------------------------------------------------------------------- /rollup.config.js: -------------------------------------------------------------------------------- 1 | import path from 'path'; 2 | import resolve from 'rollup-plugin-node-resolve'; 3 | import commonjs from 'rollup-plugin-commonjs'; 4 | import minify from 'rollup-plugin-babel-minify'; 5 | 6 | const pkg = require('./package.json'); 7 | 8 | const name = 'jsConvert'; 9 | const filename = pkg.name; 10 | 11 | export default [ 12 | { 13 | input: 'index.js', 14 | output: { 15 | name, 16 | file: path.join(__dirname, `dist/${filename}.min.js`), 17 | format: 'iife' 18 | }, 19 | plugins: [ 20 | resolve(), 21 | commonjs(), 22 | minify({ comments: false }) 23 | ] 24 | }, 25 | { 26 | input: 'index.js', 27 | output: { 28 | name, 29 | file: path.join(__dirname, `dist/${filename}.js`), 30 | format: 'iife' 31 | }, 32 | plugins: [ 33 | resolve(), 34 | commonjs() 35 | ] 36 | } 37 | ]; 38 | -------------------------------------------------------------------------------- /scripts/build_release_binary.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | PACKAGE="js-convert-case" 4 | VERSION="$1" 5 | 6 | SCRIPTS=`dirname "$0"` 7 | ROOT=`dirname "$SCRIPTS"` 8 | RELEASES="$ROOT/releases" 9 | DIST="$ROOT/dist" 10 | LIB="$ROOT/lib" 11 | 12 | rm -rf "$RELEASES" 13 | 14 | echo 15 | echo "Build packge for both dist and lib..." 16 | echo 17 | 18 | DIR="$PACKAGE-$VERSION" 19 | TAR_GZ="$DIR.tar.gz" 20 | TAR="$DIR.tar" 21 | ZIP="$DIR.zip" 22 | 23 | mkdir -p "$RELEASES/$DIR" 24 | 25 | cp -R "$DIST" "$LIB" "$RELEASES/$DIR" 26 | 27 | cd "$RELEASES" 28 | 29 | echo "Make $TAR_GZ" 30 | tar -czf "$TAR_GZ" "$DIR" 31 | echo "Make $TAR" 32 | tar -cf "$TAR" "$DIR" 33 | echo "Make $ZIP" 34 | zip -rq "$ZIP" "$DIR" 35 | 36 | cd "../" 37 | echo 38 | echo "======================================" 39 | echo 40 | echo "Build packge for browser..." 41 | echo 42 | 43 | DIR="$PACKAGE-browser-$VERSION" 44 | TAR_GZ="$DIR.tar.gz" 45 | TAR="$DIR.tar" 46 | ZIP="$DIR.zip" 47 | 48 | mkdir -p "$RELEASES/$DIR" 49 | 50 | cp -R "$DIST" "$RELEASES/$DIR" 51 | 52 | cd "$RELEASES" 53 | echo "Make $TAR_GZ" 54 | tar -czf "$TAR_GZ" "$DIR" 55 | echo "Make $TAR" 56 | tar -cf "$TAR" "$DIR" 57 | echo "Make $ZIP" 58 | zip -rq "$ZIP" "$DIR" 59 | 60 | cd "../" 61 | echo 62 | echo "======================================" 63 | echo 64 | echo "Release files:" 65 | echo 66 | echo "$RELEASES/$TAR_GZ" 67 | echo "$RELEASES/$TAR" 68 | echo "$RELEASES/$ZIP" 69 | echo 70 | echo "Done" 71 | -------------------------------------------------------------------------------- /src/index.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Author: https://github.com/huynhsamha 3 | * Github: https://github.com/huynhsamha/js-convert-case 4 | * NPM Package: https://www.npmjs.com/package/js-convert-case 5 | */ 6 | 7 | import toCamelCase from './modules/js-camelcase'; 8 | import toSnakeCase from './modules/js-snakecase'; 9 | import toPascalCase from './modules/js-pascalcase'; 10 | import toDotCase from './modules/js-dotcase'; 11 | import toPathCase from './modules/js-pathcase'; 12 | import toTextCase from './modules/js-textcase'; 13 | import toSentenceCase from './modules/js-sentencecase'; 14 | import toHeaderCase from './modules/js-headercase'; 15 | import toKebabCase from './modules/js-kebabcase'; 16 | 17 | import lowerKeys from './modules/extends/lowercase-keys-object'; 18 | import upperKeys from './modules/extends/uppercase-keys-object'; 19 | import camelKeys from './modules/extends/camelcase-keys-object'; 20 | import snakeKeys from './modules/extends/snakecase-keys-object'; 21 | import pascalKeys from './modules/extends/pascalcase-keys-object'; 22 | import kebabKeys from './modules/extends/kebabcase-keys-object'; 23 | 24 | const toLowerCase = (str: string) => String(str || '').toLowerCase(); 25 | const toUpperCase = (str: string) => String(str || '').toUpperCase(); 26 | 27 | const jsConvert = { 28 | toCamelCase, 29 | toSnakeCase, 30 | toPascalCase, 31 | toDotCase, 32 | toPathCase, 33 | toTextCase, 34 | toSentenceCase, 35 | toHeaderCase, 36 | toKebabCase, 37 | toUpperCase, 38 | toLowerCase, 39 | lowerKeys, 40 | upperKeys, 41 | camelKeys, 42 | snakeKeys, 43 | pascalKeys, 44 | kebabKeys 45 | }; 46 | 47 | export { 48 | toCamelCase, 49 | toSnakeCase, 50 | toPascalCase, 51 | toDotCase, 52 | toPathCase, 53 | toTextCase, 54 | toSentenceCase, 55 | toHeaderCase, 56 | toKebabCase, 57 | toUpperCase, 58 | toLowerCase, 59 | lowerKeys, 60 | upperKeys, 61 | camelKeys, 62 | snakeKeys, 63 | pascalKeys, 64 | kebabKeys 65 | }; 66 | 67 | export default jsConvert; 68 | -------------------------------------------------------------------------------- /src/modules/extends/camelcase-keys-object/index.ts: -------------------------------------------------------------------------------- 1 | import { isValidObject, Options, DefaultOption, isArrayObject, validateOptions, belongToTypes } from '../utils'; 2 | import toCamelCase from '../../js-camelcase'; 3 | 4 | /** 5 | * Convert string keys in an object to camelCase format. 6 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 7 | * @param opt: (optional) Options parameter, default is non-recursive. 8 | */ 9 | export default function camelKeys(obj: any, opt: Options = DefaultOption): object | null { 10 | if (!isValidObject(obj)) return null; 11 | opt = validateOptions(opt); 12 | 13 | const res: any = {}; 14 | Object.keys(obj).forEach((key) => { 15 | let value = obj[key]; 16 | const nkey = toCamelCase(key); 17 | if (opt.recursive) { 18 | if (isValidObject(value)) { 19 | if (!belongToTypes(value, opt.keepTypesOnRecursion)) { 20 | value = camelKeys(value, opt); 21 | } 22 | } else if (opt.recursiveInArray && isArrayObject(value)) { 23 | value = [...value].map((v) => { 24 | let ret = v; 25 | if (isValidObject(v)) { 26 | // object in array 27 | if (!belongToTypes(ret, opt.keepTypesOnRecursion)) { 28 | ret = camelKeys(v, opt); 29 | } 30 | } else if (isArrayObject(v)) { 31 | // array in array 32 | // workaround by using an object holding array value 33 | const temp: any = camelKeys({ key: v }, opt); 34 | ret = temp.key; 35 | } 36 | return ret; 37 | }); 38 | } 39 | } 40 | res[nkey] = value; 41 | }); 42 | 43 | return res; 44 | } 45 | -------------------------------------------------------------------------------- /src/modules/extends/kebabcase-keys-object/index.ts: -------------------------------------------------------------------------------- 1 | import { isValidObject, Options, DefaultOption, isArrayObject, validateOptions, belongToTypes } from '../utils'; 2 | import toKebabCase from '../../js-kebabcase'; 3 | 4 | /** 5 | * Convert string keys in an object to kebab-case format. 6 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 7 | * @param opt: (optional) Options parameter, default is non-recursive. 8 | */ 9 | export default function kebabKeys(obj: any, opt: Options = DefaultOption): object | null { 10 | if (!isValidObject(obj)) return null; 11 | opt = validateOptions(opt); 12 | 13 | const res: any = {}; 14 | Object.keys(obj).forEach((key) => { 15 | let value = obj[key]; 16 | const nkey = toKebabCase(key); 17 | if (opt.recursive) { 18 | if (isValidObject(value)) { 19 | if (!belongToTypes(value, opt.keepTypesOnRecursion)) { 20 | value = kebabKeys(value, opt); 21 | } 22 | } else if (opt.recursiveInArray && isArrayObject(value)) { 23 | value = [...value].map((v) => { 24 | let ret = v; 25 | if (isValidObject(v)) { 26 | // object in array 27 | if (!belongToTypes(ret, opt.keepTypesOnRecursion)) { 28 | ret = kebabKeys(v, opt); 29 | } 30 | } else if (isArrayObject(v)) { 31 | // array in array 32 | // workaround by using an object holding array value 33 | const temp: any = kebabKeys({ key: v }, opt); 34 | ret = temp.key; 35 | } 36 | return ret; 37 | }); 38 | } 39 | } 40 | res[nkey] = value; 41 | }); 42 | 43 | return res; 44 | } 45 | -------------------------------------------------------------------------------- /src/modules/extends/lowercase-keys-object/index.ts: -------------------------------------------------------------------------------- 1 | import { isValidObject, Options, DefaultOption, isArrayObject, validateOptions, belongToTypes } from '../utils'; 2 | 3 | /** 4 | * Convert string keys in an object to lowercase format. 5 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 6 | * @param opt: (optional) Options parameter, default is non-recursive. 7 | */ 8 | export default function lowerKeys(obj: any, opt: Options = DefaultOption): object | null { 9 | if (!isValidObject(obj)) return null; 10 | opt = validateOptions(opt); 11 | 12 | const res: any = {}; 13 | Object.keys(obj).forEach((key) => { 14 | let value = obj[key]; 15 | const nkey = key.toLowerCase(); 16 | if (opt.recursive) { 17 | if (isValidObject(value)) { 18 | if (!belongToTypes(value, opt.keepTypesOnRecursion)) { 19 | value = lowerKeys(value, opt); 20 | } 21 | } else if (opt.recursiveInArray && isArrayObject(value)) { 22 | value = [...value].map((v) => { 23 | let ret = v; 24 | if (isValidObject(v)) { 25 | // object in array 26 | if (!belongToTypes(ret, opt.keepTypesOnRecursion)) { 27 | ret = lowerKeys(v, opt); 28 | } 29 | } else if (isArrayObject(v)) { 30 | // array in array 31 | // workaround by using an object holding array value 32 | const temp: any = lowerKeys({ key: v }, opt); 33 | ret = temp.key; 34 | } 35 | return ret; 36 | }); 37 | } 38 | } 39 | res[nkey] = value; 40 | }); 41 | 42 | return res; 43 | } 44 | -------------------------------------------------------------------------------- /src/modules/extends/pascalcase-keys-object/index.ts: -------------------------------------------------------------------------------- 1 | import { isValidObject, Options, DefaultOption, isArrayObject, validateOptions, belongToTypes } from '../utils'; 2 | import toPascalCase from '../../js-pascalcase'; 3 | 4 | /** 5 | * Convert string keys in an object to PascalCase format. 6 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 7 | * @param opt: (optional) Options parameter, default is non-recursive. 8 | */ 9 | export default function pascalKeys(obj: any, opt: Options = DefaultOption): object | null { 10 | if (!isValidObject(obj)) return null; 11 | opt = validateOptions(opt); 12 | 13 | const res: any = {}; 14 | Object.keys(obj).forEach((key) => { 15 | let value = obj[key]; 16 | const nkey = toPascalCase(key); 17 | if (opt.recursive) { 18 | if (isValidObject(value)) { 19 | if (!belongToTypes(value, opt.keepTypesOnRecursion)) { 20 | value = pascalKeys(value, opt); 21 | } 22 | } else if (opt.recursiveInArray && isArrayObject(value)) { 23 | value = [...value].map((v) => { 24 | let ret = v; 25 | if (isValidObject(v)) { 26 | // object in array 27 | if (!belongToTypes(ret, opt.keepTypesOnRecursion)) { 28 | ret = pascalKeys(v, opt); 29 | } 30 | } else if (isArrayObject(v)) { 31 | // array in array 32 | // workaround by using an object holding array value 33 | const temp: any = pascalKeys({ key: v }, opt); 34 | ret = temp.key; 35 | } 36 | return ret; 37 | }); 38 | } 39 | } 40 | res[nkey] = value; 41 | }); 42 | 43 | return res; 44 | } 45 | -------------------------------------------------------------------------------- /src/modules/extends/snakecase-keys-object/index.ts: -------------------------------------------------------------------------------- 1 | import { isValidObject, Options, DefaultOption, isArrayObject, validateOptions, belongToTypes } from '../utils'; 2 | import toSnakeCase from '../../js-snakecase'; 3 | 4 | /** 5 | * Convert string keys in an object to snake_case format. 6 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 7 | * @param opt: (optional) Options parameter, default is non-recursive. 8 | */ 9 | export default function snakeKeys(obj: any, opt: Options = DefaultOption): object | null { 10 | if (!isValidObject(obj)) return null; 11 | opt = validateOptions(opt); 12 | 13 | const res: any = {}; 14 | Object.keys(obj).forEach((key) => { 15 | let value = obj[key]; 16 | const nkey = toSnakeCase(key); 17 | if (opt.recursive) { 18 | if (isValidObject(value)) { 19 | if (!belongToTypes(value, opt.keepTypesOnRecursion)) { 20 | value = snakeKeys(value, opt); 21 | } 22 | } else if (opt.recursiveInArray && isArrayObject(value)) { 23 | value = [...value].map((v) => { 24 | let ret = v; 25 | if (isValidObject(v)) { 26 | // object in array 27 | if (!belongToTypes(ret, opt.keepTypesOnRecursion)) { 28 | ret = snakeKeys(v, opt); 29 | } 30 | } else if (isArrayObject(v)) { 31 | // array in array 32 | // workaround by using an object holding array value 33 | const temp: any = snakeKeys({ key: v }, opt); 34 | ret = temp.key; 35 | } 36 | return ret; 37 | }); 38 | } 39 | } 40 | res[nkey] = value; 41 | }); 42 | 43 | return res; 44 | } 45 | -------------------------------------------------------------------------------- /src/modules/extends/uppercase-keys-object/index.ts: -------------------------------------------------------------------------------- 1 | import { isValidObject, Options, DefaultOption, isArrayObject, validateOptions, belongToTypes } from '../utils'; 2 | 3 | /** 4 | * Convert string keys in an object to UPPERCASE format. 5 | * @param obj: object to convert keys. If `obj` isn't a json object, `null` is returned. 6 | * @param opt: (optional) Options parameter, default is non-recursive. 7 | */ 8 | export default function upperKeys(obj: any, opt: Options = DefaultOption): object | null { 9 | if (!isValidObject(obj)) return null; 10 | opt = validateOptions(opt); 11 | 12 | const res: any = {}; 13 | Object.keys(obj).forEach((key) => { 14 | let value = obj[key]; 15 | const nkey = key.toUpperCase(); 16 | if (opt.recursive) { 17 | if (isValidObject(value)) { 18 | if (!belongToTypes(value, opt.keepTypesOnRecursion)) { 19 | value = upperKeys(value, opt); 20 | } 21 | } else if (opt.recursiveInArray && isArrayObject(value)) { 22 | value = [...value].map((v) => { 23 | let ret = v; 24 | if (isValidObject(v)) { 25 | // object in array 26 | if (!belongToTypes(ret, opt.keepTypesOnRecursion)) { 27 | ret = upperKeys(v, opt); 28 | } 29 | } else if (isArrayObject(v)) { 30 | // array in array 31 | // workaround by using an object holding array value 32 | const temp: any = upperKeys({ key: v }, opt); 33 | ret = temp.key; 34 | } 35 | return ret; 36 | }); 37 | } 38 | } 39 | res[nkey] = value; 40 | }); 41 | 42 | return res; 43 | } 44 | -------------------------------------------------------------------------------- /src/modules/extends/utils.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Options parameter for convert function 3 | * 4 | * @param recursive: recursive if value of subkey is an object that is not an array 5 | * @param recursiveInArray: recursive if ${recursive} is `true` and value of subkey 6 | * is an array. All elements in array (value of subkey) will be recursive. 7 | * If ${recursiveInArray} is not set, default is `false`. 8 | * @param keepTypesOnRecursion: list of types will be keep value on recursion. 9 | * Example Date, RegExp. These types will be right-hand side of 'instanceof' operator. 10 | */ 11 | export interface Options { 12 | recursive: boolean; 13 | recursiveInArray?: boolean; 14 | keepTypesOnRecursion?: any[]; 15 | } 16 | 17 | /** 18 | * Default options for convert function. This option is not recursive. 19 | */ 20 | export const DefaultOption: Options = { 21 | recursive: false, 22 | recursiveInArray: false, 23 | keepTypesOnRecursion: [] 24 | }; 25 | 26 | export const validateOptions = (opt: Options = DefaultOption): Options => { 27 | if (opt.recursive == null) { 28 | opt = DefaultOption; 29 | } else if (opt.recursiveInArray == null) { 30 | opt.recursiveInArray = false; 31 | } 32 | return opt; 33 | }; 34 | 35 | export const isArrayObject = (obj: any): boolean => obj != null && Array.isArray(obj); 36 | 37 | export const isValidObject = (obj: any): boolean => obj != null && typeof obj === 'object' && !Array.isArray(obj); 38 | 39 | export const belongToTypes = (obj: any, types?: any[]): boolean => (types || []).some((Type) => obj instanceof Type); 40 | -------------------------------------------------------------------------------- /src/modules/js-camelcase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toCamelCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/[^A-Za-z0-9]+/g, '$') 7 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}$${b}`) 8 | .toLowerCase() 9 | .replace(/(\$)(\w)/g, (m, a, b) => b.toUpperCase()); 10 | } 11 | -------------------------------------------------------------------------------- /src/modules/js-dotcase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toDotCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}_${b.toLowerCase()}`) 7 | .replace(/[^A-Za-z0-9]+|_+/g, '.') 8 | .toLowerCase(); 9 | } 10 | -------------------------------------------------------------------------------- /src/modules/js-headercase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toHeaderCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}_${b.toLowerCase()}`) 7 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 8 | .toLowerCase() 9 | .replace(/( ?)(\w+)( ?)/g, (m, a, b, c) => a + b.charAt(0).toUpperCase() + b.slice(1) + c); 10 | } 11 | -------------------------------------------------------------------------------- /src/modules/js-kebabcase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toKebabCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}_${b.toLowerCase()}`) 7 | .replace(/[^A-Za-z0-9]+|_+/g, '-') 8 | .toLowerCase(); 9 | } 10 | -------------------------------------------------------------------------------- /src/modules/js-pascalcase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toPascalCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '$') 6 | .replace(/[^A-Za-z0-9]+/g, '$') 7 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}$${b}`) 8 | .toLowerCase() 9 | .replace(/(\$)(\w?)/g, (m, a, b) => b.toUpperCase()); 10 | } 11 | -------------------------------------------------------------------------------- /src/modules/js-pathcase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toPathCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}_${b.toLowerCase()}`) 7 | .replace(/[^A-Za-z0-9]+|_+/g, '/') 8 | .toLowerCase(); 9 | } 10 | -------------------------------------------------------------------------------- /src/modules/js-sentencecase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toSentenceCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | const textcase = String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => `${a}_${b.toLowerCase()}`) 7 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 8 | .toLowerCase(); 9 | 10 | return textcase.charAt(0).toUpperCase() + textcase.slice(1); 11 | } 12 | -------------------------------------------------------------------------------- /src/modules/js-snakecase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toSnakeCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => a + '_' + b.toLowerCase()) 7 | .replace(/[^A-Za-z0-9]+|_+/g, '_') 8 | .toLowerCase(); 9 | } 10 | -------------------------------------------------------------------------------- /src/modules/js-textcase/index.ts: -------------------------------------------------------------------------------- 1 | export default function toTextCase(str: string = ''): string { 2 | if (!str) return ''; 3 | 4 | return String(str) 5 | .replace(/^[^A-Za-z0-9]*|[^A-Za-z0-9]*$/g, '') 6 | .replace(/([a-z])([A-Z])/g, (m, a, b) => a + '_' + b.toLowerCase()) 7 | .replace(/[^A-Za-z0-9]+|_+/g, ' ') 8 | .toLowerCase(); 9 | } 10 | -------------------------------------------------------------------------------- /test/browser/core.js: -------------------------------------------------------------------------------- 1 | (() => { 2 | 3 | console.log('Core:'); 4 | 5 | const { jsConvert } = window; 6 | 7 | console.log(jsConvert.toCamelCase('param-case')); // paramCase 8 | console.log(jsConvert.toCamelCase('camelCase')); // camelCase 9 | console.log(jsConvert.toCamelCase('Title Case')); // titleCase 10 | 11 | console.log(jsConvert.toSnakeCase('param-case')); // param_case 12 | console.log(jsConvert.toSnakeCase('camelCase')); // camel_case 13 | console.log(jsConvert.toSnakeCase('Title Case')); // title_case 14 | 15 | console.log(jsConvert.toPascalCase('param-case')); // ParamCase 16 | console.log(jsConvert.toPascalCase('camelCase')); // CamelCase 17 | console.log(jsConvert.toPascalCase('Title Case')); // TitleCase 18 | 19 | console.log(jsConvert.toDotCase('param-case')); // param.case 20 | console.log(jsConvert.toDotCase('camelCase')); // camel.case 21 | console.log(jsConvert.toDotCase('Title Case')); // title.case 22 | 23 | console.log(jsConvert.toPathCase('param-case')); // param/case 24 | console.log(jsConvert.toPathCase('camelCase')); // camel/case 25 | console.log(jsConvert.toPathCase('Title Case')); // title/case 26 | 27 | console.log(jsConvert.toTextCase('param-case')); // param case 28 | console.log(jsConvert.toTextCase('camelCase')); // camel case 29 | console.log(jsConvert.toTextCase('Title Case')); // title case 30 | 31 | console.log(jsConvert.toSentenceCase('param-case')); // Param case 32 | console.log(jsConvert.toSentenceCase('camelCase')); // Camel case 33 | console.log(jsConvert.toSentenceCase('Title Case')); // Title case 34 | 35 | console.log(jsConvert.toHeaderCase('param-case')); // Param Case 36 | console.log(jsConvert.toHeaderCase('camelCase')); // Camel Case 37 | console.log(jsConvert.toHeaderCase('Title Case')); // Title Case 38 | 39 | console.log(jsConvert.toLowerCase('param-case')); // param-case 40 | console.log(jsConvert.toLowerCase('Title Case')); // title case 41 | console.log(jsConvert.toUpperCase('param-case')); // PARAM-CASE 42 | console.log(jsConvert.toUpperCase('Title Case')); // TITLE CASE 43 | 44 | console.log(jsConvert.toKebabCase('param-case')); // param-case 45 | console.log(jsConvert.toKebabCase('Title Case')); // title-case 46 | console.log(jsConvert.toKebabCase('param-case')); // PARAM-CASE 47 | console.log(jsConvert.toKebabCase('Title Case')); // TITLE-CASE 48 | 49 | // Specific values 50 | console.log(jsConvert.toCamelCase('')); // => '' 51 | console.log(jsConvert.toSnakeCase(null)); // => '' 52 | console.log(jsConvert.toPascalCase(undefined)); // => '' 53 | 54 | console.log(jsConvert.toKebabCase('')); // => '' 55 | console.log(jsConvert.toKebabCase(null)); // => '' 56 | console.log(jsConvert.toKebabCase(undefined)); // => '' 57 | 58 | // Complicated values 59 | const str = '!@#$ = Hello___world ..<>| \\ 123_ _456 & l sn_ca - cmCa - PcCa - dot.ca - txt ca - Sen ca - Hd Ca %^$^%&'; 60 | console.log(jsConvert.toCamelCase(str)); // => 'helloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 61 | console.log(jsConvert.toPascalCase(str)); // => 'HelloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 62 | console.log(jsConvert.toSnakeCase(str)); // => 'hello_world_123_456_l_sn_ca_cm_ca_pc_ca_dot_ca_txt_ca_sen_ca_hd_ca' 63 | console.log(jsConvert.toDotCase(str)); // => 'hello.world.123.456.l.sn.ca.cm.ca.pc.ca.dot.ca.txt.ca.sen.ca.hd.ca' 64 | console.log(jsConvert.toPathCase(str)); // => 'hello/world/123/456/l/sn/ca/cm/ca/pc/ca/dot/ca/txt/ca/sen/ca/hd/ca' 65 | console.log(jsConvert.toTextCase(str)); // => 'hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 66 | console.log(jsConvert.toSentenceCase(str)); // => 'Hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 67 | console.log(jsConvert.toHeaderCase(str)); // => 'Hello World 123 456 L Sn Ca Cm Ca Pc Ca Dot Ca Txt Ca Sen Ca Hd Ca' 68 | console.log(jsConvert.toKebabCase(str)); // => 'hello-world-123-456-l-sn-ca-cm-ca-pc-ca-dot-ca-txt-ca-sen-ca-hd-ca' 69 | 70 | })(); 71 | -------------------------------------------------------------------------------- /test/browser/extends.js: -------------------------------------------------------------------------------- 1 | (() => { 2 | 3 | console.log('Extends:'); 4 | 5 | const { jsConvert } = window; 6 | 7 | // null or undefined, output is `null` 8 | console.log(jsConvert.lowerKeys(undefined)); 9 | console.log(jsConvert.lowerKeys(null)); 10 | console.log(jsConvert.upperKeys(undefined)); 11 | console.log(jsConvert.upperKeys(null)); 12 | console.log(jsConvert.camelKeys(undefined)); 13 | console.log(jsConvert.camelKeys(null)); 14 | console.log(jsConvert.snakeKeys(undefined)); 15 | console.log(jsConvert.snakeKeys(null)); 16 | console.log(jsConvert.pascalKeys(undefined)); 17 | console.log(jsConvert.pascalKeys(null)); 18 | console.log(jsConvert.kebabKeys(null)); 19 | 20 | // invalid json object, output is `null` 21 | console.log(jsConvert.lowerKeys(1)); 22 | console.log(jsConvert.lowerKeys('abc')); 23 | console.log(jsConvert.lowerKeys([1, 2, 3])); 24 | console.log(jsConvert.upperKeys(1)); 25 | console.log(jsConvert.upperKeys('abc')); 26 | console.log(jsConvert.upperKeys([1, 2, 3])); 27 | console.log(jsConvert.camelKeys(1)); 28 | console.log(jsConvert.camelKeys('abc')); 29 | console.log(jsConvert.camelKeys([1, 2, 3])); 30 | console.log(jsConvert.snakeKeys(1)); 31 | console.log(jsConvert.snakeKeys('abc')); 32 | console.log(jsConvert.snakeKeys([1, 2, 3])); 33 | console.log(jsConvert.pascalKeys(1)); 34 | console.log(jsConvert.pascalKeys('abc')); 35 | console.log(jsConvert.pascalKeys([1, 2, 3])); 36 | console.log(jsConvert.kebabKeys(1)); 37 | console.log(jsConvert.kebabKeys('abc')); 38 | console.log(jsConvert.kebabKeys([1, 2, 3])); 39 | 40 | // Object convert case 41 | const obj = { 42 | camelCase: 1, 43 | UPPERCASE: 2, 44 | lowercase: 3, 45 | snake_case: 4, 46 | PascalCase: 5, 47 | 'Title Case': 6, 48 | 'dot.case': 7, 49 | 'param-case': 8, 50 | 'Sentence case': 9, 51 | 'path/case': 10, 52 | 'Header-Case': 11 53 | }; 54 | 55 | console.log(jsConvert.lowerKeys(obj)); 56 | console.log(jsConvert.upperKeys(obj)); 57 | console.log(jsConvert.camelKeys(obj)); 58 | console.log(jsConvert.snakeKeys(obj)); 59 | console.log(jsConvert.pascalKeys(obj)); 60 | console.log(jsConvert.kebabKeys(obj)); 61 | 62 | /** 63 | { camelcase: 1, 64 | uppercase: 2, 65 | lowercase: 3, 66 | snake_case: 4, 67 | pascalcase: 5, 68 | 'title case': 6, 69 | 'dot.case': 7, 70 | 'param-case': 8, 71 | 'sentence case': 9, 72 | 'path/case': 10, 73 | 'header-case': 11 } 74 | 75 | { CAMELCASE: 1, 76 | UPPERCASE: 2, 77 | LOWERCASE: 3, 78 | SNAKE_CASE: 4, 79 | PASCALCASE: 5, 80 | 'TITLE CASE': 6, 81 | 'DOT.CASE': 7, 82 | 'PARAM-CASE': 8, 83 | 'SENTENCE CASE': 9, 84 | 'PATH/CASE': 10, 85 | 'HEADER-CASE': 11 } 86 | 87 | { camelCase: 1, 88 | uppercase: 2, 89 | lowercase: 3, 90 | snakeCase: 4, 91 | pascalCase: 5, 92 | titleCase: 6, 93 | dotCase: 7, 94 | paramCase: 8, 95 | sentenceCase: 9, 96 | pathCase: 10, 97 | headerCase: 11 } 98 | 99 | { camel_case: 1, 100 | uppercase: 2, 101 | lowercase: 3, 102 | snake_case: 4, 103 | pascal_case: 5, 104 | title_case: 6, 105 | dot_case: 7, 106 | param_case: 8, 107 | sentence_case: 9, 108 | path_case: 10, 109 | header_case: 11 } 110 | 111 | { CamelCase: 1, 112 | Uppercase: 2, 113 | Lowercase: 3, 114 | SnakeCase: 4, 115 | PascalCase: 5, 116 | TitleCase: 6, 117 | DotCase: 7, 118 | ParamCase: 8, 119 | SentenceCase: 9, 120 | PathCase: 10, 121 | HeaderCase: 11 } 122 | 123 | { 'camel-case': 1, 124 | uppercase: 2, 125 | lowercase: 3, 126 | 'snake-case': 4, 127 | 'pascal-case': 5, 128 | 'title-case': 6, 129 | 'dot-case': 7, 130 | 'param-case': 8, 131 | 'sentence-case': 9, 132 | 'path-case': 10, 133 | 'header-case': 11 } 134 | */ 135 | 136 | })(); 137 | -------------------------------------------------------------------------------- /test/browser/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /test/browser/recursive.js: -------------------------------------------------------------------------------- 1 | (() => { 2 | 3 | console.log('Recursive:'); 4 | 5 | const { jsConvert } = window; 6 | 7 | const core = { 8 | camelCase: 1, 9 | UPPERCASE: 2, 10 | lowercase: 3, 11 | snake_case: 4, 12 | PascalCase: 5, 13 | 'Title Case': 6, 14 | 'dot.case': 7, 15 | 'param-case': 8, 16 | 'Sentence case': 9, 17 | 'path/case': 10, 18 | 'Header-Case': 11 19 | }; 20 | 21 | const obj = { 22 | ...core, 23 | lv11: { ...core }, 24 | lv12: { 25 | ...core, 26 | lv21: { 27 | ...core, 28 | lv31: { 29 | ...core 30 | }, 31 | lv32: { 32 | ...core 33 | } 34 | }, 35 | lv22: { 36 | ...core 37 | } 38 | } 39 | }; 40 | 41 | console.log(jsConvert.lowerKeys(obj, { recursive: true })); 42 | console.log(jsConvert.upperKeys(obj, { recursive: true })); 43 | console.log(jsConvert.pascalKeys(obj, { recursive: true })); 44 | console.log(jsConvert.camelKeys(obj, { recursive: true })); 45 | console.log(jsConvert.snakeKeys(obj, { recursive: true })); 46 | 47 | })(); 48 | -------------------------------------------------------------------------------- /test/core/index.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | 3 | console.log(jsConvert.toCamelCase('param-case')); // paramCase 4 | console.log(jsConvert.toCamelCase('camelCase')); // camelCase 5 | console.log(jsConvert.toCamelCase('Title Case')); // titleCase 6 | 7 | console.log(jsConvert.toSnakeCase('param-case')); // param_case 8 | console.log(jsConvert.toSnakeCase('camelCase')); // camel_case 9 | console.log(jsConvert.toSnakeCase('Title Case')); // title_case 10 | 11 | console.log(jsConvert.toPascalCase('param-case')); // ParamCase 12 | console.log(jsConvert.toPascalCase('camelCase')); // CamelCase 13 | console.log(jsConvert.toPascalCase('Title Case')); // TitleCase 14 | 15 | console.log(jsConvert.toDotCase('param-case')); // param.case 16 | console.log(jsConvert.toDotCase('camelCase')); // camel.case 17 | console.log(jsConvert.toDotCase('Title Case')); // title.case 18 | 19 | console.log(jsConvert.toPathCase('param-case')); // param/case 20 | console.log(jsConvert.toPathCase('camelCase')); // camel/case 21 | console.log(jsConvert.toPathCase('Title Case')); // title/case 22 | 23 | console.log(jsConvert.toTextCase('param-case')); // param case 24 | console.log(jsConvert.toTextCase('camelCase')); // camel case 25 | console.log(jsConvert.toTextCase('Title Case')); // title case 26 | 27 | console.log(jsConvert.toSentenceCase('param-case')); // Param case 28 | console.log(jsConvert.toSentenceCase('camelCase')); // Camel case 29 | console.log(jsConvert.toSentenceCase('Title Case')); // Title case 30 | 31 | console.log(jsConvert.toHeaderCase('param-case')); // Param Case 32 | console.log(jsConvert.toHeaderCase('camelCase')); // Camel Case 33 | console.log(jsConvert.toHeaderCase('Title Case')); // Title Case 34 | 35 | console.log(jsConvert.toLowerCase('param-case')); // param-case 36 | console.log(jsConvert.toLowerCase('Title Case')); // title case 37 | console.log(jsConvert.toUpperCase('param-case')); // PARAM-CASE 38 | console.log(jsConvert.toUpperCase('Title Case')); // TITLE CASE 39 | 40 | console.log(jsConvert.toKebabCase('param-case')); // param-case 41 | console.log(jsConvert.toKebabCase('Title Case')); // title-case 42 | console.log(jsConvert.toKebabCase('param-case')); // PARAM-CASE 43 | console.log(jsConvert.toKebabCase('Title Case')); // TITLE-CASE 44 | 45 | // Specific values 46 | console.log(jsConvert.toCamelCase('')); // => '' 47 | console.log(jsConvert.toSnakeCase(null)); // => '' 48 | console.log(jsConvert.toPascalCase(undefined)); // => '' 49 | 50 | console.log(jsConvert.toKebabCase('')); // => '' 51 | console.log(jsConvert.toKebabCase(null)); // => '' 52 | console.log(jsConvert.toKebabCase(undefined)); // => '' 53 | 54 | // Complicated values 55 | const str = '!@#$ = Hello___world ..<>| \\ 123_ _456 & l sn_ca - cmCa - PcCa - dot.ca - txt ca - Sen ca - Hd Ca %^$^%&'; 56 | console.log(jsConvert.toCamelCase(str)); // => 'helloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 57 | console.log(jsConvert.toPascalCase(str)); // => 'HelloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 58 | console.log(jsConvert.toSnakeCase(str)); // => 'hello_world_123_456_l_sn_ca_cm_ca_pc_ca_dot_ca_txt_ca_sen_ca_hd_ca' 59 | console.log(jsConvert.toDotCase(str)); // => 'hello.world.123.456.l.sn.ca.cm.ca.pc.ca.dot.ca.txt.ca.sen.ca.hd.ca' 60 | console.log(jsConvert.toPathCase(str)); // => 'hello/world/123/456/l/sn/ca/cm/ca/pc/ca/dot/ca/txt/ca/sen/ca/hd/ca' 61 | console.log(jsConvert.toTextCase(str)); // => 'hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 62 | console.log(jsConvert.toSentenceCase(str)); // => 'Hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 63 | console.log(jsConvert.toHeaderCase(str)); // => 'Hello World 123 456 L Sn Ca Cm Ca Pc Ca Dot Ca Txt Ca Sen Ca Hd Ca' 64 | console.log(jsConvert.toKebabCase(str)); // => 'hello-world-123-456-l-sn-ca-cm-ca-pc-ca-dot-ca-txt-ca-sen-ca-hd-ca' 65 | -------------------------------------------------------------------------------- /test/example/index.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const fs = require('fs'); 3 | const path = require('path'); 4 | 5 | const core = { 6 | camelCase: 1, 7 | UPPERCASE: 2, 8 | lowercase: 3, 9 | snake_case: 4, 10 | PascalCase: 5, 11 | 'Title Case': 6, 12 | 'dot.case': 7, 13 | 'param-case': 8, 14 | 'Sentence case': 9, 15 | 'path/case': 10, 16 | 'Header-Case': 11 17 | }; 18 | 19 | const obj = { 20 | ...core, 21 | lv1: { 22 | ...core, 23 | lv2: { 24 | ...core 25 | } 26 | } 27 | }; 28 | 29 | fs.mkdirSync(path.join(__dirname, './samples')); 30 | 31 | const upperKeys = jsConvert.upperKeys(obj, { recursive: true }); 32 | fs.writeFileSync(path.join(__dirname, './samples/upperKeys.json'), JSON.stringify(upperKeys, null, 2)); 33 | 34 | const lowerKeys = jsConvert.lowerKeys(obj, { recursive: true }); 35 | fs.writeFileSync(path.join(__dirname, './samples/lowerKeys.json'), JSON.stringify(lowerKeys, null, 2)); 36 | 37 | const snakeKeys = jsConvert.snakeKeys(obj, { recursive: true }); 38 | fs.writeFileSync(path.join(__dirname, './samples/snakeKeys.json'), JSON.stringify(snakeKeys, null, 2)); 39 | 40 | const pascalKeys = jsConvert.pascalKeys(obj, { recursive: true }); 41 | fs.writeFileSync(path.join(__dirname, './samples/pascalKeys.json'), JSON.stringify(pascalKeys, null, 2)); 42 | 43 | const camelKeys = jsConvert.camelKeys(obj, { recursive: true }); 44 | fs.writeFileSync(path.join(__dirname, './samples/camelKeys.json'), JSON.stringify(camelKeys, null, 2)); 45 | 46 | -------------------------------------------------------------------------------- /test/example/samples/camelKeys.json: -------------------------------------------------------------------------------- 1 | { 2 | "camelCase": 1, 3 | "uppercase": 2, 4 | "lowercase": 3, 5 | "snakeCase": 4, 6 | "pascalCase": 5, 7 | "titleCase": 6, 8 | "dotCase": 7, 9 | "paramCase": 8, 10 | "sentenceCase": 9, 11 | "pathCase": 10, 12 | "headerCase": 11, 13 | "lv1": { 14 | "camelCase": 1, 15 | "uppercase": 2, 16 | "lowercase": 3, 17 | "snakeCase": 4, 18 | "pascalCase": 5, 19 | "titleCase": 6, 20 | "dotCase": 7, 21 | "paramCase": 8, 22 | "sentenceCase": 9, 23 | "pathCase": 10, 24 | "headerCase": 11, 25 | "lv2": { 26 | "camelCase": 1, 27 | "uppercase": 2, 28 | "lowercase": 3, 29 | "snakeCase": 4, 30 | "pascalCase": 5, 31 | "titleCase": 6, 32 | "dotCase": 7, 33 | "paramCase": 8, 34 | "sentenceCase": 9, 35 | "pathCase": 10, 36 | "headerCase": 11 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /test/example/samples/lowerKeys.json: -------------------------------------------------------------------------------- 1 | { 2 | "camelcase": 1, 3 | "uppercase": 2, 4 | "lowercase": 3, 5 | "snake_case": 4, 6 | "pascalcase": 5, 7 | "title case": 6, 8 | "dot.case": 7, 9 | "param-case": 8, 10 | "sentence case": 9, 11 | "path/case": 10, 12 | "header-case": 11, 13 | "lv1": { 14 | "camelcase": 1, 15 | "uppercase": 2, 16 | "lowercase": 3, 17 | "snake_case": 4, 18 | "pascalcase": 5, 19 | "title case": 6, 20 | "dot.case": 7, 21 | "param-case": 8, 22 | "sentence case": 9, 23 | "path/case": 10, 24 | "header-case": 11, 25 | "lv2": { 26 | "camelcase": 1, 27 | "uppercase": 2, 28 | "lowercase": 3, 29 | "snake_case": 4, 30 | "pascalcase": 5, 31 | "title case": 6, 32 | "dot.case": 7, 33 | "param-case": 8, 34 | "sentence case": 9, 35 | "path/case": 10, 36 | "header-case": 11 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /test/example/samples/pascalKeys.json: -------------------------------------------------------------------------------- 1 | { 2 | "CamelCase": 1, 3 | "Uppercase": 2, 4 | "Lowercase": 3, 5 | "SnakeCase": 4, 6 | "PascalCase": 5, 7 | "TitleCase": 6, 8 | "DotCase": 7, 9 | "ParamCase": 8, 10 | "SentenceCase": 9, 11 | "PathCase": 10, 12 | "HeaderCase": 11, 13 | "Lv1": { 14 | "CamelCase": 1, 15 | "Uppercase": 2, 16 | "Lowercase": 3, 17 | "SnakeCase": 4, 18 | "PascalCase": 5, 19 | "TitleCase": 6, 20 | "DotCase": 7, 21 | "ParamCase": 8, 22 | "SentenceCase": 9, 23 | "PathCase": 10, 24 | "HeaderCase": 11, 25 | "Lv2": { 26 | "CamelCase": 1, 27 | "Uppercase": 2, 28 | "Lowercase": 3, 29 | "SnakeCase": 4, 30 | "PascalCase": 5, 31 | "TitleCase": 6, 32 | "DotCase": 7, 33 | "ParamCase": 8, 34 | "SentenceCase": 9, 35 | "PathCase": 10, 36 | "HeaderCase": 11 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /test/example/samples/snakeKeys.json: -------------------------------------------------------------------------------- 1 | { 2 | "camel_case": 1, 3 | "uppercase": 2, 4 | "lowercase": 3, 5 | "snake_case": 4, 6 | "pascal_case": 5, 7 | "title_case": 6, 8 | "dot_case": 7, 9 | "param_case": 8, 10 | "sentence_case": 9, 11 | "path_case": 10, 12 | "header_case": 11, 13 | "lv1": { 14 | "camel_case": 1, 15 | "uppercase": 2, 16 | "lowercase": 3, 17 | "snake_case": 4, 18 | "pascal_case": 5, 19 | "title_case": 6, 20 | "dot_case": 7, 21 | "param_case": 8, 22 | "sentence_case": 9, 23 | "path_case": 10, 24 | "header_case": 11, 25 | "lv2": { 26 | "camel_case": 1, 27 | "uppercase": 2, 28 | "lowercase": 3, 29 | "snake_case": 4, 30 | "pascal_case": 5, 31 | "title_case": 6, 32 | "dot_case": 7, 33 | "param_case": 8, 34 | "sentence_case": 9, 35 | "path_case": 10, 36 | "header_case": 11 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /test/example/samples/upperKeys.json: -------------------------------------------------------------------------------- 1 | { 2 | "CAMELCASE": 1, 3 | "UPPERCASE": 2, 4 | "LOWERCASE": 3, 5 | "SNAKE_CASE": 4, 6 | "PASCALCASE": 5, 7 | "TITLE CASE": 6, 8 | "DOT.CASE": 7, 9 | "PARAM-CASE": 8, 10 | "SENTENCE CASE": 9, 11 | "PATH/CASE": 10, 12 | "HEADER-CASE": 11, 13 | "LV1": { 14 | "CAMELCASE": 1, 15 | "UPPERCASE": 2, 16 | "LOWERCASE": 3, 17 | "SNAKE_CASE": 4, 18 | "PASCALCASE": 5, 19 | "TITLE CASE": 6, 20 | "DOT.CASE": 7, 21 | "PARAM-CASE": 8, 22 | "SENTENCE CASE": 9, 23 | "PATH/CASE": 10, 24 | "HEADER-CASE": 11, 25 | "LV2": { 26 | "CAMELCASE": 1, 27 | "UPPERCASE": 2, 28 | "LOWERCASE": 3, 29 | "SNAKE_CASE": 4, 30 | "PASCALCASE": 5, 31 | "TITLE CASE": 6, 32 | "DOT.CASE": 7, 33 | "PARAM-CASE": 8, 34 | "SENTENCE CASE": 9, 35 | "PATH/CASE": 10, 36 | "HEADER-CASE": 11 37 | } 38 | } 39 | } -------------------------------------------------------------------------------- /test/extends/index.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | 3 | // null or undefined, output is `null` 4 | console.log(jsConvert.lowerKeys(undefined)); 5 | console.log(jsConvert.lowerKeys(null)); 6 | console.log(jsConvert.upperKeys(undefined)); 7 | console.log(jsConvert.upperKeys(null)); 8 | console.log(jsConvert.camelKeys(undefined)); 9 | console.log(jsConvert.camelKeys(null)); 10 | console.log(jsConvert.snakeKeys(undefined)); 11 | console.log(jsConvert.snakeKeys(null)); 12 | console.log(jsConvert.pascalKeys(undefined)); 13 | console.log(jsConvert.pascalKeys(null)); 14 | console.log(jsConvert.kebabKeys(null)); 15 | 16 | // invalid json object, output is `null` 17 | console.log(jsConvert.lowerKeys(1)); 18 | console.log(jsConvert.lowerKeys('abc')); 19 | console.log(jsConvert.lowerKeys([1, 2, 3])); 20 | console.log(jsConvert.upperKeys(1)); 21 | console.log(jsConvert.upperKeys('abc')); 22 | console.log(jsConvert.upperKeys([1, 2, 3])); 23 | console.log(jsConvert.camelKeys(1)); 24 | console.log(jsConvert.camelKeys('abc')); 25 | console.log(jsConvert.camelKeys([1, 2, 3])); 26 | console.log(jsConvert.snakeKeys(1)); 27 | console.log(jsConvert.snakeKeys('abc')); 28 | console.log(jsConvert.snakeKeys([1, 2, 3])); 29 | console.log(jsConvert.pascalKeys(1)); 30 | console.log(jsConvert.pascalKeys('abc')); 31 | console.log(jsConvert.pascalKeys([1, 2, 3])); 32 | console.log(jsConvert.kebabKeys(1)); 33 | console.log(jsConvert.kebabKeys('abc')); 34 | console.log(jsConvert.kebabKeys([1, 2, 3])); 35 | 36 | // Object convert case 37 | const obj = { 38 | camelCase: 1, 39 | UPPERCASE: 2, 40 | lowercase: 3, 41 | snake_case: 4, 42 | PascalCase: 5, 43 | 'Title Case': 6, 44 | 'dot.case': 7, 45 | 'param-case': 8, 46 | 'Sentence case': 9, 47 | 'path/case': 10, 48 | 'Header-Case': 11 49 | }; 50 | 51 | console.log(jsConvert.lowerKeys(obj)); 52 | console.log(jsConvert.upperKeys(obj)); 53 | console.log(jsConvert.camelKeys(obj)); 54 | console.log(jsConvert.snakeKeys(obj)); 55 | console.log(jsConvert.pascalKeys(obj)); 56 | console.log(jsConvert.kebabKeys(obj)); 57 | 58 | /** 59 | { camelcase: 1, 60 | uppercase: 2, 61 | lowercase: 3, 62 | snake_case: 4, 63 | pascalcase: 5, 64 | 'title case': 6, 65 | 'dot.case': 7, 66 | 'param-case': 8, 67 | 'sentence case': 9, 68 | 'path/case': 10, 69 | 'header-case': 11 } 70 | 71 | { CAMELCASE: 1, 72 | UPPERCASE: 2, 73 | LOWERCASE: 3, 74 | SNAKE_CASE: 4, 75 | PASCALCASE: 5, 76 | 'TITLE CASE': 6, 77 | 'DOT.CASE': 7, 78 | 'PARAM-CASE': 8, 79 | 'SENTENCE CASE': 9, 80 | 'PATH/CASE': 10, 81 | 'HEADER-CASE': 11 } 82 | 83 | { camelCase: 1, 84 | uppercase: 2, 85 | lowercase: 3, 86 | snakeCase: 4, 87 | pascalCase: 5, 88 | titleCase: 6, 89 | dotCase: 7, 90 | paramCase: 8, 91 | sentenceCase: 9, 92 | pathCase: 10, 93 | headerCase: 11 } 94 | 95 | { camel_case: 1, 96 | uppercase: 2, 97 | lowercase: 3, 98 | snake_case: 4, 99 | pascal_case: 5, 100 | title_case: 6, 101 | dot_case: 7, 102 | param_case: 8, 103 | sentence_case: 9, 104 | path_case: 10, 105 | header_case: 11 } 106 | 107 | { CamelCase: 1, 108 | Uppercase: 2, 109 | Lowercase: 3, 110 | SnakeCase: 4, 111 | PascalCase: 5, 112 | TitleCase: 6, 113 | DotCase: 7, 114 | ParamCase: 8, 115 | SentenceCase: 9, 116 | PathCase: 10, 117 | HeaderCase: 11 } 118 | 119 | { 'camel-case': 1, 120 | uppercase: 2, 121 | lowercase: 3, 122 | 'snake-case': 4, 123 | 'pascal-case': 5, 124 | 'title-case': 6, 125 | 'dot-case': 7, 126 | 'param-case': 8, 127 | 'sentence-case': 9, 128 | 'path-case': 10, 129 | 'header-case': 11 } 130 | */ 131 | -------------------------------------------------------------------------------- /test/prepublish/.babelrc: -------------------------------------------------------------------------------- 1 | { 2 | "presets": [ 3 | "@babel/preset-env" 4 | ] 5 | } 6 | -------------------------------------------------------------------------------- /test/prepublish/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "jsconvert-test-npm-pack", 3 | "version": "1.0.0", 4 | "license": "MIT", 5 | "scripts": { 6 | "es5": "node src/es5.js", 7 | "es6": "babel-node src/es6.js", 8 | "clean": "rm -rf *.tgz" 9 | }, 10 | "dependencies": { 11 | "js-convert-case": "file:js-convert-case-4.2.0.tgz" 12 | }, 13 | "devDependencies": { 14 | "@babel/core": "^7.10.1", 15 | "@babel/node": "^7.10.1", 16 | "@babel/preset-env": "^7.10.1" 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /test/prepublish/src/es5.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('js-convert-case'); 2 | 3 | console.log(jsConvert); 4 | console.log(jsConvert.default); 5 | -------------------------------------------------------------------------------- /test/prepublish/src/es6.js: -------------------------------------------------------------------------------- 1 | import jsConvert, { toPascalCase, snakeKeys } from 'js-convert-case'; 2 | import assert from 'assert'; 3 | 4 | console.log(jsConvert); 5 | console.log(jsConvert.default); 6 | 7 | assert.equal(jsConvert.toPascalCase, toPascalCase, 'Match'); 8 | assert.equal(jsConvert.snakeKeys, snakeKeys, 'Match'); 9 | -------------------------------------------------------------------------------- /test/recursive/_genexample.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | 3 | const obj = { 4 | camelCase: 1, 5 | PascalCase: { 6 | camelCase: [1, 'a', null, { PascalCase: 1 }, undefined], 7 | PascalCase: [{ PascalCase: [1] }, [1, { PascalCase: 2 }]], 8 | snake_case: { camelCase: [{ PascalCase: 1 }] } 9 | } 10 | }; 11 | 12 | const res = jsConvert.snakeKeys(obj, { recursive: true, recursiveInArray: true }); 13 | 14 | console.log(JSON.stringify(res)); 15 | -------------------------------------------------------------------------------- /test/recursive/_shared.js: -------------------------------------------------------------------------------- 1 | const util = require('util'); 2 | 3 | const log = (obj) => { 4 | console.log(util.inspect(obj, { showHidden: false, depth: null })); 5 | }; 6 | 7 | const core = { 8 | camelCase: 1, 9 | UPPERCASE: 2, 10 | lowercase: 3, 11 | snake_case: 4, 12 | PascalCase: 5, 13 | 'Title Case': 6, 14 | 'dot.case': 7, 15 | 'param-case': 8, 16 | 'Sentence case': 9, 17 | 'path/case': 10, 18 | 'Header-Case': 11 19 | }; 20 | 21 | const obj = { 22 | ...core, 23 | lv11: { ...core }, 24 | lv12: { 25 | ...core, 26 | lv21: { 27 | ...core, 28 | lv31: { ...core }, 29 | lv32: { ...core } 30 | }, 31 | lv22: { ...core }, 32 | lv23: [ 33 | { ...core }, 34 | { 35 | lv31: [1, 'A', null, { ...core }, '123', undefined], 36 | lv32: { ...core } 37 | }, 38 | [{ ...core }, 5, '123', { a: 1, b: 2 }, null], 39 | null, 40 | undefined 41 | ] 42 | } 43 | }; 44 | 45 | module.exports = { 46 | obj, 47 | log 48 | }; 49 | -------------------------------------------------------------------------------- /test/recursive/camelKeys.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.camelKeys(obj)); 5 | console.log('============================================'); 6 | log(jsConvert.camelKeys(obj, { recursive: true })); 7 | 8 | /** 9 | { 10 | camelCase: 1, 11 | uppercase: 2, 12 | lowercase: 3, 13 | snakeCase: 4, 14 | pascalCase: 5, 15 | titleCase: 6, 16 | dotCase: 7, 17 | paramCase: 8, 18 | sentenceCase: 9, 19 | pathCase: 10, 20 | headerCase: 11, 21 | lv11: { 22 | camelCase: 1, 23 | UPPERCASE: 2, 24 | lowercase: 3, 25 | snake_case: 4, 26 | PascalCase: 5, 27 | 'Title Case': 6, 28 | 'dot.case': 7, 29 | 'param-case': 8, 30 | 'Sentence case': 9, 31 | 'path/case': 10, 32 | 'Header-Case': 11 33 | }, 34 | lv12: { 35 | camelCase: 1, 36 | UPPERCASE: 2, 37 | lowercase: 3, 38 | snake_case: 4, 39 | PascalCase: 5, 40 | 'Title Case': 6, 41 | 'dot.case': 7, 42 | 'param-case': 8, 43 | 'Sentence case': 9, 44 | 'path/case': 10, 45 | 'Header-Case': 11, 46 | lv21: { 47 | camelCase: 1, 48 | UPPERCASE: 2, 49 | lowercase: 3, 50 | snake_case: 4, 51 | PascalCase: 5, 52 | 'Title Case': 6, 53 | 'dot.case': 7, 54 | 'param-case': 8, 55 | 'Sentence case': 9, 56 | 'path/case': 10, 57 | 'Header-Case': 11, 58 | lv31: { 59 | camelCase: 1, 60 | UPPERCASE: 2, 61 | lowercase: 3, 62 | snake_case: 4, 63 | PascalCase: 5, 64 | 'Title Case': 6, 65 | 'dot.case': 7, 66 | 'param-case': 8, 67 | 'Sentence case': 9, 68 | 'path/case': 10, 69 | 'Header-Case': 11 70 | }, 71 | lv32: { 72 | camelCase: 1, 73 | UPPERCASE: 2, 74 | lowercase: 3, 75 | snake_case: 4, 76 | PascalCase: 5, 77 | 'Title Case': 6, 78 | 'dot.case': 7, 79 | 'param-case': 8, 80 | 'Sentence case': 9, 81 | 'path/case': 10, 82 | 'Header-Case': 11 83 | } 84 | }, 85 | lv22: { 86 | camelCase: 1, 87 | UPPERCASE: 2, 88 | lowercase: 3, 89 | snake_case: 4, 90 | PascalCase: 5, 91 | 'Title Case': 6, 92 | 'dot.case': 7, 93 | 'param-case': 8, 94 | 'Sentence case': 9, 95 | 'path/case': 10, 96 | 'Header-Case': 11 97 | }, 98 | lv23: [ 99 | { 100 | camelCase: 1, 101 | UPPERCASE: 2, 102 | lowercase: 3, 103 | snake_case: 4, 104 | PascalCase: 5, 105 | 'Title Case': 6, 106 | 'dot.case': 7, 107 | 'param-case': 8, 108 | 'Sentence case': 9, 109 | 'path/case': 10, 110 | 'Header-Case': 11 111 | }, 112 | { 113 | lv31: [ 114 | 1, 115 | 'A', 116 | null, 117 | { 118 | camelCase: 1, 119 | UPPERCASE: 2, 120 | lowercase: 3, 121 | snake_case: 4, 122 | PascalCase: 5, 123 | 'Title Case': 6, 124 | 'dot.case': 7, 125 | 'param-case': 8, 126 | 'Sentence case': 9, 127 | 'path/case': 10, 128 | 'Header-Case': 11 129 | }, 130 | '123', 131 | undefined 132 | ], 133 | lv32: { 134 | camelCase: 1, 135 | UPPERCASE: 2, 136 | lowercase: 3, 137 | snake_case: 4, 138 | PascalCase: 5, 139 | 'Title Case': 6, 140 | 'dot.case': 7, 141 | 'param-case': 8, 142 | 'Sentence case': 9, 143 | 'path/case': 10, 144 | 'Header-Case': 11 145 | } 146 | }, 147 | [ 148 | { 149 | camelCase: 1, 150 | UPPERCASE: 2, 151 | lowercase: 3, 152 | snake_case: 4, 153 | PascalCase: 5, 154 | 'Title Case': 6, 155 | 'dot.case': 7, 156 | 'param-case': 8, 157 | 'Sentence case': 9, 158 | 'path/case': 10, 159 | 'Header-Case': 11 160 | }, 161 | 5, 162 | '123', 163 | { a: 1, b: 2 }, 164 | null 165 | ], 166 | null, 167 | undefined 168 | ] 169 | } 170 | } 171 | ============================================ 172 | { 173 | camelCase: 1, 174 | uppercase: 2, 175 | lowercase: 3, 176 | snakeCase: 4, 177 | pascalCase: 5, 178 | titleCase: 6, 179 | dotCase: 7, 180 | paramCase: 8, 181 | sentenceCase: 9, 182 | pathCase: 10, 183 | headerCase: 11, 184 | lv11: { 185 | camelCase: 1, 186 | uppercase: 2, 187 | lowercase: 3, 188 | snakeCase: 4, 189 | pascalCase: 5, 190 | titleCase: 6, 191 | dotCase: 7, 192 | paramCase: 8, 193 | sentenceCase: 9, 194 | pathCase: 10, 195 | headerCase: 11 196 | }, 197 | lv12: { 198 | camelCase: 1, 199 | uppercase: 2, 200 | lowercase: 3, 201 | snakeCase: 4, 202 | pascalCase: 5, 203 | titleCase: 6, 204 | dotCase: 7, 205 | paramCase: 8, 206 | sentenceCase: 9, 207 | pathCase: 10, 208 | headerCase: 11, 209 | lv21: { 210 | camelCase: 1, 211 | uppercase: 2, 212 | lowercase: 3, 213 | snakeCase: 4, 214 | pascalCase: 5, 215 | titleCase: 6, 216 | dotCase: 7, 217 | paramCase: 8, 218 | sentenceCase: 9, 219 | pathCase: 10, 220 | headerCase: 11, 221 | lv31: { 222 | camelCase: 1, 223 | uppercase: 2, 224 | lowercase: 3, 225 | snakeCase: 4, 226 | pascalCase: 5, 227 | titleCase: 6, 228 | dotCase: 7, 229 | paramCase: 8, 230 | sentenceCase: 9, 231 | pathCase: 10, 232 | headerCase: 11 233 | }, 234 | lv32: { 235 | camelCase: 1, 236 | uppercase: 2, 237 | lowercase: 3, 238 | snakeCase: 4, 239 | pascalCase: 5, 240 | titleCase: 6, 241 | dotCase: 7, 242 | paramCase: 8, 243 | sentenceCase: 9, 244 | pathCase: 10, 245 | headerCase: 11 246 | } 247 | }, 248 | lv22: { 249 | camelCase: 1, 250 | uppercase: 2, 251 | lowercase: 3, 252 | snakeCase: 4, 253 | pascalCase: 5, 254 | titleCase: 6, 255 | dotCase: 7, 256 | paramCase: 8, 257 | sentenceCase: 9, 258 | pathCase: 10, 259 | headerCase: 11 260 | }, 261 | lv23: [ 262 | { 263 | camelCase: 1, 264 | UPPERCASE: 2, 265 | lowercase: 3, 266 | snake_case: 4, 267 | PascalCase: 5, 268 | 'Title Case': 6, 269 | 'dot.case': 7, 270 | 'param-case': 8, 271 | 'Sentence case': 9, 272 | 'path/case': 10, 273 | 'Header-Case': 11 274 | }, 275 | { 276 | lv31: [ 277 | 1, 278 | 'A', 279 | null, 280 | { 281 | camelCase: 1, 282 | UPPERCASE: 2, 283 | lowercase: 3, 284 | snake_case: 4, 285 | PascalCase: 5, 286 | 'Title Case': 6, 287 | 'dot.case': 7, 288 | 'param-case': 8, 289 | 'Sentence case': 9, 290 | 'path/case': 10, 291 | 'Header-Case': 11 292 | }, 293 | '123', 294 | undefined 295 | ], 296 | lv32: { 297 | camelCase: 1, 298 | UPPERCASE: 2, 299 | lowercase: 3, 300 | snake_case: 4, 301 | PascalCase: 5, 302 | 'Title Case': 6, 303 | 'dot.case': 7, 304 | 'param-case': 8, 305 | 'Sentence case': 9, 306 | 'path/case': 10, 307 | 'Header-Case': 11 308 | } 309 | }, 310 | [ 311 | { 312 | camelCase: 1, 313 | UPPERCASE: 2, 314 | lowercase: 3, 315 | snake_case: 4, 316 | PascalCase: 5, 317 | 'Title Case': 6, 318 | 'dot.case': 7, 319 | 'param-case': 8, 320 | 'Sentence case': 9, 321 | 'path/case': 10, 322 | 'Header-Case': 11 323 | }, 324 | 5, 325 | '123', 326 | { a: 1, b: 2 }, 327 | null 328 | ], 329 | null, 330 | undefined 331 | ] 332 | } 333 | } 334 | 335 | */ 336 | -------------------------------------------------------------------------------- /test/recursive/camelKeysArray.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.camelKeys(obj, { recursive: true, recursiveInArray: true })); 5 | 6 | /** 7 | { 8 | camelCase: 1, 9 | uppercase: 2, 10 | lowercase: 3, 11 | snakeCase: 4, 12 | pascalCase: 5, 13 | titleCase: 6, 14 | dotCase: 7, 15 | paramCase: 8, 16 | sentenceCase: 9, 17 | pathCase: 10, 18 | headerCase: 11, 19 | lv11: { 20 | camelCase: 1, 21 | uppercase: 2, 22 | lowercase: 3, 23 | snakeCase: 4, 24 | pascalCase: 5, 25 | titleCase: 6, 26 | dotCase: 7, 27 | paramCase: 8, 28 | sentenceCase: 9, 29 | pathCase: 10, 30 | headerCase: 11 31 | }, 32 | lv12: { 33 | camelCase: 1, 34 | uppercase: 2, 35 | lowercase: 3, 36 | snakeCase: 4, 37 | pascalCase: 5, 38 | titleCase: 6, 39 | dotCase: 7, 40 | paramCase: 8, 41 | sentenceCase: 9, 42 | pathCase: 10, 43 | headerCase: 11, 44 | lv21: { 45 | camelCase: 1, 46 | uppercase: 2, 47 | lowercase: 3, 48 | snakeCase: 4, 49 | pascalCase: 5, 50 | titleCase: 6, 51 | dotCase: 7, 52 | paramCase: 8, 53 | sentenceCase: 9, 54 | pathCase: 10, 55 | headerCase: 11, 56 | lv31: { 57 | camelCase: 1, 58 | uppercase: 2, 59 | lowercase: 3, 60 | snakeCase: 4, 61 | pascalCase: 5, 62 | titleCase: 6, 63 | dotCase: 7, 64 | paramCase: 8, 65 | sentenceCase: 9, 66 | pathCase: 10, 67 | headerCase: 11 68 | }, 69 | lv32: { 70 | camelCase: 1, 71 | uppercase: 2, 72 | lowercase: 3, 73 | snakeCase: 4, 74 | pascalCase: 5, 75 | titleCase: 6, 76 | dotCase: 7, 77 | paramCase: 8, 78 | sentenceCase: 9, 79 | pathCase: 10, 80 | headerCase: 11 81 | } 82 | }, 83 | lv22: { 84 | camelCase: 1, 85 | uppercase: 2, 86 | lowercase: 3, 87 | snakeCase: 4, 88 | pascalCase: 5, 89 | titleCase: 6, 90 | dotCase: 7, 91 | paramCase: 8, 92 | sentenceCase: 9, 93 | pathCase: 10, 94 | headerCase: 11 95 | }, 96 | lv23: [ 97 | { 98 | camelCase: 1, 99 | uppercase: 2, 100 | lowercase: 3, 101 | snakeCase: 4, 102 | pascalCase: 5, 103 | titleCase: 6, 104 | dotCase: 7, 105 | paramCase: 8, 106 | sentenceCase: 9, 107 | pathCase: 10, 108 | headerCase: 11 109 | }, 110 | { 111 | lv31: [ 112 | 1, 113 | 'A', 114 | null, 115 | { 116 | camelCase: 1, 117 | uppercase: 2, 118 | lowercase: 3, 119 | snakeCase: 4, 120 | pascalCase: 5, 121 | titleCase: 6, 122 | dotCase: 7, 123 | paramCase: 8, 124 | sentenceCase: 9, 125 | pathCase: 10, 126 | headerCase: 11 127 | }, 128 | '123', 129 | undefined 130 | ], 131 | lv32: { 132 | camelCase: 1, 133 | uppercase: 2, 134 | lowercase: 3, 135 | snakeCase: 4, 136 | pascalCase: 5, 137 | titleCase: 6, 138 | dotCase: 7, 139 | paramCase: 8, 140 | sentenceCase: 9, 141 | pathCase: 10, 142 | headerCase: 11 143 | } 144 | }, 145 | [ 146 | { 147 | camelCase: 1, 148 | uppercase: 2, 149 | lowercase: 3, 150 | snakeCase: 4, 151 | pascalCase: 5, 152 | titleCase: 6, 153 | dotCase: 7, 154 | paramCase: 8, 155 | sentenceCase: 9, 156 | pathCase: 10, 157 | headerCase: 11 158 | }, 159 | 5, 160 | '123', 161 | { a: 1, b: 2 }, 162 | null 163 | ], 164 | null, 165 | undefined 166 | ] 167 | } 168 | } 169 | 170 | */ 171 | -------------------------------------------------------------------------------- /test/recursive/lowerKeys.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.lowerKeys(obj)); 5 | console.log('============================================'); 6 | log(jsConvert.lowerKeys(obj, { recursive: true })); 7 | 8 | /** 9 | { 10 | camelcase: 1, 11 | uppercase: 2, 12 | lowercase: 3, 13 | snake_case: 4, 14 | pascalcase: 5, 15 | 'title case': 6, 16 | 'dot.case': 7, 17 | 'param-case': 8, 18 | 'sentence case': 9, 19 | 'path/case': 10, 20 | 'header-case': 11, 21 | lv11: { 22 | camelCase: 1, 23 | UPPERCASE: 2, 24 | lowercase: 3, 25 | snake_case: 4, 26 | PascalCase: 5, 27 | 'Title Case': 6, 28 | 'dot.case': 7, 29 | 'param-case': 8, 30 | 'Sentence case': 9, 31 | 'path/case': 10, 32 | 'Header-Case': 11 33 | }, 34 | lv12: { 35 | camelCase: 1, 36 | UPPERCASE: 2, 37 | lowercase: 3, 38 | snake_case: 4, 39 | PascalCase: 5, 40 | 'Title Case': 6, 41 | 'dot.case': 7, 42 | 'param-case': 8, 43 | 'Sentence case': 9, 44 | 'path/case': 10, 45 | 'Header-Case': 11, 46 | lv21: { 47 | camelCase: 1, 48 | UPPERCASE: 2, 49 | lowercase: 3, 50 | snake_case: 4, 51 | PascalCase: 5, 52 | 'Title Case': 6, 53 | 'dot.case': 7, 54 | 'param-case': 8, 55 | 'Sentence case': 9, 56 | 'path/case': 10, 57 | 'Header-Case': 11, 58 | lv31: { 59 | camelCase: 1, 60 | UPPERCASE: 2, 61 | lowercase: 3, 62 | snake_case: 4, 63 | PascalCase: 5, 64 | 'Title Case': 6, 65 | 'dot.case': 7, 66 | 'param-case': 8, 67 | 'Sentence case': 9, 68 | 'path/case': 10, 69 | 'Header-Case': 11 70 | }, 71 | lv32: { 72 | camelCase: 1, 73 | UPPERCASE: 2, 74 | lowercase: 3, 75 | snake_case: 4, 76 | PascalCase: 5, 77 | 'Title Case': 6, 78 | 'dot.case': 7, 79 | 'param-case': 8, 80 | 'Sentence case': 9, 81 | 'path/case': 10, 82 | 'Header-Case': 11 83 | } 84 | }, 85 | lv22: { 86 | camelCase: 1, 87 | UPPERCASE: 2, 88 | lowercase: 3, 89 | snake_case: 4, 90 | PascalCase: 5, 91 | 'Title Case': 6, 92 | 'dot.case': 7, 93 | 'param-case': 8, 94 | 'Sentence case': 9, 95 | 'path/case': 10, 96 | 'Header-Case': 11 97 | }, 98 | lv23: [ 99 | { 100 | camelCase: 1, 101 | UPPERCASE: 2, 102 | lowercase: 3, 103 | snake_case: 4, 104 | PascalCase: 5, 105 | 'Title Case': 6, 106 | 'dot.case': 7, 107 | 'param-case': 8, 108 | 'Sentence case': 9, 109 | 'path/case': 10, 110 | 'Header-Case': 11 111 | }, 112 | { 113 | lv31: [ 114 | 1, 115 | 'A', 116 | null, 117 | { 118 | camelCase: 1, 119 | UPPERCASE: 2, 120 | lowercase: 3, 121 | snake_case: 4, 122 | PascalCase: 5, 123 | 'Title Case': 6, 124 | 'dot.case': 7, 125 | 'param-case': 8, 126 | 'Sentence case': 9, 127 | 'path/case': 10, 128 | 'Header-Case': 11 129 | }, 130 | '123', 131 | undefined 132 | ], 133 | lv32: { 134 | camelCase: 1, 135 | UPPERCASE: 2, 136 | lowercase: 3, 137 | snake_case: 4, 138 | PascalCase: 5, 139 | 'Title Case': 6, 140 | 'dot.case': 7, 141 | 'param-case': 8, 142 | 'Sentence case': 9, 143 | 'path/case': 10, 144 | 'Header-Case': 11 145 | } 146 | }, 147 | [ 148 | { 149 | camelCase: 1, 150 | UPPERCASE: 2, 151 | lowercase: 3, 152 | snake_case: 4, 153 | PascalCase: 5, 154 | 'Title Case': 6, 155 | 'dot.case': 7, 156 | 'param-case': 8, 157 | 'Sentence case': 9, 158 | 'path/case': 10, 159 | 'Header-Case': 11 160 | }, 161 | 5, 162 | '123', 163 | { a: 1, b: 2 }, 164 | null 165 | ], 166 | null, 167 | undefined 168 | ] 169 | } 170 | } 171 | ============================================ 172 | { 173 | camelcase: 1, 174 | uppercase: 2, 175 | lowercase: 3, 176 | snake_case: 4, 177 | pascalcase: 5, 178 | 'title case': 6, 179 | 'dot.case': 7, 180 | 'param-case': 8, 181 | 'sentence case': 9, 182 | 'path/case': 10, 183 | 'header-case': 11, 184 | lv11: { 185 | camelcase: 1, 186 | uppercase: 2, 187 | lowercase: 3, 188 | snake_case: 4, 189 | pascalcase: 5, 190 | 'title case': 6, 191 | 'dot.case': 7, 192 | 'param-case': 8, 193 | 'sentence case': 9, 194 | 'path/case': 10, 195 | 'header-case': 11 196 | }, 197 | lv12: { 198 | camelcase: 1, 199 | uppercase: 2, 200 | lowercase: 3, 201 | snake_case: 4, 202 | pascalcase: 5, 203 | 'title case': 6, 204 | 'dot.case': 7, 205 | 'param-case': 8, 206 | 'sentence case': 9, 207 | 'path/case': 10, 208 | 'header-case': 11, 209 | lv21: { 210 | camelcase: 1, 211 | uppercase: 2, 212 | lowercase: 3, 213 | snake_case: 4, 214 | pascalcase: 5, 215 | 'title case': 6, 216 | 'dot.case': 7, 217 | 'param-case': 8, 218 | 'sentence case': 9, 219 | 'path/case': 10, 220 | 'header-case': 11, 221 | lv31: { 222 | camelcase: 1, 223 | uppercase: 2, 224 | lowercase: 3, 225 | snake_case: 4, 226 | pascalcase: 5, 227 | 'title case': 6, 228 | 'dot.case': 7, 229 | 'param-case': 8, 230 | 'sentence case': 9, 231 | 'path/case': 10, 232 | 'header-case': 11 233 | }, 234 | lv32: { 235 | camelcase: 1, 236 | uppercase: 2, 237 | lowercase: 3, 238 | snake_case: 4, 239 | pascalcase: 5, 240 | 'title case': 6, 241 | 'dot.case': 7, 242 | 'param-case': 8, 243 | 'sentence case': 9, 244 | 'path/case': 10, 245 | 'header-case': 11 246 | } 247 | }, 248 | lv22: { 249 | camelcase: 1, 250 | uppercase: 2, 251 | lowercase: 3, 252 | snake_case: 4, 253 | pascalcase: 5, 254 | 'title case': 6, 255 | 'dot.case': 7, 256 | 'param-case': 8, 257 | 'sentence case': 9, 258 | 'path/case': 10, 259 | 'header-case': 11 260 | }, 261 | lv23: [ 262 | { 263 | camelCase: 1, 264 | UPPERCASE: 2, 265 | lowercase: 3, 266 | snake_case: 4, 267 | PascalCase: 5, 268 | 'Title Case': 6, 269 | 'dot.case': 7, 270 | 'param-case': 8, 271 | 'Sentence case': 9, 272 | 'path/case': 10, 273 | 'Header-Case': 11 274 | }, 275 | { 276 | lv31: [ 277 | 1, 278 | 'A', 279 | null, 280 | { 281 | camelCase: 1, 282 | UPPERCASE: 2, 283 | lowercase: 3, 284 | snake_case: 4, 285 | PascalCase: 5, 286 | 'Title Case': 6, 287 | 'dot.case': 7, 288 | 'param-case': 8, 289 | 'Sentence case': 9, 290 | 'path/case': 10, 291 | 'Header-Case': 11 292 | }, 293 | '123', 294 | undefined 295 | ], 296 | lv32: { 297 | camelCase: 1, 298 | UPPERCASE: 2, 299 | lowercase: 3, 300 | snake_case: 4, 301 | PascalCase: 5, 302 | 'Title Case': 6, 303 | 'dot.case': 7, 304 | 'param-case': 8, 305 | 'Sentence case': 9, 306 | 'path/case': 10, 307 | 'Header-Case': 11 308 | } 309 | }, 310 | [ 311 | { 312 | camelCase: 1, 313 | UPPERCASE: 2, 314 | lowercase: 3, 315 | snake_case: 4, 316 | PascalCase: 5, 317 | 'Title Case': 6, 318 | 'dot.case': 7, 319 | 'param-case': 8, 320 | 'Sentence case': 9, 321 | 'path/case': 10, 322 | 'Header-Case': 11 323 | }, 324 | 5, 325 | '123', 326 | { a: 1, b: 2 }, 327 | null 328 | ], 329 | null, 330 | undefined 331 | ] 332 | } 333 | } 334 | 335 | 336 | */ 337 | -------------------------------------------------------------------------------- /test/recursive/lowerKeysArray.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.lowerKeys(obj, { recursive: true, recursiveInArray: true })); 5 | 6 | /** 7 | { 8 | camelcase: 1, 9 | uppercase: 2, 10 | lowercase: 3, 11 | snake_case: 4, 12 | pascalcase: 5, 13 | 'title case': 6, 14 | 'dot.case': 7, 15 | 'param-case': 8, 16 | 'sentence case': 9, 17 | 'path/case': 10, 18 | 'header-case': 11, 19 | lv11: { 20 | camelcase: 1, 21 | uppercase: 2, 22 | lowercase: 3, 23 | snake_case: 4, 24 | pascalcase: 5, 25 | 'title case': 6, 26 | 'dot.case': 7, 27 | 'param-case': 8, 28 | 'sentence case': 9, 29 | 'path/case': 10, 30 | 'header-case': 11 31 | }, 32 | lv12: { 33 | camelcase: 1, 34 | uppercase: 2, 35 | lowercase: 3, 36 | snake_case: 4, 37 | pascalcase: 5, 38 | 'title case': 6, 39 | 'dot.case': 7, 40 | 'param-case': 8, 41 | 'sentence case': 9, 42 | 'path/case': 10, 43 | 'header-case': 11, 44 | lv21: { 45 | camelcase: 1, 46 | uppercase: 2, 47 | lowercase: 3, 48 | snake_case: 4, 49 | pascalcase: 5, 50 | 'title case': 6, 51 | 'dot.case': 7, 52 | 'param-case': 8, 53 | 'sentence case': 9, 54 | 'path/case': 10, 55 | 'header-case': 11, 56 | lv31: { 57 | camelcase: 1, 58 | uppercase: 2, 59 | lowercase: 3, 60 | snake_case: 4, 61 | pascalcase: 5, 62 | 'title case': 6, 63 | 'dot.case': 7, 64 | 'param-case': 8, 65 | 'sentence case': 9, 66 | 'path/case': 10, 67 | 'header-case': 11 68 | }, 69 | lv32: { 70 | camelcase: 1, 71 | uppercase: 2, 72 | lowercase: 3, 73 | snake_case: 4, 74 | pascalcase: 5, 75 | 'title case': 6, 76 | 'dot.case': 7, 77 | 'param-case': 8, 78 | 'sentence case': 9, 79 | 'path/case': 10, 80 | 'header-case': 11 81 | } 82 | }, 83 | lv22: { 84 | camelcase: 1, 85 | uppercase: 2, 86 | lowercase: 3, 87 | snake_case: 4, 88 | pascalcase: 5, 89 | 'title case': 6, 90 | 'dot.case': 7, 91 | 'param-case': 8, 92 | 'sentence case': 9, 93 | 'path/case': 10, 94 | 'header-case': 11 95 | }, 96 | lv23: [ 97 | { 98 | camelcase: 1, 99 | uppercase: 2, 100 | lowercase: 3, 101 | snake_case: 4, 102 | pascalcase: 5, 103 | 'title case': 6, 104 | 'dot.case': 7, 105 | 'param-case': 8, 106 | 'sentence case': 9, 107 | 'path/case': 10, 108 | 'header-case': 11 109 | }, 110 | { 111 | lv31: [ 112 | 1, 113 | 'A', 114 | null, 115 | { 116 | camelcase: 1, 117 | uppercase: 2, 118 | lowercase: 3, 119 | snake_case: 4, 120 | pascalcase: 5, 121 | 'title case': 6, 122 | 'dot.case': 7, 123 | 'param-case': 8, 124 | 'sentence case': 9, 125 | 'path/case': 10, 126 | 'header-case': 11 127 | }, 128 | '123', 129 | undefined 130 | ], 131 | lv32: { 132 | camelcase: 1, 133 | uppercase: 2, 134 | lowercase: 3, 135 | snake_case: 4, 136 | pascalcase: 5, 137 | 'title case': 6, 138 | 'dot.case': 7, 139 | 'param-case': 8, 140 | 'sentence case': 9, 141 | 'path/case': 10, 142 | 'header-case': 11 143 | } 144 | }, 145 | [ 146 | { 147 | camelcase: 1, 148 | uppercase: 2, 149 | lowercase: 3, 150 | snake_case: 4, 151 | pascalcase: 5, 152 | 'title case': 6, 153 | 'dot.case': 7, 154 | 'param-case': 8, 155 | 'sentence case': 9, 156 | 'path/case': 10, 157 | 'header-case': 11 158 | }, 159 | 5, 160 | '123', 161 | { a: 1, b: 2 }, 162 | null 163 | ], 164 | null, 165 | undefined 166 | ] 167 | } 168 | } 169 | 170 | */ 171 | -------------------------------------------------------------------------------- /test/recursive/pascalKeys.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.pascalKeys(obj)); 5 | console.log('============================================'); 6 | log(jsConvert.pascalKeys(obj, { recursive: true })); 7 | 8 | /** 9 | { 10 | CamelCase: 1, 11 | Uppercase: 2, 12 | Lowercase: 3, 13 | SnakeCase: 4, 14 | PascalCase: 5, 15 | TitleCase: 6, 16 | DotCase: 7, 17 | ParamCase: 8, 18 | SentenceCase: 9, 19 | PathCase: 10, 20 | HeaderCase: 11, 21 | Lv11: { 22 | camelCase: 1, 23 | UPPERCASE: 2, 24 | lowercase: 3, 25 | snake_case: 4, 26 | PascalCase: 5, 27 | 'Title Case': 6, 28 | 'dot.case': 7, 29 | 'param-case': 8, 30 | 'Sentence case': 9, 31 | 'path/case': 10, 32 | 'Header-Case': 11 33 | }, 34 | Lv12: { 35 | camelCase: 1, 36 | UPPERCASE: 2, 37 | lowercase: 3, 38 | snake_case: 4, 39 | PascalCase: 5, 40 | 'Title Case': 6, 41 | 'dot.case': 7, 42 | 'param-case': 8, 43 | 'Sentence case': 9, 44 | 'path/case': 10, 45 | 'Header-Case': 11, 46 | lv21: { 47 | camelCase: 1, 48 | UPPERCASE: 2, 49 | lowercase: 3, 50 | snake_case: 4, 51 | PascalCase: 5, 52 | 'Title Case': 6, 53 | 'dot.case': 7, 54 | 'param-case': 8, 55 | 'Sentence case': 9, 56 | 'path/case': 10, 57 | 'Header-Case': 11, 58 | lv31: { 59 | camelCase: 1, 60 | UPPERCASE: 2, 61 | lowercase: 3, 62 | snake_case: 4, 63 | PascalCase: 5, 64 | 'Title Case': 6, 65 | 'dot.case': 7, 66 | 'param-case': 8, 67 | 'Sentence case': 9, 68 | 'path/case': 10, 69 | 'Header-Case': 11 70 | }, 71 | lv32: { 72 | camelCase: 1, 73 | UPPERCASE: 2, 74 | lowercase: 3, 75 | snake_case: 4, 76 | PascalCase: 5, 77 | 'Title Case': 6, 78 | 'dot.case': 7, 79 | 'param-case': 8, 80 | 'Sentence case': 9, 81 | 'path/case': 10, 82 | 'Header-Case': 11 83 | } 84 | }, 85 | lv22: { 86 | camelCase: 1, 87 | UPPERCASE: 2, 88 | lowercase: 3, 89 | snake_case: 4, 90 | PascalCase: 5, 91 | 'Title Case': 6, 92 | 'dot.case': 7, 93 | 'param-case': 8, 94 | 'Sentence case': 9, 95 | 'path/case': 10, 96 | 'Header-Case': 11 97 | }, 98 | lv23: [ 99 | { 100 | camelCase: 1, 101 | UPPERCASE: 2, 102 | lowercase: 3, 103 | snake_case: 4, 104 | PascalCase: 5, 105 | 'Title Case': 6, 106 | 'dot.case': 7, 107 | 'param-case': 8, 108 | 'Sentence case': 9, 109 | 'path/case': 10, 110 | 'Header-Case': 11 111 | }, 112 | { 113 | lv31: [ 114 | 1, 115 | 'A', 116 | null, 117 | { 118 | camelCase: 1, 119 | UPPERCASE: 2, 120 | lowercase: 3, 121 | snake_case: 4, 122 | PascalCase: 5, 123 | 'Title Case': 6, 124 | 'dot.case': 7, 125 | 'param-case': 8, 126 | 'Sentence case': 9, 127 | 'path/case': 10, 128 | 'Header-Case': 11 129 | }, 130 | '123', 131 | undefined 132 | ], 133 | lv32: { 134 | camelCase: 1, 135 | UPPERCASE: 2, 136 | lowercase: 3, 137 | snake_case: 4, 138 | PascalCase: 5, 139 | 'Title Case': 6, 140 | 'dot.case': 7, 141 | 'param-case': 8, 142 | 'Sentence case': 9, 143 | 'path/case': 10, 144 | 'Header-Case': 11 145 | } 146 | }, 147 | [ 148 | { 149 | camelCase: 1, 150 | UPPERCASE: 2, 151 | lowercase: 3, 152 | snake_case: 4, 153 | PascalCase: 5, 154 | 'Title Case': 6, 155 | 'dot.case': 7, 156 | 'param-case': 8, 157 | 'Sentence case': 9, 158 | 'path/case': 10, 159 | 'Header-Case': 11 160 | }, 161 | 5, 162 | '123', 163 | { a: 1, b: 2 }, 164 | null 165 | ], 166 | null, 167 | undefined 168 | ] 169 | } 170 | } 171 | ============================================ 172 | { 173 | CamelCase: 1, 174 | Uppercase: 2, 175 | Lowercase: 3, 176 | SnakeCase: 4, 177 | PascalCase: 5, 178 | TitleCase: 6, 179 | DotCase: 7, 180 | ParamCase: 8, 181 | SentenceCase: 9, 182 | PathCase: 10, 183 | HeaderCase: 11, 184 | Lv11: { 185 | CamelCase: 1, 186 | Uppercase: 2, 187 | Lowercase: 3, 188 | SnakeCase: 4, 189 | PascalCase: 5, 190 | TitleCase: 6, 191 | DotCase: 7, 192 | ParamCase: 8, 193 | SentenceCase: 9, 194 | PathCase: 10, 195 | HeaderCase: 11 196 | }, 197 | Lv12: { 198 | CamelCase: 1, 199 | Uppercase: 2, 200 | Lowercase: 3, 201 | SnakeCase: 4, 202 | PascalCase: 5, 203 | TitleCase: 6, 204 | DotCase: 7, 205 | ParamCase: 8, 206 | SentenceCase: 9, 207 | PathCase: 10, 208 | HeaderCase: 11, 209 | Lv21: { 210 | CamelCase: 1, 211 | Uppercase: 2, 212 | Lowercase: 3, 213 | SnakeCase: 4, 214 | PascalCase: 5, 215 | TitleCase: 6, 216 | DotCase: 7, 217 | ParamCase: 8, 218 | SentenceCase: 9, 219 | PathCase: 10, 220 | HeaderCase: 11, 221 | Lv31: { 222 | CamelCase: 1, 223 | Uppercase: 2, 224 | Lowercase: 3, 225 | SnakeCase: 4, 226 | PascalCase: 5, 227 | TitleCase: 6, 228 | DotCase: 7, 229 | ParamCase: 8, 230 | SentenceCase: 9, 231 | PathCase: 10, 232 | HeaderCase: 11 233 | }, 234 | Lv32: { 235 | CamelCase: 1, 236 | Uppercase: 2, 237 | Lowercase: 3, 238 | SnakeCase: 4, 239 | PascalCase: 5, 240 | TitleCase: 6, 241 | DotCase: 7, 242 | ParamCase: 8, 243 | SentenceCase: 9, 244 | PathCase: 10, 245 | HeaderCase: 11 246 | } 247 | }, 248 | Lv22: { 249 | CamelCase: 1, 250 | Uppercase: 2, 251 | Lowercase: 3, 252 | SnakeCase: 4, 253 | PascalCase: 5, 254 | TitleCase: 6, 255 | DotCase: 7, 256 | ParamCase: 8, 257 | SentenceCase: 9, 258 | PathCase: 10, 259 | HeaderCase: 11 260 | }, 261 | Lv23: [ 262 | { 263 | camelCase: 1, 264 | UPPERCASE: 2, 265 | lowercase: 3, 266 | snake_case: 4, 267 | PascalCase: 5, 268 | 'Title Case': 6, 269 | 'dot.case': 7, 270 | 'param-case': 8, 271 | 'Sentence case': 9, 272 | 'path/case': 10, 273 | 'Header-Case': 11 274 | }, 275 | { 276 | lv31: [ 277 | 1, 278 | 'A', 279 | null, 280 | { 281 | camelCase: 1, 282 | UPPERCASE: 2, 283 | lowercase: 3, 284 | snake_case: 4, 285 | PascalCase: 5, 286 | 'Title Case': 6, 287 | 'dot.case': 7, 288 | 'param-case': 8, 289 | 'Sentence case': 9, 290 | 'path/case': 10, 291 | 'Header-Case': 11 292 | }, 293 | '123', 294 | undefined 295 | ], 296 | lv32: { 297 | camelCase: 1, 298 | UPPERCASE: 2, 299 | lowercase: 3, 300 | snake_case: 4, 301 | PascalCase: 5, 302 | 'Title Case': 6, 303 | 'dot.case': 7, 304 | 'param-case': 8, 305 | 'Sentence case': 9, 306 | 'path/case': 10, 307 | 'Header-Case': 11 308 | } 309 | }, 310 | [ 311 | { 312 | camelCase: 1, 313 | UPPERCASE: 2, 314 | lowercase: 3, 315 | snake_case: 4, 316 | PascalCase: 5, 317 | 'Title Case': 6, 318 | 'dot.case': 7, 319 | 'param-case': 8, 320 | 'Sentence case': 9, 321 | 'path/case': 10, 322 | 'Header-Case': 11 323 | }, 324 | 5, 325 | '123', 326 | { a: 1, b: 2 }, 327 | null 328 | ], 329 | null, 330 | undefined 331 | ] 332 | } 333 | } 334 | 335 | */ 336 | -------------------------------------------------------------------------------- /test/recursive/pascalKeysArray.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.pascalKeys(obj, { recursive: true, recursiveInArray: true })); 5 | 6 | /** 7 | { 8 | CamelCase: 1, 9 | Uppercase: 2, 10 | Lowercase: 3, 11 | SnakeCase: 4, 12 | PascalCase: 5, 13 | TitleCase: 6, 14 | DotCase: 7, 15 | ParamCase: 8, 16 | SentenceCase: 9, 17 | PathCase: 10, 18 | HeaderCase: 11, 19 | Lv11: { 20 | CamelCase: 1, 21 | Uppercase: 2, 22 | Lowercase: 3, 23 | SnakeCase: 4, 24 | PascalCase: 5, 25 | TitleCase: 6, 26 | DotCase: 7, 27 | ParamCase: 8, 28 | SentenceCase: 9, 29 | PathCase: 10, 30 | HeaderCase: 11 31 | }, 32 | Lv12: { 33 | CamelCase: 1, 34 | Uppercase: 2, 35 | Lowercase: 3, 36 | SnakeCase: 4, 37 | PascalCase: 5, 38 | TitleCase: 6, 39 | DotCase: 7, 40 | ParamCase: 8, 41 | SentenceCase: 9, 42 | PathCase: 10, 43 | HeaderCase: 11, 44 | Lv21: { 45 | CamelCase: 1, 46 | Uppercase: 2, 47 | Lowercase: 3, 48 | SnakeCase: 4, 49 | PascalCase: 5, 50 | TitleCase: 6, 51 | DotCase: 7, 52 | ParamCase: 8, 53 | SentenceCase: 9, 54 | PathCase: 10, 55 | HeaderCase: 11, 56 | Lv31: { 57 | CamelCase: 1, 58 | Uppercase: 2, 59 | Lowercase: 3, 60 | SnakeCase: 4, 61 | PascalCase: 5, 62 | TitleCase: 6, 63 | DotCase: 7, 64 | ParamCase: 8, 65 | SentenceCase: 9, 66 | PathCase: 10, 67 | HeaderCase: 11 68 | }, 69 | Lv32: { 70 | CamelCase: 1, 71 | Uppercase: 2, 72 | Lowercase: 3, 73 | SnakeCase: 4, 74 | PascalCase: 5, 75 | TitleCase: 6, 76 | DotCase: 7, 77 | ParamCase: 8, 78 | SentenceCase: 9, 79 | PathCase: 10, 80 | HeaderCase: 11 81 | } 82 | }, 83 | Lv22: { 84 | CamelCase: 1, 85 | Uppercase: 2, 86 | Lowercase: 3, 87 | SnakeCase: 4, 88 | PascalCase: 5, 89 | TitleCase: 6, 90 | DotCase: 7, 91 | ParamCase: 8, 92 | SentenceCase: 9, 93 | PathCase: 10, 94 | HeaderCase: 11 95 | }, 96 | Lv23: [ 97 | { 98 | CamelCase: 1, 99 | Uppercase: 2, 100 | Lowercase: 3, 101 | SnakeCase: 4, 102 | PascalCase: 5, 103 | TitleCase: 6, 104 | DotCase: 7, 105 | ParamCase: 8, 106 | SentenceCase: 9, 107 | PathCase: 10, 108 | HeaderCase: 11 109 | }, 110 | { 111 | Lv31: [ 112 | 1, 113 | 'A', 114 | null, 115 | { 116 | CamelCase: 1, 117 | Uppercase: 2, 118 | Lowercase: 3, 119 | SnakeCase: 4, 120 | PascalCase: 5, 121 | TitleCase: 6, 122 | DotCase: 7, 123 | ParamCase: 8, 124 | SentenceCase: 9, 125 | PathCase: 10, 126 | HeaderCase: 11 127 | }, 128 | '123', 129 | undefined 130 | ], 131 | Lv32: { 132 | CamelCase: 1, 133 | Uppercase: 2, 134 | Lowercase: 3, 135 | SnakeCase: 4, 136 | PascalCase: 5, 137 | TitleCase: 6, 138 | DotCase: 7, 139 | ParamCase: 8, 140 | SentenceCase: 9, 141 | PathCase: 10, 142 | HeaderCase: 11 143 | } 144 | }, 145 | undefined, 146 | null, 147 | undefined 148 | ] 149 | } 150 | } 151 | 152 | */ 153 | -------------------------------------------------------------------------------- /test/recursive/snakeKeys.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.snakeKeys(obj)); 5 | console.log('==========================================='); 6 | log(jsConvert.snakeKeys(obj, { recursive: true })); 7 | 8 | /** 9 | { 10 | camel_case: 1, 11 | uppercase: 2, 12 | lowercase: 3, 13 | snake_case: 4, 14 | pascal_case: 5, 15 | title_case: 6, 16 | dot_case: 7, 17 | param_case: 8, 18 | sentence_case: 9, 19 | path_case: 10, 20 | header_case: 11, 21 | lv11: { 22 | camelCase: 1, 23 | UPPERCASE: 2, 24 | lowercase: 3, 25 | snake_case: 4, 26 | PascalCase: 5, 27 | 'Title Case': 6, 28 | 'dot.case': 7, 29 | 'param-case': 8, 30 | 'Sentence case': 9, 31 | 'path/case': 10, 32 | 'Header-Case': 11 33 | }, 34 | lv12: { 35 | camelCase: 1, 36 | UPPERCASE: 2, 37 | lowercase: 3, 38 | snake_case: 4, 39 | PascalCase: 5, 40 | 'Title Case': 6, 41 | 'dot.case': 7, 42 | 'param-case': 8, 43 | 'Sentence case': 9, 44 | 'path/case': 10, 45 | 'Header-Case': 11, 46 | lv21: { 47 | camelCase: 1, 48 | UPPERCASE: 2, 49 | lowercase: 3, 50 | snake_case: 4, 51 | PascalCase: 5, 52 | 'Title Case': 6, 53 | 'dot.case': 7, 54 | 'param-case': 8, 55 | 'Sentence case': 9, 56 | 'path/case': 10, 57 | 'Header-Case': 11, 58 | lv31: { 59 | camelCase: 1, 60 | UPPERCASE: 2, 61 | lowercase: 3, 62 | snake_case: 4, 63 | PascalCase: 5, 64 | 'Title Case': 6, 65 | 'dot.case': 7, 66 | 'param-case': 8, 67 | 'Sentence case': 9, 68 | 'path/case': 10, 69 | 'Header-Case': 11 70 | }, 71 | lv32: { 72 | camelCase: 1, 73 | UPPERCASE: 2, 74 | lowercase: 3, 75 | snake_case: 4, 76 | PascalCase: 5, 77 | 'Title Case': 6, 78 | 'dot.case': 7, 79 | 'param-case': 8, 80 | 'Sentence case': 9, 81 | 'path/case': 10, 82 | 'Header-Case': 11 83 | } 84 | }, 85 | lv22: { 86 | camelCase: 1, 87 | UPPERCASE: 2, 88 | lowercase: 3, 89 | snake_case: 4, 90 | PascalCase: 5, 91 | 'Title Case': 6, 92 | 'dot.case': 7, 93 | 'param-case': 8, 94 | 'Sentence case': 9, 95 | 'path/case': 10, 96 | 'Header-Case': 11 97 | }, 98 | lv23: [ 99 | { 100 | camelCase: 1, 101 | UPPERCASE: 2, 102 | lowercase: 3, 103 | snake_case: 4, 104 | PascalCase: 5, 105 | 'Title Case': 6, 106 | 'dot.case': 7, 107 | 'param-case': 8, 108 | 'Sentence case': 9, 109 | 'path/case': 10, 110 | 'Header-Case': 11 111 | }, 112 | { 113 | lv31: [ 114 | 1, 115 | 'A', 116 | null, 117 | { 118 | camelCase: 1, 119 | UPPERCASE: 2, 120 | lowercase: 3, 121 | snake_case: 4, 122 | PascalCase: 5, 123 | 'Title Case': 6, 124 | 'dot.case': 7, 125 | 'param-case': 8, 126 | 'Sentence case': 9, 127 | 'path/case': 10, 128 | 'Header-Case': 11 129 | }, 130 | '123', 131 | undefined 132 | ], 133 | lv32: { 134 | camelCase: 1, 135 | UPPERCASE: 2, 136 | lowercase: 3, 137 | snake_case: 4, 138 | PascalCase: 5, 139 | 'Title Case': 6, 140 | 'dot.case': 7, 141 | 'param-case': 8, 142 | 'Sentence case': 9, 143 | 'path/case': 10, 144 | 'Header-Case': 11 145 | } 146 | }, 147 | [ 148 | { 149 | camelCase: 1, 150 | UPPERCASE: 2, 151 | lowercase: 3, 152 | snake_case: 4, 153 | PascalCase: 5, 154 | 'Title Case': 6, 155 | 'dot.case': 7, 156 | 'param-case': 8, 157 | 'Sentence case': 9, 158 | 'path/case': 10, 159 | 'Header-Case': 11 160 | }, 161 | 5, 162 | '123', 163 | { a: 1, b: 2 }, 164 | null 165 | ], 166 | null, 167 | undefined 168 | ] 169 | } 170 | } 171 | =========================================== 172 | { 173 | camel_case: 1, 174 | uppercase: 2, 175 | lowercase: 3, 176 | snake_case: 4, 177 | pascal_case: 5, 178 | title_case: 6, 179 | dot_case: 7, 180 | param_case: 8, 181 | sentence_case: 9, 182 | path_case: 10, 183 | header_case: 11, 184 | lv11: { 185 | camel_case: 1, 186 | uppercase: 2, 187 | lowercase: 3, 188 | snake_case: 4, 189 | pascal_case: 5, 190 | title_case: 6, 191 | dot_case: 7, 192 | param_case: 8, 193 | sentence_case: 9, 194 | path_case: 10, 195 | header_case: 11 196 | }, 197 | lv12: { 198 | camel_case: 1, 199 | uppercase: 2, 200 | lowercase: 3, 201 | snake_case: 4, 202 | pascal_case: 5, 203 | title_case: 6, 204 | dot_case: 7, 205 | param_case: 8, 206 | sentence_case: 9, 207 | path_case: 10, 208 | header_case: 11, 209 | lv21: { 210 | camel_case: 1, 211 | uppercase: 2, 212 | lowercase: 3, 213 | snake_case: 4, 214 | pascal_case: 5, 215 | title_case: 6, 216 | dot_case: 7, 217 | param_case: 8, 218 | sentence_case: 9, 219 | path_case: 10, 220 | header_case: 11, 221 | lv31: { 222 | camel_case: 1, 223 | uppercase: 2, 224 | lowercase: 3, 225 | snake_case: 4, 226 | pascal_case: 5, 227 | title_case: 6, 228 | dot_case: 7, 229 | param_case: 8, 230 | sentence_case: 9, 231 | path_case: 10, 232 | header_case: 11 233 | }, 234 | lv32: { 235 | camel_case: 1, 236 | uppercase: 2, 237 | lowercase: 3, 238 | snake_case: 4, 239 | pascal_case: 5, 240 | title_case: 6, 241 | dot_case: 7, 242 | param_case: 8, 243 | sentence_case: 9, 244 | path_case: 10, 245 | header_case: 11 246 | } 247 | }, 248 | lv22: { 249 | camel_case: 1, 250 | uppercase: 2, 251 | lowercase: 3, 252 | snake_case: 4, 253 | pascal_case: 5, 254 | title_case: 6, 255 | dot_case: 7, 256 | param_case: 8, 257 | sentence_case: 9, 258 | path_case: 10, 259 | header_case: 11 260 | }, 261 | lv23: [ 262 | { 263 | camelCase: 1, 264 | UPPERCASE: 2, 265 | lowercase: 3, 266 | snake_case: 4, 267 | PascalCase: 5, 268 | 'Title Case': 6, 269 | 'dot.case': 7, 270 | 'param-case': 8, 271 | 'Sentence case': 9, 272 | 'path/case': 10, 273 | 'Header-Case': 11 274 | }, 275 | { 276 | lv31: [ 277 | 1, 278 | 'A', 279 | null, 280 | { 281 | camelCase: 1, 282 | UPPERCASE: 2, 283 | lowercase: 3, 284 | snake_case: 4, 285 | PascalCase: 5, 286 | 'Title Case': 6, 287 | 'dot.case': 7, 288 | 'param-case': 8, 289 | 'Sentence case': 9, 290 | 'path/case': 10, 291 | 'Header-Case': 11 292 | }, 293 | '123', 294 | undefined 295 | ], 296 | lv32: { 297 | camelCase: 1, 298 | UPPERCASE: 2, 299 | lowercase: 3, 300 | snake_case: 4, 301 | PascalCase: 5, 302 | 'Title Case': 6, 303 | 'dot.case': 7, 304 | 'param-case': 8, 305 | 'Sentence case': 9, 306 | 'path/case': 10, 307 | 'Header-Case': 11 308 | } 309 | }, 310 | [ 311 | { 312 | camelCase: 1, 313 | UPPERCASE: 2, 314 | lowercase: 3, 315 | snake_case: 4, 316 | PascalCase: 5, 317 | 'Title Case': 6, 318 | 'dot.case': 7, 319 | 'param-case': 8, 320 | 'Sentence case': 9, 321 | 'path/case': 10, 322 | 'Header-Case': 11 323 | }, 324 | 5, 325 | '123', 326 | { a: 1, b: 2 }, 327 | null 328 | ], 329 | null, 330 | undefined 331 | ] 332 | } 333 | } 334 | 335 | */ 336 | -------------------------------------------------------------------------------- /test/recursive/snakeKeysArray.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.snakeKeys(obj, { recursive: true, recursiveInArray: true })); 5 | 6 | /** 7 | { 8 | camel_case: 1, 9 | uppercase: 2, 10 | lowercase: 3, 11 | snake_case: 4, 12 | pascal_case: 5, 13 | title_case: 6, 14 | dot_case: 7, 15 | param_case: 8, 16 | sentence_case: 9, 17 | path_case: 10, 18 | header_case: 11, 19 | lv11: { 20 | camel_case: 1, 21 | uppercase: 2, 22 | lowercase: 3, 23 | snake_case: 4, 24 | pascal_case: 5, 25 | title_case: 6, 26 | dot_case: 7, 27 | param_case: 8, 28 | sentence_case: 9, 29 | path_case: 10, 30 | header_case: 11 31 | }, 32 | lv12: { 33 | camel_case: 1, 34 | uppercase: 2, 35 | lowercase: 3, 36 | snake_case: 4, 37 | pascal_case: 5, 38 | title_case: 6, 39 | dot_case: 7, 40 | param_case: 8, 41 | sentence_case: 9, 42 | path_case: 10, 43 | header_case: 11, 44 | lv21: { 45 | camel_case: 1, 46 | uppercase: 2, 47 | lowercase: 3, 48 | snake_case: 4, 49 | pascal_case: 5, 50 | title_case: 6, 51 | dot_case: 7, 52 | param_case: 8, 53 | sentence_case: 9, 54 | path_case: 10, 55 | header_case: 11, 56 | lv31: { 57 | camel_case: 1, 58 | uppercase: 2, 59 | lowercase: 3, 60 | snake_case: 4, 61 | pascal_case: 5, 62 | title_case: 6, 63 | dot_case: 7, 64 | param_case: 8, 65 | sentence_case: 9, 66 | path_case: 10, 67 | header_case: 11 68 | }, 69 | lv32: { 70 | camel_case: 1, 71 | uppercase: 2, 72 | lowercase: 3, 73 | snake_case: 4, 74 | pascal_case: 5, 75 | title_case: 6, 76 | dot_case: 7, 77 | param_case: 8, 78 | sentence_case: 9, 79 | path_case: 10, 80 | header_case: 11 81 | } 82 | }, 83 | lv22: { 84 | camel_case: 1, 85 | uppercase: 2, 86 | lowercase: 3, 87 | snake_case: 4, 88 | pascal_case: 5, 89 | title_case: 6, 90 | dot_case: 7, 91 | param_case: 8, 92 | sentence_case: 9, 93 | path_case: 10, 94 | header_case: 11 95 | }, 96 | lv23: [ 97 | { 98 | camel_case: 1, 99 | uppercase: 2, 100 | lowercase: 3, 101 | snake_case: 4, 102 | pascal_case: 5, 103 | title_case: 6, 104 | dot_case: 7, 105 | param_case: 8, 106 | sentence_case: 9, 107 | path_case: 10, 108 | header_case: 11 109 | }, 110 | { 111 | lv31: [ 112 | 1, 113 | 'A', 114 | null, 115 | { 116 | camel_case: 1, 117 | uppercase: 2, 118 | lowercase: 3, 119 | snake_case: 4, 120 | pascal_case: 5, 121 | title_case: 6, 122 | dot_case: 7, 123 | param_case: 8, 124 | sentence_case: 9, 125 | path_case: 10, 126 | header_case: 11 127 | }, 128 | '123', 129 | undefined 130 | ], 131 | lv32: { 132 | camel_case: 1, 133 | uppercase: 2, 134 | lowercase: 3, 135 | snake_case: 4, 136 | pascal_case: 5, 137 | title_case: 6, 138 | dot_case: 7, 139 | param_case: 8, 140 | sentence_case: 9, 141 | path_case: 10, 142 | header_case: 11 143 | } 144 | }, 145 | [ 146 | { 147 | camel_case: 1, 148 | uppercase: 2, 149 | lowercase: 3, 150 | snake_case: 4, 151 | pascal_case: 5, 152 | title_case: 6, 153 | dot_case: 7, 154 | param_case: 8, 155 | sentence_case: 9, 156 | path_case: 10, 157 | header_case: 11 158 | }, 159 | 5, 160 | '123', 161 | { a: 1, b: 2 }, 162 | null 163 | ], 164 | null, 165 | undefined 166 | ] 167 | } 168 | } 169 | 170 | 171 | */ 172 | -------------------------------------------------------------------------------- /test/recursive/special/objects.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../../index'); 2 | 3 | function Car() { 4 | this.id = Date.now(); 5 | } 6 | 7 | function Car2() { 8 | this.id = Date.now(); 9 | } 10 | 11 | const Types = [Date, Car, Car2, RegExp]; 12 | // const Types = [Car, Car2]; 13 | // const Types = []; 14 | // const Types = null; 15 | // const Types = [Car, Car2, new Date()]; 16 | console.log(Types); 17 | 18 | const car = new Car(); 19 | console.log(Car.prototype); 20 | console.log(Car2.prototype); 21 | console.log(car); 22 | console.log(car instanceof Car); // true 23 | console.log(car instanceof Car2); // false 24 | console.log(car instanceof Object); // true 25 | 26 | 27 | const obj = { 28 | Id: Date.now(), 29 | DateObject: new Date() 30 | }; 31 | 32 | try { 33 | const ret = jsConvert.camelKeys(obj, { recursive: false, recursiveInArray: false, keepTypesOnRecursion: Types }); 34 | console.log(ret); 35 | Object.keys(ret).forEach((k) => { 36 | console.log(typeof ret[k]); 37 | }); 38 | } catch (ex) { 39 | console.log(ex); 40 | } 41 | 42 | try { 43 | const ret = jsConvert.camelKeys(obj, { recursive: true, recursiveInArray: true, keepTypesOnRecursion: Types }); 44 | console.log(ret); 45 | Object.keys(ret).forEach((k) => { 46 | console.log(typeof ret[k]); 47 | }); 48 | } catch (ex) { 49 | console.log(ex); 50 | } 51 | -------------------------------------------------------------------------------- /test/recursive/upperKeys.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.upperKeys(obj)); 5 | console.log('============================================'); 6 | log(jsConvert.upperKeys(obj, { recursive: true })); 7 | 8 | /** 9 | { 10 | CAMELCASE: 1, 11 | UPPERCASE: 2, 12 | LOWERCASE: 3, 13 | SNAKE_CASE: 4, 14 | PASCALCASE: 5, 15 | 'TITLE CASE': 6, 16 | 'DOT.CASE': 7, 17 | 'PARAM-CASE': 8, 18 | 'SENTENCE CASE': 9, 19 | 'PATH/CASE': 10, 20 | 'HEADER-CASE': 11, 21 | LV11: { 22 | camelCase: 1, 23 | UPPERCASE: 2, 24 | lowercase: 3, 25 | snake_case: 4, 26 | PascalCase: 5, 27 | 'Title Case': 6, 28 | 'dot.case': 7, 29 | 'param-case': 8, 30 | 'Sentence case': 9, 31 | 'path/case': 10, 32 | 'Header-Case': 11 33 | }, 34 | LV12: { 35 | camelCase: 1, 36 | UPPERCASE: 2, 37 | lowercase: 3, 38 | snake_case: 4, 39 | PascalCase: 5, 40 | 'Title Case': 6, 41 | 'dot.case': 7, 42 | 'param-case': 8, 43 | 'Sentence case': 9, 44 | 'path/case': 10, 45 | 'Header-Case': 11, 46 | lv21: { 47 | camelCase: 1, 48 | UPPERCASE: 2, 49 | lowercase: 3, 50 | snake_case: 4, 51 | PascalCase: 5, 52 | 'Title Case': 6, 53 | 'dot.case': 7, 54 | 'param-case': 8, 55 | 'Sentence case': 9, 56 | 'path/case': 10, 57 | 'Header-Case': 11, 58 | lv31: { 59 | camelCase: 1, 60 | UPPERCASE: 2, 61 | lowercase: 3, 62 | snake_case: 4, 63 | PascalCase: 5, 64 | 'Title Case': 6, 65 | 'dot.case': 7, 66 | 'param-case': 8, 67 | 'Sentence case': 9, 68 | 'path/case': 10, 69 | 'Header-Case': 11 70 | }, 71 | lv32: { 72 | camelCase: 1, 73 | UPPERCASE: 2, 74 | lowercase: 3, 75 | snake_case: 4, 76 | PascalCase: 5, 77 | 'Title Case': 6, 78 | 'dot.case': 7, 79 | 'param-case': 8, 80 | 'Sentence case': 9, 81 | 'path/case': 10, 82 | 'Header-Case': 11 83 | } 84 | }, 85 | lv22: { 86 | camelCase: 1, 87 | UPPERCASE: 2, 88 | lowercase: 3, 89 | snake_case: 4, 90 | PascalCase: 5, 91 | 'Title Case': 6, 92 | 'dot.case': 7, 93 | 'param-case': 8, 94 | 'Sentence case': 9, 95 | 'path/case': 10, 96 | 'Header-Case': 11 97 | }, 98 | lv23: [ 99 | { 100 | camelCase: 1, 101 | UPPERCASE: 2, 102 | lowercase: 3, 103 | snake_case: 4, 104 | PascalCase: 5, 105 | 'Title Case': 6, 106 | 'dot.case': 7, 107 | 'param-case': 8, 108 | 'Sentence case': 9, 109 | 'path/case': 10, 110 | 'Header-Case': 11 111 | }, 112 | { 113 | lv31: [ 114 | 1, 115 | 'A', 116 | null, 117 | { 118 | camelCase: 1, 119 | UPPERCASE: 2, 120 | lowercase: 3, 121 | snake_case: 4, 122 | PascalCase: 5, 123 | 'Title Case': 6, 124 | 'dot.case': 7, 125 | 'param-case': 8, 126 | 'Sentence case': 9, 127 | 'path/case': 10, 128 | 'Header-Case': 11 129 | }, 130 | '123', 131 | undefined 132 | ], 133 | lv32: { 134 | camelCase: 1, 135 | UPPERCASE: 2, 136 | lowercase: 3, 137 | snake_case: 4, 138 | PascalCase: 5, 139 | 'Title Case': 6, 140 | 'dot.case': 7, 141 | 'param-case': 8, 142 | 'Sentence case': 9, 143 | 'path/case': 10, 144 | 'Header-Case': 11 145 | } 146 | }, 147 | [ 148 | { 149 | camelCase: 1, 150 | UPPERCASE: 2, 151 | lowercase: 3, 152 | snake_case: 4, 153 | PascalCase: 5, 154 | 'Title Case': 6, 155 | 'dot.case': 7, 156 | 'param-case': 8, 157 | 'Sentence case': 9, 158 | 'path/case': 10, 159 | 'Header-Case': 11 160 | }, 161 | 5, 162 | '123', 163 | { a: 1, b: 2 }, 164 | null 165 | ], 166 | null, 167 | undefined 168 | ] 169 | } 170 | } 171 | ============================================ 172 | { 173 | CAMELCASE: 1, 174 | UPPERCASE: 2, 175 | LOWERCASE: 3, 176 | SNAKE_CASE: 4, 177 | PASCALCASE: 5, 178 | 'TITLE CASE': 6, 179 | 'DOT.CASE': 7, 180 | 'PARAM-CASE': 8, 181 | 'SENTENCE CASE': 9, 182 | 'PATH/CASE': 10, 183 | 'HEADER-CASE': 11, 184 | LV11: { 185 | CAMELCASE: 1, 186 | UPPERCASE: 2, 187 | LOWERCASE: 3, 188 | SNAKE_CASE: 4, 189 | PASCALCASE: 5, 190 | 'TITLE CASE': 6, 191 | 'DOT.CASE': 7, 192 | 'PARAM-CASE': 8, 193 | 'SENTENCE CASE': 9, 194 | 'PATH/CASE': 10, 195 | 'HEADER-CASE': 11 196 | }, 197 | LV12: { 198 | CAMELCASE: 1, 199 | UPPERCASE: 2, 200 | LOWERCASE: 3, 201 | SNAKE_CASE: 4, 202 | PASCALCASE: 5, 203 | 'TITLE CASE': 6, 204 | 'DOT.CASE': 7, 205 | 'PARAM-CASE': 8, 206 | 'SENTENCE CASE': 9, 207 | 'PATH/CASE': 10, 208 | 'HEADER-CASE': 11, 209 | LV21: { 210 | CAMELCASE: 1, 211 | UPPERCASE: 2, 212 | LOWERCASE: 3, 213 | SNAKE_CASE: 4, 214 | PASCALCASE: 5, 215 | 'TITLE CASE': 6, 216 | 'DOT.CASE': 7, 217 | 'PARAM-CASE': 8, 218 | 'SENTENCE CASE': 9, 219 | 'PATH/CASE': 10, 220 | 'HEADER-CASE': 11, 221 | LV31: { 222 | CAMELCASE: 1, 223 | UPPERCASE: 2, 224 | LOWERCASE: 3, 225 | SNAKE_CASE: 4, 226 | PASCALCASE: 5, 227 | 'TITLE CASE': 6, 228 | 'DOT.CASE': 7, 229 | 'PARAM-CASE': 8, 230 | 'SENTENCE CASE': 9, 231 | 'PATH/CASE': 10, 232 | 'HEADER-CASE': 11 233 | }, 234 | LV32: { 235 | CAMELCASE: 1, 236 | UPPERCASE: 2, 237 | LOWERCASE: 3, 238 | SNAKE_CASE: 4, 239 | PASCALCASE: 5, 240 | 'TITLE CASE': 6, 241 | 'DOT.CASE': 7, 242 | 'PARAM-CASE': 8, 243 | 'SENTENCE CASE': 9, 244 | 'PATH/CASE': 10, 245 | 'HEADER-CASE': 11 246 | } 247 | }, 248 | LV22: { 249 | CAMELCASE: 1, 250 | UPPERCASE: 2, 251 | LOWERCASE: 3, 252 | SNAKE_CASE: 4, 253 | PASCALCASE: 5, 254 | 'TITLE CASE': 6, 255 | 'DOT.CASE': 7, 256 | 'PARAM-CASE': 8, 257 | 'SENTENCE CASE': 9, 258 | 'PATH/CASE': 10, 259 | 'HEADER-CASE': 11 260 | }, 261 | LV23: [ 262 | { 263 | camelCase: 1, 264 | UPPERCASE: 2, 265 | lowercase: 3, 266 | snake_case: 4, 267 | PascalCase: 5, 268 | 'Title Case': 6, 269 | 'dot.case': 7, 270 | 'param-case': 8, 271 | 'Sentence case': 9, 272 | 'path/case': 10, 273 | 'Header-Case': 11 274 | }, 275 | { 276 | lv31: [ 277 | 1, 278 | 'A', 279 | null, 280 | { 281 | camelCase: 1, 282 | UPPERCASE: 2, 283 | lowercase: 3, 284 | snake_case: 4, 285 | PascalCase: 5, 286 | 'Title Case': 6, 287 | 'dot.case': 7, 288 | 'param-case': 8, 289 | 'Sentence case': 9, 290 | 'path/case': 10, 291 | 'Header-Case': 11 292 | }, 293 | '123', 294 | undefined 295 | ], 296 | lv32: { 297 | camelCase: 1, 298 | UPPERCASE: 2, 299 | lowercase: 3, 300 | snake_case: 4, 301 | PascalCase: 5, 302 | 'Title Case': 6, 303 | 'dot.case': 7, 304 | 'param-case': 8, 305 | 'Sentence case': 9, 306 | 'path/case': 10, 307 | 'Header-Case': 11 308 | } 309 | }, 310 | [ 311 | { 312 | camelCase: 1, 313 | UPPERCASE: 2, 314 | lowercase: 3, 315 | snake_case: 4, 316 | PascalCase: 5, 317 | 'Title Case': 6, 318 | 'dot.case': 7, 319 | 'param-case': 8, 320 | 'Sentence case': 9, 321 | 'path/case': 10, 322 | 'Header-Case': 11 323 | }, 324 | 5, 325 | '123', 326 | { a: 1, b: 2 }, 327 | null 328 | ], 329 | null, 330 | undefined 331 | ] 332 | } 333 | } 334 | 335 | */ 336 | -------------------------------------------------------------------------------- /test/recursive/upperKeysArray.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | const { obj, log } = require('./_shared'); 3 | 4 | log(jsConvert.upperKeys(obj, { recursive: true, recursiveInArray: true })); 5 | 6 | /** 7 | { 8 | CAMELCASE: 1, 9 | UPPERCASE: 2, 10 | LOWERCASE: 3, 11 | SNAKE_CASE: 4, 12 | PASCALCASE: 5, 13 | 'TITLE CASE': 6, 14 | 'DOT.CASE': 7, 15 | 'PARAM-CASE': 8, 16 | 'SENTENCE CASE': 9, 17 | 'PATH/CASE': 10, 18 | 'HEADER-CASE': 11, 19 | LV11: { 20 | CAMELCASE: 1, 21 | UPPERCASE: 2, 22 | LOWERCASE: 3, 23 | SNAKE_CASE: 4, 24 | PASCALCASE: 5, 25 | 'TITLE CASE': 6, 26 | 'DOT.CASE': 7, 27 | 'PARAM-CASE': 8, 28 | 'SENTENCE CASE': 9, 29 | 'PATH/CASE': 10, 30 | 'HEADER-CASE': 11 31 | }, 32 | LV12: { 33 | CAMELCASE: 1, 34 | UPPERCASE: 2, 35 | LOWERCASE: 3, 36 | SNAKE_CASE: 4, 37 | PASCALCASE: 5, 38 | 'TITLE CASE': 6, 39 | 'DOT.CASE': 7, 40 | 'PARAM-CASE': 8, 41 | 'SENTENCE CASE': 9, 42 | 'PATH/CASE': 10, 43 | 'HEADER-CASE': 11, 44 | LV21: { 45 | CAMELCASE: 1, 46 | UPPERCASE: 2, 47 | LOWERCASE: 3, 48 | SNAKE_CASE: 4, 49 | PASCALCASE: 5, 50 | 'TITLE CASE': 6, 51 | 'DOT.CASE': 7, 52 | 'PARAM-CASE': 8, 53 | 'SENTENCE CASE': 9, 54 | 'PATH/CASE': 10, 55 | 'HEADER-CASE': 11, 56 | LV31: { 57 | CAMELCASE: 1, 58 | UPPERCASE: 2, 59 | LOWERCASE: 3, 60 | SNAKE_CASE: 4, 61 | PASCALCASE: 5, 62 | 'TITLE CASE': 6, 63 | 'DOT.CASE': 7, 64 | 'PARAM-CASE': 8, 65 | 'SENTENCE CASE': 9, 66 | 'PATH/CASE': 10, 67 | 'HEADER-CASE': 11 68 | }, 69 | LV32: { 70 | CAMELCASE: 1, 71 | UPPERCASE: 2, 72 | LOWERCASE: 3, 73 | SNAKE_CASE: 4, 74 | PASCALCASE: 5, 75 | 'TITLE CASE': 6, 76 | 'DOT.CASE': 7, 77 | 'PARAM-CASE': 8, 78 | 'SENTENCE CASE': 9, 79 | 'PATH/CASE': 10, 80 | 'HEADER-CASE': 11 81 | } 82 | }, 83 | LV22: { 84 | CAMELCASE: 1, 85 | UPPERCASE: 2, 86 | LOWERCASE: 3, 87 | SNAKE_CASE: 4, 88 | PASCALCASE: 5, 89 | 'TITLE CASE': 6, 90 | 'DOT.CASE': 7, 91 | 'PARAM-CASE': 8, 92 | 'SENTENCE CASE': 9, 93 | 'PATH/CASE': 10, 94 | 'HEADER-CASE': 11 95 | }, 96 | LV23: [ 97 | { 98 | CAMELCASE: 1, 99 | UPPERCASE: 2, 100 | LOWERCASE: 3, 101 | SNAKE_CASE: 4, 102 | PASCALCASE: 5, 103 | 'TITLE CASE': 6, 104 | 'DOT.CASE': 7, 105 | 'PARAM-CASE': 8, 106 | 'SENTENCE CASE': 9, 107 | 'PATH/CASE': 10, 108 | 'HEADER-CASE': 11 109 | }, 110 | { 111 | LV31: [ 112 | 1, 113 | 'A', 114 | null, 115 | { 116 | CAMELCASE: 1, 117 | UPPERCASE: 2, 118 | LOWERCASE: 3, 119 | SNAKE_CASE: 4, 120 | PASCALCASE: 5, 121 | 'TITLE CASE': 6, 122 | 'DOT.CASE': 7, 123 | 'PARAM-CASE': 8, 124 | 'SENTENCE CASE': 9, 125 | 'PATH/CASE': 10, 126 | 'HEADER-CASE': 11 127 | }, 128 | '123', 129 | undefined 130 | ], 131 | LV32: { 132 | CAMELCASE: 1, 133 | UPPERCASE: 2, 134 | LOWERCASE: 3, 135 | SNAKE_CASE: 4, 136 | PASCALCASE: 5, 137 | 'TITLE CASE': 6, 138 | 'DOT.CASE': 7, 139 | 'PARAM-CASE': 8, 140 | 'SENTENCE CASE': 9, 141 | 'PATH/CASE': 10, 142 | 'HEADER-CASE': 11 143 | } 144 | }, 145 | undefined, 146 | null, 147 | undefined 148 | ] 149 | } 150 | } 151 | 152 | */ 153 | -------------------------------------------------------------------------------- /test/release/core.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('../../index'); 2 | 3 | console.log(jsConvert.toCamelCase('param-case')); // paramCase 4 | console.log(jsConvert.toCamelCase('camelCase')); // camelCase 5 | console.log(jsConvert.toCamelCase('Title Case')); // titleCase 6 | 7 | console.log(jsConvert.toSnakeCase('param-case')); // param_case 8 | console.log(jsConvert.toSnakeCase('camelCase')); // camel_case 9 | console.log(jsConvert.toSnakeCase('Title Case')); // title_case 10 | 11 | console.log(jsConvert.toPascalCase('param-case')); // ParamCase 12 | console.log(jsConvert.toPascalCase('camelCase')); // CamelCase 13 | console.log(jsConvert.toPascalCase('Title Case')); // TitleCase 14 | 15 | console.log(jsConvert.toDotCase('param-case')); // param.case 16 | console.log(jsConvert.toDotCase('camelCase')); // camel.case 17 | console.log(jsConvert.toDotCase('Title Case')); // title.case 18 | 19 | console.log(jsConvert.toPathCase('param-case')); // param/case 20 | console.log(jsConvert.toPathCase('camelCase')); // camel/case 21 | console.log(jsConvert.toPathCase('Title Case')); // title/case 22 | 23 | console.log(jsConvert.toTextCase('param-case')); // param case 24 | console.log(jsConvert.toTextCase('camelCase')); // camel case 25 | console.log(jsConvert.toTextCase('Title Case')); // title case 26 | 27 | console.log(jsConvert.toSentenceCase('param-case')); // Param case 28 | console.log(jsConvert.toSentenceCase('camelCase')); // Camel case 29 | console.log(jsConvert.toSentenceCase('Title Case')); // Title case 30 | 31 | console.log(jsConvert.toHeaderCase('param-case')); // Param Case 32 | console.log(jsConvert.toHeaderCase('camelCase')); // Camel Case 33 | console.log(jsConvert.toHeaderCase('Title Case')); // Title Case 34 | 35 | console.log(jsConvert.toLowerCase('param-case')); // param-case 36 | console.log(jsConvert.toLowerCase('Title Case')); // title case 37 | console.log(jsConvert.toUpperCase('param-case')); // PARAM-CASE 38 | console.log(jsConvert.toUpperCase('Title Case')); // TITLE CASE 39 | 40 | 41 | // Specific values 42 | console.log(jsConvert.toCamelCase('')); // => '' 43 | console.log(jsConvert.toSnakeCase(null)); // => '' 44 | console.log(jsConvert.toPascalCase(undefined)); // => '' 45 | 46 | // Complicated values 47 | const str = '!@#$ = Hello___world ..<>| \\ 123_ _456 & l sn_ca - cmCa - PcCa - dot.ca - txt ca - Sen ca - Hd Ca %^$^%&'; 48 | console.log(jsConvert.toCamelCase(str)); // => 'helloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 49 | console.log(jsConvert.toPascalCase(str)); // => 'HelloWorld123456LSnCaCmCaPcCaDotCaTxtCaSenCaHdCa' 50 | console.log(jsConvert.toSnakeCase(str)); // => 'hello_world_123_456_l_sn_ca_cm_ca_pc_ca_dot_ca_txt_ca_sen_ca_hd_ca' 51 | console.log(jsConvert.toDotCase(str)); // => 'hello.world.123.456.l.sn.ca.cm.ca.pc.ca.dot.ca.txt.ca.sen.ca.hd.ca' 52 | console.log(jsConvert.toPathCase(str)); // => 'hello/world/123/456/l/sn/ca/cm/ca/pc/ca/dot/ca/txt/ca/sen/ca/hd/ca' 53 | console.log(jsConvert.toTextCase(str)); // => 'hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 54 | console.log(jsConvert.toSentenceCase(str)); // => 'Hello world 123 456 l sn ca cm ca pc ca dot ca txt ca sen ca hd ca' 55 | console.log(jsConvert.toHeaderCase(str)); // => 'Hello World 123 456 L Sn Ca Cm Ca Pc Ca Dot Ca Txt Ca Sen Ca Hd Ca' 56 | -------------------------------------------------------------------------------- /test/release/extends.js: -------------------------------------------------------------------------------- 1 | const jsConvert = require('js-convert-case'); 2 | 3 | // null or undefined, output is `null` 4 | console.log(jsConvert.lowerKeys(undefined)); 5 | console.log(jsConvert.lowerKeys(null)); 6 | console.log(jsConvert.upperKeys(undefined)); 7 | console.log(jsConvert.upperKeys(null)); 8 | console.log(jsConvert.camelKeys(undefined)); 9 | console.log(jsConvert.camelKeys(null)); 10 | console.log(jsConvert.snakeKeys(undefined)); 11 | console.log(jsConvert.snakeKeys(null)); 12 | console.log(jsConvert.pascalKeys(undefined)); 13 | console.log(jsConvert.pascalKeys(null)); 14 | 15 | // invalid json object, output is `null` 16 | console.log(jsConvert.lowerKeys(1)); 17 | console.log(jsConvert.lowerKeys('abc')); 18 | console.log(jsConvert.lowerKeys([1, 2, 3])); 19 | console.log(jsConvert.upperKeys(1)); 20 | console.log(jsConvert.upperKeys('abc')); 21 | console.log(jsConvert.upperKeys([1, 2, 3])); 22 | console.log(jsConvert.camelKeys(1)); 23 | console.log(jsConvert.camelKeys('abc')); 24 | console.log(jsConvert.camelKeys([1, 2, 3])); 25 | console.log(jsConvert.snakeKeys(1)); 26 | console.log(jsConvert.snakeKeys('abc')); 27 | console.log(jsConvert.snakeKeys([1, 2, 3])); 28 | console.log(jsConvert.pascalKeys(1)); 29 | console.log(jsConvert.pascalKeys('abc')); 30 | console.log(jsConvert.pascalKeys([1, 2, 3])); 31 | 32 | // Object convert case 33 | const obj = { 34 | camelCase: 1, 35 | UPPERCASE: 2, 36 | lowercase: 3, 37 | snake_case: 4, 38 | PascalCase: 5, 39 | 'Title Case': 6, 40 | 'dot.case': 7, 41 | 'param-case': 8, 42 | 'Sentence case': 9, 43 | 'path/case': 10, 44 | 'Header-Case': 11 45 | }; 46 | 47 | console.log(jsConvert.lowerKeys(obj)); 48 | console.log(jsConvert.upperKeys(obj)); 49 | console.log(jsConvert.camelKeys(obj)); 50 | console.log(jsConvert.snakeKeys(obj)); 51 | console.log(jsConvert.pascalKeys(obj)); 52 | 53 | /** 54 | { camelcase: 1, 55 | uppercase: 2, 56 | lowercase: 3, 57 | snake_case: 4, 58 | pascalcase: 5, 59 | 'title case': 6, 60 | 'dot.case': 7, 61 | 'param-case': 8, 62 | 'sentence case': 9, 63 | 'path/case': 10, 64 | 'header-case': 11 } 65 | 66 | { CAMELCASE: 1, 67 | UPPERCASE: 2, 68 | LOWERCASE: 3, 69 | SNAKE_CASE: 4, 70 | PASCALCASE: 5, 71 | 'TITLE CASE': 6, 72 | 'DOT.CASE': 7, 73 | 'PARAM-CASE': 8, 74 | 'SENTENCE CASE': 9, 75 | 'PATH/CASE': 10, 76 | 'HEADER-CASE': 11 } 77 | 78 | { camelCase: 1, 79 | uppercase: 2, 80 | lowercase: 3, 81 | snakeCase: 4, 82 | pascalCase: 5, 83 | titleCase: 6, 84 | dotCase: 7, 85 | paramCase: 8, 86 | sentenceCase: 9, 87 | pathCase: 10, 88 | headerCase: 11 } 89 | 90 | { camel_case: 1, 91 | uppercase: 2, 92 | lowercase: 3, 93 | snake_case: 4, 94 | pascal_case: 5, 95 | title_case: 6, 96 | dot_case: 7, 97 | param_case: 8, 98 | sentence_case: 9, 99 | path_case: 10, 100 | header_case: 11 } 101 | 102 | { CamelCase: 1, 103 | Uppercase: 2, 104 | Lowercase: 3, 105 | SnakeCase: 4, 106 | PascalCase: 5, 107 | TitleCase: 6, 108 | DotCase: 7, 109 | ParamCase: 8, 110 | SentenceCase: 9, 111 | PathCase: 10, 112 | HeaderCase: 11 } 113 | */ 114 | -------------------------------------------------------------------------------- /test/release/package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "jsconvert-test-release", 3 | "version": "1.0.0", 4 | "main": "index.js", 5 | "license": "MIT", 6 | "dependencies": { 7 | "js-convert-case": "^4.0.1" 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /test/release/yarn.lock: -------------------------------------------------------------------------------- 1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. 2 | # yarn lockfile v1 3 | 4 | 5 | js-convert-case@^4.0.1: 6 | version "4.0.1" 7 | resolved "https://registry.yarnpkg.com/js-convert-case/-/js-convert-case-4.0.1.tgz#8de2088f14bf5c911caaf5db5005762034d51a24" 8 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "target": "ES5", 4 | "module": "CommonJS", 5 | "declaration": true, 6 | "outDir": "./lib", 7 | "strict": true 8 | }, 9 | "include": [ 10 | "src" 11 | ], 12 | "exclude": [ 13 | "node_modules", 14 | "**/__tests__/*" 15 | ] 16 | } 17 | -------------------------------------------------------------------------------- /tslint.json: -------------------------------------------------------------------------------- 1 | { 2 | "extends": [ 3 | "tslint:recommended", 4 | "tslint-config-prettier" 5 | ] 6 | } 7 | --------------------------------------------------------------------------------