@osamash/floor-planner 1.2.2 → 1.2.4

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/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/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);
@@ -202,6 +207,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,42 @@
+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;
+/** 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/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;

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

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+import type Catalog from "../catalog/catalog";
+export interface SubPanelOption {
+    key: string;
+    label: string;
+    icon: ReactNode;
+    active?: boolean;
+    disabled?: boolean;
+    hasChildren?: boolean;
+    onClick?: () => void;
+}
+interface ToolbarSubPanelProps {
+    title: string;
+    options?: SubPanelOption[];
+    cta?: string;
+    emptyState?: ReactNode;
+    catalog?: Catalog;
+    catalogPage?: string | null;
+    onBack?: () => void;
+    headerExtras?: ReactNode;
+}
+declare const ToolbarSubPanel: ({ title, options, cta, emptyState, catalog, catalogPage, onBack, headerExtras, }: ToolbarSubPanelProps) => import("react/jsx-runtime").JSX.Element;
+export default ToolbarSubPanel;

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

@@ -0,0 +1,5 @@
+interface ZoomControlsProps {
+    subPanelOpen?: boolean;
+}
+declare const ZoomControls: ({ subPanelOpen }: ZoomControlsProps) => import("react/jsx-runtime").JSX.Element;
+export default ZoomControls;

package/dist/types/react-planner/utils/angle.d.ts

@@ -0,0 +1,9 @@
+export declare const RIGHT_ANGLE_TOLERANCE = 5;
+/** Normalize to (-180, 180], the range the rest of the planner uses. */
+export declare const normalizeAngle: (degrees: number) => number;
+/**
+ * Pull an angle onto the nearest quarter turn if it is already close to one.
+ * Shared so that rotating an item feels the same however it is done — the 2D
+ * handle, the 3D gizmo, or anything added later.
+ */
+export declare const snapToRightAngle: (degrees: number) => number;

package/dist/types/react-planner/utils/geometry.d.ts

@@ -141,6 +141,21 @@ export declare function extendLine(x1: number, y1: number, x2: number, y2: numbe
     y: number;
 };
 export declare function roundVertex(vertex: Map<string, number>, precision?: number): Map<string, number>;
+/** Is (pointX, pointY) strictly inside `polygon` (a flat [x0,y0,x1,y1,…] ring)?
+ *
+ *  A point *on* the boundary counts as outside. Callers depend on that: the
+ *  hole detection in `Layer.detectAndUpdateAreas` asks whether one area sits
+ *  inside another by testing one of its vertices, and neighbouring rooms
+ *  always share corners — a shared corner has to answer "no".
+ *
+ *  This used to be PolyK's `ContainsPoint`, whose "hit vertex" correction
+ *  decremented the crossing count for a polygon vertex level with the query
+ *  point *even when that vertex sat to the left of it and had therefore never
+ *  been counted*, leaving the count at -1 and reporting a point far outside as
+ *  inside. Floor plans are axis-aligned and grid-snapped, so points level with
+ *  a vertex are the common case, not a corner case — every room in a grid of
+ *  rooms is level with its neighbours' corners. Rewritten as a plain
+ *  crossing-number test with an explicit boundary check up front. */
 export declare function ContainsPoint(polygon: number[], pointX: number, pointY: number): boolean;
 export declare function cosWithThreshold(alpha: number, threshold: number): number;
 export declare function sinWithThreshold(alpha: number, threshold: number): number;

package/dist/types/react-planner/utils/image-trim.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Where an image's visible pixels actually are inside the rectangle it is
+ * drawn in.
+ *
+ * Catalog artwork is usually a PNG with transparent margin around the object,
+ * and `<image>` letterboxes it on top of that when the file's proportions
+ * don't match the rectangle. Both leave empty space that nothing in the DOM
+ * reports — `getBBox()` returns the rectangle as declared — so an item snapped
+ * flush by its bounding box still looks like it is floating off the wall.
+ *
+ * The scan is done once per URL and cached for the life of the page.
+ */
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * The rectangle an image's visible pixels occupy, in the same coordinates
+ * `rect` is given in. Null when it can't be worked out — a cross-origin asset
+ * without CORS headers, a `slice` fit, an image that failed to load — in which
+ * case the caller should stay with the declared rectangle.
+ */
+export declare function visibleImageRect(src: string, rect: Rect, preserveAspectRatio: string): Promise<Rect | null>;

package/dist/types/react-planner/utils/item-footprint.d.ts

@@ -0,0 +1,23 @@
+/**
+ * What each item actually measures on the plan.
+ *
+ * Catalog elements draw themselves at whatever size they like and the `Item`
+ * record carries no width or height, so an item's footprint is only knowable
+ * from what it rendered. `viewer2d/Item` measures that anyway — for handle and
+ * label placement — and files the result here so the rest of the planner can
+ * reason about item geometry without touching the DOM.
+ *
+ * The box is in the item's own frame, after per-instance scaling and
+ * mirroring, before rotation: `x`/`y` are its corner relative to the item's
+ * origin, which is not necessarily its centre.
+ */
+export interface ItemFootprint {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function rememberItemFootprint(itemID: string, box: ItemFootprint): void;
+export declare function forgetItemFootprint(itemID: string): void;
+/** Null for an item that hasn't been drawn in 2D yet. */
+export declare function getItemFootprint(itemID: string): ItemFootprint | null;

package/dist/types/react-planner/utils/item-snap.d.ts

@@ -0,0 +1,56 @@
+import { type ItemFootprint } from "./item-footprint";
+export declare const ITEM_WALL_SNAP_DISTANCE = 25;
+export declare const ITEM_ITEM_SNAP_DISTANCE = 25;
+/** The face an item snapped against, for the viewer to draw a guide along. */
+export interface ItemSnapGuide {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export interface ItemWallSnap {
+    x: number;
+    y: number;
+    rotation: number;
+    lineID: string;
+    guides: ItemSnapGuide[];
+    /**
+     * The world direction the item is still free to slide along after the snap —
+     * the wall's own direction, since going flush only fixes the axis across it.
+     * Null once a corner snap has fixed that one too. What is left here is what
+     * a neighbouring item is allowed to move the item on.
+     */
+    free: {
+        x: number;
+        y: number;
+    } | null;
+}
+/**
+ * Where the item would sit if it snapped to a wall, or null if none is close
+ * enough.
+ *
+ * The item goes flush against the nearest wall face and squares up with it,
+ * then — if it is also near the wall at the other end — slides along until it
+ * sits in the corner. It stays free on any axis it hasn't snapped on, so the
+ * pointer still leads there.
+ */
+export declare function snapItemToWalls(layer: any, catalog: any, footprint: ItemFootprint | null, x: number, y: number, rotation: number): ItemWallSnap | null;
+/** Where the item lands, or null if nothing was close enough to snap to. */
+export interface ItemSnap {
+    x: number;
+    y: number;
+    rotation: number;
+    guides: ItemSnapGuide[];
+}
+/**
+ * Everything a dragged item snaps to: the walls first, then the items already
+ * placed.
+ *
+ * The two compose rather than compete. A wall snap fixes the axis across the
+ * wall and squares the item up; the items on the layer then get to decide
+ * where along that wall it sits — so a nightstand pushed towards a corner goes
+ * flush against the wall *and* flush against the bed in one gesture. Once a
+ * corner snap has fixed the second axis too there is nothing left to offer and
+ * the walls have it. With no wall in range, both axes are the items' to claim.
+ */
+export declare function snapItem(layer: any, catalog: any, itemID: string, footprint: ItemFootprint | null, x: number, y: number, rotation: number): ItemSnap | null;

package/dist/types/react-planner/utils/item-transform.d.ts

@@ -0,0 +1,9 @@
+export declare const ITEM_MIN_SCALE = 0.2;
+export declare const ITEM_MAX_SCALE = 8;
+export interface ItemTransform {
+    scale: number;
+    flipHorizontal: boolean;
+    flipVertical: boolean;
+}
+export declare function getItemTransform(item: any): ItemTransform;
+export declare function clampItemScale(scale: number): number;

package/dist/types/react-planner/utils/name-generator.d.ts

@@ -1,3 +1,3 @@
 export default class NameGenerator {
-    static generateName(_: any, type: string): string;
+    static generateName(_: any, type: unknown): string;
 }

package/dist/types/react-planner/utils/three-cache.d.ts

@@ -0,0 +1,17 @@
+import { Texture } from "three";
+import type { ColorSpace } from "three";
+/**
+ * One decoded image per URL, handed out as clones.
+ *
+ * Callers set their own `repeat`/`wrap` — a wall tiles differently from a
+ * floor — and those live on the Texture, so a single shared object won't do.
+ * A clone carries its own settings but shares `source` with the base, and the
+ * renderer keys GPU uploads on `source` (refcounted, so disposing a clone is
+ * safe): the bytes are fetched, decoded and uploaded once no matter how many
+ * walls ask for them.
+ *
+ * `colorSpace` defaults to sRGB because most callers want an albedo map, and
+ * one left in the renderer's linear working space comes out visibly washed
+ * out. Data maps — normals, roughness — must pass `NoColorSpace`.
+ */
+export declare function loadTexture(uri: string, colorSpace?: ColorSpace): Texture;

package/dist/types/react-planner/utils/three-materials.d.ts

@@ -0,0 +1,33 @@
+import { Object3D, Texture } from "three";
+/**
+ * Mark a texture as holding colour rather than data.
+ *
+ * Image files store colour sRGB-encoded, but lighting has to happen in linear
+ * space — the renderer only knows to convert if the texture says so. Left at
+ * the default, an albedo map renders washed out and the wrong brightness.
+ * Normal/roughness/metalness maps are numbers, not colour, and must stay
+ * linear: those get `NoColorSpace`.
+ */
+export declare function asColorMap<T extends Texture>(texture: T): T;
+export declare function asDataMap<T extends Texture>(texture: T): T;
+/**
+ * Bring a freshly imported model in line with how the viewer lights the scene.
+ *
+ * Model files describe their materials in whatever the exporting tool used,
+ * and the loaders reproduce that faithfully — which is why an .obj arrives
+ * Phong and a .glb arrives Standard. Anything already physically based is left
+ * alone beyond its colour spaces; the rest is converted so one lighting rig
+ * can light all of it consistently.
+ */
+export declare function normalizeImportedMaterials<T extends Object3D>(object: T): T;
+interface ShadowOptions {
+    cast?: boolean;
+    receive?: boolean;
+}
+/**
+ * Contact shadows are most of what makes furniture look like it's standing on
+ * the floor rather than pasted over it. Floors only receive — a flat surface
+ * casting onto itself is all acne and no shadow.
+ */
+export declare function enableShadows<T extends Object3D>(object: T, { cast, receive }?: ShadowOptions): T;
+export {};

package/dist/types/react-planner/utils/threeCSG.es6.d.ts

@@ -21,7 +21,7 @@ declare class Polygon {
     clone(): Polygon;
     flip(): this;
     classifyVertex(vertex: THREE.Vector3Like): 0 | 1 | 2;
-    classifySide(polygon: Polygon): 0 | 1 | 2 | 3;
+    classifySide(polygon: Polygon): 0 | 1 | 3 | 2;
     splitPolygon(polygon: Polygon, coplanar_front: any, coplanar_back: any, front: any, back: any): void;
 }
 declare class Node {