@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/fence-feature/inspector.js

@@ -0,0 +1,214 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { canPlaceFenceFeature, FenceStyle, fenceFeatureData, fenceWithFeatures, getFenceCenterlineLength, useScene, } from '@pascal-app/core';
+import { ActionButton, SliderControl, ToggleControl } from '@pascal-app/editor';
+import { useState } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
+export function FenceFeatureEditor({ node: child, onUpdate, }) {
+    const [error, setError] = useState('');
+    const parentId = child.parentId;
+    const parent = useScene((s) => (parentId ? s.nodes[parentId] : undefined));
+    const siblings = useScene(useShallow((s) => {
+        const fence = parentId ? s.nodes[parentId] : undefined;
+        return fence?.type === 'fence'
+            ? (fence.children ?? []).map((id) => s.nodes[id]).filter(Boolean)
+            : [];
+    }));
+    if (parent?.type !== 'fence')
+        return _jsx("p", { children: "Fence unavailable." });
+    const node = fenceWithFeatures(parent, siblings);
+    const features = [fenceFeatureData(child)];
+    const length = getFenceCenterlineLength(node);
+    const update = (id, patch) => {
+        const original = features.find((feature) => feature.id === id);
+        if (!original)
+            return;
+        const next = { ...original, ...patch };
+        if ((patch.width !== undefined || patch.center !== undefined) &&
+            !canPlaceFenceFeature(node, next)) {
+            setError('Keep the opening inside the fence and clear of other gates or passages.');
+            return;
+        }
+        setError('');
+        onUpdate(patch);
+    };
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [error && (_jsx("p", { role: "status", className: "text-amber-500", children: error })), features.map((feature) => {
+                const gate = feature.kind === 'gate';
+                const { height, bottom } = getFenceFeatureDimensions(node, feature);
+                const selects = [
+                    ...(gate
+                        ? [
+                            {
+                                key: 'leafType',
+                                label: 'Leaves',
+                                value: feature.leafType ?? 'single',
+                                options: [
+                                    ['single', 'Single gate'],
+                                    ['double', 'Double gate'],
+                                ],
+                            },
+                            {
+                                key: 'hinge',
+                                label: 'Hinge side',
+                                value: feature.hinge ?? 'left',
+                                options: [
+                                    ['left', 'Left'],
+                                    ['right', 'Right'],
+                                ],
+                            },
+                            {
+                                key: 'swing',
+                                label: 'Swing direction',
+                                value: feature.swing ?? 'inward',
+                                options: [
+                                    ['inward', 'Inward'],
+                                    ['outward', 'Outward'],
+                                ],
+                            },
+                            {
+                                key: 'brace',
+                                label: 'Bracing',
+                                value: feature.brace ?? 'none',
+                                options: [
+                                    ['none', 'None'],
+                                    ['diagonal', 'Diagonal'],
+                                    ['cross', 'Cross'],
+                                ],
+                            },
+                        ]
+                        : []),
+                ];
+                const numbers = [
+                    {
+                        key: 'center',
+                        label: 'Distance from start',
+                        value: feature.center,
+                        min: 0,
+                        max: length,
+                        step: 0.05,
+                        unit: 'm',
+                    },
+                    {
+                        key: 'width',
+                        label: 'Opening width',
+                        value: feature.width,
+                        min: 0.35,
+                        max: length,
+                        step: 0.05,
+                        unit: 'm',
+                    },
+                    {
+                        key: 'height',
+                        label: gate ? 'Gate height' : 'Post height',
+                        value: height,
+                        min: 0.3,
+                        max: 1000,
+                        step: 0.05,
+                        unit: 'm',
+                    },
+                    ...(gate
+                        ? [
+                            {
+                                key: 'clearance',
+                                label: 'Ground clearance',
+                                value: bottom,
+                                min: 0,
+                                max: 1000,
+                                step: 0.01,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'openAngle',
+                                label: 'Opening angle',
+                                value: feature.openAngle ?? 0,
+                                min: 0,
+                                max: 170,
+                                step: 1,
+                                unit: '°',
+                            },
+                            {
+                                key: 'thickness',
+                                label: 'Leaf thickness',
+                                value: feature.thickness ?? 0.06,
+                                min: 0.02,
+                                max: 0.3,
+                                step: 0.005,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'frameWidth',
+                                label: 'Frame width',
+                                value: feature.frameWidth ?? 0.055,
+                                min: 0.025,
+                                max: 0.2,
+                                step: 0.005,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'spacing',
+                                label: 'Infill spacing',
+                                value: feature.spacing ?? 0.15,
+                                min: 0.04,
+                                max: 1000,
+                                step: 0.01,
+                                unit: 'm',
+                            },
+                            {
+                                key: 'boardWidth',
+                                label: 'Board width',
+                                value: feature.boardWidth ?? 0.055,
+                                min: 0.02,
+                                max: 0.3,
+                                step: 0.005,
+                                unit: 'm',
+                            },
+                            ...(feature.leafType === 'double'
+                                ? [
+                                    {
+                                        key: 'leafSplit',
+                                        label: 'Left leaf proportion',
+                                        value: feature.leafSplit ?? 0.5,
+                                        min: 0.2,
+                                        max: 0.8,
+                                        step: 0.05,
+                                        unit: '',
+                                    },
+                                ]
+                                : []),
+                        ]
+                        : []),
+                ];
+                return (_jsx("div", { children: _jsxs("div", { className: "mt-2 space-y-2", children: [_jsx(ToggleControl, { label: "Match fence style", checked: feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
+                                    matchFenceStyle: checked,
+                                    ...(checked
+                                        ? { matchFenceHeight: true }
+                                        : { style: feature.style === 'match' ? 'picket' : feature.style }),
+                                }) }), _jsx(ToggleControl, { label: "Match fence height", checked: feature.matchFenceHeight ?? feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
+                                    matchFenceHeight: checked,
+                                    height,
+                                    ...(gate ? { clearance: bottom } : {}),
+                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: ["Gate style", _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
+                                            const style = FenceStyle.safeParse(event.currentTarget.value);
+                                            if (style.success)
+                                                update(feature.id, { style: style.data });
+                                        }, children: [_jsx("option", { value: "picket", children: "Picket" }), _jsx("option", { value: "slat", children: "Vertical slats" }), _jsx("option", { value: "horizontal", children: "Horizontal boards" }), _jsx("option", { value: "privacy", children: "Solid privacy" }), _jsx("option", { value: "rail", children: "Open rails" })] })] })), selects
+                                .filter((field) => field.key !== 'hinge' || feature.leafType !== 'double')
+                                .map((field) => (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [field.label, _jsx("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: field.value, onChange: (event) => update(feature.id, { [field.key]: event.target.value }), children: field.options.map(([value, label]) => (_jsx("option", { value: value, children: label }, value))) })] }, field.key))), numbers
+                                .filter((field) => feature.matchFenceStyle === false ||
+                                !['thickness', 'frameWidth', 'spacing', 'boardWidth'].includes(field.key))
+                                .map((field) => (_jsx(SliderControl, { label: field.label, value: field.value, min: field.min, max: field.max, step: field.step, precision: field.key === 'openAngle' ? 0 : 3, unit: field.unit, onChange: (value) => update(feature.id, {
+                                    [field.key]: value,
+                                    ...(['height', 'clearance'].includes(field.key)
+                                        ? {
+                                            matchFenceHeight: false,
+                                            ...(field.key === 'clearance'
+                                                ? { height }
+                                                : gate
+                                                    ? { clearance: bottom }
+                                                    : {}),
+                                        }
+                                        : {}),
+                                }) }, field.key))), _jsx(ToggleControl, { label: "Jamb posts", checked: feature.showPosts !== false, onChange: (checked) => update(feature.id, { showPosts: checked }) }), gate && (_jsx(ToggleControl, { label: "Hinges and latch", checked: feature.showHardware !== false, onChange: (checked) => update(feature.id, { showHardware: checked }) })), _jsx(ActionButton, { type: "button", label: gate ? 'Remove gate' : 'Remove opening', className: "w-full text-destructive hover:text-destructive", onClick: () => useScene.getState().deleteNode(child.id) })] }) }, feature.id));
+            })] }));
+}

package/dist/fence-feature/interaction.d.ts

@@ -0,0 +1,3 @@
+import { type AnyNodeId } from '@pascal-app/core';
+export declare function toggleFenceGate(nodeId: AnyNodeId): void;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/fence-feature/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../../src/fence-feature/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkC,MAAM,kBAAkB,CAAA;AAKjF,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,QA0ChD"}

package/dist/fence-feature/interaction.js

@@ -0,0 +1,41 @@
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+const animations = new Map();
+export function toggleFenceGate(nodeId) {
+    const node = useScene.getState().nodes[nodeId];
+    if (node?.type !== 'fence-gate')
+        return;
+    const previous = animations.get(nodeId);
+    if (previous)
+        window.cancelAnimationFrame(previous.frame);
+    const overrides = useLiveNodeOverrides.getState();
+    const liveAngle = overrides.get(nodeId)?.openAngle;
+    const from = typeof liveAngle === 'number' ? liveAngle : (node.openAngle ?? 0);
+    const target = previous ? (previous.target === 0 ? 90 : 0) : from > 0.01 ? 0 : 90;
+    const startedAt = window.performance.now();
+    const duration = 520 * Math.max(0.15, Math.abs(target - from) / 90);
+    const animation = { frame: 0, target };
+    const step = (time) => {
+        const current = useScene.getState().nodes[nodeId];
+        // Deletion, scene replacement, or an inspector edit invalidates this animation.
+        if (current !== node) {
+            animations.delete(nodeId);
+            useLiveNodeOverrides.getState().clearFields(nodeId, ['openAngle']);
+            return;
+        }
+        const progress = Math.min(1, Math.max(0, (time - startedAt) / duration));
+        const eased = progress * progress * (3 - 2 * progress);
+        if (progress < 1) {
+            // Live poses keep intermediate frames out of undo history.
+            useLiveNodeOverrides.getState().set(nodeId, {
+                openAngle: from + (target - from) * eased,
+            });
+            animation.frame = window.requestAnimationFrame(step);
+            return;
+        }
+        animations.delete(nodeId);
+        useScene.getState().updateNode(nodeId, { openAngle: target });
+        useLiveNodeOverrides.getState().clearFields(nodeId, ['openAngle']);
+    };
+    animations.set(nodeId, animation);
+    animation.frame = window.requestAnimationFrame(step);
+}

package/dist/fence-feature/move-session.d.ts

@@ -0,0 +1,9 @@
+import { type AnyNodeId, type FenceFeatureNode, type FenceNode, type GridEvent, type SceneApi } from '@pascal-app/core';
+export declare function createFenceFeatureMoveSession(node: FenceFeatureNode, sceneApi: SceneApi, levelId: AnyNodeId | null, selectNode: (id: AnyNodeId) => void): {
+    affectedIds: (`block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`)[];
+    clear: () => void;
+    update(point: readonly [number, number], host?: FenceNode, ray?: GridEvent['localRay']): void;
+    canCommit: () => boolean;
+    commit(): void;
+};
+//# sourceMappingURL=move-session.d.ts.map

package/dist/fence-feature/move-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-session.d.ts","sourceRoot":"","sources":["../../src/fence-feature/move-session.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EAGd,KAAK,SAAS,EACd,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,SAAS,GAAG,IAAI,EACzB,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI;;;kBAenB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,SAAS,QAAQ,SAAS,CAAC,UAAU,CAAC;;;EA6BzF"}

package/dist/fence-feature/move-session.js

@@ -0,0 +1,48 @@
+import { canPlaceFenceFeature, fenceFeatureData, fenceWithFeatures, useLiveNodeOverrides, } from '@pascal-app/core';
+import { pickFenceTarget } from './pick-target.js';
+export function createFenceFeatureMoveSession(node, sceneApi, levelId, selectNode) {
+    const affectedIds = [node.id];
+    if (node.parentId)
+        affectedIds.push(node.parentId);
+    let target = null;
+    const clear = () => {
+        const overrides = useLiveNodeOverrides.getState();
+        for (const id of affectedIds) {
+            overrides.clearFields(id, id === node.id ? ['visible'] : ['features']);
+            sceneApi.markDirty(id);
+        }
+    };
+    return {
+        affectedIds,
+        clear,
+        update(point, host, ray) {
+            clear();
+            target = pickFenceTarget(point, host, ray, sceneApi, levelId);
+            if (!target)
+                return;
+            const nodes = sceneApi.nodes();
+            const data = { ...fenceFeatureData(node), center: target.center };
+            const fence = fenceWithFeatures(target.fence, (target.fence.children ?? []).map((id) => nodes[id]));
+            if (!canPlaceFenceFeature(fence, data)) {
+                target = null;
+                return;
+            }
+            if (!affectedIds.includes(target.fence.id))
+                affectedIds.push(target.fence.id);
+            useLiveNodeOverrides.getState().set(node.id, { visible: false });
+            useLiveNodeOverrides.getState().set(target.fence.id, { features: [data] });
+            sceneApi.markDirty(node.id);
+            for (const id of affectedIds)
+                sceneApi.markDirty(id);
+        },
+        canCommit: () => target !== null,
+        commit() {
+            if (!target)
+                return;
+            const destination = target;
+            clear();
+            sceneApi.update(node.id, { parentId: destination.fence.id, center: destination.center });
+            selectNode(node.id);
+        },
+    };
+}

package/dist/fence-feature/move-tool.d.ts

@@ -0,0 +1,5 @@
+import { type FenceFeatureNode } from '@pascal-app/core';
+export default function MoveFenceFeatureTool({ node }: {
+    node: FenceFeatureNode;
+}): null;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/fence-feature/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/fence-feature/move-tool.tsx"],"names":[],"mappings":"AACA,OAAO,EAA4B,KAAK,gBAAgB,EAAkB,MAAM,kBAAkB,CAAA;AAWlG,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,QAoDhF"}

package/dist/fence-feature/move-tool.js

@@ -0,0 +1,58 @@
+'use client';
+import { emitter } from '@pascal-app/core';
+import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, useRegistryToolContext, } from '@pascal-app/editor';
+import { useEffect } from 'react';
+import { createFenceFeatureMoveSession } from './move-session.js';
+export default function MoveFenceFeatureTool({ node }) {
+    const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
+    useEffect(() => {
+        const session = createFenceFeatureMoveSession(node, sceneApi, activeLevelId, selectNode);
+        let finished = false;
+        const finish = () => {
+            if (finished || !session.canCommit())
+                return;
+            finished = true;
+            session.commit();
+            triggerSFX('sfx:item-place');
+            useEditor.getState().setMovingNode(null);
+        };
+        const move = (event) => session.update([event.localPosition[0], event.localPosition[2]], undefined, event.localRay);
+        const click = (event) => {
+            move(event);
+            finish();
+        };
+        const fenceMove = (event) => session.update([event.localPosition[0], event.localPosition[2]], event.node);
+        const fenceClick = (event) => {
+            fenceMove(event);
+            if (session.canCommit()) {
+                event.stopPropagation();
+                finish();
+            }
+        };
+        const cancel = () => {
+            session.clear();
+            markToolCancelConsumed();
+            useEditor.getState().setMovingNode(null);
+        };
+        const release = (event) => {
+            if (consumePlacementDragRelease(event))
+                finish();
+        };
+        emitter.on('grid:move', move);
+        emitter.on('grid:click', click);
+        emitter.on('fence:move', fenceMove);
+        emitter.on('fence:click', fenceClick);
+        emitter.on('tool:cancel', cancel);
+        window.addEventListener('pointerup', release);
+        return () => {
+            session.clear();
+            emitter.off('grid:move', move);
+            emitter.off('grid:click', click);
+            emitter.off('fence:move', fenceMove);
+            emitter.off('fence:click', fenceClick);
+            emitter.off('tool:cancel', cancel);
+            window.removeEventListener('pointerup', release);
+        };
+    }, [activeLevelId, node, sceneApi, selectNode]);
+    return null;
+}

package/dist/fence-feature/pick-target.d.ts

@@ -0,0 +1,7 @@
+import { type AnyNodeId, type FenceNode, type GridEvent, type SceneApi } from '@pascal-app/core';
+export declare function pickFenceTarget(point: readonly [number, number], host: FenceNode | undefined, ray: GridEvent['localRay'] | undefined, sceneApi: SceneApi, levelId: AnyNodeId | null): {
+    fence: FenceNode;
+    center: number;
+    distance: number;
+} | null;
+//# sourceMappingURL=pick-target.d.ts.map

package/dist/fence-feature/pick-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick-target.d.ts","sourceRoot":"","sources":["../../src/fence-feature/pick-target.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,SAAS,EAEd,KAAK,SAAS,EAEd,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,IAAI,EAAE,SAAS,GAAG,SAAS,EAC3B,GAAG,EAAE,SAAS,CAAC,UAAU,CAAC,GAAG,SAAS,EACtC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,SAAS,GAAG,IAAI;WAGN,SAAS;YAAU,MAAM;cAAY,MAAM;SAgD/D"}

package/dist/fence-feature/pick-target.js

@@ -0,0 +1,52 @@
+import { findLevelAncestorId, projectPointToFence, sampleFenceCenterline, } from '@pascal-app/core';
+import { createSceneSupportHeightSampler } from '@pascal-app/viewer';
+export function pickFenceTarget(point, host, ray, sceneApi, levelId) {
+    const nodes = sceneApi.nodes();
+    let best;
+    for (const fence of host ? [nodes[host.id]] : Object.values(nodes)) {
+        if (fence?.type !== 'fence' || fence.visible === false)
+            continue;
+        if (!host && levelId && findLevelAncestorId(fence.id, nodes) !== levelId)
+            continue;
+        if (ray && !host) {
+            const points = sampleFenceCenterline(fence);
+            const hostLevel = findLevelAncestorId(fence.id, nodes);
+            if (!hostLevel)
+                continue;
+            const support = createSceneSupportHeightSampler(nodes, hostLevel, fence.surfaceMode === 'selected'
+                ? (fence.supportSurfaceNodeId ?? fence.supportSlabId)
+                : undefined);
+            let along = 0;
+            for (let i = 1; i < points.length; i++) {
+                const a = points[i - 1];
+                const b = points[i];
+                const sx = b.x - a.x;
+                const sz = b.y - a.y;
+                const span = Math.hypot(sx, sz);
+                const [ox, oy, oz] = ray.origin;
+                const [dx, dy, dz] = ray.direction;
+                const denominator = dx * sz - dz * sx;
+                if (Math.abs(denominator) > 1e-8) {
+                    const t = ((a.x - ox) * sz - (a.y - oz) * sx) / denominator;
+                    const u = ((a.x - ox) * dz - (a.y - oz) * dx) / denominator;
+                    if (t >= 0 && u >= 0 && u <= 1) {
+                        const x = a.x + sx * u;
+                        const z = a.y + sz * u;
+                        const base = (fence.surfaceMode === 'level' ? support(...fence.start) : support(x, z)) +
+                            (fence.supportOffset ?? 0);
+                        const y = oy + dy * t;
+                        if (y >= base - 0.1 && y <= base + fence.height + 0.2 && (!best || t < best.distance))
+                            best = { fence, center: along + span * u, distance: t };
+                    }
+                }
+                along += span;
+            }
+        }
+        else {
+            const projection = projectPointToFence(fence, point);
+            if ((!best || projection.distance < best.distance) && projection.distance <= 0.7)
+                best = { fence, ...projection };
+        }
+    }
+    return best ?? null;
+}

package/dist/floor-opening/definition.d.ts

@@ -0,0 +1,3 @@
+import { FloorOpeningNode, type NodeDefinition } from '@pascal-app/core';
+export declare const floorOpeningDefinition: NodeDefinition<typeof FloorOpeningNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/floor-opening/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASxE,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CA0C1E,CAAA"}

package/dist/floor-opening/definition.js

@@ -0,0 +1,41 @@
+import { FloorOpeningNode } from '@pascal-app/core';
+import { buildFloorOpeningFloorplan, floorOpeningAddVertexAffordance, floorOpeningDeleteVertexAffordance, floorOpeningMoveEdgeAffordance, floorOpeningMoveVertexAffordance, } from './floorplan.js';
+export const floorOpeningDefinition = {
+    kind: 'floor-opening',
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: FloorOpeningNode,
+    category: 'structure',
+    defaults: () => {
+        const { id: _id, type: _type, ...rest } = FloorOpeningNode.parse({
+            polygon: [
+                [0, 0],
+                [1, 0],
+                [1, 1],
+                [0, 1],
+            ],
+        });
+        return rest;
+    },
+    capabilities: {
+        duplicable: false,
+        deletable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    // The void on the plan, and its corners while selected.
+    floorplan: buildFloorOpeningFloorplan,
+    floorplanAffordances: {
+        'move-vertex': floorOpeningMoveVertexAffordance,
+        'add-vertex': floorOpeningAddVertexAffordance,
+        'move-edge': floorOpeningMoveEdgeAffordance,
+        'delete-vertex': floorOpeningDeleteVertexAffordance,
+    },
+    rendersChildren: false,
+    presentation: {
+        icon: { kind: 'iconify', name: 'lucide:square-dashed' },
+        label: 'Floor opening',
+        hidden: true,
+        actionMenu: false,
+    },
+};