document resolver, reduce code duplication, refactoring

dist/module-debug/resolve/handler.js

@@ -0,0 +1,99 @@
+
+import Resolver from "../resolver.js";
+import { ResolverOptions, SearchResults, IntermediateSearchResults } from "../type.js";
+
+/**
+ * @param {string} fn
+ * @param {Array<ResolverOptions|Promise<ResolverOptions>>|Arguments} args
+ */
+Resolver.prototype.handler = function (fn, args) {
+
+    /** @type {ResolverOptions|Promise<ResolverOptions>} */
+    let first_argument = args[0];
+
+    if (first_argument.then) {
+        const self = this;
+        // todo: check when this branch was taken
+        // instead of Promise.all the args[] array could be reduced
+        // by iterate recursively one by one
+        return Promise.all(args).then(function (args) {
+            return self[fn].apply(self, args);
+        });
+    }
+
+    if (first_argument[0]) {
+        // detect array parameter style
+        if (first_argument[0].index) {
+            return this[fn].apply(this, first_argument);
+        }
+    }
+
+    /** @type {SearchResults|IntermediateSearchResults} */
+    let final = [],
+        promises = [],
+        limit = 0,
+        offset = 0,
+        enrich,
+        resolve,
+        suggest;
+    /** @type {Array<Promise<SearchResults|IntermediateSearchResults>>} */
+
+    for (let i = 0, query; i < args.length; i++) {
+
+        query = /** @type {string|ResolverOptions} */args[i];
+
+        if (query) {
+
+            let result;
+            if (query.constructor === Resolver) {
+                result = query.result;
+            } else if (query.constructor === Array) {
+                result = query;
+            } else {
+
+                limit = query.limit || 0;
+                offset = query.offset || 0;
+                suggest = query.suggest;
+                resolve = query.resolve;
+                enrich = query.enrich && resolve;
+
+                if (query.index) {
+                    query.resolve = /* suggest */ /* append: */ /* enrich */!1;
+                    query.enrich = !1;
+                    result = query.index.search(query).result;
+                    query.resolve = resolve;
+                    query.enrich = enrich;
+                } else if (query.and) {
+                    result = this.and(query.and);
+                } else if (query.or) {
+                    result = this.or(query.or);
+                } else if (query.xor) {
+                    result = this.xor(query.xor);
+                } else if (query.not) {
+                    result = this.not(query.not);
+                } else {
+                    continue;
+                }
+            }
+
+            if (result.then) {
+                promises.push(result);
+            } else if (result.length) {
+                final[i] = result;
+            } else if (!suggest && ("and" === fn || "xor" === fn)) {
+                final = [];
+                break;
+            }
+        }
+    }
+
+    return {
+        final,
+        promises,
+        limit,
+        offset,
+        enrich,
+        resolve,
+        suggest
+    };
+};