mudlet-map-editor 0.21.0 → 0.22.0

package/dist-lib/components/MapDiffModal.d.ts

@@ -0,0 +1,3 @@
+export declare function MapDiffModal({ onClose }: {
+    onClose: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist-lib/components/Toolbar.d.ts

@@ -5,7 +5,7 @@ import type { ToolbarAction } from '../editor/plugin';
  *  `null` — is rendered as-is, so a plugin can explicitly hide the slot.
  *  `transformActions` is the composed plugin transform applied to the built-in
  *  file-action list (see EditorPlugin#toolbarActions). */
-export declare function Toolbar({ title, logo, transformActions, onHelpClick, onLoadFromUrl, onSave, onSearchClick, onSettingsClick }: {
+export declare function Toolbar({ title, logo, transformActions, onHelpClick, onLoadFromUrl, onSave, onSearchClick, onSettingsClick, onDiffClick }: {
     title?: string;
     logo?: ReactNode;
     transformActions?: (actions: ToolbarAction[]) => ToolbarAction[];
@@ -14,4 +14,5 @@ export declare function Toolbar({ title, logo, transformActions, onHelpClick, on
     onSave?: (bytes: Uint8Array) => void;
     onSearchClick?: () => void;
     onSettingsClick?: () => void;
+    onDiffClick?: () => void;
 }): import("react/jsx-runtime").JSX.Element;

package/dist-lib/editor/diff/DiffHighlightOverlay.d.ts

@@ -0,0 +1,48 @@
+import type { SceneOverlay, SceneOverlayContext, Shape } from 'mudlet-map-renderer';
+import type { MudletMap } from '../../mapIO';
+import type { MapDiff } from './mapDiff';
+export type DiffStatus = 'added' | 'deleted' | 'changed';
+/** Stable keys shared between the sidebar entries and the pane highlights. */
+export declare const roomKey: (status: DiffStatus, id: number) => string;
+export declare const labelKey: (status: DiffStatus, areaId: number, labelId: number) => string;
+/** A room/label to tint, in renderer world space (renderY = -rawY). */
+export interface DiffHighlight {
+    key: string;
+    renderX: number;
+    renderY: number;
+    z: number;
+    area: number;
+    status: DiffStatus;
+    /** Half-extents of the rect in world units (room half-size, or label w/2 & h/2). */
+    halfX: number;
+    halfY: number;
+}
+/**
+ * A {@link SceneOverlay} that tints changed rooms/labels for the currently
+ * displayed area + z-level. Filtering by view keeps each pane in sync with its
+ * `drawArea(area, z)` call.
+ */
+export declare class DiffHighlightOverlay implements SceneOverlay {
+    private readonly highlights;
+    private ctx?;
+    private area;
+    private z;
+    private enabled;
+    private hoverKey;
+    constructor(highlights: DiffHighlight[]);
+    attach(ctx: SceneOverlayContext): void;
+    detach(): void;
+    setView(area: number, z: number): void;
+    setEnabled(enabled: boolean): void;
+    setHoverKey(key: string | null): void;
+    render(): Shape | Shape[] | void;
+}
+/**
+ * Build the highlight list for one side of the diff.
+ *
+ * @param diff   the computed diff (v1 = old / left, v2 = new / right)
+ * @param map    the map shown on this side (used to resolve coords of changed rooms/labels)
+ * @param side   'old' shows deletions + changes, 'new' shows additions + changes
+ * @param roomSize  renderer room size (world units)
+ */
+export declare function collectHighlights(diff: MapDiff, map: MudletMap, side: 'old' | 'new', roomSize: number): DiffHighlight[];

package/dist-lib/editor/diff/diffScene.d.ts

@@ -0,0 +1,27 @@
+import { MapRenderer } from 'mudlet-map-renderer';
+import type { MudletMap } from '../../mapIO';
+import { EditorMapReader } from '../reader/EditorMapReader';
+import { DiffHighlightOverlay } from './DiffHighlightOverlay';
+import type { MapDiff } from './mapDiff';
+export interface DiffPane {
+    renderer: MapRenderer;
+    reader: EditorMapReader;
+    overlay: DiffHighlightOverlay;
+    setView(areaId: number, z: number): void;
+    /** Show or hide the diff highlight tints. */
+    setHighlightsEnabled(enabled: boolean): void;
+    /** Emphasize a single change by its key (or clear with null). */
+    setHover(key: string | null): void;
+    /** Pan to a map-space room/point (raw Mudlet coords; Y is flipped internally). */
+    panToRoom(rawX: number, rawY: number): void;
+    destroy(): void;
+}
+/** A bare, read-only renderer pane for one side of a map diff. */
+export declare function createDiffPane(map: MudletMap, container: HTMLDivElement, diff: MapDiff, side: 'old' | 'new'): DiffPane;
+/** Copy zoom + center from one pane to another (programmatic; emits no events). */
+export declare function alignCamera(from: DiffPane, to: DiffPane): void;
+/**
+ * Mirror pan/zoom between two panes. Returns an unsubscribe function.
+ * Reentrancy is guarded so a mirrored move does not echo back.
+ */
+export declare function linkCameras(a: DiffPane, b: DiffPane): () => void;

package/dist-lib/editor/diff/mapDiff.d.ts

@@ -0,0 +1,47 @@
+import type { MudletMap, MudletRoom } from '../../mapIO';
+import type { MudletLabel, MudletArea } from 'mudlet-map-binary-reader';
+export interface PropertyChange {
+    from: any;
+    to: any;
+}
+export type PropertyDiff = Record<string, PropertyChange>;
+export interface EntityDiff<T> {
+    added: T[];
+    deleted: T[];
+    updated: Record<string, PropertyDiff>;
+}
+export interface MapDiff {
+    rooms: EntityDiff<MudletRoom & {
+        id: number;
+    }>;
+    labels: EntityDiff<MudletLabel & {
+        areaId: number;
+    }>;
+    areas: EntityDiff<MudletArea & {
+        id: number;
+    }>;
+    map: PropertyDiff;
+}
+export declare function getPropertyDiff(obj1: unknown, obj2: unknown): PropertyDiff;
+/** Compute a structural diff between two in-memory maps (v1 = old, v2 = new). */
+export declare function computeMapDiff(v1: MudletMap, v2: MudletMap): MapDiff;
+export interface DiffCounts {
+    rooms: {
+        added: number;
+        deleted: number;
+        updated: number;
+    };
+    labels: {
+        added: number;
+        deleted: number;
+        updated: number;
+    };
+    areas: {
+        added: number;
+        deleted: number;
+        updated: number;
+    };
+    map: number;
+    total: number;
+}
+export declare function countDiff(diff: MapDiff): DiffCounts;

package/dist-lib/i18n/locales/en.d.ts

@@ -13,6 +13,8 @@ export declare const en: {
         readonly fit: "Fit";
         readonly search: "Search";
         readonly searchTitle: "Search rooms and labels ({{modKey}}+F)";
+        readonly diff: "Diff";
+        readonly diffTitle: "Compare this map with another file";
         readonly rendererSettings: "Renderer settings";
         readonly helpTitle: "Help (keyboard shortcuts)";
         readonly snapTitle: "Snap to grid (G)";

package/dist-lib/i18n/locales/modals.en.d.ts

@@ -29,6 +29,22 @@ export declare const modalsEn: {
         readonly load: "Load";
         readonly corsNote: "The server must allow cross-origin requests (CORS). If loading fails, download the file and use \"Load .dat\" instead.";
     };
+    readonly diff: {
+        readonly title: "Changes this session";
+        readonly sessionStart: "Session start";
+        readonly now: "Now";
+        readonly computing: "Computing diff…";
+        readonly noChanges: "No changes this session";
+        readonly highlights: "Highlight changes";
+        readonly area: "Area";
+        readonly level: "Level";
+        readonly rooms: "Rooms";
+        readonly labels: "Labels";
+        readonly areas: "Areas";
+        readonly label: "Label";
+        readonly mapProps: "Map properties";
+        readonly dragHint: "Drag to resize";
+    };
 };
 export type ModalsLocale = {
     [K in keyof typeof modalsEn]: {