mudlet-map-renderer 1.0.0 → 1.1.0

package/dist/ExitRenderer.d.ts

@@ -0,0 +1,109 @@
+import { default as IExit } from './reader/Exit';
+import { IMapReader } from './reader/MapReader';
+import { Settings } from './types/Settings';
+export type ExitDrawLine = {
+    points: number[];
+    stroke: string;
+    strokeWidth: number;
+    dash?: number[];
+};
+export type ExitDrawArrow = {
+    points: number[];
+    pointerLength: number;
+    pointerWidth: number;
+    stroke: string;
+    strokeWidth: number;
+    fill: string;
+    dash?: number[];
+};
+export type ExitDrawDoor = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    stroke: string;
+    strokeWidth: number;
+};
+export type ExitDrawData = {
+    lines: ExitDrawLine[];
+    arrows: ExitDrawArrow[];
+    doors: ExitDrawDoor[];
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Set when this exit leads to a room in a different area (cross-area exit). */
+    targetRoomId?: number;
+    /** Source room center in map coords — used to compute label direction. */
+    from?: {
+        x: number;
+        y: number;
+    };
+    /** Arrow tip / far endpoint in map coords — anchor for placed labels. */
+    tip?: {
+        x: number;
+        y: number;
+    };
+    /** Stroke colour of the rendered arrow — used to colour area-exit labels. */
+    arrowColor?: string;
+};
+export default class ExitRenderer {
+    private mapReader;
+    private readonly settings;
+    constructor(mapReader: IMapReader, settings: Settings);
+    /**
+     * Get the edge point of a room based on its shape.
+     * The inset accounts for the inner border so exit lines reach the visible room edge.
+     */
+    private getRoomEdgePoint;
+    renderData(exit: IExit, zIndex: number): ExitDrawData | undefined;
+    renderDataWithColor(exit: IExit, color: string, zIndex: number): ExitDrawData | undefined;
+    private renderTwoWayExitData;
+    private renderOneWayExitData;
+    /**
+     * Returns hit-zone bounds for special exits (custom lines) that lead to rooms in another area.
+     */
+    /**
+     * Hit zones for cross-area inner exits (up/down/in/out). These are drawn as
+     * triangles inside the room, not through the exit pipeline, so they need
+     * their own plumbing for area-exit labelling and clickability.
+     */
+    getInnerExitAreaTargets(room: MapData.Room): {
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        targetRoomId: number;
+        from: {
+            x: number;
+            y: number;
+        };
+        tip: {
+            x: number;
+            y: number;
+        };
+        arrowColor: string;
+    }[];
+    getSpecialExitAreaTargets(room: MapData.Room): {
+        bounds: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        targetRoomId: number;
+        from: {
+            x: number;
+            y: number;
+        };
+        tip: {
+            x: number;
+            y: number;
+        };
+        arrowColor: string;
+    }[];
+}

package/dist/InteractionHandler.d.ts

@@ -0,0 +1,47 @@
+import { RendererEventMap } from './types/Settings';
+import { TypedEventEmitter } from './TypedEventEmitter';
+import { Camera } from './camera/Camera';
+import { MapState } from './MapState';
+import { HitResult } from './hit/HitTester';
+export type HitTestCallbacks = {
+    clientToMapPoint: (clientX: number, clientY: number) => {
+        x: number;
+        y: number;
+    } | null;
+    /**
+     * Pick the topmost hit-annotated shape at a point in rendered space. The
+     * unified entry point for all DOM-level interaction — rooms, area-exit
+     * labels, and any future pickable kinds all flow through one query.
+     */
+    pickAtPoint: (renderedX: number, renderedY: number) => HitResult | null;
+};
+/**
+ * Handles all DOM interaction on the map container:
+ * - Camera: drag (mouse + touch), wheel zoom, pinch zoom, resize
+ * - Map: hover cursor, click, right-click, long-press, area exit clicks
+ *
+ * No Konva dependency — works with any rendering backend.
+ */
+export declare class InteractionHandler {
+    private readonly container;
+    private readonly camera;
+    private readonly state;
+    private readonly hitTest;
+    private readonly events;
+    private lastPinchDistance?;
+    private readonly cleanupFns;
+    private destroyed;
+    /** Skip cursor changes when an external consumer (e.g. the editor) owns cursor management. */
+    private setCursor;
+    constructor(container: HTMLDivElement, camera: Camera, state: MapState, hitTest: HitTestCallbacks, events: TypedEventEmitter<RendererEventMap>);
+    destroy(): void;
+    private listen;
+    private initViewportEvents;
+    private handlePinch;
+    private initMapEvents;
+    private pickAtClientPoint;
+    private emitRoomClickEvent;
+    private emitRoomContextEvent;
+    private emitAreaExitClickEvent;
+    private emitMapClickEvent;
+}

package/dist/MapGraph.d.ts

@@ -0,0 +1,28 @@
+import { IMapReader } from './reader/MapReader';
+export interface Edge {
+    id: number;
+    weight: number;
+}
+export interface GraphData {
+    adj: Map<number, Edge[]>;
+    /** For node-dijkstra library */
+    graphDefinition: Record<string, Record<string, number>>;
+    maxEdgeDistance: number;
+    minEdgeWeight: number;
+}
+/**
+ * Builds a weighted adjacency graph from MapReader room/exit data.
+ * Separated from PathFinder so the graph can be reused and tested independently.
+ */
+export declare class MapGraph {
+    private readonly mapReader;
+    private readonly data;
+    constructor(mapReader: IMapReader);
+    getAdj(): Map<number, Edge[]>;
+    getGraphDefinition(): Record<string, Record<string, number>>;
+    getMaxEdgeDistance(): number;
+    getMinEdgeWeight(): number;
+    getRoom(roomId: number): MapData.Room;
+    private resolveEdgeWeight;
+    private buildGraph;
+}

package/dist/MapReader-mU_4JWv_.js

@@ -0,0 +1,224 @@
+//#region src/reader/Plane.ts
+var e = class {
+	constructor(e, t) {
+		this.rooms = [], this.labels = [], this.rooms = e, this.labels = t, this.bounds = this.createBounds();
+	}
+	getRooms() {
+		return this.rooms;
+	}
+	getLabels() {
+		return this.labels;
+	}
+	getBounds() {
+		return this.bounds;
+	}
+	createBounds() {
+		let e = this.rooms.reduce((e, t) => ({
+			minX: Math.min(e.minX, t.x),
+			maxX: Math.max(e.maxX, t.x),
+			minY: Math.min(e.minY, t.y),
+			maxY: Math.max(e.maxY, t.y)
+		}), {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		});
+		for (let t of this.labels) {
+			let n = t.X, r = -t.Y;
+			e.minX = Math.min(e.minX, n), e.maxX = Math.max(e.maxX, n + t.Width), e.minY = Math.min(e.minY, r), e.maxY = Math.max(e.maxY, r + t.Height);
+		}
+		return e;
+	}
+}, t = class t {
+	constructor(e) {
+		this.planes = {}, this.exits = /* @__PURE__ */ new Map(), this.version = 0, this.area = e, this.planes = this.createPlanes(), this.createExits();
+	}
+	getAreaName() {
+		return this.area.areaName;
+	}
+	getAreaId() {
+		return parseInt(this.area.areaId);
+	}
+	getVersion() {
+		return this.version;
+	}
+	markDirty() {
+		this.version++;
+	}
+	getPlane(e) {
+		return this.planes[e];
+	}
+	getPlanes() {
+		return Object.values(this.planes);
+	}
+	getZLevels() {
+		return Object.keys(this.planes).map(Number).sort((e, t) => e - t);
+	}
+	getRooms() {
+		return this.area.rooms;
+	}
+	getFullBounds() {
+		return this.getPlanes().reduce((e, t) => {
+			let n = t.getBounds();
+			return {
+				minX: Math.min(e.minX, n.minX),
+				maxX: Math.max(e.maxX, n.maxX),
+				minY: Math.min(e.minY, n.minY),
+				maxY: Math.max(e.maxY, n.maxY)
+			};
+		}, {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		});
+	}
+	getLinkExits(e) {
+		return Array.from(this.exits.values()).filter((t) => t.zIndex.includes(e));
+	}
+	createPlanes() {
+		let t = this.area.rooms.reduce((e, t) => (e[t.z] || (e[t.z] = []), e[t.z].push(t), e), {});
+		return Object.entries(t).reduce((t, [n, r]) => (t[+n] = new e(r, this.area.labels.filter((e) => e.Z === +n)), t), {});
+	}
+	static {
+		this.oppositeDir = {
+			north: "south",
+			south: "north",
+			east: "west",
+			west: "east",
+			northeast: "southwest",
+			southwest: "northeast",
+			northwest: "southeast",
+			southeast: "northwest",
+			up: "down",
+			down: "up",
+			in: "out",
+			out: "in"
+		};
+	}
+	createExits() {
+		let e = /* @__PURE__ */ new Map();
+		this.area.rooms.forEach((t) => {
+			Object.entries(t.exits).forEach(([n, r]) => {
+				if (t.id === r) return;
+				let i = `${Math.min(t.id, r)}-${Math.max(t.id, r)}`;
+				e.has(i) || e.set(i, []), e.get(i).push({
+					origin: t.id,
+					target: r,
+					z: t.z,
+					dir: n
+				});
+			});
+		});
+		for (let [n, r] of e) {
+			let [e, i] = n.split("-"), a = parseInt(e), o = parseInt(i), s = r.filter((e) => e.origin === a), c = r.filter((e) => e.origin === o), l = /* @__PURE__ */ new Set();
+			for (let e of s) {
+				let r = -1;
+				for (let n = 0; n < c.length; n++) if (!l.has(n) && c[n].dir === t.oppositeDir[e.dir]) {
+					r = n;
+					break;
+				}
+				if (r !== -1) {
+					l.add(r);
+					let t = c[r];
+					this.exits.set(`${n}-${e.dir}`, {
+						a,
+						b: o,
+						aDir: e.dir,
+						bDir: t.dir,
+						zIndex: [e.z, t.z]
+					});
+				} else this.exits.set(`${n}-a:${e.dir}`, {
+					a,
+					b: o,
+					aDir: e.dir,
+					zIndex: [e.z]
+				});
+			}
+			for (let e = 0; e < c.length; e++) if (!l.has(e)) {
+				let t = c[e];
+				this.exits.set(`${n}-b:${t.dir}`, {
+					a,
+					b: o,
+					bDir: t.dir,
+					zIndex: [t.z]
+				});
+			}
+		}
+	}
+}, n = {
+	rgb: [
+		114,
+		1,
+		0
+	],
+	rgbValue: "rgb(114, 1, 0)",
+	symbolColor: [
+		225,
+		225,
+		225
+	],
+	symbolColorValue: "rgb(225,225,225)"
+};
+function r(e) {
+	let t = e[0] / 255, n = e[1] / 255, r = e[2] / 255;
+	return (Math.max(t, n, r) + Math.min(t, n, r)) / 2;
+}
+var i = class {
+	constructor(e, n) {
+		this.rooms = {}, this.areas = {}, this.colors = {}, e.forEach((e) => {
+			let n = {
+				...e,
+				rooms: e.rooms.map((e) => ({
+					...e,
+					y: -e.y
+				}))
+			};
+			n.rooms.forEach((e) => {
+				this.rooms[e.id] = e;
+			});
+			let r = parseInt(e.areaId);
+			this.areas[r] = new t(n);
+		}), this.colors = n.reduce((e, t) => ({
+			...e,
+			[t.envId]: {
+				rgb: t.colors,
+				rgbValue: `rgb(${t.colors.join(",")})`,
+				symbolColor: r(t.colors) > .41 ? [
+					25,
+					25,
+					25
+				] : [
+					225,
+					255,
+					255
+				],
+				symbolColorValue: r(t.colors) > .41 ? "rgb(25,25,25)" : "rgb(225,255,255)"
+			}
+		}), {});
+	}
+	getArea(e) {
+		return this.areas[e];
+	}
+	getAreas() {
+		return Object.values(this.areas);
+	}
+	getRooms() {
+		return Object.values(this.rooms);
+	}
+	getRoom(e) {
+		return this.rooms[e];
+	}
+	getColorValue(e) {
+		return this.colors[e]?.rgbValue ?? n.rgbValue;
+	}
+	getSymbolColor(e, t) {
+		let r = this.colors[e]?.symbolColor ?? n.symbolColor, i = Math.min(Math.max(t ?? 1, 0), 1), a = r.join(",");
+		return i == 1 ? `rgba(${a})` : `rgba(${a}, ${i})`;
+	}
+};
+//#endregion
+export { t as n, e as r, i as t };
+
+//# sourceMappingURL=MapReader-mU_4JWv_.js.map

package/dist/MapReader-mU_4JWv_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapReader-mU_4JWv_.js","names":[],"sources":["../src/reader/Plane.ts","../src/reader/Area.ts","../src/reader/MapReader.ts"],"sourcesContent":["/**\n * Public, renderer-facing surface of a z-level slice of an area.\n *\n * The renderer (and other library consumers) only depend on this interface;\n * the concrete {@link Plane} class is one implementation of it. Downstream\n * apps that want to drive the renderer from their own data model can hand it\n * any `IPlane`-shaped object (typically returned from an {@link IArea}).\n */\nexport interface IPlane {\n    getRooms(): MapData.Room[];\n    getLabels(): MapData.Label[];\n    getBounds(): { minX: number; maxX: number; minY: number; maxY: number };\n}\n\nexport default class Plane implements IPlane {\n\n    private readonly bounds: { minX: number, maxX: number, minY: number, maxY: number }\n    private readonly rooms: MapData.Room[] = [];\n    private readonly labels: MapData.Label[] = [];\n\n    constructor(rooms: MapData.Room[], labels: MapData.Label[]) {\n        this.rooms = rooms;\n        this.labels = labels;\n        this.bounds = this.createBounds();\n    }\n\n    getRooms() {\n        return this.rooms;\n    }\n\n    getLabels() {\n        return this.labels;\n    }\n\n    getBounds() {\n        return this.bounds;\n    }\n\n    private createBounds() {\n        const b = this.rooms.reduce(\n            (acc, r) => ({\n                minX: Math.min(acc.minX, r.x),\n                maxX: Math.max(acc.maxX, r.x),\n                minY: Math.min(acc.minY, r.y),\n                maxY: Math.max(acc.maxY, r.y),\n            }),\n            {\n                minX: Number.POSITIVE_INFINITY,\n                maxX: Number.NEGATIVE_INFINITY,\n                minY: Number.POSITIVE_INFINITY,\n                maxY: Number.NEGATIVE_INFINITY,\n            }\n        );\n        for (const label of this.labels) {\n            const lx = label.X;\n            const ly = -label.Y;\n            b.minX = Math.min(b.minX, lx);\n            b.maxX = Math.max(b.maxX, lx + label.Width);\n            b.minY = Math.min(b.minY, ly);\n            b.maxY = Math.max(b.maxY, ly + label.Height);\n        }\n        return b;\n    }\n\n}\n","import Plane, {IPlane} from \"./Plane\";\n\nimport IExit from \"./Exit\";\n\n/**\n * Public, renderer-facing surface of an area. The renderer never inspects\n * private state of {@link Area}; it talks to this interface only. Custom data\n * models (e.g. an app that owns its own room store) can satisfy `IArea` and\n * hand the result to {@link MapRenderer} without subclassing.\n *\n * Mutability lives on the concrete implementation: {@link Area.markDirty} is\n * `protected`, kept off the public interface. Consumers signal \"redraw me\" by\n * bumping {@link getVersion}; the renderer reads the version to decide\n * whether to rebuild.\n */\nexport interface IArea {\n    getAreaName(): string;\n    getAreaId(): number;\n    /**\n     * Monotonically increasing version. The renderer compares the value it\n     * cached on the last build against the current value to decide whether\n     * the area needs a rebuild.\n     */\n    getVersion(): number;\n    getPlane(zIndex: number): IPlane;\n    getPlanes(): IPlane[];\n    getZLevels(): number[];\n    getRooms(): MapData.Room[];\n    getFullBounds(): { minX: number; maxX: number; minY: number; maxY: number };\n    /**\n     * Inter-room exits drawn on the given z-level. Each exit is bidirectional\n     * with optional one-way fallback; see {@link IExit}.\n     */\n    getLinkExits(zIndex: number): IExit[];\n}\n\nexport default class Area implements IArea {\n\n    private readonly planes: Record<number, Plane> = {};\n    private readonly area: MapData.Area;\n    private readonly exits: Map<string, IExit> = new Map();\n    private version = 0;\n\n    constructor(area: MapData.Area) {\n        this.area = area;\n        this.planes = this.createPlanes();\n        this.createExits();\n    }\n\n    getAreaName() {\n        return this.area.areaName\n    }\n\n    getAreaId() {\n        return parseInt(this.area.areaId)\n    }\n\n    getVersion() {\n        return this.version;\n    }\n\n    protected markDirty() {\n        this.version++;\n    }\n\n    getPlane(zIndex: number) {\n        return this.planes[zIndex];\n    }\n\n    getPlanes() {\n        return Object.values(this.planes);\n    }\n\n    getZLevels(): number[] {\n        return Object.keys(this.planes).map(Number).sort((a, b) => a - b);\n    }\n\n    getRooms() {\n        return this.area.rooms\n    }\n\n    getFullBounds(): { minX: number; maxX: number; minY: number; maxY: number } {\n        return this.getPlanes().reduce(\n            (acc, plane) => {\n                const b = plane.getBounds();\n                return {\n                    minX: Math.min(acc.minX, b.minX),\n                    maxX: Math.max(acc.maxX, b.maxX),\n                    minY: Math.min(acc.minY, b.minY),\n                    maxY: Math.max(acc.maxY, b.maxY),\n                };\n            },\n            { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }\n        );\n    }\n\n    getLinkExits(zIndex: number) {\n        return Array.from(this.exits.values()).filter(e => e.zIndex.includes(zIndex));\n    }\n\n    private createPlanes() {\n        const grouped = this.area.rooms.reduce<Record<number, MapData.Room[]>>((acc, room) => {\n            if (!acc[room.z]) {\n                acc[room.z] = [];\n            }\n            // @ts-ignore\n            acc[room.z].push(room);\n            return acc;\n        }, {});\n        return Object.entries(grouped).reduce(\n            (acc, [z, rooms]) => {\n                acc[+z] = new Plane(rooms, this.area.labels.filter(label => label.Z === +z));\n                return acc;\n            },\n            {} as Record<number, Plane>\n        );\n    }\n\n    private static readonly oppositeDir: Partial<Record<MapData.direction, MapData.direction>> = {\n        \"north\": \"south\", \"south\": \"north\",\n        \"east\": \"west\", \"west\": \"east\",\n        \"northeast\": \"southwest\", \"southwest\": \"northeast\",\n        \"northwest\": \"southeast\", \"southeast\": \"northwest\",\n        \"up\": \"down\", \"down\": \"up\",\n        \"in\": \"out\", \"out\": \"in\",\n    };\n\n    private createExits() {\n        type HalfExit = { origin: number, target: number, z: number, dir: MapData.direction };\n        const halfExitsByPair = new Map<string, HalfExit[]>();\n\n        this.area.rooms.forEach(room => {\n            Object.entries(room.exits).forEach(([direction, targetRoomId]) => {\n                if (room.id === targetRoomId) return;\n                const a = Math.min(room.id, targetRoomId);\n                const b = Math.max(room.id, targetRoomId);\n                const key = `${a}-${b}`;\n                if (!halfExitsByPair.has(key)) halfExitsByPair.set(key, []);\n                halfExitsByPair.get(key)!.push({\n                    origin: room.id, target: targetRoomId, z: room.z, dir: direction as MapData.direction\n                });\n            });\n        });\n\n        for (const [pairKey, halves] of halfExitsByPair) {\n            const [aStr, bStr] = pairKey.split('-');\n            const a = parseInt(aStr), b = parseInt(bStr);\n\n            const aSide = halves.filter(h => h.origin === a);\n            const bSide = halves.filter(h => h.origin === b);\n\n            const usedB = new Set<number>();\n\n            for (const aHalf of aSide) {\n                let bestIdx = -1;\n                for (let i = 0; i < bSide.length; i++) {\n                    if (usedB.has(i)) continue;\n                    if (bSide[i].dir === Area.oppositeDir[aHalf.dir]) {\n                        bestIdx = i;\n                        break;\n                    }\n                }\n\n                if (bestIdx !== -1) {\n                    usedB.add(bestIdx);\n                    const bHalf = bSide[bestIdx];\n                    this.exits.set(`${pairKey}-${aHalf.dir}`, {\n                        a, b, aDir: aHalf.dir, bDir: bHalf.dir, zIndex: [aHalf.z, bHalf.z]\n                    });\n                } else {\n                    this.exits.set(`${pairKey}-a:${aHalf.dir}`, {\n                        a, b, aDir: aHalf.dir, zIndex: [aHalf.z]\n                    });\n                }\n            }\n\n            for (let i = 0; i < bSide.length; i++) {\n                if (!usedB.has(i)) {\n                    const bHalf = bSide[i];\n                    this.exits.set(`${pairKey}-b:${bHalf.dir}`, {\n                        a, b, bDir: bHalf.dir, zIndex: [bHalf.z]\n                    });\n                }\n            }\n        }\n    }\n\n}","import Area, {IArea} from \"./Area\";\n\n/**\n * Public, renderer-facing surface for map data. Everything the renderer\n * (and other library consumers) call on `MapReader` is on this interface —\n * private state and internal helpers are not.\n *\n * Downstream apps with their own room/area store can implement `IMapReader`\n * directly (no need to subclass {@link MapReader}) and hand the result to\n * {@link MapRenderer}. Visibility filtering (exploration, scope overlays,\n * etc.) lives on the renderer's lens — it is intentionally not on this\n * interface.\n */\nexport interface IMapReader {\n    getArea(areaId: number): IArea;\n    getAreas(): IArea[];\n    getRooms(): MapData.Room[];\n    getRoom(roomId: number): MapData.Room;\n    /** Returns the env's `rgb(r,g,b)` string, or a default colour if the env id is unknown. */\n    getColorValue(envId: number): string;\n    /** Returns a contrasting symbol colour for the env, optionally with the given alpha. */\n    getSymbolColor(envId: number, opacity?: number): string;\n}\n\ninterface Color {\n    rgb: number[];\n    rgbValue: string;\n    symbolColor: number[];\n    symbolColorValue: string,\n}\n\nconst defaultColor: Color = {\n    rgb: [114, 1, 0],\n    rgbValue: 'rgb(114, 1, 0)',\n    symbolColor: [225, 225, 225],\n    symbolColorValue: 'rgb(225,225,225)'\n}\n\nfunction calculateLuminance(rgb: number[]) {\n    const rn = rgb[0] / 255;\n    const gn = rgb[1] / 255;\n    const bn = rgb[2] / 255;\n\n    const max = Math.max(rn, gn, bn);\n    const min = Math.min(rn, gn, bn);\n\n    return (max + min) / 2;\n}\n\nexport default class MapReader implements IMapReader {\n\n    private rooms: Record<number, MapData.Room> = {};\n    private areas: Record<number, Area> = {};\n    private colors: Record<number, Color> = {};\n\n    constructor(map: MapData.Map, envs: MapData.Env[]) {\n        map.forEach(area => {\n            const clonedArea: MapData.Area = {\n                ...area,\n                rooms: area.rooms.map(room => ({ ...room, y: -room.y })),\n            };\n            clonedArea.rooms.forEach(room => {\n                this.rooms[room.id] = room;\n            });\n            const areaId = parseInt(area.areaId);\n            this.areas[areaId] = new Area(clonedArea);\n        })\n        this.colors = envs.reduce((acc, c) => ({\n            ...acc,\n            [c.envId]: {\n                rgb: c.colors,\n                rgbValue: `rgb(${c.colors.join(',')})`,\n                symbolColor: calculateLuminance(c.colors) > 0.41 ? [25, 25, 25] : [225, 255, 255],\n                symbolColorValue: calculateLuminance(c.colors) > 0.41 ? 'rgb(25,25,25)' : 'rgb(225,255,255)'\n            }\n        }), {});\n    }\n\n    getArea(areaId: number) {\n        return this.areas[areaId];\n    }\n\n    getAreas() {\n        return Object.values(this.areas);\n    }\n\n    getRooms() {\n        return Object.values(this.rooms);\n    }\n\n    getRoom(roomId: number) {\n        return this.rooms[roomId];\n    }\n\n    getColorValue(envId: number): string {\n        return this.colors[envId]?.rgbValue ?? defaultColor.rgbValue;\n    }\n\n    getSymbolColor(envId: number, opacity?: number): string {\n        const color = this.colors[envId]?.symbolColor ?? defaultColor.symbolColor;\n        const normalizedOpacity = Math.min(Math.max(opacity ?? 1, 0), 1);\n        const value = color.join(',');\n        if (normalizedOpacity != 1) {\n            return `rgba(${value}, ${normalizedOpacity})`;\n        }\n        return `rgba(${value})`;\n    }\n\n}\n"],"mappings":";AAcA,IAAqB,IAArB,MAA6C;CAMzC,YAAY,GAAuB,GAAyB;AAGxD,eANqC,EAAE,gBACA,EAAE,EAGzC,KAAK,QAAQ,GACb,KAAK,SAAS,GACd,KAAK,SAAS,KAAK,cAAc;;CAGrC,WAAW;AACP,SAAO,KAAK;;CAGhB,YAAY;AACR,SAAO,KAAK;;CAGhB,YAAY;AACR,SAAO,KAAK;;CAGhB,eAAuB;EACnB,IAAM,IAAI,KAAK,MAAM,QAChB,GAAK,OAAO;GACT,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,EAAE;GAC7B,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,EAAE;GAC7B,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,EAAE;GAC7B,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,EAAE;GAChC,GACD;GACI,MAAM;GACN,MAAM;GACN,MAAM;GACN,MAAM;GACT,CACJ;AACD,OAAK,IAAM,KAAS,KAAK,QAAQ;GAC7B,IAAM,IAAK,EAAM,GACX,IAAK,CAAC,EAAM;AAIlB,GAHA,EAAE,OAAO,KAAK,IAAI,EAAE,MAAM,EAAG,EAC7B,EAAE,OAAO,KAAK,IAAI,EAAE,MAAM,IAAK,EAAM,MAAM,EAC3C,EAAE,OAAO,KAAK,IAAI,EAAE,MAAM,EAAG,EAC7B,EAAE,OAAO,KAAK,IAAI,EAAE,MAAM,IAAK,EAAM,OAAO;;AAEhD,SAAO;;GCzBM,IAArB,MAAqB,EAAsB;CAOvC,YAAY,GAAoB;AAG5B,gBAR6C,EAAE,+BAEN,IAAI,KAAK,iBACpC,GAGd,KAAK,OAAO,GACZ,KAAK,SAAS,KAAK,cAAc,EACjC,KAAK,aAAa;;CAGtB,cAAc;AACV,SAAO,KAAK,KAAK;;CAGrB,YAAY;AACR,SAAO,SAAS,KAAK,KAAK,OAAO;;CAGrC,aAAa;AACT,SAAO,KAAK;;CAGhB,YAAsB;AAClB,OAAK;;CAGT,SAAS,GAAgB;AACrB,SAAO,KAAK,OAAO;;CAGvB,YAAY;AACR,SAAO,OAAO,OAAO,KAAK,OAAO;;CAGrC,aAAuB;AACnB,SAAO,OAAO,KAAK,KAAK,OAAO,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE;;CAGrE,WAAW;AACP,SAAO,KAAK,KAAK;;CAGrB,gBAA4E;AACxE,SAAO,KAAK,WAAW,CAAC,QACnB,GAAK,MAAU;GACZ,IAAM,IAAI,EAAM,WAAW;AAC3B,UAAO;IACH,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,KAAK;IAChC,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,KAAK;IAChC,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,KAAK;IAChC,MAAM,KAAK,IAAI,EAAI,MAAM,EAAE,KAAK;IACnC;KAEL;GAAE,MAAM;GAAU,MAAM;GAAW,MAAM;GAAU,MAAM;GAAW,CACvE;;CAGL,aAAa,GAAgB;AACzB,SAAO,MAAM,KAAK,KAAK,MAAM,QAAQ,CAAC,CAAC,QAAO,MAAK,EAAE,OAAO,SAAS,EAAO,CAAC;;CAGjF,eAAuB;EACnB,IAAM,IAAU,KAAK,KAAK,MAAM,QAAwC,GAAK,OACpE,EAAI,EAAK,OACV,EAAI,EAAK,KAAK,EAAE,GAGpB,EAAI,EAAK,GAAG,KAAK,EAAK,EACf,IACR,EAAE,CAAC;AACN,SAAO,OAAO,QAAQ,EAAQ,CAAC,QAC1B,GAAK,CAAC,GAAG,QACN,EAAI,CAAC,KAAK,IAAI,EAAM,GAAO,KAAK,KAAK,OAAO,QAAO,MAAS,EAAM,MAAM,CAAC,EAAE,CAAC,EACrE,IAEX,EAAE,CACL;;;qBAGwF;GACzF,OAAS;GAAS,OAAS;GAC3B,MAAQ;GAAQ,MAAQ;GACxB,WAAa;GAAa,WAAa;GACvC,WAAa;GAAa,WAAa;GACvC,IAAM;GAAQ,MAAQ;GACtB,IAAM;GAAO,KAAO;GACvB;;CAED,cAAsB;EAElB,IAAM,oBAAkB,IAAI,KAAyB;AAErD,OAAK,KAAK,MAAM,SAAQ,MAAQ;AAC5B,UAAO,QAAQ,EAAK,MAAM,CAAC,SAAS,CAAC,GAAW,OAAkB;AAC9D,QAAI,EAAK,OAAO,EAAc;IAG9B,IAAM,IAAM,GAFF,KAAK,IAAI,EAAK,IAAI,EAAa,CAExB,GADP,KAAK,IAAI,EAAK,IAAI,EAAa;AAGzC,IADK,EAAgB,IAAI,EAAI,IAAE,EAAgB,IAAI,GAAK,EAAE,CAAC,EAC3D,EAAgB,IAAI,EAAI,CAAE,KAAK;KAC3B,QAAQ,EAAK;KAAI,QAAQ;KAAc,GAAG,EAAK;KAAG,KAAK;KAC1D,CAAC;KACJ;IACJ;AAEF,OAAK,IAAM,CAAC,GAAS,MAAW,GAAiB;GAC7C,IAAM,CAAC,GAAM,KAAQ,EAAQ,MAAM,IAAI,EACjC,IAAI,SAAS,EAAK,EAAE,IAAI,SAAS,EAAK,EAEtC,IAAQ,EAAO,QAAO,MAAK,EAAE,WAAW,EAAE,EAC1C,IAAQ,EAAO,QAAO,MAAK,EAAE,WAAW,EAAE,EAE1C,oBAAQ,IAAI,KAAa;AAE/B,QAAK,IAAM,KAAS,GAAO;IACvB,IAAI,IAAU;AACd,SAAK,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,IAC1B,QAAM,IAAI,EAAE,IACZ,EAAM,GAAG,QAAQ,EAAK,YAAY,EAAM,MAAM;AAC9C,SAAU;AACV;;AAIR,QAAI,MAAY,IAAI;AAChB,OAAM,IAAI,EAAQ;KAClB,IAAM,IAAQ,EAAM;AACpB,UAAK,MAAM,IAAI,GAAG,EAAQ,GAAG,EAAM,OAAO;MACtC;MAAG;MAAG,MAAM,EAAM;MAAK,MAAM,EAAM;MAAK,QAAQ,CAAC,EAAM,GAAG,EAAM,EAAE;MACrE,CAAC;UAEF,MAAK,MAAM,IAAI,GAAG,EAAQ,KAAK,EAAM,OAAO;KACxC;KAAG;KAAG,MAAM,EAAM;KAAK,QAAQ,CAAC,EAAM,EAAE;KAC3C,CAAC;;AAIV,QAAK,IAAI,IAAI,GAAG,IAAI,EAAM,QAAQ,IAC9B,KAAI,CAAC,EAAM,IAAI,EAAE,EAAE;IACf,IAAM,IAAQ,EAAM;AACpB,SAAK,MAAM,IAAI,GAAG,EAAQ,KAAK,EAAM,OAAO;KACxC;KAAG;KAAG,MAAM,EAAM;KAAK,QAAQ,CAAC,EAAM,EAAE;KAC3C,CAAC;;;;GCtJhB,IAAsB;CACxB,KAAK;EAAC;EAAK;EAAG;EAAE;CAChB,UAAU;CACV,aAAa;EAAC;EAAK;EAAK;EAAI;CAC5B,kBAAkB;CACrB;AAED,SAAS,EAAmB,GAAe;CACvC,IAAM,IAAK,EAAI,KAAK,KACd,IAAK,EAAI,KAAK,KACd,IAAK,EAAI,KAAK;AAKpB,SAHY,KAAK,IAAI,GAAI,GAAI,EAAG,GACpB,KAAK,IAAI,GAAI,GAAI,EAAG,IAEX;;AAGzB,IAAqB,IAArB,MAAqD;CAMjD,YAAY,GAAkB,GAAqB;AAY/C,eAhB0C,EAAE,eACV,EAAE,gBACA,EAAE,EAGtC,EAAI,SAAQ,MAAQ;GAChB,IAAM,IAA2B;IAC7B,GAAG;IACH,OAAO,EAAK,MAAM,KAAI,OAAS;KAAE,GAAG;KAAM,GAAG,CAAC,EAAK;KAAG,EAAE;IAC3D;AACD,KAAW,MAAM,SAAQ,MAAQ;AAC7B,SAAK,MAAM,EAAK,MAAM;KACxB;GACF,IAAM,IAAS,SAAS,EAAK,OAAO;AACpC,QAAK,MAAM,KAAU,IAAI,EAAK,EAAW;IAC3C,EACF,KAAK,SAAS,EAAK,QAAQ,GAAK,OAAO;GACnC,GAAG;IACF,EAAE,QAAQ;IACP,KAAK,EAAE;IACP,UAAU,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,aAAa,EAAmB,EAAE,OAAO,GAAG,MAAO;KAAC;KAAI;KAAI;KAAG,GAAG;KAAC;KAAK;KAAK;KAAI;IACjF,kBAAkB,EAAmB,EAAE,OAAO,GAAG,MAAO,kBAAkB;IAC7E;GACJ,GAAG,EAAE,CAAC;;CAGX,QAAQ,GAAgB;AACpB,SAAO,KAAK,MAAM;;CAGtB,WAAW;AACP,SAAO,OAAO,OAAO,KAAK,MAAM;;CAGpC,WAAW;AACP,SAAO,OAAO,OAAO,KAAK,MAAM;;CAGpC,QAAQ,GAAgB;AACpB,SAAO,KAAK,MAAM;;CAGtB,cAAc,GAAuB;AACjC,SAAO,KAAK,OAAO,IAAQ,YAAY,EAAa;;CAGxD,eAAe,GAAe,GAA0B;EACpD,IAAM,IAAQ,KAAK,OAAO,IAAQ,eAAe,EAAa,aACxD,IAAoB,KAAK,IAAI,KAAK,IAAI,KAAW,GAAG,EAAE,EAAE,EAAE,EAC1D,IAAQ,EAAM,KAAK,IAAI;AAI7B,SAHI,KAAqB,IAGlB,QAAQ,EAAM,KAFV,QAAQ,EAAM,IAAI,EAAkB"}

package/dist/MapState.d.ts

@@ -0,0 +1,110 @@
+import { IMapReader } from './reader/MapReader';
+import { IArea } from './reader/Area';
+import { IPlane } from './reader/Plane';
+import { Settings } from './types/Settings';
+import { SvgOverlays } from './SvgTypes';
+import { TypedEventEmitter } from './TypedEventEmitter';
+import { RoomLens } from './lens/RoomLens';
+export type HighlightEntry = {
+    color: string;
+    area: number;
+    z: number;
+};
+export type PathEntry = {
+    locations: number[];
+    color: string;
+};
+export type MapStateEventMap = {
+    area: {
+        area: IArea;
+        zIndex: number;
+    };
+    position: {
+        roomId: number | undefined;
+        center: boolean;
+        areaChanged: boolean;
+    };
+    center: {
+        roomId: number;
+        instant: boolean;
+    };
+    highlight: {
+        roomId: number;
+        color: string | undefined;
+    };
+    path: undefined;
+    clear: undefined;
+    lens: {
+        lens: RoomLens;
+    };
+};
+/**
+ * Pure data + events layer for map state.
+ * No Konva, no DOM — just tracks what area is displayed,
+ * where the player is, which rooms are highlighted, and active paths.
+ *
+ * Rendering backends subscribe to events and sync their visual state.
+ */
+export declare class MapState {
+    readonly mapReader: IMapReader;
+    readonly settings: Settings;
+    readonly events: TypedEventEmitter<MapStateEventMap>;
+    currentArea?: number;
+    currentAreaInstance?: IArea;
+    currentZIndex?: number;
+    currentAreaVersion?: number;
+    positionRoomId?: number;
+    centerRoomId?: number;
+    highlights: Map<number, HighlightEntry>;
+    paths: PathEntry[];
+    lens: RoomLens;
+    constructor(mapReader: IMapReader, settings: Settings);
+    setLens(lens: RoomLens): void;
+    /**
+     * Set the displayed area and z-level.
+     * Returns true if the area/z actually changed (or area version bumped).
+     */
+    setArea(id: number, zIndex: number): boolean;
+    setPosition(roomId: number, center?: boolean): boolean;
+    /**
+     * Update position marker without centering or switching area.
+     * Used when you want to show where the player is without moving the viewport.
+     */
+    updatePositionMarker(roomId: number): void;
+    /**
+     * Re-emit position for the current room (e.g. after settings change).
+     */
+    refreshPosition(): void;
+    clearPosition(): void;
+    setCenterRoom(roomId: number, instant?: boolean): boolean;
+    needsAreaRedraw(room: MapData.Room): boolean;
+    addHighlight(roomId: number, color: string): boolean;
+    removeHighlight(roomId: number): void;
+    hasHighlight(roomId: number): boolean;
+    clearHighlights(): void;
+    addPath(locations: number[], color?: string): void;
+    clearPaths(): void;
+    /**
+     * Build the overlay descriptor for the current area/z,
+     * merging stateful overlays with any extra overlays passed in.
+     */
+    getOverlaysForArea(extra?: SvgOverlays): SvgOverlays;
+    /**
+     * Get the effective plane bounds (respects uniformLevelSize setting).
+     */
+    getEffectiveBounds(area: IArea, plane: IPlane): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+    /**
+     * Compute export bounds for a given area/plane, optionally centered on a room.
+     */
+    computeExportBounds(area: IArea, plane: IPlane, roomId: number | undefined, padding: number): {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    };
+}

package/dist/PathData.d.ts

@@ -0,0 +1,18 @@
+import { IMapReader } from './reader/MapReader';
+import { Settings } from './types/Settings';
+export interface PathSegment {
+    points: number[];
+}
+export interface PathInnerMarker {
+    room: MapData.Room;
+    direction: MapData.direction;
+}
+export interface PathCustomLine {
+    points: number[];
+}
+export interface PathResult {
+    segments: PathSegment[];
+    innerMarkers: PathInnerMarker[];
+    customLines: PathCustomLine[];
+}
+export declare function computePathData(mapReader: IMapReader, settings: Settings, locations: number[], currentArea: number, currentZIndex: number): PathResult;

package/dist/PathFinder.d.ts

@@ -0,0 +1,12 @@
+import { IMapReader } from './reader/MapReader';
+export type PathFindingAlgorithm = 'dijkstra' | 'astar';
+export default class PathFinder {
+    private readonly mapGraph;
+    private readonly dijkstraGraph;
+    private _algorithm;
+    private readonly cache;
+    constructor(mapReader: IMapReader, algorithm?: PathFindingAlgorithm);
+    get algorithm(): PathFindingAlgorithm;
+    setAlgorithm(algorithm: PathFindingAlgorithm): void;
+    findPath(from: number, to: number): number[] | null;
+}