kisch 1.0.0

package/src/Schematic.js

@@ -0,0 +1,329 @@
+import SymbolLibrary from "./SymbolLibrary.js";
+import fs, {promises as fsp} from "fs";
+import Entity from "./Entity.js";
+import {Point, pointKey, Rect} from "./cartesian-math.js";
+import {findGridPath} from "../src/manhattan-router.js";
+import {isSym, sym, sexpParse, sexpStringify, symName, sexpCallName} from "./sexp.js";
+import {placeRect} from "./place-rect.js";
+
+export default class Schematic {
+	constructor(fn, options) {
+		this.schematicFileName=fn;
+		this.symbolLibraryPath=options.symbolLibraryPath;
+		this.symbolLibrary=new SymbolLibrary(this.symbolLibraryPath);
+	}
+
+	async load() {
+		this.sexp=sexpParse(await fsp.readFile(this.schematicFileName,"utf8"))[0];
+		this.entities=[];
+
+		for (let o of this.sexp) {
+			if (["wire","label","symbol"].includes(sexpCallName(o))) {
+				let e=new Entity(o,this);
+				await e.load();
+				this.entities.push(e);
+			}
+
+			if (sexpCallName(o)=="uuid")
+				this.uuid=o[1];
+		}
+
+		this.sexp=this.sexp.filter(o=>!["wire","label","symbol","uuid"].includes(sexpCallName(o)));
+	}
+
+	getSexp() {
+		let sexp=structuredClone(this.sexp);
+		sexp.push(...this.entities.map(e=>e.getSexp()));
+		sexp.push([sym("uuid"),this.uuid]);
+		return sexp;
+	}
+
+	async save() {
+		let content=sexpStringify([this.getSexp()],2);
+		await fsp.writeFile(this.schematicFileName,content);
+	}
+
+	getEntities() {
+		return this.entities;
+	}
+
+	sym(ref) {
+		for (let e of this.entities)
+			if (e.getType()=="symbol" && e.getReference()==ref)
+				return e;
+
+		throw new Error("Undefined symbol reference: "+ref);
+	}
+
+	getSymbolEntities() {
+		let entities=[];
+
+		for (let e of this.entities)
+			if (e.getType()=="symbol")
+				entities.push(e);
+
+		return entities;
+	}
+
+	getLabelEntities(label) {
+		let entities=[];
+
+		for (let e of this.entities)
+			if (e.getType()=="label" && e.getLabel()==label)
+				entities.push(e);
+
+		return entities;
+	}
+
+	getEntitiesByConnectionPoint(connectonPoint) {
+		connectonPoint=Point.from(connectonPoint);
+		let entities=[];
+
+		for (let e of this.entities) {
+			for (let p of e.getConnectionPoints())
+				if (connectonPoint.equals(p))
+					entities.push(e)
+		}
+
+		return entities;
+	}
+
+	getConnectionPoints() {
+		let points=[];
+		for (let e of this.entities)
+			points.push(...e.getConnectionPoints());
+
+		points=points.map(p=>Point.from(p));
+		return points;
+	}
+
+	arePointsConnected(p, q) {
+		return (!!this.getConnectionPath(p,q));
+	}
+
+	getConnectionPath(p, q) {
+		const startKey = pointKey(p);
+		const targetKey = pointKey(q);
+
+		// trivial case
+		if (startKey === targetKey) return [];
+
+		const visitedPoints = new Set();
+		const queue = [];
+
+		// each item: { point, path }
+		queue.push({
+			point: p,
+			path: []
+		});
+
+		while (queue.length > 0) {
+			const { point, path } = queue.shift();
+			const key = pointKey(point);
+
+			if (visitedPoints.has(key)) continue;
+			visitedPoints.add(key);
+
+			// find all entities touching this point
+			const entities = this.getEntitiesByConnectionPoint(point).filter(e=>e.getType()=="wire");
+
+			for (const entity of entities) {
+				const connectionPoints = entity.getConnectionPoints();
+
+				for (const cp of connectionPoints) {
+					const cpKey = pointKey(cp);
+
+					if (visitedPoints.has(cpKey)) continue;
+
+					const newPath = path.concat(entity);
+
+					// found target
+					if (cpKey === targetKey) {
+						return newPath;
+					}
+
+					queue.push({
+						point: cp,
+						path: newPath
+					});
+				}
+			}
+		}
+
+		// no path found
+		return null;
+	}
+
+	addConnectionWire(fromPoint, toPoint) {
+		let connectionPoints=this.getConnectionPoints();
+		connectionPoints=connectionPoints.filter(p=>!p.equals(fromPoint) && !p.equals(toPoint));
+		let avoidRects=connectionPoints.map(p=>new Rect(p.sub([0.635,0.635]),[1.27,1.27]));
+
+		let avoidLines=this.entities.filter(e=>e.getType()=="wire").map(e=>{
+			return ({
+				a: e.getConnectionPoints()[0],
+				b: e.getConnectionPoints()[1],
+			})
+		});
+
+		//console.log(avoidLines);
+
+		let points=findGridPath({
+			from: fromPoint,
+			to: toPoint,
+			gridSize: 1.27,
+			avoidRects: avoidRects,
+			avoidLines: avoidLines
+		});
+
+		for (let i=0; i<points.length-1; i++) {
+			let p1=points[i], p2=points[i+1];
+			let expr=[sym("wire"),
+				[sym("pts"), [sym("xy"),p1[0],p1[1]], [sym("xy"),p2[0],p2[1]]],
+				[sym("stroke"), [sym("width"),0], [sym("type"), sym("default")]],
+				[sym("uuid"),crypto.randomUUID()]
+			];
+
+			let e=new Entity(expr,this);
+			this.entities.push(e);
+		}
+	}
+
+	addLabel(point, label) {
+		let expr=[sym("label"),label,
+			[sym("at"),point[0],point[1],180],
+			[sym("effects"),
+				[sym("font"),[sym("size"),1.27,1.27]],
+				[sym("justify"),sym("right"),sym("bottom")]
+			],
+			[sym("uuid"),crypto.randomUUID()]
+		]
+
+		let e=new Entity(expr,this);
+		this.entities.push(e);
+		return e;
+	}
+
+	getLibSymbolsExp() {
+		//return sexpFirst(this.sexpr,x=>sexpCallName(x)=="lib_symbols")
+
+		for (let exp of this.sexp)
+			if (sexpCallName(exp)=="lib_symbols")
+				return exp;
+	}
+
+	async ensureLibSymbol(symbol) {
+		let libSymbolsExpr=this.getLibSymbolsExp();
+		for (let e of libSymbolsExpr)
+			if (sexpCallName(e)=="symbol" && e[1]==symbol)
+				return;
+
+		let librarySymbol=await this.symbolLibrary.loadLibrarySymbol(symbol);
+		//console.log("adding: "+symbol);
+		libSymbolsExpr.push(librarySymbol.getQualifiedSexpr());
+	}
+
+	async use(...symbols) {
+		symbols=symbols.flat(Infinity);
+		for (let symbol of symbols)
+			await this.ensureLibSymbol(symbol);
+	}
+
+	declare(ref, options) {
+		let entity=this.entities.find(e=>e.getType()=="symbol" && e.getReference()==ref);
+		if (!entity)
+			entity=this.addSymbol(ref,options);
+
+		if (entity.getLibId()!=options.symbol)
+			throw new Error("Symbol declaration mismatch.");
+
+		entity.setFootprint(options.footprint);
+		entity.declared=true;
+
+		return entity;
+	}
+
+	addSymbol(reference, {symbol, at}) {
+		let entity=this.entities.find(e=>e.getType()=="symbol" && e.getReference()==reference);
+		if (entity)
+			throw new Error("Reference already exists: "+reference);
+
+		let librarySymbol=this.symbolLibrary.getLibrarySymbol(symbol);
+		//let librarySymbol=await this.symbolLibrary.loadLibrarySymbol(symbol);
+		let rects=this.getSymbolEntities().map(e=>e.getBoundingRect().pad(2.54*4));
+
+		let center=new Point(101.6,101.6);
+		if (rects.length)
+			center=rects.reduce((r,q)=>r.union(q)).getCenter().snap(2.54);
+
+		if (!at) {
+			at=placeRect({
+				start: center,
+				rect: librarySymbol.getBoundingRect(),
+				avoid: rects,
+				step: 2.54,
+			});
+		}
+
+		let expr=[sym("symbol"),
+			[sym("lib_id"),symbol],
+			[sym("at"),at[0],at[1],0],
+			[sym("unit"),1],
+			[sym("exclude_from_sim"),sym("no")],
+			[sym("in_bom"),sym("yes")],
+			[sym("on_board"),sym("yes")],
+			[sym("dnp"),sym("no")],
+			[sym("fields_autoplaced"),sym("yes")],
+			[sym("uuid"),crypto.randomUUID()]
+		];
+
+		expr.push([sym("property"),"Reference",reference,
+			[sym("at"),at[0],at[1],0],
+			[sym("effects"),
+				[sym("font"),[sym("size"),1.27,1.27]],
+				[sym("justify"),sym("left")],
+			]
+		]);
+
+		for (let i=1; i<=librarySymbol.pins.length; i++)
+			expr.push([sym("pin"),String(i),[sym("uuid"),crypto.randomUUID()]]);
+
+		expr.push([sym("instances"),
+			[sym("project"),"",
+				[sym("path"),"/"+this.uuid,
+					[sym("reference"),reference],
+					[sym("unit"),1]
+				]
+			]
+		]);
+
+		let e=new Entity(expr,this);
+		e.init();
+		this.entities.push(e);
+
+		return e;
+	}
+
+	markConnectionDeclared(from, to) {
+		let wires=this.getConnectionPath(from,to);
+		for (let wire of wires) {
+			if (wire.getType()!="wire")
+				throw new Error("Sanity check... Wire is not a wire...");
+
+			wire.declared=true;
+		}
+	}
+
+	removeUndeclared() {
+		this.entities=this.entities.filter(entity=>{
+			return entity.declared;
+		});
+	}
+}
+
+export async function openSchematic(fn, options) {
+	let schematic=new Schematic(fn, options);
+	await schematic.load();
+
+	return schematic;
+}

package/src/SymbolLibrary.js

@@ -0,0 +1,101 @@
+import fs from "fs/promises";
+import path from "path";
+import LibrarySymbol from "./LibrarySymbol.js";
+import {sexpParse, sym, isSym, symEq} from "../src/sexp.js";
+
+/**
+ * SymbolLibrary represents a directory of .kicad_sym files.
+ * You can load a LibrarySymbol by its qualified name like
+ * "Connector_Generic:Conn_01x02".
+ */
+export default class SymbolLibrary {
+    constructor(dirPath) {
+        this.dirPath = dirPath;
+        this.index = new Map(); // Maps libraryName -> filename
+        this.cache = new Map(); // Maps libraryName -> parsed list of symbols
+        this.librarySymbols={};
+    }
+
+    getLibrarySymbol(qualifiedName) {
+        if (!this.librarySymbols[qualifiedName])
+            throw new Error("Symbol not loaded: "+qualifiedName);
+
+        return this.librarySymbols[qualifiedName];
+    }
+
+    /**
+     * Load the correct LibrarySymbol by full name "Lib:Symbol".
+     * @param {string} qualifiedName
+     * @returns {Promise<LibrarySymbol>}
+     */
+    async loadLibrarySymbol(qualifiedName) {
+        if (this.librarySymbols[qualifiedName])
+            return this.librarySymbols[qualifiedName];
+
+        const [libraryName, symbolName] = qualifiedName.split(":");
+        if (!libraryName || !symbolName) {
+            throw new Error(
+                `Invalid qualified name "${qualifiedName}", expected "Library:Symbol"`
+            );
+        }
+
+        await this._ensureIndex();
+
+        const fileName = this.index.get(libraryName);
+        if (!fileName) {
+            throw new Error(`Library "${libraryName}" not found in ${this.dirPath}`);
+        }
+
+        //console.log(libraryName,fileName);
+
+        const syms = await this._loadLibraryFile(libraryName, fileName);
+        const sexpr = syms.find((s) => s[1] === symbolName);
+        if (!sexpr) {
+            throw new Error(
+                `Symbol "${symbolName}" not found in library "${libraryName}"`
+            );
+        }
+
+        this.librarySymbols[qualifiedName]=new LibrarySymbol(sexpr,qualifiedName);
+
+        return this.librarySymbols[qualifiedName];
+    }
+
+    /**
+     * Scan the directory to find all .kicad_sym files and index them
+     * by base name (without extension).
+     */
+    async _ensureIndex() {
+        if (this.index.size > 0) return;
+
+        const entries = await fs.readdir(this.dirPath);
+        for (const entry of entries) {
+            if (entry.endsWith(".kicad_sym")) {
+                const libName = path.basename(entry, ".kicad_sym");
+                this.index.set(libName, entry);
+            }
+        }
+    }
+
+    /**
+     * Read and parse a .kicad_sym file if not cached.
+     */
+    async _loadLibraryFile(libraryName, fileName) {
+        if (this.cache.has(libraryName)) {
+            return this.cache.get(libraryName);
+        }
+
+        const fullPath = path.join(this.dirPath, fileName);
+        const raw = await fs.readFile(fullPath, "utf8");
+        const sexprs = sexpParse(raw)[0]; // Your sexprParse
+
+        // Filter only top-level (symbol ...) forms
+        const symbols = sexprs.filter(
+            (e) => Array.isArray(e) && symEq(e[0],"symbol")
+        );
+
+        this.cache.set(libraryName, symbols);
+        return symbols;
+    }
+}
+

package/src/cartesian-math.js

@@ -0,0 +1,127 @@
+export class Point extends Array {
+	constructor(...a) {
+		if (a)
+			super(...[a].flat(Infinity));
+
+		else
+			super();
+	}
+
+	add(p) {
+		return Point.from([
+			this[0]+p[0],
+			this[1]+p[1]
+		]);
+	}
+
+	sub(p) {
+		return Point.from([
+			this[0]-p[0],
+			this[1]-p[1]
+		]);
+	}
+
+	equals(p) {
+		return (pointKey(this)==pointKey(p));
+	}
+
+	snap(gridSize) {
+		return new Point([
+			Math.round(this[0]/gridSize)*gridSize,
+			Math.round(this[1]/gridSize)*gridSize,
+		]);
+	}
+}
+
+export class Rect {
+	constructor(corner, size) {
+		this.corner=Point.from(corner);
+		this.size=Point.from(size);
+	}
+
+	static fromCorners(p1, p2) {
+		p1=new Point(p1);
+		p2=new Point(p2);
+
+		return new Rect(p1,p2.sub(p1));
+	}
+
+	getLeft() {
+		if (this.size[0]<0)
+			return this.corner[0]+this.size[0];
+
+		return this.corner[0]
+	}
+
+	getRight() {
+		if (this.size[0]<0)
+			return this.corner[0];
+
+		return this.corner[0]+this.size[0];
+	}
+
+	getTop() {
+		if (this.size[1]<0)
+			return this.corner[1]+this.size[1];
+
+		return this.corner[1]
+	}
+
+	getBottom() {
+		if (this.size[1]<0)
+			return this.corner[1];
+
+		return this.corner[1]+this.size[1];
+	}
+
+	getTopLeft() {
+		return new Point(this.getLeft(),this.getTop());
+	}
+
+	getBottomRight() {
+		return new Point(this.getRight(),this.getBottom());
+	}
+
+	union(r) {
+		let left=Math.min(this.getLeft(),r.getLeft());
+		let top=Math.min(this.getTop(),r.getTop());
+		let right=Math.max(this.getRight(),r.getRight());
+		let bottom=Math.max(this.getBottom(),r.getBottom());
+
+		return Rect.fromCorners([left,top],[right,bottom]);
+	}
+
+	overlaps(other) {
+	    return !(
+			this.getRight()  <= other.getLeft()  ||
+			this.getLeft()   >= other.getRight() ||
+			this.getBottom() <= other.getTop()   ||
+			this.getTop()    >= other.getBottom()
+	    );
+	}
+
+	translate(p) {
+	    return new Rect(
+			this.corner.add(p),
+			this.size
+	    );
+	}
+
+	pad(border) {
+		return Rect.fromCorners(
+			this.getTopLeft().sub([border,border]),
+			this.getBottomRight().add([border,border])
+		);
+	}
+
+	getCenter() {
+		return new Point(
+			(this.getLeft()+this.getRight())/2,
+			(this.getTop()+this.getBottom())/2
+		);
+	}
+}
+
+export function pointKey(p) {
+	return `${p[0].toFixed(2)},${p[1].toFixed(2)}`;
+}

package/src/kisch-cli.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import {program} from "commander";
+import Schematic from "./Schematic.js";
+import path from "node:path";
+
+program
+	.description("Create or update KiCad schematic based on programmatic description.")
+	.option("--symbol-library-path <path>","Where to find KiCad symbols.")
+	.requiredOption("--script <script>","JavaScript file to transform the schematic.")
+	.argument("<schematic>","KiCad Schematic file.")
+
+await program.parseAsync();
+let options={
+	...program.opts(),
+	schematic: program.args[0],
+}
+
+//console.log(options);
+
+let schematic=new Schematic(options.schematic,{
+	symbolLibraryPath: options.symbolLibraryPath
+});
+
+await schematic.load();
+
+global.schematic=schematic;
+let mod=await import(path.resolve(options.script));
+if (typeof mod.default=="function")
+	await mod.default(schematic);
+
+schematic.removeUndeclared();
+await schematic.save();