n3.js-messages 0.1.2 → 0.2.0

package/browser.d.ts

@@ -0,0 +1,26 @@
+import type * as RDF from '@rdfjs/types';
+import type { MessageParserOptions, MessageCallback, MessageParseCallbacks, MessageWriterOptions } from './common.js';
+export * from './common.js';
+
+export class MessageParser<Q extends RDF.BaseQuad = RDF.Quad> {
+  constructor(options?: MessageParserOptions<Q>);
+  parse(input: string): Q[][];
+  parse(input: string, callback: MessageCallback<Q>): void;
+  parse(input: string, callbacks: MessageParseCallbacks<Q>): void;
+}
+export function parseMessages<Q extends RDF.BaseQuad = RDF.Quad>(input: string, options?: MessageParserOptions<Q>): Q[][];
+
+export type MessageChunk = string | ArrayBuffer | ArrayBufferView;
+export interface BrowserParserOptions<Q extends RDF.BaseQuad = RDF.Quad> extends MessageParserOptions<Q> {
+  onPrefix?: (prefix: string, term: RDF.NamedNode) => void;
+  onVersion?: (version: string) => void;
+}
+/** Use source.pipeThrough(new MessageStreamParser(options)). */
+export class MessageStreamParser<Q extends RDF.BaseQuad = RDF.Quad> extends TransformStream<MessageChunk, Q[]> {
+  constructor(options?: BrowserParserOptions<Q>);
+}
+export type MessageWriterInput = RDF.BaseQuad[] | { quad: RDF.BaseQuad; messageIndex?: number };
+/** Emits strings; pipe through TextEncoderStream to obtain UTF-8 bytes. */
+export class MessageStreamWriter extends TransformStream<MessageWriterInput, string> {
+  constructor(options?: Omit<MessageWriterOptions, 'end'>);
+}

package/common.d.ts

@@ -0,0 +1,89 @@
+import type * as RDF from '@rdfjs/types';
+
+export type MessageFormat =
+  | 'Turtle' | 'TriG' | 'N-Triples' | 'N-Quads'
+  | (string & {});
+
+/** One RDF message: the quads between two message delimiters. */
+export type Message<Q extends RDF.BaseQuad = RDF.Quad> = Q[];
+
+/**
+ * The part of an RDF/JS DataFactory that is used for parsing; any `RDF.DataFactory<Q>` fits.
+ * The quads that the factory creates determine the quads that are parsed.
+ */
+export interface MessageQuadFactory<Q extends RDF.BaseQuad = RDF.Quad>
+  extends Pick<RDF.DataFactory<RDF.Quad, any>, 'namedNode' | 'blankNode' | 'literal' | 'variable' | 'defaultGraph'> {
+  quad(subject: Q['subject'], predicate: Q['predicate'], object: Q['object'], graph?: Q['graph']): Q;
+}
+
+export interface MessageParserOptions<Q extends RDF.BaseQuad = RDF.Quad> {
+  /** Syntax name or media type, case-insensitive. Defaults to `TriG`. */
+  format?: MessageFormat;
+  baseIRI?: string;
+  /** Data factory used to create terms and quads. */
+  factory?: MessageQuadFactory<Q>;
+  /** Prefix for generated blank node labels, e.g. `b0_`. */
+  blankNodePrefix?: string;
+  /** RDF version label, e.g. `1.2-messages`; a `-messages` suffix forces message mode. */
+  version?: string;
+  /** Force message mode even without a `-messages` version declaration. */
+  messages?: boolean;
+}
+
+export type MessageCallback<Q extends RDF.BaseQuad = RDF.Quad> = (
+  error: Error | null,
+  message: Q[] | null,
+  prefixes?: { [prefix: string]: RDF.NamedNode },
+  index?: number,
+) => void;
+
+export interface MessageParseCallbacks<Q extends RDF.BaseQuad = RDF.Quad> {
+  onMessage?: MessageCallback<Q>;
+  onQuad?: (error: Error | null, quad?: Q, messageIndex?: number) => void;
+  onPrefix?: (prefix: string, term: RDF.NamedNode) => void;
+  onVersion?: (version: string) => void;
+}
+
+export interface MessageWriterOptions {
+  /** Syntax name or media type, case-insensitive. Defaults to `TriG`. */
+  format?: MessageFormat;
+  /** Prefixes that are declared up front. */
+  prefixes?: { [prefix: string]: RDF.NamedNode | string };
+  baseIRI?: string;
+  writeBase?: boolean;
+  lists?: { [listHead: string]: RDF.Term[] };
+  /** RDF version label announced in the output. Defaults to `1.2-messages`. */
+  version?: string;
+  /** Whether to end the output stream on `end()`. Defaults to `true`. */
+  end?: boolean;
+}
+
+export interface MessageOutputStream {
+  write(chunk: string, encoding?: string, callback?: (error?: Error | null) => void): unknown;
+  end(callback?: (error?: Error | null) => void): unknown;
+}
+
+export class MessageWriter {
+  constructor(options?: MessageWriterOptions);
+  constructor(outputStream?: MessageOutputStream | null, options?: MessageWriterOptions);
+  addMessage(quads: RDF.BaseQuad[], done: (error: Error | null) => void): void;
+  addMessage(quads: RDF.BaseQuad[]): Promise<void>;
+  /** Opens a message; optional, as `addQuad` opens one implicitly. */
+  beginMessage(done: (error: Error | null) => void): void;
+  beginMessage(): Promise<void>;
+  /** Writes a quad right away. With a 0-based `messageIndex`, a change of index ends the message and writes empty messages for gaps; a lower index is an error. */
+  addQuad(quad: RDF.BaseQuad, messageIndex: number | undefined, done: (error: Error | null) => void): void;
+  addQuad(quad: RDF.BaseQuad, done: (error: Error | null) => void): void;
+  addQuad(quad: RDF.BaseQuad, messageIndex?: number): Promise<void>;
+  /** Ends the open message (writes an empty message if none is open). */
+  endMessage(done: (error: Error | null) => void): void;
+  endMessage(): Promise<void>;
+  addPrefix(prefix: string, iri: RDF.NamedNode | string, done: (error: Error | null) => void): void;
+  addPrefix(prefix: string, iri: RDF.NamedNode | string): Promise<void>;
+  /** Without an output stream, the result is the written string. */
+  end(done: (error: Error | null, result?: string) => void): void;
+  end(): Promise<string>;
+}
+
+export function writeMessages(messages: Iterable<RDF.BaseQuad[]>, options?: MessageWriterOptions): string;
+

package/index.d.ts

@@ -2,49 +2,8 @@
 import * as RDF from '@rdfjs/types';
 import { Transform } from 'stream';
 
-export type MessageFormat =
-  | 'Turtle' | 'TriG' | 'N-Triples' | 'N-Quads'
-  | (string & {});
-
-/** One RDF message: the quads between two message delimiters. */
-export type Message<Q extends RDF.BaseQuad = RDF.Quad> = Q[];
-
-/**
- * The part of an RDF/JS DataFactory that is used for parsing; any `RDF.DataFactory<Q>` fits.
- * The quads that the factory creates determine the quads that are parsed.
- */
-export interface MessageQuadFactory<Q extends RDF.BaseQuad = RDF.Quad>
-  extends Pick<RDF.DataFactory<RDF.Quad, any>, 'namedNode' | 'blankNode' | 'literal' | 'variable' | 'defaultGraph'> {
-  quad(subject: Q['subject'], predicate: Q['predicate'], object: Q['object'], graph?: Q['graph']): Q;
-}
-
-export interface MessageParserOptions<Q extends RDF.BaseQuad = RDF.Quad> {
-  /** Syntax name or media type, case-insensitive. Defaults to `TriG`. */
-  format?: MessageFormat;
-  baseIRI?: string;
-  /** Data factory used to create terms and quads. */
-  factory?: MessageQuadFactory<Q>;
-  /** Prefix for generated blank node labels, e.g. `b0_`. */
-  blankNodePrefix?: string;
-  /** RDF version label, e.g. `1.2-messages`; a `-messages` suffix forces message mode. */
-  version?: string;
-  /** Force message mode even without a `-messages` version declaration. */
-  messages?: boolean;
-}
-
-export type MessageCallback<Q extends RDF.BaseQuad = RDF.Quad> = (
-  error: Error | null,
-  message: Q[] | null,
-  prefixes?: { [prefix: string]: RDF.NamedNode },
-  index?: number,
-) => void;
-
-export interface MessageParseCallbacks<Q extends RDF.BaseQuad = RDF.Quad> {
-  onMessage?: MessageCallback<Q>;
-  onQuad?: (error: Error | null, quad?: Q, messageIndex?: number) => void;
-  onPrefix?: (prefix: string, term: RDF.NamedNode) => void;
-  onVersion?: (version: string) => void;
-}
+export * from './common.js';
+import type { MessageParserOptions, MessageCallback, MessageParseCallbacks, MessageWriterOptions } from './common.js';
 
 export class MessageParser<Q extends RDF.BaseQuad = RDF.Quad> {
   constructor(options?: MessageParserOptions<Q>);
@@ -77,39 +36,6 @@ export class MessageStreamParser<Q extends RDF.BaseQuad = RDF.Quad> extends Tran
   [Symbol.asyncIterator](): NodeJS.AsyncIterator<Q[]>;
 }
 
-export interface MessageWriterOptions {
-  /** Syntax name or media type, case-insensitive. Defaults to `TriG`. */
-  format?: MessageFormat;
-  /** Prefixes that are declared up front. */
-  prefixes?: { [prefix: string]: RDF.NamedNode | string };
-  baseIRI?: string;
-  writeBase?: boolean;
-  lists?: { [listHead: string]: RDF.Term[] };
-  /** RDF version label announced in the output. Defaults to `1.2-messages`. */
-  version?: string;
-  /** Whether to end the output stream on `end()`. Defaults to `true`. */
-  end?: boolean;
-}
-
-export interface MessageOutputStream {
-  write(chunk: string, encoding?: string, callback?: (error?: Error | null) => void): unknown;
-  end(callback?: (error?: Error | null) => void): unknown;
-}
-
-export class MessageWriter {
-  constructor(options?: MessageWriterOptions);
-  constructor(outputStream?: MessageOutputStream | NodeJS.WritableStream | null, options?: MessageWriterOptions);
-  addMessage(quads: RDF.BaseQuad[], done: (error: Error | null) => void): void;
-  addMessage(quads: RDF.BaseQuad[]): Promise<void>;
-  addPrefix(prefix: string, iri: RDF.NamedNode | string, done: (error: Error | null) => void): void;
-  addPrefix(prefix: string, iri: RDF.NamedNode | string): Promise<void>;
-  /** Without an output stream, the result is the written string. */
-  end(done: (error: Error | null, result?: string) => void): void;
-  end(): Promise<string>;
-}
-
-export function writeMessages(messages: Iterable<RDF.BaseQuad[]>, options?: MessageWriterOptions): string;
-
 export class MessageStreamWriter extends Transform {
   constructor(options?: Omit<MessageWriterOptions, 'end'>);
 }

package/lib/MessageParser.js

@@ -10,12 +10,18 @@ var _MessageParserCore = _interopRequireDefault(require("./MessageParserCore.js"
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // **MessageParser** parses RDF Message Logs (Turtle, TriG, N-Triples and N-Quads).
 
+/** @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad] */
 class MessageParser {
+  /** @param {import('../common.js').MessageParserOptions<Q>} [options] */
   constructor(options) {
+    /** @type {import('../common.js').MessageParserOptions<Q>} */
     this._options = options || {};
     // Fail early on unsupported options
-    this._createCore({});
+    // Construction only validates options; this core never receives input.
+    this._createCore(/** @type {import('./internal.js').ParserSink<Q>} */{});
   }
+
+  /** @param {import('./internal.js').ParserSink<Q>} sink */
   _createCore(sink) {
     return new _MessageParserCore.default(this._options, sink);
   }
@@ -28,23 +34,45 @@ class MessageParser {
   // callbacks `onMessage(error, message, prefixes)`, `onQuad(error, quad, messageIndex)`,
   // `onPrefix(prefix, term)` and `onVersion(label)`, messages are reported as soon
   // as they are complete. The final call has `null` as message.
+  /**
+   * @overload
+   * @param {string} input
+   * @returns {Q[][]}
+   */
+  /**
+   * @overload
+   * @param {string | NodeJS.ReadableStream} input
+   * @param {import('../common.js').MessageCallback<Q> | import('../common.js').MessageParseCallbacks<Q>} [callbacks]
+   * @returns {void}
+   */
+  /**
+   * @param {string | NodeJS.ReadableStream} input
+   * @param {import('../common.js').MessageCallback<Q> | import('../common.js').MessageParseCallbacks<Q>} [callbacks]
+   * @returns {Q[][] | undefined}
+   */
   parse(input, callbacks) {
     if (typeof callbacks === 'function') callbacks = {
       onMessage: callbacks
     };
+
+    /** @type {Q[][] | null} */
     const messages = callbacks ? null : [];
+
+    /** @type {Error | null} */
     let error = null;
     callbacks = callbacks || {};
+
+    /** @type {import('./internal.js').ParserSink<Q>} */
     const sink = {
       message: (quads, index) => callbacks.onMessage ? callbacks.onMessage(null, quads, undefined, index) : messages && messages.push(quads),
       end: prefixes => callbacks.onMessage && callbacks.onMessage(null, null, prefixes),
       error: e => {
         error = e;
-        callbacks.onMessage && callbacks.onMessage(e);
+        callbacks.onMessage && callbacks.onMessage(e, null);
         callbacks.onQuad && callbacks.onQuad(e);
       }
     };
-    if (callbacks.onQuad) sink.quad = (quad, index) => callbacks.onQuad(null, quad, index);
+    if (callbacks.onQuad) sink.quad = (quad, index) => callbacks.onQuad?.(null, quad, index);
     if (callbacks.onPrefix) sink.prefix = callbacks.onPrefix;
     if (callbacks.onVersion) sink.version = callbacks.onVersion;
     const core = this._createCore(sink);
@@ -69,8 +97,14 @@ class MessageParser {
   }
 }
 
+/**
+ * @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad]
+ * @param {string} input
+ * @param {import('../common.js').MessageParserOptions<Q>} [options]
+ */
 // ### `parseMessages` synchronously parses a string into an array of messages
 exports.default = MessageParser;
 function parseMessages(input, options) {
   return new MessageParser(options).parse(input);
-}
+}
+//# sourceMappingURL=MessageParser.js.map

package/lib/MessageParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageParser.js","names":["MessageParserCore","StringDecoder"],"sources":["../src/MessageParser.js"],"sourcesContent":["// **MessageParser** parses RDF Message Logs (Turtle, TriG, N-Triples and N-Quads).\nimport { StringDecoder } from 'string_decoder';\nimport MessageParserCore from './MessageParserCore.js';\n\n/** @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad] */\nexport default class MessageParser {\n  /** @param {import('../common.js').MessageParserOptions<Q>} [options] */\n  constructor(options) {\n    /** @type {import('../common.js').MessageParserOptions<Q>} */\n    this._options = options || {};\n    // Fail early on unsupported options\n    // Construction only validates options; this core never receives input.\n    this._createCore(/** @type {import('./internal.js').ParserSink<Q>} */ ({}));\n  }\n\n  /** @param {import('./internal.js').ParserSink<Q>} sink */\n  _createCore(sink) {\n    return new MessageParserCore(this._options, sink);\n  }\n\n  // ### `parse` parses a string or a readable stream of RDF Messages.\n  //\n  // Without callbacks, a string is parsed synchronously into an array of\n  // messages (arrays of quads), and parse errors are thrown.\n  // With a callback `(error, message, prefixes)`, or an object with the\n  // callbacks `onMessage(error, message, prefixes)`, `onQuad(error, quad, messageIndex)`,\n  // `onPrefix(prefix, term)` and `onVersion(label)`, messages are reported as soon\n  // as they are complete. The final call has `null` as message.\n  /**\n   * @overload\n   * @param {string} input\n   * @returns {Q[][]}\n   */\n  /**\n   * @overload\n   * @param {string | NodeJS.ReadableStream} input\n   * @param {import('../common.js').MessageCallback<Q> | import('../common.js').MessageParseCallbacks<Q>} [callbacks]\n   * @returns {void}\n   */\n  /**\n   * @param {string | NodeJS.ReadableStream} input\n   * @param {import('../common.js').MessageCallback<Q> | import('../common.js').MessageParseCallbacks<Q>} [callbacks]\n   * @returns {Q[][] | undefined}\n   */\n  parse(input, callbacks) {\n    if (typeof callbacks === 'function')\n      callbacks = { onMessage: callbacks };\n\n    /** @type {Q[][] | null} */\n    const messages = callbacks ? null : [];\n\n    /** @type {Error | null} */\n    let error = null;\n    callbacks = callbacks || {};\n\n    /** @type {import('./internal.js').ParserSink<Q>} */\n    const sink = {\n      message: (quads, index) => callbacks.onMessage ? callbacks.onMessage(null, quads, undefined, index) : messages && messages.push(quads),\n      end: prefixes => callbacks.onMessage && callbacks.onMessage(null, null, prefixes),\n      error: e => {\n        error = e;\n        callbacks.onMessage && callbacks.onMessage(e, null);\n        callbacks.onQuad && callbacks.onQuad(e);\n      },\n    };\n    if (callbacks.onQuad)\n      sink.quad = (quad, index) => callbacks.onQuad?.(null, quad, index);\n    if (callbacks.onPrefix)\n      sink.prefix = callbacks.onPrefix;\n    if (callbacks.onVersion)\n      sink.version = callbacks.onVersion;\n    const core = this._createCore(sink);\n\n    // Parse a string at once\n    if (typeof input === 'string') {\n      core.write(input);\n      core.end();\n      if (error && messages)\n        throw error;\n      return messages || undefined;\n    }\n\n    // Parse a stream chunk by chunk\n    const decoder = new StringDecoder('utf8');\n    input.on('data', chunk => core.write(typeof chunk === 'string' ? chunk : decoder.write(chunk)));\n    input.on('end', () => {\n      core.write(decoder.end());\n      core.end();\n    });\n    input.on('error', e => sink.error(e));\n    return undefined;\n  }\n}\n\n/**\n * @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad]\n * @param {string} input\n * @param {import('../common.js').MessageParserOptions<Q>} [options]\n */\n// ### `parseMessages` synchronously parses a string into an array of messages\nexport function parseMessages(input, options) {\n  return new MessageParser(options).parse(input);\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/MessageParserCore.js

@@ -11,27 +11,41 @@ var _formats = require("./formats.js");
 // It feeds text to the N3.js parser, which recognizes the message delimiters
 // through its `directives` option, and groups the resulting quads into messages.
 
+/** @typedef {import('@rdfjs/types').Term} BaseTerm */
+/** @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad] */
 class MessageParserCore {
   // `sink` receives `message(quads, index)`, `end(prefixes)`, `error(error)`
   // and optionally `quad(quad, messageIndex)`, `prefix(prefix, term)`, `version(label)`
+  /**
+   * @param {import('../common.js').MessageParserOptions<Q> | undefined} options
+   * @param {import('./internal.js').ParserSink<Q>} sink
+   */
   constructor(options, sink) {
     options = options || {};
     const format = (0, _formats.resolveFormat)(options.format);
     this._sink = sink;
-    this._factory = options.factory || _n.DataFactory;
+
+    /** @type {import('../common.js').MessageQuadFactory<Q>} */
+    this._factory = options.factory || /** @type {import('../common.js').MessageQuadFactory<Q>} */_n.DataFactory;
     this._blankNodePrefix = typeof options.blankNodePrefix === 'string' ? options.blankNodePrefix.replace(/^_:/, '') : undefined;
     this._blankNodeCounter = 0;
     this._supportedVersions = _n.Parser.SUPPORTED_VERSIONS;
     this._messages = options.messages === true || (0, _formats.isMessagesVersion)(options.version);
     this._index = 0;
+
+    /** @type {Q[] | null} */
     this._current = null;
+
+    /** @type {Map<string, import('@rdfjs/types').BlankNode> | null} */
     this._scope = null;
     this._seenQuad = false;
     this._failed = false;
     this._finished = false;
+
+    /** @type {import('n3').ParserOptions} */
     const n3Options = {
       format: format.name,
-      factory: this._factory,
+      factory: (/** @type {import('@rdfjs/types').DataFactory} */ /** @type {unknown} */this._factory),
       // Version labels are validated here, because N3.js does not know `-messages` labels
       parseUnsupportedVersions: true,
       // N3.js reports `MESSAGE` and `@message .` between statements through `onDirective`,
@@ -49,7 +63,7 @@ class MessageParserCore {
     this._line = 0;
     this._delimiterLine = 0;
     new _n.Parser(n3Options).parse(this._input, {
-      onQuad: (error, quad, prefixes) => this._onQuad(error, quad, prefixes),
+      onQuad: (error, quad, prefixes) => this._onQuad(error, /** @type {Q | null} */quad, prefixes),
       onPrefix: (prefix, term) => this._failed || sink.prefix && sink.prefix(prefix, term),
       onVersion: label => this._failed || this._announce(label),
       onDirective: () => this._failed || this._delimiter(),
@@ -58,6 +72,7 @@ class MessageParserCore {
   }
 
   // ### `write` accepts the next chunk of text
+  /** @param {string} text */
   write(text) {
     if (!this._failed && !this._finished && text.length > 0) this._input.emit('data', text);
   }
@@ -68,6 +83,7 @@ class MessageParserCore {
   }
 
   // Keeps track of lines; in N-Triples and N-Quads, a delimiter must be on its own line
+  /** @param {{ line: number; type: string }} token */
   _onToken(token) {
     const line = token.line,
       delimiter = token.type === 'MESSAGE';
@@ -75,6 +91,10 @@ class MessageParserCore {
     if (delimiter) this._delimiterLine = line;
     this._line = line;
   }
+
+  /** @param {Error | null} error
+   * @param {Q | null} quad
+   * @param {Record<string, import('@rdfjs/types').NamedNode>} [prefixes] */
   _onQuad(error, quad, prefixes) {
     if (this._failed || this._finished) return;
     if (error) this._fail(error);else if (quad) this._addQuad(quad);else {
@@ -83,6 +103,8 @@ class MessageParserCore {
       this._sink.end(prefixes);
     }
   }
+
+  /** @param {Q} quad */
   _addQuad(quad) {
     this._seenQuad = true;
     // Blank node labels are scoped to their message
@@ -91,6 +113,8 @@ class MessageParserCore {
     this._current.push(quad);
     if (this._sink.quad) this._sink.quad(quad, this._index);
   }
+
+  /** @param {string} label */
   _announce(label) {
     const error = this._checkVersion(label);
     if (error) return this._fail(error);
@@ -102,6 +126,8 @@ class MessageParserCore {
   }
 
   // Validates a version label, and returns an error for unsupported ones
+  /** @param {string} label
+   * @param {boolean} [throwing] */
   _checkVersion(label, throwing) {
     if ((0, _formats.isSupportedVersion)((0, _formats.baseVersion)(label), this._supportedVersions)) return null;
     const error = new Error(`Detected unsupported version: "${label}"`);
@@ -122,6 +148,8 @@ class MessageParserCore {
     this._scope = null;
     this._sink.message(quads, this._index++);
   }
+
+  /** @param {Error} error */
   _fail(error) {
     this._failed = true;
     this._current = null;
@@ -130,6 +158,8 @@ class MessageParserCore {
 
   // ## Blank node scoping
 
+  /** @param {Q} quad
+   * @returns {Q} */
   _scopeQuad(quad) {
     const subject = this._scopeTerm(quad.subject);
     const predicate = this._scopeTerm(quad.predicate);
@@ -137,6 +167,10 @@ class MessageParserCore {
     const graph = this._scopeTerm(quad.graph);
     return subject === quad.subject && predicate === quad.predicate && object === quad.object && graph === quad.graph ? quad : this._factory.quad(subject, predicate, object, graph);
   }
+
+  /** @template {BaseTerm} T
+   * @param {T} term
+   * @returns {T} */
   _scopeTerm(term) {
     if (term.termType === 'BlankNode') {
       const scope = this._scope || (this._scope = new Map());
@@ -145,9 +179,11 @@ class MessageParserCore {
         scoped = this._blankNodePrefix === undefined ? this._factory.blankNode() : this._factory.blankNode(`${this._blankNodePrefix}${this._blankNodeCounter++}`);
         scope.set(term.value, scoped);
       }
-      return scoped;
+      return /** @type {T} */ /** @type {unknown} */scoped;
     }
-    return term.termType === 'Quad' ? this._scopeQuad(term) : term;
+    return term.termType === 'Quad' ? (/** @type {T} */ /** @type {unknown} */
+    this._scopeQuad(/** @type {Q} */ /** @type {unknown} */term)) : term;
   }
 }
-exports.default = MessageParserCore;
+exports.default = MessageParserCore;
+//# sourceMappingURL=MessageParserCore.js.map

package/lib/MessageParserCore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageParserCore.js","names":["resolveFormat","DataFactory","Parser","isMessagesVersion","baseVersion","EventEmitter","isSupportedVersion"],"sources":["../src/MessageParserCore.js"],"sourcesContent":["// **MessageParserCore** is the push-based engine behind all message parsers.\n// It feeds text to the N3.js parser, which recognizes the message delimiters\n// through its `directives` option, and groups the resulting quads into messages.\nimport { EventEmitter } from 'events';\nimport { Parser, DataFactory } from 'n3';\nimport { resolveFormat, isMessagesVersion, baseVersion, isSupportedVersion } from './formats.js';\n\n/** @typedef {import('@rdfjs/types').Term} BaseTerm */\n/** @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad] */\nexport default class MessageParserCore {\n  // `sink` receives `message(quads, index)`, `end(prefixes)`, `error(error)`\n  // and optionally `quad(quad, messageIndex)`, `prefix(prefix, term)`, `version(label)`\n  /**\n   * @param {import('../common.js').MessageParserOptions<Q> | undefined} options\n   * @param {import('./internal.js').ParserSink<Q>} sink\n   */\n  constructor(options, sink) {\n    options = options || {};\n    const format = resolveFormat(options.format);\n    this._sink = sink;\n\n    /** @type {import('../common.js').MessageQuadFactory<Q>} */\n    this._factory = options.factory || /** @type {import('../common.js').MessageQuadFactory<Q>} */ (DataFactory);\n    this._blankNodePrefix = typeof options.blankNodePrefix === 'string' ?\n      options.blankNodePrefix.replace(/^_:/, '') : undefined;\n    this._blankNodeCounter = 0;\n    this._supportedVersions = Parser.SUPPORTED_VERSIONS;\n    this._messages = options.messages === true || isMessagesVersion(options.version);\n    this._index = 0;\n\n    /** @type {Q[] | null} */\n    this._current = null;\n\n    /** @type {Map<string, import('@rdfjs/types').BlankNode> | null} */\n    this._scope = null;\n    this._seenQuad = false;\n    this._failed = false;\n    this._finished = false;\n\n    /** @type {import('n3').ParserOptions} */\n    const n3Options = {\n      format: format.name,\n      factory: /** @type {import('@rdfjs/types').DataFactory} */ (/** @type {unknown} */ (this._factory)),\n      // Version labels are validated here, because N3.js does not know `-messages` labels\n      parseUnsupportedVersions: true,\n      // N3.js reports `MESSAGE` and `@message .` between statements through `onDirective`,\n      // in order with the quads, and rejects them anywhere else\n      directives: ['message'],\n    };\n    if (options.baseIRI)\n      n3Options.baseIRI = options.baseIRI;\n    if (options.version) {\n      this._checkVersion(options.version, true);\n      n3Options.version = baseVersion(options.version);\n    }\n\n    this._input = new EventEmitter();\n    this._lineMode = format.lineMode;\n    // The line of the current token, and of the last delimiter\n    this._line = 0;\n    this._delimiterLine = 0;\n    new Parser(n3Options).parse(this._input, {\n      onQuad: (error, quad, prefixes) => this._onQuad(error, /** @type {Q | null} */ (quad), prefixes),\n      onPrefix: (prefix, term) => this._failed || sink.prefix && sink.prefix(prefix, term),\n      onVersion: label => this._failed || this._announce(label),\n      onDirective: () => this._failed || this._delimiter(),\n      onToken: token => this._onToken(token),\n    });\n  }\n\n  // ### `write` accepts the next chunk of text\n  /** @param {string} text */\n  write(text) {\n    if (!this._failed && !this._finished && text.length > 0)\n      this._input.emit('data', text);\n  }\n\n  // ### `end` signals the end of the input\n  end() {\n    if (!this._failed && !this._finished)\n      this._input.emit('end');\n  }\n\n  // Keeps track of lines; in N-Triples and N-Quads, a delimiter must be on its own line\n  /** @param {{ line: number; type: string }} token */\n  _onToken(token) {\n    const line = token.line, delimiter = token.type === 'MESSAGE';\n    if (this._lineMode && !this._failed &&\n        (delimiter ? line === this._line : line === this._delimiterLine && token.type !== 'eof'))\n      this._fail(new Error(`Unexpected \"MESSAGE\" on line ${line}.`));\n    if (delimiter)\n      this._delimiterLine = line;\n    this._line = line;\n  }\n\n  /** @param {Error | null} error\n   * @param {Q | null} quad\n   * @param {Record<string, import('@rdfjs/types').NamedNode>} [prefixes] */\n  _onQuad(error, quad, prefixes) {\n    if (this._failed || this._finished)\n      return;\n    if (error)\n      this._fail(error);\n    else if (quad)\n      this._addQuad(quad);\n    else {\n      this._finished = true;\n      if (this._current !== null)\n        this._emitMessage();\n      this._sink.end(prefixes);\n    }\n  }\n\n  /** @param {Q} quad */\n  _addQuad(quad) {\n    this._seenQuad = true;\n    // Blank node labels are scoped to their message\n    if (this._messages)\n      quad = this._scopeQuad(quad);\n    if (this._current === null)\n      this._current = [];\n    this._current.push(quad);\n    if (this._sink.quad)\n      this._sink.quad(quad, this._index);\n  }\n\n  /** @param {string} label */\n  _announce(label) {\n    const error = this._checkVersion(label);\n    if (error)\n      return this._fail(error);\n    if (isMessagesVersion(label) && !this._messages) {\n      if (this._seenQuad)\n        return this._fail(new Error(`Version \"${label}\" must be announced before the first statement.`));\n      this._messages = true;\n    }\n    if (this._sink.version)\n      this._sink.version(label);\n  }\n\n  // Validates a version label, and returns an error for unsupported ones\n  /** @param {string} label\n   * @param {boolean} [throwing] */\n  _checkVersion(label, throwing) {\n    if (isSupportedVersion(baseVersion(label), this._supportedVersions))\n      return null;\n    const error = new Error(`Detected unsupported version: \"${label}\"`);\n    if (throwing)\n      throw error;\n    return error;\n  }\n\n  _delimiter() {\n    if (!this._messages) {\n      return this._fail(new Error(`Unexpected \"MESSAGE\" on line ${this._line}: the document did not announce ` +\n                                  'a version with the \"-messages\" suffix.'));\n    }\n    this._emitMessage();\n  }\n\n  // Finalizes the current message, which is empty if no quad was seen\n  _emitMessage() {\n    const quads = this._current || [];\n    this._current = null;\n    this._scope = null;\n    this._sink.message(quads, this._index++);\n  }\n\n  /** @param {Error} error */\n  _fail(error) {\n    this._failed = true;\n    this._current = null;\n    this._sink.error(error);\n  }\n\n  // ## Blank node scoping\n\n  /** @param {Q} quad\n   * @returns {Q} */\n  _scopeQuad(quad) {\n    const subject = this._scopeTerm(quad.subject);\n    const predicate = this._scopeTerm(quad.predicate);\n    const object = this._scopeTerm(quad.object);\n    const graph = this._scopeTerm(quad.graph);\n    return subject === quad.subject && predicate === quad.predicate &&\n           object === quad.object && graph === quad.graph ?\n      quad : this._factory.quad(subject, predicate, object, graph);\n  }\n\n  /** @template {BaseTerm} T\n   * @param {T} term\n   * @returns {T} */\n  _scopeTerm(term) {\n    if (term.termType === 'BlankNode') {\n      const scope = this._scope || (this._scope = new Map());\n      let scoped = scope.get(term.value);\n      if (!scoped) {\n        scoped = this._blankNodePrefix === undefined ? this._factory.blankNode() :\n          this._factory.blankNode(`${this._blankNodePrefix}${this._blankNodeCounter++}`);\n        scope.set(term.value, scoped);\n      }\n      return /** @type {T} */ (/** @type {unknown} */ (scoped));\n    }\n    return term.termType === 'Quad' ? /** @type {T} */ (/** @type {unknown} */ (\n      this._scopeQuad(/** @type {Q} */ (/** @type {unknown} */ (term))))) : term;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/MessageStreamParser.js

@@ -13,13 +13,17 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 // It consumes strings or buffers, and produces one array of quads per message,
 // as soon as that message is complete.
 
+/** @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad] */
 class MessageStreamParser extends _stream.Transform {
+  /** @param {import('../common.js').MessageParserOptions<Q>} [options] */
   constructor(options) {
     super({
       decodeStrings: false,
       readableObjectMode: true
     });
     this._decoder = new _string_decoder.StringDecoder('utf8');
+
+    /** @type {Error | null} */
     this._error = null;
     this._core = new _MessageParserCore.default(options, {
       message: quads => this.push(quads),
@@ -31,14 +35,21 @@ class MessageStreamParser extends _stream.Transform {
       version: label => this.emit('version', label)
     });
   }
+
+  /** @param {string | Buffer} chunk
+   * @param {BufferEncoding} encoding
+   * @param {import('node:stream').TransformCallback} done */
   _transform(chunk, encoding, done) {
     this._core.write(typeof chunk === 'string' ? chunk : this._decoder.write(chunk));
     done(this._error);
   }
+
+  /** @param {import('node:stream').TransformCallback} done */
   _flush(done) {
     this._core.write(this._decoder.end());
     this._core.end();
     done(this._error);
   }
 }
-exports.default = MessageStreamParser;
+exports.default = MessageStreamParser;
+//# sourceMappingURL=MessageStreamParser.js.map

package/lib/MessageStreamParser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageStreamParser.js","names":["Transform","StringDecoder","MessageParserCore"],"sources":["../src/MessageStreamParser.js"],"sourcesContent":["// **MessageStreamParser** is a Node.js stream that turns text into RDF Messages.\n//\n// It consumes strings or buffers, and produces one array of quads per message,\n// as soon as that message is complete.\nimport { Transform } from 'stream';\nimport { StringDecoder } from 'string_decoder';\nimport MessageParserCore from './MessageParserCore.js';\n\n/** @template {import('@rdfjs/types').BaseQuad} [Q=import('@rdfjs/types').Quad] */\nexport default class MessageStreamParser extends Transform {\n  /** @param {import('../common.js').MessageParserOptions<Q>} [options] */\n  constructor(options) {\n    super({ decodeStrings: false, readableObjectMode: true });\n    this._decoder = new StringDecoder('utf8');\n\n    /** @type {Error | null} */\n    this._error = null;\n    this._core = new MessageParserCore(options, {\n      message: quads => this.push(quads),\n      end: () => {},\n      error: error => { this._error = this._error || error; },\n      prefix: (prefix, term) => this.emit('prefix', prefix, term),\n      version: label => this.emit('version', label),\n    });\n  }\n\n  /** @param {string | Buffer} chunk\n   * @param {BufferEncoding} encoding\n   * @param {import('node:stream').TransformCallback} done */\n  _transform(chunk, encoding, done) {\n    this._core.write(typeof chunk === 'string' ? chunk : this._decoder.write(chunk));\n    done(this._error);\n  }\n\n  /** @param {import('node:stream').TransformCallback} done */\n  _flush(done) {\n    this._core.write(this._decoder.end());\n    this._core.end();\n    done(this._error);\n  }\n}\n"],"mappings":";;;;;;AAIA;AACA;AACA;AAAuD;AANvD;AACA;AACA;AACA;;AAKA;AACe,MAAM,mBAAmB,SAASA,QAAA,SAAS,CAAC;EACzD;EACA,WAAW,CAAC,OAAO,EAAE;IACnB,KAAK,CAAC;MAAE,aAAa,EAAE,KAAK;MAAE,kBAAkB,EAAE;IAAK,CAAC,CAAC;IACzD,IAAI,CAAC,QAAQ,GAAG,IAAIC,gBAAA,aAAa,CAAC,MAAM,CAAC;;IAEzC;IACA,IAAI,CAAC,MAAM,GAAG,IAAI;IAClB,IAAI,CAAC,KAAK,GAAG,IAAIC,0BAAiB,CAAC,OAAO,EAAE;MAC1C,OAAO,EAAE,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC;MAClC,GAAG,EAAE,MAAM,CAAC,CAAC;MACb,KAAK,EAAE,KAAK,IAAI;QAAE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,KAAK;MAAE,CAAC;MACvD,MAAM,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC;MAC3D,OAAO,EAAE,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK;IAC9C,CAAC,CAAC;EACJ;;EAEA;AACF;AACA;EACE,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE;IAChC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,KAAK,KAAK,QAAQ,GAAG,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAChF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;EACnB;;EAEA;EACA,MAAM,CAAC,IAAI,EAAE;IACX,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACrC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAChB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;EACnB;AACF;AAAC","ignoreList":[]}

package/lib/MessageStreamWriter.js

@@ -9,15 +9,17 @@ var _MessageWriter = _interopRequireDefault(require("./MessageWriter.js"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // **MessageStreamWriter** is a Node.js stream that serializes RDF Messages.
 //
-// It consumes messages (arrays of quads) and produces text.
+// It consumes messages (arrays of quads), or `{ quad, messageIndex }` objects, and produces text.
 
 class MessageStreamWriter extends _stream.Transform {
+  /** @param {import('../common.js').MessageWriterOptions} [options] */
   constructor(options) {
     super({
       writableObjectMode: true,
       encoding: 'utf8'
     });
     // Writing into this stream never blocks, and output is pushed synchronously
+    /** @type {Pick<import('./internal.js').Output, 'write'>} */
     const output = {
       write: (chunk, encoding, done) => (this.push(chunk), done && done())
     };
@@ -25,11 +27,19 @@ class MessageStreamWriter extends _stream.Transform {
       end: false
     }));
   }
+
+  /** @param {import('../browser.js').MessageWriterInput} message
+   * @param {BufferEncoding} encoding
+   * @param {import('node:stream').TransformCallback} done */
   _transform(message, encoding, done) {
-    this._writer.addMessage(message, done);
+    // A message (array of quads), or a quad of a message: `{ quad, messageIndex }`
+    if (Array.isArray(message)) this._writer.addMessage(message, done);else this._writer.addQuad(message.quad, message.messageIndex, done);
   }
+
+  /** @param {import('node:stream').TransformCallback} done */
   _flush(done) {
     this._writer.end(done);
   }
 }
-exports.default = MessageStreamWriter;
+exports.default = MessageStreamWriter;
+//# sourceMappingURL=MessageStreamWriter.js.map

package/lib/MessageStreamWriter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageStreamWriter.js","names":["Transform","MessageWriter"],"sources":["../src/MessageStreamWriter.js"],"sourcesContent":["// **MessageStreamWriter** is a Node.js stream that serializes RDF Messages.\n//\n// It consumes messages (arrays of quads), or `{ quad, messageIndex }` objects, and produces text.\nimport { Transform } from 'stream';\nimport MessageWriter from './MessageWriter.js';\n\nexport default class MessageStreamWriter extends Transform {\n  /** @param {import('../common.js').MessageWriterOptions} [options] */\n  constructor(options) {\n    super({ writableObjectMode: true, encoding: 'utf8' });\n    // Writing into this stream never blocks, and output is pushed synchronously\n    /** @type {Pick<import('./internal.js').Output, 'write'>} */\n    const output = { write: (chunk, encoding, done) => (this.push(chunk), done && done()) };\n    this._writer = new MessageWriter(output, Object.assign({}, options, { end: false }));\n  }\n\n  /** @param {import('../browser.js').MessageWriterInput} message\n   * @param {BufferEncoding} encoding\n   * @param {import('node:stream').TransformCallback} done */\n  _transform(message, encoding, done) {\n    // A message (array of quads), or a quad of a message: `{ quad, messageIndex }`\n    if (Array.isArray(message)) this._writer.addMessage(message, done);\n    else this._writer.addQuad(message.quad, message.messageIndex, done);\n  }\n\n  /** @param {import('node:stream').TransformCallback} done */\n  _flush(done) {\n    this._writer.end(done);\n  }\n}\n"],"mappings":";;;;;;AAGA;AACA;AAA+C;AAJ/C;AACA;AACA;;AAIe,MAAM,mBAAmB,SAASA,QAAA,SAAS,CAAC;EACzD;EACA,WAAW,CAAC,OAAO,EAAE;IACnB,KAAK,CAAC;MAAE,kBAAkB,EAAE,IAAI;MAAE,QAAQ,EAAE;IAAO,CAAC,CAAC;IACrD;IACA;IACA,MAAM,MAAM,GAAG;MAAE,KAAK,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC,CAAC;IAAE,CAAC;IACvF,IAAI,CAAC,OAAO,GAAG,IAAIC,sBAAa,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE;MAAE,GAAG,EAAE;IAAM,CAAC,CAAC,CAAC;EACtF;;EAEA;AACF;AACA;EACE,UAAU,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE;IAClC;IACA,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,KAC9D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC;EACrE;;EAEA;EACA,MAAM,CAAC,IAAI,EAAE;IACX,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;EACxB;AACF;AAAC","ignoreList":[]}