@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/column/parametrics.js

@@ -13,7 +13,7 @@ export const columnParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'height', kind: 'number', unit: 'm', min: 0.5, max: 1000, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.2, max: 1000, step: 0.05 },
                 { key: 'width', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.01 },
                 { key: 'depth', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.01 },
             ],

package/dist/column/post-options.d.ts

@@ -0,0 +1,10 @@
+import { type ToolOption } from '@pascal-app/core';
+/**
+ * "Place" for the column tool, one family with the Post tool: a column of the chosen style, or a
+ * pressure-treated framing post of a size, which stands up to the beam over it. Picking across
+ * the family switches what the tool places.
+ */
+export declare const columnPlaceOption: ToolOption;
+/** What a framing post stands on, shown while the tool places posts. */
+export declare const postBaseOption: ToolOption;
+//# sourceMappingURL=post-options.d.ts.map

package/dist/column/post-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-options.d.ts","sourceRoot":"","sources":["../../src/column/post-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAazB;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAwC/B,CAAA;AAED,wEAAwE;AACxE,eAAO,MAAM,cAAc,EAAE,UAiB5B,CAAA"}

package/dist/column/post-options.js

@@ -0,0 +1,71 @@
+import { FRAMING_POST_BASE_LABELS, } from '@pascal-app/core';
+import { useEditor } from '@pascal-app/editor';
+import { armFramingPostTool, dropInflightColumnPlacement, framingPostToolChoices, } from './post-placement.js';
+const subscribe = (onChange) => useEditor.subscribe(() => onChange());
+/** The Post tool's size, or null while the column tool places ornamental columns. */
+const postChoices = () => framingPostToolChoices(useEditor.getState().toolDefaults.column);
+/**
+ * "Place" for the column tool, one family with the Post tool: a column of the chosen style, or a
+ * pressure-treated framing post of a size, which stands up to the beam over it. Picking across
+ * the family switches what the tool places.
+ */
+export const columnPlaceOption = {
+    id: 'column-place',
+    label: 'Place',
+    choices: [
+        {
+            value: 'column',
+            label: 'Column',
+            description: 'A column of a chosen style: round, square or tapered, or a support frame',
+        },
+        {
+            value: '4x4',
+            label: '4x4 post',
+            description: 'A treated 4x4 framing post, for a light porch or a deck post up to 8 ft',
+        },
+        {
+            value: '6x6',
+            label: '6x6 post',
+            description: 'A treated 6x6 framing post: the post under a porch or a deck beam',
+        },
+        {
+            value: '8x8',
+            label: '8x8 post',
+            description: 'A treated 8x8 framing post, for a tall post or a heavy load',
+        },
+    ],
+    subscribe,
+    value: () => postChoices()?.size ?? 'column',
+    set: (value) => {
+        if (value !== 'column') {
+            armFramingPostTool(value);
+            return;
+        }
+        // Already placing columns (perhaps a preset following the cursor): nothing to switch.
+        if (postChoices() === null)
+            return;
+        dropInflightColumnPlacement();
+        const editor = useEditor.getState();
+        editor.setToolDefaults('column', null);
+        if (!(editor.mode === 'build' && editor.tool === 'column'))
+            editor.armToolMode({ mode: 'build', tool: 'column' });
+    },
+};
+/** What a framing post stands on, shown while the tool places posts. */
+export const postBaseOption = {
+    id: 'post-base',
+    label: 'Base',
+    choices: ['none', 'post-base', 'pier'].map((base) => ({
+        value: base,
+        label: FRAMING_POST_BASE_LABELS[base],
+        description: base === 'none'
+            ? 'Straight on the floor or the footing under it'
+            : base === 'post-base'
+                ? 'A steel post base holding the wood off the concrete'
+                : 'A concrete pier 8 in tall under the post',
+    })),
+    subscribe,
+    value: () => postChoices()?.base ?? 'none',
+    set: (value) => armFramingPostTool(undefined, value),
+    visible: { subscribe, value: () => postChoices() !== null },
+};

package/dist/column/post-placement.d.ts

@@ -0,0 +1,78 @@
+import { type AnyNode, type AnyNodeId, type BeamNode, type ColumnNode, type ColumnPostBase, type FramingPostSize, type WallNode } from '@pascal-app/core';
+import { type WallDraftSnapKind, type WallPlanPoint } from '@pascal-app/editor';
+type Nodes = Readonly<Record<AnyNodeId, AnyNode>>;
+/** Posts no further apart than this under a beam the panel posts: 8 ft, as a porch's are. */
+export declare const FRAMING_POST_SPACING: number;
+/** The post choices the Post tool draws with, kept on the column tool's defaults. */
+export type FramingPostToolChoices = {
+    size: FramingPostSize;
+    base: ColumnPostBase;
+};
+/**
+ * The Post tool is the column tool armed with a framing post's fields (`toolDefaults.column`,
+ * `role: 'post'`): its size and base, or null while it places ornamental columns.
+ */
+export declare function framingPostToolChoices(defaults: Readonly<Record<string, unknown>> | null | undefined): FramingPostToolChoices | null;
+/** The column tool's defaults that make it the Post tool: a post of this size and base. */
+export declare function framingPostToolDefaults(size?: FramingPostSize, base?: ColumnPostBase): Record<string, unknown>;
+/**
+ * Drops a preset still following the cursor (a column preset's clone on the move tool): while it
+ * moves, no build tool mounts.
+ */
+export declare function dropInflightColumnPlacement(): void;
+/**
+ * Arms the column tool as the Post tool (the Build panel's Post tile): a post of `size` on `base`,
+ * else as the tool has them, else as they were last picked.
+ */
+export declare function armFramingPostTool(size?: FramingPostSize, base?: ColumnPostBase): void;
+/**
+ * What a post set on `levelId` snaps to: each beam's centreline (its ends, its middle and its run,
+ * so a post lands under a beam end or anywhere along it) and the other posts' and columns'
+ * centres.
+ */
+export declare function postSnapTargets(nodes: Nodes, levelId: string, ignoreIds?: readonly string[]): WallNode[];
+/**
+ * A post's plan point, snapped: a beam end, a point along a beam or another post catch it within
+ * the snap's reach, otherwise the grid while it snaps. `free` (Alt) places it as it is.
+ */
+export declare function snapPostPoint(args: {
+    point: WallPlanPoint;
+    nodes: Nodes;
+    levelId: string;
+    ignoreIds?: readonly string[];
+    free?: boolean;
+}): {
+    point: WallPlanPoint;
+    snap: WallDraftSnapKind | null;
+};
+/** What a framing post stands on at a point: the support the floor stacking elects under it. */
+export type PostFoot = (post: ColumnNode) => number;
+/** The runtime foot: the elected support's top under the post, plus its own lift. */
+export declare const electedPostFoot: (nodes: Nodes, levelId: string) => PostFoot;
+/**
+ * A framing post at a plan point, standing from its foot up to the underside of the beam over it,
+ * else to the ceiling plane: what the Post tool places, and its ghost.
+ */
+export declare function framingPostAt(args: {
+    nodes: Nodes;
+    levelId: string;
+    point: WallPlanPoint;
+    choices: FramingPostToolChoices;
+    foot: PostFoot;
+}): {
+    post: ColumnNode;
+    beamId: string | null;
+};
+/**
+ * Posts under a beam: one at each end and evenly between, no further apart than `spacing`, each
+ * from its foot up to this beam's underside. Skips a station a post already stands at.
+ */
+export declare function framingPostsUnderBeam(args: {
+    nodes: Nodes;
+    beam: BeamNode;
+    choices: FramingPostToolChoices;
+    foot: PostFoot;
+    spacing?: number;
+}): ColumnNode[];
+export {};
+//# sourceMappingURL=post-placement.d.ts.map

package/dist/column/post-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-placement.d.ts","sourceRoot":"","sources":["../../src/column/post-placement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAEb,KAAK,UAAU,EACf,KAAK,cAAc,EAKnB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAML,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAE3B,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AAEjD,6FAA6F;AAC7F,eAAO,MAAM,oBAAoB,QAAkB,CAAA;AAEnD,qFAAqF;AACrF,MAAM,MAAM,sBAAsB,GAAG;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,cAAc,CAAA;CAAE,CAAA;AAEpF;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,GAC7D,sBAAsB,GAAG,IAAI,CAU/B;AAED,2FAA2F;AAC3F,wBAAgB,uBAAuB,CACrC,IAAI,GAAE,eAA2C,EACjD,IAAI,GAAE,cAAuB,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzB;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAIlD;AAQD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,cAAc,GAAG,IAAI,CAQtF;AAmBD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,SAAS,MAAM,EAAO,GAChC,QAAQ,EAAE,CAWZ;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,KAAK,EAAE,aAAa,CAAA;IACpB,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,GAAG;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAAE,CAY3D;AAED,gGAAgG;AAChG,MAAM,MAAM,QAAQ,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,MAAM,CAAA;AAEnD,qFAAqF;AACrF,eAAO,MAAM,eAAe,UAClB,KAAK,WAAW,MAAM,KAAG,QAOV,CAAA;AAEzB;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,aAAa,CAAA;IACpB,OAAO,EAAE,sBAAsB,CAAA;IAC/B,IAAI,EAAE,QAAQ,CAAA;CACf,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAsB9C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,sBAAsB,CAAA;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,GAAG,UAAU,EAAE,CAqBf"}

package/dist/column/post-placement.js

@@ -0,0 +1,157 @@
+import { beamBottomElevation, createFramingPost, DEFAULT_FRAMING_POST_SIZE, emitter, FRAMING_POST_SIZES, framingPostFields, framingPostSize, framingPostTopAt, getFloorPlacedElevation, postStationsAlong, } from '@pascal-app/core';
+import { getMovingNode, isGridSnapActive, snapBuildingLocalToWorldGrid, snapWallDraftPointDetailed, useEditor, } from '@pascal-app/editor';
+/** Posts no further apart than this under a beam the panel posts: 8 ft, as a porch's are. */
+export const FRAMING_POST_SPACING = 8 * 12 * 0.0254;
+/**
+ * The Post tool is the column tool armed with a framing post's fields (`toolDefaults.column`,
+ * `role: 'post'`): its size and base, or null while it places ornamental columns.
+ */
+export function framingPostToolChoices(defaults) {
+    if (defaults?.role !== 'post')
+        return null;
+    const width = typeof defaults.width === 'number' ? defaults.width : undefined;
+    const size = (width !== undefined && framingPostSize({ width, depth: width })) || DEFAULT_FRAMING_POST_SIZE;
+    const base = defaults.postBase;
+    return {
+        size,
+        base: base === 'post-base' || base === 'pier' ? base : 'none',
+    };
+}
+/** The column tool's defaults that make it the Post tool: a post of this size and base. */
+export function framingPostToolDefaults(size = DEFAULT_FRAMING_POST_SIZE, base = 'none') {
+    return { ...framingPostFields(size, base) };
+}
+/**
+ * Drops a preset still following the cursor (a column preset's clone on the move tool): while it
+ * moves, no build tool mounts.
+ */
+export function dropInflightColumnPlacement() {
+    if (!getMovingNode())
+        return;
+    emitter.emit('tool:cancel');
+    useEditor.getState().setMovingNode(null);
+}
+/**
+ * The size and base last picked, kept apart from the tool's defaults: a host clears those when it
+ * arms the column tool from a tile, and the Post tile should come back as the user left it.
+ */
+let lastChoices = { size: DEFAULT_FRAMING_POST_SIZE, base: 'none' };
+/**
+ * Arms the column tool as the Post tool (the Build panel's Post tile): a post of `size` on `base`,
+ * else as the tool has them, else as they were last picked.
+ */
+export function armFramingPostTool(size, base) {
+    dropInflightColumnPlacement();
+    const editor = useEditor.getState();
+    const current = framingPostToolChoices(editor.toolDefaults.column) ?? lastChoices;
+    lastChoices = { size: size ?? current.size, base: base ?? current.base };
+    editor.setToolDefaults('column', framingPostToolDefaults(lastChoices.size, lastChoices.base));
+    if (!(editor.mode === 'build' && editor.tool === 'column'))
+        editor.armToolMode({ mode: 'build', tool: 'column' });
+}
+/** A point the wall snap reads as a wall: a segment of no length catches at the point. */
+function pointReference(id, parentId, at) {
+    return {
+        object: 'node',
+        id: id,
+        type: 'wall',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        start: at,
+        end: at,
+        frontSide: 'unknown',
+        backSide: 'unknown',
+    };
+}
+/**
+ * What a post set on `levelId` snaps to: each beam's centreline (its ends, its middle and its run,
+ * so a post lands under a beam end or anywhere along it) and the other posts' and columns'
+ * centres.
+ */
+export function postSnapTargets(nodes, levelId, ignoreIds = []) {
+    const targets = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== levelId || node.visible === false || ignoreIds.includes(node.id))
+            continue;
+        if (node.type === 'beam') {
+            targets.push({ ...pointReference(node.id, node.parentId, node.start), end: node.end });
+        }
+        else if (node.type === 'column') {
+            targets.push(pointReference(node.id, node.parentId, [node.position[0], node.position[2]]));
+        }
+    }
+    return targets;
+}
+/**
+ * A post's plan point, snapped: a beam end, a point along a beam or another post catch it within
+ * the snap's reach, otherwise the grid while it snaps. `free` (Alt) places it as it is.
+ */
+export function snapPostPoint(args) {
+    if (args.free)
+        return { point: args.point, snap: null };
+    const step = useEditor.getState().gridSnapStep;
+    const grid = isGridSnapActive();
+    const result = snapWallDraftPointDetailed({
+        point: args.point,
+        walls: postSnapTargets(args.nodes, args.levelId, args.ignoreIds),
+        // Beams and posts always catch a post; the grid is the snapping mode's to give.
+        magnetic: true,
+        gridSnap: (point) => (grid ? snapBuildingLocalToWorldGrid(point, step) : point),
+    });
+    return { point: result.point, snap: result.snap };
+}
+/** The runtime foot: the elected support's top under the post, plus its own lift. */
+export const electedPostFoot = (nodes, levelId) => (post) => getFloorPlacedElevation({
+    node: post,
+    nodes: nodes,
+    position: post.position,
+    levelId,
+}) + post.position[1];
+/**
+ * A framing post at a plan point, standing from its foot up to the underside of the beam over it,
+ * else to the ceiling plane: what the Post tool places, and its ghost.
+ */
+export function framingPostAt(args) {
+    const draft = createFramingPost({
+        position: args.point,
+        size: args.choices.size,
+        base: args.choices.base,
+        levelId: args.levelId,
+    });
+    const base = args.foot(draft);
+    const { top, beamId } = framingPostTopAt(args.nodes, args.levelId, args.point, {
+        baseElevation: base,
+        side: FRAMING_POST_SIZES[args.choices.size],
+    });
+    return {
+        post: createFramingPost({
+            position: args.point,
+            size: args.choices.size,
+            base: args.choices.base,
+            levelId: args.levelId,
+            height: top - base,
+        }),
+        beamId,
+    };
+}
+/**
+ * Posts under a beam: one at each end and evenly between, no further apart than `spacing`, each
+ * from its foot up to this beam's underside. Skips a station a post already stands at.
+ */
+export function framingPostsUnderBeam(args) {
+    const levelId = args.beam.parentId;
+    if (!levelId)
+        return [];
+    const standing = Object.values(args.nodes).filter((node) => node.type === 'column' && node.parentId === levelId);
+    const underside = beamBottomElevation(args.nodes, args.beam);
+    return postStationsAlong(args.beam.start, args.beam.end, args.spacing ?? FRAMING_POST_SPACING)
+        .filter((point) => !standing.some((post) => Math.hypot(post.position[0] - point[0], post.position[2] - point[1]) <
+        Math.max(post.width, FRAMING_POST_SIZES[args.choices.size])))
+        .map((point) => {
+        const fields = { position: point, ...args.choices, levelId };
+        const foot = args.foot(createFramingPost(fields));
+        return createFramingPost({ ...fields, height: underside - foot });
+    });
+}

package/dist/column/post-section.d.ts

@@ -0,0 +1,17 @@
+import { type AnyNode, type AnyNodeId, type ColumnNode, type FramingPostSize } from '@pascal-app/core';
+/** The fields that make a post another square size, its base kept in proportion. */
+export declare function framingPostSizePatch(post: ColumnNode, size: FramingPostSize): Partial<ColumnNode>;
+/** Where a post's top goes: the beam over it, else the ceiling plane, and its height to it from its foot. */
+export declare function framingPostFit(nodes: Record<AnyNodeId, AnyNode>, post: ColumnNode, foot: number): {
+    height: number;
+    beamId: string | null;
+} | null;
+/**
+ * A framing post's settings in the column panel, in place of a column's styles: its size, its
+ * base, its wood, its height with a fit to the beam over it, and the deck-post height check.
+ */
+export declare function FramingPostSection({ node, onUpdate, }: {
+    node: ColumnNode;
+    onUpdate: (updates: Partial<ColumnNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=post-section.d.ts.map

package/dist/column/post-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-section.d.ts","sourceRoot":"","sources":["../../src/column/post-section.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,UAAU,EAKf,KAAK,eAAe,EAQrB,MAAM,kBAAkB,CAAA;AASzB,oFAAoF;AACpF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,UAAU,CAAC,CAWjG;AAED,6GAA6G;AAC7G,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,GACX;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAAG,IAAI,CASlD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;CACjD,+BAyHA"}

package/dist/column/post-section.js

@@ -0,0 +1,95 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FRAMING_POST_BASE_LABELS, FRAMING_POST_MATERIAL_REF, FRAMING_POST_SIZES, formatLinearMeasurement, framingPostBasePatch, framingPostHeightLimit, framingPostSize, framingPostTopAt, usePascalI18n, useScene, } from '@pascal-app/core';
+import { MetricControl, PanelSection, SegmentedControl } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { electedPostFoot } from './post-placement.js';
+/** Sawn lumber for a post kept dry inside; a post's default is treated (`FRAMING_POST_MATERIAL_REF`). */
+const UNTREATED_REF = 'library:wood-woodfine2';
+const CUSTOM = 'custom';
+/** The fields that make a post another square size, its base kept in proportion. */
+export function framingPostSizePatch(post, size) {
+    const side = FRAMING_POST_SIZES[size];
+    return {
+        width: side,
+        depth: side,
+        radius: side / 2,
+        ...framingPostBasePatch({ width: side, depth: side, slots: post.slots }, post.postBase ?? 'none'),
+    };
+}
+/** Where a post's top goes: the beam over it, else the ceiling plane, and its height to it from its foot. */
+export function framingPostFit(nodes, post, foot) {
+    if (!post.parentId)
+        return null;
+    const { top, beamId } = framingPostTopAt(nodes, post.parentId, [post.position[0], post.position[2]], { baseElevation: foot, side: post.width });
+    return { height: top - foot, beamId };
+}
+/**
+ * A framing post's settings in the column panel, in place of a column's styles: its size, its
+ * base, its wood, its height with a fit to the beam over it, and the deck-post height check.
+ */
+export function FramingPostSection({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
+    const unit = useViewer((state) => state.unit);
+    const metricNotation = useViewer((state) => state.metricNotation);
+    const nodes = useScene((state) => state.nodes);
+    const size = framingPostSize(node) ?? CUSTOM;
+    const treated = (node.slots?.shaft ?? FRAMING_POST_MATERIAL_REF) === FRAMING_POST_MATERIAL_REF;
+    const limit = framingPostHeightLimit(node);
+    const length = (meters) => formatLinearMeasurement(meters, unit, metricNotation);
+    const fit = node.parentId !== null
+        ? framingPostFit(nodes, node, electedPostFoot(nodes, node.parentId)(node))
+        : null;
+    const fitBeam = fit?.beamId ? nodes[fit.beamId] : undefined;
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.column.postSection.post', message: 'Post' }), children: [_jsx(SegmentedControl, { onChange: (next) => {
+                    if (next !== CUSTOM)
+                        onUpdate(framingPostSizePatch(node, next));
+                }, options: [
+                    ...Object.keys(FRAMING_POST_SIZES).map((value) => ({
+                        label: value,
+                        value,
+                    })),
+                    ...(size === CUSTOM
+                        ? [
+                            {
+                                label: i18n._({ id: 'node.column.postSection.custom', message: 'Custom' }),
+                                value: CUSTOM,
+                            },
+                        ]
+                        : []),
+                ], value: size }), _jsx(SegmentedControl, { onChange: (base) => onUpdate(framingPostBasePatch(node, base)), options: ['none', 'post-base', 'pier'].map((value) => ({
+                    label: FRAMING_POST_BASE_LABELS[value],
+                    value,
+                })), value: node.postBase ?? 'none' }), _jsx(SegmentedControl, { onChange: (wood) => onUpdate({
+                    slots: {
+                        ...node.slots,
+                        shaft: wood === 'treated' ? FRAMING_POST_MATERIAL_REF : UNTREATED_REF,
+                    },
+                }), options: [
+                    {
+                        label: i18n._({ id: 'node.column.postSection.treated', message: 'Treated' }),
+                        value: 'treated',
+                    },
+                    {
+                        label: i18n._({ id: 'node.column.postSection.untreated', message: 'Untreated' }),
+                        value: 'untreated',
+                    },
+                ], value: treated ? 'treated' : 'untreated' }), _jsx(MetricControl, { label: i18n._({ id: 'node.column.postSection.height', message: 'Height' }), min: 0.3, onChange: (height) => onUpdate({ height }), precision: 3, step: 0.01, unit: "m", value: node.height }), fit && Math.abs(fit.height - node.height) > 0.001 && fit.height > 0.3 && (_jsx("button", { className: "self-start rounded-full border border-border/50 px-3 py-1 text-muted-foreground text-xs hover:text-foreground", "data-post-fit": true, onClick: () => onUpdate({ height: fit.height }), type: "button", children: fitBeam
+                    ? i18n._({
+                        id: 'node.column.postSection.fitToTheBeamOverIt',
+                        message: 'Fit to the beam over it ({height})',
+                        values: { height: length(fit.height) },
+                    })
+                    : i18n._({
+                        id: 'node.column.postSection.fitToTheCeilingPlane',
+                        message: 'Fit to the ceiling plane ({height})',
+                        values: { height: length(fit.height) },
+                    }) })), limit && (_jsx("p", { className: "rounded-lg bg-accent/30 px-2.5 py-2 text-muted-foreground text-xs", role: "status", children: i18n._({
+                    id: 'node.column.postSection.aSizeDeckPostStandsNo',
+                    message: 'A {size} deck post stands no taller than {limit} (IRC Table R507.4, by species and the area it carries): check it, or use the next size up.',
+                    values: { size: limit.size, limit: length(limit.limit) },
+                }) })), _jsx("button", { className: "self-start rounded-full border border-border/50 px-3 py-1 text-muted-foreground text-xs hover:text-foreground", onClick: () => onUpdate({ role: undefined, postBase: undefined }), title: i18n._({
+                    id: 'node.column.postSection.keepItsShapeAndStyleIt',
+                    message: 'Keep its shape and style it as a column',
+                }), type: "button", children: i18n._({ id: 'node.column.postSection.makeItAColumn', message: 'Make it a column' }) })] }));
+}

package/dist/column/post-tool.d.ts

@@ -0,0 +1,11 @@
+import { type FramingPostToolChoices } from './post-placement.js';
+/**
+ * The Post tool: the column tool armed with a framing post (`framingPostToolChoices`). The post
+ * snaps under a beam's end, anywhere along a beam, onto another post, else to the grid (Alt free);
+ * it stands from what it lands on up to the underside of the beam over it, else to the ceiling
+ * plane, and the ghost shows that height before the click. Repeats as the column tool does.
+ */
+export declare function FramingPostTool({ choices }: {
+    choices: FramingPostToolChoices;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=post-tool.d.ts.map

package/dist/column/post-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-tool.d.ts","sourceRoot":"","sources":["../../src/column/post-tool.tsx"],"names":[],"mappings":"AA2BA,OAAO,EAEL,KAAK,sBAAsB,EAG5B,MAAM,kBAAkB,CAAA;AAKzB;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,sBAAsB,CAAA;CAAE,sCA2F/E"}

package/dist/column/post-tool.js

@@ -0,0 +1,94 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ColumnNode as ColumnNodeSchema, emitter, resolveSupportSlabPatch, useScene, } from '@pascal-app/core';
+import { getFloorStackPreviewPosition, triggerSFX, useEditor, usePlacementPreview, useWallSnapIndicator, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useRef, useState } from 'react';
+import { stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement.js';
+import { electedPostFoot, framingPostAt, snapPostPoint, } from './post-placement.js';
+import { ColumnPreview } from './renderer.js';
+/**
+ * The Post tool: the column tool armed with a framing post (`framingPostToolChoices`). The post
+ * snaps under a beam's end, anywhere along a beam, onto another post, else to the grid (Alt free);
+ * it stands from what it lands on up to the underside of the beam over it, else to the ceiling
+ * plane, and the ghost shows that height before the click. Repeats as the column tool does.
+ */
+export function FramingPostTool({ choices }) {
+    const levelId = useViewer((state) => state.selection.levelId);
+    const cursorRef = useRef(null);
+    const [ghost, setGhost] = useState(null);
+    useEffect(() => {
+        if (!levelId)
+            return;
+        let last = null;
+        setGhost(null);
+        const place = (raw, free) => {
+            const nodes = useScene.getState().nodes;
+            const { point, snap } = snapPostPoint({ point: raw, nodes, levelId, free });
+            if (snap)
+                useWallSnapIndicator.getState().set({ x: point[0], z: point[1], kind: snap });
+            else
+                useWallSnapIndicator.getState().clear();
+            return {
+                point,
+                ...framingPostAt({ nodes, levelId, point, choices, foot: electedPostFoot(nodes, levelId) }),
+            };
+        };
+        const show = (placed) => {
+            const visual = getFloorStackPreviewPosition({
+                node: placed.post,
+                position: placed.post.position,
+                rotation: 0,
+                levelId,
+            });
+            cursorRef.current?.position.set(...visual);
+            usePlacementPreview.getState().set(placed.post);
+            setGhost(placed.post);
+        };
+        const onMove = (event) => {
+            const next = place([event.localPosition[0], event.localPosition[2]], event.nativeEvent?.altKey === true);
+            if (last &&
+                last.point[0] === next.point[0] &&
+                last.point[1] === next.point[1] &&
+                Math.abs(last.post.height - next.post.height) < 1e-6)
+                return;
+            if (!last || last.point[0] !== next.point[0] || last.point[1] !== next.point[1])
+                triggerSFX('sfx:grid-snap');
+            last = next;
+            show(next);
+        };
+        const onClick = (event) => {
+            // A click on a beam or a post is a node event, its point not the level's: use the move's.
+            const placed = last ??
+                place([event.localPosition[0], event.localPosition[2]], event.nativeEvent?.altKey === true);
+            stopPlacementCommitPropagation(event);
+            const nodes = useScene.getState().nodes;
+            const posts = Object.values(nodes).filter((node) => node.type === 'column' && node.role === 'post').length;
+            const post = ColumnNodeSchema.parse({
+                ...placed.post,
+                name: `Post ${posts + 1}`,
+                ...resolveSupportSlabPatch(placed.post, { ...nodes, [placed.post.id]: placed.post }),
+            });
+            useScene.getState().createNode(post, levelId);
+            triggerSFX('sfx:structure-build');
+            last = null;
+            if (useEditor.getState().getContinuation('point') === 'repeat')
+                return;
+            useViewer.getState().setSelection({ selectedIds: [post.id] });
+            usePlacementPreview.getState().clear();
+            useEditor.getState().setTool(null);
+            useEditor.getState().setMode('select');
+        };
+        emitter.on('grid:move', onMove);
+        const unsubscribeClicks = subscribeFloorPlacementClicks(onClick);
+        return () => {
+            emitter.off('grid:move', onMove);
+            unsubscribeClicks();
+            usePlacementPreview.getState().clear();
+            useWallSnapIndicator.getState().clear();
+        };
+    }, [levelId, choices]);
+    if (!levelId)
+        return null;
+    return (_jsx("group", { ref: cursorRef, visible: ghost !== null, children: ghost && _jsx(ColumnPreview, { node: ghost }) }));
+}

package/dist/column/preset-gallery.d.ts

@@ -0,0 +1,8 @@
+import { type ColumnNode } from '@pascal-app/core';
+export declare function ColumnPresetGallery({ node, onPreview, onCancel, onApply, }: {
+    node: ColumnNode;
+    onPreview: (patch: Partial<ColumnNode>) => void;
+    onCancel: () => void;
+    onApply: (patch: Partial<ColumnNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=preset-gallery.d.ts.map

package/dist/column/preset-gallery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preset-gallery.d.ts","sourceRoot":"","sources":["../../src/column/preset-gallery.tsx"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAIhB,MAAM,kBAAkB,CAAA;AAmCzB,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,OAAO,GACR,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IAC/C,QAAQ,EAAE,MAAM,IAAI,CAAA;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;CAC9C,+BA6HA"}