@pascal-app/nodes 0.1.1

package/dist/column/floorplan-affordances.js

@@ -0,0 +1,126 @@
+import { useScene, } from '@pascal-app/core';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+// Floor minimums — mirror the 3D handles in `column/definition.ts` so a
+// drag can't push a value past what the renderer accepts.
+const MIN_COLUMN_WIDTH = 0.1;
+const MIN_COLUMN_DEPTH = 0.1;
+const MIN_COLUMN_RADIUS = 0.05;
+const MIN_BRACE_DIMENSION = 0.04;
+const MIN_BRACE_BOTTOM_SPREAD = 0.2;
+const MIN_BRACE_TOP_SPREAD = 0;
+export const columnResizeAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { dim, planAxis } = payload;
+        const columnId = node.id;
+        const [ax, ay] = planAxis;
+        const initialProj = initialPlanPoint[0] * ax + initialPlanPoint[1] * ay;
+        const initialWidth = node.width;
+        const initialDepth = node.depth;
+        const initialRadius = node.radius;
+        const initialBraceWidth = node.braceWidth ?? node.width;
+        const initialBraceDepth = node.braceDepth ?? node.depth;
+        const initialBraceBottomSpread = node.braceBottomSpread ?? Math.max(node.width * 3, 1.2);
+        const initialBraceTopSpread = node.braceTopSpread ?? 0.12;
+        let lastPatch = {};
+        const commitPatch = (patch) => {
+            lastPatch = patch;
+            useScene.getState().updateNode(columnId, patch);
+        };
+        return {
+            affectedIds: [columnId],
+            apply({ planPoint }) {
+                const currentProj = planPoint[0] * ax + planPoint[1] * ay;
+                const projDelta = currentProj - initialProj;
+                switch (dim) {
+                    case 'width':
+                        commitPatch({
+                            width: Math.max(MIN_COLUMN_WIDTH, initialWidth + 2 * projDelta),
+                        });
+                        return;
+                    case 'depth':
+                        commitPatch({
+                            depth: Math.max(MIN_COLUMN_DEPTH, initialDepth + 2 * projDelta),
+                        });
+                        return;
+                    case 'uniform': {
+                        const next = Math.max(MIN_COLUMN_WIDTH, initialWidth + 2 * projDelta);
+                        commitPatch({ width: next, depth: next });
+                        return;
+                    }
+                    case 'radius':
+                        commitPatch({
+                            radius: Math.max(MIN_COLUMN_RADIUS, initialRadius + projDelta),
+                        });
+                        return;
+                    case 'brace-width':
+                        commitPatch({
+                            braceWidth: Math.max(MIN_BRACE_DIMENSION, initialBraceWidth + 2 * projDelta),
+                        });
+                        return;
+                    case 'brace-depth':
+                        commitPatch({
+                            braceDepth: Math.max(MIN_BRACE_DIMENSION, initialBraceDepth + 2 * projDelta),
+                        });
+                        return;
+                    case 'brace-bottom-spread':
+                        commitPatch({
+                            braceBottomSpread: Math.max(MIN_BRACE_BOTTOM_SPREAD, initialBraceBottomSpread + 2 * projDelta),
+                        });
+                        return;
+                    case 'brace-top-spread':
+                        commitPatch({
+                            braceTopSpread: Math.max(MIN_BRACE_TOP_SPREAD, initialBraceTopSpread + 2 * projDelta),
+                        });
+                        return;
+                }
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                if (Object.keys(lastPatch).length > 0) {
+                    useScene.getState().updateNode(columnId, lastPatch);
+                }
+            },
+        };
+    },
+};
+/**
+ * Column rotation drag (floor-plan). Sister to the 3D
+ * `columnRotateHandle` (arc-resize). Same `- delta` convention as the
+ * 3D handle: the floor-plan builder plots the footprint at
+ * `-column.rotation` (see `buildColumnFloorplan`'s `rot = -node.rotation`),
+ * so the 2D view rotates the same direction as 3D for the same
+ * `rotation` value, and the same cursor gesture writes the same sign
+ * in both views.
+ */
+export const columnRotateAffordance = {
+    start({ node, initialPlanPoint }) {
+        const columnId = node.id;
+        const initialRotation = node.rotation ?? 0;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastRotation = initialRotation;
+        return {
+            affectedIds: [columnId],
+            apply({ planPoint, modifiers }) {
+                const delta = rotateAffordanceDelta({
+                    center: [cx, cz],
+                    initialAngle,
+                    planPoint,
+                    free: modifiers.shiftKey,
+                });
+                const newRotation = initialRotation - delta;
+                lastRotation = newRotation;
+                useScene.getState().updateNode(columnId, { rotation: newRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(columnId, { rotation: lastRotation });
+            },
+        };
+    },
+};

package/dist/column/floorplan-move.d.ts

@@ -0,0 +1,11 @@
+import { type ColumnNode, type FloorplanMoveTarget } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for column. Columns need the same footprint-edge
+ * alignment as shelf / item, but they must preview through live transforms and
+ * commit once on release so the overlay does not churn the scene store on
+ * every pointermove.
+ *
+ * Column stores rotation as a scalar (not a tuple); position is `[x, y, z]`.
+ */
+export declare const columnFloorplanMoveTarget: FloorplanMoveTarget<ColumnNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/column/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/column/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;GAOG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAiErE,CAAA"}

package/dist/column/floorplan-move.js

@@ -0,0 +1,66 @@
+import { collectAlignmentAnchors, movingFootprintAnchors, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { applyFloorplanAlignment, getFloorStackPreviewPosition, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+/**
+ * 2D floor-plan move handler for column. Columns need the same footprint-edge
+ * alignment as shelf / item, but they must preview through live transforms and
+ * commit once on release so the overlay does not churn the scene store on
+ * every pointermove.
+ *
+ * Column stores rotation as a scalar (not a tuple); position is `[x, y, z]`.
+ */
+export const columnFloorplanMoveTarget = ({ node, nodes }) => {
+    const columnId = node.id;
+    const originalPosition = [...node.position];
+    const rotationY = node.rotation ?? 0;
+    const resolveCursor = createFloorplanCursorResolver({
+        original: [originalPosition[0], originalPosition[2]],
+        metadata: node.metadata,
+    });
+    let lastPosition = originalPosition;
+    let lastSnapKey = null;
+    // Alignment candidates gathered once — scene is stable during the drag.
+    const candidates = collectAlignmentAnchors(nodes, columnId);
+    const session = {
+        affectedIds: [columnId],
+        apply({ planPoint }) {
+            const snap = (value) => {
+                if (!isGridSnapActive())
+                    return value;
+                const step = useEditor.getState().gridSnapStep;
+                return Math.round(value / step) * step;
+            };
+            const gridSnapped = resolveCursor(planPoint, { snap });
+            // Figma-style alignment layered on the active snap mode.
+            const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], rotationY), candidates, { applySnap: isMagneticSnapActive() });
+            const next = [snapped[0], originalPosition[1], snapped[1]];
+            lastPosition = next;
+            const snapKey = `${snapped[0]},${snapped[1]}`;
+            if (snapKey !== lastSnapKey) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapKey = snapKey;
+            }
+            const visualPosition = getFloorStackPreviewPosition({
+                node,
+                position: next,
+                rotation: rotationY,
+                levelId: node.parentId ?? null,
+            });
+            sceneRegistry.nodes.get(columnId)?.position.set(...visualPosition);
+            useLiveTransforms.getState().set(columnId, {
+                position: next,
+                rotation: rotationY,
+            });
+        },
+        canCommit() {
+            const live = useScene.getState().nodes[columnId];
+            if (live?.type !== 'column')
+                return false;
+            return !(lastPosition[0] === originalPosition[0] && lastPosition[2] === originalPosition[2]);
+        },
+        commit() {
+            useScene.getState().updateNodes([{ id: columnId, data: { position: lastPosition } }]);
+        },
+    };
+    return session;
+};

package/dist/column/floorplan.d.ts

@@ -0,0 +1,15 @@
+import type { ColumnNode, FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+/**
+ * Stage C floor-plan builder for column. Inlined from the legacy
+ * `getColumnPlanFootprint` helper in `floorplan-panel.tsx`. The
+ * footprint shape depends on `crossSection` (square / rectangular /
+ * round / octagonal / sixteen-sided) and `supportStyle` (vertical /
+ * a-frame / x-brace / etc.) — brace supports use a rotated rectangle
+ * spanning the base spread; standalone columns use the shaft profile.
+ *
+ * When selected, switches to a themed accent stroke and emits the
+ * orange move-handle dot, four perpendicular side move-arrows for
+ * dragging the body, and a rotate-arrow at the front-right corner.
+ */
+export declare function buildColumnFloorplan(node: ColumnNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/column/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/column/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EAEjB,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAezB;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgI1B"}

package/dist/column/floorplan.js

@@ -0,0 +1,238 @@
+// Offsets for the floor-plan selection arrows. Resize chevrons hug the
+// footprint a hair off the rim; the rotate-arrow corner sits a bit
+// further out so it doesn't crowd the resize arrows.
+const RESIZE_ARROW_OFFSET = 0.12;
+const ROTATE_ARROW_CORNER_OFFSET = 0.22;
+const ROUND_CROSS_SECTIONS = new Set([
+    'round',
+    'octagonal',
+    'sixteen-sided',
+]);
+/**
+ * Stage C floor-plan builder for column. Inlined from the legacy
+ * `getColumnPlanFootprint` helper in `floorplan-panel.tsx`. The
+ * footprint shape depends on `crossSection` (square / rectangular /
+ * round / octagonal / sixteen-sided) and `supportStyle` (vertical /
+ * a-frame / x-brace / etc.) — brace supports use a rotated rectangle
+ * spanning the base spread; standalone columns use the shaft profile.
+ *
+ * When selected, switches to a themed accent stroke and emits the
+ * orange move-handle dot, four perpendicular side move-arrows for
+ * dragging the body, and a rotate-arrow at the front-right corner.
+ */
+export function buildColumnFloorplan(node, ctx) {
+    const polygon = getColumnPlanFootprint(node);
+    if (polygon.length < 3)
+        return null;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : '#374151';
+    const fill = showSelectedChrome ? '#fed7aa' : '#9ca3af';
+    const points = polygon.map((p) => [p.x, p.y]);
+    const children = [
+        {
+            kind: 'polygon',
+            points,
+            fill,
+            stroke,
+            strokeWidth: showSelectedChrome ? 0.03 : 0.02,
+            opacity: 0.92,
+        },
+    ];
+    // Hatch overlay on selected — same `<defs>` pattern as the wall.
+    if (isSelected && palette) {
+        children.push({
+            kind: 'hatch',
+            points,
+            color: palette.selectedHatch,
+            opacity: 0.7,
+        });
+    }
+    // Selection chrome — move-handle dot at the centre (body move), one
+    // resize chevron per dimension the 3D handle set exposes (radius /
+    // uniform / width+depth or brace-width+brace-depth + per-style spread
+    // arrows), and a rotate-arrow at the front-right corner. Mirrors
+    // `column/definition.ts`'s handle selection so what users can
+    // manipulate in 3D top-view is the same in the floor plan.
+    if (isSelected) {
+        children.push({
+            kind: 'move-handle',
+            point: [node.position[0], node.position[2]],
+        });
+        const cx = node.position[0];
+        const cz = node.position[2];
+        // Floor-plan plots at `-rotation` so SVG-CW maps to Three.js-CCW.
+        // Selection chrome (side arrows, rotate-arrow) follows the same
+        // convention so it stays glued to the rotated footprint.
+        const rot = -node.rotation;
+        const emitArrowAlong = (dim, localDirection, localOffsetDistance) => {
+            // Local position of the arrow's chevron tip relative to the
+            // column centre. The chevron sits a hair past the dimension's
+            // current half-extent so it never overlaps the footprint stroke.
+            const localPos = localDirection === 'x' ? [localOffsetDistance, 0] : [0, localOffsetDistance];
+            const [worldOffsetX, worldOffsetZ] = rotatePlanVector(localPos[0], localPos[1], rot);
+            // The cursor projection axis: same direction as the arrow's
+            // outward tip in plan coords. Captured at emit-time so the
+            // affordance doesn't need to recompute `column.rotation` (and
+            // a mid-drag rotation can't drift the projection basis).
+            const outwardLocal = localDirection === 'x' ? [1, 0] : [0, 1];
+            const [planAxisX, planAxisY] = rotatePlanVector(outwardLocal[0], outwardLocal[1], rot);
+            children.push({
+                kind: 'move-arrow',
+                point: [cx + worldOffsetX, cz + worldOffsetZ],
+                angle: Math.atan2(planAxisY, planAxisX),
+                affordance: 'column-resize',
+                payload: { dim, planAxis: [planAxisX, planAxisY] },
+            });
+        };
+        if (node.supportStyle !== 'vertical') {
+            // Brace columns — width + depth of the bracing structure. Spread
+            // arrows (top + bottom) project to the same XZ in top-view, so
+            // we only surface bracing dimensions here. The 3D set still has
+            // spread arrows at different heights.
+            const halfBraceX = Math.max(node.width, node.braceWidth ?? 0, node.braceBottomSpread ?? 0, node.braceTopSpread ?? 0) / 2;
+            const halfBraceZ = Math.max(node.depth, node.braceDepth ?? 0) / 2;
+            emitArrowAlong('brace-width', 'x', halfBraceX + RESIZE_ARROW_OFFSET);
+            emitArrowAlong('brace-depth', 'z', halfBraceZ + RESIZE_ARROW_OFFSET);
+        }
+        else if (ROUND_CROSS_SECTIONS.has(node.crossSection)) {
+            // Round shafts — single radius arrow. `radial-resize` factor 1
+            // (cursor delta = radius delta), so dragging the chevron
+            // outward 1 unit grows the column by 1 unit.
+            emitArrowAlong('radius', 'x', node.radius + RESIZE_ARROW_OFFSET);
+        }
+        else if (node.crossSection === 'square') {
+            // Square shafts — single uniform arrow that grows width + depth
+            // together (matches 3D `columnUniformHandle`).
+            emitArrowAlong('uniform', 'x', node.width / 2 + RESIZE_ARROW_OFFSET);
+        }
+        else {
+            // Rectangular — independent width + depth arrows.
+            emitArrowAlong('width', 'x', node.width / 2 + RESIZE_ARROW_OFFSET);
+            emitArrowAlong('depth', 'z', node.depth / 2 + RESIZE_ARROW_OFFSET);
+        }
+        // Rotate-arrow at the +X / +Z corner — matches the 3D
+        // `columnRotateHandle` corner placement so users see the rotation
+        // affordance in the same quadrant across views.
+        const { halfX, halfZ } = columnPlanHalfExtents(node);
+        const cornerLocalX = halfX + ROTATE_ARROW_CORNER_OFFSET;
+        const cornerLocalZ = halfZ + ROTATE_ARROW_CORNER_OFFSET;
+        const [cornerWorldX, cornerWorldZ] = rotatePlanVector(cornerLocalX, cornerLocalZ, rot);
+        const [radialX, radialZ] = rotatePlanVector(1, 1, rot);
+        children.push({
+            kind: 'rotate-arrow',
+            point: [cx + cornerWorldX, cz + cornerWorldZ],
+            angle: Math.atan2(radialZ, radialX),
+            affordance: 'column-rotate',
+            pivot: [cx, cz],
+        });
+    }
+    return { kind: 'group', children };
+}
+/**
+ * XZ half-extents for the column's plan footprint. Mirrors the 3D
+ * `columnFootprintHalf` so side-arrows + rotate-arrow ring the same
+ * bounding box the in-world handles use. Vertical supports read the
+ * shaft geometry; non-vertical supports use the widest brace bound so
+ * arrows clear the splay.
+ */
+function columnPlanHalfExtents(column) {
+    if (column.supportStyle !== 'vertical') {
+        return {
+            halfX: Math.max(column.width, column.braceWidth ?? 0, column.braceBottomSpread ?? 0, column.braceTopSpread ?? 0) / 2,
+            halfZ: Math.max(column.depth, column.braceDepth ?? 0) / 2,
+        };
+    }
+    if (column.crossSection === 'round' ||
+        column.crossSection === 'octagonal' ||
+        column.crossSection === 'sixteen-sided') {
+        return { halfX: column.radius, halfZ: column.radius };
+    }
+    if (column.crossSection === 'square') {
+        return { halfX: column.width / 2, halfZ: column.width / 2 };
+    }
+    return { halfX: column.width / 2, halfZ: column.depth / 2 };
+}
+function rotatePlanVector(x, y, rotation) {
+    const c = Math.cos(rotation);
+    const s = Math.sin(rotation);
+    return [x * c - y * s, x * s + y * c];
+}
+function getRotatedRectanglePolygon(center, width, depth, rotation) {
+    const halfW = width / 2;
+    const halfD = depth / 2;
+    const corners = [
+        [-halfW, -halfD],
+        [halfW, -halfD],
+        [halfW, halfD],
+        [-halfW, halfD],
+    ];
+    return corners.map(([x, y]) => {
+        const [rx, ry] = rotatePlanVector(x, y, rotation);
+        return { x: center.x + rx, y: center.y + ry };
+    });
+}
+function getColumnPlanFootprint(column) {
+    const center = { x: column.position[0], y: column.position[2] };
+    // Brace-support columns: rotated rectangle spanning the base spread.
+    if (column.supportStyle === 'a-frame' ||
+        column.supportStyle === 'y-frame' ||
+        column.supportStyle === 'v-frame' ||
+        column.supportStyle === 'x-brace' ||
+        column.supportStyle === 'k-brace' ||
+        column.supportStyle === 'single-strut' ||
+        column.supportStyle === 'tripod' ||
+        column.supportStyle === 'trestle' ||
+        column.supportStyle === 'portal-frame' ||
+        column.supportStyle === 'box-frame') {
+        const width = Math.max(column.supportStyle === 'a-frame' ||
+            column.supportStyle === 'x-brace' ||
+            column.supportStyle === 'k-brace' ||
+            column.supportStyle === 'single-strut' ||
+            column.supportStyle === 'tripod' ||
+            column.supportStyle === 'trestle' ||
+            column.supportStyle === 'portal-frame' ||
+            column.supportStyle === 'box-frame'
+            ? (column.braceBottomSpread ?? 1.2)
+            : 0, column.braceTopSpread ??
+            (column.supportStyle === 'y-frame' ||
+                column.supportStyle === 'v-frame' ||
+                column.supportStyle === 'x-brace' ||
+                column.supportStyle === 'k-brace' ||
+                column.supportStyle === 'single-strut' ||
+                column.supportStyle === 'tripod' ||
+                column.supportStyle === 'trestle' ||
+                column.supportStyle === 'portal-frame' ||
+                column.supportStyle === 'box-frame'
+                ? 1
+                : 0), (column.braceWidth ?? column.width) * 2);
+        const depth = Math.max(column.supportStyle === 'tripod' ||
+            column.supportStyle === 'trestle' ||
+            column.supportStyle === 'box-frame'
+            ? (column.braceTopSpread ?? 1)
+            : 0, column.braceDepth ?? column.depth, 0.08);
+        return getRotatedRectanglePolygon(center, width, depth, -column.rotation);
+    }
+    // Standalone column: shaft profile expanded for base + capital.
+    const isRound = column.crossSection === 'round' ||
+        column.crossSection === 'octagonal' ||
+        column.crossSection === 'sixteen-sided';
+    const shaftWidth = isRound ? column.radius * 2 : column.width;
+    const shaftDepth = isRound ? column.radius * 2 : column.depth;
+    const width = Math.max(shaftWidth, column.width * column.baseWidthScale, column.width * column.capitalWidthScale);
+    const depth = Math.max(shaftDepth, column.depth * column.baseDepthScale, column.depth * column.capitalDepthScale);
+    if (column.crossSection === 'square' || column.crossSection === 'rectangular') {
+        return getRotatedRectanglePolygon(center, width, depth, -column.rotation);
+    }
+    const segmentCount = column.crossSection === 'octagonal' ? 8 : column.crossSection === 'sixteen-sided' ? 16 : 32;
+    return Array.from({ length: segmentCount }, (_, index) => {
+        const angle = (index / segmentCount) * Math.PI * 2;
+        const localX = Math.cos(angle) * (width / 2);
+        const localY = Math.sin(angle) * (depth / 2);
+        const [offsetX, offsetY] = rotatePlanVector(localX, localY, -column.rotation);
+        return { x: center.x + offsetX, y: center.y + offsetY };
+    });
+}

package/dist/column/index.d.ts

@@ -0,0 +1,2 @@
+export { columnDefinition } from './definition';
+//# sourceMappingURL=index.d.ts.map

package/dist/column/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/column/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA"}

package/dist/column/index.js

@@ -0,0 +1 @@
+export { columnDefinition } from './definition';

package/dist/column/paint.d.ts

@@ -0,0 +1,2 @@
+export declare const columnPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/column/paint.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,4CAatB,CAAA"}

package/dist/column/paint.js

@@ -0,0 +1,15 @@
+import { createSlotPaintCapability, previewSlotByUserData } from '../shared/slot-paint';
+export const columnPaint = createSlotPaintCapability({
+    resolveRole: (args) => {
+        const slotId = args.hitObject?.userData?.slotId;
+        return typeof slotId === 'string' ? slotId : null;
+    },
+    applyPreview: previewSlotByUserData,
+    legacyEffective: (node) => {
+        const column = node;
+        if (column.materialPreset || column.material) {
+            return { material: column.material, materialPreset: column.materialPreset };
+        }
+        return null;
+    },
+});

package/dist/column/panel.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/column/panel.tsx"],"names":[],"mappings":"AAoQA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAw0BlC"}