@graphty/graph-io 0.3.38 → 0.3.40

package/src/common/export.ts

@@ -637,115 +637,208 @@ function checkColumns(
     note: NoteFn,
 ): void {
     for (const column of table) {
-        const { meta } = column;
-        const { name, role } = meta;
+        const { name, role } = column.meta;
         if (role !== null && STRUCTURAL_ROLES.has(role)) {
             continue;
         }
         const label = `${domain} column "${name}"`;
-        const roleNames = roleNamesOf(domain, extras);
-        if (role !== null && roleNames !== undefined) {
-            const fixed = roleNames[role];
-            if (fixed !== undefined && fixed !== name) {
-                note(
-                    LOSS.COLUMN_NAME_CHANGED,
-                    `${label} (the ${ROLE_WORDS[role] ?? role}) is written as the format's own ${role} and reads back as "${fixed}"`,
-                    name,
-                    column.length - column.nullCount,
-                );
-            }
-        }
+        noteRenamedRole(column, label, roleNamesOf(domain, extras), note);
         if (domain === "edge" && role === "id") {
             continue;
         }
-        const named = extras.writtenColumns?.[domain as "node" | "edge"]?.includes(name) ?? false;
-        if (
-            writesAttributes(domain, extras) === false &&
-            !named &&
-            !(role !== null && (extras.roles?.has(role) ?? false))
-        ) {
+        if (isDroppedColumn(column, domain, extras)) {
             note(LOSS.COLUMN_DROPPED, `${label} is not written`, name, column.length - column.nullCount);
             continue;
         }
-        if (role === "timeText") {
-            if (extras.temporalText !== true) {
-                note(
-                    LOSS.TEMPORAL_TEXT,
-                    `${label} (the original text of a date or time column) cannot be written`,
-                    name,
-                    column.length - column.nullCount,
-                );
-            }
-            continue;
-        }
-        if (role === "position") {
-            if (!caps.positions) {
-                note(LOSS.POSITIONS, `${label} (positions) cannot be written`, name, column.length - column.nullCount);
-            } else if (extras.positionDtype !== undefined && meta.dtype !== extras.positionDtype) {
-                note(
-                    LOSS.DTYPE,
-                    `${label} (positions) is ${meta.dtype}; the format reads positions back as ${extras.positionDtype}`,
-                    name,
-                    column.length - column.nullCount,
-                );
-            }
-            continue;
-        }
-        if (role !== null && VIZ_ROLES.has(role)) {
-            if (!caps.viz) {
-                note(LOSS.VIZ, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
-            }
-            continue;
-        }
-        if (role !== null && HIERARCHY_ROLES.has(role)) {
-            if (!caps.hierarchy) {
-                note(LOSS.HIERARCHY, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
-            }
-            continue;
-        }
-        if (role !== null && TEMPORAL_ROLES.has(role)) {
-            if (caps.temporal === "none") {
-                note(LOSS.TEMPORAL, `${label} (${role}) cannot be written`, name, column.length - column.nullCount);
-            }
-            continue;
-        }
-        if (role === "spells") {
-            if (caps.temporal !== "spells" && caps.temporal !== "dynamic-values") {
-                note(LOSS.SPELLS, `${label} (spells) cannot be written`, name, column.length - column.nullCount);
-            }
-            continue;
-        }
-        if (role === "open" || role === "spellsOpen") {
-            // The open bits are written by the format's own temporal syntax when it has one; the
-            // column's u8 storage is never an attribute dtype, so no dtype note either way.
-            if (extras.openIntervals !== true) {
-                note(
-                    LOSS.OPEN_INTERVAL,
-                    `${label} (open intervals) cannot be written`,
-                    name,
-                    column.length - column.nullCount,
-                );
-            }
-            continue;
-        }
-        if (role !== null && !(extras.roles?.has(role) ?? false)) {
-            note(
-                LOSS.ROLE,
-                `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost`,
-                name,
-                column.length - column.nullCount,
-            );
-        }
-        if (meta.dynamic && caps.temporal !== "dynamic-values") {
-            note(LOSS.DYNAMIC_VALUES, `${label} is dynamic; only its static value can be written`, name, null);
-        }
-        checkDtype(column, label, caps, note);
-        if (meta.default !== undefined && !caps.defaults) {
-            note(LOSS.DEFAULT, `${label} declares a default; the format has no defaults`, name, null);
+        if (!checkSlotRole(column, label, caps, extras, note)) {
+            checkAttributeColumn(column, label, caps, extras, note);
         }
-        if (meta.options !== null && !caps.options) {
-            note(LOSS.OPTIONS, `${label} declares options; the format has no enumerations`, name, null);
+    }
+}
+
+/**
+ * The note of a role column the format writes under its own fixed name.
+ * @param column - the column
+ * @param label - the column's label for messages
+ * @param roleNames - the format's fixed names per role, if any
+ * @param note - the recorder
+ */
+function noteRenamedRole(
+    column: Column,
+    label: string,
+    roleNames: Readonly<Record<string, string>> | undefined,
+    note: NoteFn,
+): void {
+    const { name, role } = column.meta;
+    if (role === null || roleNames === undefined) {
+        return;
+    }
+    const fixed = roleNames[role];
+    if (fixed !== undefined && fixed !== name) {
+        note(
+            LOSS.COLUMN_NAME_CHANGED,
+            `${label} (the ${ROLE_WORDS[role] ?? role}) is written as the format's own ${role} and reads back as "${fixed}"`,
+            name,
+            column.length - column.nullCount,
+        );
+    }
+}
+
+/**
+ * Whether a format that writes no attributes of this kind drops the column (it is neither named
+ * in CheckExtras.writtenColumns nor of a role the format has a slot for).
+ * @param column - the column
+ * @param domain - "node", "edge" or "graph"
+ * @param extras - format extras
+ * @returns true when the column is not written
+ */
+function isDroppedColumn(column: Column, domain: string, extras: CheckExtras): boolean {
+    const { name, role } = column.meta;
+    const named = extras.writtenColumns?.[domain as "node" | "edge"]?.includes(name) ?? false;
+    return (
+        writesAttributes(domain, extras) === false && !named && !(role !== null && (extras.roles?.has(role) ?? false))
+    );
+}
+
+/** How a format writes one slot role: what it loses when it cannot, and when it can. */
+interface SlotRule {
+    readonly code: string;
+    /** What the message calls the column; the role itself when absent. */
+    readonly what?: string;
+    readonly written: (caps: ExportCapabilities, extras: CheckExtras) => boolean;
+}
+
+/**
+ * The roles (other than position) a format writes in its own syntax rather than as an attribute.
+ * @returns the rules by role
+ */
+function slotRules(): ReadonlyMap<string, SlotRule> {
+    const rules = new Map<string, SlotRule>();
+    const add = (roles: Iterable<string>, rule: SlotRule): void => {
+        for (const role of roles) {
+            rules.set(role, rule);
         }
+    };
+    add(["timeText"], {
+        code: LOSS.TEMPORAL_TEXT,
+        what: "the original text of a date or time column",
+        written: (_caps, extras) => extras.temporalText === true,
+    });
+    add(VIZ_ROLES, { code: LOSS.VIZ, written: (caps) => caps.viz });
+    add(HIERARCHY_ROLES, { code: LOSS.HIERARCHY, written: (caps) => caps.hierarchy });
+    add(TEMPORAL_ROLES, { code: LOSS.TEMPORAL, written: (caps) => caps.temporal !== "none" });
+    add(["spells"], {
+        code: LOSS.SPELLS,
+        what: "spells",
+        written: (caps) => caps.temporal === "spells" || caps.temporal === "dynamic-values",
+    });
+    // The open bits are written by the format's own temporal syntax when it has one; the
+    // column's u8 storage is never an attribute dtype, so no dtype note either way.
+    add(["open", "spellsOpen"], {
+        code: LOSS.OPEN_INTERVAL,
+        what: "open intervals",
+        written: (_caps, extras) => extras.openIntervals === true,
+    });
+    return rules;
+}
+
+const SLOT_RULES = slotRules();
+
+/**
+ * The checks of a column whose role the format writes in its own syntax (positions, viz,
+ * hierarchy, temporal roles, spells, open intervals, original date text), not as an attribute.
+ * @param column - the column
+ * @param label - the column's label for messages
+ * @param caps - the capabilities
+ * @param extras - format extras
+ * @param note - the recorder
+ * @returns true when the role is one of those, so no attribute checks follow
+ */
+function checkSlotRole(
+    column: Column,
+    label: string,
+    caps: ExportCapabilities,
+    extras: CheckExtras,
+    note: NoteFn,
+): boolean {
+    const { name, role } = column.meta;
+    if (role === "position") {
+        checkPositionColumn(column, label, caps, extras, note);
+        return true;
+    }
+    const rule = role === null ? undefined : SLOT_RULES.get(role);
+    if (role === null || rule === undefined) {
+        return false;
+    }
+    if (!rule.written(caps, extras)) {
+        note(rule.code, `${label} (${rule.what ?? role}) cannot be written`, name, column.length - column.nullCount);
+    }
+    return true;
+}
+
+/**
+ * The checks of a position column: whether the format has positions, and their dtype.
+ * @param column - the column
+ * @param label - the column's label for messages
+ * @param caps - the capabilities
+ * @param extras - format extras
+ * @param note - the recorder
+ */
+function checkPositionColumn(
+    column: Column,
+    label: string,
+    caps: ExportCapabilities,
+    extras: CheckExtras,
+    note: NoteFn,
+): void {
+    const { meta } = column;
+    if (!caps.positions) {
+        note(LOSS.POSITIONS, `${label} (positions) cannot be written`, meta.name, column.length - column.nullCount);
+    } else if (extras.positionDtype !== undefined && meta.dtype !== extras.positionDtype) {
+        note(
+            LOSS.DTYPE,
+            `${label} (positions) is ${meta.dtype}; the format reads positions back as ${extras.positionDtype}`,
+            meta.name,
+            column.length - column.nullCount,
+        );
+    }
+}
+
+/**
+ * The checks of a column written as a plain attribute: a role the format has no slot for,
+ * dynamic values, the dtype, a declared default and declared options.
+ * @param column - the column
+ * @param label - the column's label for messages
+ * @param caps - the capabilities
+ * @param extras - format extras
+ * @param note - the recorder
+ */
+function checkAttributeColumn(
+    column: Column,
+    label: string,
+    caps: ExportCapabilities,
+    extras: CheckExtras,
+    note: NoteFn,
+): void {
+    const { meta } = column;
+    const { name, role } = meta;
+    if (role !== null && !(extras.roles?.has(role) ?? false)) {
+        note(
+            LOSS.ROLE,
+            `${label} (${role}) is written as a plain attribute; the format has no ${role} slot and the role is lost`,
+            name,
+            column.length - column.nullCount,
+        );
+    }
+    if (meta.dynamic && caps.temporal !== "dynamic-values") {
+        note(LOSS.DYNAMIC_VALUES, `${label} is dynamic; only its static value can be written`, name, null);
+    }
+    checkDtype(column, label, caps, note);
+    if (meta.default !== undefined && !caps.defaults) {
+        note(LOSS.DEFAULT, `${label} declares a default; the format has no defaults`, name, null);
+    }
+    if (meta.options !== null && !caps.options) {
+        note(LOSS.OPTIONS, `${label} declares options; the format has no enumerations`, name, null);
     }
 }
 

package/src/common/input.ts

@@ -1007,7 +1007,7 @@ export function throwIfAborted(signal: AbortSignal | null | undefined): void {
         throw abortError();
     }
     // the platform contract: the reason itself, whatever its type
-    throw reason as Error;
+    throw reason as Error; // NOSONAR(S3696): rethrows the abort signal's reason, as the platform does
 }
 
 /**

package/src/common/json-elements.ts

@@ -1493,10 +1493,11 @@ async function* blockElements(
  * @category Plugin helpers
  */
 export function reportTooDeep(report: ImportReportBuilder, event: Extract<AspectEvent, { kind: "deep" }>): void {
+    const what = event.aspect === null ? "a member of the document" : `an element of "${event.aspect}"`;
     report.error(
         "parse-error",
         BAD_ASPECT_BLOCK_CODE,
-        `${event.aspect === null ? "a member of the document" : `an element of "${event.aspect}"`} is nested ${event.depth} levels deep, more than the ${MAX_ELEMENT_DEPTH} a graph keeps; skipped`,
+        `${what} is nested ${event.depth} levels deep, more than the ${MAX_ELEMENT_DEPTH} a graph keeps; skipped`,
         { line: event.line, element: event.aspect },
     );
 }
@@ -1893,7 +1894,8 @@ export class CxStructure {
         }
         const error = typeof value.error === "string" ? value.error : "";
         if (value.success === false) {
-            const message = `the producer marked the document as failed${error.length > 0 ? `: ${error}` : ""}`;
+            const detail = error.length > 0 ? `: ${error}` : "";
+            const message = `the producer marked the document as failed${detail}`;
             this.report.error("validation-error", STATUS_FAILED_CODE, message, { line, element: "status" });
             throw this.report.abort(message, { code: STATUS_FAILED_CODE });
         }

package/src/common/xml.ts

@@ -416,7 +416,8 @@ export function decodeEntities(raw: string, line: number, repairs?: XmlRepairs):
             const digits = name.slice(hex ? 2 : 1);
             // XML 1.0 puts no limit on leading zeros (A is "A")
             const ok = hex ? /^0*[\da-fA-F]{1,6}$/.test(digits) : /^0*\d{1,7}$/.test(digits);
-            const cp = ok ? Number.parseInt(digits, hex ? 16 : 10) : -1;
+            const radix = hex ? 16 : 10;
+            const cp = ok ? Number.parseInt(digits, radix) : -1;
             const low = cp >= 0xd800 && cp <= 0xdbff ? lowSurrogateAfter(raw, semi + 1, repairs) : null;
             if (low !== null) {
                 repairs?.surrogatePair?.(lineAt(raw, amp, line));

package/src/formats/csv/records.ts

@@ -739,125 +739,169 @@ class RecordScanner {
      * @returns the position after the last character consumed
      */
     scan(chunk: string, from: number): number {
-        const { quoteCode, delimiterCode } = this;
+        const { delimiterCode } = this;
         const n = chunk.length;
         let i = from;
         this.segment = from;
         while (i < n) {
             const c = chunk.charCodeAt(i);
-            if (this.state === COMMENT) {
-                if (c === LF || c === CR) {
-                    this.comment = this.grow(this.comment, chunk.slice(this.segment, i));
-                    this.reader.leadingComments.push(this.comment);
-                    this.reader.leadingCommentLines.push(this.line);
-                    this.comment = "";
-                    this.state = START;
-                    this.endLine(c);
-                    this.segment = i + 1;
-                }
+            const { state } = this;
+            if (state === COMMENT) {
+                this.commentChar(chunk, i, c);
                 i++;
                 continue;
             }
-            if (this.state === QUOTED) {
-                // jump to the next quote; the run in between is field text whose line breaks are counted
-                const q = chunk.indexOf(this.quoteText, i);
-                const end = q < 0 ? n : q;
-                if (end > i) {
-                    this.countLineBreaks(chunk, i, end);
-                }
-                if (q < 0) {
-                    i = n;
-                    break;
-                }
-                this.field = this.grow(this.field, chunk.slice(this.segment, q));
-                this.state = CLOSING;
-                this.lastWasCr = false;
-                i = q + 1;
+            if (state === QUOTED) {
+                i = this.quotedRun(chunk, i);
                 continue;
             }
             const isDelimiter = c === delimiterCode || (this.collapse && c === TAB);
-            if (this.state === CLOSING) {
-                if (c === quoteCode) {
-                    this.field = this.grow(this.field, this.quoteText);
-                    this.segment = i + 1;
-                    this.state = QUOTED;
-                    this.lastWasCr = false;
-                    i++;
-                    continue;
-                }
-                if (!isDelimiter && c !== LF && c !== CR) {
-                    this.reader.badQuote(this.startLine, this.count + 1);
-                }
-                this.state = AFTER_QUOTED;
-                this.segment = i;
-                // fall through to the delimiter / line-end handling below without consuming c
-            }
-            if (isDelimiter || c === LF || c === CR) {
-                if (c === LF && this.lastWasCr) {
-                    // the second half of a CRLF already ended the record
-                    this.lastWasCr = false;
-                    this.segment = i + 1;
-                    i++;
-                    continue;
-                }
-                if (this.state === UNQUOTED) {
-                    this.field = this.grow(this.field, chunk.slice(this.segment, i));
-                }
-                if (isDelimiter && this.collapse && this.state === START) {
-                    // a run of whitespace, or indentation: one separator
-                    this.lastWasCr = false;
-                    this.segment = i + 1;
-                    i++;
-                    continue;
-                }
-                if (isDelimiter) {
-                    this.push();
-                    this.state = START;
-                    this.lastWasCr = false;
-                    this.segment = i + 1;
-                    i++;
-                    continue;
-                }
-                // a line ending right after a whitespace run in the whitespace dialect ends no field
-                if (!(this.state === START && (this.count === 0 || this.collapse))) {
-                    this.push();
-                }
-                if (this.count > 0) {
-                    this.ready = true;
-                    this.recordLine = this.startLine;
-                }
-                this.state = START;
-                this.endLine(c);
-                this.segment = i + 1;
-                i++;
+            if (state === CLOSING || isDelimiter || c === LF || c === CR) {
+                i = this.boundary(chunk, i, c, isDelimiter);
                 if (this.ready) {
                     return i;
                 }
                 continue;
             }
+            this.fieldChar(c, i);
+            i++;
+        }
+        return i;
+    }
+
+    /**
+     * One character of a leading comment line: a line break ends the comment.
+     * @param chunk - the chunk
+     * @param i - the character's index
+     * @param c - the character's code
+     */
+    private commentChar(chunk: string, i: number, c: number): void {
+        if (c !== LF && c !== CR) {
+            return;
+        }
+        this.comment = this.grow(this.comment, chunk.slice(this.segment, i));
+        this.reader.leadingComments.push(this.comment);
+        this.reader.leadingCommentLines.push(this.line);
+        this.comment = "";
+        this.state = START;
+        this.endLine(c);
+        this.segment = i + 1;
+    }
+
+    /**
+     * Inside a quoted field: jump to the next quote; the run in between is field text whose line
+     * breaks are counted.
+     * @param chunk - the chunk
+     * @param i - where the run starts
+     * @returns the position after the quote, or the chunk end when there is none
+     */
+    private quotedRun(chunk: string, i: number): number {
+        const q = chunk.indexOf(this.quoteText, i);
+        const end = q < 0 ? chunk.length : q;
+        if (end > i) {
+            this.countLineBreaks(chunk, i, end);
+        }
+        if (q < 0) {
+            return chunk.length;
+        }
+        this.field = this.grow(this.field, chunk.slice(this.segment, q));
+        this.state = CLOSING;
+        this.lastWasCr = false;
+        return q + 1;
+    }
+
+    /**
+     * The character after a quote inside a quoted field, a delimiter or a line break: a doubled
+     * quote, the end of a field, or the end of a record.
+     * @param chunk - the chunk
+     * @param i - the character's index
+     * @param c - the character's code
+     * @param isDelimiter - whether it separates fields
+     * @returns the position after the character
+     */
+    private boundary(chunk: string, i: number, c: number, isDelimiter: boolean): number {
+        if (this.state === CLOSING) {
+            if (c === this.quoteCode) {
+                this.field = this.grow(this.field, this.quoteText);
+                this.segment = i + 1;
+                this.state = QUOTED;
+                this.lastWasCr = false;
+                return i + 1;
+            }
+            if (!isDelimiter && c !== LF && c !== CR) {
+                this.reader.badQuote(this.startLine, this.count + 1);
+            }
+            this.state = AFTER_QUOTED;
+            this.segment = i;
+        }
+        if (c === LF && this.lastWasCr) {
+            // the second half of a CRLF already ended the record
             this.lastWasCr = false;
-            if (this.state === START) {
-                if (this.leading && this.count === 0 && this.commentCodes.includes(c)) {
-                    this.state = COMMENT;
-                    this.segment = i;
-                    i++;
-                    continue;
-                }
-                this.leading = false;
-                if (c === quoteCode) {
-                    this.state = QUOTED;
-                    this.fieldQuoted = true;
-                    this.segment = i + 1;
-                } else {
-                    this.state = UNQUOTED;
-                    this.segment = i;
-                }
-            } else if (c === quoteCode && this.state === UNQUOTED && this.reader.strayQuoteLine === 0) {
+            this.segment = i + 1;
+            return i + 1;
+        }
+        if (this.state === UNQUOTED) {
+            this.field = this.grow(this.field, chunk.slice(this.segment, i));
+        }
+        if (isDelimiter) {
+            // in the whitespace dialect a run of whitespace, or indentation, is one separator
+            if (!(this.collapse && this.state === START)) {
+                this.push();
+                this.state = START;
+            }
+            this.lastWasCr = false;
+            this.segment = i + 1;
+            return i + 1;
+        }
+        this.lineEnd(c);
+        this.segment = i + 1;
+        return i + 1;
+    }
+
+    /**
+     * A line break that ends a record (or a blank line).
+     * @param c - the LF or CR
+     */
+    private lineEnd(c: number): void {
+        // a line ending right after a whitespace run in the whitespace dialect ends no field
+        if (!(this.state === START && (this.count === 0 || this.collapse))) {
+            this.push();
+        }
+        if (this.count > 0) {
+            this.ready = true;
+            this.recordLine = this.startLine;
+        }
+        this.state = START;
+        this.endLine(c);
+    }
+
+    /**
+     * Any other character outside a quoted field: the start of a field or a comment, or field text.
+     * @param c - the character's code
+     * @param i - its index
+     */
+    private fieldChar(c: number, i: number): void {
+        this.lastWasCr = false;
+        if (this.state !== START) {
+            if (c === this.quoteCode && this.state === UNQUOTED && this.reader.strayQuoteLine === 0) {
                 this.reader.strayQuoteLine = this.startLine;
             }
-            i++;
+            return;
+        }
+        if (this.leading && this.count === 0 && this.commentCodes.includes(c)) {
+            this.state = COMMENT;
+            this.segment = i;
+            return;
+        }
+        this.leading = false;
+        if (c === this.quoteCode) {
+            this.state = QUOTED;
+            this.fieldQuoted = true;
+            this.segment = i + 1;
+        } else {
+            this.state = UNQUOTED;
+            this.segment = i;
         }
-        return i;
     }
 
     /**