kisch 1.0.3 → 1.0.5

package/README.md

@@ -4,6 +4,8 @@
 
 kisch — schema‑transformation tool for KiCad schematics
 
+[Watch video tutorial](https://www.youtube.com/watch?v=VylXziX1D8U)
+
 ## SYNOPSIS
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kisch",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "",
   "repository": {
     "type": "git",
@@ -10,7 +10,7 @@
     "test": "jasmine"
   },
   "bin": {
-    "kisch": "src/kisch-cli.js"
+    "kisch": "src/app/kisch-cli.js"
   },
   "keywords": [],
   "author": "",
@@ -22,5 +22,8 @@
   },
   "dependencies": {
     "commander": "^14.0.3"
+  },
+  "exports": {
+    ".": "./src/exports.js"
   }
 }

package/src/app/exports.js

@@ -0,0 +1 @@
+export {default as SymbolLibrary} from "./SymbolLibrary.js";

package/src/{kisch-cli.js → app/kisch-cli.js}

@@ -1,16 +1,12 @@
 #!/usr/bin/env node
 
 import {program} from "commander";
-import Schematic, {loadSchematic, createSchematic} from "./Schematic.js";
+import Schematic, {loadSchematic, createSchematic} from "../schematic/Schematic.js";
 import path from "node:path";
-import pkg from "../package.json" with { type: "json" };
-import {DeclaredError} from "./js-util.js";
+import pkg from "../../package.json" with { type: "json" };
+import {DeclaredError} from "../utils/js-util.js";
 import fs, {promises as fsp} from "fs";
-
-/*todo...
-
-defines
-wires*/
+import {compoundSymbol} from "../schematic/CompoundSymbol.js";
 
 let HELP_TEXT=`
 Examples:
@@ -45,6 +41,8 @@ program
     .option("-s, --script <script.js>", "Input script to apply to schematic.")
     .option("-e, --emit <script.js>", "Emit script based on schematic.")
     .option("-q, --quiet", "No output, except for errors.")
+    .option("-a, --append", "Append mode: don't remove undeclared.")
+    .option("--bounding-boxes", "Remove wires and draw bounding boxes instead (only for debug!).")
     //.option("-v, --verbose", "Print detailed execution info")
     .option(
         "-D, --define <key=value>", 
@@ -111,11 +109,29 @@ try {
             ([e.slice(0,e.indexOf("=")),e.slice(e.indexOf("=")+1)])
         ));
 
+        global.compoundSymbol=compoundSymbol;
         let mod=await import(path.resolve(options.script));
         if (typeof mod.default=="function")
             await mod.default(schematic,defines);
 
-        schematic.removeUndeclared();
+        if (!options.append)
+            schematic.removeUndeclared();
+    }
+
+    if (options.boundingBoxes) {
+        cons.info("Drawing bounding boxes...");
+        for (let e of schematic.getEntities({type: "wire"})) {
+            schematic.removeEntity(e);
+        }
+
+        for (let s of schematic.getEntities({type: "symbol"})) {
+            schematic.drawWireRect(s.getBoundingRect());
+            for (let p of s.getPins()) {
+                schematic.drawWirePoint(p.getPoint());
+                schematic.drawWirePoint(p.getLegPoint());
+                schematic.drawWireLine(p.getPoint(),p.getLegPoint());
+            }
+        }
     }
 
     if (options.emit) {

package/src/schematic/CompoundSymbol.js

@@ -0,0 +1,36 @@
+export default class CompoundSymbol {
+	constructor(...symbols) {
+		this.symbols=symbols;
+		this.pins=[];
+
+		for (let symbol of symbols) {
+			let pinNums=symbol.getPinNums();
+			pinNums.sort();
+
+			for (let pinNum of pinNums) {
+				this.pins.push(symbol.pin(pinNum));
+			}
+		}
+	}
+
+	pin(num) {
+		if (!num)
+			throw new Error("Pins start at 1");
+
+		return this.pins[num-1];
+	}
+
+	namePins(names) {
+		if (names.length!=this.pins.length)
+			throw new Error("pin count mismatch");
+
+		for (let i=0; i<this.pins.length; i++)
+			this[names[i]]=this.pins[i];
+
+		return this;
+	}
+}
+
+export function compoundSymbol(...args) {
+	return new CompoundSymbol(...args);
+}

package/src/{Entity.js → schematic/Entity.js}

@@ -1,31 +1,60 @@
-import {Point} from "./cartesian-math.js";
-import {sym, symName, sexpCallName} from "./sexp.js";
-import {Rect} from "./cartesian-math.js";
+import {Point, Rect} from "../utils/cartesian-math.js";
+import {sym, symName, sexpCallName} from "../utils/sexp.js";
 
 class EntityPin {
 	constructor(sexpr, entity) {
 		this.sexpr=sexpr;
 		this.entity=entity;
 
-		//console.log(this.sexpr);
+		//console.log("ctor pin num: "+this.sexpr[1]);
 	}
 
 	getNum() {
+		//console.log("pin num: "+this.sexpr[1]);
+
 		return this.sexpr[1];
 	}
 
-	getPoint() {
+	initPoint() {
 		let librarySymbol=this.entity.getLibrarySymbol();
-		let librarySymbolPin=librarySymbol.getPin(Number(this.getNum()));
+		let librarySymbolPin;
+		if (isNaN(this.getNum()))
+			librarySymbolPin=librarySymbol.getPin(this.getNum());
+
+		else
+			librarySymbolPin=librarySymbol.getPin(Number(this.getNum()));
+
 		let pinAt=Point.from(librarySymbolPin.at);
+		let symbolAt=this.entity.getAt();
+		let symbolRot=this.entity.getRotation();
 		pinAt[1]=-pinAt[1];
 
-		return Point.from(this.entity.getAt()).add(pinAt);
+		//this.point=Point.from(symbolAt).add(pinAt.rotateDegrees(-symbolAt[2]));
+		//this.point=Point.from(symbolAt).add(pinAt.rotateDegrees(-this.entity.getRotation()));
+		this.point=Point.from(symbolAt).add(pinAt.rotateDegrees(-symbolRot));
+
+		let leg=new Point(librarySymbolPin.length,0);
+		leg=leg.rotateDegrees(-(librarySymbolPin.rotation+symbolRot));
+		this.legPoint=this.point.add(leg);
+	}
+
+	getLegPoint() {
+		if (!this.legPoint)
+			this.initPoint();
+
+		return this.legPoint;
+	}
+
+	getPoint() {
+		if (!this.point)
+			this.initPoint();
+
+		return this.point;
 	}
 
 	isConnected(p) {
 		if (typeof p=="string") {
-			for (let e of this.entity.schematic.getLabelEntities(p)) {
+			for (let e of this.entity.schematic.getEntities({label: p})) {
 				let p=e.getConnectionPoints()[0];
 				if (this.entity.schematic.arePointsConnected(this.getPoint(),p))
 					return true;
@@ -40,9 +69,12 @@ class EntityPin {
 	}
 
 	connect(p) {
+		if (!p)
+			return;
+
 		if (this.isConnected(p)) {
 			if (typeof p=="string") {
-				for (let e of this.entity.schematic.getLabelEntities(p)) {
+				for (let e of this.entity.schematic.getEntities({label: p})) {
 					let p=e.getConnectionPoints()[0];
 					if (this.entity.schematic.arePointsConnected(this.getPoint(),p)) {
 						e.declared=true;
@@ -64,11 +96,16 @@ class EntityPin {
 		}
 
 		else {
+			//console.log("connecting wire",this.toString(),"->",p.toString());
 			this.entity.schematic.addConnectionWire(this.getPoint(),p.getPoint());
 			this.entity.schematic.markConnectionDeclared(this.getPoint(),p.getPoint());
 		}
 	}
 
+	toString() {
+		return this.entity.getReference()+":"+this.getNum();
+	}
+
 	getConnections() {
 		let connections=[];
 
@@ -77,7 +114,7 @@ class EntityPin {
 				connections.push(net);
 		}
 
-		for (let e of this.entity.schematic.getSymbolEntities()) {
+		for (let e of this.entity.schematic.getEntities({type: "symbol"})) {
 			if (e==this.entity)
 				continue;
 
@@ -97,7 +134,7 @@ export default class Entity {
 		this.pins=[];
 
 		this.type=symName(this.sexpr[0]);
-		if (!["symbol","wire","label"].includes(this.type))
+		if (!["symbol","wire","label","junction"].includes(this.type))
 			throw new Error("Unknown entity: "+this.type);
 
 		for (let a of this.sexpr)
@@ -105,6 +142,14 @@ export default class Entity {
 				this.pins.push(new EntityPin(a,this));
 	}
 
+	getRotation() {
+		return this.getAt()[2];
+	}
+
+	getPins() {
+		return this.pins;
+	}
+
 	getSexp() {
 		return this.sexpr;
 	}
@@ -178,6 +223,36 @@ export default class Entity {
 		el[2]=footprint;
 	}
 
+	removeProp(name) {
+		if (this.getType()!="symbol")
+			throw new Error("Only symbols have props");
+
+		let index=this.sexpr.findIndex(a=>sexpCallName(a)=="property" && a[1]==name);
+		if (index<0)
+			return;
+
+		this.sexpr.splice(index,1);
+	}
+
+	setProp(name, value) {
+		if (this.getType()!="symbol")
+			throw new Error("Only symbols have props");
+
+		let el=this.sexpr.find(a=>sexpCallName(a)=="property" && a[1]==name);
+		if (!el) {
+			let exp=[sym("property"),name,"",
+				[sym("effects"),
+					[sym("hide"),sym("yes")]
+				]
+			];
+
+			this.sexpr.push(exp);
+			el=exp;
+		}
+
+		el[2]=value;
+	}
+
 	getLibId() {
 		return this.sexpr.find(x=>sexpCallName(x)=="lib_id")[1];
 	}
@@ -196,12 +271,18 @@ export default class Entity {
 	}
 
 	getBoundingRect() {
+		if (!this.librarySymbol)
+			throw new Error("Can't get bounding rect, no library symbol");
+
 		//console.log(this.librarySymbol);
 		let r=this.librarySymbol.getBoundingRect();
+		let corner=r.corner.rotateDegrees(-this.getRotation());
+		let size=r.size.rotateDegrees(-this.getRotation());
+
 		//console.log(r);
 		let p=Point.from(this.getAt());
 
-		return new Rect(p.add(r.corner),r.size);
+		return new Rect(p.add(corner),size);
 	}
 
 	getLibrarySymbol() {
@@ -212,19 +293,26 @@ export default class Entity {
 		if (!num)
 			throw new Error("Pin numbers start at 1");
 
-		for (let p of this.pins)
+		for (let p of this.pins) {
+			//console.log("pin num: "+p.getNum());
+
 			if (p.getNum()==num)
 				return p;
+		}
+
+		throw new Error("Can't find pin: "+num);
 	}
 
 	getType() {
 		return this.type;
-		/*let t=symName(this.sexpr[0]);
+	}
 
-		if (!["symbol","wire","label"].includes(t))
-			throw new Error("Unknown entity: "+t);
+	getPinNums() {
+		let nums=[];
+		for (let p of this.pins)
+			nums.push(p.getNum())
 
-		return t;*/
+		return nums;
 	}
 
 	getConnectionPoints() {
@@ -239,8 +327,11 @@ export default class Entity {
 
 			case "symbol":
 				let p=[];
-				for (let i=1; i<=this.pins.length; i++)
-					p.push(this.pin(i).getPoint());
+				for (let num of this.getPinNums())
+					p.push(this.pin(num).getPoint());
+
+				/*for (let i=1; i<=this.pins.length; i++)
+					p.push(this.pin(i).getPoint());*/
 
 				return p;
 				break;
@@ -249,4 +340,43 @@ export default class Entity {
 				throw new Error("Unknown entity type: "+this.getType());
 		}
 	}
+
+	connect(...pins) {
+		if (this.getType()!="symbol")
+			throw new Error("can only connect symbols");
+
+		if (pins.length!=this.pins.length)
+			throw new Error("pin count mismatch");
+
+		for (let i=0; i<this.pins.length; i++)
+			this.pins[i].connect(pins[i]);
+	}
+
+	containsPoint(p) {
+		function isNumberInRangeInclusive(num, a, b) {
+		    return ((num >= Math.min(a, b)) && (num <= Math.max(a, b)));
+		}
+
+		if (this.getType()!="wire")
+			throw new Error("Only a wire can contain points");
+
+		p=Point.from(p);
+		let cp=this.getConnectionPoints();
+		if (cp[0][0]==cp[1][0]) { // vertical
+			if (p[0]!=cp[0][0])
+				return false;
+
+			return isNumberInRangeInclusive(p[1],cp[0][1],cp[1][1]);
+		}
+
+		else if (cp[0][1]==cp[1][1]) { // horizontal
+			if (p[1]!=cp[0][1])
+				return false;
+
+			return isNumberInRangeInclusive(p[0],cp[0][0],cp[1][0]);
+		}
+
+		else 
+			throw new Error("wire is not horizontal or vertical");
+	}
 }

package/src/{LibrarySymbol.js → schematic/LibrarySymbol.js}

@@ -1,5 +1,5 @@
-import {sym, isSym, symEq, symName, sexpStringify, sexpCallName} from "./sexp.js";
-import {Rect} from "./cartesian-math.js";
+import {sym, isSym, symEq, symName, sexpStringify, sexpCallName} from "../utils/sexp.js";
+import {Rect} from "../utils/cartesian-math.js";
 
 export default class LibrarySymbol {
     constructor(sexpr, qualifiedName) {
@@ -61,6 +61,13 @@ export default class LibrarySymbol {
             if (sexpCallName(x)=="rectangle") {
                 let start=x.find(x=>sexpCallName(x)=="start").slice(1);
                 let end=x.find(x=>sexpCallName(x)=="end").slice(1);
+
+                start[1]=-start[1];
+                end[1]=-end[1];
+
+                /*console.log(start);
+                console.log(end);*/
+
                 let r=Rect.fromCorners(start,end);
 
                 if (!rect)
@@ -68,6 +75,32 @@ export default class LibrarySymbol {
 
                 rect=rect.union(r);
             }
+
+            if (sexpCallName(x)=="polyline") {
+                //console.log("poly line...");
+                for (let sub of x) {
+                    if (sexpCallName(sub)=="pts") {
+                        for (let p of sub) {
+                            if (sexpCallName(p)=="xy") {
+                                let point=[p[1],p[2]];
+
+                                if (!rect)
+                                    rect=new Rect(point,[0,0]);
+
+                                //console.log("rect",rect);
+                                //console.log("point",point);
+
+                                rect=rect.includePoint(point);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (!rect) {
+            //console.log(symbolExp);
+            throw new Error("Symbol doesn't have any rect!");
         }
 
         //console.log(sexpStringify(symbolExp));
@@ -93,7 +126,9 @@ export class LibrarySymbolPin {
 
             switch (symName(e[0])) {
                 case "at":
+                    //console.log(e);
                     this.at = e.slice(1).map(Number); // [x, y, rotation]
+                    this.rotation=Number(e[3]);
                     break;
                 case "length":
                     this.length = Number(e[1]);