@packtrack/layout 1.1.0 → 1.2.0

package/.built/district.d.ts

@@ -1,4 +1,5 @@
 import { Layout } from "./layout";
+import { Monitor } from "./monitor";
 import { PowerDistrict } from "./power-district";
 import { Router } from "./router";
 import { Section } from "./section";
@@ -9,6 +10,7 @@ export declare class District {
     powerDistricts: PowerDistrict[];
     sections: Section[];
     routers: Router[];
+    monitors: Monitor[];
     constructor(name: string, parent: District | Layout);
     get domainName(): string;
     dump(): void;

package/.built/district.js

@@ -6,6 +6,7 @@ export class District {
     powerDistricts = [];
     sections = [];
     routers = [];
+    monitors = [];
     constructor(name, parent) {
         this.name = name;
         this.parent = parent;
@@ -48,10 +49,10 @@ export class District {
         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('')}
 			}
 		`;
@@ -60,7 +61,7 @@ export class District {
         return `
 			${this.sections.map(section => section.toDotConnection()).join('')}
 			${this.routers.map(router => router.toDotConnection()).join('')}
-				
+
 			${this.children.map(child => child.toDotConnection()).join('')}
 		`;
     }

package/.built/index.d.ts

@@ -4,8 +4,11 @@ export * from './position';
 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';

package/.built/index.js

@@ -4,8 +4,11 @@ export * from './position';
 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';

package/.built/layout.d.ts

@@ -5,13 +5,19 @@ import { Section } from "./section";
 import { Device } from "./device/index";
 import { ResponderType } from "./positioner/responder-type";
 import { Channel } from "./device/channel";
+import { Monitor } from "./monitor";
+import { Throttle } from "./throttle";
 export declare class Layout {
     name: string;
     districts: District[];
     devices: Device[];
     responderType: ResponderType[];
+    monitors: Monitor[];
+    throttles: Throttle[];
     get allDistricts(): District[];
     static from(document: any): Layout;
+    loadMonitor(source: any, parent: District | Layout): Monitor;
+    loadThrottle(source: any, parent: District | Layout): Throttle;
     loadDistrict(source: any, parent: District | Layout): District;
     linkDistrict(source: any, district: District): void;
     loadSection(source: any, district: District): void;

package/.built/layout.js

@@ -12,11 +12,15 @@ 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;
     districts = [];
     devices = [];
     responderType = [];
+    monitors = [];
+    throttles = [];
     get allDistricts() {
         const districts = [];
         function walkDistrict(district) {
@@ -36,28 +40,42 @@ 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));
                 }
-                district = district.nextSibling;
+                if (child.tagName == 'monitor') {
+                    layout.monitors.push(layout.loadMonitor(child, layout));
+                }
+                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) {
+        const montior = new Monitor(this.findDevice(source.getAttribute('device')), parent);
+        return montior;
+    }
+    loadThrottle(source, parent) {
+        const throttle = new Throttle(this.findDevice(source.getAttribute('device')), parent);
+        return throttle;
+    }
     loadDistrict(source, parent) {
         const district = new District(source.getAttribute('name'), parent);
         let child = source.firstChild;
@@ -80,6 +98,9 @@ export class Layout {
             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;
@@ -220,6 +241,7 @@ export class Layout {
     }
     linkRouter(source, router) {
         let child = source.firstChild;
+        let active;
         while (child) {
             if (child.tagName == 'route') {
                 const route = new Route(child.getAttribute('name'), router);
@@ -227,10 +249,17 @@ export class Layout {
                 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) {
         const powerDistrict = new PowerDistrict(source.getAttribute('name'), district);

package/.built/monitor.d.ts

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

package/.built/monitor.js

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

package/.built/position.d.ts

@@ -5,6 +5,8 @@ export declare class SectionPosition {
     reversed: boolean;
     constructor(section: Section, offset: number, reversed: boolean);
     get absolutePosition(): number;
-    advance(distance: number): any;
+    advance(distance: number): SectionPosition;
+    private invert;
     toString(): string;
+    toPackTrackValue(): string;
 }

package/.built/position.js

@@ -6,14 +6,23 @@ export class SectionPosition {
         this.section = section;
         this.offset = offset;
         this.reversed = reversed;
+        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) {
+        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) {
@@ -23,7 +32,14 @@ export class SectionPosition {
         }
         return new SectionPosition(this.section, this.offset + distance, this.reversed);
     }
+    // reverse direction
+    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/.built/positioner/point.d.ts

@@ -8,6 +8,6 @@ export declare class PointPositioner extends Positioner {
     channel: Channel;
     responder: ResponderType;
     constructor(track: Track, offset: number, channel: Channel, responder: ResponderType);
-    get position(): any;
+    get position(): import("..").SectionPosition;
     dump(): void;
 }

package/.built/span.d.ts

@@ -0,0 +1,12 @@
+import { SectionPosition } from "./position";
+import { Section } from "./section";
+export declare class Span {
+    head: SectionPosition;
+    inside: Section[];
+    tail: SectionPosition;
+    constructor(head: SectionPosition, inside: Section[], tail: SectionPosition);
+    contains(position: SectionPosition): boolean;
+    overlap(peer: Span): boolean;
+    get length(): number;
+    static trail(start: SectionPosition, end: SectionPosition): Span;
+}

package/.built/span.js

@@ -0,0 +1,77 @@
+export class Span {
+    head;
+    inside;
+    tail;
+    constructor(head, inside, tail) {
+        this.head = head;
+        this.inside = inside;
+        this.tail = tail;
+    }
+    // TODO verify reverse
+    contains(position) {
+        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) {
+        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, end) {
+        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/.built/throttle.d.ts

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

package/.built/throttle.js

@@ -0,0 +1,15 @@
+import { Layout } from "./layout";
+export class Throttle {
+    device;
+    scope;
+    constructor(device, scope) {
+        this.device = device;
+        this.scope = scope;
+    }
+    dump() {
+        console.group('Throttle');
+        console.log('scope:', this.scope instanceof Layout ? '*' : this.scope.domainName);
+        this.device.dump();
+        console.groupEnd();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@packtrack/layout",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"main": ".built/index.js",
 	"typings": ".built/index.d.ts",
 	"sideEffects": false,

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

@@ -4,8 +4,11 @@ export * from './position';
 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';

package/source/layout.ts

@@ -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));
+				}
+
+				if (child.tagName == 'monitor') {
+					layout.monitors.push(layout.loadMonitor(child, layout));
+				}
 
-			while (district) {
-				if (district.tagName == 'district') {
-					layout.districts.push(layout.loadDistrict(district, 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);
 
@@ -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) {

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/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,19 @@
+import { Device } from "./device";
+import { District } from "./district";
+import { Layout } from "./layout";
+
+export class Throttle {
+	constructor(
+		public device: Device,
+		public scope: District | Layout
+	) { }
+
+	dump() {
+		console.group('Throttle');
+		console.log('scope:', this.scope instanceof Layout ? '*' : this.scope.domainName);
+
+		this.device.dump();
+
+		console.groupEnd();
+	}
+}