@packtrack/layout 1.1.0 → 1.3.0

package/source/layout.ts

@@ -1,5 +1,5 @@
 import { District } from "./district";
-import { PowerDistrict } from "./power-district";
+import { PowerDistrict } from "./power-district/index";
 import { Route } from "./route";
 import { Router } from "./router";
 import { Section } from "./section";
@@ -12,6 +12,8 @@ import { PointPositioner } from "./positioner/point";
 import { PowerDistrictActivator } from "./power-district/activator";
 import { PowerDistrictReverser } from "./power-district/reverser";
 import { PowerDistrictMonitor } from "./power-district/monitor";
+import { Monitor } from "./monitor";
+import { Throttle } from "./throttle";
 
 export class Layout {
 	name: string;
@@ -21,6 +23,9 @@ export class Layout {
 	devices: Device[] = [];
 	responderType: ResponderType[] = [];
 
+	monitors: Monitor[] = [];
+	throttles: Throttle[] = [];
+
 	get allDistricts() {
 		const districts: District[] = [];
 
@@ -48,35 +53,55 @@ export class Layout {
 		const version = railway.getAttribute('version');
 
 		if (version == '1') {
-			let district = railway.firstChild;
+			let child = railway.firstChild;
+
+			while (child) {
+				if (child.tagName == 'district') {
+					layout.districts.push(layout.loadDistrict(child, layout));
+				}
 
-			while (district) {
-				if (district.tagName == 'district') {
-					layout.districts.push(layout.loadDistrict(district, layout));
+				if (child.tagName == 'monitor') {
+					layout.monitors.push(layout.loadMonitor(child, layout));
 				}
 
-				district = district.nextSibling;
+				if (child.tagName == 'throttle') {
+					layout.throttles.push(layout.loadThrottle(child, layout));
+				}
+
+				child = child.nextSibling;
 			}
 
-			district = railway.firstChild;
+			child = railway.firstChild;
 			let index = 0;
 
-			while (district) {
-				if (district.tagName == 'district') {
-					layout.linkDistrict(district, layout.districts[index]);
+			while (child) {
+				if (child.tagName == 'district') {
+					layout.linkDistrict(child, layout.districts[index]);
 
 					index++;
 				}
 
-				district = district.nextSibling;
+				child = child.nextSibling;
 			}
 		} else {
-			throw new Error(`unsupported railway definition file version '${version}'`);
+			throw new Error(`Unsupported railway definition file version '${version}'`);
 		}
 
 		return layout;
 	}
 
+	loadMonitor(source, parent: District | Layout) {
+		const montior = new Monitor(this.findDevice(source.getAttribute('device')), parent);
+
+		return montior;
+	}
+
+	loadThrottle(source, parent: District | Layout) {
+		const throttle = new Throttle(this.findDevice(source.getAttribute('device')), parent);
+
+		return throttle;
+	}
+
 	loadDistrict(source, parent: District | Layout) {
 		const district = new District(source.getAttribute('name'), parent);
 
@@ -107,6 +132,10 @@ export class Layout {
 				district.children.push(this.loadDistrict(child, district));
 			}
 
+			if (child.tagName == 'monitor') {
+				district.monitors.push(this.loadMonitor(child, district));
+			}
+
 			child = child.nextSibling;
 		}
 
@@ -314,6 +343,7 @@ export class Layout {
 
 	linkRouter(source, router: Router) {
 		let child = source.firstChild;
+		let active: Route;
 
 		while (child) {
 			if (child.tagName == 'route') {
@@ -325,11 +355,21 @@ export class Layout {
 				route.out = this.findSection(child.getAttribute('out'), router.district);
 				route.out.in = router;
 
+				if (child.hasAttribute('active')) {
+					if (active) {
+						throw new Error(`Router '${router.domainName}' has multiple active routes (${active.name}, ${route.name}).`);
+					}
+
+					active = route;
+				}
+
 				router.routes.push(route);
 			}
 
 			child = child.nextSibling;
 		}
+
+		router.activeRoute = active;
 	}
 
 	loadPowerDistrict(source, district: District) {
@@ -360,66 +400,4 @@ export class Layout {
 
 		return powerDistrict;
 	}
-
-	toDot() {
-		let dot = 'digraph G {';
-
-		for (let district of this.districts) {
-			dot += district.toDotDefinition();
-		}
-
-		for (let district of this.districts) {
-			dot += district.toDotConnection();
-		}
-
-		return `${dot}}`;
-	}
-
-	toSVG(inject = '') {
-		const positons = this.districts.map(district => district.findSVGPositions()).flat(Infinity);
-
-		const width = Math.max(...positons.map(position => position.x));
-		const height = Math.max(...positons.map(position => position.y));
-
-		let svg = `<svg width="100vw" height="100vh" viewBox="0 0 ${width + 1} ${height + 1}" xmlns="http://www.w3.org/2000/svg">
-			<style>
-
-				path {
-					fill: none;
-					stroke: #000;
-					stroke-width: 0.2;
-				}
-
-			</style>
-		`;
-
-		for (let district of this.districts) {
-			svg += district.toSVG();
-		}
-
-		return `${svg}${inject}</svg>`;
-	}
-
-	dump() {
-		console.group(`Layout ${this.name}`);
-		console.log('devices');
-
-		for (let device of this.devices) {
-			device.dump();
-		}
-
-		console.log('responder types');
-
-		for (let type of this.responderType) {
-			type.dump();
-		}
-
-		console.log('districts');
-
-		for (let district of this.districts) {
-			district.dump();
-		}
-
-		console.groupEnd();
-	}
 }

package/source/monitor.ts

@@ -0,0 +1,10 @@
+import { Device } from "./device/index";
+import { District } from "./district";
+import { Layout } from "./layout";
+
+export class Monitor {
+	constructor(
+		public device: Device,
+		public scope: District | Layout
+	) { }
+}

package/source/position.ts

@@ -1,35 +1,55 @@
 import { Section } from './section.js';
 
 export class SectionPosition {
-    constructor(
-        public section: Section,
-        public offset: number,
-        public reversed: boolean
-    ) {}
-
-    get absolutePosition() {
-        if (this.reversed) {
-            return this.section.length - this.offset;
-        }
-
-        return this.offset;
-    }
-
-    advance(distance: number) {
-        if (this.offset + distance > this.section.length) {
-            const next = this.section.next(this.reversed);
-
-            if (!next) {
-                throw new Error(`Illegal advancement ${this} + ${distance}`);
-            }
-
-            return new SectionPosition(next, 0, this.reversed).advance(this.offset + distance - this.section.length);
-        }
-        
-        return new SectionPosition(this.section, this.offset + distance, this.reversed);
-    }
-
-    toString() {
-        return `${this.section.name} @ ${this.offset.toFixed(1)} ${this.reversed ? 'backward' : 'forward'}`;
-    }
-}
+	constructor(
+		public section: Section,
+		public offset: number,
+		public reversed: boolean
+	) {
+		if (offset > section.length || offset < 0) {
+			throw new Error(`Offset ${offset} out of range for section '${section.domainName}' (0 - ${section.length})`);
+		}
+	}
+
+	// returns the absolute position of the point inside the section
+	// regardless of direction
+	get absolutePosition() {
+		if (this.reversed) {
+			return this.section.length - this.offset;
+		}
+
+		return this.offset;
+	}
+
+	// TODO verify reverse
+	advance(distance: number): SectionPosition {
+		if (distance < 0) {
+			return this.invert().advance(-distance).invert();
+		}
+
+		if (this.offset + distance > this.section.length) {
+			const next = this.section.next(this.reversed);
+
+			if (!next) {
+				throw new Error(`Illegal advancement ${this} + ${distance}`);
+			}
+
+			return new SectionPosition(next, 0, this.reversed).advance(this.offset + distance - this.section.length);
+		}
+
+		return new SectionPosition(this.section, this.offset + distance, this.reversed);
+	}
+
+	// reverse direction
+	private invert() {
+		return new SectionPosition(this.section, this.section.length - this.offset, !this.reversed);
+	}
+
+	toString() {
+		return `${this.section.name} @ ${this.offset.toFixed(1)} ${this.reversed ? 'backward' : 'forward'}`;
+	}
+
+	toPackTrackValue() {
+		return `${this.section.domainName}@${this.offset}${this.reversed ? 'R' : 'F'}`;
+	}
+}

package/source/positioner/point.ts

@@ -1,4 +1,4 @@
-import { Positioner } from ".";
+import { Positioner } from "./index";
 import { Channel } from "../device/channel";
 import { Track } from "../track";
 import { ResponderType } from "./responder-type";
@@ -16,13 +16,4 @@ export class PointPositioner extends Positioner {
 	get position() {
 		return this.track.head.advance(this.offset);
 	}
-	
-	dump() {
-		console.group('Point positioner');
-		console.log('offset:', this.offset);
-
-		this.channel.dump();
-
-		console.groupEnd();
-	}
-}
+}

package/source/positioner/responder-type.ts

@@ -2,8 +2,4 @@ export class ResponderType {
 	constructor(
 		public name: string
 	) {}
-
-	dump() {
-		console.log(`Responder Type '${this.name}'`);
-	}
-}
+}

package/source/power-district/index.ts

@@ -1,5 +1,4 @@
 import { PowerDistrictActivator } from "./activator";
-import { Device } from "../device/index";
 import { District } from "../district";
 import { PowerDistrictMonitor } from "./monitor";
 import { PowerDistrictReverser } from "./reverser";
@@ -17,8 +16,4 @@ export class PowerDistrict {
 	get domainName() {
 		return `${this.name}.${this.district.domainName}`;
 	}
-
-	dump() {
-		console.log(this.name);
-	}
 }

package/source/route.ts

@@ -4,13 +4,9 @@ import { Section } from "./section";
 export class Route {
 	in: Section;
 	out: Section;
-	
+
 	constructor(
 		public name: string,
 		public router: Router,
 	) {}
-	
-	dump() {
-		console.log(`Route ${this.name}: ${this.in.domainName} → ${this.out.domainName}`);
-	}
-}
+}

package/source/router.ts

@@ -5,7 +5,7 @@ export class Router {
 	activeRoute?: Route;
 
 	routes: Route[] = [];
-	
+
 	constructor(
 		public name: string,
 		public district: District
@@ -14,33 +14,4 @@ export class Router {
 	get domainName() {
 		return `${this.name}.${this.district.domainName}`;
 	}
-	
-	dump() {
-		console.group(`Router ${this.domainName}`);
-
-		for (let route of this.routes) {
-			route.dump();
-		}
-
-		console.groupEnd();
-	}
-	
-	toDotReference() {
-		return `router_${this.name.replace(/-/g, '_')}_${this.district.toDotReference()}`;
-	}
-	
-	toDotDefinition() {
-		return `
-			${this.toDotReference()} [ label = ${JSON.stringify(this.name)}, shape = diamond ]
-		`;
-	}
-	
-	toDotConnection() {
-		return `
-			${this.routes.map(route => `
-				${route.in.toDotReference()} -> ${this.toDotReference()} [ headlabel = ${JSON.stringify(route.name)} ]
-				${this.toDotReference()} -> ${route.out.toDotReference()} [ taillabel = ${JSON.stringify(route.name)} ]
-			`).join('')}
-		`;
-	}
-}
+}

package/source/section.ts

@@ -1,19 +1,19 @@
 import { District } from "./district";
 import { SectionPosition } from "./position";
-import { PowerDistrict } from "./power-district";
+import { PowerDistrict } from "./power-district/index";
 import { Router } from "./router";
 import { Tile } from "./tile";
 import { Track } from "./track";
 
 export class Section {
 	powerDistrict: PowerDistrict;
-	
+
 	tracks: Track[] = [];
 	tiles: Tile[] = [];
-	
+
 	in?: Router | Section;
 	out?: Router | Section;
-	
+
 	constructor(
 		public name: string,
 		public district: District
@@ -87,14 +87,14 @@ export class Section {
 					start: 0,
 					end: this.tiles[this.tiles.length - 1].pattern.length
 				},
-			
+
 				tiles: [...this.tiles]
 			};
 		}
 
 		let start = 0;
 		let end = this.length;
-		
+
 		// only use the position limit if it is within our section
 		if (startPosition.section == this) {
 			end = startPosition.absolutePosition;
@@ -131,7 +131,7 @@ export class Section {
 				if (start <= passed) {
 					offset.start = (start + length - passed) * tile.pattern.length / length;
 				}
-	
+
 				if (end >= passed) {
 					offset.end = 0.5; // (start + length - passed) * tile.pattern.length / length;
 				}
@@ -139,29 +139,13 @@ export class Section {
 
 			passed += length;
 		}
-		
+
 		return {
 			offset,
 			tiles
 		};
 	}
-	
-	dump() {
-		console.group(`Section ${this.domainName}`);
-		
-		console.log('in', this.in?.name ?? 'buffer');
-		console.log('out', this.out?.name ?? 'buffer');
-		
-		console.group(`tracks`);
-		
-		for (let track of this.tracks) {
-			track.dump();
-		}
-		
-		console.groupEnd();
-		console.groupEnd();
-	}
-	
+
 	get length() {
 		return this.tracks.reduce((accumulator, track) => accumulator + track.length, 0);
 	}
@@ -227,43 +211,4 @@ export class Section {
 			tip: new SectionPosition(tip, reversed ? -length : tip.length + length, false)
 		};
 	}
-	
-	toDotReference() {
-		return `section_${this.name.replace(/-/g, '_')}_${this.district.toDotReference()}`;
-	}
-	
-	toDotDefinition() {
-		return `
-			${this.toDotReference()} [ label = ${JSON.stringify(`${this.name}\n${this.length}`)}, shape = box ]
-		`;
-	}
-	
-	toDotConnection() {
-		return `
-			${this.out instanceof Section ? `${this.toDotReference()} -> ${this.out.toDotReference()}` : ''}
-		`;
-	}
-
-	toSVG() {
-		return `
-			<g id=${JSON.stringify(this.domainName).split('.').join('_')}>
-				<style>
-
-					g#${this.domainName.split('.').join('_')} path {
-						stroke: hsl(${(this.length / this.tileLength)}deg, 100%, 50%);
-					}
-
-				</style>
-
-				${this.tiles.map(tile => tile.toSVG()).join('')}
-			</g>
-		`;
-	}
-
-	findSVGPositions() {
-		return this.tiles.map(tile => ({ 
-			x: tile.x,
-			y: tile.y
-		}));
-	}
-}
+}

package/source/span.ts

@@ -0,0 +1,88 @@
+import { SectionPosition } from "./position";
+import { Section } from "./section";
+
+export class Span {
+	constructor(
+		public head: SectionPosition,
+		public inside: Section[],
+		public tail: SectionPosition
+	) { }
+
+	// TODO verify reverse
+	contains(position: SectionPosition) {
+		if (this.inside.includes(position.section)) {
+			return true;
+		}
+
+		if (position.section == this.head.section) {
+			if (this.head.reversed) {
+				if (this.head.absolutePosition > position.absolutePosition) {
+					return true;
+				}
+			} else {
+				if (this.head.offset < position.absolutePosition) {
+					return true;
+				}
+			}
+		}
+
+		if (position.section == this.tail.section) {
+			if (this.tail.reversed) {
+				if (this.tail.absolutePosition < position.absolutePosition) {
+					return true;
+				}
+			} else {
+				if (this.tail.offset > position.absolutePosition) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+
+	overlap(peer: Span) {
+		return this.contains(peer.head) || this.contains(peer.tail);
+	}
+
+	get length() {
+		let length = 0;
+
+		if (this.head.reversed) {
+			length += this.head.section.length - this.head.offset;
+		} else {
+			length += this.head.offset;
+		}
+
+		for (let section of this.inside) {
+			length += section.length;
+		}
+
+		if (this.tail.reversed) {
+			length += this.tail.section.length - this.tail.offset;
+		} else {
+			length += this.tail.offset;
+		}
+
+		return length;
+	}
+
+	// TODO verify reverse
+	// TODO add efficient algo
+	static trail(start: SectionPosition, end: SectionPosition) {
+		let head = start;
+
+		const sections = [];
+		const increment = 1;
+
+		while (head.section != end.section) {
+			head = head.advance(increment);
+
+			if (head.section != start.section && head.section != end.section && !sections.includes(head.section)) {
+				sections.push(head.section);
+			}
+		}
+
+		return new Span(start, sections, end);
+	}
+}

package/source/throttle.ts

@@ -0,0 +1,10 @@
+import { Device } from "./device/index";
+import { District } from "./district";
+import { Layout } from "./layout";
+
+export class Throttle {
+	constructor(
+		public device: Device,
+		public scope: District | Layout
+	) { }
+}

package/source/track.ts

@@ -1,4 +1,4 @@
-import { Positioner } from "./positioner";
+import { Positioner } from "./positioner/index";
 import { Section } from "./section";
 import { SectionPosition } from "./position";
 
@@ -19,12 +19,8 @@ export class Track {
 			if (track == this) {
 				return new SectionPosition(this.section, offset, false);
 			}
-			
+
 			offset += track.length;
 		}
 	}
-	
-	dump() {
-		console.log(this.length);
-	}
-}
+}

package/tsconfig.json

@@ -1,12 +1,11 @@
 {
 	"compilerOptions": {
-		"outDir": ".built",
-		"module": "esnext",
-		"moduleResolution": "node",
 		"target": "esnext",
-		"declaration": true
-	},
-	"include": [
-		"source"
-	]
+		"module": "esnext",
+		"outDir": ".built",
+		"declaration": true,
+		"lib": [
+			"esnext"
+		]
+	}
 }

package/source/index.ts

@@ -1,20 +0,0 @@
-export * from './district';
-export * from './layout';
-export * from './position';
-export * from './route';
-export * from './router';
-export * from './section';
-export * from './tile';
-export * from './track';
-
-export * from './power-district/index';
-export * from './power-district/activator';
-export * from './power-district/monitor';
-export * from './power-district/reverser';
-
-export * from './positioner/index';
-export * from './positioner/point';
-export * from './positioner/responder-type';
-
-export * from './device/index';
-export * from './device/channel';