@pascal-app/nodes 0.1.1 → 1.0.0-beta.2

package/dist/column/tool.js

@@ -1,10 +1,11 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { COLUMN_PRESETS, ColumnNode, collectAlignmentAnchors, emitter, useScene, } from '@pascal-app/core';
+import { COLUMN_PRESETS, ColumnNode, collectAlignmentAnchors, emitter, resolveSupportSlabPatch, useScene, } from '@pascal-app/core';
 import { getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, stopPlacementCommitPropagation, subscribeFloorPlacementClicks, } from '../shared/floor-placement';
+import { collectStructuralGridAxes, resolveStructuralGridSnap, } from '../structural-grid/coordination';
 import { ColumnPreview } from './renderer';
 const DEFAULT_COLUMN_PRESET_ID = 'basicPillar';
 function createColumnFromPreset(presetId, position) {
@@ -53,7 +54,7 @@ const ColumnTool = () => {
                 cursorVisibleRef.current = true;
                 setCursorVisible(true);
             }
-            const { position, guides } = resolveAlignedFloorPlacement({
+            const { position: alignedPosition, guides } = resolveAlignedFloorPlacement({
                 node: previewNode,
                 rawX: event.localPosition[0],
                 rawZ: event.localPosition[2],
@@ -63,7 +64,16 @@ const ColumnTool = () => {
                 applyAlignmentSnap: isMagneticSnapActive(),
                 bypassGrid: !isGridSnapActive(),
             });
-            useAlignmentGuides.getState().set(guides);
+            const structuralSnap = isGridSnapActive() || isMagneticSnapActive()
+                ? resolveStructuralGridSnap([alignedPosition[0], alignedPosition[2]], collectStructuralGridAxes(useScene.getState().nodes, activeLevelId))
+                : null;
+            const position = structuralSnap
+                ? [structuralSnap.point[0], alignedPosition[1], structuralSnap.point[1]]
+                : alignedPosition;
+            if (structuralSnap)
+                useAlignmentGuides.getState().clear();
+            else
+                useAlignmentGuides.getState().set(guides);
             const visualPosition = getFloorStackPreviewPosition({
                 node: previewNode,
                 position,
@@ -96,11 +106,24 @@ const ColumnTool = () => {
             }
         };
         const commitAtCursor = (event) => {
-            const position = lastCursorRef.current ??
+            const fallbackPosition = lastCursorRef.current ??
                 getLevelLocalSnappedPosition(activeLevelId, event, useEditor.getState().gridSnapStep, !isGridSnapActive());
-            const column = createColumnFromPreset(DEFAULT_COLUMN_PRESET_ID, position);
-            useScene.getState().createNode(column, activeLevelId);
-            useViewer.getState().setSelection({ selectedIds: [column.id] });
+            const structuralSnap = isGridSnapActive() || isMagneticSnapActive()
+                ? resolveStructuralGridSnap([fallbackPosition[0], fallbackPosition[2]], collectStructuralGridAxes(useScene.getState().nodes, activeLevelId))
+                : null;
+            const position = structuralSnap
+                ? [structuralSnap.point[0], fallbackPosition[1], structuralSnap.point[1]]
+                : fallbackPosition;
+            const column = ColumnNode.parse({
+                ...createColumnFromPreset(DEFAULT_COLUMN_PRESET_ID, position),
+                parentId: activeLevelId,
+            });
+            const committedColumn = ColumnNode.parse({
+                ...column,
+                ...resolveSupportSlabPatch(column, useScene.getState().nodes),
+            });
+            useScene.getState().createNode(committedColumn, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [committedColumn.id] });
             triggerSFX('sfx:structure-build');
             useAlignmentGuides.getState().clear();
             usePlacementPreview.getState().clear();
@@ -112,7 +135,10 @@ const ColumnTool = () => {
                 cursorVisibleRef.current = false;
                 setCursorVisible(false);
                 useFacingPose.getState().clear();
+                // Restore select mode with the tool — `mode: 'build'` with no tool is
+                // a dead state where the selection manager ignores every click.
                 useEditor.getState().setTool(null);
+                useEditor.getState().setMode('select');
             }
             stopPlacementCommitPropagation(event);
         };

package/dist/construction-dimension/definition.d.ts

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

package/dist/construction-dimension/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASzF,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAA;AAEpD,eAAO,MAAM,+BAA+B,EAAE,cAAc,CAAC,OAAO,yBAAyB,CAgF5F,CAAA"}

package/dist/construction-dimension/definition.js

@@ -0,0 +1,83 @@
+import { measurementAnchorReferenceNodeIds } from '@pascal-app/core';
+import { resolveConstructionDimensionForDrawing } from './drawing-coordination';
+import { buildConstructionDimensionFloorplan } from './floorplan';
+import { moveConstructionDimensionBaselineAffordance, moveConstructionDimensionWitnessAffordance, } from './floorplan-affordances';
+import { constructionDimensionParametrics } from './parametrics';
+import { ConstructionDimensionNode } from './schema';
+export const constructionDimensionDefinition = {
+    kind: 'construction-dimension',
+    bake: 'strip',
+    schemaVersion: 7,
+    schema: ConstructionDimensionNode,
+    category: 'analysis',
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool'),
+            availableModes: ['expert'],
+            resolveForDrawing: resolveConstructionDimensionForDrawing,
+        },
+    },
+    snapProfile: 'item',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        anchors: [
+            [0, 0, 0],
+            [1, 0, 0],
+        ],
+        baseline: { origin: [0, 0.6], direction: [1, 0] },
+        chainMode: 'point-to-point',
+        mode: 'linear',
+        featureCount: 1,
+        showCenterMark: true,
+        prefix: '',
+        suffix: '',
+        textOverride: null,
+        datumPolicy: 'centerline',
+        terminator: 'architectural-tick',
+        textPosition: 'above',
+        imperialPrecision: '1/16',
+        metricNotation: 'meters',
+        extensionStartGap: 0.075,
+        extensionOvershoot: 0.12,
+        drawingType: 'floor-plan',
+        drawingOverrides: [],
+        controllingDimensionId: null,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        duplicable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    parametrics: constructionDimensionParametrics,
+    floorplan: buildConstructionDimensionFloorplan,
+    floorplanDependencies: (node) => [
+        ...measurementAnchorReferenceNodeIds(node.anchors),
+        ...(node.controllingDimensionId ? [node.controllingDimensionId] : []),
+    ],
+    floorplanAffordances: {
+        'move-construction-dimension-baseline': moveConstructionDimensionBaselineAffordance,
+        'move-construction-dimension-witness': moveConstructionDimensionWitnessAffordance,
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Pick witness point' },
+        { key: 'Enter', label: 'Finish multi-point witnesses' },
+        { key: 'Left click', label: 'Place dimension line when needed' },
+        { key: 'Backspace', label: 'Remove last witness' },
+        { key: 'Esc', label: 'Step back or cancel' },
+    ],
+    presentation: {
+        label: 'Construction Dimension',
+        description: 'Associative linear, curved, circular, angular, or coordinate plan dimension.',
+        icon: { kind: 'iconify', name: 'lucide:ruler-dimension-line' },
+        hidden: true,
+        actionMenu: false,
+    },
+    mcp: {
+        description: 'An associative construction dimension with linear, curved, circular, angular, and coordinate modes, semantic witness anchors, document notation overrides, and coordinated plan-view presentation.',
+    },
+};

package/dist/construction-dimension/drawing-coordination.d.ts

@@ -0,0 +1,7 @@
+import { type AnyNode, type ConstructionDimensionNode, type ConstructionDrawingType } from '@pascal-app/core';
+export declare function resolveConstructionDimensionForDrawing(args: {
+    node: ConstructionDimensionNode;
+    nodes: Record<string, AnyNode>;
+    drawingType: ConstructionDrawingType;
+}): ConstructionDimensionNode | null;
+//# sourceMappingURL=drawing-coordination.d.ts.map

package/dist/construction-dimension/drawing-coordination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-coordination.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/drawing-coordination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAG7B,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,sCAAsC,CAAC,IAAI,EAAE;IAC3D,IAAI,EAAE,yBAAyB,CAAA;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,uBAAuB,CAAA;CACrC,GAAG,yBAAyB,GAAG,IAAI,CAoBnC"}

package/dist/construction-dimension/drawing-coordination.js

@@ -0,0 +1,54 @@
+import { resolveConstructionDimensionDrawingOverride, resolveConstructionDimensionDrawingPresentation, } from '@pascal-app/core';
+export function resolveConstructionDimensionForDrawing(args) {
+    const { node, nodes, drawingType } = args;
+    const presentation = resolveConstructionDimensionDrawingPresentation(node, drawingType);
+    if (presentation === 'omit')
+        return null;
+    if (presentation === 'shown')
+        return applyDrawingOverride(node, drawingType);
+    const controller = node.controllingDimensionId ? nodes[node.controllingDimensionId] : undefined;
+    if (controller?.type !== 'construction-dimension' ||
+        controller.id === node.id ||
+        controller.drawingType !== 'foundation-plan') {
+        return {
+            ...node,
+            metadata: lockedMetadata(node),
+            prefix: `UNLINKED CONTROL · ${node.prefix}`,
+        };
+    }
+    return resolveControlledDimension(node, controller);
+}
+function resolveControlledDimension(node, controller) {
+    const overridden = applyDrawingOverride(node, 'floor-plan');
+    return {
+        ...overridden,
+        metadata: lockedMetadata(overridden),
+        anchors: controller.anchors,
+        baseline: controller.baseline,
+        chainMode: controller.chainMode,
+        mode: controller.mode,
+        showCenterMark: controller.showCenterMark,
+    };
+}
+function applyDrawingOverride(node, drawingType) {
+    const override = resolveConstructionDimensionDrawingOverride(node, drawingType);
+    if (!override || override.suppressedSegmentIndexes.length === 0)
+        return node;
+    return {
+        ...node,
+        metadata: {
+            ...(typeof node.metadata === 'object' &&
+                node.metadata !== null &&
+                !Array.isArray(node.metadata)
+                ? node.metadata
+                : {}),
+            suppressedDimensionSegmentIndexes: override.suppressedSegmentIndexes,
+        },
+    };
+}
+function lockedMetadata(node) {
+    const metadata = typeof node.metadata === 'object' && node.metadata !== null && !Array.isArray(node.metadata)
+        ? node.metadata
+        : {};
+    return { ...metadata, drawingCoordinationLocked: true };
+}

package/dist/construction-dimension/floorplan-affordances.d.ts

@@ -0,0 +1,4 @@
+import { type ConstructionDimensionNode as ConstructionDimensionNodeType, type FloorplanAffordance } from '@pascal-app/core';
+export declare const moveConstructionDimensionWitnessAffordance: FloorplanAffordance<ConstructionDimensionNodeType>;
+export declare const moveConstructionDimensionBaselineAffordance: FloorplanAffordance<ConstructionDimensionNodeType>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/construction-dimension/floorplan-affordances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,yBAAyB,IAAI,6BAA6B,EAC/D,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAqDzB,eAAO,MAAM,0CAA0C,EAAE,mBAAmB,CAAC,6BAA6B,CAgEvG,CAAA;AAEH,eAAO,MAAM,2CAA2C,EAAE,mBAAmB,CAAC,6BAA6B,CAwBxG,CAAA"}

package/dist/construction-dimension/floorplan-affordances.js

@@ -0,0 +1,114 @@
+import { ConstructionDimensionNode, resolveLevelId, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isGridSnapActive, isMagneticSnapActive, resolveSurfacePlanPointSnap, useEditor, } from '@pascal-app/editor';
+import { matchMeasurementFeatureForNode, resolveMeasurementAnchor } from '../measurement/resolve';
+const SEMANTIC_FEATURE_SNAP_DISTANCE = 0.2;
+const SEMANTIC_FEATURE_BYPASS_DISTANCE = 0.012;
+function semanticWitnessAnchor(point, wallIds, nodes, maxDistance) {
+    const matches = wallIds.flatMap((id) => {
+        const node = nodes[id];
+        if (!node)
+            return [];
+        const match = matchMeasurementFeatureForNode(node, (nodeId) => nodes[nodeId], point, maxDistance);
+        return match ? [{ match, node }] : [];
+    });
+    const closest = matches.sort((a, b) => a.match.distance - b.match.distance)[0];
+    if (!closest)
+        return point;
+    return {
+        kind: 'feature',
+        reference: {
+            nodeId: closest.node.id,
+            featureId: closest.match.feature.id,
+            parameters: closest.match.parameters,
+        },
+        fallback: closest.match.point,
+    };
+}
+function withRefreshedFallbacks(node, nodes) {
+    return node.anchors.map((anchor) => {
+        if (Array.isArray(anchor))
+            return anchor;
+        const resolved = resolveMeasurementAnchor(anchor, (id) => nodes[id]);
+        return { ...anchor, fallback: resolved.point };
+    });
+}
+export const moveConstructionDimensionWitnessAffordance = {
+    start({ node, nodes, payload }) {
+        const witnessIndex = payload.witnessIndex;
+        const originalAnchors = withRefreshedFallbacks(node, nodes);
+        const levelId = resolveLevelId(node, nodes);
+        let latest = null;
+        if (!Number.isInteger(witnessIndex)) {
+            return {
+                affectedIds: [node.id],
+                apply() { },
+                canCommit: () => false,
+            };
+        }
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint, modifiers }) {
+                const forceFree = modifiers.altKey === true;
+                const gridStep = !forceFree && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+                const fallbackPoint = gridStep > 0
+                    ? [
+                        Math.round(planPoint[0] / gridStep) * gridStep,
+                        Math.round(planPoint[1] / gridStep) * gridStep,
+                    ]
+                    : [planPoint[0], planPoint[1]];
+                const magnetic = !forceFree && isMagneticSnapActive();
+                const snapped = resolveSurfacePlanPointSnap({
+                    rawPoint: [planPoint[0], planPoint[1]],
+                    fallbackPoint,
+                    excludeId: node.id,
+                    levelId,
+                    movingId: node.id,
+                    nodes,
+                    magnetic,
+                });
+                const point = [snapped.point[0], 0, snapped.point[1]];
+                const nextAnchor = semanticWitnessAnchor(point, snapped.wallIds, nodes, magnetic ? SEMANTIC_FEATURE_SNAP_DISTANCE : SEMANTIC_FEATURE_BYPASS_DISTANCE);
+                const anchors = originalAnchors.map((anchor, index) => index === witnessIndex ? nextAnchor : anchor);
+                if (!ConstructionDimensionNode.safeParse({ ...node, anchors }).success) {
+                    latest = null;
+                    useLiveNodeOverrides.getState().clear(node.id);
+                    return;
+                }
+                latest = anchors;
+                useLiveNodeOverrides.getState().set(node.id, { anchors });
+            },
+            canCommit: () => latest !== null,
+            commit() {
+                const anchors = latest;
+                useLiveNodeOverrides.getState().clear(node.id);
+                if (anchors)
+                    useScene.getState().updateNode(node.id, { anchors });
+            },
+        };
+    },
+};
+export const moveConstructionDimensionBaselineAffordance = {
+    start({ node }) {
+        let latest = null;
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint }) {
+                const origin = [planPoint[0], planPoint[1]];
+                const baseline = { ...node.baseline, origin };
+                if (!ConstructionDimensionNode.safeParse({ ...node, baseline }).success)
+                    return;
+                latest = origin;
+                useLiveNodeOverrides.getState().set(node.id, { baseline });
+            },
+            canCommit: () => latest !== null,
+            commit() {
+                useLiveNodeOverrides.getState().clear(node.id);
+                if (latest) {
+                    useScene.getState().updateNode(node.id, {
+                        baseline: { ...node.baseline, origin: latest },
+                    });
+                }
+            },
+        };
+    },
+};

package/dist/construction-dimension/floorplan-tool.d.ts

@@ -0,0 +1,21 @@
+import { type AnyNode, type AnyNodeId, type ConstructionDimensionChainMode, type ConstructionDimensionMode, type FloorplanGeometry, type MeasurementAnchor, type MeasurementPoint, type WallNode } from '@pascal-app/core';
+import { type FloorplanToolContext } from '@pascal-app/editor';
+type Draft = {
+    anchors: MeasurementAnchor[];
+    points: MeasurementPoint[];
+    stage: 'witnesses' | 'baseline';
+};
+export declare function resolveConstructionDimensionDraftDirection(points: readonly MeasurementPoint[], anchors?: readonly MeasurementAnchor[], nodes?: Readonly<Record<AnyNodeId, AnyNode>>): [number, number] | null;
+export declare function buildConstructionDimensionPreviewGeometries(points: readonly MeasurementPoint[], baselinePoint: MeasurementPoint, unit: 'metric' | 'imperial', mode?: ConstructionDimensionMode, metricNotation?: 'meters' | 'millimeters', directionOverride?: readonly [number, number] | null): FloorplanGeometry[];
+export declare function normalizeConstructionDimensionChainMode(value: unknown): ConstructionDimensionChainMode;
+export declare function normalizeConstructionDimensionMode(value: unknown): ConstructionDimensionMode;
+export declare function constructionDimensionUsesBaseline(mode: ConstructionDimensionMode): boolean;
+export declare function shouldConsumeConstructionDimensionPointerEvent(event: {
+    type: string;
+    button: number;
+    buttons: number;
+}): boolean;
+export declare function buildCurvedWallConstructionDimensionDraft(wall: WallNode, mode: ConstructionDimensionMode): Pick<Draft, 'anchors' | 'points'> | null;
+export declare function FloorplanConstructionDimensionToolLayer({ activeLevelId, finishTool, gridSnapStep, metricNotation, sceneApi, selectNode, toolDefaults, unit, }: FloorplanToolContext): import("react").JSX.Element | null;
+export default FloorplanConstructionDimensionToolLayer;
+//# sourceMappingURL=floorplan-tool.d.ts.map

package/dist/construction-dimension/floorplan-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/floorplan-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,8BAA8B,EACnC,KAAK,yBAAyB,EAI9B,KAAK,iBAAiB,EAItB,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EAErB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,KAAK,oBAAoB,EAW1B,MAAM,oBAAoB,CAAA;AAY3B,KAAK,KAAK,GAAG;IACX,OAAO,EAAE,iBAAiB,EAAE,CAAA;IAC5B,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAC1B,KAAK,EAAE,WAAW,GAAG,UAAU,CAAA;CAChC,CAAA;AA2ED,wBAAgB,0CAA0C,CACxD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,CAAC,EAAE,SAAS,iBAAiB,EAAE,EACtC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC3C,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAUzB;AAED,wBAAgB,2CAA2C,CACzD,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,aAAa,EAAE,gBAAgB,EAC/B,IAAI,EAAE,QAAQ,GAAG,UAAU,EAC3B,IAAI,GAAE,yBAAoC,EAC1C,cAAc,GAAE,QAAQ,GAAG,aAAwB,EACnD,iBAAiB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,GACnD,iBAAiB,EAAE,CAqLrB;AAED,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,OAAO,GACb,8BAA8B,CAEhC;AAED,wBAAgB,kCAAkC,CAAC,KAAK,EAAE,OAAO,GAAG,yBAAyB,CAY5F;AAED,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,yBAAyB,GAAG,OAAO,CAE1F;AAED,wBAAgB,8CAA8C,CAAC,KAAK,EAAE;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAGV;AAcD,wBAAgB,yCAAyC,CACvD,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,yBAAyB,GAC9B,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC,GAAG,IAAI,CA6B1C;AAED,wBAAgB,uCAAuC,CAAC,EACtD,aAAa,EACb,UAAU,EACV,YAAY,EACZ,cAAc,EACd,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,IAAI,GACL,EAAE,oBAAoB,sCAqVtB;AAED,eAAe,uCAAuC,CAAA"}