@graphty/graph-io 0.3.38 → 0.3.39

package/src/formats/dot/importer.ts

@@ -97,6 +97,7 @@ import {
     PARENT_COLUMN,
     PIN_ATTRIBUTE,
     POS_ATTRIBUTE,
+    POSITION_COLUMN,
     SOURCE_PORT_COLUMN,
     TARGET_PORT_COLUMN,
 } from "./names.js";
@@ -122,6 +123,12 @@ export interface DotImportOptions extends GraphChoiceOptions, CommonImportOption
      * @defaultValue true
      */
     positions?: boolean | undefined;
+    /**
+     * With `positions`, also keep `pos` as the text the file wrote; the position column is then
+     * named `graphty.position`, so a reader gets both.
+     * @defaultValue false
+     */
+    keepPositionSource?: boolean | undefined;
 }
 
 /**
@@ -323,7 +330,7 @@ interface Scope {
  */
 export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
     format: DOT_FORMAT,
-    options: Object.freeze(["mismatchedEdgeOperator", "positions"]),
+    options: Object.freeze(["keepPositionSource", "mismatchedEdgeOperator", "positions"]),
     extensions: EXTENSIONS,
     mimeTypes: MIME_TYPES,
 
@@ -376,7 +383,15 @@ export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
         const reports = { current: report };
         const lexer = dotLexer(text, reports);
         const first = guard(report, () => lexer.next());
-        const parser = new DotParser(lexer, sink, report, resolved, mismatch, options?.positions !== false);
+        const parser = new DotParser(
+            lexer,
+            sink,
+            report,
+            resolved,
+            mismatch,
+            options?.positions !== false,
+            options?.keepPositionSource === true,
+        );
         parser.headCharset = head.charset;
         const trailing = parseGraph(parser, report, first);
         if (trailing.kind !== "eof") {
@@ -429,7 +444,15 @@ export const dotImporter: GraphImporter<DotImportOptions> = Object.freeze({
             reports.current = report;
             const sink = sinkFor(done.length);
             reportSinkOptions(sink, options, report);
-            const parser = new DotParser(lexer, sink, report, resolved, mismatch, options?.positions !== false);
+            const parser = new DotParser(
+                lexer,
+                sink,
+                report,
+                resolved,
+                mismatch,
+                options?.positions !== false,
+                options?.keepPositionSource === true,
+            );
             parser.headCharset = head.charset;
             token = parseGraph(parser, report, token);
             throwIfAborted(resolved.signal);
@@ -686,6 +709,8 @@ class DotParser {
     private readonly mismatch: "operator" | "header" | "error";
     private readonly positions: boolean;
 
+    private readonly keepPositionSource: boolean;
+
     private readonly ids: IdCoercer;
 
     private readonly resolver: DirectionResolver;
@@ -758,6 +783,7 @@ class DotParser {
      * @param options - the resolved common options
      * @param mismatch - the resolved mismatchedEdgeOperator option
      * @param positions - whether `pos` goes to the position column
+     * @param keepPositionSource - whether `pos` also stays as text
      */
     constructor(
         lexer: DotTokenizer,
@@ -766,6 +792,7 @@ class DotParser {
         options: ResolvedImportOptions,
         mismatch: "operator" | "header" | "error",
         positions: boolean,
+        keepPositionSource: boolean,
     ) {
         this.lexer = lexer;
         this.sink = sink;
@@ -773,6 +800,7 @@ class DotParser {
         this.options = options;
         this.mismatch = mismatch;
         this.positions = positions;
+        this.keepPositionSource = keepPositionSource;
         this.ids = new IdCoercer(options.ids);
         this.resolver = new DirectionResolver(sink, report, options.onMixedDirection);
     }
@@ -1586,6 +1614,9 @@ class DotParser {
                 this.sink.setNodeValue(this.nodeLabel(), index, value);
             } else if (name === POS_ATTRIBUTE && this.positions) {
                 this.setPosition(index, value, line, element);
+                if (this.keepPositionSource) {
+                    this.textWriter("node", name).write(index, value);
+                }
             } else {
                 this.textWriter("node", name).write(index, value);
             }
@@ -1766,7 +1797,7 @@ class DotParser {
     private positionColumn(dims: 2 | 3): ColumnHandle {
         if (this.positionHandle === INVALID_INDEX) {
             this.positionHandle = this.declare("node", {
-                name: POS_ATTRIBUTE,
+                name: this.keepPositionSource ? POSITION_COLUMN : POS_ATTRIBUTE,
                 dtype: "f64",
                 components: 3,
                 nullable: true,

package/src/formats/dot/names.ts

@@ -54,6 +54,12 @@ export const LABEL_ATTRIBUTE = "label";
  */
 export const POS_ATTRIBUTE = "pos";
 
+/**
+ * The node position column when the import keeps `pos` as text too (the `keepPositionSource` option).
+ * @category Plugin helpers
+ */
+export const POSITION_COLUMN = "graphty.position";
+
 /**
  * The edge attribute cgraph uses as an edge's identity within its endpoints, mapped to the edge id role.
  * @category Plugin helpers

package/src/formats/dot/tokenizer.ts

@@ -148,15 +148,15 @@ export class DotTokenizer {
         const { line } = this;
         const c = text.charCodeAt(start);
         switch (c) {
-            case 0x7b: // {
-            case 0x7d: // }
-            case 0x5b: // [
-            case 0x5d: // ]
-            case 0x3b: // ;
-            case 0x2c: // ,
-            case 0x3d: // =
-            case 0x3a: // :
-            case 0x2b: // +
+            case 0x7b: // "{"
+            case 0x7d: // "}"
+            case 0x5b: // "["
+            case 0x5d: // "]"
+            case 0x3b: // ";"
+            case 0x2c: // ","
+            case 0x3d: // "="
+            case 0x3a: // ":"
+            case 0x2b: // "+"
                 this.pos++;
                 return { kind: "punct", text: text[start], quoted: false, html: false, line };
             case 0x2d: {

package/src/formats/gml/importer.ts

@@ -97,6 +97,12 @@ export interface GmlImportOptions extends GraphChoiceOptions, CommonImportOption
      * @defaultValue true
      */
     positions?: boolean | undefined;
+    /**
+     * With `positions`, also keep the whole `graphics` record, x / y / z included, as the JSON
+     * attribute named `graphics`, so a reader gets both the position and the record as written.
+     * @defaultValue false
+     */
+    keepPositionSource?: boolean | undefined;
     /**
      * Store a text attribute whose values repeat a lot (fewer distinct values than half the rows)
      * as a dictionary column, which uses less memory and reads the same. Such a column reports
@@ -378,6 +384,8 @@ class GmlImport {
 
     private readonly positions: boolean;
 
+    private readonly keepPositionSource: boolean;
+
     private readonly dictionaries: boolean;
 
     private readonly coercer: IdCoercer;
@@ -470,6 +478,7 @@ class GmlImport {
         this.report = report;
         this.options = options;
         this.positions = format?.positions ?? true;
+        this.keepPositionSource = format?.keepPositionSource ?? false;
         this.dictionaries = format?.dictionaries ?? true;
         this.coercer = new IdCoercer(options.ids);
     }
@@ -755,7 +764,8 @@ class GmlImport {
         }
         const positioned = x && y;
         entry.position ||= positioned;
-        entry.rest ||= positioned ? other : true;
+        // with keepPositionSource the whole record, x / y / z included, goes to the json column too
+        entry.rest ||= positioned ? other || this.keepPositionSource : true;
     }
 
     // ============================================================ pass 2: the push
@@ -1541,7 +1551,8 @@ class GmlImport {
         const positionPlan = plan.position;
         let rest: unknown = first;
         if (isRecord(first) && positionPlan !== null) {
-            rest = this.writePosition(positionPlan, index, first, where);
+            const left = this.writePosition(positionPlan, index, this.keepPositionSource ? { ...first } : first, where);
+            rest = this.keepPositionSource ? first : left;
         } else if (!isRecord(first)) {
             this.graphicsWarning("scalar", `node ${where.element}'s graphics is not a record`, where);
         }
@@ -1924,7 +1935,7 @@ function sniffGml(head: Uint8Array): number {
  */
 export const gmlImporter: GraphImporter<GmlImportOptions> = Object.freeze({
     format: "gml",
-    options: Object.freeze(["dictionaries", "positions"]),
+    options: Object.freeze(["dictionaries", "keepPositionSource", "positions"]),
     extensions: Object.freeze([".gml"]),
     mimeTypes: Object.freeze(["text/x-gml", "text/plain"]),
     sniff: sniffGml,

package/src/formats/graphml/importer.ts

@@ -512,16 +512,14 @@ class GraphmlReader implements XmlHandler {
         const parent = this.ctx.at(-1) ?? null;
         switch (parent) {
             case Ctx.Capture:
+            case Ctx.Data:
+            case Ctx.Default:
                 this.captureStart(name, attrs);
                 return;
             case Ctx.Skip:
             case Ctx.Desc:
                 this.ctx.push(Ctx.Skip);
                 return;
-            case Ctx.Data:
-            case Ctx.Default:
-                this.captureStart(name, attrs);
-                return;
             case Ctx.Dropped:
                 this.dropStart(localName(name));
                 return;

package/src/formats/obo/importer.ts

@@ -1429,7 +1429,8 @@ class OboReader {
             return;
         }
         const map = (record.values.get("obo.qualifiers") as Record<string, unknown[]> | undefined) ?? {};
-        (map[tag] ??= []).push({ value, qualifiers });
+        map[tag] ??= [];
+        map[tag].push({ value, qualifiers });
         record.values.set("obo.qualifiers", map);
     }
 

package/src/formats/pajek/exporter.ts

@@ -979,10 +979,12 @@ export const pajekExporter: GraphExporter<PajekExportOptions> = Object.freeze({
         // keyword and the relation name (dict columns written as keywords)
         const owned = new Set<string>();
         for (const { column, slot } of [...nodePlan, ...edgePlan]) {
-            if (slot === "shape" || slot === "relation") {
-                owned.add(`${column.meta.domain}:${column.meta.name}`);
-            } else if (slot === "param" && column.meta.domain === "node" && column.meta.name === SHAPE_COLUMN) {
-                // the shape-as-parameter note already says the column reads back as string
+            // a shape written as a parameter is owned too: its note already says the column reads back as string
+            if (
+                slot === "shape" ||
+                slot === "relation" ||
+                (slot === "param" && column.meta.domain === "node" && column.meta.name === SHAPE_COLUMN)
+            ) {
                 owned.add(`${column.meta.domain}:${column.meta.name}`);
             }
         }

package/src/sniff.ts

@@ -557,5 +557,5 @@ function clamp(value: number): number {
     if (!(value > 0)) {
         return 0;
     }
-    return value > 1 ? 1 : value;
+    return Math.min(value, 1);
 }