@pascal-app/nodes 0.1.1

package/dist/measurement/edit.js

@@ -0,0 +1,97 @@
+import { measurementDistance, measurementNormal, } from '@pascal-app/core';
+export function measurementResolvedEditPoints(measurement) {
+    return measurement.kind === 'distance' || measurement.kind === 'angle'
+        ? measurement.points.map((point) => [...point])
+        : measurement.base.map((point) => [...point]);
+}
+function mapMeasurementAnchors(measurement, map) {
+    if (measurement.kind === 'distance') {
+        return {
+            ...measurement,
+            points: [map(measurement.points[0], 0), map(measurement.points[1], 1)],
+        };
+    }
+    if (measurement.kind === 'angle') {
+        return {
+            ...measurement,
+            points: [
+                map(measurement.points[0], 0),
+                map(measurement.points[1], 1),
+                map(measurement.points[2], 2),
+            ],
+        };
+    }
+    return {
+        ...measurement,
+        base: measurement.base.map(map),
+    };
+}
+export function refreshMeasurementAnchorFallbacks(measurement, resolved) {
+    const points = measurementResolvedEditPoints(resolved);
+    return mapMeasurementAnchors(measurement, (anchor, index) => {
+        if (Array.isArray(anchor))
+            return anchor;
+        const fallback = points[index];
+        return fallback ? { ...anchor, fallback: [...fallback] } : anchor;
+    });
+}
+export function replaceMeasurementAnchor(measurement, index, anchor) {
+    const count = measurement.kind === 'distance' || measurement.kind === 'angle'
+        ? measurement.points.length
+        : measurement.base.length;
+    if (!Number.isInteger(index) || index < 0 || index >= count)
+        return null;
+    return mapMeasurementAnchors(measurement, (current, currentIndex) => currentIndex === index ? anchor : current);
+}
+function isPolygonMeasurement(measurement) {
+    return (measurement.kind === 'area' || measurement.kind === 'perimeter' || measurement.kind === 'volume');
+}
+export function constrainMeasurementSpatialEditPoint(measurement, point) {
+    if (!isPolygonMeasurement(measurement))
+        return [...point];
+    const points = measurementResolvedEditPoints(measurement);
+    const origin = points[0];
+    const normal = measurementNormal(points);
+    if (!(origin && normal))
+        return [...point];
+    const distance = (point[0] - origin[0]) * normal[0] +
+        (point[1] - origin[1]) * normal[1] +
+        (point[2] - origin[2]) * normal[2];
+    return [
+        point[0] - normal[0] * distance,
+        point[1] - normal[1] * distance,
+        point[2] - normal[2] * distance,
+    ];
+}
+export function constrainMeasurementPlanEditPoint(measurement, index, planPoint) {
+    const points = measurementResolvedEditPoints(measurement);
+    const current = points[index];
+    if (!current)
+        return null;
+    if (!isPolygonMeasurement(measurement))
+        return [planPoint[0], current[1], planPoint[1]];
+    const origin = points[0];
+    const normal = measurementNormal(points);
+    if (!(origin && normal))
+        return [planPoint[0], current[1], planPoint[1]];
+    if (Math.abs(normal[1]) > 1e-6) {
+        const y = origin[1] -
+            (normal[0] * (planPoint[0] - origin[0]) + normal[2] * (planPoint[1] - origin[2])) / normal[1];
+        return [planPoint[0], y, planPoint[1]];
+    }
+    const normalLengthSq = normal[0] * normal[0] + normal[2] * normal[2];
+    if (normalLengthSq <= 1e-12)
+        return [planPoint[0], current[1], planPoint[1]];
+    const offset = (normal[0] * (planPoint[0] - origin[0]) + normal[2] * (planPoint[1] - origin[2])) /
+        normalLengthSq;
+    return [planPoint[0] - normal[0] * offset, current[1], planPoint[1] - normal[2] * offset];
+}
+export function measurementEditAnchor(measurement, point, associatedAnchor) {
+    const constrained = constrainMeasurementSpatialEditPoint(measurement, point);
+    if (associatedAnchor &&
+        !Array.isArray(associatedAnchor) &&
+        measurementDistance(constrained, point) <= 0.012) {
+        return { ...associatedAnchor, fallback: constrained };
+    }
+    return constrained;
+}

package/dist/measurement/floorplan-affordance.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanAffordance, type MeasurementNode as MeasurementNodeType } from '@pascal-app/core';
+export declare const measurementMoveVertexAffordance: FloorplanAffordance<MeasurementNodeType>;
+//# sourceMappingURL=floorplan-affordance.d.ts.map

package/dist/measurement/floorplan-affordance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordance.d.ts","sourceRoot":"","sources":["../../src/measurement/floorplan-affordance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,mBAAmB,EAIxB,KAAK,eAAe,IAAI,mBAAmB,EAK5C,MAAM,kBAAkB,CAAA;AAgDzB,eAAO,MAAM,+BAA+B,EAAE,mBAAmB,CAAC,mBAAmB,CAoEpF,CAAA"}

package/dist/measurement/floorplan-affordance.js

@@ -0,0 +1,90 @@
+import { MeasurementNode, resolveLevelId, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { resolveSurfacePlanPointSnap } from '@pascal-app/editor';
+import { constrainMeasurementPlanEditPoint, measurementEditAnchor, refreshMeasurementAnchorFallbacks, replaceMeasurementAnchor, } from './edit';
+import { matchMeasurementFeatureForNode, resolveMeasurementNode } from './resolve';
+const SEMANTIC_FEATURE_SNAP_DISTANCE = 0.2;
+// Alt-bypass association mirrors the 3D tool's surface-verify tolerance: a
+// feature binds only when the point already sits on it, never by attraction.
+const SEMANTIC_FEATURE_BYPASS_DISTANCE = 0.012;
+function semanticWallAnchor(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 {
+        anchor: {
+            kind: 'feature',
+            reference: {
+                nodeId: closest.node.id,
+                featureId: closest.match.feature.id,
+                parameters: closest.match.parameters,
+            },
+            fallback: closest.match.point,
+        },
+        point: closest.match.point,
+    };
+}
+export const measurementMoveVertexAffordance = {
+    start({ node, nodes, payload }) {
+        const vertexIndex = payload.vertexIndex;
+        const resolved = resolveMeasurementNode(node, (id) => nodes[id]);
+        const original = refreshMeasurementAnchorFallbacks(node.measurement, resolved.payload);
+        const levelId = resolveLevelId(node, nodes);
+        let latest = null;
+        if (!Number.isInteger(vertexIndex)) {
+            return {
+                affectedIds: [node.id],
+                apply() { },
+                canCommit: () => false,
+            };
+        }
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint, modifiers }) {
+                // Measurement anchors always bind to real geometry — the construction
+                // snapping-mode chip doesn't govern this analysis tool. Alt bypasses.
+                // The raw fallback keeps free drags free: measurement geometry follows
+                // the pointer, never the construction grid lattice.
+                const snapped = resolveSurfacePlanPointSnap({
+                    rawPoint: [planPoint[0], planPoint[1]],
+                    fallbackPoint: [planPoint[0], planPoint[1]],
+                    excludeId: node.id,
+                    levelId,
+                    movingId: node.id,
+                    nodes,
+                    magnetic: !modifiers.altKey,
+                });
+                const point = constrainMeasurementPlanEditPoint(resolved.payload, vertexIndex, snapped.point);
+                const associated = point
+                    ? semanticWallAnchor(point, snapped.wallIds, nodes, modifiers.altKey ? SEMANTIC_FEATURE_BYPASS_DISTANCE : SEMANTIC_FEATURE_SNAP_DISTANCE)
+                    : null;
+                const anchor = point && associated
+                    ? measurementEditAnchor(resolved.payload, associated.point, associated.anchor)
+                    : null;
+                const next = anchor
+                    ? replaceMeasurementAnchor(original, vertexIndex, anchor)
+                    : null;
+                if (!next || !MeasurementNode.safeParse({ ...node, measurement: next }).success) {
+                    latest = null;
+                    useLiveNodeOverrides.getState().clear(node.id);
+                    return;
+                }
+                latest = next;
+                useLiveNodeOverrides.getState().set(node.id, { measurement: next });
+            },
+            canCommit: () => latest !== null,
+            commit() {
+                const measurement = latest;
+                useLiveNodeOverrides.getState().clear(node.id);
+                if (measurement)
+                    useScene.getState().updateNode(node.id, { measurement });
+            },
+        };
+    },
+};

package/dist/measurement/floorplan.d.ts

@@ -0,0 +1,3 @@
+import { type FloorplanGeometry, type GeometryContext, type MeasurementNode } from '@pascal-app/core';
+export declare function buildMeasurementFloorplan(node: MeasurementNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/measurement/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAGtB,KAAK,eAAe,EACpB,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AA6BzB,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+L1B"}

package/dist/measurement/floorplan.js

@@ -0,0 +1,195 @@
+import { measurementAngle, measurementArea, measurementDistance, measurementPerimeter, measurementPrismVolume, } from '@pascal-app/core';
+import { buildMeasurementAngleArcPoints, formatAngleRadians, formatAreaLabel, formatLinearMeasurement, formatVolumeLabel, measurementFloorplanPresentationColor, measurementPolygonLabelAnchor, } from '@pascal-app/editor';
+import { measurementResolvedEditPoints } from './edit';
+import { resolveMeasurementNode } from './resolve';
+const projectPoint = (point) => [point[0], point[2]];
+const add = (point, offset) => [
+    point[0] + offset[0],
+    point[1] + offset[1],
+    point[2] + offset[2],
+];
+const lineStyle = (stroke) => ({
+    stroke,
+    strokeWidth: 2,
+    vectorEffect: 'non-scaling-stroke',
+    strokeLinecap: 'round',
+    strokeLinejoin: 'round',
+});
+export function buildMeasurementFloorplan(node, ctx) {
+    if (node.visible === false)
+        return null;
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const resolved = resolveMeasurementNode(node, (id) => ctx.resolve(id));
+    const measurement = resolved.payload;
+    const selected = ctx.viewState?.selected || ctx.viewState?.highlighted;
+    const editable = ctx.viewState?.selected === true;
+    const stroke = measurementFloorplanPresentationColor(resolved.dangling.length > 0, Boolean(selected));
+    const style = lineStyle(stroke);
+    const statusPrefix = resolved.dangling.length > 0 ? 'Unlinked · ' : '';
+    const editHandles = editable
+        ? measurementResolvedEditPoints(measurement).map((point, vertexIndex) => ({
+            kind: 'endpoint-handle',
+            point: projectPoint(point),
+            state: 'idle',
+            affordance: 'move-measurement-vertex',
+            payload: { vertexIndex },
+        }))
+        : [];
+    if (measurement.kind === 'distance') {
+        const [start, end] = measurement.points;
+        const [x1, y1] = projectPoint(start);
+        const [x2, y2] = projectPoint(end);
+        const collapsedHitTarget = Math.hypot(x2 - x1, y2 - y1) <= 1e-9
+            ? [
+                {
+                    kind: 'circle',
+                    cx: x1,
+                    cy: y1,
+                    r: 0.1,
+                    fill: 'transparent',
+                    pointerEvents: 'all',
+                    cursor: 'pointer',
+                },
+            ]
+            : [];
+        return {
+            kind: 'group',
+            children: [
+                { kind: 'line', x1, y1, x2, y2, ...style },
+                { kind: 'hit-line', x1, y1, x2, y2, strokeWidthPx: 12 },
+                ...collapsedHitTarget,
+                {
+                    kind: 'circle',
+                    cx: x1,
+                    cy: y1,
+                    r: 0.045,
+                    fill: stroke,
+                    pointerEvents: 'none',
+                },
+                {
+                    kind: 'circle',
+                    cx: x2,
+                    cy: y2,
+                    r: 0.045,
+                    fill: stroke,
+                    pointerEvents: 'none',
+                },
+                {
+                    kind: 'dimension-label',
+                    appearance: 'outlined',
+                    cx: (x1 + x2) / 2,
+                    cy: (y1 + y2) / 2,
+                    text: `${statusPrefix}${formatLinearMeasurement(measurementDistance(start, end), unit)}`,
+                    angle: Math.atan2(y2 - y1, x2 - x1),
+                    offsetPx: 14,
+                },
+                ...editHandles,
+            ],
+        };
+    }
+    if (measurement.kind === 'angle') {
+        const [start, vertex, end] = measurement.points;
+        const angleArc = buildMeasurementAngleArcPoints(start, vertex, end);
+        const labelPoint = angleArc[Math.floor(angleArc.length / 2)] ?? vertex;
+        return {
+            kind: 'group',
+            children: [
+                {
+                    kind: 'polyline',
+                    points: [projectPoint(start), projectPoint(vertex), projectPoint(end)],
+                    ...style,
+                },
+                ...(angleArc.length >= 2
+                    ? [
+                        {
+                            kind: 'polyline',
+                            points: angleArc.map(projectPoint),
+                            ...style,
+                            strokeWidth: 3,
+                        },
+                    ]
+                    : []),
+                {
+                    kind: 'dimension-label',
+                    appearance: 'outlined',
+                    cx: labelPoint[0],
+                    cy: labelPoint[2],
+                    text: `${statusPrefix}${formatAngleRadians(measurementAngle(start, vertex, end))}`,
+                    angle: 0,
+                    offsetPx: 10,
+                    screenUpright: true,
+                },
+                ...editHandles,
+            ],
+        };
+    }
+    if (measurement.kind === 'area' || measurement.kind === 'perimeter') {
+        const centroid = measurementPolygonLabelAnchor(measurement.base) ?? measurement.base[0];
+        const label = measurement.kind === 'area'
+            ? `A ${formatAreaLabel(measurementArea(measurement.base), unit)}`
+            : `P ${formatLinearMeasurement(measurementPerimeter(measurement.base), unit)}`;
+        return {
+            kind: 'group',
+            children: [
+                {
+                    kind: 'polygon',
+                    points: measurement.base.map(projectPoint),
+                    fill: stroke,
+                    fillOpacity: measurement.kind === 'area' ? 0.08 : 0,
+                    pointerEvents: 'all',
+                    ...style,
+                },
+                {
+                    kind: 'dimension-label',
+                    appearance: 'outlined',
+                    cx: centroid[0],
+                    cy: centroid[2],
+                    text: `${statusPrefix}${label}`,
+                    angle: 0,
+                    screenUpright: true,
+                },
+                ...editHandles,
+            ],
+        };
+    }
+    const volume = measurement;
+    const top = volume.base.map((point) => add(point, volume.extrusion));
+    const baseCentroid = measurementPolygonLabelAnchor(volume.base) ?? volume.base[0];
+    const labelPoint = add(baseCentroid, [
+        volume.extrusion[0] / 2,
+        volume.extrusion[1] / 2,
+        volume.extrusion[2] / 2,
+    ]);
+    const children = [
+        {
+            kind: 'polygon',
+            points: volume.base.map(projectPoint),
+            fill: stroke,
+            fillOpacity: 0.05,
+            pointerEvents: 'all',
+            ...style,
+        },
+        {
+            kind: 'polygon',
+            points: top.map(projectPoint),
+            fill: 'none',
+            ...style,
+        },
+    ];
+    for (let index = 0; index < volume.base.length; index++) {
+        const [x1, y1] = projectPoint(volume.base[index]);
+        const [x2, y2] = projectPoint(top[index]);
+        children.push({ kind: 'line', x1, y1, x2, y2, ...style });
+    }
+    children.push({
+        kind: 'dimension-label',
+        appearance: 'outlined',
+        cx: labelPoint[0],
+        cy: labelPoint[2],
+        text: `${statusPrefix}V ${formatVolumeLabel(measurementPrismVolume(volume.base, volume.extrusion), unit)}`,
+        angle: 0,
+        screenUpright: true,
+    });
+    children.push(...editHandles);
+    return { kind: 'group', children };
+}

package/dist/measurement/index.d.ts

@@ -0,0 +1,3 @@
+export { measurementDefinition } from './definition';
+export { closestMeasurementFeature, detachMeasurementPayload, freeMeasurementPoint, type MeasurementFeatureMatch, matchMeasurementFeatureForNode, measurementDependencyIds, measurementFeaturePoint, measurementFeaturesForNode, type ResolvedMeasurement, type ResolvedMeasurementPayload, remapMeasurementReferences, resolveMeasurementNode, } from './resolve';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/measurement/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EACL,yBAAyB,EACzB,wBAAwB,EACxB,oBAAoB,EACpB,KAAK,uBAAuB,EAC5B,8BAA8B,EAC9B,wBAAwB,EACxB,uBAAuB,EACvB,0BAA0B,EAC1B,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,WAAW,CAAA"}

package/dist/measurement/index.js

@@ -0,0 +1,2 @@
+export { measurementDefinition } from './definition';
+export { closestMeasurementFeature, detachMeasurementPayload, freeMeasurementPoint, matchMeasurementFeatureForNode, measurementDependencyIds, measurementFeaturePoint, measurementFeaturesForNode, remapMeasurementReferences, resolveMeasurementNode, } from './resolve';

package/dist/measurement/renderer.d.ts

@@ -0,0 +1,8 @@
+import { type MeasurementNode } from '@pascal-app/core';
+import { type Object3D } from 'three';
+export declare function areMeasurementAncestorsVisible(object: Object3D | null): boolean;
+export declare const MeasurementRenderer: ({ node }: {
+    node: MeasurementNode;
+}) => import("react").JSX.Element;
+export default MeasurementRenderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/measurement/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/measurement/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EAWrB,MAAM,kBAAkB,CAAA;AAezB,OAAO,EAML,KAAK,QAAQ,EAKd,MAAM,OAAO,CAAA;AA4Qd,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,GAAG,OAAO,CAO/E;AAED,eAAO,MAAM,mBAAmB,GAAI,UAAU;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,gCAyItE,CAAA;AAED,eAAe,mBAAmB,CAAA"}