kisch 1.0.2 → 1.0.4

package/src/utils/astar.js

@@ -0,0 +1,113 @@
+export function astar({
+    start,
+    goal,
+    isGoal,
+    neighbours,
+    cost,
+    heuristic = () => 0,
+    key,
+    stats
+}) {
+    if (!key) throw new Error("key(n) is required");
+    if (!stats)
+        stats={};
+
+    // Goal resolution
+    const goalKey = goal !== undefined ? key(goal) : null;
+    const isGoalFn =
+        isGoal ||
+        ((n) => {
+            if (goalKey === null) throw new Error("Provide goal or isGoal");
+            return key(n) === goalKey;
+        });
+
+    // Open set (priority queue via simple array for clarity)
+    const open = [];
+    const push = (node, f) => {
+        open.push({ node, f });
+    };
+    const pop = () => {
+        // naive priority queue (can replace with binary heap later)
+        let bestIdx = 0;
+        for (let i = 1; i < open.length; i++) {
+            if (open[i].f < open[bestIdx].f) bestIdx = i;
+        }
+        const item = open[bestIdx];
+        open.splice(bestIdx, 1);
+        return item.node;
+    };
+
+    // Caches
+    const gScore = new Map();       // key(n) -> best cost
+    const cameFrom = new Map();     // key(n) -> previous key
+    const nodeCache = new Map();    // key(n) -> node (for reconstruction)
+
+    // Optional memoization (cheap + safe)
+    const heuristicCache = new Map();     // key(n) -> h(n)
+    const costCache = new Map();          // "k1|k2" -> cost
+
+    const getHeuristic = (n) => {
+        const k = key(n);
+        if (heuristicCache.has(k)) return heuristicCache.get(k);
+        const h = heuristic(n);
+        heuristicCache.set(k, h);
+        return h;
+    };
+
+    const getCost = (a, b) => {
+        const ka = key(a);
+        const kb = key(b);
+        const ck = ka + "|" + kb;
+        if (costCache.has(ck)) return costCache.get(ck);
+        const c = cost(a, b);
+        costCache.set(ck, c);
+        return c;
+    };
+
+    const startKey = key(start);
+    gScore.set(startKey, 0);
+    nodeCache.set(startKey, start);
+
+    push(start, getHeuristic(start));
+
+    stats.steps=0;
+
+    while (open.length > 0) {
+        stats.steps++;
+        const current = pop();
+        const ck = key(current);
+
+        if (isGoalFn(current)) {
+            return reconstructPath(cameFrom, nodeCache, ck);
+        }
+
+        for (const next of neighbours(current)) {
+            const nk = key(next);
+            nodeCache.set(nk, next);
+
+            const tentative =
+                gScore.get(ck) + getCost(current, next);
+
+            if (!gScore.has(nk) || tentative < gScore.get(nk)) {
+                cameFrom.set(nk, ck);
+                gScore.set(nk, tentative);
+
+                const f = tentative + getHeuristic(next);
+                push(next, f);
+            }
+        }
+    }
+
+    return null; // no path
+}
+
+// Helper
+function reconstructPath(cameFrom, nodeCache, currentKey) {
+    const path = [];
+    while (currentKey) {
+        path.push(nodeCache.get(currentKey));
+        currentKey = cameFrom.get(currentKey);
+    }
+    path.reverse();
+    return path;
+}

package/src/{cartesian-math.js → utils/cartesian-math.js}

@@ -1,10 +1,19 @@
 export class Point extends Array {
 	constructor(...a) {
-		if (a)
+		if (a.length==1 &&
+				!Array.isArray(a[0]) && 
+				Object.hasOwn(a[0],"x") && 
+				Object.hasOwn(a[0],"y"))
+			super(a[0].x,a[0].y);
+
+		else if (a)
 			super(...[a].flat(Infinity));
 
 		else
 			super();
+
+		if (this.length && (isNaN(this[0]) || isNaN(this[1])))
+			throw new Error("NaN point: l="+this.length+" from: "+a);
 	}
 
 	add(p) {
@@ -15,6 +24,8 @@ export class Point extends Array {
 	}
 
 	sub(p) {
+		//console.log("sub ",this,p);
+
 		return Point.from([
 			this[0]-p[0],
 			this[1]-p[1]
@@ -27,10 +38,26 @@ export class Point extends Array {
 
 	snap(gridSize) {
 		return new Point([
-			Math.round(this[0]/gridSize)*gridSize,
-			Math.round(this[1]/gridSize)*gridSize,
+			Number((Math.round(this[0]/gridSize)*gridSize).toFixed(2)),
+			Number((Math.round(this[1]/gridSize)*gridSize).toFixed(2)),
 		]);
 	}
+
+	len() {
+		return Math.sqrt(this[0]*this[0]+this[1]*this[1]);
+	}
+
+	rotateDegrees(deg) {
+		const rad = deg * Math.PI / 180;
+
+		const cos = Math.cos(rad);
+		const sin = Math.sin(rad);
+
+		return new Point(
+			this[0] * cos - this[1] * sin,
+			this[0] * sin + this[1] * cos
+		);
+	}
 }
 
 export class Rect {
@@ -40,9 +67,14 @@ export class Rect {
 	}
 
 	static fromCorners(p1, p2) {
+		//console.log("p1 ",p1);
+		//console.log("p2 ",p2);
+
 		p1=new Point(p1);
 		p2=new Point(p2);
 
+		//console.log("created...");
+
 		return new Rect(p1,p2.sub(p1));
 	}
 
@@ -91,6 +123,15 @@ export class Rect {
 		return Rect.fromCorners([left,top],[right,bottom]);
 	}
 
+	includePoint(p) {
+		let left=Math.min(this.getLeft(),p[0]);
+		let top=Math.min(this.getTop(),p[1]);
+		let right=Math.max(this.getRight(),p[0]);
+		let bottom=Math.max(this.getBottom(),p[1]);
+
+		return Rect.fromCorners([left,top],[right,bottom]);
+	}
+
 	overlaps(other) {
 	    return !(
 			this.getRight()  <= other.getLeft()  ||

package/src/utils/grid-util.js

@@ -0,0 +1,39 @@
+export function collapsePath(path) {
+    if (!path || path.length < 2) return path;
+
+    const result = [path[0]];
+
+    let prevDir = null;
+
+    for (let i = 1; i < path.length - 1; i++) {
+        const prev = path[i - 1];
+        const cur = path[i];
+        const next = path[i + 1];
+
+        const dir1 = {
+            x: cur.x - prev.x,
+            y: cur.y - prev.y,
+        };
+
+        const dir2 = {
+            x: next.x - cur.x,
+            y: next.y - cur.y,
+        };
+
+        const sameDirection =
+            dir1.x === dir2.x && dir1.y === dir2.y;
+
+        // keep only if direction changes
+        if (!sameDirection) {
+            result.push(cur);
+        }
+    }
+
+    result.push(path[path.length - 1]);
+
+    return result.map(p=>({x: p.x, y: p.y}));
+}
+
+export function manhattanDist(x1, y1, x2, y2) {
+    return (Math.abs(x2-x1)+Math.abs(y2-y1));
+}

package/src/utils/js-util.js

@@ -0,0 +1,33 @@
+export class DeclaredError extends Error {
+    constructor(...args) {
+        super(...args);
+        this.declared=true;
+    }
+}
+
+export function arrayUnique(array) {
+    let result=new Set();
+
+    for (let item of array)
+        result.add(item);
+
+    return Array.from(result);
+}
+
+export function arrayGetMinIndex(array) {
+    let min;
+    for (let k of Object.keys(array))
+        if (min===undefined || Number(k)<min)
+            min=Number(k);
+
+    return min;
+}
+
+export function arrayGetMaxIndex(array) {
+    let max;
+    for (let k of Object.keys(array))
+        if (max===undefined || Number(k)>max)
+            max=Number(k);
+
+    return max;
+}

package/src/{node-util.js → utils/node-util.js}

@@ -1,4 +1,5 @@
 import {spawn} from 'node:child_process';
+import {fileURLToPath} from 'url';
 
 export function runCommand(cmd, args = []) {
     return new Promise((resolve, reject) => {
@@ -15,3 +16,7 @@ export function runCommand(cmd, args = []) {
         child.on('error', reject);
     });
 }
+
+export function dirnameFromImportMeta(meta) {
+    return fileURLToPath(new URL('.', meta.url));
+}

package/src/js-util.js

@@ -1,15 +0,0 @@
-export class DeclaredError extends Error {
-    constructor(...args) {
-        super(...args);
-        this.declared=true;
-    }
-}
-
-export function arrayUnique(array) {
-    let result=new Set();
-
-    for (let item of array)
-        result.add(item);
-
-    return Array.from(result);
-}

package/src/manhattan-router.js

@@ -1,176 +0,0 @@
-import { Point, pointKey } from "../src/cartesian-math.js";
-
-function manhattan(a, b) {
-	return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]);
-}
-
-function rangeOverlap(a1, a2, b1, b2) {
-	const minA = Math.min(a1, a2);
-	const maxA = Math.max(a1, a2);
-	const minB = Math.min(b1, b2);
-	const maxB = Math.max(b1, b2);
-	return maxA > minB && maxB > minA;
-}
-
-/* ───────────────────────── Rect blocking (unchanged) ───────────────────────── */
-
-export function segmentBlocked(a, b, rects) {
-	const ax = a[0], ay = a[1];
-	const bx = b[0], by = b[1];
-
-	for (const r of rects) {
-		const rx = r.corner[0];
-		const ry = r.corner[1];
-		const rw = r.size[0];
-		const rh = r.size[1];
-
-		// horizontal
-		if (ay === by) {
-			if (
-				ay >= ry && ay <= ry + rh &&
-				rangeOverlap(ax, bx, rx, rx + rw)
-			) return true;
-		}
-
-		// vertical
-		if (ax === bx) {
-			if (
-				ax >= rx && ax <= rx + rw &&
-				rangeOverlap(ay, by, ry, ry + rh)
-			) return true;
-		}
-	}
-
-	return false;
-}
-
-/* ───────────────────────── Line blocking (NEW) ───────────────────────── */
-
-function similar(a,b) {
-	return Math.abs(a-b)<0.0000001
-}
-
-function segmentOverlapsLine(a1, a2, b1, b2) {
-	// horizontal
-//	if (a1[1] === a2[1] && b1[1] === b2[1] && a1[1] === b1[1]) {
-	if (similar(a1[1],a2[1]) && similar(b1[1],b2[1]) && similar(a1[1],b1[1])) {
-		return rangeOverlap(a1[0], a2[0], b1[0], b2[0]);
-	}
-
-	// vertical
-//	if (a1[0] === a2[0] && b1[0] === b2[0] && a1[0] === b1[0]) {
-	if (similar(a1[0],a2[0]) && similar(b1[0],b2[0]) && similar(a1[0],b1[0])) {
-		return rangeOverlap(a1[1], a2[1], b1[1], b2[1]);
-	}
-
-	return false;
-}
-
-export function segmentBlockedByLines(a, b, lines) {
-	for (const { a: l1, b: l2 } of lines) {
-		if (segmentOverlapsLine(a, b, l1, l2)) {
-			return true;
-		}
-	}
-	return false;
-}
-
-/* ───────────────────────── Path compression (unchanged) ───────────────────────── */
-
-function compressPath(points) {
-	if (points.length <= 2) return points;
-
-	const out = [points[0]];
-
-	for (let i = 1; i < points.length - 1; i++) {
-		const a = out[out.length - 1];
-		const b = points[i];
-		const c = points[i + 1];
-
-		const abx = b[0] - a[0];
-		const aby = b[1] - a[1];
-		const bcx = c[0] - b[0];
-		const bcy = c[1] - b[1];
-
-		if (
-			(abx === 0 && bcx === 0) ||
-			(aby === 0 && bcy === 0)
-		) continue;
-
-		out.push(b);
-	}
-
-	out.push(points[points.length - 1]);
-	return out; //.map(p=>p.snap(2.54));
-}
-
-/* ───────────────────────── Main router ───────────────────────── */
-
-export function findGridPath({
-	from,
-	to,
-	gridSize,
-	avoidRects = [],
-	avoidLines = []
-}) {
-	const open = new Map();
-	const closed = new Set();
-
-	open.set(pointKey(from), {
-		point: from,
-		g: 0,
-		f: manhattan(from, to),
-		parent: null
-	});
-
-	const steps = [
-		new Point([ gridSize, 0 ]),
-		new Point([ -gridSize, 0 ]),
-		new Point([ 0, gridSize ]),
-		new Point([ 0, -gridSize ])
-	];
-
-	while (open.size) {
-		let current = null;
-		for (const n of open.values()) {
-			if (!current || n.f < current.f) current = n;
-		}
-
-		if (current.point.equals(to)) {
-			const path = [];
-			let c = current;
-			while (c) {
-				path.push(c.point);
-				c = c.parent;
-			}
-			return compressPath(path.reverse());
-		}
-
-		open.delete(pointKey(current.point));
-		closed.add(pointKey(current.point));
-
-		for (const step of steps) {
-			const next = current.point.add(step);
-			const key = pointKey(next);
-
-			if (closed.has(key)) continue;
-			if (segmentBlocked(current.point, next, avoidRects)) continue;
-			if (segmentBlockedByLines(current.point, next, avoidLines)) continue;
-
-			const g = current.g + gridSize;
-			const f = g + manhattan(next, to);
-
-			const existing = open.get(key);
-			if (!existing || g < existing.g) {
-				open.set(key, {
-					point: next,
-					g,
-					f,
-					parent: current
-				});
-			}
-		}
-	}
-
-	throw new Error("No path found");
-}