fix(logical): scores in logical query operators are ignored

Closes #449

Author: krisk

dist/fuse.d.ts

@@ -112,7 +112,7 @@ declare class FuseIndex<T> {
 declare namespace Fuse {
   type FuseGetFunction<T> = (
     obj: T,
-    path: string
+    path: string | string[]
   ) => ReadonlyArray<string> | string
 
   export type FuseIndexOptions<T> = {
@@ -231,11 +231,11 @@ declare namespace Fuse {
   //   weight: 0.7
   // }
   export type FuseOptionKeyObject = {
-    name: string | [string]
+    name: string | string[]
     weight: number
   }
 
-  export type FuseOptionKey = FuseOptionKeyObject | string | [string]
+  export type FuseOptionKey = FuseOptionKeyObject | string | string[]
 
   export interface IFuseOptions<T> {
     isCaseSensitive?: boolean

dist/fuse.js

@@ -379,9 +379,10 @@
           deepGet(value, path, index + 1);
         }
       }
-    };
+    }; // Backwards compatibility (since path used to be a string)
+
 
-    deepGet(obj, path, 0);
+    deepGet(obj, isString(path) ? path.split('.') : path, 0);
     return arr ? list : list[0];
   }
 
@@ -1920,58 +1921,80 @@
         var _this = this;
 
         var expression = parse(query, this.options);
-        var records = this._myIndex.records;
-        var resultMap = {};
-        var results = [];
 
-        var evaluateExpression = function evaluateExpression(node, item, idx) {
-          if (node.children) {
-            var operator = node.operator;
-            var res = [];
+        var evaluate = function evaluate(node, item, idx) {
+          if (!node.children) {
+            var keyId = node.keyId,
+                searcher = node.searcher;
 
-            for (var k = 0; k < node.children.length; k += 1) {
-              var child = node.children[k];
-              var matches = evaluateExpression(child, item, idx);
+            var matches = _this._findMatches({
+              key: _this._keyStore.get(keyId),
+              value: _this._myIndex.getValueForItemAtKeyId(item, keyId),
+              searcher: searcher
+            });
 
-              if (matches && matches.length) {
-                res.push({
-                  idx: idx,
-                  item: item,
-                  matches: matches
-                });
+            if (matches && matches.length) {
+              return [{
+                idx: idx,
+                item: item,
+                matches: matches
+              }];
+            }
+
+            return [];
+          }
+          /*eslint indent: [2, 2, {"SwitchCase": 1}]*/
 
-                if (operator === LogicalOperator.OR) {
-                  // Short-circuit
-                  break;
+
+          switch (node.operator) {
+            case LogicalOperator.AND:
+              {
+                var res = [];
+
+                for (var i = 0, len = node.children.length; i < len; i += 1) {
+                  var child = node.children[i];
+                  var result = evaluate(child, item, idx);
+
+                  if (result.length) {
+                    res.push.apply(res, _toConsumableArray(result));
+                  } else {
+                    return [];
+                  }
                 }
-              } else if (operator === LogicalOperator.AND) {
-                res.length = 0; // Short-circuit
 
-                break;
+                return res;
               }
-            }
 
-            return res;
-          } else {
-            var keyId = node.keyId,
-                searcher = node.searcher;
+            case LogicalOperator.OR:
+              {
+                var _res = [];
 
-            var value = _this._myIndex.getValueForItemAtKeyId(item, keyId);
+                for (var _i = 0, _len = node.children.length; _i < _len; _i += 1) {
+                  var _child = node.children[_i];
 
-            return _this._findMatches({
-              key: _this._keyStore.get(keyId),
-              value: value,
-              searcher: searcher
-            });
+                  var _result = evaluate(_child, item, idx);
+
+                  if (_result.length) {
+                    _res.push.apply(_res, _toConsumableArray(_result));
+
+                    break;
+                  }
+                }
+
+                return _res;
+              }
           }
         };
 
+        var records = this._myIndex.records;
+        var resultMap = {};
+        var results = [];
         records.forEach(function (_ref3) {
           var item = _ref3.$,
               idx = _ref3.i;
 
           if (isDefined(item)) {
-            var expResults = evaluateExpression(expression, item, idx);
+            var expResults = evaluate(expression, item, idx);
 
             if (expResults.length) {
               // Dedupe when adding

docs/README.md

@@ -77,7 +77,7 @@ Of course! Fuse.js has no DOM dependencies.
 
 ### Who's using Fuse.js these days?
 
-Plenty of people. It's hard to say an exact number, since it's free. But a good indication is the number of [dependents](https://www.npmjs.com/package/fuse.js?activeTab=dependents) on NPM and [stargazers](https://github.com/krisk/Fuse/stargazers) on Github.
+Plenty of people. It's hard to say an exact number, since it's free. But a good indication is the number of [dependents](https://www.npmjs.com/package/fuse.js?activeTab=dependents) on NPM, and the [dependency graph](https://github.com/krisk/Fuse/network/dependents) and [stargazers](https://github.com/krisk/Fuse/stargazers) on Github.
 
 Read the [stories](/stories.html) to learn how various products are using Fuse.js to tackle a growing number of use cases.
 

docs/api/options.md

@@ -106,13 +106,16 @@ When `true`, it enables the use of unix-like search commands. See [example](/exa
 ### `getFn`
 
 - Type: `Function`
-- Default: `(obj: T, path: string) => string[] | string`
+- Default: `(obj: T, path: string | string[]) => string | string[]`
 
-The function to use to retrieve an object's value at the provided path (i.e, key). The default will search nested paths.
+The function to use to retrieve an object's value at the provided path. The default will also search nested paths.
 
-::: danger
-There aren't many cases where you'd want to use your own `getFn`.
-:::
+### `sortFn`
+
+- Type: `Function`
+- Default: `(a, b) => number`
+
+The function to use to sort all the results. The default will sort by ascending relevance score, ascending index.
 
 ### `ignoreFieldNorm`
 
@@ -122,5 +125,5 @@ There aren't many cases where you'd want to use your own `getFn`.
 When `true`, the calculation for the relevance score (used for sorting) will ignore the [field-length norm](/concepts/scoring-theory.html#fuzziness-score).
 
 :::tip
-The only time it might make sense `ignoreFieldNorm` to `false` is when it does not matter how many terms there are, but only that the query term exists.
+The only time it makes sense to set `ignoreFieldNorm` to `true` is when it does not matter how many terms there are, but only that the query term exists.
 :::

src/core/index.js

@@ -134,53 +134,66 @@ export default class Fuse {
 
     const expression = parse(query, this.options)
 
-    const records = this._myIndex.records
-    const resultMap = {}
-    const results = []
-
-    const evaluateExpression = (node, item, idx) => {
-      if (node.children) {
-        const operator = node.operator
-        let res = []
+    const evaluate = (node, item, idx) => {
+      if (!node.children) {
+        const { keyId, searcher } = node
 
-        for (let k = 0; k < node.children.length; k += 1) {
-          let child = node.children[k]
-          let matches = evaluateExpression(child, item, idx)
+        const matches = this._findMatches({
+          key: this._keyStore.get(keyId),
+          value: this._myIndex.getValueForItemAtKeyId(item, keyId),
+          searcher
+        })
 
-          if (matches && matches.length) {
-            res.push({
+        if (matches && matches.length) {
+          return [
+            {
               idx,
               item,
               matches
-            })
-            if (operator === LogicalOperator.OR) {
-              // Short-circuit
-              break
             }
-          } else if (operator === LogicalOperator.AND) {
-            res.length = 0
-            // Short-circuit
-            break
-          }
+          ]
         }
 
-        return res
-      } else {
-        const { keyId, searcher } = node
-
-        const value = this._myIndex.getValueForItemAtKeyId(item, keyId)
+        return []
+      }
 
-        return this._findMatches({
-          key: this._keyStore.get(keyId),
-          value,
-          searcher
-        })
+      /*eslint indent: [2, 2, {"SwitchCase": 1}]*/
+      switch (node.operator) {
+        case LogicalOperator.AND: {
+          const res = []
+          for (let i = 0, len = node.children.length; i < len; i += 1) {
+            const child = node.children[i]
+            const result = evaluate(child, item, idx)
+            if (result.length) {
+              res.push(...result)
+            } else {
+              return []
+            }
+          }
+          return res
+        }
+        case LogicalOperator.OR: {
+          const res = []
+          for (let i = 0, len = node.children.length; i < len; i += 1) {
+            const child = node.children[i]
+            const result = evaluate(child, item, idx)
+            if (result.length) {
+              res.push(...result)
+              break
+            }
+          }
+          return res
+        }
       }
     }
 
+    const records = this._myIndex.records
+    const resultMap = {}
+    const results = []
+
     records.forEach(({ $: item, i: idx }) => {
       if (isDefined(item)) {
-        let expResults = evaluateExpression(expression, item, idx)
+        let expResults = evaluate(expression, item, idx)
 
         if (expResults.length) {
           // Dedupe when adding

src/helpers/get.js

@@ -32,7 +32,8 @@ export default function get(obj, path) {
     }
   }
 
-  deepGet(obj, path, 0)
+  // Backwards compatibility (since path used to be a string)
+  deepGet(obj, isString(path) ? path.split('.') : path, 0)
 
   return arr ? list : list[0]
 }

src/index.d.ts

@@ -109,7 +109,7 @@ declare class FuseIndex<T> {
 declare namespace Fuse {
   type FuseGetFunction<T> = (
     obj: T,
-    path: string
+    path: string | string[]
   ) => ReadonlyArray<string> | string
 
   export type FuseIndexOptions<T> = {
@@ -228,11 +228,11 @@ declare namespace Fuse {
   //   weight: 0.7
   // }
   export type FuseOptionKeyObject = {
-    name: string | [string]
+    name: string | string[]
     weight: number
   }
 
-  export type FuseOptionKey = FuseOptionKeyObject | string | [string]
+  export type FuseOptionKey = FuseOptionKeyObject | string | string[]
 
   export interface IFuseOptions<T> {
     isCaseSensitive?: boolean

test/logical-search.test.js

@@ -130,11 +130,12 @@ describe('Multiple nested conditions', () => {
   ]
 
   const options = {
+    includeScore: true,
     useExtendedSearch: true,
     keys: ['title', 'author.firstName', 'author.lastName', 'author.age']
   }
-  const fuse1 = new Fuse(list1, options)
 
+  const fuse1 = new Fuse(list1, options)
   const fuse2 = new Fuse(list2, options)
 
   test('Search: nested AND + OR', () => {
@@ -170,6 +171,8 @@ describe('Multiple nested conditions', () => {
     })
 
     expect(result.length).toBe(1)
+    expect(result[0]).toHaveProperty('score')
+    expect(result[0].score).toBeGreaterThan(0)
   })
 
   test('Search: deep nested AND + OR', () => {
@@ -189,6 +192,8 @@ describe('Multiple nested conditions', () => {
     })
 
     expect(result.length).toBe(1)
+    expect(result[0]).toHaveProperty('score')
+    expect(result[0].score).toBeGreaterThan(0)
   })
 })
 
@@ -206,6 +211,7 @@ describe('Logical search with dotted keys', () => {
 
   const options = {
     useExtendedSearch: true,
+    includeScore: true,
     keys: [
       'title',
       ['author', 'first.name'],