@packtrack/layout 1.0.13 → 1.2.0

package/.built/device/channel.d.ts

@@ -1,4 +1,4 @@
-import { Device } from "./device";
+import { Device } from "./index";
 export declare class Channel {
     device: Device;
     name: string;

package/.built/device/index.d.ts

@@ -0,0 +1,11 @@
+import { Channel } from "./channel";
+export declare class Device {
+    identifier: string;
+    channels: Channel[];
+    lastDiscovery: {
+        date: Date;
+        address: string;
+    };
+    constructor(identifier: string);
+    dump(): void;
+}

package/.built/device/index.js

@@ -0,0 +1,20 @@
+export class Device {
+    identifier;
+    channels = [];
+    lastDiscovery;
+    constructor(identifier) {
+        this.identifier = identifier;
+    }
+    dump() {
+        console.group(`Device ${this.identifier}`);
+        if (this.lastDiscovery) {
+            console.log(`last discovery: ${this.lastDiscovery.date.toISOString()} ${this.lastDiscovery.address}`);
+        }
+        console.group('channels');
+        for (let channel of this.channels) {
+            channel.dump();
+        }
+        console.groupEnd();
+        console.groupEnd();
+    }
+}

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

@@ -1,14 +1,20 @@
 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/.built/index.js

@@ -1,14 +1,20 @@
 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/.built/layout.d.ts

@@ -2,16 +2,22 @@ import { District } from "./district";
 import { PowerDistrict } from "./power-district";
 import { Router } from "./router";
 import { Section } from "./section";
-import { Device } from "./device/device";
+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

@@ -5,15 +5,22 @@ 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;
     districts = [];
     devices = [];
     responderType = [];
+    monitors = [];
+    throttles = [];
     get allDistricts() {
         const districts = [];
         function walkDistrict(district) {
@@ -33,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;
@@ -77,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;
@@ -217,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);
@@ -224,13 +249,37 @@ 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);
+        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() {

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

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

package/.built/power-district/activator.js

@@ -0,0 +1,8 @@
+export class PowerDistrictActivator {
+    device;
+    channel;
+    constructor(device, channel) {
+        this.device = device;
+        this.channel = channel;
+    }
+}

package/.built/power-district/index.d.ts

@@ -0,0 +1,14 @@
+import { PowerDistrictActivator } from "./activator";
+import { District } from "../district";
+import { PowerDistrictMonitor } from "./monitor";
+import { PowerDistrictReverser } from "./reverser";
+export declare class PowerDistrict {
+    name: string;
+    district: District;
+    activator?: PowerDistrictActivator;
+    reverser?: PowerDistrictReverser;
+    monitor?: PowerDistrictMonitor;
+    constructor(name: string, district: District);
+    get domainName(): string;
+    dump(): void;
+}

package/.built/power-district/index.js

@@ -0,0 +1,17 @@
+export class PowerDistrict {
+    name;
+    district;
+    activator;
+    reverser;
+    monitor;
+    constructor(name, district) {
+        this.name = name;
+        this.district = district;
+    }
+    get domainName() {
+        return `${this.name}.${this.district.domainName}`;
+    }
+    dump() {
+        console.log(this.name);
+    }
+}

package/.built/power-district/monitor.d.ts

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

package/.built/power-district/monitor.js

@@ -0,0 +1,8 @@
+export class PowerDistrictMonitor {
+    device;
+    channel;
+    constructor(device, channel) {
+        this.device = device;
+        this.channel = channel;
+    }
+}

package/.built/power-district/reverser.d.ts

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

package/.built/power-district/reverser.js

@@ -0,0 +1,8 @@
+export class PowerDistrictReverser {
+    device;
+    channel;
+    constructor(device, channel) {
+        this.device = device;
+        this.channel = channel;
+    }
+}

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.0.13",
+	"version": "1.2.0",
 	"main": ".built/index.js",
 	"typings": ".built/index.d.ts",
 	"sideEffects": false,

package/source/device/channel.ts

@@ -1,4 +1,4 @@
-import { Device } from "./device";
+import { Device } from "./index";
 
 export class Channel {
 	constructor(
@@ -11,4 +11,4 @@ export class Channel {
 	}
 
 	publish(data: any) {}
-}
+}