@osamash/floor-planner 1.2.5 → 1.2.7

package/dist/types/react-planner/ai-chat/AIChatPanel.d.ts

@@ -1,8 +1,9 @@
 import { type AIRequestHandler } from "./aiService";
 interface AIChatPanelProps {
+    /** Whether the panel is the visible toolbar section. It stays mounted when
+        it isn't, so this drives focus and the microphone, not rendering. */
     open: boolean;
-    onClose: () => void;
     onAIMessage?: AIRequestHandler;
 }
-declare const AIChatPanel: ({ open, onClose, onAIMessage }: AIChatPanelProps) => import("react/jsx-runtime").JSX.Element;
+declare const AIChatPanel: ({ open, onAIMessage }: AIChatPanelProps) => import("react/jsx-runtime").JSX.Element;
 export default AIChatPanel;

package/dist/types/react-planner/ai-chat/aiService.d.ts

@@ -38,9 +38,16 @@ export interface WallInfo {
     /** cm. */
     thickness: number | null;
     height: number | null;
-    /** The wall's two faces. Which one looks into a given room is geometric. */
+    /** The wall's two faces. Which one looks into a given room is geometric, so
+     *  `areaA`/`areaB` name the area each face looks into — null means open air,
+     *  i.e. that face is the outside of the building. Ground surfaces such as a
+     *  garden are not counted; a wall facing one still has an outside face. */
     textureA: string | null;
     textureB: string | null;
+    colorA: string | null;
+    colorB: string | null;
+    areaA: string | null;
+    areaB: string | null;
 }
 export interface HoleInfo {
     id: string;
@@ -155,7 +162,39 @@ export type RoomSide = "left" | "right" | "above" | "below";
  * `ACTION_SPECS` (what the model may say), and a branch in
  * `applyPlannerActions` (what actually happens).
  */
-export type PlannerAction = AddRoomAction | SetRoomPropertiesAction | AddHoleAction | AddItemAction | SetWallPropertiesAction | SetItemPropertiesAction | AddSurfaceAction | DeleteAction | SetSurfacePropertiesAction;
+export type PlannerAction = GenerateLayoutAction | AddRoomAction | SetRoomPropertiesAction | AddHoleAction | AddItemAction | SetWallPropertiesAction | SetItemPropertiesAction | AddSurfaceAction | DeleteAction | SetSurfacePropertiesAction;
+/**
+ * A whole floor plan as a program: which rooms, of what type, roughly how big.
+ * No geometry — the packer works out every rectangle. Applying this REPLACES
+ * whatever is on the canvas.
+ */
+export type GenerateLayoutAction = {
+    type: "generate-layout";
+    rooms: {
+        name: string;
+        roomType: string;
+        size?: "small" | "medium" | "large";
+    }[];
+    /** A roomCategory value; the room types must belong to it. Backend defaults
+     *  this to "house", so it always arrives populated. */
+    buildingType: string;
+    /** Ground outside the building — garden, pool, patio. Not rooms: no walls,
+     *  so no doors, windows or furniture. The packer picks which outside wall
+     *  each one lies against. */
+    outdoor?: {
+        name: string;
+        texture?: string;
+        color?: string;
+        depth?: number;
+    }[];
+    /** m², if the user gave one. Absent means the packer sizes the plan itself. */
+    totalArea?: number;
+    /** Only the building OUTLINE varies — every room stays a rectangle. Absent
+     *  means the packer picks from the seed. */
+    footprint?: "rectangle" | "L" | "U";
+    /** Always populated backend-side, so the same action replays identically. */
+    seed: number;
+};
 export type AddRoomAction = {
     type: "add-room";
     /**
@@ -201,6 +240,9 @@ export type AddHoleAction = {
      * and land as two doors. Mutually exclusive with room/side.
      */
     between?: [string, string];
+    /** Where along the wall, 1-8. Absent means centred, and the frontend then
+     *  spaces multiple openings on one wall evenly. */
+    at?: number;
     /** A particular wall — the only way to reach an exterior one. */
     room?: string;
     side?: RoomSide;
@@ -222,10 +264,13 @@ export type SetWallPropertiesAction = {
     /** A room name, or "selected". All four of its walls unless `side` is given. */
     room: string;
     side?: RoomSide;
-    /** Applied to the wall face looking into `room`. */
+    /** Which of the wall's two faces to paint. "outside" only works on a wall
+     *  with open air behind it; a wall shared with another room is skipped. */
+    face?: "inside" | "outside";
     color?: string;
     texture?: string;
-    /** cm. Whole-wall, so a shared wall changes for both rooms. */
+    /** cm. Whole-wall rather than per-face, so a shared wall changes for both
+     *  rooms and neither can be combined with `face: "outside"`. */
     thickness?: number;
     height?: number;
 };

package/dist/types/react-planner/ai-chat/furnish.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Furnishing a generated plan.
+ *
+ * This lives in the frontend rather than the packer because it needs the
+ * catalog: what furniture exists, what it is tagged as, and how big it renders.
+ *
+ * A note on sizes. The catalog ships almost every item as a 100x100 placeholder
+ * — a double bed, a bedside cabinet and a TV have the same footprint — and
+ * neither renderer honours a declared width/depth, only a single uniform
+ * `scale` (viewer2d/Item.tsx measures the drawn geometry; viewer3d sets
+ * pivot.scale to one value on all three axes). So a role's size is expressed as
+ * a scale, and clearances are measured against the footprint that produces.
+ * Furniture is therefore square-ish but honestly sized.
+ */
+type Rect = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+export type Furnishing = {
+    itemType: string;
+    x: number;
+    y: number;
+    rotation: number;
+    scale: number;
+};
+/**
+ * Furniture for one room: what goes in it, where, and facing which way.
+ *
+ * Roles are placed in order of importance, each reserving its own footprint AND
+ * the walking space in front of it, so later items cannot land in the space the
+ * bed needs to be got into.
+ */
+export declare function furnishRoom(planner: any, layerID: string, roomType: string, room: Rect, walls: Record<string, string[]>, seed: number): Furnishing[];
+export {};

package/dist/types/react-planner/ai-chat/layoutPacker.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Turns a room program — which rooms, of what type, roughly how big — into
+ * rectangles. The agent never sends coordinates, so this is where a plan
+ * actually acquires geometry.
+ *
+ * Rooms stay axis-aligned rectangles; the BUILDING outline is what varies,
+ * built by packing those rectangles into one, two or three wings.
+ */
+export type Rect = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+export type ProgramRoom = {
+    name: string;
+    roomType: string;
+    size?: "small" | "medium" | "large";
+    /** Other rooms in the same program this one should sit beside, or not. The
+     *  user's own wishes; the RELATIONS table below covers the architecture. */
+    near?: string[];
+    away?: string[];
+};
+export type PackedRoom = ProgramRoom & {
+    rect: Rect;
+};
+export type PackOptions = {
+    totalArea?: number;
+    footprint?: "rectangle" | "L" | "U";
+    seed: number;
+    /** Room types valid for this building type — a hallway is only added if the
+     *  catalog has somewhere to put it. */
+    validTypes: Set<string>;
+    /** Scene centre, in cm. The footprint is centred on it. */
+    centre: {
+        x: number;
+        y: number;
+    };
+    /** Gardens, pools and patios to lay against the outside of the building. */
+    outdoor?: OutdoorRequest[];
+};
+/** Narrower than this and a room stops being usable — the caller reports these
+ *  rather than dropping them silently, since the user asked for them. */
+export declare const MIN_SIDE = 150;
+/** A corridor is legitimately narrower than a room. Callers must use this
+ *  rather than MIN_SIDE directly, or they drop the hallway and leave the two
+ *  halves of the plan with no way between them. */
+export declare const minSideFor: (roomType: string) => 150 | 130;
+export type Side = "left" | "right" | "above" | "below";
+/**
+ * An opening the plan needs. Expressed in the same terms `add-hole` already
+ * uses — two room names, or one room and a side — so the frontend resolves it
+ * with the wall-finding it already has.
+ */
+export type Opening = {
+    kind: "interior";
+    a: string;
+    b: string;
+    holeType: string;
+} | {
+    kind: "entrance";
+    room: string;
+    side: Side;
+    holeType: string;
+    at: number;
+} | {
+    kind: "window";
+    room: string;
+    side: Side;
+    holeType: string;
+    at: number;
+    width: number;
+    height: number;
+    altitude: number;
+};
+/**
+ * Every opening the plan needs: one front door, and a spanning tree of interior
+ * doors reaching every room from it.
+ *
+ * A spanning tree rather than a door on every shared wall — a 9-room house has
+ * around twenty adjacencies and should have about ten doors. Edges are taken
+ * cheapest-first, and a corridor edge always costs zero, so rooms are reached
+ * off the hall rather than through each other whenever the hall touches them.
+ */
+export declare function planDoors(packed: PackedRoom[], seed?: number): Opening[];
+export type OutdoorRequest = {
+    name: string;
+    texture?: string;
+    color?: string;
+    depth?: number;
+};
+export type OutdoorSurface = OutdoorRequest & {
+    /** The room whose wall it lies against, and which side. */
+    of: string;
+    side: Side;
+    depth: number;
+};
+/**
+ * Where the garden, the pool and the patio go.
+ *
+ * A surface runs the FULL width of the wall it lies against, so a side that is
+ * only partly exterior is no good — the surface would be laid straight over the
+ * neighbouring room. Longest wall first, never the entrance elevation (a pool
+ * across the front door is nobody's idea of a villa), and never overlapping a
+ * surface already placed.
+ */
+export declare function planOutdoor(packed: PackedRoom[], wanted: OutdoorRequest[], openings: Opening[]): OutdoorSurface[];
+export declare function packLayout(program: ProgramRoom[], opts: PackOptions): {
+    rooms: PackedRoom[];
+    openings: Opening[];
+    surfaces: OutdoorSurface[];
+};
+/** Rooms sharing enough wall for a door. Anything less is a corner touch. */
+export declare function adjacencyOf(packed: PackedRoom[]): Map<string, PackedRoom[]>;

package/dist/types/react-planner/ai-chat/plannerActions.d.ts

@@ -1,20 +1,5 @@
 import type { PlanSummary, PlannerAction } from "./aiService";
 export declare function summarizePlan(planner: any): PlanSummary;
-/**
- * Applies a batch of actions from the agent to the planner.
- *
- * The agent never sends coordinates. It says how big a room is, what to call
- * it, and which existing room it sits next to — every number describing a
- * POSITION is worked out here, where it can be exact. A room with no `of` /
- * `side` is centered in the scene, which is only ever right for the first room.
- *
- * Rooms created earlier in this same batch are valid anchors: each one is
- * looked up by name from live state after it is created, so a five-room plan
- * arrives as five actions that chain off each other.
- *
- * @returns `skipped` — human-readable reasons anything was not applied, shown
- *   to the user by the caller.
- */
 export declare function applyPlannerActions(actions: PlannerAction[]): {
     skipped: string[];
 };

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

@@ -220,6 +220,19 @@ export declare const MODE_FITTING_IMAGE = "MODE_FITTING_IMAGE";
 export declare const MODE_VIEWING_CATALOG = "MODE_VIEWING_CATALOG";
 export declare const MODE_CONFIGURING_PROJECT = "MODE_CONFIGURING_PROJECT";
 export declare const MODE_SNAPPING: string[];
+/**
+ * The modes in which `Content` mounts the 2D viewer — i.e. the plan `<svg>` is
+ * in the DOM. Every other mode shows the 3D viewer, the catalog list or
+ * nothing, so there is no plan to screenshot.
+ */
+export declare const MODE_2D_VIEWER: string[];
+/**
+ * The subset of `MODE_2D_VIEWER` where a gesture is mid-flight. The scene
+ * legitimately holds preview geometry in these — a wall that follows the
+ * cursor, an unfinished surface polygon, an item being dragged — so they're
+ * states to let settle rather than to capture as finished work.
+ */
+export declare const MODE_IN_PROGRESS: string[];
 export declare const UNIT_MILLIMETER = "mm";
 export declare const UNIT_CENTIMETER = "cm";
 export declare const UNIT_METER = "m";

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

@@ -1,12 +1,21 @@
 /**
  * Keeps a plan thumbnail up to date, handing each new one to `onReady`.
  *
- * Capture is deliberately *ahead* of unload, not during it. `beforeunload`
+ * Every visual change to the 2D view schedules a capture — adding or removing a
+ * room, an item, a wall, a hole, toggling dimensions or the grid. A capture is
+ * only *taken* once the view is in a state worth keeping: not while the 3D
+ * viewer or the catalog is up (there's no plan SVG mounted at all then), and
+ * not mid-gesture, when the scene still holds preview geometry. When the moment
+ * is wrong the change stays pending and the mode change that makes it right
+ * re-arms it, so a room added and then admired in 3D still gets its screenshot.
+ *
+ * Capture is also 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.
+ * capture on a short settle timer, and flush anything still pending when the
+ * page is hidden or the planner unmounts — by the time the tab actually closes,
+ * the consumer already has a current image.
  */
 export declare function usePlanThumbnail(onReady?: (img: string) => void): {
     ensureScreenshot: (force?: boolean) => Promise<void>;

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

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

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

@@ -1,7 +1,9 @@
 import type Catalog from "../catalog/catalog";
+import type { AIRequestHandler } from "../ai-chat/aiService";
 interface ToolbarProps {
     catalog: Catalog;
     has3dView?: boolean;
+    onAIMessage?: AIRequestHandler;
 }
-declare function Toolbar({ catalog, has3dView }: ToolbarProps): import("react/jsx-runtime").JSX.Element;
+declare function Toolbar({ catalog, has3dView, onAIMessage }: ToolbarProps): import("react/jsx-runtime").JSX.Element;
 export default Toolbar;

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

@@ -1,5 +1,5 @@
 import type { ReactNode } from "react";
-export type RailSection = "project" | "build" | "info" | "objects" | "styleboards" | "finishes" | "help";
+export type RailSection = "project" | "build" | "info" | "objects" | "ai" | "styleboards" | "finishes" | "help";
 export interface RailItem {
     key: RailSection;
     label: string;

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

@@ -11,6 +11,12 @@ export interface SubPanelOption {
 }
 interface ToolbarSubPanelProps {
     title: string;
+    /** Fills the panel below the header — used by the chat, which manages its
+        own scrolling and needs the full height rather than a list of options. */
+    children?: ReactNode;
+    /** Kept mounted but out of sight, so a panel holding state (the chat's
+        conversation) survives a trip to another section. */
+    hidden?: boolean;
     options?: SubPanelOption[];
     cta?: string;
     emptyState?: ReactNode;
@@ -19,5 +25,5 @@ interface ToolbarSubPanelProps {
     onBack?: () => void;
     headerExtras?: ReactNode;
 }
-declare const ToolbarSubPanel: ({ title, options, cta, emptyState, catalog, catalogPage, onBack, headerExtras, }: ToolbarSubPanelProps) => import("react/jsx-runtime").JSX.Element;
+declare const ToolbarSubPanel: ({ title, children, hidden, 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

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

package/dist/types/react-planner/utils/visual-change.d.ts

@@ -0,0 +1,12 @@
+import type { ReactPlannerStore } from "../../store/ReactPlannerStore";
+/**
+ * Did anything the 2D viewer paints change — and nothing that doesn't?
+ *
+ * Scene identity is too blunt to drive this. Selection is drawn, so it changes
+ * the pixels and the byte-comparison downstream won't filter it either: left
+ * alone, idly clicking around a finished plan re-uploads a thumbnail per click,
+ * each with a different element highlighted. Geometry, layer visibility, the
+ * viewport box and the view options that live outside the planner record are
+ * what count.
+ */
+export declare function hasVisualChange(next: ReactPlannerStore, prev: ReactPlannerStore): boolean;

package/package.json

@@ -11,7 +11,7 @@
   "files": [
     "dist"
   ],
-  "version": "1.2.5",
+  "version": "1.2.7",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/dist/types/react-planner/ai-chat/AIChatBubble.d.ts

@@ -1,6 +0,0 @@
-import type { AIRequestHandler } from "./aiService";
-interface AIChatBubbleProps {
-    onAIMessage?: AIRequestHandler;
-}
-declare const AIChatBubble: ({ onAIMessage }: AIChatBubbleProps) => import("react/jsx-runtime").JSX.Element;
-export default AIChatBubble;