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

package/dist/construction-dimension/floorplan.js

@@ -0,0 +1,457 @@
+import { constructionDimensionRequiredAnchorCount, getWallArcData, getWallCurveFrameAt, getWallThickness, } from '@pascal-app/core';
+import { readFloorplanContext, readFloorplanMetricNotationOverride, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
+import { resolveMeasurementAnchor } from '../measurement/resolve';
+import { formatConstructionLength, } from '../shared/construction-length';
+import { buildDimensionStringGeometry } from '../shared/dimension-string';
+import { alignConstructionDimensionDirectionToSharedWall, resolveCircularConstructionDimensionLayout, resolveConstructionDimensionLayout, } from './geometry';
+const DEFAULT_STROKE = '#334155';
+const DANGLING_STROKE = '#dc2626';
+const EPSILON = 1e-6;
+export function buildConstructionDimensionFloorplan(node, ctx) {
+    if (node.visible === false)
+        return null;
+    const resolved = node.anchors.map((anchor) => resolveDimensionAnchor(node, anchor, ctx));
+    const points = resolved.map((anchor) => anchor.point);
+    if (points.length < constructionDimensionRequiredAnchorCount(node.mode))
+        return null;
+    const selected = ctx.viewState?.selected || ctx.viewState?.highlighted;
+    const baseStroke = selected
+        ? (ctx.viewState?.palette.selectedStroke ?? '#2563eb')
+        : (ctx.viewState?.palette.measurementStroke ?? DEFAULT_STROKE);
+    const dangling = resolved.some((anchor) => anchor.dangling);
+    const stroke = dangling ? DANGLING_STROKE : baseStroke;
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const floorplanContext = readFloorplanContext(ctx);
+    const profile = floorplanContext.purpose === 'document' ? 'document' : 'editor';
+    const metricNotationOverride = readFloorplanMetricNotationOverride(ctx);
+    const displayNode = profile === 'editor' && metricNotationOverride
+        ? { ...node, metricNotation: metricNotationOverride }
+        : node;
+    const editable = ctx.viewState?.selected === true &&
+        !(typeof node.metadata === 'object' &&
+            node.metadata !== null &&
+            !Array.isArray(node.metadata) &&
+            node.metadata.drawingCoordinationLocked === true);
+    switch (node.mode) {
+        case 'linear':
+        case 'chord': {
+            const alignedNode = {
+                ...displayNode,
+                baseline: {
+                    ...displayNode.baseline,
+                    direction: alignConstructionDimensionDirectionToSharedWall(displayNode.baseline.direction, displayNode.anchors, (id) => ctx.resolve(id)),
+                },
+            };
+            return withFloorplanGeometryMetadata(buildLinearOrChord(alignedNode, points, stroke, dangling, unit, profile, editable), { annotationRole: 'manual-dimension' });
+        }
+        case 'radius':
+            return withFloorplanGeometryMetadata(buildRadius(displayNode, points, stroke, dangling, unit, profile, editable), { annotationRole: 'manual-dimension' });
+        case 'diameter':
+            return withFloorplanGeometryMetadata(buildDiameter(displayNode, points, stroke, dangling, unit, profile, editable), { annotationRole: 'manual-dimension' });
+        case 'center-mark':
+            return withFloorplanGeometryMetadata(buildCenterMarkOnly(displayNode, points, stroke, editable), { annotationRole: 'manual-dimension' });
+        case 'arc-length':
+            return withFloorplanGeometryMetadata(buildArcLength(displayNode, points, stroke, dangling, unit, profile, editable), { annotationRole: 'manual-dimension' });
+        case 'angular':
+            return withFloorplanGeometryMetadata(buildAngular(displayNode, points, stroke, dangling, editable), { annotationRole: 'manual-dimension' });
+        case 'coordinate':
+            return withFloorplanGeometryMetadata(buildCoordinate(displayNode, points, stroke, dangling, unit, profile, editable), { annotationRole: 'manual-dimension' });
+    }
+}
+function resolveDimensionAnchor(node, anchor, ctx) {
+    const resolved = resolveMeasurementAnchor(anchor, (id) => ctx.resolve(id));
+    if (Array.isArray(anchor) || resolved.dangling)
+        return resolved;
+    if (!supportsWallDatum(anchor.reference.featureId))
+        return resolved;
+    const referenced = ctx.resolve(anchor.reference.nodeId);
+    if (referenced?.type !== 'wall')
+        return resolved;
+    const t = wallFeatureParameter(anchor.reference.featureId, anchor.reference.parameters?.t);
+    const frame = getWallCurveFrameAt(referenced, t);
+    const side = wallDatumSide(node, anchor.reference.featureId, resolved, frame);
+    const offset = wallDatumOffset(referenced, node.datumPolicy, side);
+    const endpointExtension = wallEndpointDatumExtension(referenced, anchor.reference.featureId, node.datumPolicy, ctx);
+    return {
+        ...resolved,
+        point: [
+            frame.point.x + frame.normal.x * offset + frame.tangent.x * endpointExtension,
+            resolved.point[1],
+            frame.point.y + frame.normal.y * offset + frame.tangent.y * endpointExtension,
+        ],
+    };
+}
+function supportsWallDatum(featureId) {
+    return (featureId === 'wall:start' ||
+        featureId === 'wall:end' ||
+        featureId === 'wall:centerline' ||
+        featureId === 'wall:midpoint' ||
+        featureId === 'wall:face:left' ||
+        featureId === 'wall:face:right' ||
+        featureId === 'wall:top-centerline');
+}
+function wallFeatureParameter(featureId, parameter) {
+    if (featureId === 'wall:start')
+        return 0;
+    if (featureId === 'wall:end')
+        return 1;
+    return typeof parameter === 'number' ? Math.max(0, Math.min(1, parameter)) : 0.5;
+}
+function wallDatumSide(node, featureId, resolved, frame) {
+    if (featureId === 'wall:face:left')
+        return 1;
+    if (featureId === 'wall:face:right')
+        return -1;
+    const baselineProjection = (node.baseline.origin[0] - frame.point.x) * frame.normal.x +
+        (node.baseline.origin[1] - frame.point.y) * frame.normal.y;
+    if (Math.abs(baselineProjection) > EPSILON)
+        return baselineProjection > 0 ? 1 : -1;
+    const resolvedNormal = resolved.normal;
+    if (resolvedNormal) {
+        const normalProjection = resolvedNormal[0] * frame.normal.x + resolvedNormal[2] * frame.normal.y;
+        if (Math.abs(normalProjection) > EPSILON)
+            return normalProjection > 0 ? 1 : -1;
+    }
+    return 1;
+}
+function wallDatumOffset(wall, policy, side) {
+    if (policy === 'centerline')
+        return 0;
+    return (getWallThickness(wall) / 2) * side;
+}
+function wallEndpointDatumExtension(wall, featureId, policy, ctx) {
+    if (policy === 'centerline' || (featureId !== 'wall:start' && featureId !== 'wall:end')) {
+        return 0;
+    }
+    const parent = wall.parentId ? ctx.resolve(wall.parentId) : undefined;
+    const childIds = parent && 'children' in parent && Array.isArray(parent.children)
+        ? parent.children
+        : [];
+    const endpoint = featureId === 'wall:start' ? wall.start : wall.end;
+    const frame = getWallCurveFrameAt(wall, featureId === 'wall:start' ? 0 : 1);
+    const projections = [0];
+    for (const childId of childIds) {
+        const candidate = ctx.resolve(childId);
+        if (candidate?.type !== 'wall' ||
+            candidate.id === wall.id ||
+            getWallArcData(candidate) ||
+            (!pointsCoincide(endpoint, candidate.start) && !pointsCoincide(endpoint, candidate.end))) {
+            continue;
+        }
+        const dx = candidate.end[0] - candidate.start[0];
+        const dz = candidate.end[1] - candidate.start[1];
+        const length = Math.hypot(dx, dz);
+        if (length <= EPSILON)
+            continue;
+        const normal = [-dz / length, dx / length];
+        for (const side of [-1, 1]) {
+            const candidateOffset = wallDatumOffset(candidate, policy, side);
+            projections.push(normal[0] * candidateOffset * frame.tangent.x +
+                normal[1] * candidateOffset * frame.tangent.y);
+        }
+    }
+    return featureId === 'wall:start' ? Math.min(...projections) : Math.max(...projections);
+}
+function pointsCoincide(left, right) {
+    return Math.hypot(left[0] - right[0], left[1] - right[1]) <= 0.03;
+}
+function buildLinearOrChord(node, points, stroke, dangling, unit, profile, editable) {
+    const layout = resolveConstructionDimensionLayout(node, points);
+    const children = [];
+    const suppressedSegments = suppressedDimensionSegmentIndexes(node);
+    const visibleSegments = layout.segments.filter((_, index) => !suppressedSegments.has(index));
+    const dimensionSegments = visibleSegments.map((segment) => {
+        const baseText = `${node.mode === 'chord' ? 'CH ' : ''}${formatConstructionLength(segment.value, unit, profile, lengthFormatOptions(node))}`;
+        return {
+            witnessStart: segment.witnessStart,
+            witnessEnd: segment.witnessEnd,
+            dimensionStart: segment.dimensionStart,
+            dimensionEnd: segment.dimensionEnd,
+            text: notation(node, baseText, dangling),
+        };
+    });
+    children.push(...(dimensionSegments.length > 0
+        ? [
+            buildDimensionStringGeometry({
+                segments: dimensionSegments,
+                offsetNormal: layout.normal,
+                offsetDistance: 0,
+                extensionStartGap: node.extensionStartGap,
+                extensionOvershoot: node.extensionOvershoot,
+                terminator: node.terminator,
+                textPosition: node.textPosition,
+                stroke,
+            }),
+        ]
+        : []), ...visibleSegments.map((segment) => hitLine(segment.dimensionStart, segment.dimensionEnd)));
+    if (editable)
+        children.push(...witnessHandles(layout.witnessPoints), baselineHandle(layout.midpoint));
+    return dimensionGroup(children);
+}
+function buildRadius(node, points, stroke, dangling, unit, profile, editable) {
+    const layout = resolveCircularConstructionDimensionLayout('radius', points);
+    if (!layout?.end)
+        return null;
+    const direction = normalized(layout.start, layout.end);
+    if (!direction)
+        return null;
+    const normal = [-direction[1], direction[0]];
+    const children = [
+        dimensionGeometry(node, layout.start, layout.end, layout.start, layout.end, normal, notation(node, `R ${formatConstructionLength(layout.radius, unit, profile, lengthFormatOptions(node))}`, dangling), stroke),
+        hitLine(layout.start, layout.end),
+    ];
+    if (node.showCenterMark)
+        children.push(...centerMark(layout.center, layout.radius, stroke));
+    if (editable)
+        children.push(...anchorHandles(points));
+    return dimensionGroup(children);
+}
+function buildDiameter(node, points, stroke, dangling, unit, profile, editable) {
+    const layout = resolveCircularConstructionDimensionLayout('diameter', points);
+    if (!layout?.end)
+        return null;
+    const direction = normalized(layout.start, layout.end);
+    if (!direction)
+        return null;
+    const normal = [-direction[1], direction[0]];
+    const children = [
+        dimensionGeometry(node, layout.start, layout.end, layout.start, layout.end, normal, notation(node, `Ø ${formatConstructionLength(layout.radius * 2, unit, profile, lengthFormatOptions(node))}`, dangling), stroke),
+        hitLine(layout.start, layout.end),
+    ];
+    if (node.showCenterMark)
+        children.push(...centerMark(layout.center, layout.radius, stroke));
+    if (editable)
+        children.push(...anchorHandles(points));
+    return dimensionGroup(children);
+}
+function buildCenterMarkOnly(node, points, stroke, editable) {
+    const layout = resolveCircularConstructionDimensionLayout('center-mark', points);
+    if (!layout)
+        return null;
+    const children = centerMark(layout.center, layout.radius, stroke, true);
+    if (editable)
+        children.push(...anchorHandles(points));
+    return dimensionGroup(children);
+}
+function buildArcLength(node, points, stroke, dangling, unit, profile, editable) {
+    const layout = resolveCircularConstructionDimensionLayout('arc-length', points);
+    if (!(layout?.end && Math.abs(layout.sweep) > EPSILON))
+        return null;
+    const projectedEnd = arcPoint(layout.center, layout.radius, layout.endAngle);
+    const midAngle = layout.startAngle + layout.sweep / 2;
+    const arcMid = arcPoint(layout.center, layout.radius, midAngle);
+    const labelPoint = node.baseline.origin;
+    const children = [
+        arcGeometry(layout.center, layout.radius, layout.startAngle, layout.sweep, stroke),
+        styledLine(layout.center, layout.start, stroke, '0.08 0.08'),
+        styledLine(layout.center, projectedEnd, stroke, '0.08 0.08'),
+        styledLine(arcMid, labelPoint, stroke, '0.08 0.08'),
+        ...openArrow(layout.start, arcPoint(layout.center, layout.radius, layout.startAngle + layout.sweep * 0.08), stroke),
+        ...openArrow(projectedEnd, arcPoint(layout.center, layout.radius, layout.endAngle - layout.sweep * 0.08), stroke),
+        labelGeometry(labelPoint, notation(node, `ARC ${formatConstructionLength(layout.arcLength, unit, profile, lengthFormatOptions(node))}`, dangling), 0, true),
+    ];
+    if (node.showCenterMark)
+        children.push(...centerMark(layout.center, layout.radius, stroke));
+    if (editable)
+        children.push(...anchorHandles(points), baselineHandle(labelPoint));
+    return dimensionGroup(children);
+}
+function buildAngular(node, points, stroke, dangling, editable) {
+    const layout = resolveCircularConstructionDimensionLayout('angular', points);
+    if (!(layout?.end && Math.abs(layout.sweep) > EPSILON))
+        return null;
+    const endRadius = distance(layout.center, layout.end);
+    const maximumRadius = Math.max(0.25, Math.min(layout.radius, endRadius) * 0.9);
+    const requestedRadius = distance(layout.center, node.baseline.origin);
+    const arcRadius = Math.min(maximumRadius, Math.max(0.25, requestedRadius));
+    const midAngle = layout.startAngle + layout.sweep / 2;
+    const arcMid = arcPoint(layout.center, arcRadius, midAngle);
+    const labelPoint = node.baseline.origin;
+    const startRayEnd = arcPoint(layout.center, Math.max(layout.radius, arcRadius + 0.12), layout.startAngle);
+    const endRayEnd = arcPoint(layout.center, Math.max(endRadius, arcRadius + 0.12), layout.endAngle);
+    const degrees = (Math.abs(layout.sweep) * 180) / Math.PI;
+    const children = [
+        styledLine(layout.center, startRayEnd, stroke),
+        styledLine(layout.center, endRayEnd, stroke),
+        arcGeometry(layout.center, arcRadius, layout.startAngle, layout.sweep, stroke),
+        styledLine(arcMid, labelPoint, stroke, '0.08 0.08'),
+        labelGeometry(labelPoint, notation(node, `∠ ${formatDegrees(degrees)}`, dangling), 0, true),
+    ];
+    if (node.showCenterMark)
+        children.push(...centerMark(layout.center, arcRadius, stroke));
+    if (editable)
+        children.push(...anchorHandles(points), baselineHandle(node.baseline.origin));
+    return dimensionGroup(children);
+}
+function buildCoordinate(node, points, stroke, dangling, unit, profile, editable) {
+    const datum = [points[0][0], points[0][2]];
+    const features = points.slice(1).map((point) => [point[0], point[2]]);
+    if (features.length === 0)
+        return null;
+    const children = [...centerMark(datum, 0.4, stroke, true)];
+    features.forEach((feature, index) => {
+        const dx = feature[0] - datum[0];
+        const dy = feature[1] - datum[1];
+        const label = notation(node, `P${index + 1} · X ${formatConstructionLength(dx, unit, profile, lengthFormatOptions(node))} · Y ${formatConstructionLength(dy, unit, profile, lengthFormatOptions(node))}`, dangling, false);
+        children.push(styledLine(datum, feature, stroke, '0.08 0.08'), labelGeometry(feature, label, 0, true, 10), ...centerMark(feature, 0.3, stroke, true));
+    });
+    if (editable)
+        children.push(...anchorHandles(points));
+    return dimensionGroup(children);
+}
+function suppressedDimensionSegmentIndexes(node) {
+    const metadata = node.metadata;
+    if (!(typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata))) {
+        return new Set();
+    }
+    const value = metadata.suppressedDimensionSegmentIndexes;
+    if (!Array.isArray(value))
+        return new Set();
+    return new Set(value.filter((entry) => typeof entry === 'number' && Number.isInteger(entry) && entry >= 0));
+}
+function dimensionGroup(children) {
+    return { kind: 'group', children };
+}
+function lengthFormatOptions(node) {
+    return {
+        imperialPrecision: node.imperialPrecision,
+        metricNotation: node.metricNotation,
+    };
+}
+function notation(node, base, dangling, includeFeatureCount = true) {
+    const repeated = includeFeatureCount && node.featureCount > 1 ? `${node.featureCount} x ` : '';
+    const content = node.textOverride ?? `${repeated}${base}`;
+    const decorated = `${node.prefix}${content}${node.suffix}`;
+    return dangling ? `UNLINKED · ${decorated}` : decorated;
+}
+function dimensionGeometry(node, start, end, dimensionStart, dimensionEnd, offsetNormal, text, stroke) {
+    return {
+        kind: 'dimension',
+        start,
+        end,
+        dimensionStart,
+        dimensionEnd,
+        offsetNormal,
+        offsetDistance: 0,
+        extensionStartGap: node.extensionStartGap,
+        extensionOvershoot: node.extensionOvershoot,
+        terminator: node.terminator,
+        textPosition: node.textPosition,
+        text,
+        stroke,
+    };
+}
+function arcGeometry(center, radius, startAngle, sweep, stroke) {
+    const start = arcPoint(center, radius, startAngle);
+    const end = arcPoint(center, radius, startAngle + sweep);
+    return {
+        kind: 'path',
+        d: `M ${start[0]} ${start[1]} A ${radius} ${radius} 0 ${Math.abs(sweep) > Math.PI ? 1 : 0} ${sweep >= 0 ? 1 : 0} ${end[0]} ${end[1]}`,
+        ...lineStyle(stroke),
+    };
+}
+function styledLine(start, end, stroke, strokeDasharray) {
+    return {
+        kind: 'line',
+        x1: start[0],
+        y1: start[1],
+        x2: end[0],
+        y2: end[1],
+        ...lineStyle(stroke, strokeDasharray),
+    };
+}
+function lineStyle(stroke, strokeDasharray) {
+    return {
+        fill: 'none',
+        stroke,
+        strokeWidth: 0.9,
+        strokeDasharray,
+        vectorEffect: 'non-scaling-stroke',
+        strokeLinecap: 'butt',
+        strokeLinejoin: 'miter',
+    };
+}
+function labelGeometry(point, text, labelAngle, screenUpright = false, offsetPx = 0) {
+    return {
+        kind: 'dimension-label',
+        cx: point[0],
+        cy: point[1],
+        text,
+        angle: labelAngle,
+        screenUpright,
+        offsetPx,
+        appearance: 'outlined',
+    };
+}
+function centerMark(center, radius, stroke, force = false) {
+    if (!force && radius <= EPSILON)
+        return [];
+    const half = Math.min(0.22, Math.max(0.1, radius * 0.18));
+    const gap = Math.min(0.045, half * 0.3);
+    return [
+        styledLine([center[0] - half, center[1]], [center[0] - gap, center[1]], stroke),
+        styledLine([center[0] + gap, center[1]], [center[0] + half, center[1]], stroke),
+        styledLine([center[0], center[1] - half], [center[0], center[1] - gap], stroke),
+        styledLine([center[0], center[1] + gap], [center[0], center[1] + half], stroke),
+    ];
+}
+function openArrow(tip, toward, stroke) {
+    const direction = normalized(tip, toward);
+    if (!direction)
+        return [];
+    const length = 0.15;
+    const halfWidth = 0.055;
+    const base = [tip[0] + direction[0] * length, tip[1] + direction[1] * length];
+    const normal = [-direction[1], direction[0]];
+    return [
+        styledLine(tip, [base[0] + normal[0] * halfWidth, base[1] + normal[1] * halfWidth], stroke),
+        styledLine(tip, [base[0] - normal[0] * halfWidth, base[1] - normal[1] * halfWidth], stroke),
+    ];
+}
+function baselineHandle(point) {
+    return {
+        kind: 'endpoint-handle',
+        point,
+        state: 'idle',
+        variant: 'curve',
+        affordance: 'move-construction-dimension-baseline',
+        payload: null,
+    };
+}
+function anchorHandles(points) {
+    return witnessHandles(points.map((point) => [point[0], point[2]]));
+}
+function witnessHandles(points) {
+    return points.map((point, witnessIndex) => ({
+        kind: 'endpoint-handle',
+        point,
+        state: 'idle',
+        affordance: 'move-construction-dimension-witness',
+        payload: { witnessIndex },
+    }));
+}
+function hitLine(start, end) {
+    return {
+        kind: 'hit-line',
+        x1: start[0],
+        y1: start[1],
+        x2: end[0],
+        y2: end[1],
+        strokeWidthPx: 12,
+    };
+}
+function arcPoint(center, radius, pointAngle) {
+    return [center[0] + Math.cos(pointAngle) * radius, center[1] + Math.sin(pointAngle) * radius];
+}
+function normalized(start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const magnitude = Math.hypot(dx, dy);
+    return magnitude <= EPSILON ? null : [dx / magnitude, dy / magnitude];
+}
+function distance(first, second) {
+    return Math.hypot(second[0] - first[0], second[1] - first[1]);
+}
+function formatDegrees(value) {
+    return `${Number.parseFloat(value.toFixed(value < 10 ? 1 : 0))}°`;
+}

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

@@ -0,0 +1,31 @@
+import { type AnyNode, type AnyNodeId, type ConstructionDimensionMode, type ConstructionDimensionNode, type FloorplanPoint, type MeasurementAnchor, type MeasurementPoint } from '@pascal-app/core';
+export type ConstructionDimensionSegmentLayout = {
+    dimensionStart: FloorplanPoint;
+    dimensionEnd: FloorplanPoint;
+    value: number;
+    witnessStart: FloorplanPoint;
+    witnessEnd: FloorplanPoint;
+};
+export type ConstructionDimensionLayout = {
+    dimensionPoints: FloorplanPoint[];
+    direction: FloorplanPoint;
+    midpoint: FloorplanPoint;
+    normal: FloorplanPoint;
+    segments: ConstructionDimensionSegmentLayout[];
+    witnessPoints: FloorplanPoint[];
+};
+export declare function alignConstructionDimensionDirectionToSharedWall(direction: readonly [number, number], anchors: readonly MeasurementAnchor[], resolve: (id: AnyNodeId) => AnyNode | undefined): [number, number];
+export type CircularConstructionDimensionLayout = {
+    center: FloorplanPoint;
+    start: FloorplanPoint;
+    end: FloorplanPoint | null;
+    radius: number;
+    startAngle: number;
+    endAngle: number;
+    sweep: number;
+    chordLength: number;
+    arcLength: number;
+};
+export declare function resolveCircularConstructionDimensionLayout(mode: ConstructionDimensionMode, anchors: readonly MeasurementPoint[]): CircularConstructionDimensionLayout | null;
+export declare function resolveConstructionDimensionLayout(node: Pick<ConstructionDimensionNode, 'baseline' | 'chainMode'>, anchors: readonly MeasurementPoint[]): ConstructionDimensionLayout;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EAEnB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACtB,MAAM,kBAAkB,CAAA;AAEzB,MAAM,MAAM,kCAAkC,GAAG;IAC/C,cAAc,EAAE,cAAc,CAAA;IAC9B,YAAY,EAAE,cAAc,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,cAAc,CAAA;IAC5B,UAAU,EAAE,cAAc,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,eAAe,EAAE,cAAc,EAAE,CAAA;IACjC,SAAS,EAAE,cAAc,CAAA;IACzB,QAAQ,EAAE,cAAc,CAAA;IACxB,MAAM,EAAE,cAAc,CAAA;IACtB,QAAQ,EAAE,kCAAkC,EAAE,CAAA;IAC9C,aAAa,EAAE,cAAc,EAAE,CAAA;CAChC,CAAA;AAID,wBAAgB,+CAA+C,CAC7D,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,OAAO,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,GAAG,SAAS,GAC9C,CAAC,MAAM,EAAE,MAAM,CAAC,CA+BlB;AAcD,MAAM,MAAM,mCAAmC,GAAG;IAChD,MAAM,EAAE,cAAc,CAAA;IACtB,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,GAAG,IAAI,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,wBAAgB,0CAA0C,CACxD,IAAI,EAAE,yBAAyB,EAC/B,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,mCAAmC,GAAG,IAAI,CA2C5C;AAaD,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,IAAI,CAAC,yBAAyB,EAAE,UAAU,GAAG,WAAW,CAAC,EAC/D,OAAO,EAAE,SAAS,gBAAgB,EAAE,GACnC,2BAA2B,CAqD7B"}

package/dist/construction-dimension/geometry.js

@@ -0,0 +1,144 @@
+import { getWallArcData, } from '@pascal-app/core';
+const project = (point) => [point[0], point[2]];
+export function alignConstructionDimensionDirectionToSharedWall(direction, anchors, resolve) {
+    const firstAnchor = anchors[0];
+    const secondAnchor = anchors[1];
+    if (!firstAnchor ||
+        !secondAnchor ||
+        Array.isArray(firstAnchor) ||
+        Array.isArray(secondAnchor) ||
+        firstAnchor.reference.nodeId !== secondAnchor.reference.nodeId) {
+        return [direction[0], direction[1]];
+    }
+    const wall = resolve(firstAnchor.reference.nodeId);
+    if (wall?.type !== 'wall' ||
+        getWallArcData(wall) ||
+        !supportsStraightWallDirection(firstAnchor.reference.featureId) ||
+        !supportsStraightWallDirection(secondAnchor.reference.featureId)) {
+        return [direction[0], direction[1]];
+    }
+    const wallDx = wall.end[0] - wall.start[0];
+    const wallDz = wall.end[1] - wall.start[1];
+    const wallLength = Math.hypot(wallDx, wallDz);
+    if (wallLength <= 1e-9)
+        return [direction[0], direction[1]];
+    const wallDirection = [wallDx / wallLength, wallDz / wallLength];
+    return direction[0] * wallDirection[0] + direction[1] * wallDirection[1] < 0
+        ? [-wallDirection[0], -wallDirection[1]]
+        : wallDirection;
+}
+function supportsStraightWallDirection(featureId) {
+    return [
+        'wall:start',
+        'wall:end',
+        'wall:centerline',
+        'wall:midpoint',
+        'wall:face:left',
+        'wall:face:right',
+        'wall:top-centerline',
+    ].includes(featureId);
+}
+export function resolveCircularConstructionDimensionLayout(mode, anchors) {
+    if (anchors.length < 2)
+        return null;
+    const first = project(anchors[0]);
+    const second = project(anchors[1]);
+    if (mode === 'diameter' || mode === 'radius') {
+        const center = [(first[0] + second[0]) / 2, (first[1] + second[1]) / 2];
+        const radius = distance(first, second) / 2;
+        if (radius <= 1e-9)
+            return null;
+        return {
+            center,
+            start: first,
+            end: second,
+            radius,
+            startAngle: Math.atan2(first[1] - center[1], first[0] - center[0]),
+            endAngle: Math.atan2(second[1] - center[1], second[0] - center[0]),
+            sweep: Math.PI,
+            chordLength: radius * 2,
+            arcLength: Math.PI * radius,
+        };
+    }
+    const usesMiddleCenter = mode === 'arc-length' || mode === 'angular';
+    const center = usesMiddleCenter ? second : first;
+    const start = usesMiddleCenter ? first : second;
+    const radius = distance(center, start);
+    if (radius <= 1e-9)
+        return null;
+    const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+    const endAnchor = anchors[2];
+    const end = endAnchor ? project(endAnchor) : null;
+    const endAngle = end ? Math.atan2(end[1] - center[1], end[0] - center[0]) : startAngle;
+    const sweep = end ? normalizedSignedSweep(startAngle, endAngle) : 0;
+    return {
+        center,
+        start,
+        end,
+        radius,
+        startAngle,
+        endAngle,
+        sweep,
+        chordLength: end ? distance(start, end) : radius,
+        arcLength: Math.abs(sweep) * radius,
+    };
+}
+function normalizedSignedSweep(startAngle, endAngle) {
+    let sweep = endAngle - startAngle;
+    while (sweep > Math.PI)
+        sweep -= Math.PI * 2;
+    while (sweep <= -Math.PI)
+        sweep += Math.PI * 2;
+    return sweep;
+}
+function distance(first, second) {
+    return Math.hypot(second[0] - first[0], second[1] - first[1]);
+}
+export function resolveConstructionDimensionLayout(node, anchors) {
+    if (anchors.length < 2) {
+        throw new Error('Construction dimension layout requires at least two anchors');
+    }
+    const magnitude = Math.hypot(node.baseline.direction[0], node.baseline.direction[1]);
+    const direction = [
+        node.baseline.direction[0] / magnitude,
+        node.baseline.direction[1] / magnitude,
+    ];
+    const normal = [-direction[1], direction[0]];
+    const witnessPoints = anchors.map(project);
+    const dimensionPoints = witnessPoints.map((point) => {
+        const deltaX = point[0] - node.baseline.origin[0];
+        const deltaY = point[1] - node.baseline.origin[1];
+        const distance = deltaX * direction[0] + deltaY * direction[1];
+        return [
+            node.baseline.origin[0] + distance * direction[0],
+            node.baseline.origin[1] + distance * direction[1],
+        ];
+    });
+    const segmentIndexes = node.chainMode === 'continuous'
+        ? witnessPoints.slice(0, -1).map((_, index) => [index, index + 1])
+        : Array.from({ length: Math.floor(witnessPoints.length / 2) }, (_, index) => [index * 2, index * 2 + 1]);
+    const segments = segmentIndexes.map(([startIndex, endIndex]) => {
+        const witnessStart = witnessPoints[startIndex];
+        const witnessEnd = witnessPoints[endIndex];
+        const dimensionStart = dimensionPoints[startIndex];
+        const dimensionEnd = dimensionPoints[endIndex];
+        return {
+            dimensionStart,
+            dimensionEnd,
+            value: Math.abs((witnessEnd[0] - witnessStart[0]) * direction[0] +
+                (witnessEnd[1] - witnessStart[1]) * direction[1]),
+            witnessStart,
+            witnessEnd,
+        };
+    });
+    const first = dimensionPoints[0];
+    const last = dimensionPoints.at(-1);
+    return {
+        dimensionPoints,
+        direction,
+        midpoint: [(first[0] + last[0]) / 2, (first[1] + last[1]) / 2],
+        normal,
+        segments,
+        witnessPoints,
+    };
+}

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

@@ -0,0 +1,4 @@
+export { constructionDimensionDefinition } from './definition';
+export { buildConstructionDimensionFloorplan } from './floorplan';
+export { resolveCircularConstructionDimensionLayout, resolveConstructionDimensionLayout, } from './geometry';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,cAAc,CAAA;AAC9D,OAAO,EAAE,mCAAmC,EAAE,MAAM,aAAa,CAAA;AACjE,OAAO,EACL,0CAA0C,EAC1C,kCAAkC,GACnC,MAAM,YAAY,CAAA"}

package/dist/construction-dimension/index.js

@@ -0,0 +1,3 @@
+export { constructionDimensionDefinition } from './definition';
+export { buildConstructionDimensionFloorplan } from './floorplan';
+export { resolveCircularConstructionDimensionLayout, resolveConstructionDimensionLayout, } from './geometry';

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/construction-dimension/panel.tsx"],"names":[],"mappings":"AAkFA,MAAM,CAAC,OAAO,UAAU,0BAA0B,uCAoPjD"}