Host FlexSearch

paige/node_modules/flexsearch/dist/module-debug/cache.js

@@ -0,0 +1,168 @@
+import { IndexInterface, DocumentInterface } from "./type.js";
+import { create_object, is_object } from "./common.js";
+
+/**
+ * @param {boolean|number=} limit
+ * @constructor
+ */
+
+function CacheClass(limit) {
+
+    /** @private */
+    this.limit = !0 !== limit && limit;
+
+    /** @private */
+    this.cache = create_object();
+
+    /** @private */
+    this.queue = [];
+
+    //this.clear();
+}
+
+export default CacheClass;
+
+/**
+ * @param {string|Object} query
+ * @param {number|Object=} limit
+ * @param {Object=} options
+ * @this {IndexInterface}
+ * @returns {Array<number|string>}
+ */
+
+export function searchCache(query, limit, options) {
+
+    if (is_object(query)) {
+
+        query = query.query;
+    }
+
+    let cache = this.cache.get(query);
+
+    if (!cache) {
+
+        cache = this.search(query, limit, options);
+        this.cache.set(query, cache);
+    }
+
+    return cache;
+}
+
+// CacheClass.prototype.clear = function(){
+//
+//     /** @private */
+//     this.cache = create_object();
+//
+//     /** @private */
+//     this.queue = [];
+// };
+
+CacheClass.prototype.set = function (key, value) {
+
+    if (!this.cache[key]) {
+
+        // it is just a shame that native function array.shift() performs so bad
+
+        // const length = this.queue.length;
+        //
+        // this.queue[length] = key;
+        //
+        // if(length === this.limit){
+        //
+        //     delete this.cache[this.queue.shift()];
+        // }
+
+        // the same bad performance
+
+        // this.queue.unshift(key);
+        //
+        // if(this.queue.length === this.limit){
+        //
+        //     this.queue.pop();
+        // }
+
+        // fast implementation variant
+
+        // let length = this.queue.length;
+        //
+        // if(length === this.limit){
+        //
+        //     length--;
+        //
+        //     delete this.cache[this.queue[0]];
+        //
+        //     for(let x = 0; x < length; x++){
+        //
+        //         this.queue[x] = this.queue[x + 1];
+        //     }
+        // }
+        //
+        // this.queue[length] = key;
+
+        // current fastest implementation variant
+        // theoretically that should not perform better compared to the example above
+
+        let length = this.queue.length;
+
+        if (length === this.limit) {
+
+            delete this.cache[this.queue[length - 1]];
+        } else {
+
+            length++;
+        }
+
+        for (let x = length - 1; 0 < x; x--) {
+
+            this.queue[x] = this.queue[x - 1];
+        }
+
+        this.queue[0] = key;
+    }
+
+    this.cache[key] = value;
+};
+
+CacheClass.prototype.get = function (key) {
+
+    const cache = this.cache[key];
+
+    if (this.limit && cache) {
+
+        // probably the indexOf() method performs faster when matched content is on front (left-to-right)
+        // using lastIndexOf() does not help, it performs almost slower
+
+        const pos = this.queue.indexOf(key);
+
+        // if(pos < this.queue.length - 1){
+        //
+        //     const tmp = this.queue[pos];
+        //     this.queue[pos] = this.queue[pos + 1];
+        //     this.queue[pos + 1] = tmp;
+        // }
+
+        if (pos) {
+
+            const tmp = this.queue[pos - 1];
+            this.queue[pos - 1] = this.queue[pos];
+            this.queue[pos] = tmp;
+        }
+    }
+
+    return cache;
+};
+
+CacheClass.prototype.del = function (id) {
+
+    for (let i = 0, item, key; i < this.queue.length; i++) {
+
+        key = this.queue[i];
+        item = this.cache[key];
+
+        if (item.includes(id)) {
+
+            this.queue.splice(i--, 1);
+            delete this.cache[key];
+        }
+    }
+};