@graphty/graph-io 0.0.0 → 0.2.0

package/dist/chunks/text-CajMdVFy.js

@@ -0,0 +1,189 @@
+import { INVALID_INDEX, GraphFormatError } 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;
+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";
+}
+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;
+  }
+}
+function isNumericText(text) {
+  const dtype = inferTextDtype(text);
+  return dtype === "i32" || dtype === "f64";
+}
+function isCanonicalNumberText(text, value) {
+  return String(value) === text;
+}
+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 });
+    }
+  }
+}
+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;
+    this.textDtype = null;
+    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;
+    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) {
+        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 !== void 0 : sink.widenEdgeColumn !== void 0;
+    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;
+      }
+      this.valueDtype = dtype;
+    }
+  }
+}
+const WIDENING_UNSUPPORTED_CODE = "W_WIDENING_UNSUPPORTED";
+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";
+}
+export {
+  TextCellWriter as T,
+  WIDENING_UNSUPPORTED_CODE as W,
+  isNumericText as a,
+  inferTextDtype as i,
+  parseTextCell as p
+};
+//# sourceMappingURL=text-CajMdVFy.js.map

package/dist/chunks/text-CajMdVFy.js.map

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