@graphty/graph-io 0.3.40 → 0.3.41

package/src/formats/csv/importer.ts

@@ -575,6 +575,22 @@ function isUnset(text: string, quoted: boolean | undefined): boolean {
     return quoted !== true && isBlank(text);
 }
 
+/**
+ * The number of set neighbor cells of an adjacency row (every cell after the first).
+ * @param row - the cells
+ * @param quoted - whether each cell was quoted
+ * @returns the set neighbor cells
+ */
+function setNeighborCells(row: readonly string[], quoted: readonly boolean[]): number {
+    let neighbors = 0;
+    for (let k = 1; k < row.length; k++) {
+        if (!isUnset(row[k], quoted[k])) {
+            neighbors++;
+        }
+    }
+    return neighbors;
+}
+
 /** Rows between two checks of the cancellation signal on an in-memory input. */
 const ABORT_CHECK_INTERVAL = 64;
 
@@ -1520,12 +1536,7 @@ class TableReader {
         const { where } = this;
         where.line = line;
         where.element = null;
-        let neighbors = 0;
-        for (let k = 1; k < row.length; k++) {
-            if (!isUnset(row[k], quoted[k])) {
-                neighbors++;
-            }
-        }
+        const neighbors = setNeighborCells(row, quoted);
         if (isUnset(row[0], quoted[0])) {
             report.error("missing-value", MISSING_ID_CODE, `blank node cell`, { line });
             counts.skippedNodes++;

package/src/formats/csv/records.ts

@@ -410,16 +410,7 @@ export function sniffDelimiter(
         if (rows.length === 0) {
             continue;
         }
-        let total = 0;
-        let delta = 0;
-        for (let i = 0; i < rows.length; i++) {
-            const count = rows[i].length;
-            total += count;
-            if (i > 0) {
-                delta += Math.abs(count - rows[i - 1].length);
-            }
-        }
-        const average = total / rows.length;
+        const { average, delta } = rowWidths(rows);
         if (average > 1.99 && delta < bestDelta) {
             best = delimiter;
             bestDelta = delta;
@@ -428,6 +419,24 @@ export function sniffDelimiter(
     return best;
 }
 
+/**
+ * The average width of the rows and the sum of the width changes from each row to the next.
+ * @param rows - the rows (at least one)
+ * @returns the average and the delta
+ */
+function rowWidths(rows: readonly (readonly string[])[]): { average: number; delta: number } {
+    let total = 0;
+    let delta = 0;
+    for (let i = 0; i < rows.length; i++) {
+        const count = rows[i].length;
+        total += count;
+        if (i > 0) {
+            delta += Math.abs(count - rows[i - 1].length);
+        }
+    }
+    return { average: total / rows.length, delta };
+}
+
 /**
  * Whether a parsed row is a blank line: one cell holding only whitespace.
  * @param row - the row

package/src/formats/cys/tables.ts

@@ -217,24 +217,25 @@ export function cellAtt(
     namespace: string | null,
     hidden: boolean,
 ): AttRec | null {
+    const cell = { line, namespace, hidden };
     if (text.startsWith("=")) {
-        return att(column.name, column.list ? "List" : column.type, null, text, line, namespace, hidden, true);
+        return att(column.name, column.list ? "List" : column.type, null, text, true, cell);
     }
     if (!column.list) {
         if (text.length === 0 && column.type !== "String") {
             return null;
         }
-        return att(column.name, column.type, null, text, line, namespace, hidden, false);
+        return att(column.name, column.type, null, text, false, cell);
     }
     if (text.length === 0 && column.type !== "String") {
         return null;
     }
-    const list = att(column.name, "List", column.type, null, line, namespace, hidden, false);
+    const list = att(column.name, "List", column.type, null, false, cell);
     for (const item of javaSplitLines(text)) {
         if (item.length === 0 && column.type !== "String") {
             continue;
         }
-        list.children.push(att(column.name, column.type, null, item, line, namespace, hidden, false));
+        list.children.push(att(column.name, column.type, null, item, false, cell));
     }
     return list;
 }
@@ -262,10 +263,11 @@ function javaSplitLines(text: string): string[] {
  * @param cyType - the Cytoscape type
  * @param elementType - a list's item type, or null
  * @param value - the value, or null
- * @param line - the line
- * @param namespace - the table namespace, or null
- * @param hidden - a hidden column
  * @param equation - the value is a formula
+ * @param cell - where the cell sits
+ * @param cell.line - the line
+ * @param cell.namespace - the table namespace, or null
+ * @param cell.hidden - a hidden column
  * @returns the record
  */
 function att(
@@ -273,11 +275,10 @@ function att(
     cyType: string,
     elementType: string | null,
     value: string | null,
-    line: number,
-    namespace: string | null,
-    hidden: boolean,
     equation: boolean,
+    cell: { readonly line: number; readonly namespace: string | null; readonly hidden: boolean },
 ): AttRec {
+    const { line, namespace, hidden } = cell;
     return {
         name,
         type: null,

package/src/formats/gexf/exporter.ts

@@ -1247,6 +1247,27 @@ function lifetimeAttrs(roles: RoleColumns, row: number, plan: ExportPlan): strin
     return out;
 }
 
+/**
+ * The `start` and `end` attributes of one `<spell>`.
+ * @param s - the start, or a non-finite value for an unbounded start
+ * @param e - the end, or a non-finite value for an unbounded end
+ * @param open - the open-bound bits
+ * @param plan - the plan
+ * @returns the attribute text, each with a leading space
+ */
+function spellBounds(s: number, e: number, open: number, plan: ExportPlan): string {
+    let attrs = "";
+    if (Number.isFinite(s)) {
+        const name = (open & OPEN_START) === 0 ? "start" : "startopen";
+        attrs += ` ${name}="${escapeXmlAttribute(formatTimeValue(s, plan.timeFormat))}"`;
+    }
+    if (Number.isFinite(e)) {
+        const name = (open & OPEN_END) === 0 ? "end" : "endopen";
+        attrs += ` ${name}="${escapeXmlAttribute(formatTimeValue(e, plan.timeFormat))}"`;
+    }
+    return attrs;
+}
+
 /**
  * The `<spells>` element of one element: its spells column, plus (1.2) its timestamps as [t, t].
  * In 1.2 a spell whose spells.open bits mark a bound open writes that bound as `startopen` /
@@ -1276,16 +1297,7 @@ function spellsElement(roles: RoleColumns, row: number, plan: ExportPlan, indent
     }
     let out = `${indent}<spells>\n`;
     for (const [s, e, open] of pairs) {
-        let attrs = "";
-        if (Number.isFinite(s)) {
-            const name = (open & OPEN_START) === 0 ? "start" : "startopen";
-            attrs += ` ${name}="${escapeXmlAttribute(formatTimeValue(s, plan.timeFormat))}"`;
-        }
-        if (Number.isFinite(e)) {
-            const name = (open & OPEN_END) === 0 ? "end" : "endopen";
-            attrs += ` ${name}="${escapeXmlAttribute(formatTimeValue(e, plan.timeFormat))}"`;
-        }
-        out += `${indent}  <spell${attrs}/>\n`;
+        out += `${indent}  <spell${spellBounds(s, e, open, plan)}/>\n`;
     }
     return `${out}${indent}</spells>\n`;
 }
@@ -1676,23 +1688,12 @@ function metaElement(meta: GraphSnapshot["meta"]): string {
 }
 
 /**
- * The `<graph>` start tag with its header attributes.
+ * The `idtype` attribute of the `<graph>` tag.
  * @param snapshot - the snapshot
- * @param plan - the plan
- * @returns the line
+ * @returns the attribute text with a leading space, or an empty string
  */
-function graphStart(snapshot: GraphSnapshot, plan: ExportPlan): string {
-    const { meta } = snapshot;
-    let attrs = ` defaultedgetype="${defaultEdgeType(snapshot)}"`;
-    let mode = meta.mode ?? "static";
-    if (plan.temporal && mode === "static") {
-        mode = "dynamic";
-    }
-    if (plan.version === "1.2" && mode === "slice") {
-        mode = "dynamic";
-    }
-    attrs += ` mode="${mode}"`;
-    let { idType } = meta;
+function graphIdTypeAttr(snapshot: GraphSnapshot): string {
+    let { idType } = snapshot.meta;
     if (idType === null) {
         const { kind } = snapshot.ids;
         if (kind === "string") {
@@ -1701,17 +1702,16 @@ function graphStart(snapshot: GraphSnapshot, plan: ExportPlan): string {
             idType = "integer";
         }
     }
-    if (idType === "integer" || idType === "string") {
-        attrs += ` idtype="${idType}"`;
-    }
-    if (plan.timeFormat !== null) {
-        attrs += ` timeformat="${plan.timeFormat}"`;
-    } else if (plan.temporal) {
-        attrs += ' timeformat="double"';
-    }
-    if (plan.version === "1.3" && plan.timeRepresentation !== null) {
-        attrs += ` timerepresentation="${plan.timeRepresentation}"`;
-    }
+    return idType === "integer" || idType === "string" ? ` idtype="${idType}"` : "";
+}
+
+/**
+ * The `start`, `end` and `timestamp` attributes of the `<graph>` tag.
+ * @param snapshot - the snapshot
+ * @param plan - the plan
+ * @returns the attribute text with leading spaces, or an empty string
+ */
+function graphHeaderAttrs(snapshot: GraphSnapshot, plan: ExportPlan): string {
     const timestamp = graphExtraText(snapshot, "timestamp");
     const header: Record<string, string | null> = {
         start: graphExtraText(snapshot, "start"),
@@ -1724,11 +1724,42 @@ function graphStart(snapshot: GraphSnapshot, plan: ExportPlan): string {
         header.end ??= timestamp;
         header.timestamp = null;
     }
+    let attrs = "";
     for (const [key, value] of Object.entries(header)) {
         if (value !== null) {
             attrs += ` ${key}="${escapeXmlAttribute(value)}"`;
         }
     }
+    return attrs;
+}
+
+/**
+ * The `<graph>` start tag with its header attributes.
+ * @param snapshot - the snapshot
+ * @param plan - the plan
+ * @returns the line
+ */
+function graphStart(snapshot: GraphSnapshot, plan: ExportPlan): string {
+    const { meta } = snapshot;
+    let attrs = ` defaultedgetype="${defaultEdgeType(snapshot)}"`;
+    let mode = meta.mode ?? "static";
+    if (plan.temporal && mode === "static") {
+        mode = "dynamic";
+    }
+    if (plan.version === "1.2" && mode === "slice") {
+        mode = "dynamic";
+    }
+    attrs += ` mode="${mode}"`;
+    attrs += graphIdTypeAttr(snapshot);
+    if (plan.timeFormat !== null) {
+        attrs += ` timeformat="${plan.timeFormat}"`;
+    } else if (plan.temporal) {
+        attrs += ' timeformat="double"';
+    }
+    if (plan.version === "1.3" && plan.timeRepresentation !== null) {
+        attrs += ` timerepresentation="${plan.timeRepresentation}"`;
+    }
+    attrs += graphHeaderAttrs(snapshot, plan);
     return `  <graph${attrs}>\n`;
 }
 

package/src/formats/gexf/importer.ts

@@ -1328,20 +1328,15 @@ class GexfReader implements XmlHandler {
     }
 
     /**
-     * Declare one `<attribute id title type>` with its `<default>` and `<options>` (design
-     * sections 5.1, 5.5, 5.6). The edge attribute titled `weightFrom` is the weight and gets no
-     * column; its declaration is recorded in meta.weightOrigin.
-     * @param pending - the attribute as read
+     * Whether an attribute was already declared (warning that the first declaration is kept), and
+     * a warning when values that use it came before its declaration.
+     * @param domain - node or edge
+     * @param id - the attribute id
+     * @param where - the report location
+     * @returns true when the declaration is a duplicate and must be skipped
      */
-    private declareOne(pending: PendingAttribute): void {
-        const { report, sink, options } = this;
-        const { domain, dynamic, attrs } = pending;
-        const id = attrs.get("id");
-        const where = { line: pending.line, element: id ?? null };
-        if (id === undefined) {
-            report.error("validation-error", ATTRIBUTE_ID_CODE, "<attribute> without an id", where);
-            return;
-        }
+    private isDuplicateAttribute(domain: "node" | "edge", id: string, where: IssueLocation): boolean {
+        const { report } = this;
         const tracked = domain === "node" ? this.nodeAttrs : this.edgeAttrs;
         if (tracked.has(id) || (domain === "edge" && this.weightAttr !== null && this.weightAttr.id === id)) {
             report.warning(
@@ -1350,7 +1345,7 @@ class GexfReader implements XmlHandler {
                 `${domain} attribute "${id}" is declared twice; the first declaration is kept`,
                 where,
             );
-            return;
+            return true;
         }
         if (this.unknownAttributes.has(`${domain}:${id}`)) {
             report.warning(
@@ -1360,6 +1355,68 @@ class GexfReader implements XmlHandler {
                 where,
             );
         }
+        return false;
+    }
+
+    /**
+     * Whether an edge attribute becomes THE weight: the first attribute of the weight's title does
+     * (declared here), a later one only warns and stays a plain column.
+     * @param attribute - the attribute's domain, id, display name, title and type
+     * @param attribute.domain - node or edge
+     * @param attribute.id - the attribute id
+     * @param attribute.name - the column name
+     * @param attribute.title - the declared title, or null
+     * @param attribute.type - the declared type, or null
+     * @param where - the report location
+     * @returns true when the attribute was declared as the weight
+     */
+    private claimsWeight(
+        attribute: { domain: "node" | "edge"; id: string; name: string; title: string | null; type: string | null },
+        where: IssueLocation,
+    ): boolean {
+        const { report, sink, options } = this;
+        const { domain, id, name, title, type } = attribute;
+        if (domain !== "edge" || !isWeightField(name, options.weightFrom)) {
+            return false;
+        }
+        if (this.weightAttr !== null) {
+            // the first attribute of that title stays THE weight; this one becomes a plain column
+            report.warning(
+                "validation-error",
+                DUPLICATE_ATTRIBUTE_CODE,
+                `edge attribute "${id}" is also titled ${name}; attribute "${this.weightAttr.id}" is the weight, "${id}" is kept as a column`,
+                where,
+            );
+            return false;
+        }
+        const declared = declareAttribute({ format: GEXF_FORMAT, id, title, type, long: options.long });
+        for (const issue of declared.issues) {
+            report.warning(issue.category, issue.code, issue.message, where);
+        }
+        this.weightAttr = { id, spec: declared.spec, table: INVALID_INDEX as ExtensionHandle };
+        sink.setMeta({ weightOrigin: { format: GEXF_FORMAT, id, title, type, namespace: null } });
+        return true;
+    }
+
+    /**
+     * Declare one `<attribute id title type>` with its `<default>` and `<options>` (design
+     * sections 5.1, 5.5, 5.6). The edge attribute titled `weightFrom` is the weight and gets no
+     * column; its declaration is recorded in meta.weightOrigin.
+     * @param pending - the attribute as read
+     */
+    private declareOne(pending: PendingAttribute): void {
+        const { report, sink, options } = this;
+        const { domain, dynamic, attrs } = pending;
+        const id = attrs.get("id");
+        const where = { line: pending.line, element: id ?? null };
+        if (id === undefined) {
+            report.error("validation-error", ATTRIBUTE_ID_CODE, "<attribute> without an id", where);
+            return;
+        }
+        const tracked = domain === "node" ? this.nodeAttrs : this.edgeAttrs;
+        if (this.isDuplicateAttribute(domain, id, where)) {
+            return;
+        }
         const title = attrs.get("title") ?? null;
         const type = attrs.get("type") ?? null;
         if (type === null) {
@@ -1371,21 +1428,7 @@ class GexfReader implements XmlHandler {
             );
         }
         const name = title !== null && title.length > 0 ? title : id;
-        if (domain === "edge" && this.weightAttr !== null && isWeightField(name, options.weightFrom)) {
-            // the first attribute of that title stays THE weight; this one becomes a plain column
-            report.warning(
-                "validation-error",
-                DUPLICATE_ATTRIBUTE_CODE,
-                `edge attribute "${id}" is also titled ${name}; attribute "${this.weightAttr.id}" is the weight, "${id}" is kept as a column`,
-                where,
-            );
-        } else if (domain === "edge" && isWeightField(name, options.weightFrom)) {
-            const declared = declareAttribute({ format: GEXF_FORMAT, id, title, type, long: options.long });
-            for (const issue of declared.issues) {
-                report.warning(issue.category, issue.code, issue.message, where);
-            }
-            this.weightAttr = { id, spec: declared.spec, table: INVALID_INDEX as ExtensionHandle };
-            sink.setMeta({ weightOrigin: { format: GEXF_FORMAT, id, title, type, namespace: null } });
+        if (this.claimsWeight({ domain, id, name, title, type }, where)) {
             return;
         }
         const declaredNames = domain === "node" ? this.declaredNodeNames : this.declaredEdgeNames;
@@ -1717,6 +1760,15 @@ class GexfReader implements XmlHandler {
                 report.recordError(err, ref.where);
             }
         }
+        this.resolveParentsLists(lists);
+    }
+
+    /**
+     * Resolve the `<parents>` lists read so far into the parents column.
+     * @param lists - the queued `<parents>` lists
+     */
+    private resolveParentsLists(lists: readonly (typeof this.parentsRefs)[number][]): void {
+        const { sink, report } = this;
         for (const ref of lists) {
             const indices: number[] = [];
             for (const id of ref.ids) {
@@ -1763,7 +1815,7 @@ class GexfReader implements XmlHandler {
      * @param line - the line
      */
     private beginEdge(attrs: ReadonlyMap<string, string>, line: number): void {
-        const { report, sink, options } = this;
+        const { report, sink } = this;
         this.checkAbort();
         this.ctx.push(Ctx.Edge);
         this.edge = null;
@@ -1816,18 +1868,7 @@ class GexfReader implements XmlHandler {
         try {
             const source = this.coerceId(sourceText, where);
             const target = this.coerceId(targetText, where);
-            if (!options.addMissingNodes) {
-                if (sink.indexOf(source) === INVALID_INDEX) {
-                    throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${sourceText}"`, {
-                        id: source,
-                    });
-                }
-                if (sink.indexOf(target) === INVALID_INDEX) {
-                    throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${targetText}"`, {
-                        id: target,
-                    });
-                }
-            }
+            this.requireDeclaredEndpoints(source, target, sourceText, targetText);
             const weight = this.xmlWeight(attrs, where);
             const before = sink.edgeCount;
             index = this.resolver.addEdge(source, target, kind, weight, where);
@@ -1846,6 +1887,47 @@ class GexfReader implements XmlHandler {
         frame.mirror = this.resolver.lastMirror;
         frame.xmlWeight = attrs.get("weight") ?? null;
         this.edge = frame;
+        this.writeEdgeColumns(attrs, index, idText, where);
+    }
+
+    /**
+     * Throw when addMissingNodes is off and an endpoint names an undeclared node.
+     * @param source - the coerced source id
+     * @param target - the coerced target id
+     * @param sourceText - the source as written
+     * @param targetText - the target as written
+     */
+    private requireDeclaredEndpoints(source: NodeId, target: NodeId, sourceText: string, targetText: string): void {
+        const { sink, options } = this;
+        if (options.addMissingNodes) {
+            return;
+        }
+        if (sink.indexOf(source) === INVALID_INDEX) {
+            throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${sourceText}"`, {
+                id: source,
+            });
+        }
+        if (sink.indexOf(target) === INVALID_INDEX) {
+            throw new GraphFormatError("E_UNKNOWN_NODE", `edge references undeclared node "${targetText}"`, {
+                id: target,
+            });
+        }
+    }
+
+    /**
+     * Write the id, label, kind and lifetime columns of an added edge; a failure is reported.
+     * @param attrs - the edge's attributes
+     * @param index - the edge's index
+     * @param idText - the edge's id, or undefined
+     * @param where - the edge's location
+     */
+    private writeEdgeColumns(
+        attrs: ReadonlyMap<string, string>,
+        index: number,
+        idText: string | undefined,
+        where: IssueLocation,
+    ): void {
+        const { report, sink } = this;
         try {
             if (idText !== undefined) {
                 this.edgeIdColumn.set(sink, report, index, idText, where);
@@ -2555,35 +2637,18 @@ class GexfReader implements XmlHandler {
                 case "color":
                     columns.color.set(sink, report, index, parseColor(attrs), where);
                     break;
-                case "position": {
-                    const x = vizNumber(attrs, "x");
-                    const y = vizNumber(attrs, "y");
-                    const z = attrs.has("z") ? vizNumber(attrs, "z") : 0;
-                    this.positionColumn ??= new LazyColumn("node", {
-                        ...NODE_DECLS.position,
-                        extra: { ...NODE_DECLS.position.extra, sourceDims: attrs.has("z") ? 3 : 2 },
-                    });
-                    this.positionColumn.set(sink, report, index, [x, y, z], where);
+                case "position":
+                    this.writePosition(attrs, index, where);
                     break;
-                }
                 case "size":
                     this.sizeColumn.set(sink, report, index, vizNumber(attrs, "value"), where);
                     break;
                 case "thickness":
                     this.thicknessColumn.set(sink, report, index, vizNumber(attrs, "value"), where);
                     break;
-                case "shape": {
-                    const value = attrs.get("value");
-                    if (value === undefined) {
-                        throw new GraphFormatError("E_COLUMN_TYPE", "<viz:shape> without a value", { element: name });
-                    }
-                    columns.shape.set(sink, report, index, value, where);
-                    const uri = attrs.get("uri");
-                    if (domain === "node" && uri !== undefined) {
-                        this.shapeUriColumn.set(sink, report, index, uri, where);
-                    }
+                case "shape":
+                    this.writeShape(name, attrs, domain, index, where);
                     break;
-                }
                 default:
                     break;
             }
@@ -2595,6 +2660,51 @@ class GexfReader implements XmlHandler {
         }
     }
 
+    /**
+     * Write a `<viz:position>`.
+     * @param attrs - its attributes
+     * @param index - the node's index
+     * @param where - the node's location
+     */
+    private writePosition(attrs: ReadonlyMap<string, string>, index: number, where: IssueLocation): void {
+        const x = vizNumber(attrs, "x");
+        const y = vizNumber(attrs, "y");
+        const z = attrs.has("z") ? vizNumber(attrs, "z") : 0;
+        this.positionColumn ??= new LazyColumn("node", {
+            ...NODE_DECLS.position,
+            extra: { ...NODE_DECLS.position.extra, sourceDims: attrs.has("z") ? 3 : 2 },
+        });
+        this.positionColumn.set(this.sink, this.report, index, [x, y, z], where);
+    }
+
+    /**
+     * Write a `<viz:shape>` and, on a node, its `uri`.
+     * @param name - the element name as written
+     * @param attrs - its attributes
+     * @param domain - node or edge
+     * @param index - the element's index
+     * @param where - the element's location
+     */
+    private writeShape(
+        name: string,
+        attrs: ReadonlyMap<string, string>,
+        domain: "node" | "edge",
+        index: number,
+        where: IssueLocation,
+    ): void {
+        const { sink, report } = this;
+        const columns = domain === "node" ? this.nodeColumns : this.edgeColumns;
+        const value = attrs.get("value");
+        if (value === undefined) {
+            throw new GraphFormatError("E_COLUMN_TYPE", "<viz:shape> without a value", { element: name });
+        }
+        columns.shape.set(sink, report, index, value, where);
+        const uri = attrs.get("uri");
+        if (domain === "node" && uri !== undefined) {
+            this.shapeUriColumn.set(sink, report, index, uri, where);
+        }
+    }
+
     // ---------------------------------------------------------------- helpers
 
     /**