@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/item/panel.d.ts

@@ -2,9 +2,7 @@
  * Stage E inspector for item. 1:1 port of the legacy
  * `editor/components/ui/panels/item-panel.tsx`, relocated into the
  * kind's folder so `parametrics.customPanel` mounts it through the
- * registry inspector. The catalog popover (`<CollectionsPopover>`) is
- * the only kind-specific UI that can't be expressed via the generic
- * auto-inspector today — kept inline.
+ * registry inspector.
  *
  * Slider-drag fix recipe applied: scale / position / rotation slider
  * `onChange` callbacks read from a `useRef(node)` instead of the

package/dist/item/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/item/panel.tsx"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,uCAwShC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/item/panel.tsx"],"names":[],"mappings":"AAyBA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,uCAiShC"}

package/dist/item/panel.js

@@ -1,17 +1,16 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { getScaledDimensions, ItemNode, useScene } from '@pascal-app/core';
-import { ActionButton, ActionGroup, CollectionsPopover, PanelSection, PanelWrapper, SliderControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { getScaledDimensions, scriptImages, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SliderControl, triggerSFX, useEditor, usePlacementNotice, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Link, Link2Off, Move, Trash2 } from 'lucide-react';
 import { useCallback, useRef, useState } from 'react';
+import { AuthoredParams } from './authored-params';
 /**
  * Stage E inspector for item. 1:1 port of the legacy
  * `editor/components/ui/panels/item-panel.tsx`, relocated into the
  * kind's folder so `parametrics.customPanel` mounts it through the
- * registry inspector. The catalog popover (`<CollectionsPopover>`) is
- * the only kind-specific UI that can't be expressed via the generic
- * auto-inspector today — kept inline.
+ * registry inspector.
  *
  * Slider-drag fix recipe applied: scale / position / rotation slider
  * `onChange` callbacks read from a `useRef(node)` instead of the
@@ -25,6 +24,7 @@ export default function ItemPanel() {
     const deleteNode = useScene((s) => s.deleteNode);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const fitWarning = usePlacementNotice(selectedId);
     const [uniformScale, setUniformScale] = useState(true);
     const nodeRef = useRef(node);
     nodeRef.current = node;
@@ -54,21 +54,9 @@ export default function ItemPanel() {
         }
     }, [node, setMovingNode, setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node)
-            return;
-        triggerSFX('sfx:item-pick');
-        const proto = ItemNode.parse({
-            position: [...node.position],
-            rotation: [...node.rotation],
-            name: node.name,
-            asset: node.asset,
-            parentId: node.parentId,
-            side: node.side,
-            metadata: { isNew: true },
-        });
-        setMovingNode(proto);
-        setSelection({ selectedIds: [] });
-    }, [node, setMovingNode, setSelection]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleDelete = useCallback(() => {
         if (!selectedId)
             return;
@@ -78,10 +66,10 @@ export default function ItemPanel() {
     }, [selectedId, deleteNode, setSelection]);
     if (!(node && node.type === 'item' && selectedId))
         return null;
-    return (_jsxs(PanelWrapper, { icon: node.asset.thumbnail || '/icons/item.webp', onClose: handleClose, title: node.name || node.asset.name, width: 300, children: [_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsxs(PanelSection, { title: "Rotation", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: Math.round((node.rotation[1] * 180) / Math.PI) + 45, min: Math.round((node.rotation[1] * 180) / Math.PI) - 45, onChange: (degrees) => {
+    return (_jsxs(PanelWrapper, { icon: scriptImages(node)?.thumbnail ?? (node.asset.thumbnail || '/icons/item.webp'), onClose: handleClose, title: node.name || node.asset.name, width: 300, children: [fitWarning && (_jsxs("div", { className: "mx-1 mb-1 flex gap-2 rounded-lg bg-amber-400/10 px-3 py-2 text-xs", children: [_jsx("span", { className: "font-semibold text-amber-400", children: "!" }), _jsxs("div", { className: "flex flex-col gap-0.5", children: [_jsx("span", { className: "font-medium text-foreground", children: fitWarning.line }), fitWarning.detail && (_jsx("span", { className: "text-muted-foreground", children: fitWarning.detail }))] })] })), _jsx(AuthoredParams, { node: node }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "pos" })] }), max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsxs(PanelSection, { title: "Rotation", children: [_jsx(TiltSlider, { axis: 0, label: "X", node: node, onUpdate: handleUpdate }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: Math.round((node.rotation[1] * 180) / Math.PI) + 45, min: Math.round((node.rotation[1] * 180) / Math.PI) - 45, onChange: (degrees) => {
                             const radians = (degrees * Math.PI) / 180;
                             handleUpdate({ rotation: [node.rotation[0], radians, node.rotation[2]] });
-                        }, precision: 0, step: 1, unit: "\u00B0", value: Math.round((node.rotation[1] * 180) / Math.PI) }), _jsxs("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: [_jsx(ActionButton, { label: "-45\u00B0", onClick: () => {
+                        }, precision: 0, step: 1, unit: "\u00B0", value: Math.round((node.rotation[1] * 180) / Math.PI) }), _jsx(TiltSlider, { axis: 2, label: "Z", node: node, onUpdate: handleUpdate }), _jsxs("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: [_jsx(ActionButton, { label: "-45\u00B0", onClick: () => {
                                     triggerSFX('sfx:item-rotate');
                                     const currentDegrees = (node.rotation[1] * 180) / Math.PI;
                                     const radians = ((currentDegrees - 45) * Math.PI) / 180;
@@ -99,5 +87,13 @@ export default function ItemPanel() {
                         }, precision: 2, step: 0.1, value: Math.round(node.scale[0] * 100) / 100 })) : (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => handleUpdate({ scale: [Math.max(0.01, value), node.scale[1], node.scale[2]] }), precision: 2, step: 0.1, value: Math.round(node.scale[0] * 100) / 100 }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Y", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => handleUpdate({ scale: [node.scale[0], Math.max(0.01, value), node.scale[2]] }), precision: 2, step: 0.1, value: Math.round(node.scale[1] * 100) / 100 }), _jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["Z", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "scale" })] }), max: 10, min: 0.01, onChange: (value) => handleUpdate({ scale: [node.scale[0], node.scale[1], Math.max(0.01, value)] }), precision: 2, step: 0.1, value: Math.round(node.scale[2] * 100) / 100 })] }))] }), _jsx(PanelSection, { title: "Info", children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: "Dimensions" }), (() => {
                             const [w, h, d] = getScaledDimensions(node);
                             return (_jsxs("span", { className: "font-mono text-white", children: [Math.round(w * 100) / 100, "\u00D7", Math.round(h * 100) / 100, "\u00D7", Math.round(d * 100) / 100] }));
-                        })()] }) }), _jsx(PanelSection, { title: "Collections", children: _jsx(ActionGroup, { children: _jsx(CollectionsPopover, { collectionIds: node.collectionIds, nodeId: selectedId, children: _jsx(ActionButton, { label: "Manage collections\u2026" }) }) }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+                        })()] }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}
+/** Tilt about X or Z: aiming a spotlight, leaning a frame. Y stays the main turn above. */
+function TiltSlider({ axis, label, node, onUpdate, }) {
+    return (_jsx(SliderControl, { label: _jsxs(_Fragment, { children: [label, _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "rot" })] }), max: 180, min: -180, onChange: (degrees) => {
+            const rotation = [...node.rotation];
+            rotation[axis] = (degrees * Math.PI) / 180;
+            onUpdate({ rotation });
+        }, precision: 0, step: 1, unit: "\u00B0", value: Math.round((node.rotation[axis] * 180) / Math.PI) }));
 }

package/dist/item/placement-notice.d.ts

@@ -0,0 +1,14 @@
+import { type AnyNode, type ItemNode, type LiveTransformLike, type PlacementNotice } from '@pascal-app/core';
+import { type FloorItemMisfit } from '@pascal-app/core/building';
+/** What a person reads for a floor item that does not fit: in a door's way, or too large for its room. */
+export declare function floorItemMisfitNotice(misfit: FloorItemMisfit, dimensions: readonly number[]): PlacementNotice;
+/**
+ * The item's `placementNotice`: a floor item in a door's way or too large for its room, by the
+ * check place_items refuses with (`floorItemFit`), at its live pose while it is placed or moved.
+ * An item on a table, a shelf or a wall is not checked.
+ */
+export declare function itemPlacementNotice(node: ItemNode, { nodes, live }: {
+    nodes: Readonly<Record<string, AnyNode>>;
+    live?: LiveTransformLike;
+}): PlacementNotice | null;
+//# sourceMappingURL=placement-notice.d.ts.map

package/dist/item/placement-notice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement-notice.d.ts","sourceRoot":"","sources":["../../src/item/placement-notice.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,KAAK,eAAe,EAAgB,MAAM,2BAA2B,CAAA;AAI9E,0GAA0G;AAC1G,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,SAAS,MAAM,EAAE,GAC5B,eAAe,CAQjB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;IAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAAC,IAAI,CAAC,EAAE,iBAAiB,CAAA;CAAE,GACtF,eAAe,GAAG,IAAI,CAkBxB"}

package/dist/item/placement-notice.js

@@ -0,0 +1,38 @@
+import { getScaledDimensions, } from '@pascal-app/core';
+import { floorItemFit } from '@pascal-app/core/building';
+const round = (value) => Math.round(value * 100) / 100;
+/** What a person reads for a floor item that does not fit: in a door's way, or too large for its room. */
+export function floorItemMisfitNotice(misfit, dimensions) {
+    const name = misfit.room?.name.trim();
+    if (misfit.code === 'blocks_door')
+        return { line: name ? `Blocks the door to ${name}` : 'Blocks a door' };
+    return {
+        line: name ? `Too large for ${name}` : 'Too large for its room',
+        detail: `${round(dimensions[0] ?? 0)} × ${round(dimensions[2] ?? 0)} m in a ${round(misfit.room.width)} × ${round(misfit.room.depth)} m room`,
+    };
+}
+/**
+ * The item's `placementNotice`: a floor item in a door's way or too large for its room, by the
+ * check place_items refuses with (`floorItemFit`), at its live pose while it is placed or moved.
+ * An item on a table, a shelf or a wall is not checked.
+ */
+export function itemPlacementNotice(node, { nodes, live }) {
+    if (!node.parentId || nodes[node.parentId]?.type !== 'level')
+        return null;
+    const item = live
+        ? {
+            ...node,
+            position: live.position,
+            rotation: [node.rotation[0], live.rotation, node.rotation[2]],
+        }
+        : node;
+    const dimensions = getScaledDimensions(item);
+    const misfit = floorItemFit(nodes, {
+        levelId: node.parentId,
+        x: item.position[0],
+        z: item.position[2],
+        rotationDeg: ((item.rotation?.[1] ?? 0) * 180) / Math.PI,
+        dimensions,
+    });
+    return misfit ? floorItemMisfitNotice(misfit, dimensions) : null;
+}

package/dist/item/plan-symbols.d.ts

@@ -0,0 +1,67 @@
+import type { FloorplanGeometry, FloorplanPoint } from '@pascal-app/core';
+/**
+ * PERMIT-SET PLAN SYMBOLS for items — what a sheet draws instead of the
+ * asset's raster sprite: real fixtures (sinks …) with fixture labels, as a
+ * full plan set shows them.
+ *
+ * A plans examiner reads plumbing fixtures and appliances off the floor plan,
+ * so those draw as crisp linework at true size with the standard label (WC,
+ * LAV, TUB, SHWR, W, D, WH, REF, R, DW …). Furniture is thin light-grey
+ * outline, a car a light dashed outline, and ceiling-mounted items, wall
+ * devices and decor are left off — the lights go on the electrical plan.
+ *
+ * Symbols are built in the item's LOCAL plan frame, true size: x across the
+ * width, y along the depth, the BACK (the wall it stands against) at
+ * y = -depth / 2 and the front at +depth / 2. The caller maps the points.
+ */
+/**
+ * Metadata key on a drafted item's group naming what it is (`fixture`,
+ * `furniture`, `car`) — how a sheet tells a WC it must keep text off from a
+ * bed it may overlap, without re-classifying the asset itself.
+ */
+export declare const PLAN_SYMBOL_METADATA_KEY = "pascal:sheet/plan-symbol";
+export type PlanFixtureKind = 'wc' | 'lav' | 'tub' | 'shower' | 'washer' | 'dryer' | 'washer-dryer' | 'water-heater' | 'ref' | 'range' | 'cooktop' | 'oven' | 'dw' | 'mw' | 'sink' | 'fireplace' | 'ev' | 'condenser';
+export type PlanItemClass = {
+    kind: 'fixture';
+    fixture: PlanFixtureKind;
+    label: string;
+} | {
+    kind: 'casework';
+} | {
+    kind: 'car';
+} | {
+    kind: 'furniture';
+    shape: 'bed' | 'sofa' | 'plain';
+} | {
+    kind: 'omit';
+};
+type AssetLike = {
+    id?: string;
+    name?: string;
+    category?: string;
+    tags?: readonly string[];
+    attachTo?: string;
+};
+/** What a sheet draws for an item, from its asset. */
+export declare function classifyPlanItem(asset: AssetLike): PlanItemClass;
+/** Fixture linework — the weight casework draws in, near-black. */
+export declare const FIXTURE_STROKE = "#1f2937";
+export declare const FIXTURE_STROKE_WIDTH = 0.012;
+/** Furniture: thin, light grey — present, never competing with the walls. */
+export declare const FURNITURE_STROKE = "#9ca3af";
+export declare const FURNITURE_STROKE_WIDTH = 0.006;
+/** Fixture label size on the paper, points, and its plan-metre size at 1/4" = 1'-0". */
+export declare const FIXTURE_LABEL_PT = 6.5;
+export declare const FIXTURE_LABEL_SIZE = 0.11;
+export type PlanSymbolFrame = {
+    /** Local (x across, y along the depth; back = -depth / 2) → plan point. */
+    map: (x: number, y: number) => FloorplanPoint;
+    width: number;
+    depth: number;
+};
+/**
+ * The drafting symbol for an item, in plan coordinates. Empty for `omit`.
+ */
+export declare function buildPlanItemSymbol(cls: PlanItemClass, frame: PlanSymbolFrame): FloorplanGeometry[];
+export {};
+//# sourceMappingURL=plan-symbols.d.ts.map

package/dist/item/plan-symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-symbols.d.ts","sourceRoot":"","sources":["../../src/item/plan-symbols.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAGzE;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,6BAA6B,CAAA;AAElE,MAAM,MAAM,eAAe,GACvB,IAAI,GACJ,KAAK,GACL,KAAK,GACL,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,cAAc,GACd,cAAc,GACd,KAAK,GACL,OAAO,GACP,SAAS,GACT,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,MAAM,GACN,WAAW,GACX,IAAI,GACJ,WAAW,CAAA;AAEf,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GACpB;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GACf;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpB,KAAK,SAAS,GAAG;IACf,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AA4CD,sDAAsD;AACtD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa,CA2BhE;AAID,mEAAmE;AACnE,eAAO,MAAM,cAAc,YAAY,CAAA;AACvC,eAAO,MAAM,oBAAoB,QAAQ,CAAA;AAEzC,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,YAAY,CAAA;AACzC,eAAO,MAAM,sBAAsB,QAAQ,CAAA;AAE3C,wFAAwF;AACxF,eAAO,MAAM,gBAAgB,MAAM,CAAA;AACnC,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC,MAAM,MAAM,eAAe,GAAG;IAC5B,2EAA2E;IAC3E,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,cAAc,CAAA;IAC7C,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,aAAa,EAClB,KAAK,EAAE,eAAe,GACrB,iBAAiB,EAAE,CAqBrB"}

package/dist/item/plan-symbols.js

@@ -0,0 +1,407 @@
+import { floorplanGeometryMetadata } from '@pascal-app/editor';
+/**
+ * PERMIT-SET PLAN SYMBOLS for items — what a sheet draws instead of the
+ * asset's raster sprite: real fixtures (sinks …) with fixture labels, as a
+ * full plan set shows them.
+ *
+ * A plans examiner reads plumbing fixtures and appliances off the floor plan,
+ * so those draw as crisp linework at true size with the standard label (WC,
+ * LAV, TUB, SHWR, W, D, WH, REF, R, DW …). Furniture is thin light-grey
+ * outline, a car a light dashed outline, and ceiling-mounted items, wall
+ * devices and decor are left off — the lights go on the electrical plan.
+ *
+ * Symbols are built in the item's LOCAL plan frame, true size: x across the
+ * width, y along the depth, the BACK (the wall it stands against) at
+ * y = -depth / 2 and the front at +depth / 2. The caller maps the points.
+ */
+/**
+ * Metadata key on a drafted item's group naming what it is (`fixture`,
+ * `furniture`, `car`) — how a sheet tells a WC it must keep text off from a
+ * bed it may overlap, without re-classifying the asset itself.
+ */
+export const PLAN_SYMBOL_METADATA_KEY = 'pascal:sheet/plan-symbol';
+const FIXTURES = [
+    { test: /\btoilet\b(?!-paper)|water-?closet|\bwc\b/, fixture: 'wc', label: 'WC' },
+    { test: /bathroom-sink|lavatory|\blav\b|\bvanity\b|wash-?basin/, fixture: 'lav', label: 'LAV' },
+    { test: /\bbathtub\b|\bbath-?tub\b|^bath$|\btub\b/, fixture: 'tub', label: 'TUB' },
+    { test: /\bshower\b(?!-rug|-curtain|-caddy)/, fixture: 'shower', label: 'SHWR' },
+    {
+        test: /washer-?dryer|washer\/dryer|laundry-?pair|stacked-?laundry/,
+        fixture: 'washer-dryer',
+        label: 'W/D',
+    },
+    { test: /washing-?machine|(?<!dish)\bwasher\b|clothes-?washer/, fixture: 'washer', label: 'W' },
+    { test: /(?<!hair-)\bdryer\b|clothes-?dryer|tumble/, fixture: 'dryer', label: 'D' },
+    { test: /water-?heater|\bboiler\b|tankless/, fixture: 'water-heater', label: 'WH' },
+    { test: /fridge|refrigerator|freezer/, fixture: 'ref', label: 'REF' },
+    { test: /dishwasher/, fixture: 'dw', label: 'DW' },
+    { test: /microwave/, fixture: 'mw', label: 'MW' },
+    { test: /cooktop|\bhob\b/, fixture: 'cooktop', label: 'CT' },
+    { test: /\bstove\b|\brange\b(?!-hood)/, fixture: 'range', label: 'R' },
+    { test: /\boven\b/, fixture: 'oven', label: 'OV' },
+    {
+        test: /kitchen-?sink|bar-?sink|utility-?sink|laundry-?sink|\bsink\b/,
+        fixture: 'sink',
+        label: 'SINK',
+    },
+    { test: /fireplace|wood-?stove/, fixture: 'fireplace', label: 'FP' },
+    { test: /ev-?(wall-)?charger|\bevse\b/, fixture: 'ev', label: 'EV' },
+    { test: /ac-block|condenser|condensing-unit|heat-pump/, fixture: 'condenser', label: 'A/C' },
+];
+/** Built-in cabinets and counters placed as items: casework, drawn in ink like a cabinet run. */
+const CASEWORK = /kitchen-counter|kitchen-cabinet|kitchen-island|kitchen-bar|^kitchen$|base-cabinet|^cabinet$|modular-cabinet/;
+/** Decor, loose kitchenware and wall devices: not drawn on a permit floor plan. */
+const OMIT = /plant|cactus|\btree\b|\bbush\b|\bpalm\b|carpet|\brug\b|picture|mirror|lamp|light|toilet-?paper|laundry-?bag|\bbooks?\b|\btoy\b|\bball\b|skate|scooter|kettle|toaster|frying|fruit|wine|utensil|cutting-?board|coffee-?machine|\biron\b|ironing|computer|speaker|guitar|easel|sewing|barbell|outlet|thermostat|keypad|detector|sprinkler|exit-?sign|electric-?panel|alarm|umbrella|hydrant|basket|drying-?rack|coat-?rack|\bhood\b|television|\btv\b(?!-stand)|air-?conditioning|parking-?spot|kitchen-?shelf/;
+const CAR = /\bcar\b(?!-toy)|tesla|camaro|chevrolet|\btruck\b|sedan|\bsuv\b|vehicle/;
+const BED = /\bbed\b|bunkbed|double-bed|single-bed/;
+const SOFA = /sofa|couch|sectional|loveseat/;
+/** What a sheet draws for an item, from its asset. */
+export function classifyPlanItem(asset) {
+    if (asset.attachTo === 'ceiling')
+        return { kind: 'omit' };
+    const id = (asset.id ?? '').toLowerCase();
+    const name = (asset.name ?? '').toLowerCase().replace(/\s+/g, '-');
+    // the id first: it is the catalog's own word for the thing
+    for (const text of [id, name]) {
+        if (!text)
+            continue;
+        for (const entry of FIXTURES) {
+            if (!entry.test.test(text))
+                continue;
+            // a tub with a shower over it is the TUB/SHWR a plan labels
+            if (entry.fixture === 'tub' && /shower/.test(`${id} ${name}`)) {
+                return { kind: 'fixture', fixture: 'tub', label: 'TUB/SHWR' };
+            }
+            return { kind: 'fixture', fixture: entry.fixture, label: entry.label };
+        }
+    }
+    const words = `${id} ${name}`;
+    if (CASEWORK.test(id) || CASEWORK.test(name))
+        return { kind: 'casework' };
+    if (CAR.test(words))
+        return { kind: 'car' };
+    if (OMIT.test(words))
+        return { kind: 'omit' };
+    if (asset.attachTo === 'wall' || asset.attachTo === 'wall-side') {
+        // shelves, cabinets and the like hang on a wall inside the cut: outline them
+        return { kind: 'furniture', shape: 'plain' };
+    }
+    if (BED.test(words))
+        return { kind: 'furniture', shape: 'bed' };
+    if (SOFA.test(words))
+        return { kind: 'furniture', shape: 'sofa' };
+    return { kind: 'furniture', shape: 'plain' };
+}
+/* ------------------------------------------------------------ styles */
+/** Fixture linework — the weight casework draws in, near-black. */
+export const FIXTURE_STROKE = '#1f2937';
+export const FIXTURE_STROKE_WIDTH = 0.012;
+const FIXTURE_DETAIL_WIDTH = 0.008;
+/** Furniture: thin, light grey — present, never competing with the walls. */
+export const FURNITURE_STROKE = '#9ca3af';
+export const FURNITURE_STROKE_WIDTH = 0.006;
+const LABEL_FILL = '#111827';
+/** Fixture label size on the paper, points, and its plan-metre size at 1/4" = 1'-0". */
+export const FIXTURE_LABEL_PT = 6.5;
+export const FIXTURE_LABEL_SIZE = 0.11;
+/**
+ * The drafting symbol for an item, in plan coordinates. Empty for `omit`.
+ */
+export function buildPlanItemSymbol(cls, frame) {
+    switch (cls.kind) {
+        case 'omit':
+            return [];
+        case 'car':
+            return [carOutline(frame)];
+        case 'casework': {
+            const hw = frame.width / 2;
+            const hd = frame.depth / 2;
+            return [
+                polygon(frame, rect(-hw, -hd, hw, hd), {
+                    ...OUTLINE,
+                    strokeWidth: FIXTURE_DETAIL_WIDTH * 1.25,
+                }),
+            ];
+        }
+        case 'furniture':
+            return furnitureSymbol(cls.shape, frame);
+        case 'fixture':
+            return fixtureSymbol(cls.fixture, cls.label, frame);
+    }
+}
+const OUTLINE = {
+    stroke: FIXTURE_STROKE,
+    strokeWidth: FIXTURE_STROKE_WIDTH,
+    fill: '#ffffff',
+};
+const DETAIL = { stroke: FIXTURE_STROKE, strokeWidth: FIXTURE_DETAIL_WIDTH, fill: 'none' };
+const FURNITURE = {
+    stroke: FURNITURE_STROKE,
+    strokeWidth: FURNITURE_STROKE_WIDTH,
+    fill: 'none',
+};
+function polygon(frame, points, style) {
+    return {
+        kind: 'polygon',
+        points: points.map(([x, y]) => frame.map(x, y)),
+        fill: style.fill ?? 'none',
+        stroke: style.stroke,
+        strokeWidth: style.strokeWidth,
+        strokeDasharray: style.strokeDasharray,
+        strokeLinejoin: 'round',
+    };
+}
+function line(frame, x1, y1, x2, y2, style) {
+    const [ax, ay] = frame.map(x1, y1);
+    const [bx, by] = frame.map(x2, y2);
+    return {
+        kind: 'line',
+        x1: ax,
+        y1: ay,
+        x2: bx,
+        y2: by,
+        stroke: style.stroke,
+        strokeWidth: style.strokeWidth,
+        strokeDasharray: style.strokeDasharray,
+    };
+}
+function circle(frame, x, y, r, style) {
+    const [cx, cy] = frame.map(x, y);
+    return {
+        kind: 'circle',
+        cx,
+        cy,
+        r,
+        fill: style.fill ?? 'none',
+        stroke: style.stroke,
+        strokeWidth: style.strokeWidth,
+    };
+}
+function rect(x0, y0, x1, y1) {
+    return [
+        [x0, y0],
+        [x1, y0],
+        [x1, y1],
+        [x0, y1],
+    ];
+}
+function roundedRect(x0, y0, x1, y1, radius) {
+    const r = Math.max(0, Math.min(radius, (x1 - x0) / 2, (y1 - y0) / 2));
+    if (r < 1e-4)
+        return rect(x0, y0, x1, y1);
+    const out = [];
+    const corner = (cx, cy, from) => {
+        for (let i = 0; i <= 4; i++) {
+            const a = from + (i / 4) * (Math.PI / 2);
+            out.push([cx + Math.cos(a) * r, cy + Math.sin(a) * r]);
+        }
+    };
+    corner(x1 - r, y0 + r, -Math.PI / 2);
+    corner(x1 - r, y1 - r, 0);
+    corner(x0 + r, y1 - r, Math.PI / 2);
+    corner(x0 + r, y0 + r, Math.PI);
+    return out;
+}
+function ellipse(cx, cy, rx, ry, segments = 32) {
+    const out = [];
+    for (let i = 0; i < segments; i++) {
+        const a = (i / segments) * Math.PI * 2;
+        out.push([cx + Math.cos(a) * rx, cy + Math.sin(a) * ry]);
+    }
+    return out;
+}
+/**
+ * A fixture label. Text is an annotation on a sheet, printed at a fixed paper
+ * size (`FIXTURE_LABEL_PT`) whatever the scale; `fontSize` is its plan-metre
+ * size at 1/4" = 1'-0" for any view that draws it in plan units. Each label
+ * is its own group so two labels that share an x (a double vanity's LAVs)
+ * are never read as one stacked block and re-spaced together.
+ */
+function label(frame, text, x, y) {
+    const [px, py] = frame.map(x, y);
+    return {
+        kind: 'group',
+        children: [
+            {
+                kind: 'text',
+                x: px,
+                y: py,
+                text,
+                fontSize: FIXTURE_LABEL_SIZE,
+                fill: LABEL_FILL,
+                fontWeight: 700,
+                fontFamily: 'Helvetica, Arial, sans-serif',
+                textAnchor: 'middle',
+                dominantBaseline: 'central',
+                upright: true,
+                metadata: floorplanGeometryMetadata({ textSizePt: FIXTURE_LABEL_PT }),
+            },
+        ],
+    };
+}
+/* ------------------------------------------------------------ symbols */
+function carOutline(frame) {
+    const hw = frame.width / 2;
+    const hd = frame.depth / 2;
+    return polygon(frame, roundedRect(-hw, -hd, hw, hd, Math.min(hw, hd) * 0.35), {
+        stroke: FURNITURE_STROKE,
+        strokeWidth: FURNITURE_STROKE_WIDTH * 1.2,
+        fill: 'none',
+        strokeDasharray: '0.18 0.12',
+    });
+}
+function furnitureSymbol(shape, frame) {
+    const hw = frame.width / 2;
+    const hd = frame.depth / 2;
+    const out = [polygon(frame, rect(-hw, -hd, hw, hd), FURNITURE)];
+    if (shape === 'bed' && frame.depth > 1.2) {
+        // pillows at the head (the back), the turned-down sheet across
+        const pillows = frame.width >= 1.2 ? 2 : 1;
+        const gap = 0.06;
+        const pw = (frame.width - gap * (pillows + 1)) / pillows;
+        for (let i = 0; i < pillows; i++) {
+            const x0 = -hw + gap + i * (pw + gap);
+            out.push(polygon(frame, roundedRect(x0, -hd + gap, x0 + pw, -hd + gap + 0.2, 0.05), FURNITURE));
+        }
+        out.push(line(frame, -hw, -hd + 0.5, hw, -hd + 0.5, FURNITURE));
+    }
+    else if (shape === 'sofa' && frame.depth > 0.5 && frame.width > 1) {
+        const back = -hd + Math.min(0.22, frame.depth * 0.25);
+        const arm = Math.min(0.2, frame.width * 0.12);
+        out.push(line(frame, -hw, back, hw, back, FURNITURE));
+        out.push(line(frame, -hw + arm, back, -hw + arm, hd, FURNITURE));
+        out.push(line(frame, hw - arm, back, hw - arm, hd, FURNITURE));
+    }
+    return out;
+}
+function fixtureSymbol(fixture, text, frame) {
+    const w = frame.width;
+    const d = frame.depth;
+    const hw = w / 2;
+    const hd = d / 2;
+    const out = [];
+    switch (fixture) {
+        case 'wc': {
+            // tank against the wall, elongated bowl in front of it
+            const tank = Math.min(0.22, Math.max(0.15, d * 0.3));
+            out.push(polygon(frame, roundedRect(-hw, -hd, hw, -hd + tank, 0.03), OUTLINE));
+            const bowlLength = Math.max(0.2, d - tank - 0.02);
+            const cy = -hd + tank + bowlLength / 2;
+            const rx = Math.min(hw * 0.92, 0.2);
+            out.push(polygon(frame, ellipse(0, cy, rx, bowlLength / 2), OUTLINE));
+            out.push(polygon(frame, ellipse(0, cy + bowlLength * 0.04, rx * 0.68, bowlLength * 0.34), DETAIL));
+            out.push(label(frame, text, 0, cy + bowlLength * 0.04));
+            return out;
+        }
+        case 'lav': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            // a double vanity from 48 in wide: a basin per sink, each labelled
+            const basins = w >= 1.2 ? 2 : 1;
+            const pitch = w / basins;
+            const rx = Math.min(0.22, pitch * 0.34);
+            const ry = Math.min(0.17, d * 0.3);
+            for (let i = 0; i < basins; i++) {
+                const cx = -hw + pitch * (i + 0.5);
+                const cy = d * 0.04;
+                out.push(polygon(frame, ellipse(cx, cy, rx, ry), DETAIL));
+                out.push(circle(frame, cx, cy - ry - 0.05, 0.018, DETAIL));
+                out.push(label(frame, 'LAV', cx, cy));
+            }
+            return out;
+        }
+        case 'tub': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            const inset = Math.min(0.08, Math.min(w, d) * 0.1);
+            // the long axis carries the drain at one end
+            const long = w >= d;
+            out.push(polygon(frame, roundedRect(-hw + inset, -hd + inset, hw - inset, hd - inset, Math.min(w, d) * 0.22), DETAIL));
+            if (long)
+                out.push(circle(frame, -hw + inset + 0.14, 0, 0.03, DETAIL));
+            else
+                out.push(circle(frame, 0, -hd + inset + 0.14, 0.03, DETAIL));
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+        case 'shower': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            const inset = Math.min(0.05, Math.min(w, d) * 0.08);
+            out.push(polygon(frame, rect(-hw + inset, -hd + inset, hw - inset, hd - inset), DETAIL));
+            // the drain, and the diagonals a shower pan is drawn with, stopped short of the label
+            out.push(circle(frame, 0, d * 0.22, 0.035, DETAIL));
+            out.push(line(frame, -hw + inset, hd - inset, -0.08, d * 0.22 + 0.06, DETAIL));
+            out.push(line(frame, hw - inset, hd - inset, 0.08, d * 0.22 + 0.06, DETAIL));
+            out.push(label(frame, text, 0, -d * 0.08));
+            return out;
+        }
+        case 'washer':
+        case 'dryer':
+        case 'washer-dryer': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            if (fixture === 'washer')
+                out.push(circle(frame, 0, 0, Math.min(w, d) * 0.32, DETAIL));
+            if (fixture === 'washer-dryer')
+                out.push(line(frame, -hw, hd - 0.06, hw, hd - 0.06, DETAIL));
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+        case 'water-heater': {
+            const r = Math.min(w, d) / 2;
+            out.push(circle(frame, 0, 0, r, OUTLINE));
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+        case 'ref': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            // the door's swing line across the front
+            out.push(line(frame, -hw, hd - Math.min(0.06, d * 0.1), hw, hd - Math.min(0.06, d * 0.1), DETAIL));
+            out.push(label(frame, text, 0, -d * 0.05));
+            return out;
+        }
+        case 'range':
+        case 'cooktop': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            const r = Math.min(0.08, w * 0.13, d * 0.14);
+            for (const [x, y] of [
+                [-w * 0.26, -d * 0.2],
+                [w * 0.26, -d * 0.2],
+                [-w * 0.26, d * 0.18],
+                [w * 0.26, d * 0.18],
+            ]) {
+                out.push(circle(frame, x, y, r, DETAIL));
+            }
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+        case 'sink': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            const inset = Math.min(0.06, Math.min(w, d) * 0.12);
+            out.push(polygon(frame, roundedRect(-hw + inset, -hd + inset * 1.8, hw - inset, hd - inset, 0.04), DETAIL));
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+        case 'fireplace': {
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), {
+                ...OUTLINE,
+                strokeWidth: FIXTURE_STROKE_WIDTH * 1.4,
+            }));
+            if (d > 0.3) {
+                // the firebox, splayed toward the room
+                const back = -hd + d * 0.25;
+                out.push(polygon(frame, [
+                    [-w * 0.2, back],
+                    [w * 0.2, back],
+                    [w * 0.32, hd],
+                    [-w * 0.32, hd],
+                ], DETAIL));
+            }
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+        default: {
+            // DW, MW, OV, EV: the box and its label
+            out.push(polygon(frame, rect(-hw, -hd, hw, hd), OUTLINE));
+            out.push(label(frame, text, 0, 0));
+            return out;
+        }
+    }
+}