@packtrack/layout 1.0.1 → 1.0.4

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

@@ -0,0 +1,8 @@
+import { Device } from "./device";
+export declare class Channel {
+    device: Device;
+    name: string;
+    constructor(device: Device, name: string);
+    dump(): void;
+    publish(data: any): void;
+}

package/.built/device/channel.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+class Channel {
+    device;
+    name;
+    constructor(device, name) {
+        this.device = device;
+        this.name = name;
+    }
+    dump() {
+        console.log(`Channel '${this.name}' on ${this.device.identifier}`);
+    }
+    publish(data) { }
+}
+exports.Channel = Channel;

package/.built/device/device.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/device.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+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();
+    }
+}
+exports.Device = Device;

package/.built/positioner/index.d.ts

@@ -0,0 +1,2 @@
+export declare class Positioner {
+}

package/.built/positioner/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Positioner = void 0;
+class Positioner {
+}
+exports.Positioner = Positioner;

package/.built/positioner/point.d.ts

@@ -0,0 +1,13 @@
+import { Positioner } from ".";
+import { Channel } from "../source/device/channel";
+import { Track } from "../source/track";
+import { ResponderType } from "./responder-type";
+export declare class PointPositioner extends Positioner {
+    track: Track;
+    offset: number;
+    channel: Channel;
+    responder: ResponderType;
+    constructor(track: Track, offset: number, channel: Channel, responder: ResponderType);
+    get position(): any;
+    dump(): void;
+}

package/.built/positioner/point.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointPositioner = void 0;
+const _1 = require(".");
+class PointPositioner extends _1.Positioner {
+    track;
+    offset;
+    channel;
+    responder;
+    constructor(track, offset, channel, responder) {
+        super();
+        this.track = track;
+        this.offset = offset;
+        this.channel = channel;
+        this.responder = responder;
+    }
+    get position() {
+        return this.track.head.advance(this.offset);
+    }
+    dump() {
+        console.group('Point positioner');
+        console.log('offset:', this.offset);
+        this.channel.dump();
+        console.groupEnd();
+    }
+}
+exports.PointPositioner = PointPositioner;

package/.built/positioner/responder-type.d.ts

@@ -0,0 +1,5 @@
+export declare class ResponderType {
+    name: string;
+    constructor(name: string);
+    dump(): void;
+}

package/.built/positioner/responder-type.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponderType = void 0;
+class ResponderType {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    dump() {
+        console.log(`Responder Type '${this.name}'`);
+    }
+}
+exports.ResponderType = ResponderType;

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

@@ -0,0 +1,8 @@
+import { Device } from "./device";
+export declare class Channel {
+    device: Device;
+    name: string;
+    constructor(device: Device, name: string);
+    dump(): void;
+    publish(data: any): void;
+}

package/.built/source/device/channel.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Channel = void 0;
+class Channel {
+    device;
+    name;
+    constructor(device, name) {
+        this.device = device;
+        this.name = name;
+    }
+    dump() {
+        console.log(`Channel '${this.name}' on ${this.device.identifier}`);
+    }
+    publish(data) { }
+}
+exports.Channel = Channel;

package/.built/source/device/device.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/source/device/device.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+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();
+    }
+}
+exports.Device = Device;

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

@@ -0,0 +1,20 @@
+import { Layout } from "./layout";
+import { PowerDistrict } from "./power-district";
+import { Router } from "./router";
+import { Section } from "./section";
+export declare class District {
+    name: string;
+    parent: District | Layout;
+    children: District[];
+    powerDistricts: PowerDistrict[];
+    sections: Section[];
+    routers: Router[];
+    constructor(name: string, parent: District | Layout);
+    get domainName(): string;
+    dump(): void;
+    toDotReference(): any;
+    toDotDefinition(): any;
+    toDotConnection(): any;
+    toSVG(): any;
+    findSVGPositions(): any;
+}

package/.built/source/district.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.District = void 0;
+const layout_1 = require("./layout");
+class District {
+    name;
+    parent;
+    children = [];
+    powerDistricts = [];
+    sections = [];
+    routers = [];
+    constructor(name, parent) {
+        this.name = name;
+        this.parent = parent;
+    }
+    get domainName() {
+        if (this.parent instanceof layout_1.Layout) {
+            return `${this.name}.${this.parent.name}`;
+        }
+        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('')}
+		`;
+    }
+    toSVG() {
+        return `
+			<g id=${JSON.stringify(this.domainName)}>
+				${this.sections.map(section => section.toSVG()).join('')}
+
+				${this.children.map(child => child.toSVG()).join('')}
+			</g>
+		`;
+    }
+    findSVGPositions() {
+        return [
+            ...this.sections.map(section => section.findSVGPositions()),
+            ...this.children.map(child => child.findSVGPositions())
+        ];
+    }
+}
+exports.District = District;

package/.built/source/layout.d.ts

@@ -0,0 +1,29 @@
+import { District } from "./district";
+import { PowerDistrict } from "./power-district";
+import { Router } from "./router";
+import { Section } from "./section";
+import { Device } from "./device/device";
+import { ResponderType } from "../positioner/responder-type";
+import { Channel } from "./device/channel";
+export declare class Layout {
+    name: string;
+    districts: District[];
+    devices: Device[];
+    responderType: ResponderType[];
+    get allDistricts(): District[];
+    static from(document: any): Layout;
+    loadDistrict(source: any, parent: District | Layout): District;
+    linkDistrict(source: any, district: District): void;
+    loadSection(source: any, district: District): void;
+    findDevice(identifier: string): Device;
+    findChannel(device: Device, name: string): Channel;
+    findResponderType(name: string): ResponderType;
+    linkSection(source: any, section: Section): void;
+    findSection(path: string, base: District, source?: District): any;
+    loadRouter(source: any, district: District): Router;
+    linkRouter(source: any, router: Router): void;
+    loadPowerDistrict(source: any, district: District): PowerDistrict;
+    toDot(): string;
+    toSVG(inject?: string): string;
+    dump(): void;
+}

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;