@pascal-app/nodes 0.1.1

package/dist/door/paint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Door paint on the unified slot model. The door's opening proxy (a proud,
+ * invisible cutout) wins the shared scene raycast over the wall in front of the
+ * recessed door body, so `resolveSlotByReRaycast` re-raycasts the door's own
+ * subtree to find the part (panel / frame / glass / hardware) under the cursor.
+ */
+export declare const doorPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/door/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/door/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAGpB,CAAA"}

package/dist/door/paint.js

@@ -0,0 +1,11 @@
+import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint';
+/**
+ * Door paint on the unified slot model. The door's opening proxy (a proud,
+ * invisible cutout) wins the shared scene raycast over the wall in front of the
+ * recessed door body, so `resolveSlotByReRaycast` re-raycasts the door's own
+ * subtree to find the part (panel / frame / glass / hardware) under the cursor.
+ */
+export const doorPaint = createSlotPaintCapability({
+    resolveRole: resolveSlotByReRaycast,
+    applyPreview: previewSlotByUserData,
+});

package/dist/door/panel.d.ts

@@ -0,0 +1,2 @@
+export default function DoorPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/door/panel.tsx"],"names":[],"mappings":"AAsIA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAmoChC"}

package/dist/door/panel.js

@@ -0,0 +1,576 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { DoorNode, useInteractive, useScene } from '@pascal-app/core';
+import { ActionButton, ActionGroup, cn, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Copy, DoorOpen, FlipHorizontal2, Move, Trash2 } from 'lucide-react';
+import { useCallback, useRef } from 'react';
+import { scaleHandleHeight } from './door-math';
+const doorTypeOptions = [
+    { label: 'Hinged', value: 'hinged', available: true },
+    { label: 'Double', value: 'double', available: true },
+    { label: 'French', value: 'french', available: true },
+    { label: 'Folding', value: 'folding', available: true },
+    { label: 'Pocket', value: 'pocket', available: true },
+    { label: 'Barn', value: 'barn', available: true },
+    { label: 'Sliding', value: 'sliding', available: true },
+];
+const garageDoorTypeOptions = [
+    { label: 'Sectional', value: 'garage-sectional', available: true },
+    { label: 'Roll-up', value: 'garage-rollup', available: true },
+    { label: 'Tilt-up', value: 'garage-tiltup', available: true },
+];
+const frenchDoorSegments = [
+    {
+        type: 'glass',
+        heightRatio: 0.76,
+        columnRatios: [1, 1],
+        dividerThickness: 0.025,
+        panelDepth: 0.01,
+        panelInset: 0.04,
+    },
+    {
+        type: 'panel',
+        heightRatio: 0.24,
+        columnRatios: [1],
+        dividerThickness: 0.03,
+        panelDepth: 0.012,
+        panelInset: 0.035,
+    },
+];
+const foldingDoorSegments = [
+    {
+        type: 'panel',
+        heightRatio: 1,
+        columnRatios: [1],
+        dividerThickness: 0.02,
+        panelDepth: 0.008,
+        panelInset: 0.025,
+    },
+];
+const hingedDoorSegments = [
+    {
+        type: 'panel',
+        heightRatio: 0.4,
+        columnRatios: [1],
+        dividerThickness: 0.03,
+        panelDepth: 0.01,
+        panelInset: 0.04,
+    },
+    {
+        type: 'panel',
+        heightRatio: 0.6,
+        columnRatios: [1],
+        dividerThickness: 0.03,
+        panelDepth: 0.01,
+        panelInset: 0.04,
+    },
+];
+const defaultDoorDimensions = {
+    hinged: { width: 0.9, height: 2.1 },
+    double: { width: 1.5, height: 2.1 },
+    french: { width: 1.5, height: 2.1 },
+    folding: { width: 1.8, height: 2.1 },
+    pocket: { width: 0.9, height: 2.1 },
+    barn: { width: 1, height: 2.1 },
+    sliding: { width: 1.5, height: 2.1 },
+    'garage-sectional': { width: 2.7, height: 2.4 },
+    'garage-rollup': { width: 2.7, height: 2.4 },
+    'garage-tiltup': { width: 2.7, height: 2.4 },
+};
+const defaultDoorSegmentsByType = {
+    hinged: hingedDoorSegments,
+    double: hingedDoorSegments,
+    french: frenchDoorSegments,
+    folding: foldingDoorSegments,
+    pocket: foldingDoorSegments,
+    barn: foldingDoorSegments,
+    sliding: frenchDoorSegments,
+    'garage-sectional': foldingDoorSegments,
+    'garage-rollup': foldingDoorSegments,
+    'garage-tiltup': foldingDoorSegments,
+};
+function isSameDoorValue(current, next) {
+    if (typeof current === 'number' && typeof next === 'number') {
+        return Math.abs(current - next) < 1e-6;
+    }
+    if (Array.isArray(current) && Array.isArray(next)) {
+        return (current.length === next.length &&
+            current.every((value, index) => isSameDoorValue(value, next[index])));
+    }
+    return Object.is(current, next);
+}
+export default function DoorPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const deleteNode = useScene((s) => s.deleteNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const previewRef = useRef(null);
+    const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    // Panel slider-drag fix recipe (plans/editor-node-registry.md). Without
+    // it, the 29+ SliderControls in this panel would loop on drag.
+    const handleUpdate = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        const liveNode = useScene.getState().nodes[selectedId];
+        if (liveNode?.type !== 'door')
+            return;
+        const hasChange = Object.entries(updates).some(([key, value]) => {
+            const currentValue = liveNode[key];
+            return !isSameDoorValue(currentValue, value);
+        });
+        if (!hasChange)
+            return;
+        if ('operationState' in updates || 'swingAngle' in updates || 'doorType' in updates) {
+            useInteractive.getState().removeDoorOpenState(selectedId);
+        }
+        useScene.getState().updateNode(selectedId, updates);
+        const scene = useScene.getState();
+        scene.dirtyNodes.add(selectedId);
+        if (liveNode.parentId)
+            scene.dirtyNodes.add(liveNode.parentId);
+    }, [selectedId]);
+    const previewDoorUpdate = useCallback((key, value) => {
+        if (!selectedId)
+            return;
+        const liveNode = useScene.getState().nodes[selectedId];
+        if (liveNode?.type !== 'door')
+            return;
+        if (!(previewRef.current &&
+            previewRef.current.id === selectedId &&
+            previewRef.current.key === key)) {
+            previewRef.current = {
+                id: selectedId,
+                key,
+                value: liveNode[key],
+            };
+        }
+        if (isSameDoorValue(liveNode[key], value))
+            return;
+        liveNode[key] = value;
+        useScene.getState().dirtyNodes.add(selectedId);
+    }, [selectedId]);
+    const commitDoorPreview = useCallback((key, value) => {
+        if (!selectedId)
+            return;
+        const scene = useScene.getState();
+        const liveNode = scene.nodes[selectedId];
+        const preview = previewRef.current;
+        if (liveNode?.type === 'door' && preview?.id === selectedId && preview.key === key) {
+            ;
+            liveNode[key] = preview.value;
+            scene.dirtyNodes.add(selectedId);
+        }
+        previewRef.current = null;
+        useScene
+            .getState()
+            .updateNode(selectedId, { [key]: value });
+        scene.dirtyNodes.add(selectedId);
+    }, [selectedId]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleFlip = useCallback(() => {
+        if (!node)
+            return;
+        handleUpdate({
+            side: node.side === 'front' ? 'back' : 'front',
+            rotation: [node.rotation[0], node.rotation[1] + Math.PI, node.rotation[2]],
+        });
+    }, [node, handleUpdate]);
+    const handleMove = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!(selectedId && node))
+            return;
+        triggerSFX('sfx:item-delete');
+        deleteNode(selectedId);
+        if (node.parentId)
+            useScene.getState().dirtyNodes.add(node.parentId);
+        setSelection({ selectedIds: [] });
+    }, [selectedId, node, deleteNode, setSelection]);
+    const handleDuplicate = useCallback(() => {
+        if (!node?.parentId)
+            return;
+        triggerSFX('sfx:item-pick');
+        useScene.temporal.getState().pause();
+        const cloned = structuredClone(node);
+        delete cloned.id;
+        cloned.metadata = { ...cloned.metadata, isNew: true };
+        const duplicate = DoorNode.parse(cloned);
+        useScene.getState().createNode(duplicate, node.parentId);
+        setMovingNode(duplicate);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    const setSegmentHeightRatio = (segIdx, newVal) => {
+        if (!node)
+            return;
+        const numSegs = node.segments.length;
+        const totalH = node.segments.reduce((sum, s) => sum + s.heightRatio, 0);
+        const normH = node.segments.map((s) => s.heightRatio / totalH);
+        const clamped = Math.max(0.05, Math.min(0.95, newVal));
+        const neighborIdx = segIdx < numSegs - 1 ? segIdx + 1 : segIdx - 1;
+        const delta = clamped - normH[segIdx];
+        const neighborVal = Math.max(0.05, normH[neighborIdx] - delta);
+        const newRatios = normH.map((v, i) => {
+            if (i === segIdx)
+                return clamped;
+            if (i === neighborIdx)
+                return neighborVal;
+            return v;
+        });
+        const updated = node.segments.map((s, idx) => ({ ...s, heightRatio: newRatios[idx] }));
+        handleUpdate({ segments: updated });
+    };
+    const setSegmentColumnRatio = (segIdx, colIdx, newVal) => {
+        const seg = node?.segments[segIdx];
+        if (!seg)
+            return;
+        const normRatios = (() => {
+            const sum = seg.columnRatios.reduce((a, b) => a + b, 0);
+            return seg.columnRatios.map((r) => r / sum);
+        })();
+        const numCols = normRatios.length;
+        const clamped = Math.max(0.05, Math.min(0.95, newVal));
+        const neighborIdx = colIdx < numCols - 1 ? colIdx + 1 : colIdx - 1;
+        const delta = clamped - normRatios[colIdx];
+        const neighborVal = Math.max(0.05, normRatios[neighborIdx] - delta);
+        const newRatios = normRatios.map((v, i) => {
+            if (i === colIdx)
+                return clamped;
+            if (i === neighborIdx)
+                return neighborVal;
+            return v;
+        });
+        const updated = node?.segments.map((s, idx) => idx === segIdx ? { ...s, columnRatios: newRatios } : s);
+        handleUpdate({ segments: updated });
+    };
+    if (!(node && node.type === 'door' && selectedId))
+        return null;
+    const hSum = node.segments.reduce((s, seg) => s + seg.heightRatio, 0);
+    const normHeights = node.segments.map((seg) => seg.heightRatio / hSum);
+    const isOpening = node.openingKind === 'opening';
+    const openingShape = node.openingShape ?? 'rectangle';
+    const doorShape = openingShape === 'arch' || openingShape === 'rounded' ? openingShape : 'rectangle';
+    const openingRadiusMode = node.openingRadiusMode ?? 'all';
+    const openingTopRadii = node.openingTopRadii ?? [0.15, 0.15];
+    const cornerRadius = node.cornerRadius ?? 0.15;
+    const archHeight = node.archHeight ?? 0.45;
+    const openingRevealRadius = node.openingRevealRadius ?? 0.025;
+    const maxRoundedRadius = Math.max(0.01, Math.min(node.width / 2, node.height));
+    const doorType = node.doorType ?? 'hinged';
+    const isGarageDoor = node.doorCategory === 'garage' || doorType.startsWith('garage-');
+    const isSwingDoor = doorType === 'hinged' || doorType === 'double' || doorType === 'french';
+    const isSlideFoldDoor = doorType === 'folding' || doorType === 'pocket' || doorType === 'barn' || doorType === 'sliding';
+    const isSlidingDoor = doorType === 'pocket' || doorType === 'barn' || doorType === 'sliding';
+    const isFoldingDoor = doorType === 'folding';
+    const isSectionalGarageDoor = doorType === 'garage-sectional';
+    const isRollupGarageDoor = doorType === 'garage-rollup';
+    const isTiltupGarageDoor = doorType === 'garage-tiltup';
+    const isCutoutOnly = isOpening;
+    const typeMode = isCutoutOnly ? 'opening' : isGarageDoor ? 'garage' : 'door';
+    const supportsHingeSide = doorType === 'hinged';
+    const supportsHandleSide = doorType === 'hinged';
+    const supportsTopShape = isSwingDoor;
+    const showFlipSide = !isCutoutOnly;
+    const showFoldSection = isFoldingDoor && !isCutoutOnly;
+    const showSlideSection = isSlidingDoor && !isCutoutOnly;
+    const showGarageSection = (isSectionalGarageDoor || isRollupGarageDoor || isTiltupGarageDoor) && !isCutoutOnly;
+    const showOpeningShapeSection = isCutoutOnly;
+    const showDoorShapeSection = !isCutoutOnly && supportsTopShape;
+    const showFrameSection = !isCutoutOnly;
+    const showContentPaddingSection = !isCutoutOnly && !isGarageDoor;
+    const showSwingSection = isSwingDoor;
+    const showThresholdSection = isSwingDoor;
+    const showHandleSection = isSwingDoor;
+    const showHardwareSection = isSwingDoor;
+    const showSegmentsSection = !isCutoutOnly && !isGarageDoor;
+    const maxDoorWidth = isGarageDoor ? 6 : 3;
+    const setOpeningTopRadius = (index, value, commit = false) => {
+        const next = [...openingTopRadii];
+        next[index] = value;
+        if (commit) {
+            commitDoorPreview('openingTopRadii', next);
+        }
+        else {
+            previewDoorUpdate('openingTopRadii', next);
+        }
+    };
+    const getDoorTypeUpdates = (nextDoorType) => {
+        const dimensions = defaultDoorDimensions[nextDoorType];
+        const segments = structuredClone(defaultDoorSegmentsByType[nextDoorType]);
+        const dimensionUpdates = {
+            width: dimensions.width,
+            height: dimensions.height,
+            position: [node.position[0], dimensions.height / 2, node.position[2]],
+        };
+        if (nextDoorType === 'double' || nextDoorType === 'french') {
+            return {
+                doorCategory: 'interior',
+                doorType: nextDoorType,
+                leafCount: 2,
+                ...dimensionUpdates,
+                handleSide: 'right',
+                segments,
+                ...(nextDoorType === 'french'
+                    ? {
+                        contentPadding: [0.045, 0.055],
+                    }
+                    : {}),
+            };
+        }
+        if (nextDoorType === 'folding') {
+            return {
+                doorCategory: 'interior',
+                doorType: nextDoorType,
+                leafCount: 4,
+                ...dimensionUpdates,
+                openingShape: 'rectangle',
+                handle: true,
+                handleSide: 'right',
+                trackStyle: 'visible',
+                operationState: Math.max(node.operationState ?? 0, 0.65),
+                threshold: false,
+                contentPadding: [0.03, 0.04],
+                segments,
+            };
+        }
+        if (nextDoorType === 'pocket') {
+            return {
+                doorCategory: 'interior',
+                doorType: nextDoorType,
+                leafCount: 1,
+                ...dimensionUpdates,
+                openingShape: 'rectangle',
+                handle: true,
+                handleSide: 'right',
+                trackStyle: 'pocket',
+                slideDirection: node.slideDirection ?? 'left',
+                operationState: node.operationState ?? 0,
+                threshold: false,
+                contentPadding: [0.035, 0.045],
+                segments,
+            };
+        }
+        if (nextDoorType === 'barn') {
+            return {
+                doorCategory: 'interior',
+                doorType: nextDoorType,
+                leafCount: 1,
+                ...dimensionUpdates,
+                openingShape: 'rectangle',
+                handle: true,
+                handleSide: 'right',
+                trackStyle: 'visible',
+                slideDirection: node.slideDirection ?? 'left',
+                operationState: node.operationState ?? 0,
+                threshold: false,
+                contentPadding: [0.035, 0.045],
+                segments,
+            };
+        }
+        if (nextDoorType === 'sliding') {
+            return {
+                doorCategory: 'interior',
+                doorType: nextDoorType,
+                leafCount: 2,
+                ...dimensionUpdates,
+                openingShape: 'rectangle',
+                handle: true,
+                handleSide: 'right',
+                trackStyle: 'visible',
+                slideDirection: node.slideDirection ?? 'left',
+                operationState: node.operationState ?? 0,
+                threshold: false,
+                contentPadding: [0.03, 0.04],
+                segments,
+            };
+        }
+        if (nextDoorType === 'garage-sectional') {
+            return {
+                doorCategory: 'garage',
+                doorType: nextDoorType,
+                leafCount: 1,
+                ...dimensionUpdates,
+                handle: false,
+                threshold: false,
+                openingShape: 'rectangle',
+                trackStyle: 'overhead',
+                operationState: 0,
+                garagePanelCount: Math.max(3, Math.min(8, node.garagePanelCount ?? 4)),
+                contentPadding: [0.04, 0.04],
+                segments,
+            };
+        }
+        if (nextDoorType === 'garage-rollup') {
+            return {
+                doorCategory: 'garage',
+                doorType: nextDoorType,
+                leafCount: 1,
+                ...dimensionUpdates,
+                handle: false,
+                threshold: false,
+                openingShape: 'rectangle',
+                trackStyle: 'overhead',
+                operationState: 0,
+                garagePanelCount: 4,
+                contentPadding: [0.04, 0.04],
+                segments,
+            };
+        }
+        if (nextDoorType === 'garage-tiltup') {
+            return {
+                doorCategory: 'garage',
+                doorType: nextDoorType,
+                leafCount: 1,
+                ...dimensionUpdates,
+                handle: false,
+                threshold: false,
+                openingShape: 'rectangle',
+                trackStyle: 'overhead',
+                operationState: 0,
+                garagePanelCount: 4,
+                contentPadding: [0.04, 0.04],
+                segments,
+            };
+        }
+        return {
+            doorCategory: 'interior',
+            doorType: nextDoorType,
+            leafCount: 1,
+            ...dimensionUpdates,
+            segments,
+            threshold: true,
+        };
+    };
+    return (_jsxs(PanelWrapper, { icon: "/icons/door.webp", onClose: handleClose, title: node.name || 'Door', width: 320, children: [_jsxs(PanelSection, { title: "Type", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate(v === 'opening'
+                                ? {
+                                    openingKind: v,
+                                    openingShape,
+                                    openingRadiusMode,
+                                    openingTopRadii,
+                                    cornerRadius,
+                                    archHeight,
+                                    openingRevealRadius,
+                                }
+                                : v === 'garage'
+                                    ? {
+                                        openingKind: 'door',
+                                        ...getDoorTypeUpdates(isGarageDoor ? doorType : 'garage-sectional'),
+                                    }
+                                    : {
+                                        openingKind: 'door',
+                                        ...(isGarageDoor ? getDoorTypeUpdates('hinged') : {}),
+                                    }), options: [
+                                { label: 'Door', value: 'door' },
+                                { label: 'Opening', value: 'opening' },
+                                { label: 'Garage', value: 'garage' },
+                            ], value: typeMode }) }), !isOpening && (_jsx("div", { className: "grid grid-cols-2 gap-2 px-1 pt-1", children: (isGarageDoor ? garageDoorTypeOptions : doorTypeOptions).map((option) => {
+                            const isSelected = doorType === option.value;
+                            return (_jsxs("button", { className: cn('flex min-h-12 items-center gap-2.5 rounded-lg border px-3 py-2.5 text-left text-xs transition-colors', isSelected
+                                    ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
+                                    : 'border-border/50 bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground', !option.available &&
+                                    'cursor-not-allowed opacity-45 hover:bg-[#2C2C2E] hover:text-muted-foreground'), disabled: !option.available, onClick: () => handleUpdate(getDoorTypeUpdates(option.value)), type: "button", children: [_jsx(DoorOpen, { className: "h-4 w-4 shrink-0" }), _jsx("span", { className: "truncate font-medium", children: option.label })] }, option.value));
+                        }) }))] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: _jsxs(_Fragment, { children: ["X", _jsx("sub", { className: "ml-[1px] text-[11px] opacity-70", children: "wall" })] }), max: 10, min: -10, onChange: (v) => handleUpdate({ position: [v, node.position[1], node.position[2]] }), precision: 2, step: 0.1, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), showFlipSide && (_jsx("div", { className: "px-1 pt-2 pb-1", children: _jsx(ActionButton, { className: "w-full", icon: _jsx(FlipHorizontal2, { className: "h-4 w-4" }), label: "Flip Side", onClick: handleFlip }) }))] }), showFoldSection && (_jsxs(PanelSection, { title: "Fold", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Panels" }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ leafCount: v === '2' ? 2 : 4 }), options: [
+                                        { label: '2', value: '2' },
+                                        { label: '4', value: '4' },
+                                    ], value: node.leafCount === 2 ? '2' : '4' })] }) }), _jsx(SliderControl, { label: "Open", max: 100, min: 0, onChange: (v) => handleUpdate({ operationState: v / 100 }), precision: 0, restoreOnCommit: false, step: 5, unit: "%", value: Math.round((node.operationState ?? 0) * 100) })] })), showSlideSection && (_jsxs(PanelSection, { title: "Slide", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: doorType === 'pocket' ? 'Pocket' : doorType === 'barn' ? 'Rail' : 'Panel' }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ slideDirection: v }), options: [
+                                        { label: 'Left', value: 'left' },
+                                        { label: 'Right', value: 'right' },
+                                    ], value: node.slideDirection ?? 'left' })] }) }), _jsx(SliderControl, { label: "Open", max: 100, min: 0, onChange: (v) => handleUpdate({ operationState: v / 100 }), precision: 0, restoreOnCommit: false, step: 5, unit: "%", value: Math.round((node.operationState ?? 0) * 100) })] })), showGarageSection && (_jsxs(PanelSection, { title: "Garage", children: [_jsx(SliderControl, { label: "Open", max: 100, min: 0, onChange: (v) => handleUpdate({ operationState: v / 100 }), precision: 0, restoreOnCommit: false, step: 5, unit: "%", value: Math.round((node.operationState ?? 0) * 100) }), isSectionalGarageDoor && (_jsx(SliderControl, { label: "Panels", max: 8, min: 3, onChange: (v) => handleUpdate({ garagePanelCount: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, value: node.garagePanelCount ?? 4 }))] })), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: maxDoorWidth, min: 0.5, onChange: (v) => handleUpdate({ width: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 4, min: 1.0, onChange: (v) => handleUpdate({
+                            height: v,
+                            position: [node.position[0], v / 2, node.position[2]],
+                            // Keep the handle at the same relative height as the door resizes,
+                            // matching the height-resize arrow.
+                            handleHeight: scaleHandleHeight(node.handleHeight, node.height, v),
+                        }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(node.height * 100) / 100 })] }), showDoorShapeSection && (_jsxs(PanelSection, { title: "Top Shape", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({
+                                openingShape: v,
+                                ...(v === 'rounded'
+                                    ? {
+                                        openingRadiusMode,
+                                        openingTopRadii,
+                                        cornerRadius: Math.min(cornerRadius, maxRoundedRadius),
+                                        openingRevealRadius,
+                                    }
+                                    : {}),
+                                ...(v === 'arch' ? { archHeight } : {}),
+                            }), options: [
+                                { label: 'Rect', value: 'rectangle' },
+                                { label: 'Rounded', value: 'rounded' },
+                                { label: 'Arch', value: 'arch' },
+                            ], value: doorShape }) }), doorShape === 'rounded' && (_jsxs(_Fragment, { children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ openingRadiusMode: v }), options: [
+                                        { label: 'All', value: 'all' },
+                                        { label: 'Individual', value: 'individual' },
+                                    ], value: openingRadiusMode }) }), openingRadiusMode === 'all' ? (_jsx(SliderControl, { label: "Corner Radius", max: maxRoundedRadius, min: 0, onChange: (v) => previewDoorUpdate('cornerRadius', v), onCommit: (v) => commitDoorPreview('cornerRadius', v), precision: 2, step: 0.05, unit: "m", value: Math.round(cornerRadius * 100) / 100 })) : (_jsx(_Fragment, { children: [
+                                    ['Top Left', 0],
+                                    ['Top Right', 1],
+                                ].map(([label, index]) => (_jsx(SliderControl, { label: label, max: maxRoundedRadius, min: 0, onChange: (v) => setOpeningTopRadius(index, v), onCommit: (v) => setOpeningTopRadius(index, v, true), precision: 2, step: 0.05, unit: "m", value: Math.round((openingTopRadii[index] ?? 0) * 100) / 100 }, label))) })), _jsx(SliderControl, { label: "Reveal Radius", max: 0.08, min: 0, onChange: (v) => previewDoorUpdate('openingRevealRadius', v), onCommit: (v) => commitDoorPreview('openingRevealRadius', v), precision: 3, step: 0.005, unit: "m", value: Math.round(openingRevealRadius * 1000) / 1000 })] })), doorShape === 'arch' && (_jsx(SliderControl, { label: "Arch Height", max: node.height, min: 0.05, onChange: (v) => handleUpdate({ archHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(archHeight * 100) / 100 }))] })), showOpeningShapeSection && (_jsxs(PanelSection, { title: "Opening Shape", children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({
+                                openingShape: v,
+                                ...(v === 'rounded'
+                                    ? { openingRadiusMode, openingTopRadii, cornerRadius, openingRevealRadius }
+                                    : {}),
+                                ...(v === 'arch' ? { archHeight } : {}),
+                            }), options: [
+                                { label: 'Rect', value: 'rectangle' },
+                                { label: 'Rounded', value: 'rounded' },
+                                { label: 'Arch', value: 'arch' },
+                            ], value: openingShape }) }), openingShape === 'rounded' && (_jsxs(_Fragment, { children: [_jsx("div", { className: "flex flex-col gap-2 px-1 pb-1", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ openingRadiusMode: v }), options: [
+                                        { label: 'All', value: 'all' },
+                                        { label: 'Individual', value: 'individual' },
+                                    ], value: openingRadiusMode }) }), openingRadiusMode === 'all' ? (_jsx(SliderControl, { label: "Corner Radius", max: maxRoundedRadius, min: 0, onChange: (v) => previewDoorUpdate('cornerRadius', v), onCommit: (v) => commitDoorPreview('cornerRadius', v), precision: 2, step: 0.05, unit: "m", value: Math.round(cornerRadius * 100) / 100 })) : (_jsx(_Fragment, { children: [
+                                    ['Top Left', 0],
+                                    ['Top Right', 1],
+                                ].map(([label, index]) => (_jsx(SliderControl, { label: label, max: maxRoundedRadius, min: 0, onChange: (v) => setOpeningTopRadius(index, v), onCommit: (v) => setOpeningTopRadius(index, v, true), precision: 2, step: 0.05, unit: "m", value: Math.round((openingTopRadii[index] ?? 0) * 100) / 100 }, label))) })), _jsx(SliderControl, { label: "Reveal Radius", max: 0.08, min: 0, onChange: (v) => previewDoorUpdate('openingRevealRadius', v), onCommit: (v) => commitDoorPreview('openingRevealRadius', v), precision: 3, step: 0.005, unit: "m", value: Math.round(openingRevealRadius * 1000) / 1000 })] })), openingShape === 'arch' && (_jsx(SliderControl, { label: "Arch Height", max: node.height, min: 0.05, onChange: (v) => handleUpdate({ archHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round(archHeight * 100) / 100 }))] })), !isCutoutOnly && (_jsxs(_Fragment, { children: [showFrameSection && (_jsxs(PanelSection, { title: "Frame", children: [_jsx(SliderControl, { label: "Thickness", max: 0.2, min: 0.01, onChange: (v) => handleUpdate({ frameThickness: v }), precision: 3, step: 0.01, unit: "m", value: Math.round(node.frameThickness * 1000) / 1000 }), _jsx(SliderControl, { label: "Depth", max: 0.3, min: 0.01, onChange: (v) => handleUpdate({ frameDepth: v }), precision: 3, step: 0.01, unit: "m", value: Math.round(node.frameDepth * 1000) / 1000 })] })), showContentPaddingSection && (_jsxs(PanelSection, { title: "Content Padding", children: [_jsx(SliderControl, { label: "Horizontal", max: 0.2, min: 0, onChange: (v) => handleUpdate({ contentPadding: [v, node.contentPadding[1]] }), precision: 3, step: 0.005, unit: "m", value: Math.round(node.contentPadding[0] * 1000) / 1000 }), _jsx(SliderControl, { label: "Vertical", max: 0.2, min: 0, onChange: (v) => handleUpdate({ contentPadding: [node.contentPadding[0], v] }), precision: 3, step: 0.005, unit: "m", value: Math.round(node.contentPadding[1] * 1000) / 1000 })] })), showSwingSection && (_jsx(PanelSection, { title: "Swing", children: _jsxs("div", { className: "flex flex-col gap-2 px-1 pb-1", children: [supportsHingeSide && (_jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Hinges Side" }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ hingesSide: v }), options: [
+                                                { label: 'Left', value: 'left' },
+                                                { label: 'Right', value: 'right' },
+                                            ], value: node.hingesSide })] })), _jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Direction" }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ swingDirection: v }), options: [
+                                                { label: 'Inward', value: 'inward' },
+                                                { label: 'Outward', value: 'outward' },
+                                            ], value: node.swingDirection })] })] }) })), showThresholdSection && (_jsxs(PanelSection, { title: "Threshold", children: [_jsx(ToggleControl, { checked: node.threshold, label: "Enable Threshold", onChange: (checked) => handleUpdate({ threshold: checked }) }), node.threshold && (_jsx("div", { className: "mt-1 flex flex-col gap-1", children: _jsx(SliderControl, { label: "Height", max: 0.1, min: 0.005, onChange: (v) => handleUpdate({ thresholdHeight: v }), precision: 3, step: 0.005, unit: "m", value: Math.round(node.thresholdHeight * 1000) / 1000 }) }))] })), showHandleSection && (_jsxs(PanelSection, { title: "Handle", children: [isSwingDoor && (_jsx(ToggleControl, { checked: node.handle, label: "Enable Handle", onChange: (checked) => handleUpdate({ handle: checked }) })), (node.handle || !isSwingDoor) && (_jsxs("div", { className: "mt-1 flex flex-col gap-1", children: [_jsx(SliderControl, { label: "Height", max: node.height - 0.1, min: 0.5, onChange: (v) => handleUpdate({ handleHeight: v }), precision: 2, step: 0.05, unit: "m", value: Math.round(node.handleHeight * 100) / 100 }), supportsHandleSide && (_jsxs("div", { className: "space-y-1", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Handle Side" }), _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ handleSide: v }), options: [
+                                                    { label: 'Left', value: 'left' },
+                                                    { label: 'Right', value: 'right' },
+                                                ], value: node.handleSide })] }))] }))] })), showHardwareSection && (_jsxs(PanelSection, { title: "Hardware", children: [_jsx(ToggleControl, { checked: node.doorCloser, label: "Door Closer", onChange: (checked) => handleUpdate({ doorCloser: checked }) }), _jsx(ToggleControl, { checked: node.panicBar, label: "Panic Bar", onChange: (checked) => handleUpdate({ panicBar: checked }) }), node.panicBar && (_jsx("div", { className: "mt-1 flex flex-col gap-1", children: _jsx(SliderControl, { label: "Bar Height", max: node.height - 0.1, min: 0.5, onChange: (v) => handleUpdate({ panicBarHeight: v }), precision: 2, step: 0.05, unit: "m", value: Math.round(node.panicBarHeight * 100) / 100 }) }))] })), showSegmentsSection && (_jsxs(PanelSection, { title: "Segments", children: [node.segments.map((seg, i) => {
+                                const numCols = seg.columnRatios.length;
+                                const colSum = seg.columnRatios.reduce((a, b) => a + b, 0);
+                                const normCols = seg.columnRatios.map((r) => r / colSum);
+                                return (_jsxs("div", { className: "mb-2 flex flex-col gap-1", children: [_jsx("div", { className: "flex items-center justify-between pb-1", children: _jsxs("span", { className: "font-medium text-white/80 text-xs", children: ["Segment ", i + 1] }) }), _jsx(SegmentedControl, { onChange: (t) => {
+                                                const updated = node.segments.map((s, idx) => idx === i ? { ...s, type: t } : s);
+                                                handleUpdate({ segments: updated });
+                                            }, options: [
+                                                { label: 'Panel', value: 'panel' },
+                                                { label: 'Glass', value: 'glass' },
+                                                { label: 'Empty', value: 'empty' },
+                                            ], value: seg.type }), _jsx(SliderControl, { label: "Height", max: 95, min: 5, onChange: (v) => setSegmentHeightRatio(i, v / 100), precision: 1, step: 1, unit: "%", value: Math.round(normHeights[i] * 100 * 10) / 10 }), _jsx(SliderControl, { label: "Columns", max: 8, min: 1, onChange: (v) => {
+                                                const n = Math.max(1, Math.min(8, Math.round(v)));
+                                                const updated = node.segments.map((s, idx) => idx === i ? { ...s, columnRatios: Array(n).fill(1 / n) } : s);
+                                                handleUpdate({ segments: updated });
+                                            }, precision: 0, step: 1, value: numCols }), numCols > 1 && (_jsxs("div", { className: "mt-1 border-border/50 border-t pt-1", children: [normCols.map((ratio, ci) => (_jsx(SliderControl, { label: `C${ci + 1}`, max: 95, min: 5, onChange: (v) => setSegmentColumnRatio(i, ci, v / 100), precision: 1, step: 1, unit: "%", value: Math.round(ratio * 100 * 10) / 10 }, `c-${ci}`))), _jsx(SliderControl, { label: "Divider", max: 0.1, min: 0.005, onChange: (v) => {
+                                                        const updated = node.segments.map((s, idx) => idx === i ? { ...s, dividerThickness: v } : s);
+                                                        handleUpdate({ segments: updated });
+                                                    }, precision: 3, step: 0.005, unit: "m", value: Math.round(seg.dividerThickness * 1000) / 1000 })] })), seg.type === 'panel' && (_jsxs("div", { className: "mt-1 border-border/50 border-t pt-1", children: [_jsx(SliderControl, { label: "Inset", max: 0.1, min: 0, onChange: (v) => {
+                                                        const updated = node.segments.map((s, idx) => idx === i ? { ...s, panelInset: v } : s);
+                                                        handleUpdate({ segments: updated });
+                                                    }, precision: 3, step: 0.005, unit: "m", value: Math.round(seg.panelInset * 1000) / 1000 }), _jsx(SliderControl, { label: "Depth", max: 0.1, min: 0, onChange: (v) => {
+                                                        const updated = node.segments.map((s, idx) => idx === i ? { ...s, panelDepth: v } : s);
+                                                        handleUpdate({ segments: updated });
+                                                    }, precision: 3, step: 0.005, unit: "m", value: Math.round(seg.panelDepth * 1000) / 1000 })] }))] }, i));
+                            }), _jsxs("div", { className: "flex gap-1.5 px-1 pt-1", children: [_jsx(ActionButton, { label: "+ Add Segment", onClick: () => {
+                                            const updated = [
+                                                ...node.segments,
+                                                {
+                                                    type: 'panel',
+                                                    heightRatio: 1,
+                                                    columnRatios: [1],
+                                                    dividerThickness: 0.03,
+                                                    panelDepth: 0.01,
+                                                    panelInset: 0.04,
+                                                },
+                                            ];
+                                            handleUpdate({ segments: updated });
+                                        } }), node.segments.length > 1 && (_jsx(ActionButton, { className: "text-white/60 hover:text-white", label: "- Remove", onClick: () => handleUpdate({ segments: node.segments.slice(0, -1) }) }))] })] }))] })), _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 })] }) })] }));
+}

package/dist/door/parametrics.d.ts

@@ -0,0 +1,12 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { DoorNode } from './schema';
+/**
+ * Stage E inspector for door. Mounts the kind-owned panel
+ * (`panel.tsx`) via `customPanel` — door has 29+ controls (segments,
+ * hardware, hinges, panic bar, opening shape, etc.) that can't fit
+ * into the generic auto-inspector. The `groups` entries stay populated
+ * so the registry still considers door "parametric" (for tooling that
+ * lists kinds with editable schema).
+ */
+export declare const doorParametrics: ParametricDescriptor<DoorNode>;
+//# sourceMappingURL=parametrics.d.ts.map

package/dist/door/parametrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/door/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAkB1D,CAAA"}