@packtrack/layout 1.0.13 → 1.2.0

package/source/district.ts

@@ -1,15 +1,18 @@
 import { Layout } from "./layout";
+import { Monitor } from "./monitor";
 import { PowerDistrict } from "./power-district";
 import { Router } from "./router";
 import { Section } from "./section";
 
 export class District {
 	children: District[] = [];
-	
+
 	powerDistricts: PowerDistrict[] = [];
 	sections: Section[] = [];
 	routers: Router[] = [];
-	
+
+	monitors: Monitor[] = [];
+
 	constructor(
 		public name: string,
 		public parent: District | Layout
@@ -22,65 +25,65 @@ export class District {
 
 		return `${this.name}.${this.parent.domainName}`;
 	}
-	
+
 	dump() {
 		console.group(`District ${this.domainName}`);
-		
+
 		if (this.powerDistricts.length) {
 			console.group('power districts');
-			
+
 			for (let district of this.powerDistricts) {
 				district.dump();
 			}
 
 			console.groupEnd();
 		}
-		
+
 		if (this.sections.length) {
 			console.group('sections');
-			
+
 			for (let section of this.sections) {
 				section.dump();
 			}
 
 			console.groupEnd();
 		}
-		
+
 		if (this.children.length) {
 			console.group('children');
-			
+
 			for (let district of this.children) {
 				district.dump();
 			}
 
 			console.groupEnd();
 		}
-		
+
 		console.groupEnd();
 	}
-	
+
 	toDotReference() {
 		return `cluster_${this.name.replace(/-/g, '_')}${this.parent instanceof District ? this.parent.toDotReference() : ''}`;
 	}
-	
+
 	toDotDefinition() {
 		return `
 			subgraph ${this.toDotReference()} {
 				label = ${JSON.stringify(this.name)}
-				
+
 				${this.sections.map(section => section.toDotDefinition()).join('')}
 				${this.routers.map(router => router.toDotDefinition()).join('')}
-				
+
 				${this.children.map(child => child.toDotDefinition()).join('')}
 			}
 		`;
 	}
-	
+
 	toDotConnection() {
 		return `
 			${this.sections.map(section => section.toDotConnection()).join('')}
 			${this.routers.map(router => router.toDotConnection()).join('')}
-				
+
 			${this.children.map(child => child.toDotConnection()).join('')}
 		`;
 	}
@@ -97,8 +100,8 @@ export class District {
 
 	findSVGPositions() {
 		return [
-			...this.sections.map(section => section.findSVGPositions()), 
+			...this.sections.map(section => section.findSVGPositions()),
 			...this.children.map(child => child.findSVGPositions())
 		];
 	}
-}
+}

package/source/index.ts

@@ -1,16 +1,23 @@
 export * from './district';
 export * from './layout';
 export * from './position';
-export * from './power-district';
 export * from './route';
 export * from './router';
 export * from './section';
+export * from './span';
 export * from './tile';
 export * from './track';
+export * from './monitor';
+export * from './throttle';
+
+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/device';
+export * from './device/index';
 export * from './device/channel';

package/source/layout.ts

@@ -5,19 +5,27 @@ import { Router } from "./router";
 import { Section } from "./section";
 import { TilePattern, Tile } from "./tile";
 import { Track } from "./track";
-import { Device } from "./device/device";
+import { Device } from "./device/index";
 import { ResponderType } from "./positioner/responder-type";
 import { Channel } from "./device/channel";
 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;
-	
+
 	districts: District[] = [];
-	
+
 	devices: Device[] = [];
 	responderType: ResponderType[] = [];
 
+	monitors: Monitor[] = [];
+	throttles: Throttle[] = [];
+
 	get allDistricts() {
 		const districts: District[] = [];
 
@@ -43,120 +51,144 @@ export class Layout {
 		layout.name = railway.getAttribute('name');
 
 		const version = railway.getAttribute('version');
-		
+
 		if (version == '1') {
-			let district = railway.firstChild;
-			
-			while (district) {
-				if (district.tagName == 'district') {
-					layout.districts.push(layout.loadDistrict(district, layout));
+			let child = railway.firstChild;
+
+			while (child) {
+				if (child.tagName == 'district') {
+					layout.districts.push(layout.loadDistrict(child, layout));
+				}
+
+				if (child.tagName == 'monitor') {
+					layout.monitors.push(layout.loadMonitor(child, layout));
+				}
+
+				if (child.tagName == 'throttle') {
+					layout.throttles.push(layout.loadThrottle(child, layout));
 				}
-				
-				district = district.nextSibling;
+
+				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);
-		
+
 		let child = source.firstChild;
-		
+
 		while (child) {
 			if (child.tagName == 'power-districts') {
 				let powerDistrict = child.firstChild;
-				
+
 				while (powerDistrict) {
 					if (powerDistrict.tagName == 'power-district') {
 						district.powerDistricts.push(this.loadPowerDistrict(powerDistrict, district));
 					}
-					
+
 					powerDistrict = powerDistrict.nextSibling;
 				}
 			}
-			
+
 			if (child.tagName == 'section') {
 				this.loadSection(child, district);
 			}
-			
+
 			if (child.tagName == 'router') {
 				district.routers.push(this.loadRouter(child, district));
 			}
-			
+
 			if (child.tagName == 'district') {
 				district.children.push(this.loadDistrict(child, district));
 			}
-			
+
+			if (child.tagName == 'monitor') {
+				district.monitors.push(this.loadMonitor(child, district));
+			}
+
 			child = child.nextSibling;
 		}
-		
+
 		return district;
 	}
-	
+
 	linkDistrict(source, district: District) {
 		let child = source.firstChild;
-		
+
 		let sectionIndex = 0;
 		let childIndex = 0;
-		
+
 		while (child) {
 			if (child.tagName == 'section') {
 				this.linkSection(child, district.sections[sectionIndex]);
-				
+
 				sectionIndex++;
 			}
-			
+
 			if (child.tagName == 'router') {
 				this.linkRouter(child, district.routers.find(router => router.name == child.getAttribute('name'))!);
 			}
-			
+
 			if (child.tagName == 'district') {
 				this.linkDistrict(child, district.children[childIndex]);
-				
+
 				childIndex++;
 			}
-			
+
 			child = child.nextSibling;
 		}
 	}
-	
+
 	loadSection(source, district: District) {
 		const section = new Section(source.getAttribute('name'), district);
 		district.sections.push(section);
-		
+
 		let child = source.firstChild;
-		
+
 		while (child) {
 			if (child.tagName == 'tracks') {
 				let trackNode = child.firstChild;
-				
+
 				while (trackNode) {
 					if (trackNode.tagName == 'track') {
 						const track = new Track(
-							section, 
-							+trackNode.getAttribute('length'), 
+							section,
+							+trackNode.getAttribute('length'),
 							trackNode.getAttribute('path')
 						);
 
 						section.tracks.push(track);
-						
+
 						let trackChild = trackNode.firstChild;
 
 						while (trackChild) {
@@ -170,7 +202,7 @@ export class Layout {
 										const responderType = this.findResponderType(positioner.getAttribute('responder'));
 
 										track.positioners.push(new PointPositioner(
-											track, 
+											track,
 											+positioner.getAttribute('offset'),
 											channel,
 											responderType
@@ -184,7 +216,7 @@ export class Layout {
 							trackChild = trackChild.nextSibling;
 						}
 					}
-					
+
 					trackNode = trackNode.nextSibling;
 				}
 			}
@@ -198,7 +230,7 @@ export class Layout {
 
 				section.tiles.push(new Tile(section, +child.getAttribute('x'), +child.getAttribute('y'), TilePattern.patterns[pattern]))
 			}
-			
+
 			child = child.nextSibling;
 		}
 	}
@@ -241,111 +273,145 @@ export class Layout {
 
 		return type;
 	}
-	
+
 	linkSection(source, section: Section) {
 		let child = source.firstChild;
-		
+
 		while (child) {
 			if (child.tagName == 'out') {
 				const out = this.findSection(child.getAttribute('section'), section.district);
-				
+
 				section.out = out;
 				out.in = section;
 			}
-			
+
 			child = child.nextSibling;
 		}
 	}
-	
+
 	findSection(path: string, base: District, source = base) {
 		const parts = path.split('.');
-		
+
 		if (parts.length == 0) {
 			throw `section '${path}' not found from '${source.name}': invalid name`;
 		}
-		
+
 		if (parts.length == 1) {
 			const localSection = base.sections.find(section => section.name == parts[0]);
-			
+
 			if (!localSection) {
 				throw new Error(`Section '${path}' not found from '${source.name}': section does not exist in '${base.name}'`);
 			}
-			
+
 			return localSection;
 		}
-		
+
 		const sectionName = parts.pop()!;
-		
+
 		let pool: District | Layout = base;
-		
+
 		for (let index = 0; index < parts.length; index++) {
 			if (pool instanceof Layout || !pool.parent) {
 				throw new Error(`Section '${path}' could not be found from '${source.name}': district '${pool.name}' does not have a parent`);
 			}
-			
+
 			pool = pool.parent!;
 		}
-		
+
 		for (let part of parts) {
 			const child = (pool instanceof District ? pool.children : pool.districts).find(child => child.name == part);
-			
+
 			if (!child) {
 				throw new Error(`Section '${path}' could not be found from '${source.name}': district '${pool.name}' does not have a child named '${part}'`);
 			}
-			
+
 			pool = child;
 		}
 
 		if (pool instanceof Layout) {
 			throw new Error(`Section '${path}' could not be found from '${source.name}': a layout cannot directly include a section`);
 		}
-		
+
 		return this.findSection(sectionName, pool, source);
 	}
-	
+
 	loadRouter(source, district: District) {
 		const router = new Router(source.getAttribute('name'), district);
-		
+
 		return router;
 	}
-	
+
 	linkRouter(source, router: Router) {
 		let child = source.firstChild;
-		
+		let active: Route;
+
 		while (child) {
 			if (child.tagName == 'route') {
 				const route = new Route(child.getAttribute('name'), router);
-				
+
 				route.in = this.findSection(child.getAttribute('in'), router.district);
 				route.in.out = router;
-				
+
 				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) {
 		const powerDistrict = new PowerDistrict(source.getAttribute('name'), district);
-		
+
+		let actor = source.firstChild;
+
+		while (actor) {
+			if (actor.tagName == 'activator' || actor.tagName == 'reverser' || actor.tagName == 'monitor') {
+				const device = this.findDevice(actor.getAttribute('device'));
+				const channel = this.findChannel(device, actor.getAttribute('channel'));
+
+				if (actor.tagName == 'activator') {
+					powerDistrict.activator = new PowerDistrictActivator(device, channel);
+				}
+
+				if (actor.tagName == 'reverser') {
+					powerDistrict.reverser = new PowerDistrictReverser(device, channel);
+				}
+
+				if (actor.tagName == 'monitor') {
+					powerDistrict.monitor = new PowerDistrictMonitor(device, channel);
+				}
+			}
+
+			actor = actor.nextSibling;
+		}
+
 		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}}`;
 	}
 
@@ -366,11 +432,11 @@ export class Layout {
 
 			</style>
 		`;
-		
+
 		for (let district of this.districts) {
 			svg += district.toSVG();
 		}
-			
+
 		return `${svg}${inject}</svg>`;
 	}
 
@@ -396,4 +462,4 @@ export class Layout {
 
 		console.groupEnd();
 	}
-}
+}

package/source/monitor.ts

@@ -0,0 +1,19 @@
+import { Device } from "./device";
+import { District } from "./district";
+import { Layout } from "./layout";
+
+export class Monitor {
+	constructor(
+		public device: Device,
+		public scope: District | Layout
+	) { }
+
+	dump() {
+		console.group('Monitor');
+		console.log('scope:', this.scope instanceof Layout ? '*' : this.scope.domainName);
+
+		this.device.dump();
+
+		console.groupEnd();
+	}
+}

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/power-district/activator.ts

@@ -0,0 +1,9 @@
+import { Channel } from "../device/channel";
+import { Device } from "../device/index";
+
+export class PowerDistrictActivator {
+	constructor(
+		public device: Device,
+		public channel: Channel
+	) {}
+}