@ahrowe/ui 0.41.2 → 0.42.0

package/dist/types/common/floorPlan/floorPlan.graph.d.ts

@@ -5,6 +5,13 @@ import { PlanEdit, PlanFloor, PlanIssue, PlanNode, PlanOpening, PlanPoint, PlanW
  * reproducible.
  */
 export declare function newId(prefix: string): string;
+/**
+ * The first of `nameFor(start)`, `nameFor(start + 1)`, … that `used` does not hold.
+ *
+ * Bounded because `nameFor` is the caller's: one that ignores its number would never reach a
+ * free name. An injective one always finds one within `used.size + 1` tries.
+ */
+export declare function freshName(nameFor: (n: number) => string, start: number, used: ReadonlySet<string>): string;
 /** Test-only: makes generated ids reproducible within a single test. */
 export declare function __resetIdSeq(): void;
 declare function wallLength(floor: PlanFloor, wall: PlanWall): number;
@@ -157,9 +164,9 @@ export declare function transformPlan(floor: PlanFloor, dx: number, dy: number):
 /**
  * Multiplies every coordinate and dimension by `factor`.
  *
- * The one place a scale factor belongs: converting a unitless legacy plan into the
- * module's millimetre invariant, once, at the import boundary. The caller picks the
- * factor, because nothing in the old data says what it should be.
+ * The one place a scale factor belongs: converting geometry drawn in another unit into
+ * the module's millimetre invariant, once, where it enters. The caller picks the factor,
+ * because nothing in the data says what it should be.
  */
 export declare function scalePlan(floor: PlanFloor, factor: number): PlanFloor;
 export declare function addOpening(floor: PlanFloor, opening: Omit<PlanOpening, 'id'>): PlanEdit<{

package/dist/types/common/floorPlan/floorPlan.plan.d.ts

@@ -34,6 +34,11 @@ export declare function floorIndex(plan: FloorPlan, floorId: string): number;
 export declare function floorBelow(plan: FloorPlan, floorId: string): PlanFloor | null;
 export interface AddFloorOptions {
     label?: string;
+    /**
+     * Names the floor when `label` is not given. `n` is the floor count plus one, moved past
+     * any number whose name is taken. Default `` (n) => `Floor ${n}` ``.
+     */
+    nameFor?: (n: number) => string;
     /** Millimetres. Defaults to the storey height of the floor it is added above. */
     height?: number;
     /** Where to put it. Defaults to directly above `aboveFloorId`, else on top. */

package/dist/types/common/floorPlan/floorPlan.rooms.d.ts

@@ -22,8 +22,12 @@ export declare function derivePlan(floor: PlanFloor): PlanDerivation;
 /** Test-only: makes the room sequence counter reproducible. */
 export declare function __resetRoomSeq(): void;
 export interface CommitDerivationOptions {
-    /** Names new rooms. Receives the 1-based index among rooms created in this call. */
-    nameFor?: (index: number, face: DerivedRoom) => string;
+    /**
+     * Names a new room. `n` is the floor's room count plus one, moved past any number whose
+     * name is taken, so `` (n) => `Raum ${n}` `` numbers rooms the way the default does.
+     * Default `` (n) => `Room ${n}` ``.
+     */
+    nameFor?: (n: number, face: DerivedRoom) => string;
 }
 /**
  * Mints a `PlanRoom` for every face that matched nothing.

package/dist/types/common/floorPlan/floorPlan.snap.d.ts

@@ -35,7 +35,7 @@ export interface SnapOptions {
 export declare const DEFAULT_SNAP_OPTIONS: SnapOptions;
 export interface SnapContext {
     floor: PlanFloor;
-    /** World units per screen pixel at the current zoom. See `screenScale`. */
+    /** World units per screen pixel at the current zoom: `1 / view.zoom`. */
     pxToWorld: number;
     /** The anchored point. Required for angle lock; also enables the length readout. */
     origin?: PlanPoint;
@@ -70,8 +70,6 @@ export interface SnapResult {
      */
     angleRelativeTo?: 'world' | 'reference';
 }
-/** World units per screen pixel, from the element's current transform. */
-export declare function screenScale(svg: SVGSVGElement): number;
 /**
  * Client (screen) coordinates to world coordinates. Pure conversion, no snapping.
  *

package/dist/types/common/floorPlan/index.d.ts

@@ -18,7 +18,7 @@ export { HIT_PX, HIT_PX_COARSE, hitTest, selectionsEqual, worldTolerances } from
 export type { HitTestOptions, HitTolerances } from './floorPlan.hit.js';
 export { DEFAULT_WALL_ATTRS, addOpening, addRect, addWall, cleanupPlan, detachWall, dissolveNode, mergeNodes, moveNode, removeOpening, removeWall, scalePlan, splitWall, transformPlan, updateOpening, validatePlan, wallLength, weldShortWalls, } from './floorPlan.graph.js';
 export type { DetachWallResult, DissolveNodeOptions, ResolveNodeResult, SplitWallResult, WallAttrs, } from './floorPlan.graph.js';
-export { DEFAULT_SNAP_OPTIONS, SnapKind, clientToWorld, resolveSnap, screenScale } from './floorPlan.snap.js';
+export { DEFAULT_SNAP_OPTIONS, SnapKind, clientToWorld, resolveSnap } from './floorPlan.snap.js';
 export type { SnapContext, SnapGuide, SnapOptions, SnapResult } from './floorPlan.snap.js';
 export { buildWallPaths, openingGeometry, wallCentrelineSpans } from './floorPlan.path.js';
 export type { BuildWallPathsOptions, WallCapLine, WallCapReason, WallPathGroup, WallPathResult, } from './floorPlan.path.js';
@@ -26,5 +26,3 @@ export { PLAN_FORMAT_VERSION, planFromJson, planToJson } from './floorPlan.json.
 export type { PlanParseResult } from './floorPlan.json.js';
 export { buildPlanMesh } from './floorPlan.mesh.js';
 export type { BuildPlanMeshOptions, PlanMesh, PlanMeshGroup, PlanMeshPart } from './floorPlan.mesh.js';
-export { planFromLegacySvg } from './legacySvg.js';
-export type { LegacyImportOptions } from './legacySvg.js';

package/dist/types/common/planCanvas/planCanvas.types.d.ts

@@ -33,7 +33,7 @@ export interface PlanCanvasProps {
         area: number;
         faceId: string;
     }) => ReactNode;
-    /** Accessible name for a room. */
+    /** Accessible name for an interactive room. RoomViewer supplies the default, from its labels. */
     getRoomLabel?: (room: PlanRoom | null, context: {
         area: number;
     }) => string;

package/dist/types/common/roomDrawer/roomDrawer.types.d.ts

@@ -27,7 +27,10 @@ export interface RoomDrawerChangeMeta {
     /** Ids of whatever the change touched, for syncing an external selection. */
     targetIds: string[];
 }
-/** Every string the drawer's own chrome renders, for localisation. */
+/**
+ * Every string the drawer produces of its own, for localisation: its chrome, and the names it
+ * gives the rooms and floors it creates, which are stored in the plan.
+ */
 export interface RoomDrawerLabels {
     /** The toolbar, read out by screen readers. */
     tools?: string;
@@ -54,12 +57,21 @@ export interface RoomDrawerLabels {
     floorHeight?: string;
     moveFloorUp?: string;
     moveFloorDown?: string;
+    /** Name of a new room. `n` counts the floor's rooms, skipping names already taken. */
+    newRoomName?: (n: number) => string;
+    /** Name of a floor added with the `+` button. `n` counts the floors, skipping names already taken. */
+    newFloorName?: (n: number) => string;
+    /** Name of a copied floor, from the name of the floor it copies. */
+    copiedFloorName?: (name: string) => string;
+    /** Name of the one floor an empty plan starts with, uncontrolled or after `clear()`. */
+    initialFloorName?: string;
     /** The inspector's noun for a floor, shown when nothing is selected. */
     selectedFloor?: string;
     /** Shown in the hint line when an opened file could not be read at all. */
     importFailed?: string;
     snap?: string;
-    angleLock?: string;
+    /** The angle lock toggle, given `constrainAngle`. */
+    angleLock?: (angle: number) => string;
     grid?: string;
     zoomIn?: string;
     zoomOut?: string;
@@ -69,22 +81,27 @@ export interface RoomDrawerLabels {
     thickness?: string;
     width?: string;
     sill?: string;
-    head?: string;
     deleteSelection?: string;
-    /** Shown when several things are selected. `{count}` is replaced with the number. */
-    selectedCount?: string;
+    /** What the inspector calls several things selected at once. */
+    selectedCount?: (count: number) => string;
     /** What the inspector calls the current selection. */
-    selectedNothing?: string;
     selectedRoom?: string;
     selectedWall?: string;
     selectedCorner?: string;
-    /** Overrides the opening's own kind, which is used by default. */
-    selectedOpening?: string;
+    selectedDoor?: string;
+    selectedWindow?: string;
+    selectedArchway?: string;
+    selectedGap?: string;
+    /** Hint for the select tool with `multiSelect` on. */
     hintSelect?: string;
+    /** Hint for the select tool with `multiSelect` off. */
+    hintSelectSingle?: string;
     hintWall?: string;
     hintRect?: string;
     hintMeasure?: string;
     hintOpening?: string;
+    /** A drawing angle measured from the previous wall, given the formatted angle. */
+    relativeAngle?: (angle: string) => string;
 }
 /** Every icon in the chrome is overridable. */
 export interface RoomDrawerIcons {
@@ -259,6 +276,10 @@ export interface RoomDrawerProps extends Omit<HtmlProps<HTMLDivElement>, 'onChan
     showMeasurements?: boolean;
     formatLength?: (lengthMm: number) => string;
     formatArea?: (areaMm2: number) => string;
+    /** A drawing angle, in degrees from -180 to 180. */
+    formatAngle?: (degrees: number) => string;
+    /** The zoom readout. `zoom` is screen pixels per millimetre, so `1` reads as 100%. */
+    formatZoom?: (zoom: number) => string;
     showToolbar?: boolean;
     showInspector?: boolean;
     showHint?: boolean;

package/dist/types/common/roomViewer/roomViewer.types.d.ts

@@ -10,8 +10,10 @@ export interface RoomViewerLabels {
     zoomOut?: string;
     fit?: string;
     empty?: string;
-    /** Announced when a room is selected. `{name}` and `{area}` are replaced. */
-    selectedRoom?: string;
+    /** Stands in for the name of a room that has none. */
+    unnamedRoom?: string;
+    /** Announced when a room is selected, given its name and its formatted area. */
+    selectedRoom?: (name: string, area: string) => string;
     /** Announced when the selection is cleared. */
     noRoomSelected?: string;
 }

package/docs/CLAUDE.md

@@ -39,7 +39,9 @@ enums and slot names. Do not infer props from a component's name.
   Input, Textarea, NumberInput and SearchInput hand out their inner `<input>`. Timer, Flip, Tilt,
   Ripple, VirtualList, RoomDrawer and RoomViewer expose an imperative handle instead; its type is
   exported next to the props.
-- Every module is `'use client'`; nothing renders on the server. No right-to-left support.
+- Every module is `'use client'`; nothing renders on the server. The exception is
+  `@ahrowe/ui/floor-plan`, the plan model (FloorPlan.md) without React, for server code that reads
+  or validates a plan. No right-to-left support.
   `prefers-reduced-motion` is honoured. Built for Chrome and Edge 111, Firefox 114, Safari 16.4
   and newer, with no polyfills. The package is 0.x: a minor can break, a patch cannot.
 

package/docs/FloorPlan.md

@@ -4,7 +4,7 @@
 
 **Keywords:** blueprint, cad, grundriss, apartment, building, storey, partition, area calculation, planar graph, half-edge, extrusion
 
-**Import:** `import { emptyFloorPlan, addWall, derivePlan } from '@ahrowe/ui'`
+**Import:** `import { emptyFloorPlan, addWall, derivePlan } from '@ahrowe/ui'`, or from `'@ahrowe/ui/floor-plan'` where there is no React
 **Types:** `import type { FloorPlan, PlanFloor, PlanNode, PlanWall, PlanOpening, PlanRoom, DerivedRoom, PlanPoint, PlanView, PlanSelection } from '@ahrowe/ui'`
 
 `PlanPoint`, `PlanView` and `PlanSelection` are the ones that also appear in `RoomDrawer` and `RoomViewer` props. Every exported function's own option and result types come with it — `WallAttrs`, `SplitWallResult`, `WallPathResult` and the rest.
@@ -80,7 +80,7 @@ const { floor: refreshed, rooms, issues } = derivePlan(floor);
 
 `derivePlan` extracts the faces and attaches stored metadata. It is pure and **never creates or deletes a `PlanRoom`**, so it is safe to call on every render. Memoise it on `plan.revision`, which every mutation bumps.
 
-`commitDerivation(floor)` mints a `PlanRoom` for each face that matched nothing — call it once per committed edit, not per render.
+`commitDerivation(floor, options?)` mints a `PlanRoom` for each face that matched nothing — call it once per committed edit, not per render. It names them `Room 1`, `Room 2`, … counting the floor's rooms and skipping any name already taken; `nameFor: (n, face) => string` replaces the name with the same numbering, so `` (n) => `Raum ${n}` `` gives `Raum 3` on a floor with two rooms. `addFloor` takes the same `nameFor` for `Floor 2`, `Floor 3`, …, and `duplicateFloor` a `label` in place of `<name> copy`.
 
 Each `DerivedRoom` carries the face (`outer`, `holes`, `area`, `perimeter`, `wallIds`), the matched `meta`, and an `anchor` guaranteed to be **inside** the polygon (an area centroid can fall outside a concave room, so it is computed, not averaged).
 
@@ -172,6 +172,22 @@ else if (issues.length) console.warn(issues);   // loaded, but repaired
 
 `revision` is bumped on load, since `derivePlan` memoises on it and the repaired plan is not the one the file described.
 
+### On a server
+
+`@ahrowe/ui/floor-plan` is the whole model, and only the model: every function and type on this page, with no React, react-dom or FontAwesome behind it and no `'use client'` in front of it. That is what lets a Node server check a plan with the same code the client drew it with, instead of storing whatever it was sent.
+
+```ts
+import { planFromJson, validatePlan } from '@ahrowe/ui/floor-plan';
+
+export function readPlan(json: string) {
+  const { plan, issues } = planFromJson(json);
+  if (!plan) throw new Error(issues.join('; '));
+  return { plan, repaired: issues, broken: plan.floors.flatMap((floor) => validatePlan(floor)) };
+}
+```
+
+`@ahrowe/ui` exports the same functions, so client code can keep importing from there.
+
 ## Snapping and pointer input
 
 ```tsx
@@ -195,18 +211,6 @@ const issues = validatePlan(floor); // O(walls²) — development and tests, not
 
 The invariant that matters: **no two walls may cross without a node at the intersection, and no node may sit on a wall's interior without that wall being split there.** Break either and the face walk silently merges two rooms into one figure-eight face with no error anywhere, which is why `UnsplitCrossing` and `UnsplitNodeOnWall` exist as explicit issue kinds. Everything built through `addWall` maintains this automatically.
 
-## Importing older plans
-
-```tsx
-import { planFromLegacySvg } from '@ahrowe/ui';
-
-// The old canvas was unitless; pick the factor that makes it millimetres.
-// A 400-unit-wide export meant to be a 12m house wants scale: 30.
-const plan = planFromLegacySvg(svgText, { scale: 30 });
-```
-
-Feeding every legacy polygon edge through `addWall` is what collapses the old duplicated walls: the second room's copy of a shared edge resolves to the same two nodes and is recognised as already walled. Room names carry across, and doors are recovered where the old swing-arc path is recognisable; anything that is not is skipped rather than guessed at.
-
 ## Ready for 3D
 
 `buildPlanMesh(floor, options?)` turns a storey into triangles: wall solids with their openings cut out, and a slab under each room.

package/docs/RoomDrawer.md

@@ -246,7 +246,7 @@ ref.current?.deleteSelection();
 | `wallThickness` / `wallHeight` | `number` | Millimetres, applied to newly drawn walls |
 | `openingDefaults` | `Partial<Record<OpeningKind, { width?, sill?, head? }>>` | Size of newly placed openings |
 | `showMeasurements` | `boolean` | Live length, angle and area readouts while drawing (default `true`) |
-| `formatLength` / `formatArea` | `(mm) => string` | Override the readouts |
+| `formatLength` / `formatArea` / `formatAngle` / `formatZoom` | `(value) => string` | Override the readouts: millimetres, mm², degrees from -180 to 180, and zoom in screen px per mm. See [Localisation](#localisation) |
 | `showToolbar` / `showInspector` / `showHint` / `showHistoryControls` / `showFileControls` / `showFloorBar` | `boolean` | Hide parts of the chrome |
 | `floorId` / `defaultFloorId` / `onFloorChange` | `string` / `string` / `(id) => void` | Which storey is being edited |
 | `showUnderlay` | `boolean` | Trace the storey below behind this one (default `true`) |
@@ -258,7 +258,7 @@ ref.current?.deleteSelection();
 | `disabled` | `boolean` | No interaction at all |
 | `canvasHeight` | `string` | Any CSS length (default `'420px'`) |
 | `getRoomColor` / `renderRoomLabel` | | Per-room fill colour and label content |
-| `labels` / `icons` | `RoomDrawerLabels` / `RoomDrawerIcons` | Localise or re-icon the chrome |
+| `labels` / `icons` | `RoomDrawerLabels` / `RoomDrawerIcons` | Localise or re-icon the chrome, and name new rooms and floors |
 
 `RoomDrawerProps` extends the full native `div` attribute set plus `data-*`, so `id`, `title`, `aria-*` and the rest pass through to the root.
 
@@ -292,7 +292,7 @@ Floors are part of the plan document, so they survive a download and reopen with
 
 A bar under the canvas shows what is selected and what can be done with it: a name for a room, thickness for a wall, width and sill for an opening, and delete for any of them. It is **always there and always the same height**, including when nothing is selected — it used to appear on selection and size itself to its contents, which moved the canvas out from under the pointer by up to 116px as you clicked between a corner and a wall.
 
-Each selection is named on the left (`Room`, `Wall`, `Door`, `Corner`, `3 selected`), which is the whole content of the bar for a corner: a corner has nothing to edit that dragging it does not already do. Delete sits at the far end, apart from the fields, since it is the one action that applies to every kind of selection and the only destructive one. Override any of the names through `labels` (`selectedRoom`, `selectedWall`, `selectedCorner`, `selectedOpening`, `selectedCount`, `selectedNothing`), and hide the bar with `showInspector={false}`.
+Each selection is named on the left (`Room`, `Wall`, `Door`, `Corner`, `3 selected`), which is the whole content of the bar for a corner: a corner has nothing to edit that dragging it does not already do. Delete sits at the far end, apart from the fields, since it is the one action that applies to every kind of selection and the only destructive one. Override any of the names through `labels` (`selectedRoom`, `selectedWall`, `selectedCorner`, `selectedDoor`, `selectedWindow`, `selectedArchway`, `selectedGap`, `selectedCount`), and hide the bar with `showInspector={false}`.
 
 **Sill**, on an opening, is how far above the floor it starts: 0 for a door, around 900 for a window. It changes nothing in the plan, because a plan is a horizontal cut and every opening looks the same from above. It is stored so the same plan can drive a 3D view later without anyone having to supply the heights again — as are `head` (the top of the opening), `PlanWall.height` and `PlanFloor.elevation`.
 
@@ -358,20 +358,49 @@ Stated plainly: **a free-form drawing canvas cannot be fully operated from a key
 
 The root is `role="application"` (justified here, since single-letter keys are intercepted), the toolbar is a real `role="toolbar"` of `<button>`s with `aria-pressed`, and room labels render with a halo so they stay legible over any fill colour a consumer sets.
 
-## Global defaults
+## Localisation
 
-Adopts `ConfigProvider`, e.g. `defaultProps={{ RoomDrawer: { gridSize: 250, showGrid: false } }}`. See [ConfigProvider.md](ConfigProvider.md).
+Every string the drawer produces goes through `labels`, and every number it prints through a `format*` prop. Set them once, app-wide: labels merge per key, so an instance that overrides one string keeps the rest.
+
+Some of those strings end up **in the plan**, not only on screen: the names of the rooms and floors the drawer creates. A plan saved before they were translated keeps "Room 1" and "Ground floor" for good, so set them from the start.
 
-## Migration from the previous version
+```tsx
+const number = new Intl.NumberFormat('de-AT', { maximumFractionDigits: 1 });
+const percent = new Intl.NumberFormat('de-AT', { style: 'percent', maximumFractionDigits: 1 });
+
+<AhroweProvider
+  defaultProps={{
+    RoomDrawer: {
+      labels: {
+        newRoomName: (n) => `Raum ${n}`,
+        newFloorName: (n) => `Etage ${n}`,
+        copiedFloorName: (name) => `${name} (Kopie)`,
+        initialFloorName: 'Erdgeschoss',
+        angleLock: (angle) => `Auf ${angle}°-Schritte einrasten`,
+        selectedCount: (count) => `${count} ausgewählt`,
+        selectedDoor: 'Tür',
+        hintSelect: 'Ecke ziehen zum Umformen · …',
+        hintSelectSingle: 'Ecke ziehen zum Umformen · …',
+      },
+      formatLength: (mm) => `${number.format(mm / 1000)} m`,
+      formatArea: (mm2) => `${number.format(mm2 / 1e6)} m²`,
+      formatAngle: (degrees) => `${number.format(degrees)}°`,
+      formatZoom: (zoom) => percent.format(zoom),
+    },
+  }}
+>
+  <App />
+</AhroweProvider>
+```
 
-The previous `RoomDrawer` had no data contract at all: `RoomDrawerProps` was `{ className }`, and the only way data left the component was a browser file download. Everything below is new rather than changed, so the old usage still renders, it just starts empty.
+A label that carries a value is a function of it: `angleLock` gets `constrainAngle`, `selectedCount` the count, `copiedFloorName` the name of the floor being copied, and `newRoomName` and `newFloorName` the next number whose name is not taken yet. `hintSelect` is the hint with `multiSelect` on and `hintSelectSingle` the one with it off. `formatZoom` gets screen pixels per millimetre, which is the fraction `Intl`'s `percent` style expects.
 
-- `Tool`, `RoomData`, `DoorData`, `Point` are gone. Use `RoomDrawerTool` and the `FloorPlan` model.
-- `selection` is an array rather than a single entry, since the drawer supports multi-select. A single selection is `[entry]`, and nothing selected is `[]` rather than `null`.
-- The SVG download and upload buttons are gone. The plan JSON is the interchange format now. To read an SVG exported by the old version, use `planFromLegacySvg` (see [FloorPlan.md](FloorPlan.md)), which also collapses each duplicated room boundary into the single shared wall it should have been.
-- The `polygon` tool is now `wall`, which draws open chains as well as closed ones.
-- Removing a corner was a double-click, which was undiscoverable and impossible on touch. Select it and press `Delete` instead.
+Two texts are not in `labels`. The root's accessible name is the `aria-label` prop (default "Floor plan editor"), which `defaultProps` can set as well. The repair report after opening a file is `planFromJson`'s list of English sentences, shown as it comes; `onImport` receives it too, if you would rather show your own.
+
+## Global defaults
+
+Adopts `ConfigProvider`, e.g. `defaultProps={{ RoomDrawer: { gridSize: 250, showGrid: false } }}`. See [ConfigProvider.md](ConfigProvider.md).
 
 **Slots:** `root` `toolbar` `toolButton` `toolIcon` `viewControls` `viewButton` `zoomLabel` `canvasWrapper` `canvas` `grid` `rooms` `roomFill` `roomLabel` `walls` `wallBody` `openings` `opening` `overlay` `measureLine` `floorBar` `floorTab` `inspector` `inspectorLabel` `inspectorField` `hint`
 
-**Labels:** every string the drawer's own chrome renders, including `tools`, `storeyHeightHint` and `sillHeightHint`. Type: `RoomDrawerLabels`.
+**Labels:** every string the drawer's own chrome renders, including `tools`, `storeyHeightHint` and `sillHeightHint`, and the names it gives new rooms and floors. Type: `RoomDrawerLabels`.

package/docs/RoomViewer.md

@@ -72,7 +72,7 @@ Walls are drawn as mass rather than as ink: the body is `var(--text-color)` mixe
 | `getRoomColor` / `renderRoomLabel` / `getRoomLabel` / `formatArea` | functions | Colour, label and area rendering |
 | `height` | `number \| string` | Canvas height (default `360`) |
 | `emptyState` | `ReactNode` | Shown when there is no plan, or nothing in it |
-| `labels` / `icons` | objects | Every string and icon in the chrome |
+| `labels` / `icons` | objects | Every string and icon in the chrome. `selectedRoom` is `(name, area) => string`, and `unnamedRoom` stands in for a room with no name |
 
 **Imperative handle:** `fitToContent(options?)`, `getView()`, `setView(view)`, `zoomBy(factor)`, `select(roomId)`, `getFloorId()`, `setFloorId(id)`, `getSvgElement()`.
 
@@ -81,16 +81,3 @@ Walls are drawn as mass rather than as ink: the body is `var(--text-color)` mixe
 ## Accessibility, honestly
 
 A free-form plan cannot be fully keyboard operated, and this does not pretend otherwise. What it does give you: every room is a focusable `role="button"` with an accessible name, `Enter`/`Space` select, the floor tabs are real buttons, the zoom controls are real buttons, and the current selection is announced. Panning and zooming are pointer-only; the zoom buttons and `fitToContent()` are the keyboard path.
-
-## Migration from the previous version
-
-The old viewer took `data: { label, data: ReactNode }[]` — an array of **pre-rendered SVG elements** — and found rooms by looking for `id="room…"`, highlighting them by mutating `classList`. That is gone, and there is no shim: the old `data` was a React element rather than a string, so there is nothing to parse at runtime.
-
-| Before | Now |
-|--------|-----|
-| `data={[{ label, data: <svg/> }]}` | `plan={plan}` — one `FloorPlan`, floors and all |
-| `id="room12"` convention | `PlanRoom` ids in the model |
-| Highlighting via `classList` | `selectedRoomId` / `hoveredRoomId` |
-| No selection callback | `onSelect(roomId, room, floorId)` |
-
-To bring an old SVG across, run it through `planFromLegacySvg` once and keep the resulting plan. See [FloorPlan](./FloorPlan.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ahrowe/ui",
-  "version": "0.41.2",
+  "version": "0.42.0",
   "description": "A React UI component library with theming, CSS Modules, and TypeScript support",
   "keywords": [
     "agent",
@@ -39,6 +39,13 @@
   "main": "./dist/index.cjs",
   "module": "./dist/esm/index.mjs",
   "types": "./dist/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "floor-plan": [
+        "./dist/types/common/floorPlan/index.d.ts"
+      ]
+    }
+  },
   "exports": {
     ".": {
       "import": {
@@ -50,6 +57,16 @@
         "default": "./dist/index.cjs"
       }
     },
+    "./floor-plan": {
+      "import": {
+        "types": "./dist/types/common/floorPlan/index.d.ts",
+        "default": "./dist/esm/floor-plan.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs-types/common/floorPlan/index.d.ts",
+        "default": "./dist/floor-plan.cjs"
+      }
+    },
     "./style.css": "./dist/style.css",
     "./package.json": "./package.json"
   },

package/dist/cjs-types/common/floorPlan/legacySvg.d.ts

@@ -1,27 +0,0 @@
-import { scalePlan } from './floorPlan.graph.js';
-import { FloorPlan } from './floorPlan.types.js';
-export interface LegacyImportOptions {
-    /**
-     * Multiplies every imported coordinate, converting the old unitless canvas into the
-     * module's millimetre invariant.
-     *
-     * There is no correct automatic value: the old format records no scale at all. The
-     * default of 1 keeps the numbers as they were, which makes a typical 400x300 export
-     * a 40cm plan. A 400-unit-wide export meant to be a 12m house wants `scale: 30`.
-     */
-    scale?: number;
-    /** Wall thickness for imported walls, in millimetres after scaling. */
-    thickness?: number;
-    /** Tolerance for welding coincident endpoints, in millimetres after scaling. */
-    weldTolerance?: number;
-    label?: string;
-}
-/**
- * Parses a legacy exported SVG into a single-floor `FloorPlan`.
- *
- * Rooms keep their names. Doors are recovered where the old swing-arc path is
- * recognisable, as `OpeningKind.Door`. Windows and archways did not exist in that
- * format, so nothing is lost by not looking for them.
- */
-export declare function planFromLegacySvg(svg: string, options?: LegacyImportOptions): FloorPlan;
-export { scalePlan };

package/dist/esm/common/floorPlan/legacySvg.mjs

@@ -1,2 +0,0 @@
-"use client";import{OpeningKind as e,WallType as t}from"./floorPlan.types.mjs";import{DEFAULT_WALL_ATTRS as n,addOpening as r,addWall as i}from"./floorPlan.graph.mjs";import{emptyFloorPlan as a}from"./floorPlan.plan.mjs";import{commitDerivation as o,derivePlan as s}from"./floorPlan.rooms.mjs";function c(e){let t=[];for(let n of e.matchAll(/[ML]\s*(-?[\d.]+)[,\s]+(-?[\d.]+)/gi))t.push({x:parseFloat(n[1]),y:parseFloat(n[2])});return t}function l(e){let t=e.match(/^\s*M\s*(-?[\d.]+),(-?[\d.]+)\s*L\s*(-?[\d.]+),(-?[\d.]+)\s*M\s*(-?[\d.]+),(-?[\d.]+)\s*A\s/i);return t?{p1:{x:parseFloat(t[1]),y:parseFloat(t[2])},p2:{x:parseFloat(t[3]),y:parseFloat(t[4])}}:null}function u(e){let t=new DOMParser().parseFromString(e,`image/svg+xml`),n=[],r=[];return t.querySelectorAll(`[id^="room"]`).forEach(e=>{let t=e.querySelector(`[id="background"]`),i=t?.getAttribute(`d`);if(!i)return;let a=c(i);a.length<3||(n.push({name:e.querySelector(`text`)?.textContent?.trim()??``,points:a}),e.querySelectorAll(`path`).forEach(e=>{if(e===t)return;let n=l(e.getAttribute(`d`)??``);n&&r.push(n)}))}),{rooms:n,doors:r}}function d(c,l={}){let{scale:d=1,thickness:p=n.thickness,weldTolerance:m,label:h}=l,{rooms:g,doors:_}=u(c),v=a({floorLabel:h}),y=v.floors[0],b=m??Math.max(1,d*2);for(let e of g){let n=e.points.map(e=>({x:e.x*d,y:e.y*d}));for(let e=0;e<n.length;e++){let r=n[e],a=n[(e+1)%n.length];y=i(y,r,a,{thickness:p,type:t.Interior},b).floor}}for(let t of _){let n={x:t.p1.x*d,y:t.p1.y*d},i={x:t.p2.x*d,y:t.p2.y*d},a={x:(n.x+i.x)/2,y:(n.y+i.y)/2},o=Math.hypot(i.x-n.x,i.y-n.y);if(o<=0)continue;let s=null;for(let e of Object.values(y.walls)){let t=y.nodes[e.a],n=y.nodes[e.b];if(!t||!n)continue;let r=Math.hypot(n.x-t.x,n.y-t.y);if(r<1e-6)continue;let i=((a.x-t.x)*(n.x-t.x)+(a.y-t.y)*(n.y-t.y))/(r*r),o=Math.min(1,Math.max(0,i)),c=t.x+(n.x-t.x)*o,l=t.y+(n.y-t.y)*o,u=Math.hypot(a.x-c,a.y-l);u<=b&&(!s||u<s.dist)&&(s={wallId:e.id,offset:o*r,dist:u})}s&&(y=r(y,{wallId:s.wallId,kind:e.Door,offset:s.offset,width:o,sill:0,head:2100}).floor)}y=o(y).floor;let x=s(y).rooms;for(let e of g){if(!e.name)continue;let t={x:e.points.reduce((e,t)=>e+t.x,0)/e.points.length*d,y:e.points.reduce((e,t)=>e+t.y,0)/e.points.length*d},n=x.find(e=>e.roomId&&e.outer.length>2&&f(t,e.outer)&&y.rooms[e.roomId]?.name.startsWith(`Room `));n?.roomId&&(y={...y,rooms:{...y.rooms,[n.roomId]:{...y.rooms[n.roomId],name:e.name}}})}return{...v,floors:[y]}}function f(e,t){let n=!1;for(let r=0,i=t.length-1;r<t.length;i=r++){let a=t[r].x,o=t[r].y,s=t[i].x,c=t[i].y;o>e.y!=c>e.y&&e.x<(s-a)*(e.y-o)/(c-o)+a&&(n=!n)}return n}export{d as planFromLegacySvg};
-//# sourceMappingURL=legacySvg.mjs.map

package/dist/esm/common/floorPlan/legacySvg.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacySvg.mjs","names":[],"sources":["../../../../package/common/floorPlan/legacySvg.ts"],"sourcesContent":["/**\n * Imports floor plans exported by the previous `RoomDrawer` into the current model.\n *\n * The old format stored each room as its own closed polygon, so a wall between two\n * rooms appeared twice, once per room. Feeding every polygon edge through `addWall` is\n * what converts that: coincident edges resolve to the same nodes and the second one is\n * recognised as already walled, so the pair collapses into the single shared wall the\n * new model needs.\n *\n * Import only. Nothing writes this format any more. See LEGACY_SVG_FORMAT.md in this\n * folder for the specification of what is accepted.\n */\n\nimport { DEFAULT_WALL_ATTRS, addOpening, addWall, scalePlan } from './floorPlan.graph';\nimport { commitDerivation, derivePlan } from './floorPlan.rooms';\nimport { emptyFloorPlan } from './floorPlan.plan';\nimport { OpeningKind, WallType } from './floorPlan.types';\nimport type { FloorPlan, PlanFloor, PlanPoint } from './floorPlan.types';\n\nexport interface LegacyImportOptions {\n  /**\n   * Multiplies every imported coordinate, converting the old unitless canvas into the\n   * module's millimetre invariant.\n   *\n   * There is no correct automatic value: the old format records no scale at all. The\n   * default of 1 keeps the numbers as they were, which makes a typical 400x300 export\n   * a 40cm plan. A 400-unit-wide export meant to be a 12m house wants `scale: 30`.\n   */\n  scale?: number;\n  /** Wall thickness for imported walls, in millimetres after scaling. */\n  thickness?: number;\n  /** Tolerance for welding coincident endpoints, in millimetres after scaling. */\n  weldTolerance?: number;\n  label?: string;\n}\n\ninterface LegacyRoom {\n  name: string;\n  points: PlanPoint[];\n}\n\ninterface LegacyDoor {\n  p1: PlanPoint;\n  p2: PlanPoint;\n}\n\n/** Reads the absolute M/L commands the old exporter wrote. */\nfunction parseClosedPath(d: string): PlanPoint[] {\n  const points: PlanPoint[] = [];\n  for (const m of d.matchAll(/[ML]\\s*(-?[\\d.]+)[,\\s]+(-?[\\d.]+)/gi)) {\n    points.push({ x: parseFloat(m[1]), y: parseFloat(m[2]) });\n  }\n  return points;\n}\n\n/**\n * Recovers a door from the old swing-arc path: `M p1 L p2 M p1 A w,w 0 0,1 end`.\n *\n * Position and width follow from p1 and p2. Anything that does not match this shape is\n * skipped and the wall is left solid, rather than guessed at.\n */\nfunction parseDoorPath(d: string): LegacyDoor | null {\n  const match = d.match(/^\\s*M\\s*(-?[\\d.]+),(-?[\\d.]+)\\s*L\\s*(-?[\\d.]+),(-?[\\d.]+)\\s*M\\s*(-?[\\d.]+),(-?[\\d.]+)\\s*A\\s/i);\n  if (!match) return null;\n  return {\n    p1: { x: parseFloat(match[1]), y: parseFloat(match[2]) },\n    p2: { x: parseFloat(match[3]), y: parseFloat(match[4]) },\n  };\n}\n\nfunction parseLegacyDocument(svg: string): { rooms: LegacyRoom[]; doors: LegacyDoor[] } {\n  const doc = new DOMParser().parseFromString(svg, 'image/svg+xml');\n  const rooms: LegacyRoom[] = [];\n  const doors: LegacyDoor[] = [];\n\n  doc.querySelectorAll('[id^=\"room\"]').forEach((group) => {\n    const background = group.querySelector('[id=\"background\"]');\n    const d = background?.getAttribute('d');\n    if (!d) return;\n    const points = parseClosedPath(d);\n    if (points.length < 3) return;\n    rooms.push({ name: group.querySelector('text')?.textContent?.trim() ?? '', points });\n\n    group.querySelectorAll('path').forEach((path) => {\n      if (path === background) return;\n      const door = parseDoorPath(path.getAttribute('d') ?? '');\n      if (door) doors.push(door);\n    });\n  });\n\n  return { rooms, doors };\n}\n\n/**\n * Parses a legacy exported SVG into a single-floor `FloorPlan`.\n *\n * Rooms keep their names. Doors are recovered where the old swing-arc path is\n * recognisable, as `OpeningKind.Door`. Windows and archways did not exist in that\n * format, so nothing is lost by not looking for them.\n */\nexport function planFromLegacySvg(svg: string, options: LegacyImportOptions = {}): FloorPlan {\n  const { scale = 1, thickness = DEFAULT_WALL_ATTRS.thickness, weldTolerance, label } = options;\n  const { rooms, doors } = parseLegacyDocument(svg);\n\n  const plan = emptyFloorPlan({ floorLabel: label });\n  let floor: PlanFloor = plan.floors[0];\n  // Generous relative to the old canvas, where coordinates were snapped to a grid of 5.\n  const tol = weldTolerance ?? Math.max(1, scale * 2);\n\n  for (const room of rooms) {\n    const points = room.points.map((p) => ({ x: p.x * scale, y: p.y * scale }));\n    for (let i = 0; i < points.length; i++) {\n      const a = points[i];\n      const b = points[(i + 1) % points.length];\n      // The welding step: an edge an adjacent room already drew resolves to the same\n      // two nodes, and addWall declines to duplicate it.\n      floor = addWall(floor, a, b, { thickness, type: WallType.Interior }, tol).floor;\n    }\n  }\n\n  for (const door of doors) {\n    const p1 = { x: door.p1.x * scale, y: door.p1.y * scale };\n    const p2 = { x: door.p2.x * scale, y: door.p2.y * scale };\n    const centre = { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 };\n    const width = Math.hypot(p2.x - p1.x, p2.y - p1.y);\n    if (width <= 0) continue;\n\n    // Find the wall the door sits on now that edges have been welded.\n    let best: { wallId: string; offset: number; dist: number } | null = null;\n    for (const wall of Object.values(floor.walls)) {\n      const a = floor.nodes[wall.a];\n      const b = floor.nodes[wall.b];\n      if (!a || !b) continue;\n      const len = Math.hypot(b.x - a.x, b.y - a.y);\n      if (len < 1e-6) continue;\n      const t = ((centre.x - a.x) * (b.x - a.x) + (centre.y - a.y) * (b.y - a.y)) / (len * len);\n      const clamped = Math.min(1, Math.max(0, t));\n      const px = a.x + (b.x - a.x) * clamped;\n      const py = a.y + (b.y - a.y) * clamped;\n      const d = Math.hypot(centre.x - px, centre.y - py);\n      if (d <= tol && (!best || d < best.dist)) {\n        best = { wallId: wall.id, offset: clamped * len, dist: d };\n      }\n    }\n    if (!best) continue;\n\n    floor = addOpening(floor, {\n      wallId: best.wallId,\n      kind: OpeningKind.Door,\n      offset: best.offset,\n      width,\n      sill: 0,\n      head: 2100,\n    }).floor;\n  }\n\n  // Name the derived faces from the polygons they came from, matching each face to the\n  // legacy room whose own centroid falls inside it.\n  const committed = commitDerivation(floor);\n  floor = committed.floor;\n\n  const derived = derivePlan(floor).rooms;\n  for (const legacy of rooms) {\n    if (!legacy.name) continue;\n    const centroid = {\n      x: (legacy.points.reduce((s, p) => s + p.x, 0) / legacy.points.length) * scale,\n      y: (legacy.points.reduce((s, p) => s + p.y, 0) / legacy.points.length) * scale,\n    };\n    const match = derived.find(\n      (face) =>\n        face.roomId &&\n        face.outer.length > 2 &&\n        pointInsideRing(centroid, face.outer) &&\n        floor.rooms[face.roomId]?.name.startsWith('Room '),\n    );\n    if (match?.roomId) {\n      floor = {\n        ...floor,\n        rooms: { ...floor.rooms, [match.roomId]: { ...floor.rooms[match.roomId], name: legacy.name } },\n      };\n    }\n  }\n\n  return { ...plan, floors: [floor] };\n}\n\nfunction pointInsideRing(p: PlanPoint, ring: PlanPoint[]): boolean {\n  let inside = false;\n  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {\n    const xi = ring[i].x;\n    const yi = ring[i].y;\n    const xj = ring[j].x;\n    const yj = ring[j].y;\n    if (yi > p.y !== yj > p.y && p.x < ((xj - xi) * (p.y - yi)) / (yj - yi) + xi) inside = !inside;\n  }\n  return inside;\n}\n\nexport { scalePlan };\n"],"mappings":"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"}

package/dist/types/common/floorPlan/legacySvg.d.ts

@@ -1,27 +0,0 @@
-import { scalePlan } from './floorPlan.graph.js';
-import { FloorPlan } from './floorPlan.types.js';
-export interface LegacyImportOptions {
-    /**
-     * Multiplies every imported coordinate, converting the old unitless canvas into the
-     * module's millimetre invariant.
-     *
-     * There is no correct automatic value: the old format records no scale at all. The
-     * default of 1 keeps the numbers as they were, which makes a typical 400x300 export
-     * a 40cm plan. A 400-unit-wide export meant to be a 12m house wants `scale: 30`.
-     */
-    scale?: number;
-    /** Wall thickness for imported walls, in millimetres after scaling. */
-    thickness?: number;
-    /** Tolerance for welding coincident endpoints, in millimetres after scaling. */
-    weldTolerance?: number;
-    label?: string;
-}
-/**
- * Parses a legacy exported SVG into a single-floor `FloorPlan`.
- *
- * Rooms keep their names. Doors are recovered where the old swing-arc path is
- * recognisable, as `OpeningKind.Door`. Windows and archways did not exist in that
- * format, so nothing is lost by not looking for them.
- */
-export declare function planFromLegacySvg(svg: string, options?: LegacyImportOptions): FloorPlan;
-export { scalePlan };