autocomplete: replace Fuse.js with liblevenshtein

src/autocomplete/FuzzyMatcher.js

@@ -0,0 +1,74 @@
+import Levenshtein from 'liblevenshtein';
+import _at from 'lodash/at';
+import _flatMap from 'lodash/flatMap';
+import _sortBy from 'lodash/sortBy';
+import _sortedUniq from 'lodash/sortedUniq';
+import _keys from 'lodash/keys';
+
+class KeyMap {
+    keys: Array<String>;
+    objectMap: {[String]: Array<Object>};
+    priorityMap: {[String]: number}
+}
+
+const DEFAULT_RESULT_COUNT = 10;
+const DEFAULT_DISTANCE = 5;
+
+export default class FuzzyMatcher {
+    /**
+     * Given an array of objects and keys, returns a KeyMap
+     * Keys can refer to object properties by name and as in JavaScript (for nested properties)
+     *
+     * To use, simply presort objects by required criteria, run through this function and create a FuzzyMatcher with the
+     * resulting KeyMap.
+     *
+     * TODO: Handle arrays and objects (Fuse did this, RoomProvider uses it)
+     */
+    static valuesToKeyMap(objects: Array<Object>, keys: Array<String>): KeyMap {
+        const keyMap = new KeyMap();
+        const map = {};
+        const priorities = {};
+
+        objects.forEach((object, i) => {
+            const keyValues = _at(object, keys);
+            console.log(object, keyValues, keys);
+            for (const keyValue of keyValues) {
+                if (!map.hasOwnProperty(keyValue)) {
+                   map[keyValue] = [];
+                }
+                map[keyValue].push(object);
+            }
+            priorities[object] = i;
+        });
+
+        keyMap.objectMap = map;
+        keyMap.priorityMap = priorities;
+        keyMap.keys = _sortBy(_keys(map), [value => priorities[value]]);
+        return keyMap;
+    }
+
+    constructor(objects: Array<Object>, options: {[Object]: Object} = {}) {
+        this.options = options;
+        this.keys = options.keys;
+        this.setObjects(objects);
+    }
+
+    setObjects(objects: Array<Object>) {
+        this.keyMap = FuzzyMatcher.valuesToKeyMap(objects, this.keys);
+        console.log(this.keyMap.keys);
+        this.matcher = new Levenshtein.Builder()
+            .dictionary(this.keyMap.keys, true)
+            .algorithm('transposition')
+            .sort_candidates(false)
+            .case_insensitive_sort(true)
+            .include_distance(false)
+            .maximum_candidates(this.options.resultCount || DEFAULT_RESULT_COUNT) // result count 0 doesn't make much sense
+            .build();
+    }
+
+    match(query: String): Array<Object> {
+        const candidates = this.matcher.transduce(query, this.options.distance || DEFAULT_DISTANCE);
+        return _sortedUniq(_sortBy(_flatMap(candidates, candidate => this.keyMap.objectMap[candidate]),
+            candidate => this.keyMap.priorityMap[candidate]));
+    }
+}