trellis 3.1.35 → 3.2.2

package/dist/{index-yp88he8n.js → chunk-6CTA6MCE.js}

@@ -1,4 +1,3 @@
-// @bun
 // src/core/query/types.ts
 function isVariable(t) {
   return t.kind === "variable";
@@ -14,13 +13,13 @@ function literal(value) {
 }
 
 // src/core/query/engine.ts
-class QueryEngine {
-  store;
-  rules = new Map;
-  maxRuleDepth = 32;
+var QueryEngine = class {
   constructor(store) {
     this.store = store;
   }
+  rules = /* @__PURE__ */ new Map();
+  maxRuleDepth = 32;
+  /** Register a Datalog rule. Multiple rules with the same name = union. */
   addRule(rule) {
     const existing = this.rules.get(rule.name) ?? [];
     existing.push(rule);
@@ -29,9 +28,10 @@ class QueryEngine {
   removeRule(name) {
     this.rules.delete(name);
   }
+  /** Execute a query against the store. */
   execute(query) {
     const start = performance.now();
-    let results = this._evaluatePatterns(query.where, [new Map]);
+    let results = this._evaluatePatterns(query.where, [/* @__PURE__ */ new Map()]);
     for (const filter of query.filters) {
       results = results.filter((b) => this._evalFilter(filter, b));
     }
@@ -41,10 +41,8 @@ class QueryEngine {
     if (query.orderBy.length > 0) {
       results = this._order(results, query.orderBy);
     }
-    if (query.offset > 0)
-      results = results.slice(query.offset);
-    if (query.limit > 0)
-      results = results.slice(0, query.limit);
+    if (query.offset > 0) results = results.slice(query.offset);
+    if (query.limit > 0) results = results.slice(0, query.limit);
     const projected = this._project(results, query.select);
     return {
       bindings: projected,
@@ -52,11 +50,13 @@ class QueryEngine {
       count: projected.length
     };
   }
+  // -------------------------------------------------------------------------
+  // Pattern evaluation
+  // -------------------------------------------------------------------------
   _evaluatePatterns(patterns, bindings) {
     let current = bindings;
     for (const pattern of patterns) {
-      if (current.length === 0)
-        break;
+      if (current.length === 0) break;
       current = this._evaluatePattern(pattern, current);
     }
     return current;
@@ -82,18 +82,18 @@ class QueryEngine {
       const aResolved = this._resolve(p.attribute, b);
       const vResolved = this._resolve(p.value, b);
       let facts;
-      if (eResolved !== undefined && aResolved !== undefined) {
+      if (eResolved !== void 0 && aResolved !== void 0) {
         facts = this.store.getFactsByEntity(String(eResolved)).filter((f) => f.a === aResolved);
-      } else if (eResolved !== undefined) {
+      } else if (eResolved !== void 0) {
         facts = this.store.getFactsByEntity(String(eResolved));
-      } else if (aResolved !== undefined && vResolved !== undefined) {
+      } else if (aResolved !== void 0 && vResolved !== void 0) {
         facts = this.store.getFactsByValue(String(aResolved), vResolved);
-      } else if (aResolved !== undefined) {
+      } else if (aResolved !== void 0) {
         facts = this.store.getFactsByAttribute(String(aResolved));
       } else {
         facts = this.store.getAllFacts();
       }
-      if (vResolved !== undefined) {
+      if (vResolved !== void 0) {
         facts = facts.filter((f) => f.v === vResolved);
       }
       for (const fact of facts) {
@@ -112,16 +112,19 @@ class QueryEngine {
       const attrResolved = this._resolve(p.attribute, b);
       const tgtResolved = this._resolve(p.target, b);
       let links;
-      if (srcResolved !== undefined && attrResolved !== undefined) {
-        links = this.store.getLinksByEntityAndAttribute(String(srcResolved), String(attrResolved));
-      } else if (srcResolved !== undefined) {
+      if (srcResolved !== void 0 && attrResolved !== void 0) {
+        links = this.store.getLinksByEntityAndAttribute(
+          String(srcResolved),
+          String(attrResolved)
+        );
+      } else if (srcResolved !== void 0) {
         links = this.store.getLinksByEntity(String(srcResolved));
-      } else if (attrResolved !== undefined) {
+      } else if (attrResolved !== void 0) {
         links = this.store.getLinksByAttribute(String(attrResolved));
       } else {
         links = this.store.getAllLinks();
       }
-      if (tgtResolved !== undefined) {
+      if (tgtResolved !== void 0) {
         links = links.filter((l) => l.e2 === tgtResolved);
       }
       for (const link of links) {
@@ -148,34 +151,32 @@ class QueryEngine {
     return this._dedup(results);
   }
   _evalRuleApplication(p, bindings, depth = 0) {
-    if (depth > this.maxRuleDepth)
-      return [];
+    if (depth > this.maxRuleDepth) return [];
     const ruleDefs = this.rules.get(p.name);
-    if (!ruleDefs)
-      return [];
+    if (!ruleDefs) return [];
     const results = [];
     for (const b of bindings) {
       for (const rule of ruleDefs) {
         const ruleBindings = new Map(b);
         let ok = true;
-        for (let i = 0;i < rule.params.length && i < p.args.length; i++) {
+        for (let i = 0; i < rule.params.length && i < p.args.length; i++) {
           const resolved = this._resolve(p.args[i], b);
-          if (resolved !== undefined) {
+          if (resolved !== void 0) {
             ruleBindings.set(rule.params[i], resolved);
-          } else if (isVariable(p.args[i])) {}
+          } else if (isVariable(p.args[i])) {
+          }
         }
-        if (!ok)
-          continue;
+        if (!ok) continue;
         let bodyResults = this._evaluatePatterns(rule.body, [ruleBindings]);
         for (const f of rule.filters) {
           bodyResults = bodyResults.filter((rb) => this._evalFilter(f, rb));
         }
         for (const rb of bodyResults) {
           const nb = new Map(b);
-          for (let i = 0;i < rule.params.length && i < p.args.length; i++) {
+          for (let i = 0; i < rule.params.length && i < p.args.length; i++) {
             if (isVariable(p.args[i])) {
               const val = rb.get(rule.params[i]);
-              if (val !== undefined)
+              if (val !== void 0)
                 nb.set(p.args[i].name, val);
             }
           }
@@ -185,11 +186,13 @@ class QueryEngine {
     }
     return this._dedup(results);
   }
+  // -------------------------------------------------------------------------
+  // Filtering
+  // -------------------------------------------------------------------------
   _evalFilter(filter, b) {
     const left = this._resolve(filter.left, b);
     const right = this._resolve(filter.right, b);
-    if (left === undefined || right === undefined)
-      return false;
+    if (left === void 0 || right === void 0) return false;
     switch (filter.op) {
       case "=":
         return left === right;
@@ -215,12 +218,15 @@ class QueryEngine {
         return false;
     }
   }
+  // -------------------------------------------------------------------------
+  // Aggregation
+  // -------------------------------------------------------------------------
   _aggregate(bindings, aggregates, groupBy) {
     const aggVarNames = new Set(aggregates.map((a) => a.as));
     const groupVars = groupBy.filter((v) => !aggVarNames.has(v));
-    const groups = new Map;
+    const groups = /* @__PURE__ */ new Map();
     for (const b of bindings) {
-      const key = groupVars.map((v) => String(b.get(v) ?? "")).join("\x00");
+      const key = groupVars.map((v) => String(b.get(v) ?? "")).join("\0");
       const group = groups.get(key) ?? [];
       group.push(b);
       groups.set(key, group);
@@ -229,7 +235,7 @@ class QueryEngine {
     for (const [, group] of groups) {
       const nb = new Map(group[0]);
       for (const agg of aggregates) {
-        const vals = group.map((b) => b.get(agg.variable)).filter((v) => v !== undefined);
+        const vals = group.map((b) => b.get(agg.variable)).filter((v) => v !== void 0);
         nb.set(agg.as, this._computeAggregate(agg.op, vals));
       }
       results.push(nb);
@@ -241,76 +247,94 @@ class QueryEngine {
       case "count":
         return vals.length;
       case "sum":
-        return vals.reduce((s, v) => s + (Number(v) || 0), 0);
+        return vals.reduce(
+          (s, v) => s + (Number(v) || 0),
+          0
+        );
       case "avg":
-        return vals.length ? vals.reduce((s, v) => s + (Number(v) || 0), 0) / vals.length : 0;
+        return vals.length ? vals.reduce(
+          (s, v) => s + (Number(v) || 0),
+          0
+        ) / vals.length : 0;
       case "min":
-        return vals.reduce((m, v) => v < m ? v : m, vals[0]);
+        return vals.reduce(
+          (m, v) => v < m ? v : m,
+          vals[0]
+        );
       case "max":
-        return vals.reduce((m, v) => v > m ? v : m, vals[0]);
+        return vals.reduce(
+          (m, v) => v > m ? v : m,
+          vals[0]
+        );
       case "collect":
         return JSON.stringify(vals);
       default:
         return vals.length;
     }
   }
+  // -------------------------------------------------------------------------
+  // Ordering
+  // -------------------------------------------------------------------------
   _order(bindings, orderBy) {
     return [...bindings].sort((a, b) => {
       for (const o of orderBy) {
         const va = a.get(o.variable);
         const vb = b.get(o.variable);
-        if (va === vb)
-          continue;
-        if (va === undefined)
-          return 1;
-        if (vb === undefined)
-          return -1;
+        if (va === vb) continue;
+        if (va === void 0) return 1;
+        if (vb === void 0) return -1;
         const cmp = va < vb ? -1 : 1;
         return o.direction === "asc" ? cmp : -cmp;
       }
       return 0;
     });
   }
+  // -------------------------------------------------------------------------
+  // Projection
+  // -------------------------------------------------------------------------
   _project(bindings, select) {
     return bindings.map((b) => {
       const row = {};
       if (select.length === 0) {
-        for (const [k, v] of b)
-          row[k] = v;
+        for (const [k, v] of b) row[k] = v;
       } else {
         for (const s of select) {
           const v = b.get(s);
-          if (v !== undefined)
-            row[s] = v;
+          if (v !== void 0) row[s] = v;
         }
       }
       return row;
     });
   }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
   _resolve(term, bindings) {
-    if (isLiteral(term))
-      return term.value;
+    if (isLiteral(term)) return term.value;
     return bindings.get(term.name);
   }
   _bind(term, value, bindings) {
-    if (isLiteral(term))
-      return term.value === value;
+    if (isLiteral(term)) return term.value === value;
     const existing = bindings.get(term.name);
-    if (existing !== undefined)
-      return existing === value;
+    if (existing !== void 0) return existing === value;
     bindings.set(term.name, value);
     return true;
   }
   _dedup(bindings) {
-    const seen = new Set;
+    const seen = /* @__PURE__ */ new Set();
     return bindings.filter((b) => {
-      const key = [...b.entries()].sort(([a], [b2]) => a.localeCompare(b2)).map(([k, v]) => `${k}=${v}`).join("\x00");
-      if (seen.has(key))
-        return false;
+      const key = [...b.entries()].sort(([a], [b2]) => a.localeCompare(b2)).map(([k, v]) => `${k}=${v}`).join("\0");
+      if (seen.has(key)) return false;
       seen.add(key);
       return true;
     });
   }
-}
+};
 
-export { isVariable, isLiteral, variable, literal, QueryEngine };
+export {
+  isVariable,
+  isLiteral,
+  variable,
+  literal,
+  QueryEngine
+};