@graphty/graph-io 0.0.0 → 0.2.0

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

@@ -0,0 +1,104 @@
+/**
+ * The fixed lexical grammar of design section 5.1 for untyped text sources (CSV cells, GML
+ * values, DOT strings, Pajek tokens), reproduced from the core's reference implementation so the
+ * two agree (invariant I15). Text importers parse each cell with parseTextCell() and push the JS
+ * value; the sink's per-column inference then widens `bool -> i32 -> f64 -> string` and never per
+ * cell, so a column that saw `1` and then `"01"` becomes string for all rows.
+ *
+ * - `bool` is exactly `true` / `false` (case-sensitive);
+ * - `i32` is `/^-?(0|[1-9][0-9]*)$/` within `[-2^31, 2^31)`; `0` / `1` are i32, never bool;
+ * - `f64` is a decimal or exponent literal accepted by `Number()` that is not empty, not
+ *   whitespace, not `Infinity` / `NaN`, not a hex / octal / binary form, has no leading zeros in
+ *   its integer part, and whose value is finite (an integer literal outside i32 range is f64);
+ * - everything else is `string`.
+ */
+import { type ColumnHandle, type GraphSink } from "@graphty/graph-format";
+import { type ImportReportBuilder } from "./report.js";
+/**
+ * The dtype a text cell parses as under the design section 5.1 grammar.
+ * Consumed by the per-format importers and exporters under src/formats.
+ * @public
+ */
+export type TextDtype = "bool" | "i32" | "f64" | "string";
+/**
+ * Classify one text cell by the fixed grammar.
+ * @param text - the cell text, exactly as read (no trimming)
+ * @returns bool, i32, f64 or string
+ */
+export declare function inferTextDtype(text: string): TextDtype;
+/**
+ * Parse one text cell into the JS value its grammar class implies: a boolean for bool, a number for
+ * i32 / f64, the text itself for string. The sink infers the column dtype from the value.
+ * @param text - the cell text, exactly as read
+ * @returns the value
+ */
+export declare function parseTextCell(text: string): boolean | number | string;
+/**
+ * Whether a text cell is a number under the f64 grammar (an i32 or f64 literal).
+ * @param text - the cell text
+ * @returns true when parseTextCell(text) returns a number
+ */
+export declare function isNumericText(text: string): boolean;
+/**
+ * The inferred-column writer of the untyped text formats (CSV, DOT, Pajek; design section 5.1):
+ * parses every cell by the fixed grammar and pushes the scalar, and keeps the COLUMN's dtype the
+ * one the grammar implies rather than the one the values happen to imply:
+ *
+ * - a column whose cells are all `2.0`-style f64 text is widened to f64 through the sink's
+ *   widening call even though every value is integral (the values alone would infer i32);
+ * - a numeric cell whose text is not the canonical spelling of its value (`1e5`, `-0`, `1.0`) is
+ *   remembered, and when a later cell widens the column to string the original texts are written
+ *   back, so the lexical form is never rewritten by the widening.
+ *
+ * A sink without the optional widening call keeps the value-inferred dtype and the writer records
+ * one W_WIDENING_UNSUPPORTED warning per column.
+ * Consumed by the per-format importers under src/formats.
+ * @public
+ */
+export declare class TextCellWriter {
+    /** The column name in the sink. */
+    readonly name: string;
+    private readonly domain;
+    private readonly sink;
+    private readonly report;
+    private handle;
+    /** The widest text dtype seen (the column's dtype under the 5.1 grammar). */
+    private textDtype;
+    /** The widest dtype the pushed values imply (what the sink inferred on its own). */
+    private valueDtype;
+    private readonly keptRows;
+    private readonly keptTexts;
+    /**
+     * Create a writer; the column is declared by the sink's inference on the first write.
+     * @param name - the column name
+     * @param domain - node or edge
+     * @param sink - the sink
+     * @param report - the report the widening warning is recorded in
+     */
+    constructor(name: string, domain: "node" | "edge", sink: GraphSink, report: ImportReportBuilder);
+    /**
+     * The column handle once the first cell was written.
+     * @returns the handle, or INVALID_INDEX before the first write
+     */
+    get column(): ColumnHandle;
+    /**
+     * Write one cell text.
+     * @param row - the node or edge index
+     * @param text - the cell text, exactly as read
+     */
+    write(row: number, text: string): void;
+    /**
+     * Write a value (the parsed scalar, or a text into a widened column).
+     * @param row - the row
+     * @param value - the value
+     */
+    private set;
+    /**
+     * Widen the column to the dtype the text grammar implies, through the sink's optional call.
+     * @param dtype - the dtype
+     */
+    private widen;
+}
+/** Issue code: the sink has no widening call, so a text column keeps the dtype its values imply. */
+export declare const WIDENING_UNSUPPORTED_CODE = "W_WIDENING_UNSUPPORTED";
+//# sourceMappingURL=text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/common/text.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,KAAK,YAAY,EAAoB,KAAK,SAAS,EAAiB,MAAM,uBAAuB,CAAC;AAE3G,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAOvD;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAC;AAE1D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAetD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAYrE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGnD;AAmCD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,cAAc;IACvB,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IAEzC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAY;IAEjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAE7C,OAAO,CAAC,MAAM,CAA+C;IAE7D,6EAA6E;IAC7E,OAAO,CAAC,SAAS,CAA0B;IAE3C,oFAAoF;IACpF,OAAO,CAAC,UAAU,CAA0B;IAE5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IAEzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAE1C;;;;;;OAMG;gBACS,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,mBAAmB;IAO/F;;;OAGG;IACH,IAAI,MAAM,IAAI,YAAY,CAEzB;IAED;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAoCtC;;;;OAIG;IACH,OAAO,CAAC,GAAG;IAkBX;;;OAGG;IACH,OAAO,CAAC,KAAK;CA6BhB;AAED,oGAAoG;AACpG,eAAO,MAAM,yBAAyB,2BAA2B,CAAC"}

package/dist/src/common/text.js

@@ -0,0 +1,255 @@
+/**
+ * The fixed lexical grammar of design section 5.1 for untyped text sources (CSV cells, GML
+ * values, DOT strings, Pajek tokens), reproduced from the core's reference implementation so the
+ * two agree (invariant I15). Text importers parse each cell with parseTextCell() and push the JS
+ * value; the sink's per-column inference then widens `bool -> i32 -> f64 -> string` and never per
+ * cell, so a column that saw `1` and then `"01"` becomes string for all rows.
+ *
+ * - `bool` is exactly `true` / `false` (case-sensitive);
+ * - `i32` is `/^-?(0|[1-9][0-9]*)$/` within `[-2^31, 2^31)`; `0` / `1` are i32, never bool;
+ * - `f64` is a decimal or exponent literal accepted by `Number()` that is not empty, not
+ *   whitespace, not `Infinity` / `NaN`, not a hex / octal / binary form, has no leading zeros in
+ *   its integer part, and whose value is finite (an integer literal outside i32 range is f64);
+ * - everything else is `string`.
+ */
+import { GraphFormatError, INVALID_INDEX } from "@graphty/graph-format";
+const I32_TEXT = /^-?(0|[1-9][0-9]*)$/;
+const F64_TEXT = /^[+-]?((0|[1-9][0-9]*)(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?$/;
+const I32_MIN = -2147483648;
+const I32_MAX = 2147483647;
+/**
+ * Classify one text cell by the fixed grammar.
+ * @param text - the cell text, exactly as read (no trimming)
+ * @returns bool, i32, f64 or string
+ */
+export function inferTextDtype(text) {
+    if (text === "true" || text === "false") {
+        return "bool";
+    }
+    if (I32_TEXT.test(text)) {
+        const n = Number(text);
+        if (n >= I32_MIN && n <= I32_MAX) {
+            return "i32";
+        }
+        return Number.isFinite(n) ? "f64" : "string";
+    }
+    if (F64_TEXT.test(text) && Number.isFinite(Number(text))) {
+        return "f64";
+    }
+    return "string";
+}
+/**
+ * Parse one text cell into the JS value its grammar class implies: a boolean for bool, a number for
+ * i32 / f64, the text itself for string. The sink infers the column dtype from the value.
+ * @param text - the cell text, exactly as read
+ * @returns the value
+ */
+export function parseTextCell(text) {
+    switch (inferTextDtype(text)) {
+        case "bool":
+            return text === "true";
+        case "i32":
+        case "f64":
+            return Number(text);
+        case "string":
+            return text;
+        default:
+            return text;
+    }
+}
+/**
+ * Whether a text cell is a number under the f64 grammar (an i32 or f64 literal).
+ * @param text - the cell text
+ * @returns true when parseTextCell(text) returns a number
+ */
+export function isNumericText(text) {
+    const dtype = inferTextDtype(text);
+    return dtype === "i32" || dtype === "f64";
+}
+/**
+ * Whether a numeric cell text is the canonical spelling of its value (`String(value) === text`),
+ * so that the sink's own re-formatting of the value would reproduce it.
+ * @param text - the cell text
+ * @param value - the parsed value
+ * @returns true when the lexical form survives a widening to string
+ */
+function isCanonicalNumberText(text, value) {
+    return String(value) === text;
+}
+/**
+ * The widening rank of a text dtype in the design section 5.1 order.
+ * @param dtype - the text dtype
+ * @returns 0 for bool, 1 for i32, 2 for f64, 3 for string
+ */
+function textDtypeRank(dtype) {
+    switch (dtype) {
+        case "bool":
+            return 0;
+        case "i32":
+            return 1;
+        case "f64":
+            return 2;
+        case "string":
+            return 3;
+        default: {
+            const name = dtype;
+            throw new GraphFormatError("E_UNSUPPORTED", `unknown text dtype ${name}`, { dtype: name });
+        }
+    }
+}
+/**
+ * The inferred-column writer of the untyped text formats (CSV, DOT, Pajek; design section 5.1):
+ * parses every cell by the fixed grammar and pushes the scalar, and keeps the COLUMN's dtype the
+ * one the grammar implies rather than the one the values happen to imply:
+ *
+ * - a column whose cells are all `2.0`-style f64 text is widened to f64 through the sink's
+ *   widening call even though every value is integral (the values alone would infer i32);
+ * - a numeric cell whose text is not the canonical spelling of its value (`1e5`, `-0`, `1.0`) is
+ *   remembered, and when a later cell widens the column to string the original texts are written
+ *   back, so the lexical form is never rewritten by the widening.
+ *
+ * A sink without the optional widening call keeps the value-inferred dtype and the writer records
+ * one W_WIDENING_UNSUPPORTED warning per column.
+ * Consumed by the per-format importers under src/formats.
+ * @public
+ */
+export class TextCellWriter {
+    /**
+     * Create a writer; the column is declared by the sink's inference on the first write.
+     * @param name - the column name
+     * @param domain - node or edge
+     * @param sink - the sink
+     * @param report - the report the widening warning is recorded in
+     */
+    constructor(name, domain, sink, report) {
+        this.handle = INVALID_INDEX;
+        /** The widest text dtype seen (the column's dtype under the 5.1 grammar). */
+        this.textDtype = null;
+        /** The widest dtype the pushed values imply (what the sink inferred on its own). */
+        this.valueDtype = null;
+        this.keptRows = [];
+        this.keptTexts = [];
+        this.name = name;
+        this.domain = domain;
+        this.sink = sink;
+        this.report = report;
+    }
+    /**
+     * The column handle once the first cell was written.
+     * @returns the handle, or INVALID_INDEX before the first write
+     */
+    get column() {
+        return this.handle;
+    }
+    /**
+     * Write one cell text.
+     * @param row - the node or edge index
+     * @param text - the cell text, exactly as read
+     */
+    write(row, text) {
+        const kind = inferTextDtype(text);
+        const value = parseTextCell(text);
+        const wasString = this.textDtype === "string";
+        const textDtype = this.textDtype === null || textDtypeRank(kind) > textDtypeRank(this.textDtype) ? kind : this.textDtype;
+        // a string column keeps every cell's lexical form; a numeric text is never re-spelled. The
+        // sink may refuse the value (a declared column of another dtype): the state advances only
+        // once the cell is written, so a refused cell leaves the writer as it was.
+        this.set(row, textDtype === "string" ? text : value);
+        this.textDtype = textDtype;
+        const valueKind = kindOfValue(value);
+        if (this.valueDtype === null || textDtypeRank(valueKind) > textDtypeRank(this.valueDtype)) {
+            this.valueDtype = valueKind;
+        }
+        if (this.textDtype === "string") {
+            if (!wasString && this.keptRows.length > 0) {
+                // the sink just widened the column to string from the values; restore the texts
+                // whose lexical form the values did not carry
+                for (let i = 0; i < this.keptRows.length; i++) {
+                    this.set(this.keptRows[i], this.keptTexts[i]);
+                }
+                this.keptRows.length = 0;
+                this.keptTexts.length = 0;
+            }
+            return;
+        }
+        if (typeof value === "number" && !isCanonicalNumberText(text, value)) {
+            this.keptRows.push(row);
+            this.keptTexts.push(text);
+        }
+        if (this.textDtype === "f64" && this.valueDtype !== "f64") {
+            this.widen("f64");
+        }
+    }
+    /**
+     * Write a value (the parsed scalar, or a text into a widened column).
+     * @param row - the row
+     * @param value - the value
+     */
+    set(row, value) {
+        if (this.handle === INVALID_INDEX) {
+            if (this.domain === "node") {
+                this.sink.setNodeValue(this.name, row, value);
+                this.handle = this.sink.nodeColumn(this.name);
+            }
+            else {
+                this.sink.setEdgeValue(this.name, row, value);
+                this.handle = this.sink.edgeColumn(this.name);
+            }
+            return;
+        }
+        if (this.domain === "node") {
+            this.sink.setNodeValue(this.handle, row, value);
+        }
+        else {
+            this.sink.setEdgeValue(this.handle, row, value);
+        }
+    }
+    /**
+     * Widen the column to the dtype the text grammar implies, through the sink's optional call.
+     * @param dtype - the dtype
+     */
+    widen(dtype) {
+        const { sink } = this;
+        const supported = this.domain === "node" ? sink.widenNodeColumn !== undefined : sink.widenEdgeColumn !== undefined;
+        if (!supported) {
+            this.report.warnOnce("coercion", WIDENING_UNSUPPORTED_CODE, `column "${this.name}" holds ${dtype} text but the sink cannot widen an inferred column; it keeps the value-inferred dtype`, { element: this.name });
+            this.valueDtype = dtype;
+            return;
+        }
+        try {
+            if (this.domain === "node") {
+                sink.widenNodeColumn?.(this.handle, dtype);
+            }
+            else {
+                sink.widenEdgeColumn?.(this.handle, dtype);
+            }
+            this.valueDtype = dtype;
+        }
+        catch (err) {
+            if (!(err instanceof GraphFormatError) || err.code !== "E_COLUMN_TYPE") {
+                throw err;
+            }
+            // a caller's declared column of the name: its dtype stands
+            this.valueDtype = dtype;
+        }
+    }
+}
+/** Issue code: the sink has no widening call, so a text column keeps the dtype its values imply. */
+export const WIDENING_UNSUPPORTED_CODE = "W_WIDENING_UNSUPPORTED";
+/**
+ * The text dtype a parsed cell value implies on its own (what the sink's inference sees).
+ * @param value - the parsed value
+ * @returns the dtype
+ */
+function kindOfValue(value) {
+    if (typeof value === "boolean") {
+        return "bool";
+    }
+    if (typeof value === "string") {
+        return "string";
+    }
+    return Number.isInteger(value) && value >= -2147483648 && value <= 2147483647 && !Object.is(value, -0)
+        ? "i32"
+        : "f64";
+}
+//# sourceMappingURL=text.js.map

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

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

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

@@ -0,0 +1,77 @@
+/**
+ * Weight resolution shared by every importer (design sections 3.7 and 8.4): which source field is
+ * THE weight (`weightFrom`, per-format default, null = unweighted), how its text or JSON value
+ * becomes the number passed to `addEdge`, and the E_INVALID_WEIGHT boundary.
+ *
+ * An edge whose weight field is absent or blank is pushed WITHOUT a weight argument, never with an
+ * explicit 1: the builder's weightSet bitmap then records that the weight was defaulted, and the
+ * exporter re-emits no weight for it (decision D-WSET). NaN and non-numeric text are
+ * E_INVALID_WEIGHT before the sink is touched, so the importer records the issue and skips the edge
+ * with the sink unchanged; Infinity and negative values are legal weights (design section 3.7).
+ */
+import { type GraphSnapshot } from "@graphty/graph-format";
+/** The weight of an edge added without one (design section 3.7). */
+export declare const DEFAULT_WEIGHT = 1;
+/**
+ * Whether a source field is the weight field under the resolved `weightFrom` option.
+ * @param name - the field name (attribute title, CSV header, JSON key)
+ * @param weightFrom - the resolved option; null means unweighted
+ * @returns true when the field is THE weight
+ */
+export declare function isWeightField(name: string, weightFrom: string | null): boolean;
+/**
+ * The weight argument of addEdge from a text cell: undefined for a blank cell (the weight is
+ * omitted), the number otherwise.
+ * @param text - the cell text
+ * @returns the weight, or undefined when blank; E_INVALID_WEIGHT for NaN or non-numeric text
+ */
+export declare function parseWeightText(text: string): number | undefined;
+/**
+ * The weight argument of addEdge from a typed value (JSON, a record field): undefined for null /
+ * undefined, the number for a finite or infinite number, the parsed number for numeric text.
+ * @param value - the field value
+ * @returns the weight, or undefined when absent; E_INVALID_WEIGHT for NaN, a boolean, an object or non-numeric text
+ */
+export declare function weightFromValue(value: unknown): number | undefined;
+/**
+ * The explicit weights of a snapshot for exporters (design sections 3.7 and 8.5): the weight
+ * role column when present (its validity says which edges had an explicit weight, its dtype how
+ * the value is written), else `edgeList().weights` as f32 for every edge of a weighted snapshot;
+ * nothing for an unweighted one. One implementation for every exporter.
+ * Consumed by the per-format exporters under src/formats.
+ * @public
+ */
+export interface ExplicitWeights {
+    /** Whether any edge can have an explicit weight (the snapshot is weighted). */
+    readonly weighted: boolean;
+    /** The dtype the values are read from: the shadow column's, or f32 for the arc array. */
+    readonly dtype: "f32" | "f64";
+    /**
+     * Whether an edge's weight was explicit in the source.
+     * @param e - the logical edge index
+     * @returns true when the exporter must write it
+     */
+    isExplicit(e: number): boolean;
+    /**
+     * The weight value of an edge (meaningful when explicit).
+     * @param e - the logical edge index
+     * @returns the value
+     */
+    value(e: number): number;
+    /**
+     * The weight text of an edge: the shortest round-tripping decimal for its dtype, or the
+     * integer digits when `integral` is requested and the value is an integer; null when the
+     * weight was defaulted.
+     * @param e - the logical edge index
+     * @param integral - write an integral value without a decimal part (formats declaring an int weight)
+     * @returns the text, or null
+     */
+    text(e: number, integral?: boolean): string | null;
+}
+/**
+ * Build the explicit-weight view of a snapshot.
+ * @param snapshot - the snapshot
+ * @returns the view
+ */
+export declare function explicitWeights(snapshot: GraphSnapshot): ExplicitWeights;
+//# sourceMappingURL=weights.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"weights.d.ts","sourceRoot":"","sources":["../../../src/common/weights.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAiC,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAK1F,oEAAoE;AACpE,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAE9E;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAehE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAclE;AA4BD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,yFAAyF;IACzF,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;IAC9B;;;;OAIG;IACH,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B;;;;OAIG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;CACtD;AAqBD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,aAAa,GAAG,eAAe,CAwCxE"}

package/dist/src/common/weights.js

@@ -0,0 +1,156 @@
+/**
+ * Weight resolution shared by every importer (design sections 3.7 and 8.4): which source field is
+ * THE weight (`weightFrom`, per-format default, null = unweighted), how its text or JSON value
+ * becomes the number passed to `addEdge`, and the E_INVALID_WEIGHT boundary.
+ *
+ * An edge whose weight field is absent or blank is pushed WITHOUT a weight argument, never with an
+ * explicit 1: the builder's weightSet bitmap then records that the weight was defaulted, and the
+ * exporter re-emits no weight for it (decision D-WSET). NaN and non-numeric text are
+ * E_INVALID_WEIGHT before the sink is touched, so the importer records the issue and skips the edge
+ * with the sink unchanged; Infinity and negative values are legal weights (design section 3.7).
+ */
+import { GraphFormatError } from "@graphty/graph-format";
+import { parseDecimalText } from "./declared-types.js";
+import { formatF32, formatF64, formatInteger } from "./format.js";
+/** The weight of an edge added without one (design section 3.7). */
+export const DEFAULT_WEIGHT = 1;
+/**
+ * Whether a source field is the weight field under the resolved `weightFrom` option.
+ * @param name - the field name (attribute title, CSV header, JSON key)
+ * @param weightFrom - the resolved option; null means unweighted
+ * @returns true when the field is THE weight
+ */
+export function isWeightField(name, weightFrom) {
+    return weightFrom !== null && name === weightFrom;
+}
+/**
+ * The weight argument of addEdge from a text cell: undefined for a blank cell (the weight is
+ * omitted), the number otherwise.
+ * @param text - the cell text
+ * @returns the weight, or undefined when blank; E_INVALID_WEIGHT for NaN or non-numeric text
+ */
+export function parseWeightText(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    let value;
+    try {
+        value = parseDecimalText(trimmed);
+    }
+    catch (err) {
+        throw invalidWeight(text, err);
+    }
+    if (Number.isNaN(value)) {
+        throw invalidWeight(text, null);
+    }
+    return value;
+}
+/**
+ * The weight argument of addEdge from a typed value (JSON, a record field): undefined for null /
+ * undefined, the number for a finite or infinite number, the parsed number for numeric text.
+ * @param value - the field value
+ * @returns the weight, or undefined when absent; E_INVALID_WEIGHT for NaN, a boolean, an object or non-numeric text
+ */
+export function weightFromValue(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === "number") {
+        if (Number.isNaN(value)) {
+            throw invalidWeight(value, null);
+        }
+        return value;
+    }
+    if (typeof value === "string") {
+        return parseWeightText(value);
+    }
+    throw invalidWeight(value, null);
+}
+/**
+ * The E_INVALID_WEIGHT error of a rejected value.
+ * @param value - the rejected value
+ * @param cause - the parse error, or null
+ * @returns the error
+ */
+function invalidWeight(value, cause) {
+    let shown;
+    switch (typeof value) {
+        case "string":
+            shown = JSON.stringify(value);
+            break;
+        case "number":
+            shown = String(value);
+            break;
+        default:
+            shown = typeof value;
+    }
+    return new GraphFormatError("E_INVALID_WEIGHT", `invalid edge weight ${shown}`, {
+        value: typeof value === "object" ? typeof value : value,
+        cause: cause instanceof Error ? cause.message : null,
+    });
+}
+/** The dtypes a weight role column may have (an integer column declared by a caller included). */
+const NUMERIC_DTYPES = new Set(["f32", "f64", "i32", "u32", "u8"]);
+/**
+ * The shortest round-tripping text of a weight by the shadow column's dtype.
+ * @param dtype - the shadow column's dtype
+ * @returns the formatter
+ */
+function weightFormatter(dtype) {
+    switch (dtype) {
+        case "f32":
+            return formatF32;
+        case "f64":
+            return formatF64;
+        default:
+            return formatInteger;
+    }
+}
+/**
+ * Build the explicit-weight view of a snapshot.
+ * @param snapshot - the snapshot
+ * @returns the view
+ */
+export function explicitWeights(snapshot) {
+    const shadowColumn = snapshot.edges.byRole("weight");
+    const shadow = shadowColumn !== null && NUMERIC_DTYPES.has(shadowColumn.dtype) ? shadowColumn : null;
+    if (shadow !== null) {
+        const dtype = shadow.dtype === "f32" ? "f32" : "f64";
+        const format = weightFormatter(shadow.dtype);
+        return {
+            weighted: true,
+            dtype,
+            isExplicit: (e) => shadow.isSet(e),
+            value: (e) => shadow.value(e),
+            text: (e, integral = false) => {
+                if (!shadow.isSet(e)) {
+                    return null;
+                }
+                const value = shadow.value(e);
+                return integral && Number.isInteger(value) ? formatInteger(value) : format(value);
+            },
+        };
+    }
+    const { weights } = snapshot.edgeList();
+    if (weights === null || !snapshot.flags.weighted) {
+        return {
+            weighted: false,
+            dtype: "f32",
+            isExplicit: () => false,
+            value: () => DEFAULT_WEIGHT,
+            text: () => null,
+        };
+    }
+    return {
+        weighted: true,
+        dtype: "f32",
+        isExplicit: () => true,
+        value: (e) => weights[e],
+        text: (e, integral = false) => {
+            const value = weights[e];
+            return integral && Number.isInteger(value) ? formatInteger(value) : formatF32(value);
+        },
+    };
+}
+//# sourceMappingURL=weights.js.map

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

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