eyeling 1.7.5 → 1.7.7

package/examples/list-map.n3

@@ -0,0 +1,17 @@
+# ========================================================
+# List map
+# behaves like the functional programming operator flatMap
+# Examples from Giacomo Citi
+# ========================================================
+
+@prefix list: <http://www.w3.org/2000/10/swap/list#> .
+@prefix : <http://example.org/#>.
+
+:s1 :p1 :o1 .
+:s2 :p1 :o2 .
+:s3 :p1 :o3, :o4 .
+
+{ ((:s1 :s2) :p1) list:map (:o1 :o2) } => { :test1 :is true } .
+{ ((:s1 :s2 :s3) :p1) list:map (:o1 :o2 :o3 :o4) } => { :test2 :is true } .
+{ ((:s4) :p1) list:map () } => { :test3 :is true } .
+{ ((:s1) :p2) list:map () } => { :test4 :is true } .

package/examples/log-conclusion.n3

@@ -0,0 +1,20 @@
+# ======================
+# log:conclusion example
+# ======================
+
+@prefix : <http://example.org/>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:let :param { 
+    :Felix a :Cat . 
+    { ?X a :Cat . } => { ?X :says "Meow" . } .
+} .
+
+{ 
+    :let :param ?param .
+    ?param log:conclusion ?conclusion .
+} 
+=> 
+{ 
+    :result :is ?conclusion . 
+} .

package/examples/output/list-map.n3

@@ -0,0 +1,6 @@
+@prefix : <http://example.org/#> .
+
+:test1 :is true .
+:test2 :is true .
+:test3 :is true .
+:test4 :is true .

package/examples/output/log-conclusion.n3

@@ -0,0 +1,13 @@
+@prefix : <http://example.org/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+
+:result :is {
+    :Felix a :Cat .
+    {
+        ?X a :Cat .
+    } => {
+        ?X :says "Meow" .
+    } .
+    :Felix :says "Meow" .
+} .

package/eyeling.js

@@ -89,6 +89,62 @@ const jsonPointerCache = new Map();
 // Key is the dereferenced document IRI *without* fragment.
 const __logContentCache = new Map(); // iri -> string | null (null means fetch/read failed)
 const __logSemanticsCache = new Map(); // iri -> GraphTerm | null (null means parse failed)
+const __logConclusionCache = new WeakMap(); // GraphTerm -> GraphTerm (deductive closure)
+
+// Environment detection (Node vs Browser/Worker).
+// Eyeling is primarily synchronous, so we use sync XHR in browsers for log:content/log:semantics.
+// Note: Browser fetches are subject to CORS; use CORS-enabled resources or a proxy.
+const __IS_NODE =
+  typeof process !== 'undefined' &&
+  !!(process.versions && process.versions.node);
+
+function __hasXmlHttpRequest() {
+  return typeof XMLHttpRequest !== 'undefined';
+}
+
+function __resolveBrowserUrl(ref) {
+  if (!ref) return ref;
+  // If already absolute, keep as-is.
+  if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(ref)) return ref;
+  const base =
+    (typeof document !== 'undefined' && document.baseURI) ||
+    (typeof location !== 'undefined' && location.href) ||
+    '';
+  try {
+    return new URL(ref, base).toString();
+  } catch {
+    return ref;
+  }
+}
+
+function __fetchHttpTextSyncBrowser(url) {
+  if (!__hasXmlHttpRequest()) return null;
+  try {
+    const xhr = new XMLHttpRequest();
+    xhr.open('GET', url, false); // synchronous
+    try {
+      xhr.setRequestHeader(
+        'Accept',
+        'text/n3, text/turtle, application/n-triples, application/n-quads, text/plain;q=0.1, */*;q=0.01'
+      );
+    } catch {
+      // Some environments restrict setting headers (ignore).
+    }
+    xhr.send(null);
+    const sc = xhr.status || 0;
+    if (sc < 200 || sc >= 300) return null;
+    return xhr.responseText;
+  } catch {
+    return null;
+  }
+}
+
+function __normalizeDerefIri(iriNoFrag) {
+  // In Node, treat non-http as local path; leave as-is.
+  if (__IS_NODE) return iriNoFrag;
+  // In browsers/workers, resolve relative references against the page URL.
+  return __resolveBrowserUrl(iriNoFrag);
+}
 
 function __stripFragment(iri) {
   const i = iri.indexOf('#');
@@ -114,6 +170,7 @@ function __fileIriToPath(fileIri) {
 }
 
 function __readFileText(pathOrFileIri) {
+  if (!__IS_NODE) return null;
   const fs = require('fs');
   let path = pathOrFileIri;
   if (__isFileIri(pathOrFileIri)) path = __fileIriToPath(pathOrFileIri);
@@ -125,6 +182,7 @@ function __readFileText(pathOrFileIri) {
 }
 
 function __fetchHttpTextViaSubprocess(url) {
+  if (!__IS_NODE) return null;
   const cp = require('child_process');
   // Use a subprocess so this code remains synchronous without rewriting the whole reasoner to async.
   const script = `
@@ -180,16 +238,27 @@ function __fetchHttpTextViaSubprocess(url) {
 }
 
 function __derefTextSync(iriNoFrag) {
-  if (__logContentCache.has(iriNoFrag)) return __logContentCache.get(iriNoFrag);
+  const norm = __normalizeDerefIri(iriNoFrag);
+  const key = typeof norm === 'string' && norm ? norm : iriNoFrag;
+
+  if (__logContentCache.has(key)) return __logContentCache.get(key);
 
   let text = null;
-  if (__isHttpIri(iriNoFrag)) {
-    text = __fetchHttpTextViaSubprocess(iriNoFrag);
+
+  if (__IS_NODE) {
+    if (__isHttpIri(key)) {
+      text = __fetchHttpTextViaSubprocess(key);
+    } else {
+      // Treat any non-http(s) IRI as a local path (including file://), for basic usability.
+      text = __readFileText(key);
+    }
   } else {
-    // Treat any non-http(s) IRI as a local path (including file://), for basic usability.
-    text = __readFileText(iriNoFrag);
+    // Browser / Worker: we can only dereference over HTTP(S), and it must pass CORS.
+    const url = typeof norm === 'string' && norm ? norm : key;
+    if (__isHttpIri(url)) text = __fetchHttpTextSyncBrowser(url);
   }
-  __logContentCache.set(iriNoFrag, text);
+
+  __logContentCache.set(key, text);
   return text;
 }
 
@@ -217,22 +286,106 @@ function __parseSemanticsToFormula(text, baseIri) {
 }
 
 function __derefSemanticsSync(iriNoFrag) {
-  if (__logSemanticsCache.has(iriNoFrag)) return __logSemanticsCache.get(iriNoFrag);
+  const norm = __normalizeDerefIri(iriNoFrag);
+  const key = typeof norm === 'string' && norm ? norm : iriNoFrag;
+  if (__logSemanticsCache.has(key)) return __logSemanticsCache.get(key);
 
   const text = __derefTextSync(iriNoFrag);
   if (typeof text !== 'string') {
-    __logSemanticsCache.set(iriNoFrag, null);
+    __logSemanticsCache.set(key, null);
     return null;
   }
   try {
-    const formula = __parseSemanticsToFormula(text, iriNoFrag);
-    __logSemanticsCache.set(iriNoFrag, formula);
+    const baseIri = (typeof key === 'string' && key) ? key : iriNoFrag;
+      const formula = __parseSemanticsToFormula(text, baseIri);
+    __logSemanticsCache.set(key, formula);
     return formula;
   } catch {
-    __logSemanticsCache.set(iriNoFrag, null);
+    __logSemanticsCache.set(key, null);
     return null;
   }
 }
+function __makeRuleFromTerms(left, right, isForward) {
+  // Mirror Parser.makeRule, but usable at runtime (e.g., log:conclusion).
+  let premiseTerm, conclTerm;
+
+  if (isForward) {
+    premiseTerm = left;
+    conclTerm = right;
+  } else {
+    premiseTerm = right;
+    conclTerm = left;
+  }
+
+  let isFuse = false;
+  if (isForward) {
+    if (conclTerm instanceof Literal && conclTerm.value === 'false') {
+      isFuse = true;
+    }
+  }
+
+  let rawPremise;
+  if (premiseTerm instanceof GraphTerm) {
+    rawPremise = premiseTerm.triples;
+  } else if (premiseTerm instanceof Literal && premiseTerm.value === 'true') {
+    rawPremise = [];
+  } else {
+    rawPremise = [];
+  }
+
+  let rawConclusion;
+  if (conclTerm instanceof GraphTerm) {
+    rawConclusion = conclTerm.triples;
+  } else if (conclTerm instanceof Literal && conclTerm.value === 'false') {
+    rawConclusion = [];
+  } else {
+    rawConclusion = [];
+  }
+
+  const headBlankLabels = collectBlankLabelsInTriples(rawConclusion);
+  const [premise0, conclusion] = liftBlankRuleVars(rawPremise, rawConclusion);
+  const premise = isForward ? reorderPremiseForConstraints(premise0) : premise0;
+  return new Rule(premise, conclusion, isForward, isFuse, headBlankLabels);
+}
+
+function __computeConclusionFromFormula(formula) {
+  if (!(formula instanceof GraphTerm)) return null;
+
+  const cached = __logConclusionCache.get(formula);
+  if (cached) return cached;
+
+  // Facts start as *all* triples in the formula, including rule triples.
+  const facts2 = formula.triples.slice();
+
+  // Extract rules from rule-triples present inside the formula.
+  const fw = [];
+  const bw = [];
+
+  for (const tr of formula.triples) {
+    // Treat {A} => {B} as a forward rule.
+    if (isLogImplies(tr.p)) {
+      fw.push(__makeRuleFromTerms(tr.s, tr.o, true));
+      continue;
+    }
+
+    // Treat {A} <= {B} as the same rule in the other direction, i.e., {B} => {A},
+    // so it participates in deductive closure even if only <= is used.
+    if (isLogImpliedBy(tr.p)) {
+      fw.push(__makeRuleFromTerms(tr.o, tr.s, true));
+      // Also index it as a backward rule for completeness (helps proveGoals in some cases).
+      bw.push(__makeRuleFromTerms(tr.s, tr.o, false));
+      continue;
+    }
+  }
+
+  // Saturate within this local formula only.
+  forwardChain(facts2, fw, bw);
+
+  const out = new GraphTerm(facts2.slice());
+  __logConclusionCache.set(formula, out);
+  return out;
+}
+
 
 
 // Controls whether human-readable proof comments are printed.
@@ -4850,6 +5003,31 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return s2 !== null ? [s2] : [];
   }
 
+
+// log:conclusion
+// Schema: $s+ log:conclusion $o?
+// $o is the deductive closure of the subject formula $s (including rule inferences).
+if (pv === LOG_NS + 'conclusion') {
+  // Accept 'true' as the empty formula.
+  let inFormula = null;
+  if (g.s instanceof GraphTerm) inFormula = g.s;
+  else if (g.s instanceof Literal && g.s.value === 'true') inFormula = new GraphTerm([]);
+  else return [];
+
+  const conclusion = __computeConclusionFromFormula(inFormula);
+  if (!(conclusion instanceof GraphTerm)) return [];
+
+  if (g.o instanceof Var) {
+    const s2 = { ...subst };
+    s2[g.o.name] = conclusion;
+    return [s2];
+  }
+  if (g.o instanceof Blank) return [{ ...subst }];
+
+  const s2 = unifyTerm(g.o, conclusion, subst);
+  return s2 !== null ? [s2] : [];
+}
+
   // log:content
   // Schema: $s+ log:content $o?
   // Dereferences $s and returns the online resource as an xsd:string.
@@ -5998,10 +6176,17 @@ function termToN3(t, pref) {
     return '(' + inside.join(' ') + ')';
   }
   if (t instanceof GraphTerm) {
+    const indent = '    ';
+    const indentBlock = (str) =>
+      str
+        .split(/\r?\n/)
+        .map((ln) => (ln.length ? indent + ln : ln))
+        .join('\n');
+
     let s = '{\n';
     for (const tr of t.triples) {
-      let line = tripleToN3(tr, pref).trimEnd();
-      if (line) s += '    ' + line + '\n';
+      const block = tripleToN3(tr, pref).trimEnd();
+      if (block) s += indentBlock(block) + '\n';
     }
     s += '}';
     return s;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.7.5",
+  "version": "1.7.7",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [