cmpstr 1.0.1 → 1.0.3

package/README.md

@@ -4,7 +4,7 @@ This lightweight npm package can be used to __calculate the similarity of string
 
 ## Install
 
-Using Node.js install the package using shell command:
+Using __Node.js__, install the package with the following shell command:
 
 ```sh
 npm install cmpstr
@@ -58,6 +58,16 @@ let matches = cmpstr.levenshteinMatch( 'best', [
 ] );
 ```
 
+### JavaScript
+
+Using JavaScript load this package by embed this file via [jsDelivr](https://www.jsdelivr.com/package/npm/cmpstr):
+
+```js
+import cmpstr from "https://cdn.jsdelivr.net/npm/cmpstr@1.0.3/+esm";
+```
+
+Remember: To use ``import`` you need to load your JavaScript file as ``type="module"``.
+
 ## API
 
 The npm package ``cmpstr`` supports two different methods for determining the similarity of two strings. The __Levenshtein distance__, as the minimum number of inserting, deleting and replacing operations to convert one string into another, and the __Sørensen-Dice coefficient__ to measure the similarity of two samples.
@@ -69,32 +79,60 @@ Learn more about both by visiting these links:
 
 ### Levenshtein distance
 
-#### ``levenshteinDistance( a, b )``
+#### ``levenshteinDistance( a, b [, flags = null ] )``
 
 Calculates the difference between two strings ``a`` and ``b`` and returns the Levenshtein distance as an integer value.
 
-#### ``levenshtein( a, b )``
+#### ``levenshtein( a, b [, flags = null ] )``
 
 Returns the match percentage of two strings ``a`` and ``b``. The output value is in the range ``0..1`` as a floating point number.
 
-#### ``levenshteinClosest( str, arr )``
+#### ``levenshteinClosest( str, arr [, flags = null ] )``
 
 Returns the best match of the string ``str`` against the array ``arr`` of passed strings. The function returns the most closely matched string found in the array.
 
-#### ``levenshteinMatch( str, arr )``
+#### ``levenshteinMatch( str, arr [, flags = null [, threshold = 0 ] ] )``
 
-Calculates the similarity of all strings contained in the array ``arr`` according to Levenshtein compared to ``str`` and returns an array of all samples sorted by matching in descending order.
+Calculates the similarity of all strings contained in the array ``arr`` according to Levenshtein compared to ``str`` and returns an array of all samples sorted by matching in descending order. The ``threshold`` specifies the minimum required similarity.
 
 ### Sørensen-Dice coefficient
 
-#### ``diceCoefficient( a, b )``
+#### ``diceCoefficient( a, b [, flags = null ] )``
 
 This function evaluates the similarity of two given strings ``a`` and ``b`` as percentage value according to the Sørensen-Dice coefficient and returns the result as floating point number.
 
-#### ``diceClosest( str, arr )``
+#### ``diceClosest( str, arr [, flags = null ] )``
 
 As another way to find the best match between the string ``str`` and a given array ``arr`` of samples, this function uses the Sørensen-Dice coefficient. It returns the most matching string as well.
 
-#### ``diceMatch( str, arr )``
+#### ``diceMatch( str, arr [, flags = null [, threshold = 0 ] ] )``
+
+Calculates the similarity of all strings contained in the array ``arr`` according to Sørensen-Dice coefficient compared to ``str`` and returns an array of all samples sorted by matching in descending order. The ``threshold`` specifies the minimum required similarity.
+
+### Flags
+
+Each method can be passed the ``flags`` options listed below:
+
+| Flag  | Option                         |
+| ----- | ------------------------------ |
+| ``i`` | case insensitive               |
+| ``s`` | non-whitespace characters only |
+
+## Patch notes
+
+### 1.0.3
+
+* Add ``threshold`` to specify the minimum required similarity
+
+### 1.0.2
+
+* Add normalize options ``i`` and ``s``
+* Minor fixes
+
+### 1.0.1
+
+* Minor fixes
+
+### 1.0.0
 
-Calculates the similarity of all strings contained in the array ``arr`` according to Sørensen-Dice coefficient compared to ``str`` and returns an array of all samples sorted by matching in descending order.
+* Initial release

package/index.js

@@ -3,11 +3,11 @@
  * lightweight npm package to calculate string similarity
  * 
  * @author komed3 (Paul Köhler)
- * @version 1.0.1
+ * @version 1.0.3
  * @license MIT
  */
 
-'use strict'
+'use strict';
 
 /**
  * basic functions
@@ -17,11 +17,40 @@
 /**
  * normalize string
  * @param {String} str string
+ * @param {Null|String} flags options
  * @returns normalized string
  */
-const normalize = ( str ) => {
+const normalize = ( str, flags = null ) => {
 
-    return str.toString();
+    str = str.toString();
+
+    ( flags || '' ).toString().split( '' ).forEach( ( f ) => {
+
+        /**
+         * normalize options
+         * i    case insensitive
+         * s    non-whitespace
+         */
+
+        switch( f.toLowerCase() ) {
+
+            case 'i':
+                str = str.toLowerCase();
+                break;
+
+            case 's':
+                str = str.replace( /[^\S]+/g, '' );
+                break;
+
+            default:
+                /* do nothing */
+                break;
+
+        }
+
+    } );
+
+    return str;
 
 };
 
@@ -47,21 +76,22 @@ const str2bigrams = ( str ) => {
 };
 
 /**
- * 
+ * compare strings by given algorithm
  * @param {String} algo algorithm to use
  * @param {String} a string 1
  * @param {String} b string 2
+ * @param {Null|String} flags options
  * @returns similarity
  */
-const cpmByAlgo = ( algo, a, b ) => {
+const cpmByAlgo = ( algo, a, b, flags = null ) => {
 
     switch( algo ) {
 
         case 'levenshtein':
-            return levenshtein( a, b );
+            return levenshtein( a, b, flags );
 
         case 'diceCoefficient':
-            return diceCoefficient( a, b );
+            return diceCoefficient( a, b, flags );
 
         default:
             return 0;
@@ -75,9 +105,10 @@ const cpmByAlgo = ( algo, a, b ) => {
  * @param {String} algo algorithm to use
  * @param {String} test test string
  * @param {Array} arr targets to test
+ * @param {Null|String} flags options
  * @returns closest target
  */
-const findClosest = ( algo, test, arr ) => {
+const findClosest = ( algo, test, arr, flags = null ) => {
 
     let best = -Infinity,
         idx = 0,
@@ -85,9 +116,9 @@ const findClosest = ( algo, test, arr ) => {
 
     /* search for closest element in arr */
 
-    arr.forEach( ( str, i ) => {
+    [ ...arr ].forEach( ( str, i ) => {
 
-        pct = cpmByAlgo( algo, test, str );
+        pct = cpmByAlgo( algo, test, str, flags );
 
         if( pct > best ) {
 
@@ -111,23 +142,29 @@ const findClosest = ( algo, test, arr ) => {
  * @param {String} algo algorithm to use
  * @param {String} test test string
  * @param {Array} arr targets to test
+ * @param {Null|String} flags options
+ * @param {Float} threshold required similarity
  * @returns sorted matches
  */
-const bestMatch = ( algo, test, arr ) => {
+const bestMatch = ( algo, test, arr, flags = null, threshold = 0 ) => {
 
     let matches = [],
         pct;
 
     /* calculate similarity for each arr items */
 
-    arr.forEach( ( str ) => {
+    [ ...arr ].forEach( ( str ) => {
 
-        pct = cpmByAlgo( algo, test, str );
+        pct = cpmByAlgo( algo, test, str, flags );
 
-        matches.push( {
-            target: str,
-            match: pct
-        } );
+        if( pct >= threshold ) {
+
+            matches.push( {
+                target: str,
+                match: pct
+            } );
+
+        }
 
     } );
 
@@ -152,14 +189,15 @@ const bestMatch = ( algo, test, arr ) => {
  * calculate levenshtein similarity (in percent)
  * @param {String} a string 1
  * @param {String} b string 2
+ * @param {Null|String} flags options
  * @returns similarity 0..1
  */
-const levenshtein = ( a, b ) => {
+const levenshtein = ( a, b, flags = null ) => {
 
     /* normalize string */
 
-    a = normalize( a );
-    b = normalize( b );
+    a = normalize( a, flags );
+    b = normalize( b, flags );
 
     if( a == b ) {
 
@@ -196,14 +234,15 @@ const levenshtein = ( a, b ) => {
  * get levenshtein distance
  * @param {String} a string 1
  * @param {String} b string 2
+ * @param {Null|String} flags options
  * @returns distance
  */
-const levenshteinDistance = ( a, b ) => {
+const levenshteinDistance = ( a, b, flags = null ) => {
 
     /* normalize string */
 
-    a = normalize( a );
-    b = normalize( b );
+    a = normalize( a, flags );
+    b = normalize( b, flags );
 
     if( a == b ) {
 
@@ -281,11 +320,12 @@ const levenshteinDistance = ( a, b ) => {
  * search for closest target to test string
  * @param {String} test test string
  * @param {Array} arr targets to test
+ * @param {Null|String} flags options
  * @returns closest target
  */
-const levenshteinClosest = ( test, arr ) => {
+const levenshteinClosest = ( test, arr, flags = null ) => {
 
-    return findClosest( 'levenshtein', test, arr );
+    return findClosest( 'levenshtein', test, arr, flags );
 
 };
 
@@ -293,11 +333,13 @@ const levenshteinClosest = ( test, arr ) => {
  * sort best matches to test string
  * @param {String} test test string
  * @param {Array} arr targets to test
+ * @param {Null|String} flags options
+ * @param {Float} threshold required similarity
  * @returns sorted matches
  */
-const levenshteinMatch = ( test, arr ) => {
+const levenshteinMatch = ( test, arr, flags = null, threshold = 0 ) => {
 
-    return bestMatch( 'levenshtein', test, arr );
+    return bestMatch( 'levenshtein', test, arr, flags, threshold );
 
 };
 
@@ -305,14 +347,15 @@ const levenshteinMatch = ( test, arr ) => {
  * calculate dice coefficient
  * @param {String} a string 1
  * @param {String} b string 2
+ * @param {Null|String} flags options
  * @returns dice coefficient
  */
-const diceCoefficient = ( a, b ) => {
+const diceCoefficient = ( a, b, flags = null ) => {
 
     /* normalize string */
 
-    a = normalize( a );
-    b = normalize( b );
+    a = normalize( a, flags );
+    b = normalize( b, flags );
 
     if( a == b ) {
 
@@ -352,11 +395,12 @@ const diceCoefficient = ( a, b ) => {
  * search for closest target to test string
  * @param {String} test test string
  * @param {Array} arr targets to test
+ * @param {Null|String} flags options
  * @returns closest target
  */
-const diceClosest = ( test, arr ) => {
+const diceClosest = ( test, arr, flags = null ) => {
 
-    return findClosest( 'diceCoefficient', test, arr );
+    return findClosest( 'diceCoefficient', test, arr, flags );
 
 };
 
@@ -364,11 +408,13 @@ const diceClosest = ( test, arr ) => {
  * sort best matches to test string
  * @param {String} test test string
  * @param {Array} arr targets to test
+ * @param {Null|String} flags options
+ * @param {Float} threshold required similarity
  * @returns sorted matches
  */
-const diceMatch = ( test, arr ) => {
+const diceMatch = ( test, arr, flags = null, threshold = 0 ) => {
 
-    return bestMatch( 'diceCoefficient', test, arr );
+    return bestMatch( 'diceCoefficient', test, arr, flags, threshold );
 
 };
 

package/package.json

@@ -7,7 +7,7 @@
     "url" : "https://komed3.de"
   },
   "homepage": "https://github.com/komed3/cmpstr#readme",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "license": "MIT",
   "keywords": [
     "string",