@graphty/graph-io 0.0.0 → 0.2.1

package/dist/src/common/writer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The output side of the exporter contract (design sections 8.5 and 12.4): an exporter produces
+ * its document as a sequence of text parts (a sync or async generator of strings, one per line or
+ * element); these helpers turn that sequence into `export()`'s `AsyncIterable<Uint8Array>` of
+ * UTF-8 chunks of a bounded size, into `exportToString()`'s one string, or into a
+ * `ReadableStream<Uint8Array>` for a caller that wants a stream.
+ */
+/**
+ * Text parts an exporter produces.
+ * Consumed by the per-format importers and exporters under src/formats.
+ * @public
+ */
+export type TextParts = Iterable<string> | AsyncIterable<string>;
+/** The target size of one encoded chunk; parts are coalesced up to it and never split. */
+export declare const DEFAULT_CHUNK_BYTES: number;
+/**
+ * Encode text parts as UTF-8 chunks of about `chunkBytes` each. Small parts are coalesced; a part
+ * larger than the chunk size is emitted whole. The last chunk may be short; nothing is emitted for
+ * an empty document.
+ * @param parts - the text parts
+ * @param chunkBytes - the target chunk size in bytes
+ * @yields UTF-8 chunks
+ * @returns nothing
+ */
+export declare function encodeChunks(parts: TextParts, chunkBytes?: number): AsyncGenerator<Uint8Array, void, undefined>;
+/**
+ * Join text parts into one string.
+ * @param parts - the text parts
+ * @returns the whole document
+ */
+export declare function joinText(parts: TextParts): Promise<string>;
+/**
+ * Decode UTF-8 chunks back into one string (for tests and for callers holding an export() result).
+ * @param chunks - the chunks
+ * @returns the decoded text
+ */
+export declare function decodeChunks(chunks: AsyncIterable<Uint8Array>): Promise<string>;
+/**
+ * Collect UTF-8 chunks into one Uint8Array.
+ * @param chunks - the chunks
+ * @returns the concatenated bytes
+ */
+export declare function collectBytes(chunks: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+/**
+ * Wrap an async iterable of chunks as a ReadableStream, pulling one chunk per read and cancelling
+ * the iterable when the stream is cancelled.
+ * @param chunks - the chunks
+ * @returns a byte stream
+ */
+export declare function toReadableStream(chunks: AsyncIterable<Uint8Array>): ReadableStream<Uint8Array>;
+//# sourceMappingURL=writer.d.ts.map

package/dist/src/common/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../../src/common/writer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;AAEjE,0FAA0F;AAC1F,eAAO,MAAM,mBAAmB,QAAY,CAAC;AAE7C;;;;;;;;GAQG;AACH,wBAAuB,YAAY,CAC/B,KAAK,EAAE,SAAS,EAChB,UAAU,GAAE,MAA4B,GACzC,cAAc,CAAC,UAAU,EAAE,IAAI,EAAE,SAAS,CAAC,CAoB7C;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAMhE;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAQrF;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAczF;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,cAAc,CAAC,UAAU,CAAC,CAe9F"}

package/dist/src/common/writer.js

@@ -0,0 +1,108 @@
+/**
+ * The output side of the exporter contract (design sections 8.5 and 12.4): an exporter produces
+ * its document as a sequence of text parts (a sync or async generator of strings, one per line or
+ * element); these helpers turn that sequence into `export()`'s `AsyncIterable<Uint8Array>` of
+ * UTF-8 chunks of a bounded size, into `exportToString()`'s one string, or into a
+ * `ReadableStream<Uint8Array>` for a caller that wants a stream.
+ */
+/** The target size of one encoded chunk; parts are coalesced up to it and never split. */
+export const DEFAULT_CHUNK_BYTES = 64 * 1024;
+/**
+ * Encode text parts as UTF-8 chunks of about `chunkBytes` each. Small parts are coalesced; a part
+ * larger than the chunk size is emitted whole. The last chunk may be short; nothing is emitted for
+ * an empty document.
+ * @param parts - the text parts
+ * @param chunkBytes - the target chunk size in bytes
+ * @yields UTF-8 chunks
+ * @returns nothing
+ */
+export async function* encodeChunks(parts, chunkBytes = DEFAULT_CHUNK_BYTES) {
+    const encoder = new TextEncoder();
+    let pending = [];
+    let pendingUnits = 0;
+    for await (const part of parts) {
+        if (part.length === 0) {
+            continue;
+        }
+        pending.push(part);
+        pendingUnits += part.length;
+        // UTF-16 code units are a lower bound on the UTF-8 byte count; flush when the lower bound reaches the target
+        if (pendingUnits >= chunkBytes) {
+            yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+            pending = [];
+            pendingUnits = 0;
+        }
+    }
+    if (pending.length > 0) {
+        yield encoder.encode(pending.length === 1 ? pending[0] : pending.join(""));
+    }
+}
+/**
+ * Join text parts into one string.
+ * @param parts - the text parts
+ * @returns the whole document
+ */
+export async function joinText(parts) {
+    const collected = [];
+    for await (const part of parts) {
+        collected.push(part);
+    }
+    return collected.join("");
+}
+/**
+ * Decode UTF-8 chunks back into one string (for tests and for callers holding an export() result).
+ * @param chunks - the chunks
+ * @returns the decoded text
+ */
+export async function decodeChunks(chunks) {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    const parts = [];
+    for await (const chunk of chunks) {
+        parts.push(decoder.decode(chunk, { stream: true }));
+    }
+    parts.push(decoder.decode());
+    return parts.join("");
+}
+/**
+ * Collect UTF-8 chunks into one Uint8Array.
+ * @param chunks - the chunks
+ * @returns the concatenated bytes
+ */
+export async function collectBytes(chunks) {
+    const parts = [];
+    let total = 0;
+    for await (const chunk of chunks) {
+        parts.push(chunk);
+        total += chunk.byteLength;
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const part of parts) {
+        out.set(part, offset);
+        offset += part.byteLength;
+    }
+    return out;
+}
+/**
+ * Wrap an async iterable of chunks as a ReadableStream, pulling one chunk per read and cancelling
+ * the iterable when the stream is cancelled.
+ * @param chunks - the chunks
+ * @returns a byte stream
+ */
+export function toReadableStream(chunks) {
+    const iterator = chunks[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const { done, value } = await iterator.next();
+            if (done) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(value);
+        },
+        async cancel() {
+            await iterator.return?.(undefined);
+        },
+    });
+}
+//# sourceMappingURL=writer.js.map

package/dist/src/common/writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.js","sourceRoot":"","sources":["../../../src/common/writer.ts"],"names":[],"mappings":"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"}

package/dist/src/common/xml.d.ts

@@ -0,0 +1,245 @@
+/**
+ * The streaming XML tokenizer shared by the GEXF and GraphML importers (design sections 8.2 and
+ * 8.4): SAX-style start / end / text events over the text chunks of the common reader, so both
+ * importers run in one pass with bounded memory and every issue carries a line number.
+ *
+ * Cost model: every character of the input is scanned once. A token that spans many chunks (a
+ * long attribute value, comment, CDATA section or name) resumes where the previous chunk left off
+ * instead of re-reading the token from its `<`, and line numbers are counted from a cached next
+ * line-break position, so a document without line breaks costs the same as one with them.
+ *
+ * What it handles: the XML declaration and processing instructions (skipped), comments (skipped),
+ * CDATA sections (text), a DOCTYPE with an internal subset (skipped; entity declarations are not
+ * expanded, so an unknown entity reference is a syntax error), the five predefined entities and
+ * numeric character references (decimal and hexadecimal) in text and attribute values, attribute
+ * value whitespace normalisation, end-of-line normalisation (CR LF and lone CR become LF), and
+ * well-formedness: matching end tags, one root element, no text outside it, no duplicate
+ * attributes, no unterminated markup at the end of the input. Namespaces are not resolved; element
+ * and attribute names are reported as written (with their prefix).
+ *
+ * Why not fast-xml-parser: its XMLParser accepts mismatched and unclosed tags without error, does
+ * not decode numeric character references unless the deprecated `htmlEntities` option is set, and
+ * its validator (`XMLValidator`, the `parse(xml, true)` overload) and `XMLBuilder` are deprecated in
+ * 5.x, which the root lint's `no-deprecated` rule forbids using; so the malformed corpus could not
+ * be rejected and attribute values written by the common `escapeXmlAttribute` (`&#10;`) could not
+ * be read back.
+ */
+import { type GraphSnapshot } from "@graphty/graph-format";
+import { type LossNote } from "../types.js";
+/** The events of the tokenizer; every callback is synchronous. */
+export interface XmlHandler {
+    /**
+     * An element starts (a self-closing element produces start then end).
+     * @param name - the element name as written, prefix included
+     * @param attrs - the attributes, entities decoded, in document order
+     * @param line - the 1-based line of the `<`
+     */
+    start(name: string, attrs: ReadonlyMap<string, string>, line: number): void;
+    /**
+     * An element ends.
+     * @param name - the element name
+     * @param line - the 1-based line of the end tag (or of the self-closing start tag)
+     */
+    end(name: string, line: number): void;
+    /**
+     * Character data between two tags (entities decoded, CDATA included), one call per run;
+     * whitespace-only runs are delivered too.
+     * @param text - the text
+     * @param line - the 1-based line where the run starts
+     */
+    text(text: string, line: number): void;
+}
+/** A well-formedness or syntax error, with the line it was found on. */
+export declare class XmlSyntaxError extends Error {
+    /** The 1-based line. */
+    readonly line: number;
+    /**
+     * Create the error.
+     * @param message - a plain-ASCII message
+     * @param line - the 1-based line
+     */
+    constructor(message: string, line: number);
+}
+/**
+ * Whether a text holds a character XML 1.0 forbids (see ILLEGAL_CHAR); such a character cannot be
+ * written even as a character reference, so a conforming parser rejects the whole document.
+ * @param text - the text
+ * @returns true when the text cannot appear in an XML 1.0 document
+ */
+export declare function hasIllegalXmlChar(text: string): boolean;
+/**
+ * The loss notes of the texts a snapshot holds that no XML 1.0 document can carry (see
+ * hasIllegalXmlChar): one E_XML_ILLEGAL_CHAR note per column (node, edge and graph string / dict /
+ * list-of-text columns) and one for the ids, each counting the affected rows; export() throws on
+ * the first such text. Shared by the GEXF and GraphML exporters' check().
+ * @param snapshot - the snapshot
+ * @returns the notes, empty when every text is writable
+ */
+export declare function xmlIllegalTextNotes(snapshot: GraphSnapshot): LossNote[];
+/**
+ * Whether a text is an XML Name.
+ * @param text - the text
+ * @returns true for a well-formed name
+ */
+export declare function isXmlName(text: string): boolean;
+/**
+ * Decode the predefined entities and character references of a text.
+ * @param raw - the text as written
+ * @param line - the line, for errors
+ * @returns the decoded text
+ */
+export declare function decodeEntities(raw: string, line: number): string;
+/**
+ * Whether a text is whitespace only.
+ * @param text - the text
+ * @returns true when every character is XML whitespace (also for an empty text)
+ */
+export declare function isWhitespace(text: string): boolean;
+/**
+ * The local part of a possibly prefixed XML name.
+ * @param name - the name as written
+ * @returns the text after the last colon, or the name itself
+ */
+export declare function localName(name: string): string;
+/**
+ * Tokenize XML text arriving in chunks and deliver events to a handler. Throws XmlSyntaxError on
+ * malformed input; any error the handler throws propagates unchanged.
+ * @param chunks - the text (already UTF-8 decoded, BOM removed)
+ * @param handler - the event sink
+ */
+export declare function tokenizeXml(chunks: AsyncIterable<string>, handler: XmlHandler): Promise<void>;
+/**
+ * The tokenizer state: the unconsumed tail of the input, the current line, the open element
+ * stack and the text run being accumulated. `push()` chunks, then `finish()`.
+ */
+export declare class XmlTokenizer {
+    private readonly handler;
+    /** Unconsumed input that is not part of a pending token: at most a held-back entity or the last chunk. */
+    private buffer;
+    /** The markup whose end has not arrived yet, or null. */
+    private pending;
+    /** The line number at the start of `buffer` (or of the pending markup). */
+    private line;
+    /**
+     * The index of the next line break in `buffer` at or after the last counted position: -2
+     * when not yet searched for the current buffer, -1 when the buffer holds no further break.
+     */
+    private nextBreak;
+    /** A CR held back from the end of the previous chunk (it may be the first half of CR LF). */
+    private pendingCr;
+    /** Whether the input has ended (an incomplete token is then an error, not a wait). */
+    private final;
+    /** The text run being accumulated (entities decoded), and the line it started on. */
+    private text;
+    private textLine;
+    private readonly stack;
+    private rootSeen;
+    private rootClosed;
+    /**
+     * Create a tokenizer.
+     * @param handler - the event sink
+     */
+    constructor(handler: XmlHandler);
+    /**
+     * Feed one chunk and emit every complete token in it.
+     * @param chunk - the text
+     */
+    push(chunk: string): void;
+    /** Signal the end of the input: flush the last text run and check well-formedness. */
+    finish(): void;
+    /**
+     * Append normalised text: continue a pending token's terminator scan over the new text alone,
+     * and once the token is complete (or when none is pending) scan the buffer for tokens.
+     * @param text - the text, line breaks normalised
+     */
+    private feed;
+    /**
+     * Continue the terminator scan of a pending token over new text.
+     * @param pending - the pending token
+     * @param text - the new text
+     * @returns the index in `text` one past the token's end, or -1 when it does not end there
+     */
+    private scanPending;
+    /**
+     * Scan text for the `>` that ends a start tag, skipping quoted attribute values (the quote
+     * state survives between calls).
+     * @param pending - the pending token
+     * @param text - the text
+     * @param from - where to start
+     * @returns the index one past the `>`, or -1
+     */
+    private scanStartTag;
+    /**
+     * Scan text for the `>` that ends a DOCTYPE declaration, skipping a bracketed internal subset,
+     * quoted literals and comments inside the subset. A character state machine, so the state
+     * (`depth`, `quote`, `comment`, and `run`, the progress through a `<!--` or the dashes before
+     * a `-->`) survives between calls and nothing is re-read.
+     * @param pending - the pending token
+     * @param text - the text
+     * @param from - where to start
+     * @returns the index one past the `>`, or -1
+     */
+    private scanDoctype;
+    /**
+     * Consume every complete token at the front of the buffer; an incomplete token at its end
+     * becomes the pending token (its text moved out of the buffer), a possibly split entity
+     * reference is held back in the buffer.
+     */
+    private scan;
+    /**
+     * Turn the incomplete markup at `pos` into a pending token, running the terminator scan over
+     * the part already in the buffer so later chunks are scanned alone.
+     * @param buffer - the buffer
+     * @param pos - the index of the `<`
+     * @returns the pending token
+     */
+    private startPending;
+    /**
+     * Consume the markup starting at `pos` (a `<`).
+     * @param pos - the index of the `<`
+     * @returns the index after the markup, or -1 when the buffer ends before the markup does
+     */
+    private consumeMarkup;
+    /**
+     * Parse a start tag at `pos`.
+     * @param pos - the index of the `<`
+     * @returns the tag, or null when the buffer ends inside it
+     */
+    private parseStartTag;
+    /**
+     * The end of the XML Name starting at `i` (an ASCII table for the common case, the code point
+     * classes beyond it).
+     * @param i - the start index
+     * @returns the index after the name; `i` when no name starts there; -1 when the name may
+     * continue past the end of the buffer
+     */
+    private readName;
+    /**
+     * Move text from the buffer into the current run.
+     * @param start - the start index
+     * @param end - the end index (exclusive)
+     */
+    private takeText;
+    /**
+     * Count the newlines of a consumed range. Ranges are consumed in order, so the next line break
+     * is searched for once per buffer and re-searched only after it was passed; a buffer without
+     * a further break is searched once and remembered as such.
+     * @param start - the start index
+     * @param end - the end index (exclusive)
+     */
+    private advanceLine;
+    /** Deliver the accumulated text run, if any. */
+    private flushText;
+    /**
+     * Open an element.
+     * @param name - the element name
+     * @param attrs - its attributes
+     */
+    private startElement;
+    /**
+     * Close an element, checking that it matches the innermost open one.
+     * @param name - the element name
+     */
+    private endElement;
+}
+//# sourceMappingURL=xml.d.ts.map

package/dist/src/common/xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../../src/common/xml.ts"],"names":[],"mappings":"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"}