@graphty/graph-io 0.3.42 → 0.3.44

package/src/formats/xgmml/columns.ts

@@ -12,7 +12,7 @@ import { declareResolved, DictHeuristic, uniqueColumnName } from "../../common/a
 import { type ImportReportBuilder, type IssueLocation } from "../../common/report.js";
 import { inferTextDtype, parseTextCell } from "../../common/text.js";
 import { CYTOSCAPE_ORIGIN_NAMESPACE, FORMAT, XGMML_ISSUE } from "./constants.js";
-import { type AttRec, isListLike } from "./document.js";
+import { type AttRec, attTree } from "./document.js";
 import { attType, elementKind, parseScalar, type ScalarKind, widenScalar } from "./values.js";
 
 /** A table of the snapshot. */
@@ -153,6 +153,14 @@ export class ColumnSet {
             if (cell !== null) {
                 plan.declared.add("string");
             }
+        } else if ((type.kind === "list" || type.kind === "map") && deeperThan(att, MAX_JSON_ATT_DEPTH)) {
+            // a json value that deep cannot be written as JSON text (or read back) without overflowing the stack
+            this.badAtt(
+                `"${name}" is nested more than ${String(MAX_JSON_ATT_DEPTH)} atts deep; it is skipped`,
+                att,
+                "depth",
+            );
+            cell = null;
         } else if (type.kind === "list") {
             cell = this.listCell(att, name, plan, at);
             plan.declared.add("list");
@@ -698,19 +706,41 @@ function recordOf(att: AttRec): Record<string, unknown> {
     return out;
 }
 
+/** The deepest list or map att kept, as a json value. */
+const MAX_JSON_ATT_DEPTH = 64;
+
+/**
+ * Whether an att tree is deeper than a limit, walked with an explicit stack.
+ * @param root - the att
+ * @param limit - the most levels allowed
+ * @returns true when deeper
+ */
+function deeperThan(root: AttRec, limit: number): boolean {
+    const stack: [AttRec, number][] = [[root, 1]];
+    for (let top = stack.pop(); top !== undefined; top = stack.pop()) {
+        const [att, depth] = top;
+        if (depth > limit) {
+            return true;
+        }
+        for (const child of att.children) {
+            stack.push([child, depth + 1]);
+        }
+    }
+    return false;
+}
+
 /**
- * An att as a json value: its value text, its children as an array or a record, or its XML.
+ * An att as a json value: its XML, its value text, or its children as an array or a record.
  * @param att - the att
  * @returns the value
  */
 function jsonOfAtt(att: AttRec): unknown {
-    if (att.xml !== null) {
-        return att.xml;
-    }
-    if (att.children.length === 0) {
-        return att.value;
-    }
-    return isListLike(att) ? att.children.map(jsonOfAtt) : recordOf(att);
+    return attTree(att, (a) => {
+        if (a.xml !== null) {
+            return { value: a.xml };
+        }
+        return a.children.length === 0 ? { value: a.value } : null;
+    });
 }
 
 /**

package/src/formats/xgmml/constants.ts

@@ -50,6 +50,7 @@ import {
     WEIGHT_KEY_CLASH_CODE,
     WIDENED_CODE,
     XML_ILLEGAL_CHAR_CODE,
+    XML_NESTING_CODE,
     XML_SYNTAX_CODE,
 } from "../../common/codes.js";
 
@@ -190,6 +191,8 @@ export const XGMML_ISSUE = Object.freeze({
     ...ELEMENT_ISSUE,
     /** The input is not well-formed XML. The import stops. */
     XML_SYNTAX: XML_SYNTAX_CODE,
+    /** Elements are nested more than 100,000 deep. The import stops. */
+    XML_NESTING: XML_NESTING_CODE,
     /** The input is empty or whitespace only. The import stops. */
     EMPTY_INPUT: EMPTY_INPUT_CODE,
     /** The input is not valid UTF-8. The import stops. */

package/src/formats/xgmml/document.ts

@@ -1046,7 +1046,19 @@ export class XgmmlParser implements XmlHandler {
         if (target.graphics !== null && att.name in target.graphics) {
             this.duplicateGraphics(att.name, att.line);
         }
-        target.graphics = { ...target.graphics, [att.name]: attJson(att) };
+        // in place: beginGraphics() gave the target its own record, and a copy per att cost the square of a node's
+        // att count. An att named __proto__ is defined, not assigned, so it stays an own property
+        const graphics = (target.graphics ??= {});
+        if (att.name === "__proto__") {
+            Object.defineProperty(graphics, att.name, {
+                value: attJson(att),
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        } else {
+            graphics[att.name] = attJson(att);
+        }
     }
 
     /**
@@ -1072,7 +1084,7 @@ export class XgmmlParser implements XmlHandler {
  * @returns true for a list
  * @category Plugin helpers
  */
-export function isListLike(att: AttRec): boolean {
+function isListLike(att: AttRec): boolean {
     const names = new Set(att.children.map((c) => c.name));
     if (names.size !== 1) {
         return false;
@@ -1090,18 +1102,48 @@ export function isListLike(att: AttRec): boolean {
  * @category Plugin helpers
  */
 export function attJson(att: AttRec): unknown {
-    if (att.children.length === 0) {
-        if (att.value !== null) {
-            return att.value;
+    return attTree(att, (a) => {
+        if (a.children.length > 0) {
+            return null;
         }
-        return Object.keys(att.extra).length > 0 ? { ...att.extra } : null;
-    }
-    if (isListLike(att)) {
-        return att.children.map(attJson);
+        if (a.value !== null) {
+            return { value: a.value };
+        }
+        return { value: Object.keys(a.extra).length > 0 ? { ...a.extra } : null };
+    });
+}
+
+/**
+ * An att tree as plain data, walked with an explicit stack so an att nested any depth deep cannot overflow the
+ * call stack: an att `leafOf` gives a value for is that value; any other is an array of its children when they are
+ * list items (isListLike), else a record of them by name.
+ * @param root - the att
+ * @param leafOf - the value of an att that is a leaf, or null for one whose children make its value
+ * @returns the value
+ * @category Plugin helpers
+ */
+export function attTree(root: AttRec, leafOf: (att: AttRec) => { readonly value: unknown } | null): unknown {
+    const rootLeaf = leafOf(root);
+    if (rootLeaf !== null) {
+        return rootLeaf.value;
     }
-    const out: Record<string, unknown> = {};
-    for (const child of att.children) {
-        out[child.name ?? ""] = attJson(child);
+    const container = (att: AttRec): unknown[] | Record<string, unknown> => (isListLike(att) ? [] : {});
+    const out = container(root);
+    const stack: [AttRec, unknown[] | Record<string, unknown>][] = [[root, out]];
+    for (let top = stack.pop(); top !== undefined; top = stack.pop()) {
+        const [att, into] = top;
+        for (const child of att.children) {
+            const leaf = leafOf(child);
+            const value = leaf === null ? container(child) : leaf.value;
+            if (Array.isArray(into)) {
+                into.push(value);
+            } else {
+                into[child.name ?? ""] = value;
+            }
+            if (leaf === null) {
+                stack.push([child, value as unknown[] | Record<string, unknown>]);
+            }
+        }
     }
     return out;
 }

package/src/formats/xgmml/emit.ts

@@ -15,6 +15,7 @@ import { type ResolvedImportOptions } from "../../common/options.js";
 import { agree, plural } from "../../common/plural.js";
 import { type ImportReportBuilder, type IssueLocation } from "../../common/report.js";
 import { parseWeightText } from "../../common/weights.js";
+import { flipY } from "../../positions/convert.js";
 import { ColumnSet } from "./columns.js";
 import {
     CYTOSCAPE_ORIGIN_NAMESPACE,
@@ -1419,10 +1420,15 @@ class JsonColumn {
             return;
         }
         const sink = this.emitter.target;
-        if (this.domain === "node") {
-            sink.setNodeValue(this.handle, index, value);
-        } else {
-            sink.setEdgeValue(this.handle, index, value);
+        try {
+            if (this.domain === "node") {
+                sink.setNodeValue(this.handle, index, value);
+            } else {
+                sink.setEdgeValue(this.handle, index, value);
+            }
+        } catch (err) {
+            // a value the sink refuses (graphics nested deeper than a json cell holds) leaves the cell unset
+            this.emitter.issues.recordError(err, { element: this.name });
         }
     }
 }
@@ -1468,8 +1474,7 @@ class Positions {
             }
         }
         if (x !== null && y !== null) {
-            const flipped = y === 0 ? 0 : -y;
-            this.values.set(row.index, [x, flipped, this.zAs === "position" ? (z ?? 0) : 0]);
+            this.values.set(row.index, [x, flipY(y), this.zAs === "position" ? (z ?? 0) : 0]);
         }
     }
 

package/src/formats/xgmml/exporter.ts

@@ -8,7 +8,9 @@
  * and nested atts, containment as each group node's nested graph of `xlink:href` member
  * references (every node is declared at the top level, so the node order survives), and newline
  * and tab as character references unless `cytoscapeEscapes` asks for Cytoscape's two-character
- * form. It writes the graph's structure and columns, never styles.
+ * form. It writes the graph's structure and columns; given styles (`exportGraph(..., { styles })`), every element's
+ * `<graphics>` holds what graphty draws as Cytoscape visual properties, and the `graphty.styles` block and the
+ * style values its rules read go into graph and element `<att>`s.
  */
 
 import { type Column, GraphFormatError, type GraphSnapshot } from "@graphty/graph-format";
@@ -24,6 +26,7 @@ import { agree, plural } from "../../common/plural.js";
 import { type ExplicitWeights, explicitWeights } from "../../common/weights.js";
 import { encodeChunks, joinText } from "../../common/writer.js";
 import { xmlIllegalTextNotes } from "../../common/xml.js";
+import type { ExporterStyleInput, ExporterStyleOptions } from "../../styles/io/writer.js";
 import { type CommonExportOptions, type ExportCapabilities, type GraphExporter, type LossNote } from "../../types.js";
 import {
     CY_NAMESPACE,
@@ -48,6 +51,10 @@ import {
     Z_COLUMN,
 } from "./constants.js";
 import { aliasesOf } from "./emit.js";
+import { styledGraphGraphics, styledGraphics, styledGraphicsNotes, XGMML_STYLE_CAPABILITIES } from "./styles.js";
+
+/** What the writer takes: the format's options, the common ones and the styles. */
+type XgmmlWriteOptions = XgmmlExportOptions & CommonExportOptions & ExporterStyleOptions;
 
 /** The two escapes Cytoscape reads back as a newline and a tab, as a message writes them. */
 const LITERAL_ESCAPES = String.raw`\n or \t`;
@@ -1089,6 +1096,7 @@ function* groupAttOf(
  * @param plan - the plan
  * @param node - the node
  * @param indent - the indentation
+ * @param styles - the styles being written, or undefined
  * @yields the node element
  * @returns nothing
  */
@@ -1097,6 +1105,7 @@ function* nodeOf(
     plan: Plan,
     node: number,
     indent: string,
+    styles: ExporterStyleInput | undefined,
 ): Generator<string, void, undefined> {
     const labelCol = slot(plan.nodes, "label");
     const label = cellOf(labelCol, node);
@@ -1115,7 +1124,8 @@ function* nodeOf(
     } else if (typeof pointer === "string") {
         yield `${inner}<att>\n${inner}    <graph xlink:href="${escapeXmlAttribute(pointer)}"/>\n${inner}</att>\n`;
     }
-    const graphics = cellOf(slot(plan.nodes, "graphics"), node) as Record<string, unknown> | null;
+    const kept = cellOf(slot(plan.nodes, "graphics"), node) as Record<string, unknown> | null;
+    const graphics = styles === undefined ? kept : styledGraphics("node", styles, node, kept);
     yield* graphicsOf(graphics, coordsOf(plan, slot(plan.nodes, "z"), node), inner);
     yield `${indent}</node>\n`;
 }
@@ -1128,11 +1138,9 @@ function* nodeOf(
  * @yields the XML text
  * @returns nothing
  */
-function* write(
-    snapshot: GraphSnapshot,
-    options: (XgmmlExportOptions & CommonExportOptions) | undefined,
-): Generator<string, void, undefined> {
+function* write(snapshot: GraphSnapshot, options: XgmmlWriteOptions | undefined): Generator<string, void, undefined> {
     const plan = planFor(snapshot, options);
+    const styles = options?.styles;
     const meta = snapshot.meta.extra[META_KEY] as { graphId?: unknown; directed?: unknown } | undefined;
     const graphId = typeof meta?.graphId === "string" ? ` id="${escapeXmlAttribute(meta.graphId)}"` : "";
     // Every edge carries cy:directed, so when they all agree the root attribute does not decide
@@ -1150,12 +1158,13 @@ function* write(
     yield `<graph${graphId}${name} directed="${directed}" cy:documentVersion="3.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xlink="${XLINK_NAMESPACE}" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:cy="${CY_NAMESPACE}" xmlns="${XGMML_NAMESPACE}">\n`;
     yield* metadataOf(snapshot);
     yield* attsOf(plan.graph, 0, true, plan, "    ");
-    yield* graphicsOf(cellOf(slot(plan.graph, "graphics"), 0) as Record<string, unknown> | null, [], "    ");
+    const graphGraphics = cellOf(slot(plan.graph, "graphics"), 0) as Record<string, unknown> | null;
+    yield* graphicsOf(styles === undefined ? graphGraphics : styledGraphGraphics(styles, graphGraphics), [], "    ");
     for (let u = 0; u < snapshot.nodeCount; u++) {
-        yield* nodeOf(snapshot, plan, u, "    ");
+        yield* nodeOf(snapshot, plan, u, "    ", styles);
     }
     yield* networksOf(snapshot, plan);
-    yield* edgesOf(snapshot, plan);
+    yield* edgesOf(snapshot, plan, styles);
     yield "</graph>\n";
 }
 
@@ -1216,10 +1225,15 @@ function* networksOf(snapshot: GraphSnapshot, plan: Plan): Generator<string, voi
  * The edges: one per logical edge, expanded pairs folded.
  * @param snapshot - the snapshot
  * @param plan - the plan
+ * @param styles - the styles being written, or undefined
  * @yields the edge elements
  * @returns nothing
  */
-function* edgesOf(snapshot: GraphSnapshot, plan: Plan): Generator<string, void, undefined> {
+function* edgesOf(
+    snapshot: GraphSnapshot,
+    plan: Plan,
+    styles: ExporterStyleInput | undefined,
+): Generator<string, void, undefined> {
     const { folding, weights } = plan;
     const labelCol = slot(plan.edges, "label");
     const graphicsCol = slot(plan.edges, "graphics");
@@ -1241,7 +1255,8 @@ function* edgesOf(snapshot: GraphSnapshot, plan: Plan): Generator<string, void,
         const target = escapeXmlAttribute(idText(snapshot.ids.idOf(v)));
         yield `    <edge${idAttr}${labelAttr} source="${source}" target="${target}" cy:directed="${directed ? "1" : "0"}"${optionalAttribute("weight", weight)}${xmlAttributesOf(plan.edges, e)}>\n`;
         yield* attsOf(plan.edges, e, first, plan, "        ");
-        yield* graphicsOf(cellOf(graphicsCol, e) as Record<string, unknown> | null, [], "        ");
+        const kept = cellOf(graphicsCol, e) as Record<string, unknown> | null;
+        yield* graphicsOf(styles === undefined ? kept : styledGraphics("edge", styles, e, kept), [], "        ");
         yield "    </edge>\n";
         first = false;
     }
@@ -1286,8 +1301,12 @@ export const xgmmlExporter: GraphExporter<XgmmlExportOptions> = Object.freeze({
     format: FORMAT,
     options: Object.freeze(["cytoscapeEscapes"]),
     capabilities: CAPABILITIES,
-    check: (snapshot: GraphSnapshot, options?: XgmmlExportOptions & CommonExportOptions): readonly LossNote[] =>
-        Object.freeze(planExport(snapshot, resolveExportOptions(options), resolveEscapes(options)).notes),
+    styles: Object.freeze({ capabilities: XGMML_STYLE_CAPABILITIES }),
+    check: (snapshot: GraphSnapshot, options?: XgmmlWriteOptions): readonly LossNote[] =>
+        Object.freeze([
+            ...planExport(snapshot, resolveExportOptions(options), resolveEscapes(options)).notes,
+            ...(options?.styles === undefined ? [] : styledGraphicsNotes(options.styles, snapshot)),
+        ]),
     export: (snapshot: GraphSnapshot, options?: XgmmlExportOptions & CommonExportOptions): AsyncIterable<Uint8Array> =>
         encodeChunks(write(snapshot, options)),
     exportToString: (snapshot: GraphSnapshot, options?: XgmmlExportOptions & CommonExportOptions): Promise<string> =>

package/src/formats/xgmml/importer.ts

@@ -9,7 +9,8 @@
  * `defaultDirected` option), then `cy:directed` per edge, overruling Cytoscape, which ignores the
  * root attribute. Ids are kept as written (`ids: "keep"`), so `"1"`, `"01"` and `" 1 "` stay three
  * nodes. Positions are stored y-up (Cytoscape writes screen coordinates). Graphics values are kept
- * as a json column, never interpreted (style import is issue #706).
+ * as a json column; asked for styles, the importer reads them as Cytoscape's resolved visual properties
+ * (styles.ts), with Cytoscape desktop's default style for what an element leaves unset.
  */
 
 import { GraphFormatError, type GraphSink } from "@graphty/graph-format";
@@ -26,7 +27,14 @@ import {
 } from "../../common/options.js";
 import { agree, elementCount } from "../../common/plural.js";
 import { ImportReportBuilder } from "../../common/report.js";
-import { isWhitespace, tokenizeXml, xmlDeclaredEncoding, type XmlRepairs, XmlSyntaxError } from "../../common/xml.js";
+import {
+    isWhitespace,
+    tokenizeXml,
+    xmlDeclaredEncoding,
+    XmlNestingError,
+    type XmlRepairs,
+    XmlSyntaxError,
+} from "../../common/xml.js";
 import {
     type CommonImportOptions,
     type GraphChoiceOptions,
@@ -35,7 +43,7 @@ import {
     type ImportInput,
     type ImportReport,
 } from "../../types.js";
-import { EXTENSIONS, FORMAT, MIME_TYPES, XGMML_ISSUE } from "./constants.js";
+import { EXTENSIONS, FORMAT, MIME_TYPES, XGMML_ISSUE, XGMML_NAMESPACE } from "./constants.js";
 import { type GraphRec, type XgmmlDocument, XgmmlParser } from "./document.js";
 import {
     type Dialect,
@@ -46,6 +54,7 @@ import {
     XgmmlEmitter,
     type XgmmlSettings,
 } from "./emit.js";
+import { readXgmmlFileStyles } from "./styles.js";
 
 /**
  * The format-specific options of the XGMML importer.
@@ -174,17 +183,18 @@ export async function parseXgmml(
     common: ResolvedImportOptions,
     options: XgmmlImportOptions | undefined,
 ): Promise<XgmmlDocument> {
-    const repairs = repairsOf(options, report);
     const parser = new XgmmlParser(report);
     const seen = { content: false };
     try {
         await tokenizeXml(
             watch(textChunks(input, report, { ...common, declaredEncoding: xmlDeclaredEncoding, xml: true }), seen),
             parser,
-            repairs,
+            xmlRepairs(report, options),
         );
     } catch (err) {
-        failOnSyntax(err, seen.content, report);
+        if (err instanceof XmlSyntaxError) {
+            failSyntax(report, err, seen.content);
+        }
         throw err;
     }
     const doc = parser.document();
@@ -201,45 +211,46 @@ export async function parseXgmml(
 
 /**
  * The XML repairs the options switch on, each reporting where it repaired.
- * @param options - the XGMML options
  * @param report - the report
+ * @param options - the XGMML options
  * @returns the repairs
  */
-function repairsOf(options: XgmmlImportOptions | undefined, report: ImportReportBuilder): XmlRepairs {
+function xmlRepairs(report: ImportReportBuilder, options: XgmmlImportOptions | undefined): XmlRepairs {
+    const ampersand = (line: number): void => {
+        report.warning("parse-error", XGMML_ISSUE.AMPERSAND_REPAIRED, "a bare & was read as &amp;", { line });
+    };
+    const surrogate = (line: number): void => {
+        report.warning(
+            "parse-error",
+            XGMML_ISSUE.SURROGATE_PAIRED,
+            "two surrogate character references were joined into one character",
+            { line },
+        );
+    };
     return {
         bareAmpersand: booleanOption("repairBareAmpersands", options?.repairBareAmpersands, false)
-            ? (line): void => {
-                  report.warning("parse-error", XGMML_ISSUE.AMPERSAND_REPAIRED, "a bare & was read as &amp;", { line });
-              }
+            ? ampersand
             : undefined,
         surrogatePair: booleanOption("pairSurrogateReferences", options?.pairSurrogateReferences, false)
-            ? (line): void => {
-                  report.warning(
-                      "parse-error",
-                      XGMML_ISSUE.SURROGATE_PAIRED,
-                      "two surrogate character references were joined into one character",
-                      { line },
-                  );
-              }
+            ? surrogate
             : undefined,
     };
 }
 
 /**
- * Fail the report on an XML syntax error: an input with no content is empty, any other is
- * malformed. Any other error is left to the caller.
- * @param err - the error the tokenizer threw
- * @param content - whether non-whitespace text was seen
+ * Fails the report for an XML syntax error: an empty input, nesting too deep, or broken XML.
  * @param report - the report
+ * @param err - the error
+ * @param content - whether the input held anything but white space
+ * @returns never: it throws the report's ImportError
  */
-function failOnSyntax(err: unknown, content: boolean, report: ImportReportBuilder): void {
-    if (!(err instanceof XmlSyntaxError)) {
-        return;
-    }
+function failSyntax(report: ImportReportBuilder, err: XmlSyntaxError, content: boolean): never {
     if (!content) {
         report.fail(XGMML_ISSUE.EMPTY_INPUT, "the input is empty");
     }
-    report.fail(XGMML_ISSUE.XML_SYNTAX, err.message, { line: err.line });
+    return report.fail(err instanceof XmlNestingError ? XGMML_ISSUE.XML_NESTING : XGMML_ISSUE.XML_SYNTAX, err.message, {
+        line: err.line,
+    });
 }
 
 /**
@@ -466,7 +477,9 @@ function sniffXgmml(head: Uint8Array): number {
     }
     const tagEnd = text.indexOf(">", root.index);
     const tag = text.slice(root.index, tagEnd < 0 ? undefined : tagEnd);
-    return tag.includes("http://www.cs.rpi.edu/XGMML") ? 0.95 : 0.5;
+    // the XGMML namespace declared on the root, as a whole attribute value
+    const namespaces = [...tag.matchAll(/\bxmlns(?::[\w.-]+)?\s*=\s*(["'])([^"']*)\1/g)].map((m) => m[2]);
+    return namespaces.includes(XGMML_NAMESPACE) ? 0.95 : 0.5;
 }
 
 /**
@@ -488,4 +501,5 @@ export const xgmmlImporter: GraphImporter<XgmmlImportOptions> = Object.freeze({
     import: importXgmml,
     importAll: importAllXgmml,
     listGraphs: listXgmmlGraphs,
+    styles: readXgmmlFileStyles,
 });