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

package/esm/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/esm/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/esm/helpers/formatMissingTables.js

@@ -2,11 +2,6 @@ import quoteIdentifier from "./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(
@@ -15,6 +10,14 @@ import quoteIdentifier from "./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.
  */
 export default function formatMissingTables(method, missingTables, availableTables) {
     const missing = [...missingTables].sort();

package/esm/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/esm/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/esm/helpers/formatNumber.js

@@ -1,25 +1,31 @@
 /**
  * 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" &&
@@ -39,40 +45,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.
  */
 export default function formatNumber(number, options = {}) {
     if (typeof number !== "number") {

package/esm/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/esm/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/esm/helpers/getGraphEdgeIdColumn.js

@@ -0,0 +1,25 @@
+import foldIdentifier from "./foldIdentifier.js";
+import getGraphEndpointColumns from "./getGraphEndpointColumns.js";
+import quoteIdentifier from "./quoteIdentifier.js";
+/** Resolves a route edge-ID column and its exact comparison type. */
+export default function getGraphEdgeIdColumn(schema, requestedEdgeId, method) {
+    const folded = foldIdentifier(requestedEdgeId);
+    const column = Object.keys(schema).find((name) => foldIdentifier(name) === folded);
+    if (column === undefined) {
+        throw new Error(`${method} the column ${quoteIdentifier(requestedEdgeId)} does not exist. Check for typos, or load the data first.`);
+    }
+    try {
+        const resolved = getGraphEndpointColumns({ [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 ${quoteIdentifier(column)} has type ${schema[column]}.`);
+        }
+        throw error;
+    }
+}

package/esm/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/esm/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/esm/helpers/getGraphEndpointColumns.js

@@ -0,0 +1,160 @@
+import foldIdentifier from "./foldIdentifier.js";
+import quoteIdentifier from "./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. */
+export default 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).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 ${quoteIdentifier(unsupported.column)} has type ${unsupported.type}.`);
+    }
+    if (sourceKind.family !== targetKind.family) {
+        throw new TypeError(`${method} requires compatible source and target ID types, but ${quoteIdentifier(source)} has type ${sourceType} and ${quoteIdentifier(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 = foldIdentifier(requested);
+    return Object.keys(schema).find((column) => foldIdentifier(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/esm/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/esm/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/esm/helpers/getGraphWeightColumn.js

@@ -0,0 +1,40 @@
+import foldIdentifier from "./foldIdentifier.js";
+import quoteIdentifier from "./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. */
+export default function getGraphWeightColumn(schema, requestedWeight, method) {
+    const folded = foldIdentifier(requestedWeight);
+    const column = Object.keys(schema).find((name) => foldIdentifier(name) === folded);
+    if (column === undefined) {
+        throw new Error(`${method} the column ${quoteIdentifier(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 ${quoteIdentifier(column)} has type ${type}.`);
+}

package/esm/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/esm/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/esm/helpers/graphRouteResultSchema.js

@@ -0,0 +1,12 @@
+import validateGraphRouteResultSchema from "./validateGraphRouteResultSchema.js";
+/** Derives the route result schema while preserving input columns and types. */
+export default function graphRouteResultSchema(schema, distanceType, method) {
+    validateGraphRouteResultSchema(schema, method);
+    return {
+        pathId: "BIGINT",
+        step: "BIGINT",
+        weight: distanceType,
+        total: distanceType,
+        ...schema,
+    };
+}

package/esm/helpers/graphRouteResultSelect.d.ts

@@ -0,0 +1,4 @@
+import type { GraphEdgeIdColumn } from "./getGraphEdgeIdColumn.js";
+/** Joins ranked route steps to their original input rows for final output. */
+export default function graphRouteResultSelect(rankedRelation: string, input: string, edgeIdColumn: GraphEdgeIdColumn, includeStart?: boolean): string;
+//# sourceMappingURL=graphRouteResultSelect.d.ts.map

package/esm/helpers/graphRouteResultSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphRouteResultSelect.d.ts","sourceRoot":"","sources":["../../src/helpers/graphRouteResultSelect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,8EAA8E;AAC9E,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,iBAAiB,EAC/B,YAAY,UAAQ,GACnB,MAAM,CAyBR"}

package/esm/helpers/graphRouteResultSelect.js

@@ -0,0 +1,22 @@
+import quoteIdentifier from "./quoteIdentifier.js";
+/** Joins ranked route steps to their original input rows for final output. */
+export default function graphRouteResultSelect(rankedRelation, input, edgeIdColumn, includeStart = false) {
+    const q = quoteIdentifier;
+    const routeStep = `${q("unnested")}.${q("route_step")}`;
+    const originalEdgeId = `${q("original")}.${q(edgeIdColumn.column)}`;
+    const edgeMatch = edgeIdColumn.family === "string"
+        ? `ENCODE(CAST(${originalEdgeId} AS VARCHAR)) =
+        ENCODE(${routeStep}.${q("edgeId")})`
+        : `CAST(${originalEdgeId} AS ${edgeIdColumn.idType}) =
+        ${routeStep}.${q("edgeId")}`;
+    return `SELECT ${includeStart ? `${q("ranked")}.${q("start")},\n      ` : ""}${q("ranked")}.${q("pathId")},
+      CAST(${q("unnested")}.${q("step")} AS BIGINT) AS ${q("step")},
+      ${routeStep}.${q("weight")} AS ${q("weight")},
+      ${routeStep}.${q("distance")} AS ${q("total")},
+      ${q("original")}.*
+    FROM ${rankedRelation} AS ${q("ranked")},
+      UNNEST(${q("ranked")}.${q("steps")}) WITH ORDINALITY AS ${q("unnested")}(${q("route_step")}, ${q("step")})
+    INNER JOIN ${input} AS ${q("original")}
+      ON ${edgeMatch}
+    ORDER BY ${includeStart ? `${q("ranked")}.${q("__start_key")}, ` : ""}${q("ranked")}.${q("pathId")}, ${q("unnested")}.${q("step")}`;
+}

package/esm/helpers/hasGeometryColumn.d.ts

@@ -5,9 +5,6 @@ import type SimpleTable from "../class/SimpleTable.js";
  * Uses `getTypes()` to inspect column types and checks for any column
  * whose type normalizes to `"geometry"`.
  *
- * @param table - The SimpleTable instance to inspect.
- * @returns `true` if at least one geometry column exists, `false` otherwise.
- *
  * @example
  * ```ts
  * const hasGeo = await hasGeometryColumn(table);
@@ -15,6 +12,10 @@ import type SimpleTable from "../class/SimpleTable.js";
  *   console.log("This table contains geometry columns");
  * }
  * ```
+ *
+ * @param table - The SimpleTable instance to inspect.
+ *
+ * @returns `true` if at least one geometry column exists, `false` otherwise.
  */
 export default function hasGeometryColumn(table: SimpleTable): Promise<boolean>;
 //# sourceMappingURL=hasGeometryColumn.d.ts.map

package/esm/helpers/hasGeometryColumn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hasGeometryColumn.d.ts","sourceRoot":"","sources":["../../src/helpers/hasGeometryColumn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAA8B,iBAAiB,CAC7C,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,OAAO,CAAC,CAGlB"}
+{"version":3,"file":"hasGeometryColumn.d.ts","sourceRoot":"","sources":["../../src/helpers/hasGeometryColumn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAA8B,iBAAiB,CAC7C,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC,OAAO,CAAC,CAGlB"}

package/esm/helpers/hasGeometryColumn.js

@@ -4,9 +4,6 @@
  * Uses `getTypes()` to inspect column types and checks for any column
  * whose type normalizes to `"geometry"`.
  *
- * @param table - The SimpleTable instance to inspect.
- * @returns `true` if at least one geometry column exists, `false` otherwise.
- *
  * @example
  * ```ts
  * const hasGeo = await hasGeometryColumn(table);
@@ -14,6 +11,10 @@
  *   console.log("This table contains geometry columns");
  * }
  * ```
+ *
+ * @param table - The SimpleTable instance to inspect.
+ *
+ * @returns `true` if at least one geometry column exists, `false` otherwise.
  */
 export default async function hasGeometryColumn(table) {
     const types = await table.getTypes();

package/esm/helpers/inspectGraphConnectivity.d.ts

@@ -0,0 +1,10 @@
+import type { DuckDBConnection } from "@duckdb/node-api";
+/**
+ * Inspect connectivity of an edge relation while transferring ids, not vectors.
+ * Isolated vertices count as one-point components. Invalid ids fail closed.
+ */
+export default function inspectGraphConnectivity(connection: DuckDBConnection, edges: string, vertexCount: number): Promise<{
+    componentCount: number;
+    sizes: number[];
+}>;
+//# sourceMappingURL=inspectGraphConnectivity.d.ts.map

package/esm/helpers/inspectGraphConnectivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspectGraphConnectivity.d.ts","sourceRoot":"","sources":["../../src/helpers/inspectGraphConnectivity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;GAGG;AACH,wBAA8B,wBAAwB,CACpD,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAoDtD"}