@packtrack/layout 1.0.4 → 1.0.5

package/.built/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/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/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/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 device_1 = require("./device/device");
+const responder_type_1 = require("./positioner/responder-type");
+const channel_1 = require("./device/channel");
+const point_1 = require("./positioner/point");
+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/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/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/positioner/point.d.ts

@@ -1,6 +1,6 @@
 import { Positioner } from ".";
-import { Channel } from "../source/device/channel";
-import { Track } from "../source/track";
+import { Channel } from "../device/channel";
+import { Track } from "../track";
 import { ResponderType } from "./responder-type";
 export declare class PointPositioner extends Positioner {
     track: Track;

package/.built/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/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/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/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/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/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/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;
+    }[];
+}

package/.built/section.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Section = void 0;
+const position_1 = require("./position");
+const router_1 = require("./router");
+class Section {
+    name;
+    district;
+    powerDistrict;
+    tracks = [];
+    tiles = [];
+    in;
+    out;
+    constructor(name, district) {
+        this.name = name;
+        this.district = district;
+    }
+    get domainName() {
+        return `${this.name}.${this.district.domainName}`;
+    }
+    // returns the next currently set section
+    next(reverse) {
+        if (reverse) {
+            if (!this.in) {
+                return null;
+            }
+            if (this.in instanceof Section) {
+                return this.in;
+            }
+            if (this.in instanceof router_1.Router) {
+                const activeRoute = this.in.activeRoute;
+                if (!activeRoute) {
+                    throw new Error(`Router '${this.in.domainName}' has no active route`);
+                }
+                if (activeRoute.in == this) {
+                    return activeRoute.out;
+                }
+                if (activeRoute.out == this) {
+                    return activeRoute.in;
+                }
+                throw new Error(`Router '${this.in.domainName}' is not routing from '${this.domainName}'`);
+            }
+        }
+        else {
+            if (!this.out) {
+                return null;
+            }
+            if (this.out instanceof Section) {
+                return this.out;
+            }
+            if (this.out instanceof router_1.Router) {
+                const activeRoute = this.out.activeRoute;
+                if (!activeRoute) {
+                    throw new Error(`Router '${this.out.domainName}' has no active route`);
+                }
+                if (activeRoute.in == this) {
+                    return activeRoute.out;
+                }
+                if (activeRoute.out == this) {
+                    return activeRoute.in;
+                }
+                throw new Error(`Router '${this.in?.domainName}' is not routing from '${this.domainName}'`);
+            }
+        }
+    }
+    getTilesInRange(startPosition, endPosition) {
+        if (startPosition.section != this && endPosition.section != this) {
+            return {
+                offset: {
+                    start: 0,
+                    end: this.tiles[this.tiles.length - 1].pattern.length
+                },
+                tiles: [...this.tiles]
+            };
+        }
+        let start = 0;
+        let end = this.length;
+        // only use the position limit if it is within our section
+        if (startPosition.section == this) {
+            end = startPosition.absolutePosition;
+        }
+        if (endPosition.section == this) {
+            start = endPosition.absolutePosition;
+        }
+        // flip if the range was reversed
+        if (end < start) {
+            const small = end;
+            end = start;
+            start = small;
+        }
+        let passed = 0;
+        const tiles = [];
+        const tileUnitLength = this.length / this.tileLength;
+        const offset = {
+            start: 0,
+            end: 0
+        };
+        for (let tile of this.tiles) {
+            const length = tile.pattern.length * tileUnitLength;
+            if (start - length <= passed && end + length >= passed) {
+                tiles.push(tile);
+                if (start <= passed) {
+                    offset.start = (start + length - passed) * tile.pattern.length / length;
+                }
+                if (end >= passed) {
+                    offset.end = 0.5; // (start + length - passed) * tile.pattern.length / length;
+                }
+            }
+            passed += length;
+        }
+        return {
+            offset,
+            tiles
+        };
+    }
+    dump() {
+        console.group(`Section ${this.domainName}`);
+        console.log('in', this.in?.name ?? 'buffer');
+        console.log('out', this.out?.name ?? 'buffer');
+        console.group(`tracks`);
+        for (let track of this.tracks) {
+            track.dump();
+        }
+        console.groupEnd();
+        console.groupEnd();
+    }
+    get length() {
+        return this.tracks.reduce((accumulator, track) => accumulator + track.length, 0);
+    }
+    get tileLength() {
+        return this.tiles.reduce((accumulator, tile) => accumulator + tile.pattern.length, 0);
+    }
+    // follow the active path ahead (reverse = true = back)
+    // uses the currently set routes
+    // returns all touched sections
+    trail(offset, reversed, length) {
+        let tip = this;
+        const sections = [this];
+        if (reversed) {
+            length -= offset;
+        }
+        else {
+            length -= this.length - offset;
+        }
+        while (length > 0) {
+            let next;
+            if (reversed) {
+                next = tip.in;
+            }
+            else {
+                next = tip.out;
+            }
+            if (!next) {
+                return {
+                    sections,
+                    tip: new position_1.SectionPosition(tip, tip.length, false)
+                };
+            }
+            if (next instanceof Section) {
+                tip = next;
+            }
+            if (next instanceof router_1.Router) {
+                if (!next.activeRoute) {
+                    throw new Error(`Router '${next.domainName}' has no active route (routes: ${next.routes.map(route => `'${route.name}'`).join(', ')})`);
+                }
+                // TODO: handle flipped cases
+                if (reversed) {
+                    tip = next.activeRoute.in;
+                }
+                else {
+                    tip = next.activeRoute.out;
+                }
+            }
+            sections.push(tip);
+            length -= tip.length;
+        }
+        return {
+            sections,
+            tip: new position_1.SectionPosition(tip, reversed ? -length : tip.length + length, false)
+        };
+    }
+    toDotReference() {
+        return `section_${this.name.replace(/-/g, '_')}_${this.district.toDotReference()}`;
+    }
+    toDotDefinition() {
+        return `
+			${this.toDotReference()} [ label = ${JSON.stringify(`${this.name}\n${this.length}`)}, shape = box ]
+		`;
+    }
+    toDotConnection() {
+        return `
+			${this.out instanceof Section ? `${this.toDotReference()} -> ${this.out.toDotReference()}` : ''}
+		`;
+    }
+    toSVG() {
+        return `
+			<g id=${JSON.stringify(this.domainName).split('.').join('_')}>
+				<style>
+
+					g#${this.domainName.split('.').join('_')} path {
+						stroke: hsl(${(this.length / this.tileLength)}deg, 100%, 50%);
+					}
+
+				</style>
+
+				${this.tiles.map(tile => tile.toSVG()).join('')}
+			</g>
+		`;
+    }
+    findSVGPositions() {
+        return this.tiles.map(tile => ({
+            x: tile.x,
+            y: tile.y
+        }));
+    }
+}
+exports.Section = Section;

package/.built/tile.d.ts

@@ -0,0 +1,57 @@
+import { Section } from './section.js';
+export declare class TilePattern {
+    length: number;
+    path: (continuous: boolean, x: number, y: number) => string;
+    static patterns: {
+        'tl-cc': TilePattern;
+        'tc-cc': TilePattern;
+        'tr-cc': TilePattern;
+        'cl-cc': TilePattern;
+        'cr-cc': TilePattern;
+        'bl-cc': TilePattern;
+        'bc-cc': TilePattern;
+        'br-cc': TilePattern;
+        'cc-tl': TilePattern;
+        'cc-tc': TilePattern;
+        'cc-tr': TilePattern;
+        'cc-cl': TilePattern;
+        'cc-cr': TilePattern;
+        'cc-bl': TilePattern;
+        'cc-bc': TilePattern;
+        'cc-br': TilePattern;
+        'cr-cl': TilePattern;
+        'cr-tl': TilePattern;
+        'cr-bl': TilePattern;
+        'cl-cr': TilePattern;
+        'cl-tr': TilePattern;
+        'cl-bl': TilePattern;
+        'tl-bc': TilePattern;
+        'tl-br': TilePattern;
+        'tl-cr': TilePattern;
+        'tc-bc': TilePattern;
+        'tc-br': TilePattern;
+        'tc-bl': TilePattern;
+        'tr-cl': TilePattern;
+        'tr-bc': TilePattern;
+        'bl-tr': TilePattern;
+        'bl-tc': TilePattern;
+        'bl-cr': TilePattern;
+        'bc-tc': TilePattern;
+        'bc-tr': TilePattern;
+        'bc-tl': TilePattern;
+        'br-cl': TilePattern;
+        'br-tc': TilePattern;
+        'br-tl': TilePattern;
+        'cl-bc': TilePattern;
+    };
+    constructor(length: number, path: (continuous: boolean, x: number, y: number) => string);
+}
+export declare class Tile {
+    section: Section;
+    x: number;
+    y: number;
+    pattern: TilePattern;
+    constructor(section: Section, x: number, y: number, pattern: TilePattern);
+    toSVGPath(continuous?: boolean): string;
+    toSVG(): string;
+}

package/.built/tile.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tile = exports.TilePattern = void 0;
+class TilePattern {
+    length;
+    path;
+    // TODO: replace simple paths with rounded versions
+    static patterns = {
+        'tl-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}`),
+        'tc-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 0.5}`),
+        'tr-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0}, L ${x + 0.5} ${y + 0.5}`),
+        'cl-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}`),
+        'cr-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}`),
+        'bl-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}`),
+        'bc-cc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}`),
+        'br-cc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}`),
+        'cc-tl': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+        'cc-tc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'cc-tr': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'cc-cl': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'cc-cr': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+        'cc-bl': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 1}`),
+        'cc-bc': new TilePattern(0.5, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 1}`),
+        'cc-br': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        'cr-cl': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'cr-tl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+        'cr-bl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 1}`),
+        'cl-cr': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+        'cl-tr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'cl-bl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        'tl-bc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 1}`),
+        'tl-br': new TilePattern(1.4, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        'tl-cr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+        'tc-bc': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 1}`),
+        'tc-br': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 1}`),
+        'tc-bl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 1}`),
+        'tr-cl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'tr-bc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 0}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 1}`),
+        'bl-tr': new TilePattern(1.4, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'bl-tc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'bl-cr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0.5}`),
+        'bc-tc': new TilePattern(1, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'bc-tr': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 1} ${y + 0}`),
+        'bc-tl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0.5} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+        'br-cl': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0.5}`),
+        'br-tc': new TilePattern(1.2, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0.5} ${y + 0}`),
+        'br-tl': new TilePattern(1.4, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 1} ${y + 1}, L ${x + 0.5} ${y + 0.5}, L ${x + 0} ${y + 0}`),
+        // oddities
+        'cl-bc': new TilePattern(0.7, (continuous, x, y) => `${continuous ? 'L' : 'M'} ${x + 0} ${y + 0.5}, L ${x + 0.5} ${y + 1}`)
+    };
+    constructor(length, path) {
+        this.length = length;
+        this.path = path;
+    }
+}
+exports.TilePattern = TilePattern;
+class Tile {
+    section;
+    x;
+    y;
+    pattern;
+    constructor(section, x, y, pattern) {
+        this.section = section;
+        this.x = x;
+        this.y = y;
+        this.pattern = pattern;
+    }
+    toSVGPath(continuous = false) {
+        return this.pattern.path(continuous, this.x, this.y);
+    }
+    toSVG() {
+        return `
+            <path d="${this.toSVGPath()}" />
+            ${this.section.tiles[0] == this ? `<text x="${this.x}" y="${this.y}" font-size="0.2">${this.section.name}</text>` : ''}
+        `;
+    }
+}
+exports.Tile = Tile;

package/.built/track.d.ts

@@ -0,0 +1,12 @@
+import { Positioner } from "./positioner";
+import { Section } from "./section";
+import { SectionPosition } from "./position";
+export declare class Track {
+    section: Section;
+    length: number;
+    path: string;
+    positioners: Positioner[];
+    constructor(section: Section, length: number, path: string);
+    get head(): SectionPosition;
+    dump(): void;
+}

package/.built/track.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Track = void 0;
+const position_1 = require("./position");
+class Track {
+    section;
+    length;
+    path;
+    positioners = [];
+    constructor(section, length, path) {
+        this.section = section;
+        this.length = length;
+        this.path = path;
+    }
+    // the start of the track within the section
+    get head() {
+        let offset = 0;
+        for (let track of this.section.tracks) {
+            if (track == this) {
+                return new position_1.SectionPosition(this.section, offset, false);
+            }
+            offset += track.length;
+        }
+    }
+    dump() {
+        console.log(this.length);
+    }
+}
+exports.Track = Track;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@packtrack/layout",
-	"version": "1.0.4",
+	"version": "1.0.5",
 	"main": ".built/index.js",
 	"typings": ".built/index.d.ts",
 	"scripts": {

package/source/layout.ts

@@ -5,10 +5,10 @@ import { Router } from "./router";
 import { Section } from "./section";
 import { TilePattern, Tile } from "./tile";
 import { Track } from "./track";
-import { PointPositioner } from "../positioner/point";
 import { Device } from "./device/device";
-import { ResponderType } from "../positioner/responder-type";
+import { ResponderType } from "./positioner/responder-type";
 import { Channel } from "./device/channel";
+import { PointPositioner } from "./positioner/point";
 
 export class Layout {
 	name: string;

package/{positioner → source/positioner}/point.ts

@@ -1,6 +1,6 @@
 import { Positioner } from ".";
-import { Channel } from "../source/device/channel";
-import { Track } from "../source/track";
+import { Channel } from "../device/channel";
+import { Track } from "../track";
 import { ResponderType } from "./responder-type";
 
 export class PointPositioner extends Positioner {

package/source/track.ts

@@ -1,4 +1,4 @@
-import { Positioner } from "../positioner";
+import { Positioner } from "./positioner";
 import { Section } from "./section";
 import { SectionPosition } from "./position";