@thi.ng/rstream-query 2.1.86 → 2.1.88

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-18T13:41:20Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1 +0,0 @@
-export {};

package/convert.js

@@ -5,70 +5,24 @@ import { mapcat } from "@thi.ng/transducers/mapcat";
 import { pairs } from "@thi.ng/transducers/pairs";
 let NEXT_ID = 0;
 const mapBNode = (s, p, o) => {
-    const id = `__b${NEXT_ID++}__`;
-    return concat([[s, p, id]], asTriples(o, id));
+  const id = `__b${NEXT_ID++}__`;
+  return concat([[s, p, id]], asTriples(o, id));
 };
 const mapSubject = (subject) => ([p, o]) => {
-    if (isArray(o)) {
-        return mapcat((o) => isPlainObject(o)
-            ? mapBNode(subject, p, o)
-            : [[subject, p, o]], o);
-    }
-    else if (isPlainObject(o)) {
-        return mapBNode(subject, p, o);
-    }
-    return [[subject, p, o]];
+  if (isArray(o)) {
+    return mapcat(
+      (o2) => isPlainObject(o2) ? mapBNode(subject, p, o2) : [[subject, p, o2]],
+      o
+    );
+  } else if (isPlainObject(o)) {
+    return mapBNode(subject, p, o);
+  }
+  return [[subject, p, o]];
+};
+const asTriples = (obj, subject) => mapcat(
+  subject === void 0 ? ([s, v]) => mapcat(mapSubject(s), pairs(v)) : mapSubject(subject),
+  pairs(obj)
+);
+export {
+  asTriples
 };
-/**
- * Converts given object into an iterable of triples, with the following
- * conversion rules:
- *
- * - Toplevel object keys are used as subjects and MUST each have a
- *   plain object as value, where its keys are used as predicates and
- *   values as objects (in the SPO sense).
- * - Plain objects in SPO object position are translated into unique IDs
- *   in order to allow the nested map to become a subject itself. In RDF
- *   terms, this is equivalent to BNodes.
- * - Arrays in SPO object position cause multiple triples with same
- *   subject & predicate to be emitted. If any of the items in the array
- *   is a plain object, it will be treated as BNode and transformed as
- *   described in the previous rule
- *
- * @example
- * ```ts
- * src = {
- *   "@thi.ng/rstream-query": {
- *     type: "project",
- *     author: "toxi",
- *     tag: ["ES6", "TypeScript", "graph"]
- *   },
- *   toxi: {
- *     type: "person",
- *     hasAccount: [
- *       {type: "twitter", id: "toxi"},
- *       {type: "github", id: "postspectacular"}
- *     ]
- *   }
- * };
- *
- * [...asTriples(src)]
- * // [ [ '@thi.ng/rstream-query', 'type', 'project' ],
- * //   [ '@thi.ng/rstream-query', 'author', 'toxi' ],
- * //   [ '@thi.ng/rstream-query', 'tag', 'ES6' ],
- * //   [ '@thi.ng/rstream-query', 'tag', 'TypeScript' ],
- * //   [ '@thi.ng/rstream-query', 'tag', 'graph' ],
- * //   [ 'toxi', 'type', 'person' ],
- * //   [ 'toxi', 'hasAccount', '__b0__' ],
- * //   [ '__b0__', 'type', 'twitter' ],
- * //   [ '__b0__', 'id', 'toxi' ],
- * //   [ 'toxi', 'hasAccount', '__b1__' ],
- * //   [ '__b1__', 'type', 'github' ],
- * //   [ '__b1__', 'id', 'postspectacular' ] ]
- * ```
- *
- * @param obj -
- * @param subject - internal use only, do not specify!
- */
-export const asTriples = (obj, subject) => mapcat(subject === undefined
-    ? ([s, v]) => mapcat(mapSubject(s), pairs(v))
-    : mapSubject(subject), pairs(obj));

package/logger.js

@@ -1,3 +1,7 @@
 import { NULL_LOGGER } from "@thi.ng/logger/null";
-export let LOGGER = NULL_LOGGER;
-export const setLogger = (logger) => (LOGGER = logger);
+let LOGGER = NULL_LOGGER;
+const setLogger = (logger) => LOGGER = logger;
+export {
+  LOGGER,
+  setLogger
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/rstream-query",
-  "version": "2.1.86",
+  "version": "2.1.88",
   "description": "@thi.ng/rstream based triple store & reactive query engine",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,19 +35,20 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/associative": "^6.3.23",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/equiv": "^2.1.36",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/logger": "^2.0.1",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/rstream": "^8.2.13",
-    "@thi.ng/rstream-dot": "^3.0.36",
-    "@thi.ng/transducers": "^8.8.14"
+    "@thi.ng/api": "^8.9.13",
+    "@thi.ng/associative": "^6.3.25",
+    "@thi.ng/checks": "^3.4.13",
+    "@thi.ng/equiv": "^2.1.38",
+    "@thi.ng/errors": "^2.4.7",
+    "@thi.ng/logger": "^2.1.0",
+    "@thi.ng/math": "^5.7.8",
+    "@thi.ng/rstream": "^8.2.15",
+    "@thi.ng/rstream-dot": "^3.0.38",
+    "@thi.ng/transducers": "^8.8.16"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -70,7 +73,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=12.7"
+    "node": ">=18"
   },
   "files": [
     "./*.js",
@@ -106,5 +109,5 @@
     "parent": "@thi.ng/rstream",
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "25a42a81fac8603a1e440a7aa8bc343276211ff4\n"
 }

package/pattern.js

@@ -1,49 +1,35 @@
 import { repeatedly } from "@thi.ng/transducers/repeatedly";
 import { autoQVar, isQVar, qvarName } from "./qvar.js";
-export const patternVarCount = (p) => {
-    let n = 0;
-    if (isQVar(p[0]))
-        n++;
-    if (isQVar(p[1]))
-        n++;
-    if (isQVar(p[2]))
-        n++;
-    return n;
+const patternVarCount = (p) => {
+  let n = 0;
+  if (isQVar(p[0]))
+    n++;
+  if (isQVar(p[1]))
+    n++;
+  if (isQVar(p[2]))
+    n++;
+  return n;
 };
-export const patternVars = ([s, p, o]) => {
-    const vars = [];
-    isQVar(s) && vars.push(qvarName(s));
-    isQVar(p) && vars.push(qvarName(p));
-    isQVar(o) && vars.push(qvarName(o));
-    return vars;
+const patternVars = ([s, p, o]) => {
+  const vars = [];
+  isQVar(s) && vars.push(qvarName(s));
+  isQVar(p) && vars.push(qvarName(p));
+  isQVar(o) && vars.push(qvarName(o));
+  return vars;
 };
-/**
- * Takes a path triple pattern and max depth. The pattern's predicate
- * must be a seq of preds. Returns a 2-elem vector [patterns vars],
- * where `patterns` is a list of generated sub-query patterns with
- * injected temp qvars for in between patterns and `vars` are the temp
- * qvars themselves.
- *
- * Example:
- *
- * ```
- * ["?s", [p1, p2, p3], "?o"] =>
- * [
- *   [["?s", p1, "?__q0"], ["?__q0", p2, "?__q1"], ["?__q1", p3, "?o"] ],
- *   ["?__q0", "?__q1"]
- * ]
- * ```
- *
- * @param pattern -
- * @param maxLen -
- */
-export const resolvePathPattern = ([s, p, o], maxLen = p.length) => {
-    const res = [];
-    const avars = [...repeatedly(autoQVar, maxLen - 1)];
-    for (let i = 0; i < maxLen; i++) {
-        res.push([s, p[i % p.length], (s = avars[i])]);
-    }
-    res[res.length - 1][2] = o;
-    return [res, avars];
+const resolvePathPattern = ([s, p, o], maxLen = p.length) => {
+  const res = [];
+  const avars = [...repeatedly(autoQVar, maxLen - 1)];
+  for (let i = 0; i < maxLen; i++) {
+    res.push([s, p[i % p.length], s = avars[i]]);
+  }
+  res[res.length - 1][2] = o;
+  return [res, avars];
+};
+const sortPatterns = (patterns) => patterns.sort((a, b) => patternVarCount(a) - patternVarCount(b));
+export {
+  patternVarCount,
+  patternVars,
+  resolvePathPattern,
+  sortPatterns
 };
-export const sortPatterns = (patterns) => patterns.sort((a, b) => patternVarCount(a) - patternVarCount(b));

package/qvar.js

@@ -1,46 +1,39 @@
 import { isString } from "@thi.ng/checks/is-string";
 const AUTO_QVAR_PREFIX = "?__q";
 let AUTO_QVAR_ID = 0;
-export const isQVar = (x) => isString(x) && x.charAt(0) === "?";
-export const isAutoQVar = (x) => isString(x) && x.indexOf(AUTO_QVAR_PREFIX) == 0;
-export const autoQVar = () => AUTO_QVAR_PREFIX + (AUTO_QVAR_ID++).toString(36);
-export const qvarName = (x) => x.substring(1);
-/**
- * Returns an optimized query variable solution extractor function based
- * on given pattern type. `vs`, `vp`, `vo` are flags to indicate if `s`,
- * `p` and/or `o` pattern items are query variables. The returned fn
- * will be optimized to 1 of the 8 possible case and accepts a single
- * fact to extract the respective variables from.
- *
- * @param vs -
- * @param vp -
- * @param vo -
- * @param s -
- * @param p -
- * @param o -
- */
-export const qvarResolver = (vs, vp, vo, s, p, o) => {
-    const type = (vs << 2) | (vp << 1) | vo;
-    let ss = vs && qvarName(s);
-    let pp = vp && qvarName(p);
-    let oo = vo && qvarName(o);
-    switch (type) {
-        case 0:
-        default:
-            return;
-        case 1:
-            return (f) => ({ [oo]: f[2] });
-        case 2:
-            return (f) => ({ [pp]: f[1] });
-        case 3:
-            return (f) => ({ [pp]: f[1], [oo]: f[2] });
-        case 4:
-            return (f) => ({ [ss]: f[0] });
-        case 5:
-            return (f) => ({ [ss]: f[0], [oo]: f[2] });
-        case 6:
-            return (f) => ({ [ss]: f[0], [pp]: f[1] });
-        case 7:
-            return (f) => ({ [ss]: f[0], [pp]: f[1], [oo]: f[2] });
-    }
+const isQVar = (x) => isString(x) && x.charAt(0) === "?";
+const isAutoQVar = (x) => isString(x) && x.indexOf(AUTO_QVAR_PREFIX) == 0;
+const autoQVar = () => AUTO_QVAR_PREFIX + (AUTO_QVAR_ID++).toString(36);
+const qvarName = (x) => x.substring(1);
+const qvarResolver = (vs, vp, vo, s, p, o) => {
+  const type = vs << 2 | vp << 1 | vo;
+  let ss = vs && qvarName(s);
+  let pp = vp && qvarName(p);
+  let oo = vo && qvarName(o);
+  switch (type) {
+    case 0:
+    default:
+      return;
+    case 1:
+      return (f) => ({ [oo]: f[2] });
+    case 2:
+      return (f) => ({ [pp]: f[1] });
+    case 3:
+      return (f) => ({ [pp]: f[1], [oo]: f[2] });
+    case 4:
+      return (f) => ({ [ss]: f[0] });
+    case 5:
+      return (f) => ({ [ss]: f[0], [oo]: f[2] });
+    case 6:
+      return (f) => ({ [ss]: f[0], [pp]: f[1] });
+    case 7:
+      return (f) => ({ [ss]: f[0], [pp]: f[1], [oo]: f[2] });
+  }
+};
+export {
+  autoQVar,
+  isAutoQVar,
+  isQVar,
+  qvarName,
+  qvarResolver
 };

package/store.js

@@ -16,317 +16,354 @@ import { mapIndexed } from "@thi.ng/transducers/map-indexed";
 import { transduce } from "@thi.ng/transducers/transduce";
 import { patternVars, resolvePathPattern } from "./pattern.js";
 import { isQVar, qvarResolver } from "./qvar.js";
-import { bindVars, filterSolutions, indexSel, intersect2, intersect3, joinSolutions, limitSolutions, resultTriples, } from "./xforms.js";
-export class TripleStore {
-    NEXT_ID;
-    freeIDs;
-    triples;
-    indexS;
-    indexP;
-    indexO;
-    indexSelections;
-    queries;
-    allIDs;
-    streamAll;
-    streamS;
-    streamP;
-    streamO;
-    constructor(triples) {
-        this.triples = [];
-        this.freeIDs = [];
-        this.queries = new Map();
-        this.indexS = new Map();
-        this.indexP = new Map();
-        this.indexO = new Map();
-        this.indexSelections = {
-            s: new Map(),
-            p: new Map(),
-            o: new Map(),
-        };
-        this.streamS = new Stream({ id: "S", closeOut: CloseMode.NEVER });
-        this.streamP = new Stream({ id: "P", closeOut: CloseMode.NEVER });
-        this.streamO = new Stream({ id: "O", closeOut: CloseMode.NEVER });
-        this.streamAll = new Stream({ id: "ALL", closeOut: CloseMode.NEVER });
-        this.allIDs = new Set();
-        this.NEXT_ID = 0;
-        if (triples) {
-            this.into(triples);
-        }
-    }
-    *[Symbol.iterator]() {
-        for (let t of this.triples) {
-            if (t) {
-                yield t;
-            }
-        }
-    }
-    has(t) {
-        return this.get(t) !== undefined;
-    }
-    get(t, notFound) {
-        const id = this.findTriple(this.indexS.get(t[0]), this.indexP.get(t[1]), this.indexO.get(t[2]), t);
-        return id !== -1 ? this.triples[id] : notFound;
-    }
-    add(t) {
-        let s = this.indexS.get(t[0]);
-        let p = this.indexP.get(t[1]);
-        let o = this.indexO.get(t[2]);
-        if (this.findTriple(s, p, o, t) !== -1)
-            return false;
-        const id = this.nextID();
-        const is = s || new Set();
-        const ip = p || new Set();
-        const io = o || new Set();
-        this.triples[id] = t;
-        is.add(id);
-        ip.add(id);
-        io.add(id);
-        this.allIDs.add(id);
-        !s && this.indexS.set(t[0], is);
-        !p && this.indexP.set(t[1], ip);
-        !o && this.indexO.set(t[2], io);
-        this.broadcastTriple(is, ip, io, t);
-        return true;
+import {
+  bindVars,
+  filterSolutions,
+  indexSel,
+  intersect2,
+  intersect3,
+  joinSolutions,
+  limitSolutions,
+  resultTriples
+} from "./xforms.js";
+class TripleStore {
+  NEXT_ID;
+  freeIDs;
+  triples;
+  indexS;
+  indexP;
+  indexO;
+  indexSelections;
+  queries;
+  allIDs;
+  streamAll;
+  streamS;
+  streamP;
+  streamO;
+  constructor(triples) {
+    this.triples = [];
+    this.freeIDs = [];
+    this.queries = /* @__PURE__ */ new Map();
+    this.indexS = /* @__PURE__ */ new Map();
+    this.indexP = /* @__PURE__ */ new Map();
+    this.indexO = /* @__PURE__ */ new Map();
+    this.indexSelections = {
+      s: /* @__PURE__ */ new Map(),
+      p: /* @__PURE__ */ new Map(),
+      o: /* @__PURE__ */ new Map()
+    };
+    this.streamS = new Stream({ id: "S", closeOut: CloseMode.NEVER });
+    this.streamP = new Stream({ id: "P", closeOut: CloseMode.NEVER });
+    this.streamO = new Stream({ id: "O", closeOut: CloseMode.NEVER });
+    this.streamAll = new Stream({ id: "ALL", closeOut: CloseMode.NEVER });
+    this.allIDs = /* @__PURE__ */ new Set();
+    this.NEXT_ID = 0;
+    if (triples) {
+      this.into(triples);
     }
-    into(triples) {
-        let ok = true;
-        for (let f of triples) {
-            ok = this.add(f) && ok;
-        }
-        return ok;
-    }
-    delete(t) {
-        let s = this.indexS.get(t[0]);
-        let p = this.indexP.get(t[1]);
-        let o = this.indexO.get(t[2]);
-        const id = this.findTriple(s, p, o, t);
-        if (id === -1)
-            return false;
-        s.delete(id);
-        !s.size && this.indexS.delete(t[0]);
-        p.delete(id);
-        !p.size && this.indexP.delete(t[1]);
-        o.delete(id);
-        !o.size && this.indexO.delete(t[2]);
-        this.allIDs.delete(id);
-        delete this.triples[id];
-        this.freeIDs.push(id);
-        this.broadcastTriple(s, p, o, t);
-        return true;
+  }
+  *[Symbol.iterator]() {
+    for (let t of this.triples) {
+      if (t) {
+        yield t;
+      }
     }
-    /**
-     * Replaces triple `a` with `b`, *iff* `a` is actually in the store.
-     * Else does nothing.
-     *
-     * @param a -
-     * @param b -
-     */
-    replace(a, b) {
-        if (this.delete(a)) {
-            return this.add(b);
-        }
-        return false;
+  }
+  has(t) {
+    return this.get(t) !== void 0;
+  }
+  get(t, notFound) {
+    const id = this.findTriple(
+      this.indexS.get(t[0]),
+      this.indexP.get(t[1]),
+      this.indexO.get(t[2]),
+      t
+    );
+    return id !== -1 ? this.triples[id] : notFound;
+  }
+  add(t) {
+    let s = this.indexS.get(t[0]);
+    let p = this.indexP.get(t[1]);
+    let o = this.indexO.get(t[2]);
+    if (this.findTriple(s, p, o, t) !== -1)
+      return false;
+    const id = this.nextID();
+    const is = s || /* @__PURE__ */ new Set();
+    const ip = p || /* @__PURE__ */ new Set();
+    const io = o || /* @__PURE__ */ new Set();
+    this.triples[id] = t;
+    is.add(id);
+    ip.add(id);
+    io.add(id);
+    this.allIDs.add(id);
+    !s && this.indexS.set(t[0], is);
+    !p && this.indexP.set(t[1], ip);
+    !o && this.indexO.set(t[2], io);
+    this.broadcastTriple(is, ip, io, t);
+    return true;
+  }
+  into(triples) {
+    let ok = true;
+    for (let f of triples) {
+      ok = this.add(f) && ok;
     }
-    addPatternQuery(pattern, id, emitTriples = true) {
-        let results;
-        const [s, p, o] = pattern;
-        if (s == null && p == null && o == null) {
-            results = this.streamAll;
-        }
-        else {
-            const key = JSON.stringify(pattern);
-            if (!(results = this.queries.get(key))) {
-                const qs = this.getIndexSelection(this.streamS, s, "s");
-                const qp = this.getIndexSelection(this.streamP, p, "p");
-                const qo = this.getIndexSelection(this.streamO, o, "o");
-                let src;
-                let xform = intersect2;
-                // optimize cases with 2 null terms (only needs single intersection w/ streamAll)
-                if (s == null && p == null) {
-                    src = { a: qo, b: qs };
-                }
-                else if (s == null && o == null) {
-                    src = { a: qp, b: qs };
-                }
-                else if (p == null && o == null) {
-                    src = { a: qs, b: qp };
-                }
-                else {
-                    src = { s: qs, p: qp, o: qo };
-                    xform = intersect3;
-                }
-                results = sync({
-                    id,
-                    src,
-                    xform,
-                    reset: true,
-                });
-                this.queries.set(key, results);
-                submit(this.indexS, qs, s);
-                submit(this.indexP, qp, p);
-                submit(this.indexO, qo, o);
-            }
-        }
-        return emitTriples ? results.transform(resultTriples(this)) : results;
+    return ok;
+  }
+  delete(t) {
+    let s = this.indexS.get(t[0]);
+    let p = this.indexP.get(t[1]);
+    let o = this.indexO.get(t[2]);
+    const id = this.findTriple(s, p, o, t);
+    if (id === -1)
+      return false;
+    s.delete(id);
+    !s.size && this.indexS.delete(t[0]);
+    p.delete(id);
+    !p.size && this.indexP.delete(t[1]);
+    o.delete(id);
+    !o.size && this.indexO.delete(t[2]);
+    this.allIDs.delete(id);
+    delete this.triples[id];
+    this.freeIDs.push(id);
+    this.broadcastTriple(s, p, o, t);
+    return true;
+  }
+  /**
+   * Replaces triple `a` with `b`, *iff* `a` is actually in the store.
+   * Else does nothing.
+   *
+   * @param a -
+   * @param b -
+   */
+  replace(a, b) {
+    if (this.delete(a)) {
+      return this.add(b);
     }
-    /**
-     * Creates a new parametric query using given pattern with at least
-     * 1 query variable. Query vars are strings with `?` prefix. The
-     * rest of the string is considered the variable name.
-     *
-     * ```
-     * g.addParamQuery(["?a", "friend", "?b"]);
-     * ```
-     *
-     * Internally, the query pattern is translated into a basic param
-     * query with an additional result transformation to resolve the
-     * stated query variable solutions. Returns a rstream subscription
-     * emitting arrays of solution objects like:
-     *
-     * ```
-     * [{a: "asterix", b: "obelix"}, {a: "romeo", b: "julia"}]
-     * ```
-     *
-     * @param id -
-     * @param param1 -
-     */
-    addParamQuery([s, p, o], id) {
-        const vs = isQVar(s);
-        const vp = isQVar(p);
-        const vo = isQVar(o);
-        const resolve = qvarResolver(vs, vp, vo, s, p, o);
-        if (!resolve) {
-            illegalArgs("at least 1 query variable is required in pattern");
+    return false;
+  }
+  addPatternQuery(pattern, id, emitTriples = true) {
+    let results;
+    const [s, p, o] = pattern;
+    if (s == null && p == null && o == null) {
+      results = this.streamAll;
+    } else {
+      const key = JSON.stringify(pattern);
+      if (!(results = this.queries.get(key))) {
+        const qs = this.getIndexSelection(this.streamS, s, "s");
+        const qp = this.getIndexSelection(this.streamP, p, "p");
+        const qo = this.getIndexSelection(this.streamO, o, "o");
+        let src;
+        let xform = intersect2;
+        if (s == null && p == null) {
+          src = { a: qo, b: qs };
+        } else if (s == null && o == null) {
+          src = { a: qp, b: qs };
+        } else if (p == null && o == null) {
+          src = { a: qs, b: qp };
+        } else {
+          src = { s: qs, p: qp, o: qo };
+          xform = intersect3;
         }
-        id || (id = `query-${__nextID()}`);
-        const query = (this.addPatternQuery([vs ? null : s, vp ? null : p, vo ? null : o], id + "-raw"));
-        return query.transform(map((triples) => {
-            const res = new Set();
-            for (let f of triples) {
-                res.add(resolve(f));
-            }
-            return res;
-        }), dedupe(equiv), { id });
-    }
-    /**
-     * Converts the given path pattern into a number of sub-queries and
-     * return a rstream subscription of re-joined result solutions. If
-     * `maxLen` is given and greater than the number of actual path
-     * predicates, the predicates are repeated.
-     *
-     * @param path -
-     * @param maxDepth -
-     * @param id -
-     */
-    addPathQuery(path, len = path[1].length, id) {
-        return this.addMultiJoin(this.addParamQueries(resolvePathPattern(path, len)[0]), patternVars(path), id);
-    }
-    /**
-     * Like {@link TripleStore.addMultiJoin}, but optimized for only two
-     * input queries. Returns a rstream subscription computing the
-     * natural join of the given input query results.
-     *
-     * @param id -
-     * @param a -
-     * @param b -
-     */
-    addJoin(a, b, id) {
-        return sync({
-            id,
-            src: { a, b },
-            xform: comp(map(({ a, b }) => join(a, b)), dedupe(equiv)),
+        results = sync({
+          id,
+          src,
+          xform,
+          reset: true
         });
+        this.queries.set(key, results);
+        submit(this.indexS, qs, s);
+        submit(this.indexP, qp, p);
+        submit(this.indexO, qo, o);
+      }
     }
-    addMultiJoin(queries, keepVars, id) {
-        const src = transduce(mapIndexed((i, q) => [
-            String(i),
-            q,
-        ]), assocObj(), queries);
-        let xforms = [
-            joinSolutions(Object.keys(src).length),
-            dedupe(equiv),
-        ];
-        keepVars && xforms.push(filterSolutions(keepVars));
-        return sync({
-            id,
-            src,
-            xform: comp.apply(null, xforms),
-        });
+    return emitTriples ? results.transform(resultTriples(this)) : results;
+  }
+  /**
+   * Creates a new parametric query using given pattern with at least
+   * 1 query variable. Query vars are strings with `?` prefix. The
+   * rest of the string is considered the variable name.
+   *
+   * ```
+   * g.addParamQuery(["?a", "friend", "?b"]);
+   * ```
+   *
+   * Internally, the query pattern is translated into a basic param
+   * query with an additional result transformation to resolve the
+   * stated query variable solutions. Returns a rstream subscription
+   * emitting arrays of solution objects like:
+   *
+   * ```
+   * [{a: "asterix", b: "obelix"}, {a: "romeo", b: "julia"}]
+   * ```
+   *
+   * @param id -
+   * @param param1 -
+   */
+  addParamQuery([s, p, o], id) {
+    const vs = isQVar(s);
+    const vp = isQVar(p);
+    const vo = isQVar(o);
+    const resolve = qvarResolver(vs, vp, vo, s, p, o);
+    if (!resolve) {
+      illegalArgs("at least 1 query variable is required in pattern");
     }
-    /**
-     * Compiles given query spec into a number of sub-queries and result
-     * transformations. Returns rstream subscription of final result
-     * sets. See {@link QuerySpec} docs for further details.
-     *
-     * @param spec -
-     */
-    addQueryFromSpec(spec) {
-        let query;
-        let curr;
-        for (let q of spec.q) {
-            if (isWhereQuery(q)) {
-                curr = this.addMultiJoin(this.addParamQueries(q.where));
-            }
-            else if (isPathQuery(q)) {
-                curr = this.addPathQuery(q.path);
-            }
-            query && curr && (curr = this.addJoin(query, curr));
-            query = curr;
-        }
-        assert(!!query, "illegal query spec");
-        let xforms = [];
-        spec.limit && xforms.push(limitSolutions(spec.limit));
-        spec.bind && xforms.push(bindVars(spec.bind));
-        spec.select && xforms.push(filterSolutions(spec.select));
-        if (xforms.length) {
-            // @ts-ignore
-            query = query.transform(...xforms);
+    id || (id = `query-${__nextID()}`);
+    const query = this.addPatternQuery(
+      [vs ? null : s, vp ? null : p, vo ? null : o],
+      id + "-raw"
+    );
+    return query.transform(
+      map((triples) => {
+        const res = /* @__PURE__ */ new Set();
+        for (let f of triples) {
+          res.add(resolve(f));
         }
-        return query;
-    }
-    toDot(opts) {
-        return serialize([this.streamS, this.streamP, this.streamO, this.streamAll], opts);
+        return res;
+      }),
+      dedupe(equiv),
+      { id }
+    );
+  }
+  /**
+   * Converts the given path pattern into a number of sub-queries and
+   * return a rstream subscription of re-joined result solutions. If
+   * `maxLen` is given and greater than the number of actual path
+   * predicates, the predicates are repeated.
+   *
+   * @param path -
+   * @param maxDepth -
+   * @param id -
+   */
+  addPathQuery(path, len = path[1].length, id) {
+    return this.addMultiJoin(
+      this.addParamQueries(resolvePathPattern(path, len)[0]),
+      patternVars(path),
+      id
+    );
+  }
+  /**
+   * Like {@link TripleStore.addMultiJoin}, but optimized for only two
+   * input queries. Returns a rstream subscription computing the
+   * natural join of the given input query results.
+   *
+   * @param id -
+   * @param a -
+   * @param b -
+   */
+  addJoin(a, b, id) {
+    return sync({
+      id,
+      src: { a, b },
+      xform: comp(
+        map(({ a: a2, b: b2 }) => join(a2, b2)),
+        dedupe(equiv)
+      )
+    });
+  }
+  addMultiJoin(queries, keepVars, id) {
+    const src = transduce(
+      mapIndexed((i, q) => [
+        String(i),
+        q
+      ]),
+      assocObj(),
+      queries
+    );
+    let xforms = [
+      joinSolutions(Object.keys(src).length),
+      dedupe(equiv)
+    ];
+    keepVars && xforms.push(filterSolutions(keepVars));
+    return sync({
+      id,
+      src,
+      xform: comp.apply(null, xforms)
+    });
+  }
+  /**
+   * Compiles given query spec into a number of sub-queries and result
+   * transformations. Returns rstream subscription of final result
+   * sets. See {@link QuerySpec} docs for further details.
+   *
+   * @param spec -
+   */
+  addQueryFromSpec(spec) {
+    let query;
+    let curr;
+    for (let q of spec.q) {
+      if (isWhereQuery(q)) {
+        curr = this.addMultiJoin(this.addParamQueries(q.where));
+      } else if (isPathQuery(q)) {
+        curr = this.addPathQuery(q.path);
+      }
+      query && curr && (curr = this.addJoin(query, curr));
+      query = curr;
     }
-    nextID() {
-        return this.freeIDs.length ? this.freeIDs.pop() : this.NEXT_ID++;
+    assert(!!query, "illegal query spec");
+    let xforms = [];
+    spec.limit && xforms.push(limitSolutions(spec.limit));
+    spec.bind && xforms.push(bindVars(spec.bind));
+    spec.select && xforms.push(filterSolutions(spec.select));
+    if (xforms.length) {
+      query = query.transform(...xforms);
     }
-    broadcastTriple(s, p, o, t) {
-        this.streamAll.next(this.allIDs);
-        this.streamS.next({ index: s, key: t[0] });
-        this.streamP.next({ index: p, key: t[1] });
-        this.streamO.next({ index: o, key: t[2] });
-    }
-    findTriple(s, p, o, f) {
-        if (s && p && o) {
-            const triples = this.triples;
-            const index = [s, p, o][min3id(s.size, p.size, o.size)];
-            for (let id of index) {
-                if (equiv(triples[id], f)) {
-                    return id;
-                }
-            }
+    return query;
+  }
+  toDot(opts) {
+    return serialize(
+      [this.streamS, this.streamP, this.streamO, this.streamAll],
+      opts
+    );
+  }
+  nextID() {
+    return this.freeIDs.length ? this.freeIDs.pop() : this.NEXT_ID++;
+  }
+  broadcastTriple(s, p, o, t) {
+    this.streamAll.next(this.allIDs);
+    this.streamS.next({ index: s, key: t[0] });
+    this.streamP.next({ index: p, key: t[1] });
+    this.streamO.next({ index: o, key: t[2] });
+  }
+  findTriple(s, p, o, f) {
+    if (s && p && o) {
+      const triples = this.triples;
+      const index = [s, p, o][min3id(s.size, p.size, o.size)];
+      for (let id of index) {
+        if (equiv(triples[id], f)) {
+          return id;
         }
-        return -1;
+      }
     }
-    getIndexSelection(stream, key, id) {
-        if (key == null) {
-            return this.streamAll;
-        }
-        let sel = this.indexSelections[id].get(key);
-        if (!sel) {
-            this.indexSelections[id].set(key, (sel = stream.transform(indexSel(key), { id })));
-        }
-        return sel;
+    return -1;
+  }
+  getIndexSelection(stream, key, id) {
+    if (key == null) {
+      return this.streamAll;
     }
-    addParamQueries(patterns) {
-        return map((q) => this.addParamQuery(q), patterns);
+    let sel = this.indexSelections[id].get(key);
+    if (!sel) {
+      this.indexSelections[id].set(
+        key,
+        sel = stream.transform(indexSel(key), { id })
+      );
     }
+    return sel;
+  }
+  addParamQueries(patterns) {
+    return map(
+      (q) => this.addParamQuery(q),
+      patterns
+    );
+  }
 }
 const submit = (index, stream, key) => {
-    if (key != null) {
-        const ids = index.get(key);
-        ids && stream.next({ index: ids, key });
-    }
+  if (key != null) {
+    const ids = index.get(key);
+    ids && stream.next({ index: ids, key });
+  }
 };
 const isWhereQuery = (q) => !!q.where;
 const isPathQuery = (q) => !!q.path;
+export {
+  TripleStore
+};

package/xforms.js

@@ -7,62 +7,78 @@ import { compR } from "@thi.ng/transducers/compr";
 import { dedupe } from "@thi.ng/transducers/dedupe";
 import { keySelector } from "@thi.ng/transducers/key-selector";
 import { map } from "@thi.ng/transducers/map";
-export const intersect2 = comp(map(({ a, b }) => intersection(a, b)), dedupe(equiv));
-export const intersect3 = comp(map(({ s, p, o }) => intersection(intersection(s, p), o)), dedupe(equiv));
-export const indexSel = (key) => (rfn) => {
-    const r = rfn[2];
-    return compR(rfn, (acc, e) => {
-        LOGGER.fine("index sel", e.key, key);
-        if (equiv(e.key, key)) {
-            return r(acc, e.index);
-        }
-        return acc;
-    });
+const intersect2 = comp(
+  map(({ a, b }) => intersection(a, b)),
+  dedupe(equiv)
+);
+const intersect3 = comp(
+  map(({ s, p, o }) => intersection(intersection(s, p), o)),
+  dedupe(equiv)
+);
+const indexSel = (key) => (rfn) => {
+  const r = rfn[2];
+  return compR(rfn, (acc, e) => {
+    LOGGER.fine("index sel", e.key, key);
+    if (equiv(e.key, key)) {
+      return r(acc, e.index);
+    }
+    return acc;
+  });
 };
-export const resultTriples = (graph) => map((ids) => {
-    const res = new Set();
-    for (let id of ids)
-        res.add(graph.triples[id]);
-    return res;
+const resultTriples = (graph) => map((ids) => {
+  const res = /* @__PURE__ */ new Set();
+  for (let id of ids)
+    res.add(graph.triples[id]);
+  return res;
 });
-export const joinSolutions = (n) => map((src) => {
-    let res = src[0];
-    for (let i = 1; i < n && res.size; i++) {
-        res = join(res, src[i]);
-    }
-    return res;
+const joinSolutions = (n) => map((src) => {
+  let res = src[0];
+  for (let i = 1; i < n && res.size; i++) {
+    res = join(res, src[i]);
+  }
+  return res;
 });
-export const filterSolutions = (qvars) => {
-    const filterVars = keySelector([...qvars]);
-    return map((sol) => {
-        const res = new Set();
-        for (let s of sol) {
-            res.add(filterVars(s));
-        }
-        return res;
-    });
-};
-export const limitSolutions = (n) => map((sol) => {
-    if (sol.size <= n) {
-        return sol;
-    }
-    const res = new Set();
-    let m = n;
+const filterSolutions = (qvars) => {
+  const filterVars = keySelector([...qvars]);
+  return map((sol) => {
+    const res = /* @__PURE__ */ new Set();
     for (let s of sol) {
-        res.add(s);
-        if (--m <= 0)
-            break;
+      res.add(filterVars(s));
     }
     return res;
+  });
+};
+const limitSolutions = (n) => map((sol) => {
+  if (sol.size <= n) {
+    return sol;
+  }
+  const res = /* @__PURE__ */ new Set();
+  let m = n;
+  for (let s of sol) {
+    res.add(s);
+    if (--m <= 0)
+      break;
+  }
+  return res;
 });
-export const bindVars = (bindings) => map((sol) => {
-    const res = new Set();
-    for (let s of sol) {
-        s = { ...s };
-        res.add(s);
-        for (let b in bindings) {
-            s[b] = bindings[b](s);
-        }
+const bindVars = (bindings) => map((sol) => {
+  const res = /* @__PURE__ */ new Set();
+  for (let s of sol) {
+    s = { ...s };
+    res.add(s);
+    for (let b in bindings) {
+      s[b] = bindings[b](s);
     }
-    return res;
+  }
+  return res;
 });
+export {
+  bindVars,
+  filterSolutions,
+  indexSel,
+  intersect2,
+  intersect3,
+  joinSolutions,
+  limitSolutions,
+  resultTriples
+};