change-case - npm Package Compare versions

Comparing version 0.0.5 to 1.0.0

index.js

@@ -0,6 +1,14 @@
+/**
+ * Wraps a function with a security check that ensures the argument being
+ * passed in is a string.
+ *
+ * @param  {Function} fn
+ * @return {Function}
+ */
 var acceptString = function (fn) {
   return function (string) {
     if (typeof string !== 'string') {
-      throw new TypeError('Changing the case only works on strings');
+      throw new TypeError('Changing case will only works on strings');
     }
+
     return fn.apply(null, arguments);
@@ -10,66 +18,200 @@ };
 
-var splitWords = function (word) {
-  return word.replace(/([a-z0-9])([A-Z])/, '$1 $2').split(/[^a-zA-Z0-9]/).map(e.lower);
+/**
+ * Sanitizes a passed in string with certain options. It accepts a replacement
+ * function that should accept a string word parameter. It also accepts an
+ * optional separator override to replace the seperator character.
+ *
+ * @param  {String}   string
+ * @param  {Function} replacement
+ * @param  {Function|String} [separator]
+ * @return {Array}
+ */
+var sanitizeString = function (string, replacement, separator) {
+  var index = -1;
+
+  return string
+    .replace(/([a-z0-9])([A-Z])/, '$1 $2')
+    .replace(/([^a-zA-Z0-9]*)([a-zA-Z0-9]+)/g, function (_, $0, $1) {
+      var prefix = $0;
+
+      index += 1;
+
+      if (prefix) {
+        if (typeof separator === 'string') {
+          prefix = separator;
+        } else if (typeof separator === 'function') {
+          prefix = separator($0, index);
+        }
+      }
+
+      return prefix + replacement($1, index);
+    });
 };
 
-var e = exports; // Alias `exports` object so I don't have to type as much
+/**
+ * Exports object.
+ *
+ * @type {Object}
+ */
+var e = exports;
 
+/**
+ * Expose a mutable array of insignificant words that will not be title cased.
+ *
+ * @type {Array}
+ */
 e.insignificantWords = ['and'];
 
+/**
+ * Lowercase a passed in string.
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.lowerCase = e.lower = acceptString(function (str) {
-  return str.toLowerCase();
+  return str.toLocaleLowerCase();
 });
 
+/**
+ * Uppercase a passed in string.
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.upperCase = e.upper = acceptString(function (str) {
-  return str.toUpperCase();
+  return str.toLocaleUpperCase();
 });
 
-e.titleCase = e.title = acceptString(function (str, isSignificant) {
-  return splitWords(str).map(function (word, index) {
-    if (index && !isSignificant && (word.length < 3 || ~e.insignificantWords.indexOf(word))) {
-      return word;
+/**
+ * Uppercase the first character of a string.
+ *
+ * @param  {String} str
+ * @return {String}
+ */
+e.upperCaseFirst = e.upperFirst = acceptString(function (str) {
+  return e.upperCase(str.charAt(0)) + str.substr(1);
+});
+
+/**
+ * Lowercase the first character of a string.
+ *
+ * @param  {String} str
+ * @return {String}
+ */
+e.lowerCaseFirst = e.lowerFirst = acceptString(function (str) {
+  return e.lowerCase(str.charAt(0)) + str.substr(1);
+});
+
+/**
+ * Title case a passed in string. Pass an optional boolean flag to title case
+ * all words. Default behaviour is to skip insignicant words.
+ *
+ * @param  {String} str
+ * @return {String}
+ */
+e.titleCase = e.title = acceptString(function (str) {
+  return sanitizeString(str, function (word, index) {
+    // The first word of the string should always be capitalized.
+    if (index > 0 && (word.length < 3 || ~e.insignificantWords.indexOf(word))) {
+      return e.lowerCase(word);
     }
-    return e.upper(word[0]) + word.slice(1);
-  }).join(' ');
+
+    // Returns the word with the first character uppercased.
+    return e.upperCaseFirst(e.lowerCase(word));
+  });
 });
 
+/**
+ * Sentence case a passed in string. E.g. "TestString" => "test string".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
+e.sentenceCase = e.sentence = acceptString(function (str) {
+  return sanitizeString(str, e.lowerCase, ' ');
+});
+
+/**
+ * Pascal case a passed in string. E.g. "test string" => "TestString".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.pascalCase = e.pascal = acceptString(function (str) {
-  return splitWords(str).map(e.title).join('');
+  return sanitizeString(str, function (word) {
+    return e.upperCaseFirst(e.lowerCase(word));
+  }, '');
 });
 
+/**
+ * Camel case a passed in string. E.g. "test string" => "testString".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.camelCase = e.camel = acceptString(function (str) {
-  str = e.pascal(str);
-  return e.lower(str[0]) + str.slice(1);
+  return e.lowerCaseFirst(e.pascalCase(str));
 });
 
+/**
+ * Snake case a passed in string. E.g. "test string" => "test_string".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.snakeCase = e.snake = acceptString(function (str) {
-  return splitWords(str).join('_');
+  return sanitizeString(str, e.lowerCase, '_');
 });
 
+/**
+ * Param case a passed in string. E.g. "test string" => "test-string".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.paramCase = e.param = acceptString(function (str) {
-  return splitWords(str).join('-');
+  return sanitizeString(str, e.lowerCase, '-');
 });
 
+/**
+ * Dot case a passed in string. E.g. "test string" => "test.string".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.dotCase = e.dot = acceptString(function (str) {
-  return splitWords(str).join('.');
+  return sanitizeString(str, e.lowerCase, '.');
 });
 
+/**
+ * Path case a passed in string. E.g. "test string" => "test/string".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.pathCase = e.path = acceptString(function (str) {
-  return splitWords(str).join('/');
+  return sanitizeString(str, e.lowerCase, '/');
 });
 
+/**
+ * Constant case a passed in string. E.g. "test string" => "TEST_STRING".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.constantCase = e.constant = acceptString(function (str) {
-  return splitWords(str).map(e.upper).join('_');
+  return sanitizeString(str, e.upperCase, '_');
 });
 
+/**
+ * Reverse the case of a string. E.g. "Test String" => "tEST sTRING".
+ *
+ * @param  {String} str
+ * @return {String}
+ */
 e.switchCase = e.switch = acceptString(function (str) {
-  var output = '',
-      char;
-
-  for (var i = 0; i < str.length; i++) {
-    char = str.charAt(i);
-    output += (char === e.upper(char) ? e.lower(char) : e.upper(char));
-  }
-
-  return output;
+  return str.replace(/\w/g, function (c) {
+    var u = e.upperCase(c);
+    return c === u ? e.lowerCase(c) : u;
+  });
 });

package.json

 {
   "name": "change-case",
-  "version": "0.0.5",
+  "version": "1.0.0",
   "description": "Convert strings between camelCase, PascalCase, Title Case, snake_case, etc",
@@ -5,0 +5,0 @@ "main": "index.js",

Readme.md

@@ -13,33 +13,125 @@ # Change Case
 
-```
+```js
 var changeCase = require('change-case');
 ```
 
-* `changeCase.upperCase(string)`
-* `changeCase.lowerCase(string)`
-* `changeCase.titleCase(string [, ignoreInsignificantWords])`
-* `changeCase.camelCase(string)`
-* `changeCase.snakeCase(string)`
-* `changeCase.paramCase(string)`
-* `changeCase.dotCase(string)`
-* `changeCase.pathCase(string)`
-* `changeCase.constantCase(string)`
-* `changeCase.switchCase(string)`
+**upperCase** changeCase.upperCase(string)
 
-```javascript
-changeCase.upperCase('test string') // "TEST STRING"
-changeCase.lowerCase('TEST STRING') // "test string"
-changeCase.titleCase('this is a test string') // "This is a Test String"
-changeCase.titleCase('this is a test string', true) // "This Is A Test String"
-changeCase.camelCase('test string') // "testString"
-changeCase.snakeCase('test string') // "test_string"
-changeCase.paramCase('test string') // "test-string"
-changeCase.dotCase('test string') // "test.string"
-changeCase.pathCase('test string') // "test/string"
-changeCase.constantCase('test string') // "TEST_STRING"
-changeCase.switchCase('TeST stRInG') // "tEst STriNg"
+Upper cases a string.
+
+```js
+changeCase.upperCase('test string');
+--> "TEST STRING"
 ```
 
+**lowerCase** changeCase.lowerCase(string)
+
+Lower cases a string.
+
+```js
+changeCase.lowerCase('TEST STRING');
+--> "test string"
+```
+
+**upperCaseFirst** changeCase.upperCaseFirst(string)
+
+Upper cases only the first character of a string.
+
+```js
+changeCase.upperCaseFirst('test string');
+--> "Test string"
+```
+
+**lowerCaseFirst** changeCase.lowerCaseFirst(string)
+
+Lower cases only the first character of a string.
+
+```js
+changeCase.lowerCaseFirst('TEST STRING');
+--> "tEST STRING"
+```
+
+**titleCase** changeCase.titleCase(string)
+
+Title cases a string, useful for user inputted values being shown as titles. It does minimal sanitization of characters and will not handle non-sentence formats correctly (since it risks breaking formatting). If you need to parse a string in a different format, pass it through `sentenceCase` first.
+
+```js
+changeCase.titleCase('a simple test');
+--> "A Simple Test"
+```
+
+**sentenceCase** changeCase.sentenceCase(string)
+
+Transforms a string from any format to a lower cased sentence.
+
+```js
+changeCase.sentenceCase('testString');
+--> "test string"
+```
+
+**camelCase** changeCase.camelCase(string)
+
+Converts a string to a camel cased word.
+
+```js
+changeCase.camelCase('test string');
+--> "testString"
+```
+
+**snakeCase** changeCase.snakeCase(string)
+
+Converts a string to an underscore separated string.
+
+```js
+changeCase.snakeCase('test string');
+--> "test_string"
+```
+
+**paramCase** changeCase.paramCase(string)
+
+Converts a string to a dash separated string.
+
+```js
+changeCase.paramCase('test string');
+--> "test-case"
+```
+
+**dotCase** changeCase.dotCase(string)
+
+Converts a string to a period separated string.
+
+```js
+changeCase.dotCase('test string');
+--> "test.string"
+```
+
+**pathCase** changeCase.pathCase(string)
+
+Converts a string to a slash separated string.
+
+```js
+changeCase.pathCase('test string');
+--> "test/string"
+```
+
+**constantCase** changeCase.constantCase(string)
+
+Converts a string to a constant styled string (upper case separated by underscores).
+
+```js
+changeCase.constantCase('test string');
+--> "TEST_STRING"
+```
+
+**switchCase** changeCase.switchCase(string)
+
+Reverses the strings case.
+
+```js
+changeCase.switchCase('Test String');
+--> "tEST sTRING"
+```
+
 ## License
 
 MIT

test.js

@@ -14,10 +14,21 @@ /* global describe, it */
 
+  it('should lower case the first character', function () {
+    assert.equal(changeCase.lowerCaseFirst('TEST'), 'tEST');
+  });
+
+  it('should upper case the first character', function () {
+    assert.equal(changeCase.upperCaseFirst('test'), 'Test');
+  });
+
   it('should convert to title case', function () {
-    assert.equal(changeCase.titleCase('a-simple-test'), 'A Simple Test');
-    assert.equal(changeCase.titleCase('this is a test'), 'This is a Test');
-    assert.equal(changeCase.titleCase('this_is_a_test'), 'This is a Test');
-    assert.equal(changeCase.titleCase('this-is-a-test'), 'This is a Test');
-    assert.equal(changeCase.titleCase('this is a test', true), 'This Is A Test');
+    assert.equal(changeCase.titleCase('a test sentence'), 'A Test Sentence');
   });
 
+  it('should convert to sentence case', function () {
+    assert.equal(changeCase.sentenceCase('a-simple-test'), 'a simple test');
+    assert.equal(changeCase.sentenceCase('this is a test'), 'this is a test');
+    assert.equal(changeCase.sentenceCase('this_is_a_test'), 'this is a test');
+    assert.equal(changeCase.sentenceCase('this-is-a-test'), 'this is a test');
+  });
+
   it('should convert to camel case', function () {
@@ -28,2 +39,3 @@ assert.equal(changeCase.camelCase('TestString'),  'testString');
     assert.equal(changeCase.camelCase('Test-String'), 'testString');
+    assert.equal(changeCase.camelCase('-webkit-transform'), 'webkitTransform');
   });
@@ -37,2 +49,3 @@
     assert.equal(changeCase.pascalCase('a-test-again'), 'ATestAgain');
+    assert.equal(changeCase.pascalCase('a---better__test'), 'ABetterTest');
   });
@@ -45,2 +58,3 @@
     assert.equal(changeCase.snakeCase('Test-String'), 'test_string');
+    assert.equal(changeCase.snakeCase('a---better__test'), 'a_better_test');
   });
@@ -53,2 +67,3 @@
     assert.equal(changeCase.paramCase('Test-String'), 'test-string');
+    assert.equal(changeCase.paramCase('a---better__test'), 'a-better-test');
   });
@@ -61,2 +76,3 @@
     assert.equal(changeCase.constantCase('Test-String'), 'TEST_STRING');
+    assert.equal(changeCase.constantCase('a---better__test'), 'A_BETTER_TEST');
   });
@@ -69,2 +85,3 @@
     assert.equal(changeCase.dotCase('Test-String'), 'test.string');
+    assert.equal(changeCase.dotCase('a---better__test'), 'a.better.test');
   });
@@ -77,2 +94,3 @@
     assert.equal(changeCase.pathCase('Test-String'), 'test/string');
+    assert.equal(changeCase.pathCase('a---better__test'), 'a/better/test');
   });
@@ -79,0 +97,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

13769

increased by89.45%

Number of package files

7

increased by16.67%

Lines of code

273

increased by121.95%

Number of low quality alerts

1

decreased by-50%

Number of lines in readme file

137

increased by204.44%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes