eyeling 1.19.5 → 1.20.0

package/eyeling.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 'use strict';
 
 (function(){
@@ -8972,6 +8971,8 @@ module.exports = {
   isGroundTriple: engine.isGroundTriple,
   printExplanation: engine.printExplanation,
   tripleToN3: engine.tripleToN3,
+  collectOutputStringsFromFacts: engine.collectOutputStringsFromFacts,
+  prettyPrintQueryTriples: engine.prettyPrintQueryTriples,
   getEnforceHttpsEnabled: engine.getEnforceHttpsEnabled,
   setEnforceHttpsEnabled: engine.setEnforceHttpsEnabled,
   getProofCommentsEnabled: engine.getProofCommentsEnabled,
@@ -12752,7 +12753,7 @@ module.exports = {
     return m.exports;
   }
   const __entry = __loadEntry();
-  const __api = { reasonStream: __entry.reasonStream, reasonRdfJs: __entry.reasonRdfJs };
+  const __api = __entry;
 
   try { if (__outerModule && __outerModule.exports) __outerModule.exports = __api; } catch (ignoredError) {}
   try { if (__outerSelf) __outerSelf.eyeling = __api; } catch (ignoredError) {}
@@ -12769,8 +12770,9 @@ module.exports = {
       if (typeof __entry.isGroundTriple === "function") __outerSelf.isGroundTriple = __entry.isGroundTriple;
       if (typeof __entry.printExplanation === "function") __outerSelf.printExplanation = __entry.printExplanation;
       if (typeof __entry.tripleToN3 === "function") __outerSelf.tripleToN3 = __entry.tripleToN3;
+      if (typeof __entry.collectOutputStringsFromFacts === "function") __outerSelf.collectOutputStringsFromFacts = __entry.collectOutputStringsFromFacts;
+      if (typeof __entry.prettyPrintQueryTriples === "function") __outerSelf.prettyPrintQueryTriples = __entry.prettyPrintQueryTriples;
 
-      // Expose flags as mutable globals (with live linkage to engine module state).
       const def = (name, getFn, setFn) => {
         try {
           if (typeof Object.defineProperty === "function") {
@@ -12780,7 +12782,6 @@ module.exports = {
               set: (typeof setFn === "function") ? setFn : undefined,
             });
           } else {
-            // Fallback (no live linkage)
             if (typeof getFn === "function") __outerSelf[name] = getFn();
           }
         } catch (ignoredError) {}

package/index.d.ts

@@ -205,3 +205,41 @@ declare module 'eyeling' {
   export function loadBuiltinModule(specifier: string, options?: { resolveFrom?: string }): string;
   export function listBuiltinIris(): string[];
 }
+
+declare module 'eyeling/browser' {
+  export type RdfJsDataFactory = import('eyeling').RdfJsDataFactory;
+  export type RdfJsQuad = import('eyeling').RdfJsQuad;
+  export type RdfJsReasonInput = import('eyeling').RdfJsReasonInput;
+  export type EyelingAstBundle = import('eyeling').EyelingAstBundle;
+  export type ReasonStreamOptions = import('eyeling').ReasonStreamOptions;
+  export type ReasonStreamResult = import('eyeling').ReasonStreamResult;
+  export type BuiltinHandler = import('eyeling').BuiltinHandler;
+
+  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;
+  export function registerBuiltin(iri: string, handler: BuiltinHandler): BuiltinHandler;
+  export function unregisterBuiltin(iri: string): boolean;
+  export function registerBuiltinModule(mod: any, origin?: string): boolean;
+  export function listBuiltinIris(): string[];
+
+  const eyeling: {
+    readonly version: string;
+    reasonStream: typeof reasonStream;
+    reasonRdfJs: typeof reasonRdfJs;
+    rdfjs: typeof rdfjs;
+    registerBuiltin: typeof registerBuiltin;
+    unregisterBuiltin: typeof unregisterBuiltin;
+    registerBuiltinModule: typeof registerBuiltinModule;
+    listBuiltinIris: typeof listBuiltinIris;
+  };
+
+  export default eyeling;
+}

package/lib/entry.js

@@ -32,6 +32,8 @@ module.exports = {
   isGroundTriple: engine.isGroundTriple,
   printExplanation: engine.printExplanation,
   tripleToN3: engine.tripleToN3,
+  collectOutputStringsFromFacts: engine.collectOutputStringsFromFacts,
+  prettyPrintQueryTriples: engine.prettyPrintQueryTriples,
   getEnforceHttpsEnabled: engine.getEnforceHttpsEnabled,
   setEnforceHttpsEnabled: engine.setEnforceHttpsEnabled,
   getProofCommentsEnabled: engine.getProofCommentsEnabled,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.19.5",
+  "version": "1.20.0",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -15,7 +15,7 @@
   },
   "homepage": "https://github.com/eyereasoner/eyeling#readme",
   "bin": {
-    "eyeling": "./eyeling.js"
+    "eyeling": "./bin/eyeling.cjs"
   },
   "types": "./index.d.ts",
   "files": [
@@ -27,6 +27,8 @@
     "eyeling.js",
     "index.js",
     "index.d.ts",
+    "bin",
+    "dist",
     "lib",
     "test",
     "tools",
@@ -43,14 +45,36 @@
     "test:builtin-contract": "node test/builtin-contract.test.js",
     "test:n3gen": "node test/n3gen.test.js",
     "test:examples": "node test/examples.test.js",
+    "test:extra": "node test/extra.test.js",
     "test:manifest": "node test/manifest.test.js",
     "test:playground": "node test/playground.test.js",
     "test:package": "node test/package.test.js",
-    "test:all": "npm run test:api && npm run test:builtin-contract && npm run test:n3gen && npm run test:examples && npm run test:manifest && npm run test:playground",
+    "test:all": "npm run test:api && npm run test:builtin-contract && npm run test:n3gen && npm run test:examples && npm run test:extra && npm run test:manifest && npm run test:playground",
     "pretest": "npm run build && npm run test:packlist",
     "test": "npm run test:all",
     "posttest": "npm run test:package",
     "preversion": "npm test",
     "postversion": "git push origin HEAD --follow-tags"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./dist/browser/index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./browser": {
+      "types": "./index.d.ts",
+      "default": "./dist/browser/index.mjs"
+    },
+    "./eyeling.js": "./eyeling.js",
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "browser": [
+        "index.d.ts"
+      ]
+    }
   }
 }

package/test/extra.test.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const TTY = process.stdout.isTTY;
+const C = TTY
+  ? { g: '\x1b[32m', r: '\x1b[31m', y: '\x1b[33m', dim: '\x1b[2m', n: '\x1b[0m' }
+  : { g: '', r: '', y: '', dim: '', n: '' };
+const msTag = (ms) => `${C.dim}(${ms} ms)${C.n}`;
+
+function ok(msg) {
+  console.log(`${C.g}OK${C.n}  ${msg}`);
+}
+function fail(msg) {
+  console.error(`${C.r}FAIL${C.n} ${msg}`);
+}
+function info(msg) {
+  console.log(`${C.y}==${C.n} ${msg}`);
+}
+
+function main() {
+  const suiteStart = Date.now();
+  const root = path.resolve(__dirname, '..');
+  const extraDir = path.join(root, 'examples', 'extra');
+  const outputDir = path.join(extraDir, 'output');
+  const nodePath = process.execPath;
+
+  if (!fs.existsSync(extraDir)) {
+    fail(`Cannot find examples/extra directory: ${extraDir}`);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const files = fs
+    .readdirSync(extraDir)
+    .filter((f) => f.endsWith('.js'))
+    .sort((a, b) => a.localeCompare(b));
+
+  info(`Running ${files.length} extra examples`);
+  console.log(`${C.dim}node ${process.version}${C.n}`);
+
+  if (files.length === 0) {
+    ok('No .js files found in examples/extra/');
+    process.exit(0);
+  }
+
+  let passed = 0;
+  let failed = 0;
+  const idxWidth = String(files.length).length;
+
+  for (let i = 0; i < files.length; i += 1) {
+    const idx = String(i + 1).padStart(idxWidth, '0');
+    const file = files[i];
+    const start = Date.now();
+
+    const inputPath = path.join(extraDir, file);
+    const outputPath = path.join(outputDir, file.replace(/\.js$/i, '.txt'));
+
+    const r = cp.spawnSync(nodePath, [inputPath], {
+      cwd: extraDir,
+      encoding: 'utf8',
+      maxBuffer: 200 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    const stdout = r.stdout || '';
+    fs.writeFileSync(outputPath, stdout, 'utf8');
+
+    const rc = r.status == null ? 1 : r.status;
+    const ms = Date.now() - start;
+
+    if (rc === 0) {
+      ok(`${idx} ${file} -> output/${path.basename(outputPath)} ${msTag(ms)}`);
+      passed += 1;
+    } else {
+      fail(`${idx} ${file} ${msTag(ms)}`);
+      fail(`Exit code ${rc}`);
+      if (r.stderr) process.stderr.write(r.stderr);
+      failed += 1;
+    }
+  }
+
+  console.log('');
+  const suiteMs = Date.now() - suiteStart;
+  info(`Total elapsed: ${suiteMs} ms (${(suiteMs / 1000).toFixed(2)} s)`);
+
+  if (failed === 0) {
+    ok(`All extra examples passed (${passed}/${files.length})`);
+    process.exit(0);
+  }
+
+  fail(`Some extra examples failed (${passed}/${files.length})`);
+  process.exit(2);
+}
+
+main();

package/test/packlist.test.js

@@ -30,8 +30,12 @@ try {
   assert.ok(fs.existsSync('eyeling.js'), 'eyeling.js missing');
   assert.ok(fs.existsSync('index.js'), 'index.js missing');
 
-  const firstLine = fs.readFileSync('eyeling.js', 'utf8').split(/\r?\n/, 1)[0];
-  assert.match(firstLine, /^#!\/usr\/bin\/env node\b/, 'eyeling.js should start with "#!/usr/bin/env node"');
+  assert.ok(fs.existsSync('bin/eyeling.cjs'), 'bin/eyeling.cjs missing');
+  assert.ok(fs.existsSync('dist/browser/eyeling.browser.js'), 'dist/browser/eyeling.browser.js missing');
+  assert.ok(fs.existsSync('dist/browser/index.mjs'), 'dist/browser/index.mjs missing');
+
+  const binFirstLine = fs.readFileSync('bin/eyeling.cjs', 'utf8').split(/\r?\n/, 1)[0];
+  assert.match(binFirstLine, /^#!\/usr\/bin\/env node\b/, 'bin/eyeling.cjs should start with "#!/usr/bin/env node"');
 
   let packJson;
   try {
@@ -43,7 +47,16 @@ try {
   const pack = JSON.parse(packJson)[0];
   const paths = new Set(pack.files.map((f) => f.path));
 
-  const mustHave = ['package.json', 'README.md', 'LICENSE.md', 'eyeling.js', 'index.js'];
+  const mustHave = [
+    'package.json',
+    'README.md',
+    'LICENSE.md',
+    'eyeling.js',
+    'index.js',
+    'bin/eyeling.cjs',
+    'dist/browser/eyeling.browser.js',
+    'dist/browser/index.mjs',
+  ];
 
   for (const p of mustHave) assert.ok(paths.has(p), `missing from npm pack: ${p}`);