graphwise 1.8.0 → 1.9.0

package/dist/async/index.cjs

@@ -1,243 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/async/utils.ts
-/**
-* Async utility functions.
-*
-* @module async/utils
-*/
-/** Collect an AsyncIterable into a readonly array. */
-async function collectAsyncIterable(iter) {
-	const result = [];
-	for await (const item of iter) result.push(item);
-	return result;
-}
-/** Default yield strategy: setTimeout(0) to yield to the event loop. */
-function defaultYieldStrategy() {
-	return new Promise((r) => {
-		setTimeout(r, 0);
-	});
-}
-//#endregion
-//#region src/async/runners.ts
-/**
-* Resolve a single GraphOp against a synchronous ReadableGraph.
-*
-* Returns a tagged GraphOpResponse so the receiving generator can narrow
-* the result type without type assertions.
-*
-* @param graph - The synchronous graph to query
-* @param op - The operation to resolve
-* @returns The tagged response
-*/
-function resolveSyncOp(graph, op) {
-	switch (op.tag) {
-		case "neighbours": return {
-			tag: "neighbours",
-			value: Array.from(graph.neighbours(op.id, op.direction))
-		};
-		case "degree": return {
-			tag: "degree",
-			value: graph.degree(op.id, op.direction)
-		};
-		case "getNode": return {
-			tag: "getNode",
-			value: graph.getNode(op.id)
-		};
-		case "getEdge": return {
-			tag: "getEdge",
-			value: graph.getEdge(op.source, op.target)
-		};
-		case "hasNode": return {
-			tag: "hasNode",
-			value: graph.hasNode(op.id)
-		};
-		case "yield": return { tag: "yield" };
-		case "progress": return { tag: "progress" };
-	}
-}
-/**
-* Drive a generator to completion using a synchronous graph.
-*
-* The generator yields GraphOp requests; each is resolved immediately
-* against the graph and the tagged response is fed back via gen.next().
-*
-* @param gen - The generator to drive
-* @param graph - The graph to resolve ops against
-* @returns The generator's return value
-*/
-function runSync(gen, graph) {
-	let step = gen.next();
-	while (step.done !== true) {
-		const response = resolveSyncOp(graph, step.value);
-		step = gen.next(response);
-	}
-	return step.value;
-}
-/**
-* Resolve a single GraphOp against an async ReadableGraph.
-*
-* AsyncIterables (neighbours) are collected into readonly arrays so the
-* generator receives the same value type as in sync mode. Returns a tagged
-* GraphOpResponse for type-safe narrowing without assertions.
-*
-* @param graph - The async graph to query
-* @param op - The operation to resolve
-* @returns A promise resolving to the tagged response
-*/
-async function resolveAsyncOp(graph, op) {
-	switch (op.tag) {
-		case "neighbours": return {
-			tag: "neighbours",
-			value: await collectAsyncIterable(graph.neighbours(op.id, op.direction))
-		};
-		case "degree": return {
-			tag: "degree",
-			value: await graph.degree(op.id, op.direction)
-		};
-		case "getNode": return {
-			tag: "getNode",
-			value: await graph.getNode(op.id)
-		};
-		case "getEdge": return {
-			tag: "getEdge",
-			value: await graph.getEdge(op.source, op.target)
-		};
-		case "hasNode": return {
-			tag: "hasNode",
-			value: await graph.hasNode(op.id)
-		};
-		case "yield": return { tag: "yield" };
-		case "progress": return { tag: "progress" };
-	}
-}
-/**
-* Drive a generator to completion using an async graph.
-*
-* Extends sync semantics with:
-* - Cancellation via AbortSignal (throws DOMException "AbortError")
-* - Cooperative yielding at `yield` ops (calls yieldStrategy)
-* - Progress callbacks at `progress` ops (may be async for backpressure)
-* - Error propagation: graph errors are forwarded via gen.throw(); if the
-*   generator does not handle them, they propagate to the caller
-*
-* @param gen - The generator to drive
-* @param graph - The async graph to resolve ops against
-* @param options - Runner configuration
-* @returns A promise resolving to the generator's return value
-*/
-async function runAsync(gen, graph, options) {
-	const signal = options?.signal;
-	const onProgress = options?.onProgress;
-	const yieldStrategy = options?.yieldStrategy ?? defaultYieldStrategy;
-	let step = gen.next();
-	while (step.done !== true) {
-		if (signal?.aborted === true) {
-			const abortError = new DOMException("Aborted", "AbortError");
-			try {
-				gen.throw(abortError);
-			} catch {
-				throw abortError;
-			}
-			throw abortError;
-		}
-		const op = step.value;
-		if (op.tag === "yield") {
-			await yieldStrategy();
-			step = gen.next({ tag: "yield" });
-			continue;
-		}
-		if (op.tag === "progress") {
-			if (onProgress !== void 0) {
-				const maybePromise = onProgress(op.stats);
-				if (maybePromise instanceof Promise) await maybePromise;
-			}
-			step = gen.next({ tag: "progress" });
-			continue;
-		}
-		let response;
-		try {
-			response = await resolveAsyncOp(graph, op);
-		} catch (error) {
-			step = gen.throw(error);
-			continue;
-		}
-		step = gen.next(response);
-	}
-	return step.value;
-}
-//#endregion
-//#region src/async/ops.ts
-function* opNeighbours(id, direction) {
-	const response = yield direction !== void 0 ? {
-		tag: "neighbours",
-		id,
-		direction
-	} : {
-		tag: "neighbours",
-		id
-	};
-	if (response.tag !== "neighbours") throw new TypeError(`Expected neighbours response, got ${response.tag}`);
-	return response.value;
-}
-function* opDegree(id, direction) {
-	const response = yield direction !== void 0 ? {
-		tag: "degree",
-		id,
-		direction
-	} : {
-		tag: "degree",
-		id
-	};
-	if (response.tag !== "degree") throw new TypeError(`Expected degree response, got ${response.tag}`);
-	return response.value;
-}
-function* opGetNode(id) {
-	const response = yield {
-		tag: "getNode",
-		id
-	};
-	if (response.tag !== "getNode") throw new TypeError(`Expected getNode response, got ${response.tag}`);
-	return response.value;
-}
-function* opGetEdge(source, target) {
-	const response = yield {
-		tag: "getEdge",
-		source,
-		target
-	};
-	if (response.tag !== "getEdge") throw new TypeError(`Expected getEdge response, got ${response.tag}`);
-	return response.value;
-}
-function* opHasNode(id) {
-	const response = yield {
-		tag: "hasNode",
-		id
-	};
-	if (response.tag !== "hasNode") throw new TypeError(`Expected hasNode response, got ${response.tag}`);
-	return response.value;
-}
-function* opYield() {
-	yield { tag: "yield" };
-}
-function* opProgress(stats) {
-	yield {
-		tag: "progress",
-		stats
-	};
-}
-//#endregion
-exports.collectAsyncIterable = collectAsyncIterable;
-exports.defaultYieldStrategy = defaultYieldStrategy;
-exports.opDegree = opDegree;
-exports.opGetEdge = opGetEdge;
-exports.opGetNode = opGetNode;
-exports.opHasNode = opHasNode;
-exports.opNeighbours = opNeighbours;
-exports.opProgress = opProgress;
-exports.opYield = opYield;
-exports.resolveAsyncOp = resolveAsyncOp;
-exports.resolveSyncOp = resolveSyncOp;
-exports.runAsync = runAsync;
-exports.runSync = runSync;
-
-//# sourceMappingURL=index.cjs.map
+const require_utils = require("../utils-CDtCcsyF.cjs");
+const require_ops = require("../ops-djAsQQSh.cjs");
+exports.collectAsyncIterable = require_utils.collectAsyncIterable;
+exports.defaultYieldStrategy = require_utils.defaultYieldStrategy;
+exports.opDegree = require_ops.opDegree;
+exports.opGetEdge = require_ops.opGetEdge;
+exports.opGetNode = require_ops.opGetNode;
+exports.opHasNode = require_ops.opHasNode;
+exports.opNeighbours = require_ops.opNeighbours;
+exports.opProgress = require_ops.opProgress;
+exports.opYield = require_ops.opYield;
+exports.resolveAsyncOp = require_ops.resolveAsyncOp;
+exports.resolveSyncOp = require_ops.resolveSyncOp;
+exports.runAsync = require_ops.runAsync;
+exports.runSync = require_ops.runSync;

package/dist/async/index.js

@@ -1,230 +1,3 @@
-//#region src/async/utils.ts
-/**
-* Async utility functions.
-*
-* @module async/utils
-*/
-/** Collect an AsyncIterable into a readonly array. */
-async function collectAsyncIterable(iter) {
-	const result = [];
-	for await (const item of iter) result.push(item);
-	return result;
-}
-/** Default yield strategy: setTimeout(0) to yield to the event loop. */
-function defaultYieldStrategy() {
-	return new Promise((r) => {
-		setTimeout(r, 0);
-	});
-}
-//#endregion
-//#region src/async/runners.ts
-/**
-* Resolve a single GraphOp against a synchronous ReadableGraph.
-*
-* Returns a tagged GraphOpResponse so the receiving generator can narrow
-* the result type without type assertions.
-*
-* @param graph - The synchronous graph to query
-* @param op - The operation to resolve
-* @returns The tagged response
-*/
-function resolveSyncOp(graph, op) {
-	switch (op.tag) {
-		case "neighbours": return {
-			tag: "neighbours",
-			value: Array.from(graph.neighbours(op.id, op.direction))
-		};
-		case "degree": return {
-			tag: "degree",
-			value: graph.degree(op.id, op.direction)
-		};
-		case "getNode": return {
-			tag: "getNode",
-			value: graph.getNode(op.id)
-		};
-		case "getEdge": return {
-			tag: "getEdge",
-			value: graph.getEdge(op.source, op.target)
-		};
-		case "hasNode": return {
-			tag: "hasNode",
-			value: graph.hasNode(op.id)
-		};
-		case "yield": return { tag: "yield" };
-		case "progress": return { tag: "progress" };
-	}
-}
-/**
-* Drive a generator to completion using a synchronous graph.
-*
-* The generator yields GraphOp requests; each is resolved immediately
-* against the graph and the tagged response is fed back via gen.next().
-*
-* @param gen - The generator to drive
-* @param graph - The graph to resolve ops against
-* @returns The generator's return value
-*/
-function runSync(gen, graph) {
-	let step = gen.next();
-	while (step.done !== true) {
-		const response = resolveSyncOp(graph, step.value);
-		step = gen.next(response);
-	}
-	return step.value;
-}
-/**
-* Resolve a single GraphOp against an async ReadableGraph.
-*
-* AsyncIterables (neighbours) are collected into readonly arrays so the
-* generator receives the same value type as in sync mode. Returns a tagged
-* GraphOpResponse for type-safe narrowing without assertions.
-*
-* @param graph - The async graph to query
-* @param op - The operation to resolve
-* @returns A promise resolving to the tagged response
-*/
-async function resolveAsyncOp(graph, op) {
-	switch (op.tag) {
-		case "neighbours": return {
-			tag: "neighbours",
-			value: await collectAsyncIterable(graph.neighbours(op.id, op.direction))
-		};
-		case "degree": return {
-			tag: "degree",
-			value: await graph.degree(op.id, op.direction)
-		};
-		case "getNode": return {
-			tag: "getNode",
-			value: await graph.getNode(op.id)
-		};
-		case "getEdge": return {
-			tag: "getEdge",
-			value: await graph.getEdge(op.source, op.target)
-		};
-		case "hasNode": return {
-			tag: "hasNode",
-			value: await graph.hasNode(op.id)
-		};
-		case "yield": return { tag: "yield" };
-		case "progress": return { tag: "progress" };
-	}
-}
-/**
-* Drive a generator to completion using an async graph.
-*
-* Extends sync semantics with:
-* - Cancellation via AbortSignal (throws DOMException "AbortError")
-* - Cooperative yielding at `yield` ops (calls yieldStrategy)
-* - Progress callbacks at `progress` ops (may be async for backpressure)
-* - Error propagation: graph errors are forwarded via gen.throw(); if the
-*   generator does not handle them, they propagate to the caller
-*
-* @param gen - The generator to drive
-* @param graph - The async graph to resolve ops against
-* @param options - Runner configuration
-* @returns A promise resolving to the generator's return value
-*/
-async function runAsync(gen, graph, options) {
-	const signal = options?.signal;
-	const onProgress = options?.onProgress;
-	const yieldStrategy = options?.yieldStrategy ?? defaultYieldStrategy;
-	let step = gen.next();
-	while (step.done !== true) {
-		if (signal?.aborted === true) {
-			const abortError = new DOMException("Aborted", "AbortError");
-			try {
-				gen.throw(abortError);
-			} catch {
-				throw abortError;
-			}
-			throw abortError;
-		}
-		const op = step.value;
-		if (op.tag === "yield") {
-			await yieldStrategy();
-			step = gen.next({ tag: "yield" });
-			continue;
-		}
-		if (op.tag === "progress") {
-			if (onProgress !== void 0) {
-				const maybePromise = onProgress(op.stats);
-				if (maybePromise instanceof Promise) await maybePromise;
-			}
-			step = gen.next({ tag: "progress" });
-			continue;
-		}
-		let response;
-		try {
-			response = await resolveAsyncOp(graph, op);
-		} catch (error) {
-			step = gen.throw(error);
-			continue;
-		}
-		step = gen.next(response);
-	}
-	return step.value;
-}
-//#endregion
-//#region src/async/ops.ts
-function* opNeighbours(id, direction) {
-	const response = yield direction !== void 0 ? {
-		tag: "neighbours",
-		id,
-		direction
-	} : {
-		tag: "neighbours",
-		id
-	};
-	if (response.tag !== "neighbours") throw new TypeError(`Expected neighbours response, got ${response.tag}`);
-	return response.value;
-}
-function* opDegree(id, direction) {
-	const response = yield direction !== void 0 ? {
-		tag: "degree",
-		id,
-		direction
-	} : {
-		tag: "degree",
-		id
-	};
-	if (response.tag !== "degree") throw new TypeError(`Expected degree response, got ${response.tag}`);
-	return response.value;
-}
-function* opGetNode(id) {
-	const response = yield {
-		tag: "getNode",
-		id
-	};
-	if (response.tag !== "getNode") throw new TypeError(`Expected getNode response, got ${response.tag}`);
-	return response.value;
-}
-function* opGetEdge(source, target) {
-	const response = yield {
-		tag: "getEdge",
-		source,
-		target
-	};
-	if (response.tag !== "getEdge") throw new TypeError(`Expected getEdge response, got ${response.tag}`);
-	return response.value;
-}
-function* opHasNode(id) {
-	const response = yield {
-		tag: "hasNode",
-		id
-	};
-	if (response.tag !== "hasNode") throw new TypeError(`Expected hasNode response, got ${response.tag}`);
-	return response.value;
-}
-function* opYield() {
-	yield { tag: "yield" };
-}
-function* opProgress(stats) {
-	yield {
-		tag: "progress",
-		stats
-	};
-}
-//#endregion
+import { n as defaultYieldStrategy, t as collectAsyncIterable } from "../utils-BodeE2Mo.js";
+import { a as opNeighbours, c as resolveAsyncOp, d as runSync, i as opHasNode, l as resolveSyncOp, n as opGetEdge, o as opProgress, r as opGetNode, s as opYield, t as opDegree, u as runAsync } from "../ops-upIi6JIi.js";
 export { collectAsyncIterable, defaultYieldStrategy, opDegree, opGetEdge, opGetNode, opHasNode, opNeighbours, opProgress, opYield, resolveAsyncOp, resolveSyncOp, runAsync, runSync };
-
-//# sourceMappingURL=index.js.map

package/dist/expansion/index.cjs

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_expansion = require("../expansion-DaTroIyv.cjs");
+exports.base = require_expansion.base;
+exports.baseAsync = require_expansion.baseAsync;
+exports.dfsPriority = require_expansion.dfsPriority;
+exports.dfsPriorityAsync = require_expansion.dfsPriorityAsync;
+exports.dfsPriorityFn = require_expansion.dfsPriorityFn;
+exports.dome = require_expansion.dome;
+exports.domeAsync = require_expansion.domeAsync;
+exports.domeHighDegree = require_expansion.domeHighDegree;
+exports.domeHighDegreeAsync = require_expansion.domeHighDegreeAsync;
+exports.edge = require_expansion.edge;
+exports.edgeAsync = require_expansion.edgeAsync;
+exports.flux = require_expansion.flux;
+exports.fluxAsync = require_expansion.fluxAsync;
+exports.frontierBalanced = require_expansion.frontierBalanced;
+exports.frontierBalancedAsync = require_expansion.frontierBalancedAsync;
+exports.fuse = require_expansion.fuse;
+exports.fuseAsync = require_expansion.fuseAsync;
+exports.hae = require_expansion.hae;
+exports.haeAsync = require_expansion.haeAsync;
+exports.kHop = require_expansion.kHop;
+exports.lace = require_expansion.lace;
+exports.laceAsync = require_expansion.laceAsync;
+exports.maze = require_expansion.maze;
+exports.mazeAsync = require_expansion.mazeAsync;
+exports.pipe = require_expansion.pipe;
+exports.pipeAsync = require_expansion.pipeAsync;
+exports.randomPriority = require_expansion.randomPriority;
+exports.randomPriorityAsync = require_expansion.randomPriorityAsync;
+exports.randomWalk = require_expansion.randomWalk;
+exports.reach = require_expansion.reach;
+exports.reachAsync = require_expansion.reachAsync;
+exports.sage = require_expansion.sage;
+exports.sageAsync = require_expansion.sageAsync;
+exports.sift = require_expansion.sift;
+exports.siftAsync = require_expansion.siftAsync;
+exports.standardBfs = require_expansion.standardBfs;
+exports.standardBfsAsync = require_expansion.standardBfsAsync;
+exports.tide = require_expansion.tide;
+exports.tideAsync = require_expansion.tideAsync;
+exports.warp = require_expansion.warp;
+exports.warpAsync = require_expansion.warpAsync;

package/dist/expansion/index.js

@@ -0,0 +1,2 @@
+import { A as pipe, B as base, C as tideAsync, D as reachAsync, E as reach, F as haeAsync, I as dome, L as domeAsync, M as edge, N as edgeAsync, O as sage, P as hae, R as domeHighDegree, S as tide, T as mazeAsync, V as baseAsync, _ as fuseAsync, a as dfsPriorityFn, b as lace, c as frontierBalanced, d as standardBfsAsync, f as flux, g as fuse, h as siftAsync, i as dfsPriorityAsync, j as pipeAsync, k as sageAsync, l as frontierBalancedAsync, m as sift, n as kHop, o as randomPriority, p as fluxAsync, r as dfsPriority, s as randomPriorityAsync, t as randomWalk, u as standardBfs, v as warp, w as maze, x as laceAsync, y as warpAsync, z as domeHighDegreeAsync } from "../expansion-ClDhlMK8.js";
+export { base, baseAsync, dfsPriority, dfsPriorityAsync, dfsPriorityFn, dome, domeAsync, domeHighDegree, domeHighDegreeAsync, edge, edgeAsync, flux, fluxAsync, frontierBalanced, frontierBalancedAsync, fuse, fuseAsync, hae, haeAsync, kHop, lace, laceAsync, maze, mazeAsync, pipe, pipeAsync, randomPriority, randomPriorityAsync, randomWalk, reach, reachAsync, sage, sageAsync, sift, siftAsync, standardBfs, standardBfsAsync, tide, tideAsync, warp, warpAsync };