@osamash/floor-planner 1.2.3 → 1.2.5

package/dist/types/react-planner/catalog/factories/room-types.d.ts

@@ -0,0 +1,22 @@
+export interface RoomType {
+    value: string;
+    label: string;
+    color: string;
+}
+export interface RoomCategory {
+    value: string;
+    label: string;
+    types: RoomType[];
+}
+export declare const ROOM_CATEGORIES: RoomCategory[];
+export declare function getCategory(value: string | undefined): RoomCategory | undefined;
+export declare function getRoomType(categoryValue: string | undefined, typeValue: string | undefined): RoomType | undefined;
+export declare function getRoomTypeLabel(categoryValue: string | undefined, typeValue: string | undefined): string;
+export declare function getRoomTypeColor(categoryValue: string | undefined, typeValue: string | undefined): string | undefined;
+export declare const DEFAULT_ROOM_CATEGORY = "";
+export declare const DEFAULT_ROOM_TYPE = "";
+export type AreaKind = "Room" | "Surface" | "Area";
+export declare function getAreaKind(area: any, layer: any): AreaKind;
+export declare function deriveAreaLabel(area: any, layer: any, opts?: {
+    defaultLabel?: string;
+}): string;

package/dist/types/react-planner/catalog/factories/wall-factory-3d.d.ts

@@ -13,5 +13,5 @@ type TextureInfo = {
     };
 };
 export declare function buildWall(element: any, layer: Layer, scene: Scene, textures: Record<string, TextureInfo>): Promise<Group>;
-export declare function updatedWall(element: any, layer: any, scene: any, textures: any, mesh: any, oldElement: any, differences: any, selfDestroy: any, selfBuild: any): any;
+export declare function updatedWall(element: any, layer: any, scene: any, textures: any, mesh: any, _oldElement: any, differences: any, selfDestroy: any, selfBuild: any): any;
 export {};

package/dist/types/react-planner/catalog/unknown-element.d.ts

@@ -0,0 +1,10 @@
+import type { CatalogElement } from "./catalog";
+/**
+ * Build the stand-in for `type`.
+ *
+ * `prototype` is left empty on purpose: the element's own record already
+ * carries the right one, and claiming one here would file the placeholder among
+ * real elements — `getElementsOfPrototype` backs the "similar elements" list,
+ * which should never offer a missing type as something to place.
+ */
+export default function unknownElement(type: string): CatalogElement;

package/dist/types/react-planner/class/area.d.ts

@@ -1,7 +1,34 @@
 import { Set } from "immutable";
+import { type LineFamily } from "../utils/line-family";
 declare class Area {
     static getSurfaceLines(state: any, layerID: string, areaID: string): Set<string>;
-    static add(state: any, layerID: any, type: any, verticesCoords: any, catalog: any): {
+    static center(state: any, layerID: string, areaID: string): {
+        x: number;
+        y: number;
+    } | null;
+    static transform(state: any, layerID: string, areaID: string, transform: (point: {
+        x: number;
+        y: number;
+    }) => {
+        x: number;
+        y: number;
+    }): {
+        updatedState: any;
+    };
+    /** Rotate about the area's center. Maths convention: in these y-up scene
+     *  coords a positive angle turns counter-clockwise, which reads *clockwise*
+     *  in the y-flipped 2D view. */
+    static rotate(state: any, layerID: string, areaID: string, degrees: number): {
+        updatedState: any;
+    };
+    /** Mirror about the area's center — "x" flips it left-right, "y" top-bottom. */
+    static mirror(state: any, layerID: string, areaID: string, axis: "x" | "y"): {
+        updatedState: any;
+    };
+    /** `family` says which graph the boundary belongs to. Walls and surfaces can
+     *  now have distinct vertices at identical coordinates, so without it the
+     *  lookup below could bind a surface polygon to a wall's corner. */
+    static add(state: any, layerID: any, type: any, verticesCoords: any, catalog: any, family?: LineFamily): {
         updatedState: any;
         area: undefined;
     };

package/dist/types/react-planner/class/hole.d.ts

@@ -28,6 +28,16 @@ declare class Hole {
     static endDraggingHole(state: any, x: any, y: any): {
         updatedState: any;
     };
+    static flip(state: any, layerID: any, holeID: any, axis?: "x" | "y"): {
+        updatedState: any;
+    };
+    static duplicate(state: any, layerID: any, holeID: any): {
+        updatedState: any;
+        hole?: undefined;
+    } | {
+        updatedState: any;
+        hole: any;
+    };
     static setProperties(state: any, layerID: any, holeID: any, properties: any): {
         updatedState: any;
     };
@@ -40,6 +50,9 @@ declare class Hole {
     static updateJsProperties(state: any, layerID: any, holeID: any, properties: any): {
         updatedState: any;
     };
+    static mergeAttributes(state: any, layerID: any, holeID: any, attributes: any): {
+        updatedState: any;
+    };
     static setAttributes(state: any, layerID: any, holeID: any, holesAttributes: any): {
         updatedState: any;
     };

package/dist/types/react-planner/class/index.d.ts

@@ -7,8 +7,9 @@ import Vertex from "./vertex";
 import Area from "./area";
 import Item from "./item";
 import Surface from "./surface";
+import Room from "./room";
 import { HorizontalGuide, VerticalGuide } from "./guide";
-export { Project, Group, Layer, Line, Hole, Vertex, Area, Item, HorizontalGuide, VerticalGuide, Surface, };
+export { Project, Group, Layer, Line, Hole, Vertex, Area, Item, HorizontalGuide, VerticalGuide, Surface, Room, };
 declare const _default: {
     Project: typeof Project;
     Group: typeof Group;
@@ -19,6 +20,7 @@ declare const _default: {
     Area: typeof Area;
     Item: typeof Item;
     Surface: typeof Surface;
+    Room: typeof Room;
     HorizontalGuide: typeof HorizontalGuide;
     VerticalGuide: typeof VerticalGuide;
 };

package/dist/types/react-planner/class/item.d.ts

@@ -39,6 +39,28 @@ declare class Item {
     static endRotatingItem(state: any, x: any, y: any): {
         updatedState: any;
     };
+    static beginResizingItem(state: any, layerID: any, itemID: any, x: number, y: number): {
+        updatedState: any;
+    };
+    static updateResizingItem(state: any, x: number, y: number): {
+        updatedState: any;
+    };
+    static endResizingItem(state: any, x: number, y: number): {
+        updatedState: any;
+    };
+    static rotate(state: any, layerID: any, itemID: any, delta: number): {
+        updatedState: any;
+    };
+    static flip(state: any, layerID: any, itemID: any, axis: "x" | "y"): {
+        updatedState: any;
+    };
+    static duplicate(state: any, layerID: any, itemID: any): {
+        updatedState: any;
+        item?: undefined;
+    } | {
+        updatedState: any;
+        item: any;
+    };
     static setProperties(state: any, layerID: any, itemID: any, properties: any): {
         updatedState: any;
     };

package/dist/types/react-planner/class/line.d.ts

@@ -33,9 +33,18 @@ declare class Line {
         line: any;
         vertex: any;
     };
-    static selectToolDrawingLine(state: any, sceneComponentType: string): {
-        updatedState: any;
-    };
+    static selectToolDrawingLine(state: any, sceneComponentType: string, options?: {
+        thickness?: number;
+        height?: number;
+    }): {
+        updatedState: any;
+    };
+    /** Thickness/height the toolbar's steppers are currently set to, kept on
+     *  `drawingSupport` for as long as the tool is active (same place
+     *  `Room.selectToolDrawingRoom` keeps them). Returns undefined when the tool
+     *  was selected without them — e.g. picking a line element straight out of
+     *  the catalog — so the catalog element's own defaults apply. */
+    static drawingProperties(drawingSupport: any): any;
     static beginDrawingLine(state: any, layerID: string, x: number, y: number): {
         updatedState: any;
     };

package/dist/types/react-planner/class/room.d.ts

@@ -0,0 +1,18 @@
+declare class Room {
+    static selectToolDrawingRoom(state: any, options?: {
+        thickness?: number;
+        height?: number;
+    }): {
+        updatedState: any;
+    };
+    static beginDrawingRoom(state: any, layerID: string, x: number, y: number): {
+        updatedState: any;
+    };
+    static updateDrawingRoom(state: any, x: number, y: number): {
+        updatedState: any;
+    };
+    static endDrawingRoom(state: any, x: number, y: number): {
+        updatedState: any;
+    };
+}
+export default Room;

package/dist/types/react-planner/class/surface.d.ts

@@ -1,7 +1,27 @@
+/** Free-standing polygons — patios, lawns, decking. Drawn corner by corner
+ *  with the same lines/vertices as walls, but kept out of the wall graph by
+ *  `utils/line-family`, so laying one over a room neither welds it to the
+ *  walls it crosses nor takes the room's floor over.
+ *
+ *  Snapping is the deliberate exception: a surface *should* be able to land
+ *  exactly on a wall corner or run flush along a wall — it just must not
+ *  become attached to it. So the whole scene is offered as snap targets, the
+ *  same set the wall tool uses.
+ *
+ *  Drawing: click each corner. Click back on the first corner to close the
+ *  polygon, or leave the tool (Esc, double-click) once three corners are down
+ *  and `finishDrawingSurface` closes it for you.
+ */
 declare class Surface {
     static selectToolDrawingSurface(state: any, sceneComponentType: string): {
         updatedState: any;
     };
+    /** Snap targets for the whole scene, plus the horizontal/vertical guides
+     *  through `(x, y)` — exactly what `Line.beginDrawingLine` builds. This was
+     *  simply missing before: `snapElements` stayed empty for the surface tool,
+     *  so every `nearestSnap` downstream had nothing to find and the tool
+     *  behaved as if snapping were off. */
+    private static anchorSnaps;
     static beginDrawingSurface(state: any, layerID: string, x: number, y: number): {
         updatedState: any;
     };
@@ -11,5 +31,19 @@ declare class Surface {
     static endDrawingSurface(state: any, x: number, y: number): {
         updatedState: any;
     };
+    /** Leave the tool keeping what has been drawn, by committing the edge from
+     *  the last clicked corner back to the first.
+     *
+     *  This is what Esc and the double-click go through. The outline on screen
+     *  is already drawn closed while the tool is live, so throwing it away is
+     *  never what leaving the tool means — but only clicked corners count, not
+     *  wherever the cursor happens to be resting.
+     *
+     *  Under three corners there is no polygon to keep; `finished: false` says
+     *  so, and the caller falls back to a real rollback. */
+    static finishDrawingSurface(state: any): {
+        updatedState: any;
+        finished: boolean;
+    };
 }
 export default Surface;

package/dist/types/react-planner/class/vertex.d.ts

@@ -1,5 +1,10 @@
+import { type LineFamily } from "../utils/line-family";
 declare class Vertex {
-    static add(state: any, layerID: any, x: any, y: any, relatedPrototype: any, relatedID: any): {
+    /** `family` is what the caller is about to attach here. A coincident vertex
+     *  is only reused when it belongs to the same family, so a surface corner
+     *  dropped on a wall corner gets its own vertex and the two graphs stay
+     *  separate. Omit it to reuse any coincident vertex (the old behaviour). */
+    static add(state: any, layerID: any, x: any, y: any, relatedPrototype: any, relatedID: any, family?: LineFamily): {
         updatedState: any;
         vertex: any;
     };

package/dist/types/react-planner/components/ErrorBoundary.d.ts

@@ -0,0 +1,19 @@
+import { Component, type ReactNode } from "react";
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    onReset?: () => void;
+}
+interface ErrorBoundaryState {
+    error: Error | null;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    state: ErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, info: {
+        componentStack?: string | null;
+    }): void;
+    render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+}
+export default ErrorBoundary;

package/dist/types/react-planner/components/SearchInput.d.ts

@@ -6,8 +6,9 @@ interface SearchFieldInterface {
     onClick?: () => false;
     isStatic?: boolean;
     className?: string;
+    inputClassName?: string;
     hasDropDown?: boolean;
     onSearch: (term: string, event: React.ChangeEvent<HTMLInputElement>) => void;
 }
-declare const SearchInput: ({ term, placeholder, noSpacing, onClick, isStatic, hasDropDown, onSearch, className, value, }: SearchFieldInterface) => import("react/jsx-runtime").JSX.Element;
+declare const SearchInput: ({ term, placeholder, noSpacing, onClick, isStatic, hasDropDown, onSearch, className, value, inputClassName, }: SearchFieldInterface) => import("react/jsx-runtime").JSX.Element;
 export default SearchInput;

package/dist/types/react-planner/constants.d.ts

@@ -203,6 +203,8 @@ export declare const MODE_3D_VIEW = "MODE_3D_VIEW";
 export declare const MODE_3D_FIRST_PERSON = "MODE_3D_FIRST_PERSON";
 export declare const MODE_WAITING_DRAWING_LINE = "MODE_WAITING_DRAWING_LINE";
 export declare const MODE_WAITING_DRAWING_SURFACE = "MODE_WAITING_DRAWING_SURFACE";
+export declare const MODE_WAITING_DRAWING_ROOM = "MODE_WAITING_DRAWING_ROOM";
+export declare const MODE_DRAWING_ROOM = "MODE_DRAWING_ROOM";
 export declare const MODE_DRAGGING_LINE = "MODE_DRAGGING_LINE";
 export declare const MODE_DRAGGING_VERTEX = "MODE_DRAGGING_VERTEX";
 export declare const MODE_DRAGGING_ITEM = "MODE_DRAGGING_ITEM";
@@ -212,6 +214,7 @@ export declare const MODE_DRAWING_HOLE = "MODE_DRAWING_HOLE";
 export declare const MODE_DRAWING_ITEM = "MODE_DRAWING_ITEM";
 export declare const MODE_DRAWING_SURFACE = "MODE_DRAWING_SURFACE";
 export declare const MODE_ROTATING_ITEM = "MODE_ROTATING_ITEM";
+export declare const MODE_RESIZING_ITEM = "MODE_RESIZING_ITEM";
 export declare const MODE_UPLOADING_IMAGE = "MODE_UPLOADING_IMAGE";
 export declare const MODE_FITTING_IMAGE = "MODE_FITTING_IMAGE";
 export declare const MODE_VIEWING_CATALOG = "MODE_VIEWING_CATALOG";

package/dist/types/react-planner/footer-bar/Footerbar.d.ts

@@ -1,2 +1,2 @@
-declare const Footerbar: () => import("react/jsx-runtime").JSX.Element | undefined;
+declare const Footerbar: () => null;
 export default Footerbar;

package/dist/types/react-planner/hooks/usePlanThumbnail.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Keeps a plan thumbnail up to date, handing each new one to `onReady`.
+ *
+ * Capture is deliberately *ahead* of unload, not during it. `beforeunload`
+ * can't await anything, and a multi-hundred-KB data URI is far past what
+ * sendBeacon or fetch({ keepalive: true }) will carry (~64KB), so there is no
+ * way to both build and ship an image once the page is going away. Instead we
+ * capture on an idle timer and again when the page is hidden — by the time the
+ * tab actually closes, the server already has a current image.
+ */
+export declare function usePlanThumbnail(onReady?: (img: string) => void): {
+    ensureScreenshot: (force?: boolean) => Promise<void>;
+};

package/dist/types/react-planner/models.d.ts

@@ -57,6 +57,7 @@ declare const Hole_base: Record.Factory<{
     prototype: string;
     offset: number;
     line: string;
+    flipAlongWall: boolean;
     id: string;
     type: string;
     name: string;
@@ -89,6 +90,9 @@ declare const Item_base: Record.Factory<{
     y: number;
     rotation: number;
     altitude: number;
+    scale: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
     id: string;
     type: string;
     name: string;
@@ -156,6 +160,7 @@ declare const CatalogElement_base: Record.Factory<{
     prototype: string;
     info: Map<unknown, unknown>;
     properties: Map<unknown, unknown>;
+    textures: Map<unknown, unknown>;
 }>;
 export declare class CatalogElement extends CatalogElement_base {
     constructor(json?: any);
@@ -168,6 +173,18 @@ declare const Catalog_base: Record.Factory<{
 }>;
 export declare class Catalog extends Catalog_base {
     constructor(json?: any);
+    /**
+     * Build a record of `type` with its catalog defaults filled in.
+     *
+     * A type the catalog doesn't have is normally a caller's mistake, but not
+     * always: duplicating something already in the plan goes through here, and a
+     * plan can outlive the catalog it was drawn with (see
+     * `catalog/unknown-element.tsx`). So when `options.prototype` says which kind
+     * of record to build, one gets built — carrying whatever properties came in,
+     * since there are no defaults to merge — rather than taking the planner down
+     * over a copy of something already on screen. Without that hint there is
+     * nothing to construct, and it still throws.
+     */
     factoryElement(type: string, options: any, initialProperties?: Map<string, any>): Line | Hole | Area | Item;
 }
 declare const HistoryStructure_base: Record.Factory<{
@@ -202,6 +219,8 @@ declare const State_base: Record.Factory<{
     drawingSupport: Map<unknown, unknown>;
     draggingSupport: Map<unknown, unknown>;
     rotatingSupport: Map<unknown, unknown>;
+    resizingSupport: Map<unknown, unknown>;
+    itemSnapGuides: null;
     errors: List<unknown>;
     warnings: List<unknown>;
     clipboardProperties: Map<unknown, unknown>;

package/dist/types/react-planner/plugins/autosave.d.ts

@@ -1,2 +1,2 @@
 import { type Plan, type ReactPlannerStore } from "../../store/ReactPlannerStore";
-export default function autosave(autosaveKey: string, delay?: number): (store: ReactPlannerStore, plan: Plan, onSave?: (data: any) => void) => void;
+export default function autosave(autosaveKey: string, delay?: number): (store: ReactPlannerStore, plan: Plan, onSave?: (data: any) => void) => (() => void) | undefined;

package/dist/types/react-planner/plugins/keyboard.d.ts

@@ -1,2 +1,2 @@
 import type { ReactPlannerStore } from "../../store/ReactPlannerStore";
-export default function keyboard(): (store: ReactPlannerStore) => void;
+export default function keyboard(): (store: ReactPlannerStore) => () => void;

package/dist/types/react-planner/sidebar/Panel.d.ts

@@ -2,7 +2,8 @@ import React from "react";
 interface PanelProps {
     opened?: boolean;
     name: string;
+    subtitle?: string;
     children: React.ReactNode;
 }
-declare const Panel: ({ children, name, ...props }: PanelProps) => import("react/jsx-runtime").JSX.Element;
+declare const Panel: ({ children, name, subtitle, ...props }: PanelProps) => import("react/jsx-runtime").JSX.Element;
 export default Panel;

package/dist/types/react-planner/sidebar/panel-element-editor/AreaAttributesEditor.d.ts

@@ -0,0 +1,8 @@
+import type Catalog from "../../catalog/catalog";
+interface AreaAttributesEditorProps {
+    element: any;
+    layer: any;
+    catalog: Catalog;
+}
+declare const AreaAttributesEditor: ({ element, layer, catalog, }: AreaAttributesEditorProps) => import("react/jsx-runtime").JSX.Element;
+export default AreaAttributesEditor;

package/dist/types/react-planner/sidebar/panel-element-editor/AttributesEditor.d.ts

@@ -1,8 +1,11 @@
+import type Catalog from "../../catalog/catalog";
 interface AttributesEditorProps {
     element: any;
+    layer: any;
+    catalog: Catalog;
     onUpdate: (k: string, v: any) => void;
     onValid: () => void;
     attributeFormData: any;
 }
-declare const AttributesEditor: ({ element, onUpdate, onValid, attributeFormData, ...props }: AttributesEditorProps) => import("react/jsx-runtime").JSX.Element | null;
+declare const AttributesEditor: ({ element, layer, catalog, onUpdate, onValid, attributeFormData, ...props }: AttributesEditorProps) => import("react/jsx-runtime").JSX.Element | null;
 export default AttributesEditor;

package/dist/types/react-planner/sidebar/panel-element-editor/HoleAttributesEditor.d.ts

@@ -1,8 +1,7 @@
+import type Catalog from "../../catalog/catalog";
 interface HoleAttributesEditorProps {
     element: any;
-    onUpdate: (k: string, v: any) => void;
-    attributeFormData: any;
-    onValid?: (event: Event) => void;
+    catalog: Catalog;
 }
-declare const HoleAttributesEditor: ({ element, attributeFormData, onUpdate, ...props }: HoleAttributesEditorProps) => import("react/jsx-runtime").JSX.Element;
+declare const HoleAttributesEditor: ({ element, catalog, }: HoleAttributesEditorProps) => import("react/jsx-runtime").JSX.Element;
 export default HoleAttributesEditor;

package/dist/types/react-planner/sidebar/panel-element-editor/ItemAttributesEditor.d.ts

@@ -1,8 +1,7 @@
+import type Catalog from "../../catalog/catalog";
 interface ItemAttributesEditorProps {
     element: any;
-    onUpdate: (k: string, v: any) => void;
-    attributeFormData: any;
-    onValid?: (event: Event) => void;
+    catalog: Catalog;
 }
-declare const ItemAttributesEditor: ({ element, onUpdate, attributeFormData, ...props }: ItemAttributesEditorProps) => import("react/jsx-runtime").JSX.Element;
+declare const ItemAttributesEditor: ({ element, catalog, }: ItemAttributesEditorProps) => import("react/jsx-runtime").JSX.Element;
 export default ItemAttributesEditor;

package/dist/types/react-planner/sidebar/panel-element-editor/SimilarElements.d.ts

@@ -0,0 +1,15 @@
+import type Catalog from "../../catalog/catalog";
+import type { CatalogElement } from "../../catalog/catalog";
+export declare function findSimilarElements(catalog: Catalog, element: any): CatalogElement[];
+interface SimilarElementsGridProps {
+    elements: CatalogElement[];
+    /** Panel the pointer has to leave for the drag to become a placement. */
+    containerSelector?: string;
+}
+/**
+ * A browse-and-place list: press an entry and drag it out of the sidebar to
+ * start placing one, exactly like the catalog picker in the toolbar. Nothing
+ * here touches the selected element — these are additions, not swaps.
+ */
+export declare const SimilarElementsGrid: ({ elements, containerSelector, }: SimilarElementsGridProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/react-planner/sidebar/panel-element-editor/WallAttributesEditor.d.ts

@@ -0,0 +1,8 @@
+import type Catalog from "../../catalog/catalog";
+interface WallAttributesEditorProps {
+    element: any;
+    layer: any;
+    catalog: Catalog;
+}
+declare const WallAttributesEditor: ({ element, layer, catalog, }: WallAttributesEditorProps) => import("react/jsx-runtime").JSX.Element;
+export default WallAttributesEditor;

package/dist/types/react-planner/sidebar/panel-element-editor/editor-ui.d.ts

@@ -0,0 +1,93 @@
+import type React from "react";
+export declare const BackHeader: ({ title, subtitle, onBack, }: {
+    title: string;
+    subtitle?: string;
+    onBack: () => void;
+}) => import("react/jsx-runtime").JSX.Element;
+interface RowButtonProps {
+    swatchColor?: string;
+    textureUri?: string;
+    icon?: React.ReactNode;
+    label: string;
+    value?: string;
+    onClick: () => void;
+}
+export declare const RowButton: ({ swatchColor, textureUri, icon, label, value, onClick, }: RowButtonProps) => import("react/jsx-runtime").JSX.Element;
+interface MeasureStepperProps {
+    value: number;
+    onChange: (next: number) => void;
+    step?: number;
+    min?: number;
+    max?: number;
+    /** Suffix shown inside the field. Lengths are stored in cm throughout. */
+    unit?: string;
+}
+export declare const MeasureStepper: ({ value, onChange, step, min, max, unit, }: MeasureStepperProps) => import("react/jsx-runtime").JSX.Element;
+export interface EditorAction {
+    key: string;
+    label: string;
+    icon: React.ReactNode;
+    danger?: boolean;
+    onClick: () => void;
+}
+/** Round icon buttons under the preview — duplicate, rotate, flip, delete. */
+export declare const ActionRow: ({ actions }: {
+    actions: EditorAction[];
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * One entry of a catalog element's `textures` map, as far as the picker cares.
+ * Structural on purpose — the repeat scales matter to the renderers, not here.
+ */
+export interface MaterialTexture {
+    name: string;
+    uri: string;
+    tag?: string[];
+}
+interface MaterialPickerProps {
+    textures: Record<string, MaterialTexture>;
+    /** Currently applied key, or `"none"`. */
+    value: string;
+    onChange: (key: string) => void;
+    /** Heading, rendered only alongside the picker so it can't be left stranded
+     *  above nothing when the element has no materials. */
+    label?: string;
+}
+/**
+ * Browse a catalog element's materials.
+ *
+ * Shared by the wall and area editors because they browse the same library —
+ * the catalog hands floors and walls one `textures` map, so whatever makes it
+ * navigable for one has to be there for the other. Categories come from the
+ * materials' own tags in the order the catalog lists them, so no vocabulary is
+ * baked in here.
+ */
+export declare const MaterialPicker: ({ textures, value, onChange, label, }: MaterialPickerProps) => import("react/jsx-runtime").JSX.Element | null;
+interface FinishPickerProps {
+    /** Paint colour, as `#RRGGBB`. */
+    color: string;
+    onColorChange: (color: string) => void;
+    textures: Record<string, MaterialTexture>;
+    /** Currently applied texture key, or `"none"`. */
+    texture: string;
+    onTextureChange: (key: string) => void;
+    /**
+     * Rendered under the palette on the Colors tab. Areas put their hatch
+     * patterns here; walls have none, and pass nothing.
+     */
+    patterns?: React.ReactNode;
+}
+/**
+ * How a surface's finish is chosen: paint on one tab, materials on the other.
+ *
+ * Walls and areas both answer the same question here — what is this surface
+ * covered in — so they get the same two tabs over the same palette and the same
+ * material library. What differs is what else lives under the palette, which
+ * comes in as `patterns`.
+ */
+export declare const FinishPicker: ({ color, onColorChange, textures, texture, onTextureChange, patterns, }: FinishPickerProps) => import("react/jsx-runtime").JSX.Element;
+/** Catalog thumbnail, falling back to a neutral tile when there is no image. */
+export declare const ElementPreview: ({ imageUri, alt, }: {
+    imageUri?: string;
+    alt: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/react-planner/sidebar/panel-element-editor/paint-palette.d.ts

@@ -0,0 +1,6 @@
+interface PaintPaletteProps {
+    value: string;
+    onChange: (color: string) => void;
+}
+export declare const PaintPalette: ({ value, onChange }: PaintPaletteProps) => import("react/jsx-runtime").JSX.Element;
+export default PaintPalette;

package/dist/types/react-planner/toolbar/CatalogPicker.d.ts

@@ -0,0 +1,8 @@
+import Catalog from "../catalog/catalog";
+interface CatalogPickerProps {
+    catalog: Catalog;
+    page: string;
+    containerSelector?: string;
+}
+declare const CatalogPicker: ({ catalog, page, containerSelector, }: CatalogPickerProps) => import("react/jsx-runtime").JSX.Element;
+export default CatalogPicker;

package/dist/types/react-planner/toolbar/NumberStepper.d.ts

@@ -0,0 +1,11 @@
+interface NumberStepperProps {
+    label: string;
+    value: number;
+    unit?: string;
+    step?: number;
+    min?: number;
+    max?: number;
+    onChange: (value: number) => void;
+}
+declare const NumberStepper: ({ label, value, unit, step, min, max, onChange, }: NumberStepperProps) => import("react/jsx-runtime").JSX.Element;
+export default NumberStepper;

package/dist/types/react-planner/toolbar/ProjectMiniMap.d.ts

@@ -0,0 +1,11 @@
+export interface HoveredArea {
+    layerID: string;
+    areaID: string;
+    label: string;
+    area: number;
+}
+interface ProjectMiniMapProps {
+    onHoverChange?: (info: HoveredArea | null) => void;
+}
+declare const ProjectMiniMap: ({ onHoverChange }: ProjectMiniMapProps) => import("react/jsx-runtime").JSX.Element;
+export default ProjectMiniMap;

package/dist/types/react-planner/toolbar/ProjectPanel.d.ts

@@ -0,0 +1,2 @@
+declare const ProjectPanel: () => import("react/jsx-runtime").JSX.Element;
+export default ProjectPanel;

package/dist/types/react-planner/toolbar/ToolbarRail.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export type RailSection = "project" | "build" | "info" | "objects" | "styleboards" | "finishes" | "help";
+export interface RailItem {
+    key: RailSection;
+    label: string;
+    icon: ReactNode;
+    disabled?: boolean;
+}
+interface ToolbarRailProps {
+    items: RailItem[];
+    active: RailSection | null;
+    onChange: (section: RailSection) => void;
+}
+declare const ToolbarRail: ({ items, active, onChange }: ToolbarRailProps) => import("react/jsx-runtime").JSX.Element;
+export default ToolbarRail;