eyeling 1.15.13 → 1.16.0

package/index.d.ts

@@ -1,3 +1,186 @@
 declare module 'eyeling' {
-  export function reason(opts: any, input: string): string;
+  export interface RdfJsTerm {
+    termType: string;
+    value: string;
+    equals(other: RdfJsTerm | null | undefined): boolean;
+  }
+
+  export interface RdfJsNamedNode extends RdfJsTerm {
+    termType: 'NamedNode';
+  }
+
+  export interface RdfJsBlankNode extends RdfJsTerm {
+    termType: 'BlankNode';
+  }
+
+  export interface RdfJsVariable extends RdfJsTerm {
+    termType: 'Variable';
+  }
+
+  export interface RdfJsDefaultGraph extends RdfJsTerm {
+    termType: 'DefaultGraph';
+    value: '';
+  }
+
+  export interface RdfJsLiteral extends RdfJsTerm {
+    termType: 'Literal';
+    language: string;
+    datatype: RdfJsNamedNode;
+  }
+
+  export interface RdfJsQuad extends RdfJsTerm {
+    termType: 'Quad';
+    value: '';
+    subject: RdfJsTerm;
+    predicate: RdfJsTerm;
+    object: RdfJsTerm;
+    graph: RdfJsTerm;
+  }
+
+  export interface RdfJsDataFactory {
+    namedNode(value: string): RdfJsNamedNode;
+    blankNode(value?: string): RdfJsBlankNode;
+    literal(value: string, languageOrDatatype?: string | RdfJsNamedNode): RdfJsLiteral;
+    variable(value: string): RdfJsVariable;
+    defaultGraph(): RdfJsDefaultGraph;
+    quad(subject: RdfJsTerm, predicate: RdfJsTerm, object: RdfJsTerm, graph?: RdfJsTerm): RdfJsQuad;
+  }
+
+  export interface EyelingPrefixEnv {
+    _type?: 'PrefixEnv';
+    map: Record<string, string>;
+    baseIri?: string;
+  }
+
+  export interface EyelingIri {
+    _type?: 'Iri';
+    value: string;
+  }
+
+  export interface EyelingLiteral {
+    _type?: 'Literal';
+    value: string;
+  }
+
+  export interface EyelingVar {
+    _type?: 'Var';
+    name: string;
+  }
+
+  export interface EyelingBlank {
+    _type?: 'Blank';
+    label: string;
+  }
+
+  export interface EyelingListTerm {
+    _type?: 'ListTerm';
+    elems: EyelingTerm[];
+  }
+
+  export interface EyelingOpenListTerm {
+    _type?: 'OpenListTerm';
+    prefix: EyelingTerm[];
+    tailVar: string;
+  }
+
+  export interface EyelingGraphTerm {
+    _type?: 'GraphTerm';
+    triples: EyelingTriple[];
+  }
+
+  export type EyelingTerm =
+    | EyelingIri
+    | EyelingLiteral
+    | EyelingVar
+    | EyelingBlank
+    | EyelingListTerm
+    | EyelingOpenListTerm
+    | EyelingGraphTerm
+    | RdfJsNamedNode
+    | RdfJsBlankNode
+    | RdfJsVariable
+    | RdfJsLiteral;
+
+  export interface EyelingTriple {
+    _type?: 'Triple';
+    s: EyelingTerm;
+    p: EyelingTerm;
+    o: EyelingTerm;
+  }
+
+  export interface EyelingRule {
+    _type?: 'Rule';
+    premise: EyelingTriple[];
+    conclusion: EyelingTriple[];
+    isForward?: boolean;
+    isFuse?: boolean;
+    headBlankLabels?: Iterable<string> | string[];
+    __dynamicConclusionTerm?: EyelingTerm;
+  }
+
+  export type EyelingAstBundle = [EyelingPrefixEnv, EyelingTriple[], EyelingRule[], EyelingRule[], EyelingRule[]?];
+
+  export interface RdfJsReasonInput {
+    n3?: string;
+    quads?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
+    facts?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
+    dataset?: Iterable<RdfJsQuad> | AsyncIterable<RdfJsQuad>;
+    rules?: EyelingRule[] | EyelingAstBundle;
+    factsN3?: string;
+    n3Facts?: string;
+    prefixesN3?: string;
+    n3Prefixes?: string;
+    prefixes?: EyelingPrefixEnv;
+    triples?: EyelingTriple[];
+    forwardRules?: EyelingRule[];
+    frules?: EyelingRule[];
+    backwardRules?: EyelingRule[];
+    brules?: EyelingRule[];
+    queryRules?: EyelingRule[];
+    logQueryRules?: EyelingRule[];
+    qrules?: EyelingRule[];
+    ast?: EyelingAstBundle;
+    document?: EyelingAstBundle;
+  }
+
+  export interface ReasonOptions {
+    proofComments?: boolean;
+    noProofComments?: boolean;
+    args?: string[];
+    maxBuffer?: number;
+  }
+
+  export interface ReasonStreamOptions {
+    baseIri?: string | null;
+    proof?: boolean;
+    includeInputFactsInClosure?: boolean;
+    enforceHttps?: boolean;
+    rdfjs?: boolean;
+    dataFactory?: RdfJsDataFactory | null;
+    onDerived?: (item: { triple: string; quad?: RdfJsQuad; df: any }) => void;
+  }
+
+  export interface ReasonStreamResult {
+    prefixes: any;
+    facts: any[];
+    derived: any[];
+    queryMode: boolean;
+    queryTriples: any[];
+    queryDerived: any[];
+    closureN3: string;
+    closureQuads?: RdfJsQuad[];
+    queryQuads?: RdfJsQuad[];
+  }
+
+  export function reason(opts: ReasonOptions, input: string | RdfJsReasonInput | EyelingAstBundle): string;
+  export function reasonStream(
+    input: string | RdfJsReasonInput | EyelingAstBundle,
+    opts?: ReasonStreamOptions,
+  ): ReasonStreamResult;
+  export function reasonRdfJs(
+    input: string | RdfJsReasonInput | EyelingAstBundle,
+    opts?: Omit<ReasonStreamOptions, 'rdfjs' | 'onDerived'>,
+  ): AsyncIterable<RdfJsQuad>;
+
+  export const rdfjs: RdfJsDataFactory;
 }

package/index.js

@@ -5,16 +5,21 @@ const os = require('node:os');
 const path = require('node:path');
 const cp = require('node:child_process');
 
-function reason(opt = {}, n3_input = '') {
-  if (n3_input == null) n3_input = '';
-  if (typeof n3_input !== 'string') {
-    throw new TypeError('reason(opt, n3_input): n3_input must be a string');
-  }
+const bundleApi = require('./eyeling.js');
+const { dataFactory, normalizeReasonerInputSync } = require('./lib/rdfjs');
+
+function reason(opt = {}, input = '') {
+  if (input == null) input = '';
 
   // allow passing an args array directly
   if (Array.isArray(opt)) opt = { args: opt };
   if (opt == null || typeof opt !== 'object') opt = {};
 
+  const n3Input = normalizeReasonerInputSync(input);
+  if (typeof n3Input !== 'string') {
+    throw new TypeError('reason(opt, input): input must resolve to an N3 string');
+  }
+
   const args = [];
 
   // default: proof comments OFF for API output (machine-friendly)
@@ -43,7 +48,7 @@ function reason(opt = {}, n3_input = '') {
   const inputFile = path.join(dir, 'input.n3');
 
   try {
-    fs.writeFileSync(inputFile, n3_input, 'utf8');
+    fs.writeFileSync(inputFile, n3Input, 'utf8');
 
     const eyelingPath = path.join(__dirname, 'eyeling.js');
     const res = cp.spawnSync(process.execPath, [eyelingPath, ...args, inputFile], { encoding: 'utf8', maxBuffer });
@@ -67,7 +72,12 @@ function reason(opt = {}, n3_input = '') {
   }
 }
 
-module.exports = { reason };
+module.exports = {
+  reason,
+  reasonStream: bundleApi.reasonStream,
+  reasonRdfJs: bundleApi.reasonRdfJs,
+  rdfjs: dataFactory,
+};
 
 // small interop nicety for ESM default import
 module.exports.default = module.exports;

package/lib/engine.js

@@ -53,6 +53,13 @@ const {
 const { makeExplain } = require('./explain');
 
 const { tripleToN3, prettyPrintQueryTriples } = require('./printing');
+const {
+  getDataFactory,
+  internalTripleToRdfJsQuad,
+  normalizeParsedReasonerInputSync,
+  normalizeReasonerInputSync,
+  normalizeReasonerInputAsync,
+} = require('./rdfjs');
 
 const trace = require('./trace');
 const { deterministicSkolemIdFromKey } = require('./skolem');
@@ -2867,24 +2874,41 @@ function forwardChainAndCollectLogQueryConclusions(facts, forwardRules, backRule
 
 // (proof printing + log:outputString moved to lib/explain.js)
 
-function reasonStream(n3Text, opts = {}) {
+function reasonStream(input, opts = {}) {
   const {
     baseIri = null,
     proof = false,
     onDerived = null,
     includeInputFactsInClosure = true,
     enforceHttps = false,
+    rdfjs = false,
+    dataFactory = null,
   } = opts;
 
+  const parsedInput = normalizeParsedReasonerInputSync(input);
+  const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
+
   const __oldEnforceHttps = deref.getEnforceHttpsEnabled();
   deref.setEnforceHttpsEnabled(!!enforceHttps);
   proofCommentsEnabled = !!proof;
 
-  const toks = lex(n3Text);
-  const parser = new Parser(toks);
-  if (baseIri) parser.prefixes.setBase(baseIri);
+  let prefixes, triples, frules, brules, logQueryRules;
+
+  if (parsedInput) {
+    prefixes = parsedInput.prefixes;
+    triples = parsedInput.triples;
+    frules = parsedInput.frules;
+    brules = parsedInput.brules;
+    logQueryRules = parsedInput.logQueryRules;
+    if (baseIri) prefixes.setBase(baseIri);
+  } else {
+    const n3Text = normalizeReasonerInputSync(input);
+    const toks = lex(n3Text);
+    const parser = new Parser(toks);
+    if (baseIri) parser.prefixes.setBase(baseIri);
 
-  const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
+    [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
+  }
   // Make the parsed prefixes available to log:trace output
   trace.setTracePrefixes(prefixes);
 
@@ -2913,17 +2937,21 @@ function reasonStream(n3Text, opts = {}) {
     // query-selected triples (not all derived facts).
     if (typeof onDerived === 'function') {
       for (const qdf of queryDerived) {
-        onDerived({ triple: tripleToN3(qdf.fact, prefixes), df: qdf });
+        const payload = { triple: tripleToN3(qdf.fact, prefixes), df: qdf };
+        if (rdfFactory) payload.quad = internalTripleToRdfJsQuad(qdf.fact, rdfFactory);
+        onDerived(payload);
       }
     }
   } else {
     // Default mode: output only newly derived forward facts.
     derived = forwardChain(facts, frules, brules, (df) => {
       if (typeof onDerived === 'function') {
-        onDerived({
+        const payload = {
           triple: tripleToN3(df.fact, prefixes),
           df,
-        });
+        };
+        if (rdfFactory) payload.quad = internalTripleToRdfJsQuad(df.fact, rdfFactory);
+        onDerived(payload);
       }
     });
   }
@@ -2949,10 +2977,65 @@ function reasonStream(n3Text, opts = {}) {
     queryDerived,
     closureN3,
   };
+
+  if (rdfFactory) {
+    __out.closureQuads = closureTriples.map((t) => internalTripleToRdfJsQuad(t, rdfFactory));
+    __out.queryQuads = queryTriples.map((t) => internalTripleToRdfJsQuad(t, rdfFactory));
+  }
   deref.setEnforceHttpsEnabled(__oldEnforceHttps);
   return __out;
 }
 
+function reasonRdfJs(input, opts = {}) {
+  const { dataFactory = null, ...restOpts } = opts || {};
+  const rdfFactory = getDataFactory(dataFactory);
+
+  const queue = [];
+  const waiters = [];
+  let done = false;
+  let failure = null;
+
+  const flush = () => {
+    while (waiters.length && (queue.length || done)) {
+      const resolve = waiters.shift();
+      if (queue.length) resolve({ value: queue.shift(), done: false });
+      else if (failure) resolve(Promise.reject(failure));
+      else resolve({ value: undefined, done: true });
+    }
+  };
+
+  Promise.resolve().then(async () => {
+    try {
+      const normalizedInput = await normalizeReasonerInputAsync(input);
+      reasonStream(normalizedInput, {
+        ...restOpts,
+        rdfjs: false,
+        onDerived: ({ df }) => {
+          queue.push(internalTripleToRdfJsQuad(df.fact, rdfFactory));
+          flush();
+        },
+      });
+    } catch (e) {
+      failure = e;
+    } finally {
+      done = true;
+      flush();
+    }
+  });
+
+  return {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      if (queue.length) return Promise.resolve({ value: queue.shift(), done: false });
+      if (failure) return Promise.reject(failure);
+      if (done) return Promise.resolve({ value: undefined, done: true });
+      return new Promise((resolve) => waiters.push(resolve));
+    },
+  };
+}
+
 // Minimal export surface for Node + browser/worker
 function main() {
   // Lazily require to avoid hard cycles in the module graph.
@@ -2999,6 +3082,7 @@ function setTracePrefixes(v) {
 
 module.exports = {
   reasonStream,
+  reasonRdfJs,
   collectLogQueryConclusions,
   forwardChainAndCollectLogQueryConclusions,
   collectOutputStringsFromFacts,

package/lib/entry.js

@@ -12,10 +12,13 @@
 // can call into the reasoner like the original monolithic build did.
 
 const engine = require('./engine');
+const { dataFactory } = require('./rdfjs');
 
 module.exports = {
   // public
   reasonStream: engine.reasonStream,
+  reasonRdfJs: engine.reasonRdfJs,
+  rdfjs: dataFactory,
   main: engine.main,
   version: engine.version,