@nshiab/simple-data-analysis-core 2.0.9 → 2.1.0

package/script/helpers/findGeoColumnFromSchema.js

@@ -8,11 +8,6 @@ const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
 /**
  * Returns the only geometry column in a table schema.
  *
- * @param types - The table schema to inspect.
- * @param method - The SDA method requesting a geometry column.
- * @param tableName - The name of the table represented by the schema.
- * @returns The name of the only geometry column.
- *
  * @example
  * ```ts
  * const column = findGeoColumnFromSchema(
@@ -21,6 +16,14 @@ const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
  *   "places",
  * );
  * ```
+ *
+ * @param types - The table schema to inspect.
+ *
+ * @param method - The SDA method requesting a geometry column.
+ *
+ * @param tableName - The name of the table represented by the schema.
+ *
+ * @returns The name of the only geometry column.
  */
 function findGeoColumnFromSchema(types, method, tableName) {
     const geometryColumns = Object.keys(types).filter((column) => types[column].toLowerCase().includes("geometry")).sort();

package/script/helpers/formatDate.d.ts

@@ -2,12 +2,6 @@
  * Formats a `Date` object into a human-readable string using only the format
  * strings actually used in the project.
  *
- * @param date - The `Date` object to format.
- * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
- * @param options - Optional settings.
- * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
- * @returns The formatted date string.
- *
  * @example
  * ```ts
  * // Format a date with time (local time).
@@ -15,18 +9,30 @@
  * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period");
  * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
  * ```
+ *
  * @example
  * ```ts
  * // Format a date as month and day only (UTC).
  * const formatted = formatDate(new Date("2023-01-01"), "Month DD", { utc: true });
  * console.log(formatted); // "January 1"
  * ```
+ *
  * @example
  * ```ts
  * // Minutes of ":00" are omitted.
  * const formatted = formatDate(new Date("2023-01-01T01:00:00"), "Month DD, YYYY, at HH:MM period", { utc: true });
  * console.log(formatted); // "January 1, 2023, at 1 a.m."
  * ```
+ *
+ * @param date - The `Date` object to format.
+ *
+ * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
+ *
+ * @param options - Optional settings.
+ *
+ * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
+ *
+ * @returns The formatted date string.
  */
 export default function formatDate(date: Date, format: "Month DD, YYYY, at HH:MM period" | "Month DD", options?: {
     utc?: boolean;

package/script/helpers/formatDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/helpers/formatDate.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,iCAAiC,GAAG,UAAU,EACtD,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B,MAAM,CA2BR"}
+{"version":3,"file":"formatDate.d.ts","sourceRoot":"","sources":["../../src/helpers/formatDate.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,iCAAiC,GAAG,UAAU,EACtD,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,OAAO,CAAA;CAAO,GAC9B,MAAM,CA2BR"}

package/script/helpers/formatDate.js

@@ -19,12 +19,6 @@ const MONTHS = [
  * Formats a `Date` object into a human-readable string using only the format
  * strings actually used in the project.
  *
- * @param date - The `Date` object to format.
- * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
- * @param options - Optional settings.
- * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
- * @returns The formatted date string.
- *
  * @example
  * ```ts
  * // Format a date with time (local time).
@@ -32,18 +26,30 @@ const MONTHS = [
  * const formatted = formatDate(date, "Month DD, YYYY, at HH:MM period");
  * console.log(formatted); // "January 1, 2023, at 1:35 a.m."
  * ```
+ *
  * @example
  * ```ts
  * // Format a date as month and day only (UTC).
  * const formatted = formatDate(new Date("2023-01-01"), "Month DD", { utc: true });
  * console.log(formatted); // "January 1"
  * ```
+ *
  * @example
  * ```ts
  * // Minutes of ":00" are omitted.
  * const formatted = formatDate(new Date("2023-01-01T01:00:00"), "Month DD, YYYY, at HH:MM period", { utc: true });
  * console.log(formatted); // "January 1, 2023, at 1 a.m."
  * ```
+ *
+ * @param date - The `Date` object to format.
+ *
+ * @param format - The format string to use. Only `"Month DD, YYYY, at HH:MM period"` and `"Month DD"` are supported.
+ *
+ * @param options - Optional settings.
+ *
+ * @param options.utc - If `true`, format the date in UTC instead of local time. Defaults to `false`.
+ *
+ * @returns The formatted date string.
  */
 function formatDate(date, format, options = {}) {
     const getFullYear = options.utc ? date.getUTCFullYear : date.getFullYear;

package/script/helpers/formatMissingTables.d.ts

@@ -1,11 +1,6 @@
 /**
  * Formats a missing-table error with the requested and available table names.
  *
- * @param method - The SDA method looking up the tables.
- * @param missingTables - The requested table names that were not found.
- * @param availableTables - The table names currently available.
- * @returns An actionable missing-table error message.
- *
  * @example
  * ```ts
  * const message = formatMissingTables(
@@ -14,6 +9,14 @@
  *   ["votes", "districts"],
  * );
  * ```
+ *
+ * @param method - The SDA method looking up the tables.
+ *
+ * @param missingTables - The requested table names that were not found.
+ *
+ * @param availableTables - The table names currently available.
+ *
+ * @returns An actionable missing-table error message.
  */
 export default function formatMissingTables(method: string, missingTables: string[], availableTables: string[]): string;
 //# sourceMappingURL=formatMissingTables.d.ts.map

package/script/helpers/formatMissingTables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatMissingTables.d.ts","sourceRoot":"","sources":["../../src/helpers/formatMissingTables.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EAAE,EACvB,eAAe,EAAE,MAAM,EAAE,GACxB,MAAM,CAUR"}
+{"version":3,"file":"formatMissingTables.d.ts","sourceRoot":"","sources":["../../src/helpers/formatMissingTables.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EAAE,EACvB,eAAe,EAAE,MAAM,EAAE,GACxB,MAAM,CAUR"}

package/script/helpers/formatMissingTables.js

@@ -8,11 +8,6 @@ const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
 /**
  * Formats a missing-table error with the requested and available table names.
  *
- * @param method - The SDA method looking up the tables.
- * @param missingTables - The requested table names that were not found.
- * @param availableTables - The table names currently available.
- * @returns An actionable missing-table error message.
- *
  * @example
  * ```ts
  * const message = formatMissingTables(
@@ -21,6 +16,14 @@ const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
  *   ["votes", "districts"],
  * );
  * ```
+ *
+ * @param method - The SDA method looking up the tables.
+ *
+ * @param missingTables - The requested table names that were not found.
+ *
+ * @param availableTables - The table names currently available.
+ *
+ * @returns An actionable missing-table error message.
  */
 function formatMissingTables(method, missingTables, availableTables) {
     const missing = [...missingTables].sort();

package/script/helpers/formatNumber.d.ts

@@ -1,40 +1,49 @@
 /**
  * Formats a number with thousands separators, decimals, abbreviations, and more.
  *
- * @param number - The number to be formatted.
- * @param options - An object containing various formatting options.
- * @param options.decimals - The number of decimal places to round to.
- * @param options.significantDigits - The number of significant digits to round to.
- * @param options.abbreviation - If `true`, the number will be abbreviated (e.g., 1,200,000 becomes "1.2M").
- * @param options.prefix - A string to prepend before the formatted number.
- * @param options.suffix - A string to append after the formatted number.
- *
- * @returns The formatted number as a string.
- *
  * @example
  * ```ts
  * // Basic usage: Format a number with thousands separator.
  * const num1 = formatNumber(1234567.89);
  * console.log(num1); // "1,234,567.89"
  * ```
+ *
  * @example
  * ```ts
  * // With significant digits and suffix.
  * const num2 = formatNumber(66.666, { significantDigits: 3, suffix: "%" });
  * console.log(num2); // "66.7%"
  * ```
+ *
  * @example
  * ```ts
  * // Abbreviation.
  * const num3 = formatNumber(12000, { abbreviation: true });
  * console.log(num3); // "12K"
  * ```
+ *
  * @example
  * ```ts
  * // With decimal places.
  * const num4 = formatNumber(123.456, { decimals: 1 });
  * console.log(num4); // "123.5"
  * ```
+ *
+ * @param number - The number to be formatted.
+ *
+ * @param options - An object containing various formatting options.
+ *
+ * @param options.decimals - The number of decimal places to round to.
+ *
+ * @param options.significantDigits - The number of significant digits to round to.
+ *
+ * @param options.abbreviation - If `true`, the number will be abbreviated (e.g., 1,200,000 becomes "1.2M").
+ *
+ * @param options.prefix - A string to prepend before the formatted number.
+ *
+ * @param options.suffix - A string to append after the formatted number.
+ *
+ * @returns The formatted number as a string.
  */
 export default function formatNumber(number: number, options?: {
     decimals?: number;

package/script/helpers/formatNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAgDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,MAAM,CAgER"}
+{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACZ,GACL,MAAM,CAgER"}

package/script/helpers/formatNumber.js

@@ -4,25 +4,31 @@ exports.default = formatNumber;
 /**
  * Rounds a number based on specified criteria: a fixed number of decimal places or to a specific number of significant digits.
  *
- * @param number - The number to be rounded.
- * @param options - An object containing options for rounding.
- * @param options.decimals - The number of decimal places to keep when rounding.
- * @param options.significantDigits - The number of significant digits to retain.
- * @returns The rounded number.
- * @throws {Error} If more than one rounding option is provided.
- *
  * @example
  * ```ts
  * // Round to one decimal place.
  * const result = round(1234.567, { decimals: 1 });
  * console.log(result); // 1234.6
  * ```
+ *
  * @example
  * ```ts
  * // Round to 3 significant digits.
  * const result = round(0.004622, { significantDigits: 3 });
  * console.log(result); // 0.00462
  * ```
+ *
+ * @param number - The number to be rounded.
+ *
+ * @param options - An object containing options for rounding.
+ *
+ * @param options.decimals - The number of decimal places to keep when rounding.
+ *
+ * @param options.significantDigits - The number of significant digits to retain.
+ *
+ * @returns The rounded number.
+ *
+ * @throws {Error} If more than one rounding option is provided.
  */
 function round(number, options = {}) {
     if (typeof options.decimals === "number" &&
@@ -42,40 +48,49 @@ function round(number, options = {}) {
 /**
  * Formats a number with thousands separators, decimals, abbreviations, and more.
  *
- * @param number - The number to be formatted.
- * @param options - An object containing various formatting options.
- * @param options.decimals - The number of decimal places to round to.
- * @param options.significantDigits - The number of significant digits to round to.
- * @param options.abbreviation - If `true`, the number will be abbreviated (e.g., 1,200,000 becomes "1.2M").
- * @param options.prefix - A string to prepend before the formatted number.
- * @param options.suffix - A string to append after the formatted number.
- *
- * @returns The formatted number as a string.
- *
  * @example
  * ```ts
  * // Basic usage: Format a number with thousands separator.
  * const num1 = formatNumber(1234567.89);
  * console.log(num1); // "1,234,567.89"
  * ```
+ *
  * @example
  * ```ts
  * // With significant digits and suffix.
  * const num2 = formatNumber(66.666, { significantDigits: 3, suffix: "%" });
  * console.log(num2); // "66.7%"
  * ```
+ *
  * @example
  * ```ts
  * // Abbreviation.
  * const num3 = formatNumber(12000, { abbreviation: true });
  * console.log(num3); // "12K"
  * ```
+ *
  * @example
  * ```ts
  * // With decimal places.
  * const num4 = formatNumber(123.456, { decimals: 1 });
  * console.log(num4); // "123.5"
  * ```
+ *
+ * @param number - The number to be formatted.
+ *
+ * @param options - An object containing various formatting options.
+ *
+ * @param options.decimals - The number of decimal places to round to.
+ *
+ * @param options.significantDigits - The number of significant digits to round to.
+ *
+ * @param options.abbreviation - If `true`, the number will be abbreviated (e.g., 1,200,000 becomes "1.2M").
+ *
+ * @param options.prefix - A string to prepend before the formatted number.
+ *
+ * @param options.suffix - A string to append after the formatted number.
+ *
+ * @returns The formatted number as a string.
  */
 function formatNumber(number, options = {}) {
     if (typeof number !== "number") {

package/script/helpers/getGraphEdgeIdColumn.d.ts

@@ -0,0 +1,9 @@
+import type { TableSchema } from "./pendingOps.js";
+export type GraphEdgeIdColumn = {
+    column: string;
+    family: "string" | "numeric";
+    idType: string;
+};
+/** Resolves a route edge-ID column and its exact comparison type. */
+export default function getGraphEdgeIdColumn(schema: TableSchema, requestedEdgeId: string, method: string): GraphEdgeIdColumn;
+//# sourceMappingURL=getGraphEdgeIdColumn.d.ts.map

package/script/helpers/getGraphEdgeIdColumn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGraphEdgeIdColumn.d.ts","sourceRoot":"","sources":["../../src/helpers/getGraphEdgeIdColumn.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,qEAAqE;AACrE,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GACb,iBAAiB,CAmCnB"}

package/script/helpers/getGraphEdgeIdColumn.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getGraphEdgeIdColumn;
+const foldIdentifier_js_1 = __importDefault(require("./foldIdentifier.js"));
+const getGraphEndpointColumns_js_1 = __importDefault(require("./getGraphEndpointColumns.js"));
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+/** Resolves a route edge-ID column and its exact comparison type. */
+function getGraphEdgeIdColumn(schema, requestedEdgeId, method) {
+    const folded = (0, foldIdentifier_js_1.default)(requestedEdgeId);
+    const column = Object.keys(schema).find((name) => (0, foldIdentifier_js_1.default)(name) === folded);
+    if (column === undefined) {
+        throw new Error(`${method} the column ${(0, quoteIdentifier_js_1.default)(requestedEdgeId)} does not exist. Check for typos, or load the data first.`);
+    }
+    try {
+        const resolved = (0, getGraphEndpointColumns_js_1.default)({ [column]: schema[column] }, column, column, method);
+        return {
+            column,
+            family: resolved.family,
+            idType: resolved.idType,
+        };
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            throw new TypeError(`${method} requires string or whole-number edge IDs, but column ${(0, quoteIdentifier_js_1.default)(column)} has type ${schema[column]}.`);
+        }
+        throw error;
+    }
+}

package/script/helpers/getGraphEndpointColumns.d.ts

@@ -0,0 +1,11 @@
+import type { TableSchema } from "./pendingOps.js";
+export type GraphEndpointColumns = {
+    source: string;
+    target: string;
+    idType: string;
+    family: "string" | "numeric";
+    floating: boolean;
+};
+/** Resolves and validates a graph's endpoint columns from an existing schema. */
+export default function getGraphEndpointColumns(schema: TableSchema, requestedSource: string, requestedTarget: string, method: string): GraphEndpointColumns;
+//# sourceMappingURL=getGraphEndpointColumns.d.ts.map

package/script/helpers/getGraphEndpointColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGraphEndpointColumns.d.ts","sourceRoot":"","sources":["../../src/helpers/getGraphEndpointColumns.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAqBF,iFAAiF;AACjF,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAC7C,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GACb,oBAAoB,CAiEtB"}

package/script/helpers/getGraphEndpointColumns.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getGraphEndpointColumns;
+const foldIdentifier_js_1 = __importDefault(require("./foldIdentifier.js"));
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+const integerTypes = {
+    TINYINT: { signed: true, bits: 8, digits: 3 },
+    SMALLINT: { signed: true, bits: 16, digits: 5 },
+    INTEGER: { signed: true, bits: 32, digits: 10 },
+    BIGINT: { signed: true, bits: 64, digits: 19 },
+    HUGEINT: { signed: true, bits: 128, digits: 39 },
+    UTINYINT: { signed: false, bits: 8, digits: 3 },
+    USMALLINT: { signed: false, bits: 16, digits: 5 },
+    UINTEGER: { signed: false, bits: 32, digits: 10 },
+    UBIGINT: { signed: false, bits: 64, digits: 20 },
+    UHUGEINT: { signed: false, bits: 128, digits: 39 },
+};
+/** Resolves and validates a graph's endpoint columns from an existing schema. */
+function getGraphEndpointColumns(schema, requestedSource, requestedTarget, method) {
+    const source = findColumn(schema, requestedSource);
+    const target = findColumn(schema, requestedTarget);
+    const missing = [
+        source === undefined ? requestedSource : undefined,
+        target === undefined ? requestedTarget : undefined,
+    ].filter((column) => column !== undefined);
+    if (missing.length > 0) {
+        const plural = missing.length > 1;
+        throw new Error(`${method} the column${plural ? "s" : ""} ${missing.map(quoteIdentifier_js_1.default).join(", ")} ${plural ? "do" : "does"} not exist. Check for typos, or load the data first.`);
+    }
+    const sourceType = normalizeType(schema[source]);
+    const targetType = normalizeType(schema[target]);
+    const sourceKind = typeKind(sourceType);
+    const targetKind = typeKind(targetType);
+    if (sourceKind === undefined || targetKind === undefined) {
+        const unsupported = sourceKind === undefined
+            ? { column: source, type: sourceType }
+            : { column: target, type: targetType };
+        throw new TypeError(`${method} requires string or numeric endpoint IDs, but column ${(0, quoteIdentifier_js_1.default)(unsupported.column)} has type ${unsupported.type}.`);
+    }
+    if (sourceKind.family !== targetKind.family) {
+        throw new TypeError(`${method} requires compatible source and target ID types, but ${(0, quoteIdentifier_js_1.default)(source)} has type ${sourceType} and ${(0, quoteIdentifier_js_1.default)(target)} has type ${targetType}.`);
+    }
+    if (sourceKind.family === "string") {
+        return {
+            source: source,
+            target: target,
+            idType: "VARCHAR",
+            family: "string",
+            floating: false,
+        };
+    }
+    const idType = compatibleNumericType(sourceType, targetType);
+    if (idType === undefined) {
+        throw new TypeError(`${method} cannot combine endpoint types ${sourceType} and ${targetType} without losing ID precision. Convert both columns to one compatible exact numeric type first.`);
+    }
+    return {
+        source: source,
+        target: target,
+        idType,
+        family: "numeric",
+        floating: isFloating(sourceType) || isFloating(targetType),
+    };
+}
+function findColumn(schema, requested) {
+    const folded = (0, foldIdentifier_js_1.default)(requested);
+    return Object.keys(schema).find((column) => (0, foldIdentifier_js_1.default)(column) === folded);
+}
+function normalizeType(type) {
+    return type.toUpperCase().replace(/^REAL$/, "FLOAT");
+}
+function typeKind(type) {
+    if (type === "VARCHAR")
+        return { family: "string" };
+    if (integerTypes[type] !== undefined || isDecimal(type) || isFloating(type) ||
+        type === "BIGNUM") {
+        return { family: "numeric" };
+    }
+    return undefined;
+}
+function compatibleNumericType(left, right) {
+    if (left === right)
+        return left;
+    if (isFloating(left) || isFloating(right)) {
+        return isFloating(left) && isFloating(right) ? "DOUBLE" : undefined;
+    }
+    if (left === "BIGNUM" || right === "BIGNUM") {
+        const other = left === "BIGNUM" ? right : left;
+        return integerTypes[other] !== undefined || decimalScale(other) === 0
+            ? "BIGNUM"
+            : undefined;
+    }
+    const leftInteger = integerTypes[left];
+    const rightInteger = integerTypes[right];
+    if (leftInteger !== undefined && rightInteger !== undefined) {
+        return commonIntegerType(leftInteger, rightInteger);
+    }
+    const leftDecimal = parseDecimal(left);
+    const rightDecimal = parseDecimal(right);
+    if (leftDecimal === undefined && rightDecimal === undefined)
+        return undefined;
+    const scale = Math.max(leftDecimal?.scale ?? 0, rightDecimal?.scale ?? 0);
+    const integerDigits = Math.max(leftDecimal === undefined
+        ? leftInteger.digits
+        : leftDecimal.precision - leftDecimal.scale, rightDecimal === undefined
+        ? rightInteger.digits
+        : rightDecimal.precision - rightDecimal.scale);
+    const precision = integerDigits + scale;
+    return precision <= 38 ? `DECIMAL(${precision},${scale})` : undefined;
+}
+function commonIntegerType(left, right) {
+    if (left.signed === right.signed) {
+        const bits = Math.max(left.bits, right.bits);
+        return integerTypeName(left.signed, bits);
+    }
+    const signed = left.signed ? left : right;
+    const unsigned = left.signed ? right : left;
+    const requiredBits = Math.max(signed.bits, nextBits(unsigned.bits));
+    return requiredBits > 128 ? undefined : integerTypeName(true, requiredBits);
+}
+function nextBits(bits) {
+    if (bits <= 8)
+        return 16;
+    if (bits <= 16)
+        return 32;
+    if (bits <= 32)
+        return 64;
+    if (bits <= 64)
+        return 128;
+    return 256;
+}
+function integerTypeName(signed, bits) {
+    const names = signed
+        ? {
+            8: "TINYINT",
+            16: "SMALLINT",
+            32: "INTEGER",
+            64: "BIGINT",
+            128: "HUGEINT",
+        }
+        : {
+            8: "UTINYINT",
+            16: "USMALLINT",
+            32: "UINTEGER",
+            64: "UBIGINT",
+            128: "UHUGEINT",
+        };
+    return names[bits];
+}
+function isFloating(type) {
+    return type === "FLOAT" || type === "DOUBLE";
+}
+function isDecimal(type) {
+    return /^DECIMAL\(\d+,\d+\)$/.test(type);
+}
+function parseDecimal(type) {
+    const match = /^DECIMAL\((\d+),(\d+)\)$/.exec(type);
+    return match === null
+        ? undefined
+        : { precision: Number(match[1]), scale: Number(match[2]) };
+}
+function decimalScale(type) {
+    return parseDecimal(type)?.scale;
+}

package/script/helpers/getGraphWeightColumn.d.ts

@@ -0,0 +1,10 @@
+import type { TableSchema } from "./pendingOps.js";
+type GraphWeightColumn = {
+    column: string;
+    distanceType: string;
+    type: string;
+};
+/** Resolves a numeric graph weight and a precision-preserving sum type. */
+export default function getGraphWeightColumn(schema: TableSchema, requestedWeight: string, method: string): GraphWeightColumn;
+export {};
+//# sourceMappingURL=getGraphWeightColumn.d.ts.map

package/script/helpers/getGraphWeightColumn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGraphWeightColumn.d.ts","sourceRoot":"","sources":["../../src/helpers/getGraphWeightColumn.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,KAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAcF,2EAA2E;AAC3E,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,MAAM,EAAE,WAAW,EACnB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,MAAM,GACb,iBAAiB,CAsCnB"}

package/script/helpers/getGraphWeightColumn.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getGraphWeightColumn;
+const foldIdentifier_js_1 = __importDefault(require("./foldIdentifier.js"));
+const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
+const integerTypes = new Set([
+    "TINYINT",
+    "SMALLINT",
+    "INTEGER",
+    "BIGINT",
+    "UTINYINT",
+    "USMALLINT",
+    "UINTEGER",
+    "UBIGINT",
+]);
+const wideIntegerTypes = new Set(["HUGEINT", "UHUGEINT", "BIGNUM"]);
+/** Resolves a numeric graph weight and a precision-preserving sum type. */
+function getGraphWeightColumn(schema, requestedWeight, method) {
+    const folded = (0, foldIdentifier_js_1.default)(requestedWeight);
+    const column = Object.keys(schema).find((name) => (0, foldIdentifier_js_1.default)(name) === folded);
+    if (column === undefined) {
+        throw new Error(`${method} the column ${(0, quoteIdentifier_js_1.default)(requestedWeight)} does not exist. Check for typos, or load the data first.`);
+    }
+    const type = schema[column].toUpperCase().replace(/^REAL$/, "FLOAT");
+    if (integerTypes.has(type)) {
+        return { column, type, distanceType: "HUGEINT" };
+    }
+    if (wideIntegerTypes.has(type)) {
+        return { column, type, distanceType: "BIGNUM" };
+    }
+    if (type === "FLOAT" || type === "DOUBLE") {
+        return { column, type, distanceType: type };
+    }
+    const decimal = /^DECIMAL\((\d+),(\d+)\)$/.exec(type);
+    if (decimal !== null) {
+        return {
+            column,
+            type,
+            distanceType: `DECIMAL(38,${Number(decimal[2])})`,
+        };
+    }
+    throw new TypeError(`${method} requires a numeric weight column, but column ${(0, quoteIdentifier_js_1.default)(column)} has type ${type}.`);
+}

package/script/helpers/graphRouteResultSchema.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from "./pendingOps.js";
+/** Derives the route result schema while preserving input columns and types. */
+export default function graphRouteResultSchema(schema: TableSchema, distanceType: string, method: string): TableSchema;
+//# sourceMappingURL=graphRouteResultSchema.d.ts.map

package/script/helpers/graphRouteResultSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphRouteResultSchema.d.ts","sourceRoot":"","sources":["../../src/helpers/graphRouteResultSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAGnD,gFAAgF;AAChF,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,MAAM,EAAE,WAAW,EACnB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,GACb,WAAW,CASb"}

package/script/helpers/graphRouteResultSchema.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = graphRouteResultSchema;
+const validateGraphRouteResultSchema_js_1 = __importDefault(require("./validateGraphRouteResultSchema.js"));
+/** Derives the route result schema while preserving input columns and types. */
+function graphRouteResultSchema(schema, distanceType, method) {
+    (0, validateGraphRouteResultSchema_js_1.default)(schema, method);
+    return {
+        pathId: "BIGINT",
+        step: "BIGINT",
+        weight: distanceType,
+        total: distanceType,
+        ...schema,
+    };
+}