@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/beam/definition.edit.js

@@ -0,0 +1,133 @@
+import { beamPlan, beamTopElevation, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, FLOORPLAN_NODE_EXTENSION_KEY, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { beamToolOptions } from './draft-settings.js';
+import { buildBeamFloorplan } from './floorplan.js';
+import { beamEndpointAffordance } from './floorplan-affordances.js';
+import { beamFloorplanMoveTarget } from './floorplan-move.js';
+import { beamPanelModel } from './panel-model.js';
+import { beamParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.22;
+const INCH = 0.0254;
+/** Where a beam's top is in the live scene (a descriptor may run before the scene has a level). */
+function topOf(beam, sceneApi) {
+    return beamTopElevation(sceneApi?.nodes() ?? {}, beam);
+}
+function midFrame(beam) {
+    const plan = beamPlan(beam);
+    return {
+        mid: [(plan.start[0] + plan.end[0]) / 2, (plan.start[1] + plan.end[1]) / 2],
+        normal: plan.normal,
+    };
+}
+/** The beam's top, as the elevation guides read a structural datum. */
+function guideSource(beam) {
+    const { mid } = midFrame(beam);
+    return { nodeId: beam.id, levelId: beam.parentId, anchor: mid };
+}
+// Side arrows: a tap hands the beam to its move tool, either side of its middle at mid-depth.
+function beamSideMoveHandle(side) {
+    return {
+        kind: 'tap-action',
+        onActivate: (node, _scene, editor) => editor.engageMove(node),
+        placement: {
+            position: (n, sceneApi) => {
+                const { mid, normal } = midFrame(n);
+                const offset = (n.width / 2 + SIDE_HANDLE_OFFSET) * side;
+                return [
+                    mid[0] + normal[0] * offset,
+                    topOf(n, sceneApi) - n.depth / 2,
+                    mid[1] + normal[1] * offset,
+                ];
+            },
+            rotationY: (n) => {
+                const { normal } = midFrame(n);
+                return Math.atan2(-normal[1] * side, normal[0] * side);
+            },
+        },
+        cursor: 'ew-resize',
+    };
+}
+// End pickers: a dashed leader down the beam's depth and a disc at its end; a tap drags the end.
+function beamEndPicker(endpoint) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.depth,
+        onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
+        placement: {
+            position: (n, sceneApi) => {
+                const point = n[endpoint];
+                return [point[0], topOf(n, sceneApi) - n.depth, point[1]];
+            },
+        },
+    };
+}
+/**
+ * The beam's top, dragged up and down: it stores the top it lands on, caught by the levels'
+ * structural heights (a ceiling plane, a slab top) and otherwise to the half inch (the centimetre
+ * on a metric plan).
+ */
+function beamTopHandle(current) {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        shape: 'tracker',
+        currentValue: () => current,
+        magneticSnap: (n, value, sceneApi) => {
+            const snapped = resolveStructuralElevationSnap(guideSource(n), value, sceneApi.nodes());
+            if (snapped !== value)
+                return snapped;
+            const step = useViewer.getState().unit === 'imperial' ? INCH / 2 : 0.01;
+            return Math.round(value / step) * step;
+        },
+        onDrag: (n, sceneApi) => publishStructuralElevationGuide(guideSource(n), topOf(n, sceneApi), sceneApi.nodes()),
+        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
+        apply: (_n, top) => ({ topElevation: top }),
+        placement: {
+            position: (n, sceneApi) => {
+                const { mid } = midFrame(n);
+                return [mid[0], topOf(n, sceneApi), mid[1]];
+            },
+        },
+    };
+}
+const beamHandles = (node, sceneApi) => [
+    beamSideMoveHandle(1),
+    beamSideMoveHandle(-1),
+    beamEndPicker('start'),
+    beamEndPicker('end'),
+    beamTopHandle(topOf(node, sceneApi)),
+];
+export const beamEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+            // In 2D-only view the 3D tool never mounts: the plan drafts beams itself.
+            tool: () => import('./tool.js').then((module) => ({ default: module.BeamFloorplanTool })),
+            // A beam crosses rooms: a plan click on it picks the beam, not the room.
+            planHitSelectsNode: true,
+        },
+        [PANEL_MODEL_EXTENSION]: beamPanelModel,
+    },
+    parametrics: beamParametrics,
+    handles: beamHandles,
+    tool: () => import('./tool.js'),
+    toolOptions: beamToolOptions,
+    toolHints: [
+        { key: 'Left click', label: 'Set beam start / end; the next beam starts there' },
+        { key: 'Alt', label: 'Free place' },
+        { key: 'Esc', label: 'End the run' },
+    ],
+    floorplan: buildBeamFloorplan,
+    floorplanMoveTarget: beamFloorplanMoveTarget,
+    floorplanAffordances: {
+        'move-endpoint': beamEndpointAffordance,
+    },
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+        'move-endpoint': () => import('./move-endpoint-tool.js'),
+    },
+};

package/dist/beam/definition.js

@@ -0,0 +1,4 @@
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { beamEditContribution } from './definition.edit.js';
+import { beamRenderDefinition } from './definition.render.js';
+export const beamDefinition = composeNodeDefinition(beamRenderDefinition, beamEditContribution);

package/dist/beam/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { BeamNode } from './schema.js';
+export declare const beamRenderDefinition: NodeRenderDefinition<typeof BeamNode> & {
+    kind: 'beam';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/beam/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/beam/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA+BxF,CAAA"}

package/dist/beam/definition.render.js

@@ -0,0 +1,32 @@
+import { BeamNode } from './schema.js';
+export const beamRenderDefinition = {
+    kind: 'beam',
+    schemaVersion: 1,
+    schema: BeamNode,
+    category: 'structure',
+    defaults: () => {
+        const { id: _id, type: _type, ...rest } = BeamNode.parse({ start: [0, 0], end: [3, 0] });
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: { hosting: false },
+        duplicable: true,
+        deletable: true,
+        drawTool: true,
+    },
+    // The renderer reads the scene and live overrides itself; nothing consumes a dirty mark.
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: { kind: 'parametric', module: () => import('./renderer.js') },
+    presentation: {
+        label: 'Beam',
+        description: 'A framing beam drawn end to end: a porch header, a deck beam, a girder.',
+        icon: { kind: 'url', src: '/icons/beam.svg' },
+        paletteSection: 'structure',
+        paletteOrder: 72,
+    },
+    mcp: {
+        description: 'A horizontal framing beam: start/end centreline (level-local), actual width/depth, nominal size and plies, material, dropped or flush placement, and a top elevation (absent = under the ceiling plane).',
+    },
+};

package/dist/beam/draft-settings.d.ts

@@ -0,0 +1,17 @@
+import { type BeamMaterial, type BeamTopReference, type ToolOption } from '@pascal-app/core';
+/** What the beam tool draws with: its size, material and where its top goes. */
+export type BeamDraftChoices = {
+    preset: string;
+    material: BeamMaterial;
+    top: BeamTopReference;
+};
+/**
+ * The beam tool's choices, kept apart from the editor's tool defaults: a host clears those when it
+ * arms a tool from its tile, which would forget the size just picked.
+ */
+export declare const useBeamDraft: import("zustand").UseBoundStore<import("zustand").StoreApi<BeamDraftChoices & {
+    set: (patch: Partial<BeamDraftChoices>) => void;
+}>>;
+/** The Beam tool's rows in the Build panel: material, size, top. */
+export declare const beamToolOptions: readonly ToolOption[];
+//# sourceMappingURL=draft-settings.d.ts.map

package/dist/beam/draft-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft-settings.d.ts","sourceRoot":"","sources":["../../src/beam/draft-settings.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EAGrB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,gFAAgF;AAChF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,YAAY,CAAA;IACtB,GAAG,EAAE,gBAAgB,CAAA;CACtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY;SACG,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI;GAMnE,CAAA;AAsFH,oEAAoE;AACpE,eAAO,MAAM,eAAe,EAAE,SAAS,UAAU,EAAgD,CAAA"}

package/dist/beam/draft-settings.js

@@ -0,0 +1,81 @@
+import { BEAM_MATERIAL_LABELS, BEAM_SIZE_PRESETS, BEAM_TOP_REFERENCE_LABELS, BEAM_TOP_REFERENCES, beamSizePreset, DEFAULT_BEAM_SIZE_PRESET_ID, } from '@pascal-app/core';
+import { create } from 'zustand';
+/**
+ * The beam tool's choices, kept apart from the editor's tool defaults: a host clears those when it
+ * arms a tool from its tile, which would forget the size just picked.
+ */
+export const useBeamDraft = create((set) => ({
+    preset: DEFAULT_BEAM_SIZE_PRESET_ID,
+    material: 'sawn',
+    top: 'ceiling-dropped',
+    set: (patch) => set(patch),
+}));
+const familyOf = (material) => material === 'pressure-treated' ? 'sawn' : material;
+/** The size a family starts at when its material is picked. */
+const FAMILY_SIZE = {
+    sawn: DEFAULT_BEAM_SIZE_PRESET_ID,
+    lvl: '(2)lvl-1-3/4x11-7/8',
+    glulam: 'glulam-5-1/8x12',
+    steel: 'W8x10',
+};
+const MATERIAL_DESCRIPTIONS = {
+    sawn: 'A solid timber or 2x plies nailed up, inside where it stays dry',
+    'pressure-treated': 'Treated sawn lumber, for a porch, a deck or anything in the weather',
+    lvl: 'Laminated veneer lumber: a stiff beam for a long span inside',
+    glulam: 'Glued-laminated timber: long spans, often left exposed',
+    steel: 'A steel W shape, for the longest spans',
+};
+const TOP_DESCRIPTIONS = {
+    'ceiling-dropped': 'Hangs under the ceiling plane, the top of the walls: the joists or rafters bear on it',
+    'ceiling-flush': 'In the ceiling framing, its underside on the ceiling plane: the joists hang from its sides',
+    'floor-flush': 'Its top flush with the floor over it, in the floor framing',
+    'floor-under': "Under the floor's framing: a girder in a crawl space, or a deck's beam under its joists",
+};
+const subscribe = (onChange) => useBeamDraft.subscribe(() => onChange());
+/** The material row: picking another family brings its usual size along. */
+const materialOption = {
+    id: 'beam-material',
+    label: 'Material',
+    choices: Object.keys(BEAM_MATERIAL_LABELS).map((material) => ({
+        value: material,
+        label: BEAM_MATERIAL_LABELS[material],
+        description: MATERIAL_DESCRIPTIONS[material],
+    })),
+    subscribe,
+    value: () => useBeamDraft.getState().material,
+    set: (value) => {
+        const material = value;
+        const preset = beamSizePreset(useBeamDraft.getState().preset);
+        const keeps = preset && familyOf(preset.material) === familyOf(material);
+        useBeamDraft
+            .getState()
+            .set({ material, ...(keeps ? {} : { preset: FAMILY_SIZE[familyOf(material)] }) });
+    },
+};
+/** One Size row per family, shown while its material is the one picked. */
+const sizeOptions = ['sawn', 'lvl', 'glulam', 'steel'].map((family) => ({
+    id: `beam-size-${family}`,
+    label: 'Size',
+    choices: BEAM_SIZE_PRESETS.filter((preset) => familyOf(preset.material) === family).map((preset) => ({ value: preset.id, label: preset.label.replace(/ (LVL|GLB)$/, '') })),
+    subscribe,
+    value: () => useBeamDraft.getState().preset,
+    set: (value) => useBeamDraft.getState().set({ preset: value }),
+    visible: {
+        subscribe,
+        value: () => familyOf(useBeamDraft.getState().material) === family,
+    },
+}));
+const topOption = {
+    id: 'beam-top',
+    label: 'Top',
+    choices: BEAM_TOP_REFERENCES.map((top) => ({
+        value: top,
+        label: BEAM_TOP_REFERENCE_LABELS[top],
+        description: TOP_DESCRIPTIONS[top],
+    })),
+    subscribe,
+    value: () => useBeamDraft.getState().top,
+    set: (value) => useBeamDraft.getState().set({ top: value }),
+};
+/** The Beam tool's rows in the Build panel: material, size, top. */
+export const beamToolOptions = [materialOption, ...sizeOptions, topOption];

package/dist/beam/drafting.d.ts

@@ -0,0 +1,35 @@
+import { type AnyNode, type AnyNodeId, BeamNode, type WallNode } from '@pascal-app/core';
+import { type WallDraftSnapKind, type WallPlanPoint } from '@pascal-app/editor';
+import { type BeamDraftChoices } from './draft-settings.js';
+type Nodes = Readonly<Record<AnyNodeId, AnyNode>>;
+/**
+ * What a beam drawn on `levelId` snaps to, through the wall snap (`snapWallDraftPoint`): the
+ * level's wall centrelines and both faces of each straight wall (so a beam end lands on a wall's
+ * face or its corner), other beams' centrelines (their ends, middles and runs), and every post
+ * and column centre (a segment of no length). Kept per scene, so a pointer move asks once.
+ */
+export declare function beamSnapTargets(nodes: Nodes, levelId: string, ignoreIds?: readonly string[]): WallNode[];
+/** A snapped plan point and what caught it (null: the grid, an angle step, or nothing). */
+export type BeamPlanSnap = {
+    point: WallPlanPoint;
+    snap: WallDraftSnapKind | null;
+};
+/**
+ * A beam point snapped as the beam tool snaps: wall and beam ends, faces, middles and crossings,
+ * post centres, the grid, and from `start` the angle steps. `free` (Alt) places it as it is.
+ */
+export declare function snapBeamPoint(args: {
+    point: WallPlanPoint;
+    nodes: Nodes;
+    levelId: string;
+    start?: WallPlanPoint | null;
+    ignoreIds?: readonly string[];
+    free?: boolean;
+}): BeamPlanSnap;
+/**
+ * The beam a draft makes from `start` to `end` on `levelId` with the tool's choices, its top set
+ * from the chosen reference; `seed` (a preset the host armed the tool with) overrides them.
+ */
+export declare function draftBeam(start: WallPlanPoint, end: WallPlanPoint, levelId: string, nodes: Nodes, choices?: BeamDraftChoices, seed?: Readonly<Record<string, unknown>> | null, fields?: Partial<BeamNode>): BeamNode;
+export {};
+//# sourceMappingURL=drafting.d.ts.map

package/dist/beam/drafting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drafting.d.ts","sourceRoot":"","sources":["../../src/beam/drafting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,QAAQ,EAIR,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAML,KAAK,iBAAiB,EACtB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,kBAAkB,CAAA;AAEtE,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;AA0BjD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,SAAS,MAAM,EAAO,GAChC,QAAQ,EAAE,CAmCZ;AAED,2FAA2F;AAC3F,MAAM,MAAM,YAAY,GAAG;IAAE,KAAK,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAAE,CAAA;AAEnF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,KAAK,EAAE,aAAa,CAAA;IACpB,KAAK,EAAE,KAAK,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,aAAa,GAAG,IAAI,CAAA;IAC5B,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC7B,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,GAAG,YAAY,CAaf;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,KAAK,EACZ,OAAO,GAAE,gBAA0C,EACnD,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,EAC/C,MAAM,GAAE,OAAO,CAAC,QAAQ,CAAM,GAC7B,QAAQ,CAmBV"}

package/dist/beam/drafting.js

@@ -0,0 +1,103 @@
+import { BeamNode, beamTopReferencePatch, createBeam, getWallFaceLine, } from '@pascal-app/core';
+import { getSegmentGridStep, isAngleSnapActive, isMagneticSnapActive, snapBuildingLocalToWorldGrid, snapWallDraftPointDetailed, } from '@pascal-app/editor';
+import { useBeamDraft } from './draft-settings.js';
+/** A segment as the wall snap reads a wall: its ends, its middle and its body catch a point. */
+function reference(id, parentId, start, end) {
+    return {
+        object: 'node',
+        id: id,
+        type: 'wall',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        start,
+        end,
+        frontSide: 'unknown',
+        backSide: 'unknown',
+    };
+}
+const targetsMemo = new WeakMap();
+/**
+ * What a beam drawn on `levelId` snaps to, through the wall snap (`snapWallDraftPoint`): the
+ * level's wall centrelines and both faces of each straight wall (so a beam end lands on a wall's
+ * face or its corner), other beams' centrelines (their ends, middles and runs), and every post
+ * and column centre (a segment of no length). Kept per scene, so a pointer move asks once.
+ */
+export function beamSnapTargets(nodes, levelId, ignoreIds = []) {
+    const key = `${levelId}|${ignoreIds.join(',')}`;
+    let byKey = targetsMemo.get(nodes);
+    if (!byKey) {
+        byKey = new Map();
+        targetsMemo.set(nodes, byKey);
+    }
+    const cached = byKey.get(key);
+    if (cached)
+        return cached;
+    const targets = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== levelId || node.visible === false || ignoreIds.includes(node.id))
+            continue;
+        if (node.type === 'wall') {
+            targets.push(node);
+            if (Math.abs(node.curveOffset ?? 0) > 1e-6)
+                continue;
+            for (const face of ['a', 'b']) {
+                const line = getWallFaceLine(node, face);
+                targets.push(reference(`${node.id}:${face}`, node.parentId, [line.start.x, line.start.y], [line.end.x, line.end.y]));
+            }
+        }
+        else if (node.type === 'beam') {
+            targets.push(reference(node.id, node.parentId, node.start, node.end));
+        }
+        else if (node.type === 'column') {
+            const centre = [node.position[0], node.position[2]];
+            targets.push(reference(node.id, node.parentId, centre, centre));
+        }
+    }
+    byKey.set(key, targets);
+    return targets;
+}
+/**
+ * A beam point snapped as the beam tool snaps: wall and beam ends, faces, middles and crossings,
+ * post centres, the grid, and from `start` the angle steps. `free` (Alt) places it as it is.
+ */
+export function snapBeamPoint(args) {
+    if (args.free)
+        return { point: args.point, snap: null };
+    const step = getSegmentGridStep();
+    const angleSnap = !!args.start && isAngleSnapActive();
+    const result = snapWallDraftPointDetailed({
+        point: args.point,
+        walls: beamSnapTargets(args.nodes, args.levelId, args.ignoreIds),
+        start: args.start ?? undefined,
+        angleSnap,
+        magnetic: isMagneticSnapActive(),
+        gridSnap: (point) => snapBuildingLocalToWorldGrid(point, step),
+    });
+    return { point: result.point, snap: result.snap };
+}
+/**
+ * The beam a draft makes from `start` to `end` on `levelId` with the tool's choices, its top set
+ * from the chosen reference; `seed` (a preset the host armed the tool with) overrides them.
+ */
+export function draftBeam(start, end, levelId, nodes, choices = useBeamDraft.getState(), seed, fields = {}) {
+    const base = createBeam({
+        start,
+        end,
+        preset: choices.preset,
+        material: choices.material,
+        levelId,
+    });
+    const placed = { ...base, ...beamTopReferencePatch(nodes, base, choices.top) };
+    return BeamNode.parse({
+        ...placed,
+        ...(seed ?? {}),
+        ...fields,
+        id: base.id,
+        type: 'beam',
+        start,
+        end,
+        parentId: levelId,
+    });
+}

package/dist/beam/floorplan-affordances.d.ts

@@ -0,0 +1,8 @@
+import { type BeamNode, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * A beam's end, dragged in the plan: snapped as the beam tool snaps, angle-stepped off the other
+ * end. Previews through live overrides, writes the last end on release, and refuses an end that
+ * would leave the beam too short to draw.
+ */
+export declare const beamEndpointAffordance: FloorplanAffordance<BeamNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/beam/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAKzB;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,QAAQ,CA8BhE,CAAA"}

package/dist/beam/floorplan-affordances.js

@@ -0,0 +1,40 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isSegmentLongEnough } from '@pascal-app/editor';
+import { snapBeamPoint } from './drafting.js';
+/**
+ * A beam's end, dragged in the plan: snapped as the beam tool snaps, angle-stepped off the other
+ * end. Previews through live overrides, writes the last end on release, and refuses an end that
+ * would leave the beam too short to draw.
+ */
+export const beamEndpointAffordance = {
+    start({ node, payload, nodes }) {
+        const { endpoint } = payload;
+        const id = node.id;
+        const fixed = endpoint === 'start' ? node.end : node.start;
+        let last = null;
+        return {
+            affectedIds: [id],
+            apply({ planPoint, modifiers }) {
+                last = node.parentId
+                    ? snapBeamPoint({
+                        point: [planPoint[0], planPoint[1]],
+                        nodes,
+                        levelId: node.parentId,
+                        start: fixed,
+                        ignoreIds: [node.id],
+                        free: modifiers.altKey,
+                    }).point
+                    : [planPoint[0], planPoint[1]];
+                useLiveNodeOverrides.getState().set(id, { [endpoint]: last });
+            },
+            canCommit() {
+                return last !== null && isSegmentLongEnough(fixed, last);
+            },
+            commit() {
+                if (last)
+                    useScene.getState().updateNodes([{ id, data: { [endpoint]: last } }]);
+                useLiveNodeOverrides.getState().clear(id);
+            },
+        };
+    },
+};

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

@@ -0,0 +1,11 @@
+import { type BeamNode, type FloorplanMoveTarget } from '@pascal-app/core';
+import { type WallPlanPoint } from '@pascal-app/editor';
+/** A beam translated by `delta`, both ends together. */
+export declare function movedBeamEnds(beam: Pick<BeamNode, 'start' | 'end'>, delta: WallPlanPoint): Pick<BeamNode, 'start' | 'end'>;
+/**
+ * A beam moved in the plan: its start follows the pointer and snaps as the beam tool snaps (wall
+ * faces and ends, other beams, post centres, the grid); its end travels with it. Previews through
+ * live overrides, writes once on release.
+ */
+export declare const beamFloorplanMoveTarget: FloorplanMoveTarget<BeamNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAInE,wDAAwD;AACxD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,EACrC,KAAK,EAAE,aAAa,GACnB,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAC,CAKjC;AAED;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAqCjE,CAAA"}

package/dist/beam/floorplan-move.js

@@ -0,0 +1,54 @@
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { snapBeamPoint } from './drafting.js';
+/** A beam translated by `delta`, both ends together. */
+export function movedBeamEnds(beam, delta) {
+    return {
+        start: [beam.start[0] + delta[0], beam.start[1] + delta[1]],
+        end: [beam.end[0] + delta[0], beam.end[1] + delta[1]],
+    };
+}
+/**
+ * A beam moved in the plan: its start follows the pointer and snaps as the beam tool snaps (wall
+ * faces and ends, other beams, post centres, the grid); its end travels with it. Previews through
+ * live overrides, writes once on release.
+ */
+export const beamFloorplanMoveTarget = ({ node, nodes }) => {
+    const id = node.id;
+    const origin = [node.start[0], node.start[1]];
+    let anchor = null;
+    let delta = [0, 0];
+    return {
+        affectedIds: [id],
+        apply({ planPoint, modifiers }) {
+            if (!anchor) {
+                anchor = [planPoint[0], planPoint[1]];
+                return;
+            }
+            const at = node.parentId
+                ? snapBeamPoint({
+                    point: [origin[0] + planPoint[0] - anchor[0], origin[1] + planPoint[1] - anchor[1]],
+                    nodes,
+                    levelId: node.parentId,
+                    ignoreIds: [node.id],
+                    free: modifiers.altKey,
+                }).point
+                : origin;
+            const next = [at[0] - origin[0], at[1] - origin[1]];
+            if (next[0] === delta[0] && next[1] === delta[1])
+                return;
+            delta = next;
+            triggerSFX('sfx:grid-snap');
+            useLiveNodeOverrides.getState().set(id, movedBeamEnds(node, delta));
+        },
+        canCommit() {
+            return delta[0] !== 0 || delta[1] !== 0;
+        },
+        commit() {
+            useScene.getState().updateNodes([{ id, data: movedBeamEnds(node, delta) }]);
+            useLiveNodeOverrides.getState().clear(id);
+            useViewer.getState().setSelection({ selectedIds: [id] });
+        },
+    };
+};

package/dist/beam/floorplan.d.ts

@@ -0,0 +1,11 @@
+import { type BeamNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+export type BeamEndpointPayload = {
+    endpoint: 'start' | 'end';
+};
+/**
+ * A beam in the plan, the way a framing plan draws one: its width as a dashed double outline and
+ * its size beside it ("6x8", "(2) 2x10"), over a clear hit area. Selected, it gets its end handles,
+ * a move arrow either side and its length.
+ */
+export declare function buildBeamFloorplan(node: BeamNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/beam/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,mBAAmB,GAAG;IAAE,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAAE,CAAA;AAE/D;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoFjG"}

package/dist/beam/floorplan.js

@@ -0,0 +1,91 @@
+import { beamOutline, beamPlan, beamSizeLabel, formatLinearMeasurement, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
+/** Hidden work: a beam is over the plan's cut, so it is drawn dashed, as a framing plan draws it. */
+const HIDDEN_DASH = '8 4';
+const MOVE_ARROW_OFFSET = 0.17;
+/** Screen pixels between the beam's line and its size label (and, selected, its length). */
+const LABEL_OFFSET_PX = 11;
+/**
+ * A beam in the plan, the way a framing plan draws one: its width as a dashed double outline and
+ * its size beside it ("6x8", "(2) 2x10"), over a clear hit area. Selected, it gets its end handles,
+ * a move arrow either side and its length.
+ */
+export function buildBeamFloorplan(node, ctx) {
+    const plan = beamPlan(node);
+    if (plan.length < 1e-6)
+        return null;
+    const view = ctx.viewState;
+    const selected = view?.selected ?? false;
+    const chrome = selected || (view?.highlighted ?? false);
+    const stroke = chrome && view?.palette
+        ? view.palette.selectedStroke
+        : view?.hovered && view.palette
+            ? view.palette.wallHoverStroke
+            : '#374151';
+    const mid = [
+        (plan.start[0] + plan.end[0]) / 2,
+        (plan.start[1] + plan.end[1]) / 2,
+    ];
+    const angle = Math.atan2(plan.direction[1], plan.direction[0]);
+    const children = [
+        {
+            kind: 'polygon',
+            points: beamOutline(node),
+            fill: chrome ? '#fed7aa' : 'transparent',
+            fillOpacity: chrome ? 0.35 : undefined,
+            stroke,
+            strokeWidth: chrome ? 1.75 : 1.25,
+            strokeDasharray: HIDDEN_DASH,
+            vectorEffect: 'non-scaling-stroke',
+            // A room's name and area move off a beam rather than hide it.
+            metadata: floorplanGeometryMetadata({ annotationObstacle: 'outline' }),
+        },
+        // A beam is a few inches wide: a click near its line picks it at any zoom.
+        {
+            kind: 'hit-line',
+            x1: plan.start[0],
+            y1: plan.start[1],
+            x2: plan.end[0],
+            y2: plan.end[1],
+            strokeWidthPx: 12,
+        },
+        {
+            kind: 'dimension-label',
+            cx: mid[0],
+            cy: mid[1],
+            text: beamSizeLabel(node),
+            angle,
+            offsetPx: LABEL_OFFSET_PX,
+            appearance: 'outlined',
+        },
+    ];
+    if (selected) {
+        for (const endpoint of ['start', 'end'])
+            children.push({
+                kind: 'endpoint-handle',
+                point: plan[endpoint],
+                state: 'idle',
+                affordance: 'move-endpoint',
+                payload: { endpoint },
+            });
+        for (const side of [1, -1]) {
+            // No affordance: the layer hands the beam to `floorplanMoveTarget`.
+            const offset = (plan.width / 2 + MOVE_ARROW_OFFSET) * side;
+            children.push({
+                kind: 'move-arrow',
+                point: [mid[0] + plan.normal[0] * offset, mid[1] + plan.normal[1] * offset],
+                angle: Math.atan2(plan.normal[1] * side, plan.normal[0] * side),
+            });
+        }
+        if (plan.length >= 0.1)
+            children.push({
+                kind: 'dimension-label',
+                cx: mid[0],
+                cy: mid[1],
+                text: formatLinearMeasurement(plan.length, view?.unit ?? 'metric', readFloorplanMetricNotationOverride(ctx) ?? 'meters'),
+                angle,
+                offsetPx: -LABEL_OFFSET_PX - 4,
+            });
+    }
+    return { kind: 'group', children };
+}