eyeling 1.16.1 → 1.16.3

package/lib/explain.js

@@ -118,7 +118,7 @@ function makeExplain(deps) {
   // log:outputString support
   // ===========================================================================
 
-  function __compareOutputStringKeys(a, b, _prefixes) {
+  function compareOutputStringKeys(a, b) {
     // Deterministic ordering of keys. The spec only requires "order of the subject keys"
     // and leaves concrete term ordering reasoner-dependent. We implement:
     //   1) numeric literals (numeric value)
@@ -196,7 +196,7 @@ function makeExplain(deps) {
     }
 
     pairs.sort((a, b) => {
-      const c = __compareOutputStringKeys(a.key, b.key, prefixes);
+      const c = compareOutputStringKeys(a.key, b.key, prefixes);
       if (c !== 0) return c;
       return a.idx - b.idx; // stable tie-breaker
     });

package/lib/prelude.js

@@ -426,7 +426,7 @@ function collectIrisInTerm(t) {
   if (t instanceof Iri) {
     out.push(t.value);
   } else if (t instanceof Literal) {
-    const [_lex, dt] = literalParts(t.value);
+    const [, dt] = literalParts(t.value);
     if (dt) out.push(dt); // so rdf/xsd prefixes are emitted when only used in ^^...
   } else if (t instanceof ListTerm) {
     for (const x of t.elems) out.push(...collectIrisInTerm(x));

package/package.json

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

package/test/api.test.js

@@ -1305,15 +1305,15 @@ ex:a p:trig ex:b.
       });
 
       // stash for check()
-      this._seen = seen;
-      this._result = r;
+      this.seen = seen;
+      this.result = r;
       return r.closureN3;
     },
     expect: [/http:\/\/example\.org\/q/m],
     notExpect: [/http:\/\/example\.org\/p/m],
     check(out, tc) {
-      assert.equal(tc._seen.length, 1, 'Expected onDerived to be called once');
-      assert.match(tc._seen[0], /http:\/\/example\.org\/q/, 'Expected streamed triple to be the derived one');
+      assert.equal(tc.seen.length, 1, 'Expected onDerived to be called once');
+      assert.match(tc.seen[0], /http:\/\/example\.org\/q/, 'Expected streamed triple to be the derived one');
       // closureN3 should be exactly the derived triple (no input facts).
       assert.ok(String(out).trim().includes('http://example.org/q'));
       assert.ok(!String(out).includes('http://example.org/p'));
@@ -1584,19 +1584,19 @@ _:x :hates { _:foo :making :mess }.
           onDerived: ({ quad }) => seen.push(quad),
         },
       );
-      this._seen = seen;
-      this._result = result;
+      this.seen = seen;
+      this.result = result;
       return result.closureN3;
     },
     expect: [/http:\/\/example\.org\/q/m],
     notExpect: [/http:\/\/example\.org\/p/m],
-    check(_out, tc) {
-      assert.equal(tc._seen.length, 1, 'Expected one streamed RDF/JS quad');
-      assert.equal(tc._seen[0].termType, 'Quad');
-      assert.equal(tc._seen[0].predicate.value, 'http://example.org/q');
-      assert.ok(Array.isArray(tc._result.closureQuads), 'Expected closureQuads array');
-      assert.equal(tc._result.closureQuads.length, 1);
-      assert.equal(tc._result.closureQuads[0].object.value, 'http://example.org/o');
+    check(outputIgnored, tc) {
+      assert.equal(tc.seen.length, 1, 'Expected one streamed RDF/JS quad');
+      assert.equal(tc.seen[0].termType, 'Quad');
+      assert.equal(tc.seen[0].predicate.value, 'http://example.org/q');
+      assert.ok(Array.isArray(tc.result.closureQuads), 'Expected closureQuads array');
+      assert.equal(tc.result.closureQuads.length, 1);
+      assert.equal(tc.result.closureQuads[0].object.value, 'http://example.org/o');
     },
   },
   {
@@ -1633,14 +1633,14 @@ _:x :hates { _:foo :making :mess }.
       })) {
         quads.push(quad);
       }
-      this._quads = quads;
+      this.quads = quads;
       return quads.map((q) => `${q.subject.value} ${q.predicate.value} ${q.object.value}`).join('\n');
     },
     expect: [/http:\/\/example\.org\/q/],
-    check(_out, tc) {
-      assert.equal(tc._quads.length, 1, 'Expected one yielded quad');
-      assert.equal(tc._quads[0].predicate.value, 'http://example.org/q');
-      assert.equal(tc._quads[0].graph.termType, 'DefaultGraph');
+    check(outputIgnored, tc) {
+      assert.equal(tc.quads.length, 1, 'Expected one yielded quad');
+      assert.equal(tc.quads[0].predicate.value, 'http://example.org/q');
+      assert.equal(tc.quads[0].graph.termType, 'DefaultGraph');
     },
   },
   {

package/test/playground.test.js

@@ -74,7 +74,7 @@ function startStaticServer(rootDir) {
 
       res.writeHead(200, { 'Content-Type': guessContentType(fsPath), 'Cache-Control': 'no-store' });
       fs.createReadStream(fsPath).pipe(res);
-    } catch (_e) {
+    } catch {
       res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
       res.end('Not found');
     }

package/tools/bundle.js

@@ -140,8 +140,10 @@ out.push('  }');
 out.push('  const __entry = __loadEntry();');
 out.push('  const __api = { reasonStream: __entry.reasonStream, reasonRdfJs: __entry.reasonRdfJs };');
 out.push('');
-out.push('  try { if (__outerModule && __outerModule.exports) __outerModule.exports = __api; } catch (_e) {}');
-out.push('  try { if (__outerSelf) __outerSelf.eyeling = __api; } catch (_e) {}');
+out.push(
+  '  try { if (__outerModule && __outerModule.exports) __outerModule.exports = __api; } catch (ignoredError) {}',
+);
+out.push('  try { if (__outerSelf) __outerSelf.eyeling = __api; } catch (ignoredError) {}');
 out.push('');
 out.push('  // ---- demo.html compatibility ----');
 out.push('  // The original monolithic eyeling.js exposed internal functions/flags as globals.');
@@ -175,14 +177,14 @@ out.push('          } else {');
 out.push('            // Fallback (no live linkage)');
 out.push('            if (typeof getFn === "function") __outerSelf[name] = getFn();');
 out.push('          }');
-out.push('        } catch (_e) {}');
+out.push('        } catch (ignoredError) {}');
 out.push('      };');
 out.push('');
 out.push('      def("enforceHttpsEnabled", __entry.getEnforceHttpsEnabled, __entry.setEnforceHttpsEnabled);');
 out.push('      def("proofCommentsEnabled", __entry.getProofCommentsEnabled, __entry.setProofCommentsEnabled);');
 out.push('      def("__tracePrefixes", __entry.getTracePrefixes, __entry.setTracePrefixes);');
 out.push('    }');
-out.push('  } catch (_e) {}');
+out.push('  } catch (ignoredError) {}');
 out.push('');
 out.push('  try {');
 out.push(
@@ -190,7 +192,7 @@ out.push(
 );
 out.push('      __entry.main();');
 out.push('    }');
-out.push('  } catch (_e) {}');
+out.push('  } catch (ignoredError) {}');
 out.push('})();');
 
 fs.writeFileSync(OUT, out.join('\n') + '\n', { encoding: 'utf8' });

package/tools/n3gen.js

@@ -32,7 +32,7 @@ const process = require('node:process');
 
 const crypto = require('node:crypto');
 
-function _stripIriRef(s) {
+function stripIriRef(s) {
   // Allow passing an IRIREF like <...>
   if (typeof s !== 'string') return '';
   s = s.trim();
@@ -41,7 +41,7 @@ function _stripIriRef(s) {
 }
 
 function normalizeSkolemRoot(root) {
-  root = _stripIriRef(root);
+  root = stripIriRef(root);
   if (!root) return '';
   // Ensure it ends with '/.well-known/genid/' OR at least with '/'
   if (!root.endsWith('/')) root += '/';
@@ -64,7 +64,7 @@ const SKOLEM_ROOT = normalizeSkolemRoot(process.env.SKOLEM_ROOT) || DEFAULT_SKOL
 let SKOLEM_UUID = null; // e.g., '3f2504e0-4f89-5d3a-9a0c-0305e82c3301'
 let SKOLEM_PREFIX_IRI = null; // e.g., 'https://.../.well-known/genid/<UUID>#'
 
-function _deterministicUuidFromText(inputText) {
+function deterministicUuidFromText(inputText) {
   const h = crypto.createHash('sha256').update(inputText, 'utf8').digest();
   const b = Buffer.from(h.subarray(0, 16));
 
@@ -77,11 +77,11 @@ function _deterministicUuidFromText(inputText) {
 }
 
 function initSkolemForInput(inputText) {
-  SKOLEM_UUID = _deterministicUuidFromText(inputText);
+  SKOLEM_UUID = deterministicUuidFromText(inputText);
   SKOLEM_PREFIX_IRI = `${SKOLEM_ROOT}${SKOLEM_UUID}#`;
 }
 
-function _pnLocalSafe(s) {
+function pnLocalSafe(s) {
   // Turtle PN_LOCAL allows percent escapes (PLX). We make sure all "special"
   // encodeURIComponent survivors are percent-escaped too.
   return encodeURIComponent(s).replace(/[!'()*]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase());
@@ -786,7 +786,7 @@ class TurtleParser {
     this.blankCounter = 0;
     this.pendingTriples = [];
     this.reifierCounter = 0;
-    this._reifiesEmitted = new Set();
+    this.reifiesEmitted = new Set();
   }
 
   peek() {
@@ -811,16 +811,16 @@ class TurtleParser {
     return new Blank(`_:n3r${this.reifierCounter}`);
   }
 
-  _termKey(t) {
+  termKey(t) {
     if (t == null) return '[]';
     if (t instanceof Iri) return `I:${t.value}`;
     if (t instanceof Blank) return `B:${t.label}`;
     if (t instanceof Literal) return `L:${t.value}`;
     if (t instanceof Var) return `V:${t.name}`;
-    if (t instanceof ListTerm) return `T:(` + t.elems.map((x) => this._termKey(x)).join(' ') + `)`;
+    if (t instanceof ListTerm) return `T:(` + t.elems.map((x) => this.termKey(x)).join(' ') + `)`;
     if (t instanceof GraphTerm) {
       const inner = t.triples
-        .map((tr) => `${this._termKey(tr.s)} ${this._termKey(tr.p)} ${this._termKey(tr.o)}`)
+        .map((tr) => `${this.termKey(tr.s)} ${this.termKey(tr.p)} ${this.termKey(tr.o)}`)
         .join(' | ');
       return `G:{${inner}}`;
     }
@@ -831,9 +831,9 @@ class TurtleParser {
   //   reifier log:nameOf tripleTerm .
   // We represent tripleTerm in N3 as a quoted graph term: { s p o . }
   emitReifies(reifier, tripleGraph) {
-    const key = `${this._termKey(reifier)}|${this._termKey(tripleGraph)}`;
-    if (this._reifiesEmitted.has(key)) return;
-    this._reifiesEmitted.add(key);
+    const key = `${this.termKey(reifier)}|${this.termKey(tripleGraph)}`;
+    if (this.reifiesEmitted.has(key)) return;
+    this.reifiesEmitted.add(key);
     this.pendingTriples.push(new Triple(reifier, internIri(LOG_NS + 'nameOf'), tripleGraph));
   }
 
@@ -1519,7 +1519,7 @@ function buildSkolemMapForBnodesThatCrossScopes(triples) {
     if (scopes.size <= 1) continue;
 
     const id = lbl.startsWith('_:') ? lbl.slice(2) : lbl;
-    const local = _pnLocalSafe(id);
+    const local = pnLocalSafe(id);
     skolemMap.set(lbl, `${SKOLEM_PREFIX}:${local}`);
   }
   return skolemMap;
@@ -1538,16 +1538,16 @@ function buildSkolemMapForBnodesThatCrossScopes(triples) {
 // semantics-preserving.
 // ---------------------------------------------------------------------------
 
-function _termKey(t) {
+function termKey(t) {
   if (t == null) return 'N:null';
   if (t instanceof Iri) return `I:${t.value}`;
   if (t instanceof Blank) return `B:${t.label}`;
   if (t instanceof Literal) return `L:${t.value}`;
   if (t instanceof Var) return `V:${t.name}`;
-  if (t instanceof ListTerm) return `T:(` + t.elems.map(_termKey).join(' ') + `)`;
-  if (t instanceof OpenListTerm) return `T:(` + t.prefix.map(_termKey).join(' ') + ` ... ?${t.tailVar})`;
+  if (t instanceof ListTerm) return `T:(` + t.elems.map(termKey).join(' ') + `)`;
+  if (t instanceof OpenListTerm) return `T:(` + t.prefix.map(termKey).join(' ') + ` ... ?${t.tailVar})`;
   if (t instanceof GraphTerm)
-    return `G:{` + t.triples.map((tr) => `${_termKey(tr.s)} ${_termKey(tr.p)} ${_termKey(tr.o)}`).join(' ; ') + `}`;
+    return `G:{` + t.triples.map((tr) => `${termKey(tr.s)} ${termKey(tr.p)} ${termKey(tr.o)}`).join(' ; ') + `}`;
   return `X:${String(t)}`;
 }
 
@@ -1567,11 +1567,11 @@ function foldRdfLists(triples) {
 
   for (let i = 0; i < triples.length; i++) {
     const tr = triples[i];
-    const sKey = _termKey(tr.s);
+    const sKey = termKey(tr.s);
     if (!outBySubj.has(sKey)) outBySubj.set(sKey, { term: tr.s, idxs: [] });
     outBySubj.get(sKey).idxs.push(i);
 
-    const oKey = _termKey(tr.o);
+    const oKey = termKey(tr.o);
     const viaRest = isIri(tr.p, rdfRest);
     addIncoming(oKey, viaRest);
   }
@@ -1655,7 +1655,7 @@ function foldRdfLists(triples) {
         break;
       }
 
-      const nextKey = _termKey(next);
+      const nextKey = termKey(next);
 
       // Intermediate node safety: only referenced via rdf:rest and exactly once.
       const inc = incoming.get(nextKey) || 0;
@@ -1694,7 +1694,7 @@ function foldRdfLists(triples) {
     if (t == null) return t;
 
     if (t instanceof Blank) {
-      const m = listMap.get(_termKey(t));
+      const m = listMap.get(termKey(t));
       if (m) return replaceTerm(m.listTerm);
       return t;
     }
@@ -1813,7 +1813,7 @@ function ensureSkolemPrefix(prefixes, skolemMap) {
     const base = prefixes ? prefixes.baseIri || '' : '';
     const labels = [...skolemMap.keys()].sort().join('\n');
     const seed = ['n3gen-skolem', SKOLEM_ROOT, base, labels, ''].join('\n');
-    const uuid = _deterministicUuidFromText(seed);
+    const uuid = deterministicUuidFromText(seed);
     SKOLEM_PREFIX_IRI = `${SKOLEM_ROOT}${uuid}#`;
   } else if (!SKOLEM_PREFIX_IRI) {
     SKOLEM_PREFIX_IRI = `${SKOLEM_ROOT}${SKOLEM_UUID}#`;