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

package/script/helpers/validateNumericalAnalysis.js

@@ -9,12 +9,6 @@ const keepNumericalColumns_js_1 = __importDefault(require("./keepNumericalColumn
 /**
  * Validates the column options shared by numerical pair analyses.
  *
- * @param types - The schema of the table being analyzed.
- * @param options - The optional x and y columns selected by the caller.
- * @param method - The SDA method performing the analysis.
- * @param tableName - The name of the table being analyzed.
- * @returns All numeric columns in the table schema.
- *
  * @example
  * ```ts
  * const columns = validateNumericalAnalysis(
@@ -24,6 +18,16 @@ const keepNumericalColumns_js_1 = __importDefault(require("./keepNumericalColumn
  *   "measurements",
  * );
  * ```
+ *
+ * @param types - The schema of the table being analyzed.
+ *
+ * @param options - The optional x and y columns selected by the caller.
+ *
+ * @param method - The SDA method performing the analysis.
+ *
+ * @param tableName - The name of the table being analyzed.
+ *
+ * @returns All numeric columns in the table schema.
  */
 function validateNumericalAnalysis(types, options, method, tableName) {
     if (options.x === undefined && options.y !== undefined) {

package/script/helpers/validateVectorRowIds.d.ts

@@ -0,0 +1,4 @@
+import type { DuckDBConnection } from "@duckdb/node-api";
+/** Validate the positional identity contract before bounded vector scans. */
+export default function validateVectorRowIds(connection: DuckDBConnection, rows: string, count: number): Promise<void>;
+//# sourceMappingURL=validateVectorRowIds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateVectorRowIds.d.ts","sourceRoot":"","sources":["../../src/helpers/validateVectorRowIds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,6EAA6E;AAC7E,wBAA8B,oBAAoB,CAChD,UAAU,EAAE,gBAAgB,EAC5B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAuBf"}

package/script/helpers/validateVectorRowIds.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = validateVectorRowIds;
+/** Validate the positional identity contract before bounded vector scans. */
+async function validateVectorRowIds(connection, rows, count) {
+    // Graph state and DuckDB scratch schemas use signed INTEGER vertex ids.
+    if (!Number.isSafeInteger(count) || count < 1 || count > 2147483647) {
+        throw new Error("Vector row count must fit a positive INTEGER vertex count.");
+    }
+    const [actual, distinct, minimum, maximum, invalid] = (await connection.runAndReadAll(`SELECT count(*),count(DISTINCT vertex),
+      min(vertex),max(vertex),count(*) FILTER (
+        WHERE vertex IS NULL OR vertex!=trunc(vertex)) FROM ${rows}`))
+        .getRowsJS()[0];
+    if (Number(actual) !== count || Number(distinct) !== count ||
+        Number(minimum) !== 0 || Number(maximum) !== count - 1 ||
+        Number(invalid) !== 0) {
+        throw new Error(`Vector rows must contain exactly ${count} unique integer vertex ids from 0 to ${count - 1}.`);
+    }
+}

package/script/helpers/vectorDistanceExpression.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Build a DOUBLE-precision distance expression for prepared vector aliases.
+ * Cosine callers first stabilize their private rows with stabilizeCosineVectors.
+ */
+export default function vectorDistanceExpression(left: string, right: string, metric: "euclidean" | "cosine"): string;
+//# sourceMappingURL=vectorDistanceExpression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vectorDistanceExpression.d.ts","sourceRoot":"","sources":["../../src/helpers/vectorDistanceExpression.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAC9C,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,WAAW,GAAG,QAAQ,GAC7B,MAAM,CAKR"}

package/script/helpers/vectorDistanceExpression.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = vectorDistanceExpression;
+/**
+ * Build a DOUBLE-precision distance expression for prepared vector aliases.
+ * Cosine callers first stabilize their private rows with stabilizeCosineVectors.
+ */
+function vectorDistanceExpression(left, right, metric) {
+    if (metric === "euclidean")
+        return `array_distance(${left},${right})`;
+    // DuckDB can return tiny positive or negative errors for equal/cosine-aligned
+    // vectors. Exact equality also makes duplicate behavior deterministic.
+    return `CASE WHEN ${left}=${right} THEN 0 ELSE greatest(0,array_cosine_distance(${left},${right})) END`;
+}

package/script/helpers/wrapString.d.ts

@@ -4,13 +4,6 @@
  * will be broken at the character boundary. This function is primarily used
  * for preparing text to be displayed in console tables.
  *
- * @param str - The string to wrap.
- * @param maxWidth - The maximum width of each line.
- * @param wordWrap - If true, attempts to break at word boundaries. If false,
- *   breaks at character boundaries. Defaults to `true`.
- * @returns The wrapped string with newline characters inserted at appropriate
- *   positions.
- *
  * @example
  * ```typescript
  * const text = "This is a very long sentence that needs to be wrapped";
@@ -30,6 +23,16 @@
  * // Output: Thisisaver
  * //         ylongword
  * ```
+ *
+ * @param str - The string to wrap.
+ *
+ * @param maxWidth - The maximum width of each line.
+ *
+ * @param wordWrap - If true, attempts to break at word boundaries. If false,
+ *   breaks at character boundaries. Defaults to `true`.
+ *
+ * @returns The wrapped string with newline characters inserted at appropriate
+ *   positions.
  */
 export default function wrapString(str: string, maxWidth: number, wordWrap?: boolean): string;
 //# sourceMappingURL=wrapString.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wrapString.d.ts","sourceRoot":"","sources":["../../src/helpers/wrapString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAO,GACd,MAAM,CAqDR"}
+{"version":3,"file":"wrapString.d.ts","sourceRoot":"","sources":["../../src/helpers/wrapString.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,UAAU,UAAU,CAChC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,QAAQ,UAAO,GACd,MAAM,CAqDR"}

package/script/helpers/wrapString.js

@@ -7,13 +7,6 @@ exports.default = wrapString;
  * will be broken at the character boundary. This function is primarily used
  * for preparing text to be displayed in console tables.
  *
- * @param str - The string to wrap.
- * @param maxWidth - The maximum width of each line.
- * @param wordWrap - If true, attempts to break at word boundaries. If false,
- *   breaks at character boundaries. Defaults to `true`.
- * @returns The wrapped string with newline characters inserted at appropriate
- *   positions.
- *
  * @example
  * ```typescript
  * const text = "This is a very long sentence that needs to be wrapped";
@@ -33,6 +26,16 @@ exports.default = wrapString;
  * // Output: Thisisaver
  * //         ylongword
  * ```
+ *
+ * @param str - The string to wrap.
+ *
+ * @param maxWidth - The maximum width of each line.
+ *
+ * @param wordWrap - If true, attempts to break at word boundaries. If false,
+ *   breaks at character boundaries. Defaults to `true`.
+ *
+ * @returns The wrapped string with newline characters inserted at appropriate
+ *   positions.
  */
 function wrapString(str, maxWidth, wordWrap = true) {
     if (str.length <= maxWidth) {

package/script/methods/addId.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function addId(simpleTable: SimpleTable, newColumn: string, options?: {
+    prefix?: string;
+}): void;
+//# sourceMappingURL=addId.d.ts.map

package/script/methods/addId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addId.d.ts","sourceRoot":"","sources":["../../src/methods/addId.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,QAgDlC"}

package/script/methods/addId.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addId;
+const assertNewColumns_js_1 = __importDefault(require("../helpers/assertNewColumns.js"));
+const foldIdentifier_js_1 = __importDefault(require("../helpers/foldIdentifier.js"));
+const mergeOptions_js_1 = __importDefault(require("../helpers/mergeOptions.js"));
+const queryDB_js_1 = __importDefault(require("../helpers/queryDB.js"));
+const queueOp_js_1 = __importDefault(require("../helpers/queueOp.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+function addId(simpleTable, newColumn, options = {}) {
+    if (typeof newColumn !== "string") {
+        throw new TypeError("addId() newColumn must be a string.");
+    }
+    if (options.prefix !== undefined && typeof options.prefix !== "string") {
+        throw new TypeError("addId() options.prefix must be a string.");
+    }
+    // Materialize preceding operations so IDs follow their resulting row order.
+    options = structuredClone(options);
+    (0, queueOp_js_1.default)(simpleTable, {
+        kind: "barrier",
+        method: "addId()",
+        parameters: { newColumn, options },
+        execute: async () => {
+            const types = await simpleTable.getTypes();
+            const existingColumn = Object.keys(types).find((column) => (0, foldIdentifier_js_1.default)(column) === (0, foldIdentifier_js_1.default)(newColumn));
+            (0, assertNewColumns_js_1.default)(types, [existingColumn ?? newColumn], "addId()");
+            // An empty window preserves scan order without referencing rowid, which
+            // may be shadowed by a user column.
+            const rowNumber = "(ROW_NUMBER() OVER () - 1)";
+            const id = options.prefix === undefined
+                ? rowNumber
+                : `CONCAT(?, CAST(${rowNumber} AS VARCHAR))`;
+            await (0, queryDB_js_1.default)(simpleTable, `CREATE OR REPLACE TABLE ${(0, quoteIdentifier_js_1.default)(simpleTable.name)} AS SELECT *, ${id} AS ${(0, quoteIdentifier_js_1.default)(newColumn)} FROM ${(0, quoteIdentifier_js_1.default)(simpleTable.name)}`, (0, mergeOptions_js_1.default)(simpleTable, {
+                table: simpleTable.name,
+                method: "addId()",
+                parameters: { newColumn, options },
+                values: options.prefix === undefined ? undefined : [options.prefix],
+            }));
+        },
+    });
+}

package/script/methods/cache.js

@@ -46,7 +46,7 @@ const serializeCacheInputs_js_1 = __importStar(require("../helpers/serializeCach
 const tableGeneration_js_1 = require("../helpers/tableGeneration.js");
 const cacheDatabase_js_1 = require("../helpers/cacheDatabase.js");
 const cacheTableDependencies_js_1 = require("../helpers/cacheTableDependencies.js");
-const CACHE_FORMAT_VERSION = "duckdb-v4";
+const CACHE_FORMAT_VERSION = "duckdb-v5";
 async function cache(table, compute, options = {}) {
     // If cache() is itself called from another cache computation, the outer
     // computation depends on the table produced here.

package/script/methods/commonNeighbors.d.ts

@@ -0,0 +1,10 @@
+import type SimpleTable from "../class/SimpleTable.js";
+import { type GraphId } from "../helpers/prepareGraphStarts.js";
+import { type GraphDirection } from "../helpers/prepareGraphTraversal.js";
+type CommonNeighborsOptions = {
+    direction?: GraphDirection;
+    outputTable?: string | boolean;
+};
+export default function commonNeighbors(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, nodeA: GraphId, nodeB: GraphId, options?: CommonNeighborsOptions): SimpleTable;
+export {};
+//# sourceMappingURL=commonNeighbors.d.ts.map

package/script/methods/commonNeighbors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commonNeighbors.d.ts","sourceRoot":"","sources":["../../src/methods/commonNeighbors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,OAA2B,EACzB,KAAK,OAAO,EAEb,MAAM,kCAAkC,CAAC;AAC1C,OAA8B,EAC5B,KAAK,cAAc,EAEpB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,sBAAsB,GAAG;IAC5B,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,eAAe,CACrC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,sBAA2B,GACnC,WAAW,CAwDb"}

package/script/methods/commonNeighbors.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = commonNeighbors;
+const prepareGraphStarts_js_1 = __importDefault(require("../helpers/prepareGraphStarts.js"));
+const prepareGraphTraversal_js_1 = __importStar(require("../helpers/prepareGraphTraversal.js"));
+const queueGraphResult_js_1 = __importDefault(require("../helpers/queueGraphResult.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+function commonNeighbors(simpleTable, sourceColumn, targetColumn, nodeA, nodeB, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("commonNeighbors() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("commonNeighbors() targetColumn must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("commonNeighbors() options must be an object.");
+    }
+    if (options.direction !== undefined &&
+        !["outgoing", "incoming", "both"].includes(options.direction)) {
+        throw new TypeError('commonNeighbors() options.direction must be "outgoing", "incoming", or "both".');
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("commonNeighbors() options.outputTable must be a string or boolean.");
+    }
+    const nodes = prepareNodes(nodeA, nodeB);
+    options = structuredClone(options);
+    const direction = options.direction ?? "outgoing";
+    const parameters = { sourceColumn, targetColumn, nodeA, nodeB, options };
+    return (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "commonNeighbors()",
+        parameters,
+        outputTable: options.outputTable,
+        values: (schema) => {
+            validateNodes(schema, sourceColumn, targetColumn, nodes);
+            return nodes.values;
+        },
+        buildSelect: (input, schema) => commonNeighborsSelect(input, schema, sourceColumn, targetColumn, nodes, direction),
+        outputSchema: (schema) => ({
+            node: validateNodes(schema, sourceColumn, targetColumn, nodes).idType,
+        }),
+    });
+}
+function prepareNodes(nodeA, nodeB) {
+    if (Array.isArray(nodeA)) {
+        throw new TypeError("commonNeighbors() nodeA must be one node ID.");
+    }
+    if (Array.isArray(nodeB)) {
+        throw new TypeError("commonNeighbors() nodeB must be one node ID.");
+    }
+    const first = (0, prepareGraphStarts_js_1.default)(nodeA, "commonNeighbors()", "nodeA", true);
+    const second = (0, prepareGraphStarts_js_1.default)(nodeB, "commonNeighbors()", "nodeB", true);
+    if (first.family !== second.family) {
+        throw new TypeError("commonNeighbors() nodeA and nodeB must both be string IDs or both be numeric IDs.");
+    }
+    if (first.values[0] === second.values[0]) {
+        throw new TypeError("commonNeighbors() nodeA and nodeB must be different.");
+    }
+    return {
+        family: first.family,
+        numericValues: [...first.numericValues, ...second.numericValues],
+        values: [first.values[0], second.values[0]],
+    };
+}
+function validateNodes(schema, source, target, nodes) {
+    return (0, prepareGraphTraversal_js_1.validateGraphStarts)(schema, source, target, nodes, "commonNeighbors()", "nodeA and nodeB");
+}
+function commonNeighborsSelect(input, schema, source, target, nodes, direction) {
+    const prepared = (0, prepareGraphTraversal_js_1.default)(input, schema, source, target, nodes, "commonNeighbors()", "nodeA and nodeB");
+    const relations = prepared.relationNames([
+        "graph_requested_nodes",
+        "graph_edges",
+        "graph_neighbor_memberships",
+        "graph_common_neighbors",
+    ]);
+    const requested = relations.graph_requested_nodes;
+    const edges = relations.graph_edges;
+    const memberships = relations.graph_neighbor_memberships;
+    const common = relations.graph_common_neighbors;
+    const q = quoteIdentifier_js_1.default;
+    return `WITH ${requested}(${q("node")}) AS (
+      VALUES ${prepared.startValues}
+    ), ${edges} AS (
+      ${prepared.edges(direction)}
+    ), ${memberships} AS (
+      SELECT ${q("requested")}.${q("node")} AS ${q("requested_node")},
+        ${q("edges")}.${q("__from_key")} AS ${q("__requested_key")},
+        ${q("edges")}.${q("__to")} AS ${q("node")},
+        ${q("edges")}.${q("__to_key")} AS ${q("__node_key")}
+      FROM ${edges} AS ${q("edges")}
+      INNER JOIN ${requested} AS ${q("requested")}
+        ON ${q("edges")}.${q("__from_key")} =
+          ${prepared.key(`${q("requested")}.${q("node")}`)}
+    ), ${common} AS (
+      SELECT MIN(${q("node")}) AS ${q("node")}, ${q("__node_key")}
+      FROM ${memberships}
+      GROUP BY ${q("__node_key")}
+      HAVING COUNT(DISTINCT ${q("__requested_key")}) = 2
+    )
+    SELECT ${q("node")}
+    FROM ${common}
+    ORDER BY ${q("__node_key")}`;
+}

package/script/methods/connectedComponents.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+import { type GraphTemporalOptions } from "../helpers/prepareGraphTemporalSql.js";
+type ConnectedComponentsOptions = GraphTemporalOptions & {
+    mode?: "weak" | "strong";
+    outputTable?: string | boolean;
+};
+export default function connectedComponents(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, options?: ConnectedComponentsOptions): SimpleTable;
+export {};
+//# sourceMappingURL=connectedComponents.d.ts.map

package/script/methods/connectedComponents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectedComponents.d.ts","sourceRoot":"","sources":["../../src/methods/connectedComponents.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAGvD,OAAgC,EAC9B,KAAK,oBAAoB,EAG1B,MAAM,uCAAuC,CAAC;AAM/C,KAAK,0BAA0B,GAAG,oBAAoB,GAAG;IACvD,IAAI,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,mBAAmB,CACzC,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,0BAA+B,GACvC,WAAW,CAqFb"}

package/script/methods/connectedComponents.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = connectedComponents;
+const buildChronologicalGraphComponentsSql_js_1 = __importDefault(require("../helpers/buildChronologicalGraphComponentsSql.js"));
+const buildWeakGraphComponentsSql_js_1 = __importDefault(require("../helpers/buildWeakGraphComponentsSql.js"));
+const getGraphEndpointColumns_js_1 = __importDefault(require("../helpers/getGraphEndpointColumns.js"));
+const prepareGraphTemporalSql_js_1 = __importStar(require("../helpers/prepareGraphTemporalSql.js"));
+const prepareGraphTraversal_js_1 = require("../helpers/prepareGraphTraversal.js");
+const queueGraphResult_js_1 = __importDefault(require("../helpers/queueGraphResult.js"));
+const quoteIdentifier_js_1 = __importDefault(require("../helpers/quoteIdentifier.js"));
+const validateGraphTemporalEvents_js_1 = __importDefault(require("../helpers/validateGraphTemporalEvents.js"));
+function connectedComponents(simpleTable, sourceColumn, targetColumn, options = {}) {
+    if (typeof sourceColumn !== "string") {
+        throw new TypeError("connectedComponents() sourceColumn must be a string.");
+    }
+    if (typeof targetColumn !== "string") {
+        throw new TypeError("connectedComponents() targetColumn must be a string.");
+    }
+    if (options === null || typeof options !== "object" || Array.isArray(options)) {
+        throw new TypeError("connectedComponents() options must be an object.");
+    }
+    if (options.mode !== undefined &&
+        !["weak", "strong"].includes(options.mode)) {
+        throw new TypeError('connectedComponents() options.mode must be "weak" or "strong".');
+    }
+    if (options.outputTable !== undefined &&
+        typeof options.outputTable !== "string" &&
+        typeof options.outputTable !== "boolean") {
+        throw new TypeError("connectedComponents() options.outputTable must be a string or boolean.");
+    }
+    const temporalOptions = (0, prepareGraphTemporalSql_js_1.prepareGraphTemporalOptions)(options, undefined, "connectedComponents()");
+    if (temporalOptions !== undefined && options.mode !== "strong") {
+        throw new TypeError('connectedComponents() chronological options require options.mode to be explicitly set to "strong".');
+    }
+    options = structuredClone(options);
+    const mode = options.mode ?? "weak";
+    const parameters = { sourceColumn, targetColumn, options };
+    return (0, queueGraphResult_js_1.default)(simpleTable, {
+        method: "connectedComponents()",
+        parameters,
+        outputTable: options.outputTable,
+        preflight: temporalOptions === undefined
+            ? undefined
+            : (input) => (0, validateGraphTemporalEvents_js_1.default)(input, temporalOptions, "connectedComponents()", parameters),
+        values: (schema) => {
+            const temporal = validateInputs(schema, sourceColumn, targetColumn, temporalOptions).temporal;
+            return temporal === undefined ? [] : [temporal.gapParameter];
+        },
+        buildSelect: (input, schema) => connectedComponentsSelect(input, schema, sourceColumn, targetColumn, mode, temporalOptions),
+        outputSchema: (schema) => ({
+            componentId: "BIGINT",
+            node: validateInputs(schema, sourceColumn, targetColumn, temporalOptions).endpoints.idType,
+        }),
+    });
+}
+function validateEndpoints(schema, source, target) {
+    return (0, getGraphEndpointColumns_js_1.default)(schema, source, target, "connectedComponents()");
+}
+function validateInputs(schema, source, target, temporalOptions) {
+    const endpoints = validateEndpoints(schema, source, target);
+    const temporal = temporalOptions === undefined
+        ? undefined
+        : (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "connectedComponents()");
+    return { endpoints, temporal };
+}
+function connectedComponentsSelect(input, schema, source, target, mode, temporalOptions) {
+    const prepared = (0, prepareGraphTraversal_js_1.prepareGraphSql)(input, schema, source, target, "connectedComponents()");
+    if (temporalOptions !== undefined) {
+        return (0, buildChronologicalGraphComponentsSql_js_1.default)(prepared, (0, prepareGraphTemporalSql_js_1.default)(schema, temporalOptions, "connectedComponents()"));
+    }
+    const relationNames = mode === "weak"
+        ? [
+            "graph_edges",
+            "graph_nodes",
+            "graph_component_labels",
+            "graph_component_roots",
+        ]
+        : [
+            "graph_edges",
+            "graph_nodes",
+            "graph_reachable",
+            "graph_component_members",
+            "graph_component_roots",
+        ];
+    const relations = prepared.relationNames(relationNames);
+    const edges = relations.graph_edges;
+    const nodes = relations.graph_nodes;
+    const roots = relations.graph_component_roots;
+    const q = quoteIdentifier_js_1.default;
+    const common = `${edges} AS (
+      ${prepared.edges(mode === "weak" ? "both" : "outgoing")}
+    ), ${nodes} AS (
+      SELECT ${q("__from")} AS ${q("node")},
+        ${q("__from_key")} AS ${q("__key")}
+      FROM ${edges}
+      UNION
+      SELECT ${q("__to")} AS ${q("node")},
+        ${q("__to_key")} AS ${q("__key")}
+      FROM ${edges}
+    )`;
+    if (mode === "weak") {
+        const labels = relations.graph_component_labels;
+        return `WITH RECURSIVE ${common}, ${(0, buildWeakGraphComponentsSql_js_1.default)(edges, nodes, labels, roots)}
+    SELECT ${q("roots")}.${q("componentId")}, ${q("labels")}.${q("node")}
+    FROM ${labels} AS ${q("labels")}
+    INNER JOIN ${roots} AS ${q("roots")}
+      ON ${q("labels")}.${q("__root_key")} =
+        ${q("roots")}.${q("__root_key")}
+    ORDER BY ${q("labels")}.${q("__node_key")}`;
+    }
+    const reachable = relations.graph_reachable;
+    const members = relations.graph_component_members;
+    return `WITH RECURSIVE ${common}, ${reachable}(
+      ${q("__start_key")}, ${q("__node_key")}
+    ) AS (
+      SELECT ${q("__key")}, ${q("__key")} FROM ${nodes}
+      UNION
+      SELECT ${q("reached")}.${q("__start_key")},
+        ${q("edges")}.${q("__to_key")}
+      FROM ${reachable} AS ${q("reached")}
+      INNER JOIN ${edges} AS ${q("edges")}
+        ON ${q("reached")}.${q("__node_key")} =
+          ${q("edges")}.${q("__from_key")}
+    ), ${members} AS (
+      SELECT ${q("nodes")}.${q("node")}, ${q("nodes")}.${q("__key")},
+        MIN(${q("forward")}.${q("__start_key")}) AS ${q("__root_key")}
+      FROM ${nodes} AS ${q("nodes")}
+      INNER JOIN ${reachable} AS ${q("forward")}
+        ON ${q("nodes")}.${q("__key")} =
+          ${q("forward")}.${q("__node_key")}
+      INNER JOIN ${reachable} AS ${q("reverse")}
+        ON ${q("forward")}.${q("__start_key")} =
+          ${q("reverse")}.${q("__node_key")}
+        AND ${q("nodes")}.${q("__key")} =
+          ${q("reverse")}.${q("__start_key")}
+      GROUP BY ${q("nodes")}.${q("node")}, ${q("nodes")}.${q("__key")}
+    ), ${roots} AS (
+      SELECT ${q("__root_key")},
+        CAST(row_number() OVER (ORDER BY ${q("__root_key")}) - 1 AS BIGINT)
+          AS ${q("componentId")}
+      FROM (SELECT DISTINCT ${q("__root_key")} FROM ${members})
+        AS ${q("distinct_roots")}
+    )
+    SELECT ${q("roots")}.${q("componentId")}, ${q("members")}.${q("node")}
+    FROM ${members} AS ${q("members")}
+    INNER JOIN ${roots} AS ${q("roots")}
+      ON ${q("members")}.${q("__root_key")} =
+        ${q("roots")}.${q("__root_key")}
+    ORDER BY ${q("members")}.${q("__key")}`;
+}

package/script/methods/degree.d.ts

@@ -0,0 +1,9 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type DegreeOptions = {
+    count?: "edges" | "neighbors";
+    weight?: string;
+    outputTable?: string | boolean;
+};
+export default function degree(simpleTable: SimpleTable, sourceColumn: string, targetColumn: string, options?: DegreeOptions): SimpleTable;
+export {};
+//# sourceMappingURL=degree.d.ts.map

package/script/methods/degree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"degree.d.ts","sourceRoot":"","sources":["../../src/methods/degree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAQvD,KAAK,aAAa,GAAG;IACnB,KAAK,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE,aAAkB,GAC1B,WAAW,CAoEb"}