kisch 1.0.0

package/spec/manhattan-router.spec.js

@@ -0,0 +1,152 @@
+import {Point} from "../src/cartesian-math.js";
+import {findGridPath, segmentBlocked} from "../src/manhattan-router.js";
+
+describe("manhattan-router", () => {
+	const P = (x, y) => new Point([x, y]);
+	const R = (x, y, w, h) => ({
+		corner: P(x, y),
+		size: P(w, h)
+	});
+
+	it("connects two points directly", () => {
+		const path = findGridPath({
+			from: P(0, 0),
+			to: P(10, 0),
+			gridSize: 5,
+			avoidRects: []
+		});
+
+		expect(path.map(p => p.join(",")))
+			.toEqual(["0,0", "10,0"]);
+	});
+
+	it("creates an L-shaped path", () => {
+		const path = findGridPath({
+			from: P(0, 0),
+			to: P(10, 10),
+			gridSize: 5,
+			avoidRects: []
+		});
+
+		expect(path.length).toBe(3);
+		expect(path[0].equals(P(0, 0))).toBeTrue();
+		expect(path[2].equals(P(10, 10))).toBeTrue();
+	});
+
+	it("routes around a small obstacle", () => {
+		const path = findGridPath({
+			from: P(0, 0),
+			to: P(10, 0),
+			gridSize: 5,
+			avoidRects: [
+				R(4, -1, 2, 2) // blocks (5,0)
+			]
+		});
+
+		const keys = path.map(p => p.join(","));
+		expect(keys).not.toContain("5,0");
+		expect(keys[0]).toBe("0,0");
+		expect(keys[keys.length - 1]).toBe("10,0");
+	});
+
+	it("avoids a rectangular keep-out area", () => {
+		const path = findGridPath({
+			from: P(0, 0),
+			to: P(20, 0),
+			gridSize: 5,
+			avoidRects: [
+				R(5, -5, 10, 10)
+			]
+		});
+
+		for (let i = 0; i < path.length - 1; i++) {
+			expect(
+				segmentBlocked(path[i], path[i + 1], [
+					R(5, -5, 10, 10)
+				])
+			).toBeFalse();
+		}
+	});
+
+	it("is deterministic", () => {
+		const opts = {
+			from: P(0, 0),
+			to: P(10, 10),
+			gridSize: 5,
+			avoidRects: [R(5, 0, 2, 2)]
+		};
+
+		const a = findGridPath(opts).map(p => p.join(","));
+		const b = findGridPath(opts).map(p => p.join(","));
+
+		expect(a).toEqual(b);
+	});
+});
+
+describe("findGridPath – avoidLines", () => {
+
+	it("avoids drawing collinear overlapping horizontal lines", () => {
+		const path = findGridPath({
+			from: new Point([0, 0]),
+			to: new Point([10, 0]),
+			gridSize: 5,
+			avoidRects: [],
+			avoidLines: [
+				{ a: new Point([0, 0]), b: new Point([10, 0]) }
+			]
+		});
+
+		// must detour
+		expect(path.length).toBeGreaterThan(2);
+
+		// should not contain straight horizontal segment at y=0
+		for (let i = 0; i < path.length - 1; i++) {
+			const a = path[i];
+			const b = path[i + 1];
+			if (a[1] === 0 && b[1] === 0) {
+				fail("Path contains forbidden collinear segment");
+			}
+		}
+	});
+
+	it("allows orthogonal crossing of avoidLines", () => {
+		const path = findGridPath({
+			from: new Point([5, -5]),
+			to: new Point([5, 5]),
+			gridSize: 5,
+			avoidRects: [],
+			avoidLines: [
+				{ a: new Point([0, 0]), b: new Point([10, 0]) }
+			]
+		});
+
+		// straight vertical path is allowed
+		expect(path).toEqual([
+			new Point([5, -5]),
+			new Point([5, 5])
+		]);
+	});
+
+	it("avoids vertical collinear overlap as well", () => {
+		const path = findGridPath({
+			from: new Point([0, 0]),
+			to: new Point([0, 10]),
+			gridSize: 5,
+			avoidRects: [],
+			avoidLines: [
+				{ a: new Point([0, 0]), b: new Point([0, 10]) }
+			]
+		});
+
+		expect(path.length).toBeGreaterThan(2);
+
+		for (let i = 0; i < path.length - 1; i++) {
+			const a = path[i];
+			const b = path[i + 1];
+			if (a[0] === 0 && b[0] === 0) {
+				fail("Vertical collinear overlap detected");
+			}
+		}
+	});
+
+});

package/spec/sexp.spec.js

@@ -0,0 +1,14 @@
+import {sexpParse, sexpStringify}from "../src/sexp.js";
+
+describe("sexpr",()=>{
+	it("can parse and stringify s-expressions",()=>{
+		let input=`(symbol "R1" (value "10k") (footprint "Resistor_SMD:R_0805"))`;
+		let exp=sexpParse(input);
+		//console.log(exp);
+
+		let output=sexpStringify(exp);
+		//console.log(output);
+
+		expect(output).toEqual(`(symbol "R1" (value "10k") (footprint "Resistor_SMD:R_0805"))`);
+	});
+});

package/spec/support/jasmine.mjs

@@ -0,0 +1,14 @@
+export default {
+  spec_dir: "spec",
+  spec_files: [
+    "**/*[sS]pec.?(m)js"
+  ],
+  helpers: [
+    "helpers/**/*.?(m)js"
+  ],
+  env: {
+    stopSpecOnExpectationFailure: false,
+    random: true,
+    forbidDuplicateNames: true
+  }
+}

package/src/Entity.js

@@ -0,0 +1,232 @@
+import {Point} from "./cartesian-math.js";
+import {sym, symName, sexpCallName} from "./sexp.js";
+import {Rect} from "./cartesian-math.js";
+
+class EntityPin {
+	constructor(sexpr, entity) {
+		this.sexpr=sexpr;
+		this.entity=entity;
+
+		//console.log(this.sexpr);
+	}
+
+	getNum() {
+		return this.sexpr[1];
+	}
+
+	getPoint() {
+		let librarySymbol=this.entity.getLibrarySymbol();
+		let librarySymbolPin=librarySymbol.getPin(Number(this.getNum()));
+		let pinAt=Point.from(librarySymbolPin.at);
+		pinAt[1]=-pinAt[1];
+
+		return Point.from(this.entity.getAt()).add(pinAt);
+	}
+
+	isConnected(p) {
+		if (typeof p=="string") {
+			for (let e of this.entity.schematic.getLabelEntities(p)) {
+				let p=e.getConnectionPoints()[0];
+				if (this.entity.schematic.arePointsConnected(this.getPoint(),p))
+					return true;
+			}
+
+			return false;
+		}
+
+		else {
+			return this.entity.schematic.arePointsConnected(this.getPoint(),p.getPoint());
+		}
+	}
+
+	connect(p) {
+		if (this.isConnected(p)) {
+			if (typeof p=="string") {
+				for (let e of this.entity.schematic.getLabelEntities(p)) {
+					let p=e.getConnectionPoints()[0];
+					if (this.entity.schematic.arePointsConnected(this.getPoint(),p)) {
+						e.declared=true;
+						this.entity.schematic.markConnectionDeclared(this.getPoint(),p);
+					}
+				}
+			}
+
+			else {
+				this.entity.schematic.markConnectionDeclared(this.getPoint(),p.getPoint());
+			}
+
+			return;
+		}
+
+		if (typeof p=="string") {
+			let l=this.entity.schematic.addLabel(this.getPoint(),p);
+			l.declared=true;
+		}
+
+		else {
+			this.entity.schematic.addConnectionWire(this.getPoint(),p.getPoint());
+			this.entity.schematic.markConnectionDeclared(this.getPoint(),p.getPoint());
+		}
+	}
+}
+
+export default class Entity {
+	constructor(sexpr, schematic) {
+		this.schematic=schematic;
+		this.sexpr=sexpr;
+		this.pins=[];
+
+		this.type=symName(this.sexpr[0]);
+		if (!["symbol","wire","label"].includes(this.type))
+			throw new Error("Unknown entity: "+this.type);
+
+		for (let a of this.sexpr)
+			if (sexpCallName(a)=="pin")
+				this.pins.push(new EntityPin(a,this));
+	}
+
+	getSexp() {
+		return this.sexpr;
+	}
+
+	init() {
+		if (this.getType()!="symbol")
+			return;
+
+		let id=this.getLibId();
+		if (!id)
+			throw new Error("Unable to load symbol");
+
+		//console.log("id: "+id);
+		this.librarySymbol=this.schematic.symbolLibrary.getLibrarySymbol(this.getLibId())
+		if (!this.librarySymbol)
+			throw new Error("Unable to load symbol");
+	}
+
+	async load() {
+		if (this.getType()!="symbol")
+			return;
+
+		let id=this.getLibId();
+		if (!id)
+			throw new Error("Unable to load symbol");
+
+		//console.log("id: "+id);
+		this.librarySymbol=await this.schematic.symbolLibrary.loadLibrarySymbol(this.getLibId())
+		if (!this.librarySymbol)
+			throw new Error("Unable to load symbol");
+	}
+
+	getReference() {
+		if (this.getType()!="symbol")
+			return;
+
+		let el=this.sexpr.find(a=>sexpCallName(a)=="property" && a[1]=="Reference");
+		return el[2];
+	}
+
+	getFootprint() {
+		if (this.getType()!="symbol")
+			throw new Error("Only symbols have footprints");
+
+		let el=this.sexpr.find(a=>sexpCallName(a)=="property" && a[1]=="Footprint");
+		if (!el)
+			return "";
+
+		return el[2];
+	}
+
+	setFootprint(footprint) {
+		if (this.getType()!="symbol")
+			throw new Error("Only symbols have footprints");
+
+		if (!footprint)
+			footprint="";
+
+		let el=this.sexpr.find(a=>sexpCallName(a)=="property" && a[1]=="Footprint");
+		if (!el) {
+			let exp=[sym("property"),"Footprint","",
+				[sym("effects"),
+					[sym("hide"),sym("yes")]
+				]
+			];
+
+			this.sexpr.push(exp);
+			el=exp;
+		}
+
+		el[2]=footprint;
+	}
+
+	getLibId() {
+		return this.sexpr.find(x=>sexpCallName(x)=="lib_id")[1];
+	}
+
+	getAt() {
+		for (let a of this.sexpr)
+			if (sexpCallName(a)=="at")
+				return a.slice(1).map(Number);
+	}
+
+	getLabel() {
+		if (this.getType()!="label")
+			throw new Error("Not a label");
+
+		return this.sexpr[1];
+	}
+
+	getBoundingRect() {
+		//console.log(this.librarySymbol);
+		let r=this.librarySymbol.getBoundingRect();
+		//console.log(r);
+		let p=Point.from(this.getAt());
+
+		return new Rect(p.add(r.corner),r.size);
+	}
+
+	getLibrarySymbol() {
+		return this.librarySymbol;
+	}
+
+	pin(num) {
+		if (!num)
+			throw new Error("Pin numbers start at 1");
+
+		for (let p of this.pins)
+			if (p.getNum()==num)
+				return p;
+	}
+
+	getType() {
+		return this.type;
+		/*let t=symName(this.sexpr[0]);
+
+		if (!["symbol","wire","label"].includes(t))
+			throw new Error("Unknown entity: "+t);
+
+		return t;*/
+	}
+
+	getConnectionPoints() {
+		switch (this.getType()) {
+			case "wire":
+				return [this.sexpr[1][1].slice(1),this.sexpr[1][2].slice(1)]
+				break;
+
+			case "label":
+				return [this.sexpr[2].slice(1)];
+				break;
+
+			case "symbol":
+				let p=[];
+				for (let i=1; i<=this.pins.length; i++)
+					p.push(this.pin(i).getPoint());
+
+				return p;
+				break;
+
+			default:
+				throw new Error("Unknown entity type: "+this.getType());
+		}
+	}
+}

package/src/LibrarySymbol.js

@@ -0,0 +1,100 @@
+import {sym, isSym, symEq, symName, sexpStringify, sexpCallName} from "./sexp.js";
+import {Rect} from "./cartesian-math.js";
+
+export default class LibrarySymbol {
+    constructor(sexpr, qualifiedName) {
+        this.sexpr = sexpr;
+        this._pins = null; // lazy parse
+        this.qualifiedName=qualifiedName;
+    }
+
+    /**
+     * Return all pins as LibrarySymbolPin instances.
+     */
+    get pins() {
+        if (!this._pins) {
+            // 1. Find the first nested symbol
+            const nestedSymbol = this.sexpr.find(
+                (e) => Array.isArray(e) && symEq(e[0],"symbol") && e !== this.sexpr[0]
+            );
+
+            if (!nestedSymbol) {
+                this._pins = [];
+            } else {
+                // 2. Collect all (pin ...) inside nested symbol
+                this._pins = nestedSymbol
+                    .filter((e) => Array.isArray(e) && symEq(e[0],"pin"))
+                    .map((pinSexpr) => new LibrarySymbolPin(pinSexpr));
+            }
+        }
+        return this._pins;
+    }
+
+    /**
+     * Get pin by index (0-based) or by pin name.
+     */
+    getPin(numberOrName) {
+        return this.pins.find((p) => p.name === numberOrName || p.number==numberOrName);
+    }
+
+    getQualifiedSexpr() {
+        let expr=structuredClone(this.sexpr);
+        expr[1]=this.qualifiedName;
+        return expr;
+    }
+
+    getBoundingRect() {
+        let rect;
+
+        let symbolExp=this.sexpr.find(x=>sexpCallName(x)=="symbol")
+        for (let x of symbolExp) {
+            if (sexpCallName(x)=="rectangle") {
+                let start=x.find(x=>sexpCallName(x)=="start").slice(1);
+                let end=x.find(x=>sexpCallName(x)=="end").slice(1);
+                let r=Rect.fromCorners(start,end);
+
+                if (!rect)
+                    rect=r;
+
+                rect=rect.union(r);
+            }
+        }
+
+        //console.log(sexpStringify(symbolExp));
+
+        return rect;
+    }
+}
+
+export class LibrarySymbolPin {
+    constructor(sexpr) {
+        this.sexpr = sexpr;
+        this.type = sexpr[1]; // e.g., "passive"
+        this.shape = sexpr[2]; // e.g., "line"
+
+        // parse attributes
+        this.at = [0, 0, 0];
+        this.length = 0;
+        this.name = null;
+        this.number = null;
+
+        for (const e of sexpr.slice(3)) {
+            if (!Array.isArray(e) || !isSym(e[0])) continue;
+
+            switch (symName(e[0])) {
+                case "at":
+                    this.at = e.slice(1).map(Number); // [x, y, rotation]
+                    break;
+                case "length":
+                    this.length = Number(e[1]);
+                    break;
+                case "name":
+                    this.name = e[1];
+                    break;
+                case "number":
+                    this.number = e[1];
+                    break;
+            }
+        }
+    }
+}