@packtrack/layout 1.0.10 → 1.0.11

package/.built/source/layout.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layout = void 0;
+const district_1 = require("./district");
+const power_district_1 = require("./power-district");
+const route_1 = require("./route");
+const router_1 = require("./router");
+const section_1 = require("./section");
+const tile_1 = require("./tile");
+const track_1 = require("./track");
+const point_1 = require("../positioner/point");
+const device_1 = require("./device/device");
+const responder_type_1 = require("../positioner/responder-type");
+const channel_1 = require("./device/channel");
+class Layout {
+    name;
+    districts = [];
+    devices = [];
+    responderType = [];
+    get allDistricts() {
+        const districts = [];
+        function walkDistrict(district) {
+            districts.push(district);
+            for (let child of district.children) {
+                walkDistrict(child);
+            }
+        }
+        for (let district of this.districts) {
+            walkDistrict(district);
+        }
+        return districts;
+    }
+    static from(document) {
+        const layout = new Layout();
+        const railway = document.firstChild;
+        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));
+                }
+                district = district.nextSibling;
+            }
+            district = railway.firstChild;
+            let index = 0;
+            while (district) {
+                if (district.tagName == 'district') {
+                    layout.linkDistrict(district, layout.districts[index]);
+                    index++;
+                }
+                district = district.nextSibling;
+            }
+        }
+        else {
+            throw new Error(`unsupported railway definition file version '${version}'`);
+        }
+        return layout;
+    }
+    loadDistrict(source, parent) {
+        const district = new district_1.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));
+            }
+            child = child.nextSibling;
+        }
+        return district;
+    }
+    linkDistrict(source, 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) {
+        const section = new section_1.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_1.Track(section, +trackNode.getAttribute('length'), trackNode.getAttribute('path'));
+                        section.tracks.push(track);
+                        let trackChild = trackNode.firstChild;
+                        while (trackChild) {
+                            if (trackChild.tagName == 'positioners') {
+                                let positioner = trackChild.firstChild;
+                                while (positioner) {
+                                    if (positioner.tagName == 'point') {
+                                        const device = this.findDevice(positioner.getAttribute('device'));
+                                        const channel = this.findChannel(device, positioner.getAttribute('channel'));
+                                        const responderType = this.findResponderType(positioner.getAttribute('responder'));
+                                        track.positioners.push(new point_1.PointPositioner(track, +positioner.getAttribute('offset'), channel, responderType));
+                                    }
+                                    positioner = positioner.nextSibling;
+                                }
+                            }
+                            trackChild = trackChild.nextSibling;
+                        }
+                    }
+                    trackNode = trackNode.nextSibling;
+                }
+            }
+            if (child.tagName == 'tile') {
+                const pattern = child.getAttribute('pattern');
+                if (!(pattern in tile_1.TilePattern.patterns)) {
+                    throw new Error(`Unknown tile pattern '${pattern}' in tile ${section.tiles.length + 1} in ${section.domainName}`);
+                }
+                section.tiles.push(new tile_1.Tile(section, +child.getAttribute('x'), +child.getAttribute('y'), tile_1.TilePattern.patterns[pattern]));
+            }
+            child = child.nextSibling;
+        }
+    }
+    findDevice(identifier) {
+        let device = this.devices.find(device => device.identifier == identifier);
+        if (device) {
+            return device;
+        }
+        device = new device_1.Device(identifier);
+        this.devices.push(device);
+        return device;
+    }
+    findChannel(device, name) {
+        let channel = device.channels.find(channel => channel.name == name);
+        if (channel) {
+            return channel;
+        }
+        channel = new channel_1.Channel(device, name);
+        device.channels.push(channel);
+        return channel;
+    }
+    findResponderType(name) {
+        let type = this.responderType.find(type => type.name == name);
+        if (type) {
+            return type;
+        }
+        type = new responder_type_1.ResponderType(name);
+        this.responderType.push(type);
+        return type;
+    }
+    linkSection(source, 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, base, 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 = 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_1.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) {
+        const router = new router_1.Router(source.getAttribute('name'), district);
+        return router;
+    }
+    linkRouter(source, router) {
+        let child = source.firstChild;
+        while (child) {
+            if (child.tagName == 'route') {
+                const route = new route_1.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;
+                router.routes.push(route);
+            }
+            child = child.nextSibling;
+        }
+    }
+    loadPowerDistrict(source, district) {
+        const powerDistrict = new power_district_1.PowerDistrict(source.getAttribute('name'), district);
+        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();
+    }
+}
+exports.Layout = Layout;

package/.built/source/position.d.ts

@@ -0,0 +1,10 @@
+import { Section } from './section.js';
+export declare class SectionPosition {
+    section: Section;
+    offset: number;
+    reversed: boolean;
+    constructor(section: Section, offset: number, reversed: boolean);
+    get absolutePosition(): number;
+    advance(distance: number): any;
+    toString(): string;
+}

package/.built/source/position.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SectionPosition = void 0;
+class SectionPosition {
+    section;
+    offset;
+    reversed;
+    constructor(section, offset, reversed) {
+        this.section = section;
+        this.offset = offset;
+        this.reversed = reversed;
+    }
+    get absolutePosition() {
+        if (this.reversed) {
+            return this.section.length - this.offset;
+        }
+        return this.offset;
+    }
+    advance(distance) {
+        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'}`;
+    }
+}
+exports.SectionPosition = SectionPosition;

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

@@ -0,0 +1,8 @@
+import { District } from "./district";
+export declare class PowerDistrict {
+    name: string;
+    district: District;
+    constructor(name: string, district: District);
+    get domainName(): string;
+    dump(): void;
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerDistrict = void 0;
+class PowerDistrict {
+    name;
+    district;
+    constructor(name, district) {
+        this.name = name;
+        this.district = district;
+    }
+    get domainName() {
+        return `${this.name}.${this.district.domainName}`;
+    }
+    dump() {
+        console.log(this.name);
+    }
+}
+exports.PowerDistrict = PowerDistrict;

package/.built/source/route.d.ts

@@ -0,0 +1,10 @@
+import { Router } from "./router";
+import { Section } from "./section";
+export declare class Route {
+    name: string;
+    router: Router;
+    in: Section;
+    out: Section;
+    constructor(name: string, router: Router);
+    dump(): void;
+}

package/.built/source/route.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = void 0;
+class Route {
+    name;
+    router;
+    in;
+    out;
+    constructor(name, router) {
+        this.name = name;
+        this.router = router;
+    }
+    dump() {
+        console.log(`Route ${this.name}: ${this.in.domainName} → ${this.out.domainName}`);
+    }
+}
+exports.Route = Route;

package/.built/source/router.d.ts

@@ -0,0 +1,14 @@
+import { District } from "./district";
+import { Route } from "./route";
+export declare class Router {
+    name: string;
+    district: District;
+    activeRoute?: Route;
+    routes: Route[];
+    constructor(name: string, district: District);
+    get domainName(): string;
+    dump(): void;
+    toDotReference(): string;
+    toDotDefinition(): string;
+    toDotConnection(): string;
+}

package/.built/source/router.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+class Router {
+    name;
+    district;
+    activeRoute;
+    routes = [];
+    constructor(name, district) {
+        this.name = name;
+        this.district = district;
+    }
+    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('')}
+		`;
+    }
+}
+exports.Router = Router;

package/.built/source/section.d.ts

@@ -0,0 +1,40 @@
+import { District } from "./district";
+import { SectionPosition } from "./position";
+import { PowerDistrict } from "./power-district";
+import { Router } from "./router";
+import { Tile } from "./tile";
+import { Track } from "./track";
+export declare class Section {
+    name: string;
+    district: District;
+    powerDistrict: PowerDistrict;
+    tracks: Track[];
+    tiles: Tile[];
+    in?: Router | Section;
+    out?: Router | Section;
+    constructor(name: string, district: District);
+    get domainName(): string;
+    next(reverse: boolean): Section;
+    getTilesInRange(startPosition: SectionPosition, endPosition: SectionPosition): {
+        offset: {
+            start: number;
+            end: number;
+        };
+        tiles: Tile[];
+    };
+    dump(): void;
+    get length(): number;
+    get tileLength(): number;
+    trail(offset: number, reversed: boolean, length: number): {
+        sections: Section[];
+        tip: SectionPosition;
+    };
+    toDotReference(): string;
+    toDotDefinition(): string;
+    toDotConnection(): string;
+    toSVG(): string;
+    findSVGPositions(): {
+        x: number;
+        y: number;
+    }[];
+}