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

package/dist/structural-grid/coordination.js

@@ -0,0 +1,105 @@
+export const STRUCTURAL_GRID_SNAP_DISTANCE_M = 0.25;
+export const STRUCTURAL_GRID_REFERENCE_TOLERANCE_M = 0.02;
+const EPSILON = 1e-9;
+export function collectStructuralGridAxes(nodes, levelId) {
+    if (!levelId)
+        return [];
+    return Object.values(nodes).filter((node) => node.type === 'structural-grid' && node.parentId === levelId && node.visible !== false);
+}
+export function formatStructuralGridReference(axes) {
+    const labels = [...new Set(axes.map((axis) => axis.label.trim()).filter(Boolean))];
+    labels.sort((left, right) => {
+        const leftFamily = structuralGridLabelSortFamily(left);
+        const rightFamily = structuralGridLabelSortFamily(right);
+        if (leftFamily !== rightFamily)
+            return leftFamily - rightFamily;
+        return left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' });
+    });
+    return labels.join('-');
+}
+export function resolveStructuralGridSnap(point, axes, maxDistance = STRUCTURAL_GRID_SNAP_DISTANCE_M) {
+    let nearestIntersection = null;
+    for (let firstIndex = 0; firstIndex < axes.length; firstIndex += 1) {
+        const first = axes[firstIndex];
+        if (!first)
+            continue;
+        for (let secondIndex = firstIndex + 1; secondIndex < axes.length; secondIndex += 1) {
+            const second = axes[secondIndex];
+            if (!second)
+                continue;
+            const intersection = segmentIntersection(first.start, first.end, second.start, second.end);
+            if (!intersection)
+                continue;
+            const distance = pointDistance(point, intersection);
+            if (distance > maxDistance ||
+                (nearestIntersection && distance >= nearestIntersection.distance)) {
+                continue;
+            }
+            nearestIntersection = {
+                point: intersection,
+                distance,
+                kind: 'intersection',
+                axes: [first, second],
+                reference: formatStructuralGridReference([first, second]),
+            };
+        }
+    }
+    if (nearestIntersection)
+        return nearestIntersection;
+    let nearestLine = null;
+    for (const axis of axes) {
+        const projected = closestPointOnSegment(point, axis.start, axis.end);
+        const distance = pointDistance(point, projected);
+        if (distance > maxDistance || (nearestLine && distance >= nearestLine.distance))
+            continue;
+        nearestLine = {
+            point: projected,
+            distance,
+            kind: 'line',
+            axes: [axis],
+            reference: formatStructuralGridReference([axis]),
+        };
+    }
+    return nearestLine;
+}
+export function resolveStructuralGridReference(point, axes, tolerance = STRUCTURAL_GRID_REFERENCE_TOLERANCE_M) {
+    const matching = axes.filter((axis) => pointDistance(point, closestPointOnSegment(point, axis.start, axis.end)) <= tolerance);
+    const reference = formatStructuralGridReference(matching);
+    return reference || null;
+}
+function structuralGridLabelSortFamily(label) {
+    if (/^[A-Za-z]+$/.test(label))
+        return 0;
+    if (/^\d+$/.test(label))
+        return 1;
+    return 2;
+}
+function pointDistance(first, second) {
+    return Math.hypot(second[0] - first[0], second[1] - first[1]);
+}
+function closestPointOnSegment(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared <= EPSILON)
+        return [start[0], start[1]];
+    const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSquared));
+    return [start[0] + dx * t, start[1] + dz * t];
+}
+function segmentIntersection(firstStart, firstEnd, secondStart, secondEnd) {
+    const firstDx = firstEnd[0] - firstStart[0];
+    const firstDz = firstEnd[1] - firstStart[1];
+    const secondDx = secondEnd[0] - secondStart[0];
+    const secondDz = secondEnd[1] - secondStart[1];
+    const denominator = firstDx * secondDz - firstDz * secondDx;
+    if (Math.abs(denominator) <= EPSILON)
+        return null;
+    const offsetX = secondStart[0] - firstStart[0];
+    const offsetZ = secondStart[1] - firstStart[1];
+    const firstT = (offsetX * secondDz - offsetZ * secondDx) / denominator;
+    const secondT = (offsetX * firstDz - offsetZ * firstDx) / denominator;
+    if (firstT < -EPSILON || firstT > 1 + EPSILON || secondT < -EPSILON || secondT > 1 + EPSILON) {
+        return null;
+    }
+    return [firstStart[0] + firstDx * firstT, firstStart[1] + firstDz * firstT];
+}

package/dist/structural-grid/definition.d.ts

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

package/dist/structural-grid/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/structural-grid/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAGtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAsD9E,CAAA"}

package/dist/structural-grid/definition.js

@@ -0,0 +1,51 @@
+import { buildStructuralGridFloorplan } from './floorplan';
+import { StructuralGridNode } from './schema';
+export const structuralGridDefinition = {
+    kind: 'structural-grid',
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: StructuralGridNode,
+    category: 'structure',
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool'),
+            availableModes: ['expert'],
+            preferredView: '2d',
+        },
+    },
+    snapProfile: 'structural',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        start: [0, 0],
+        end: [0, 5],
+        label: '1',
+        showStartBubble: true,
+        showEndBubble: true,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    floorplan: buildStructuralGridFloorplan,
+    toolHints: [
+        { key: 'Left click', label: 'Start grid axis' },
+        { key: 'Left click', label: 'Finish grid axis' },
+        { key: 'Alt', label: 'Bypass snapping' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Structural Grid',
+        description: 'Persistent construction grid axis with identification bubbles.',
+        icon: { kind: 'url', src: '/icons/structural-grid.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 72,
+    },
+    mcp: {
+        description: 'A floor-plan structural datum axis defined by two level-local points and a grid identifier.',
+    },
+};

package/dist/structural-grid/floorplan-tool.d.ts

@@ -0,0 +1,16 @@
+import { type AnyNode } from '@pascal-app/core';
+import { type FloorplanToolContext } from '@pascal-app/editor';
+type PlanPoint = [number, number];
+export type StructuralGridLabelFamily = 'numeric' | 'alphabetic';
+export declare function shouldConsumeStructuralGridPointerEvent(event: {
+    type: string;
+    button: number;
+    buttons: number;
+}): boolean;
+export declare function structuralGridLabelFamily(start: PlanPoint, end: PlanPoint): StructuralGridLabelFamily;
+export declare function alphabeticGridLabel(index: number): string;
+export declare function nextStructuralGridLabel(nodes: Readonly<Record<string, AnyNode>>, levelId: string, start: PlanPoint, end: PlanPoint): string;
+export declare function snapStructuralGridAngle(start: PlanPoint, point: PlanPoint): PlanPoint;
+export declare function FloorplanStructuralGridToolLayer({ activeLevelId, finishTool, gridSnapStep, sceneApi, selectNode, }: FloorplanToolContext): import("react").JSX.Element | null;
+export default FloorplanStructuralGridToolLayer;
+//# sourceMappingURL=floorplan-tool.d.ts.map

package/dist/structural-grid/floorplan-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/structural-grid/floorplan-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAIb,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,oBAAoB,EAS1B,MAAM,oBAAoB,CAAA;AAQ3B,KAAK,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACjC,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,YAAY,CAAA;AAEhE,wBAAgB,uCAAuC,CAAC,KAAK,EAAE;IAC7D,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAGV;AAaD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,GACb,yBAAyB,CAE3B;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQzD;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,SAAS,GACb,MAAM,CAiBR;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,CAOrF;AAED,wBAAgB,gCAAgC,CAAC,EAC/C,aAAa,EACb,UAAU,EACV,YAAY,EACZ,QAAQ,EACR,UAAU,GACX,EAAE,oBAAoB,sCA4MtB;AAED,eAAe,gCAAgC,CAAA"}

package/dist/structural-grid/floorplan-tool.js

@@ -0,0 +1,183 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { StructuralGridNode, } from '@pascal-app/core';
+import { clearSurfacePlanSnapFeedback, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, resolveSurfacePlanPointSnap, triggerSFX, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
+import { useCallback, useEffect, useRef, useState } from 'react';
+const MIN_GRID_LENGTH = 0.01;
+const GRID_BUBBLE_RADIUS = 0.22;
+const GRID_LABEL_SIZE = 0.18;
+const ANGLE_INCREMENT = Math.PI / 4;
+export function shouldConsumeStructuralGridPointerEvent(event) {
+    if (event.type === 'pointerdown')
+        return event.button === 0;
+    return (event.buttons & 0b110) === 0;
+}
+function snap(value, step) {
+    return step > 0 ? Math.round(value / step) * step : value;
+}
+function clientToPlanPoint(group, clientX, clientY) {
+    const matrix = group.getScreenCTM();
+    if (!matrix)
+        return null;
+    const local = new DOMPoint(clientX, clientY).matrixTransform(matrix.inverse());
+    return [local.x, local.y];
+}
+export function structuralGridLabelFamily(start, end) {
+    return Math.abs(end[1] - start[1]) >= Math.abs(end[0] - start[0]) ? 'numeric' : 'alphabetic';
+}
+export function alphabeticGridLabel(index) {
+    let value = Math.max(0, Math.floor(index));
+    let label = '';
+    do {
+        label = String.fromCharCode(65 + (value % 26)) + label;
+        value = Math.floor(value / 26) - 1;
+    } while (value >= 0);
+    return label;
+}
+export function nextStructuralGridLabel(nodes, levelId, start, end) {
+    const family = structuralGridLabelFamily(start, end);
+    const used = new Set(Object.values(nodes)
+        .filter((node) => node.type === 'structural-grid' &&
+        node.parentId === levelId &&
+        structuralGridLabelFamily(node.start, node.end) === family)
+        .map((node) => node.label.toUpperCase()));
+    for (let index = 0;; index += 1) {
+        const candidate = family === 'numeric' ? String(index + 1) : alphabeticGridLabel(index);
+        if (!used.has(candidate))
+            return candidate;
+    }
+}
+export function snapStructuralGridAngle(start, point) {
+    const dx = point[0] - start[0];
+    const dz = point[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < MIN_GRID_LENGTH)
+        return point;
+    const angle = Math.round(Math.atan2(dz, dx) / ANGLE_INCREMENT) * ANGLE_INCREMENT;
+    return [start[0] + Math.cos(angle) * length, start[1] + Math.sin(angle) * length];
+}
+export function FloorplanStructuralGridToolLayer({ activeLevelId, finishTool, gridSnapStep, sceneApi, selectNode, }) {
+    const groupRef = useRef(null);
+    const startRef = useRef(null);
+    const [start, setStart] = useState(null);
+    const [hover, setHover] = useState(null);
+    const renderContext = useFloorplanRender();
+    useEffect(() => {
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'structural-grid' });
+        return () => useInteractionScope
+            .getState()
+            .endIf((scope) => scope.kind === 'drafting' && scope.tool === 'structural-grid');
+    }, []);
+    const updateStart = useCallback((point) => {
+        startRef.current = point;
+        setStart(point);
+    }, []);
+    useEffect(() => {
+        updateStart(null);
+        setHover(null);
+        const group = groupRef.current;
+        const svg = group?.ownerSVGElement;
+        if (!(activeLevelId && group && svg))
+            return;
+        const consume = (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            event.stopImmediatePropagation();
+        };
+        const resolveEvent = (event) => {
+            const raw = clientToPlanPoint(group, event.clientX, event.clientY);
+            if (!raw)
+                return null;
+            const anglePoint = startRef.current && !event.altKey && isAngleSnapActive()
+                ? snapStructuralGridAngle(startRef.current, raw)
+                : raw;
+            const step = !event.altKey && isGridSnapActive() ? gridSnapStep : 0;
+            const fallback = [snap(anglePoint[0], step), snap(anglePoint[1], step)];
+            const snapped = resolveSurfacePlanPointSnap({
+                rawPoint: anglePoint,
+                fallbackPoint: fallback,
+                levelId: activeLevelId,
+                magnetic: !event.altKey && isMagneticSnapActive(),
+                align: isMagneticSnapActive(),
+            });
+            return snapped.point;
+        };
+        const onPointerDown = (event) => {
+            if (shouldConsumeStructuralGridPointerEvent(event))
+                consume(event);
+        };
+        const onPointerMove = (event) => {
+            if (shouldConsumeStructuralGridPointerEvent(event))
+                consume(event);
+            setHover(resolveEvent(event));
+        };
+        const onPointerLeave = () => {
+            clearSurfacePlanSnapFeedback();
+            setHover(null);
+        };
+        const onClick = (event) => {
+            if (event.button !== 0)
+                return;
+            consume(event);
+            const point = resolveEvent(event);
+            if (!point)
+                return;
+            const currentStart = startRef.current;
+            if (!currentStart) {
+                updateStart(point);
+                triggerSFX('sfx:grid-snap');
+                return;
+            }
+            if (Math.hypot(point[0] - currentStart[0], point[1] - currentStart[1]) < MIN_GRID_LENGTH) {
+                return;
+            }
+            const label = nextStructuralGridLabel(sceneApi.nodes(), activeLevelId, currentStart, point);
+            const node = StructuralGridNode.parse({
+                name: `Grid ${label}`,
+                start: currentStart,
+                end: point,
+                label,
+            });
+            sceneApi.upsert(node, activeLevelId);
+            selectNode(node.id);
+            triggerSFX('sfx:structure-build');
+            updateStart(null);
+        };
+        const onKeyDown = (event) => {
+            if (event.key !== 'Escape')
+                return;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            markToolCancelConsumed();
+            if (startRef.current) {
+                updateStart(null);
+                return;
+            }
+            finishTool();
+        };
+        const onBlur = () => clearSurfacePlanSnapFeedback();
+        svg.addEventListener('pointerdown', onPointerDown, true);
+        svg.addEventListener('pointermove', onPointerMove, true);
+        svg.addEventListener('pointerleave', onPointerLeave, true);
+        svg.addEventListener('click', onClick, true);
+        window.addEventListener('keydown', onKeyDown, true);
+        window.addEventListener('blur', onBlur);
+        return () => {
+            clearSurfacePlanSnapFeedback();
+            svg.removeEventListener('pointerdown', onPointerDown, true);
+            svg.removeEventListener('pointermove', onPointerMove, true);
+            svg.removeEventListener('pointerleave', onPointerLeave, true);
+            svg.removeEventListener('click', onClick, true);
+            window.removeEventListener('keydown', onKeyDown, true);
+            window.removeEventListener('blur', onBlur);
+        };
+    }, [activeLevelId, finishTool, gridSnapStep, sceneApi, selectNode, updateStart]);
+    if (!activeLevelId)
+        return null;
+    const unitsPerPixel = renderContext?.unitsPerPixel ?? 0.01;
+    const reticleRadius = 9 * unitsPerPixel;
+    const label = start && hover ? nextStructuralGridLabel(sceneApi.nodes(), activeLevelId, start, hover) : null;
+    const renderBubble = (point, key) => (_jsxs("g", { pointerEvents: "none", children: [_jsx("circle", { cx: point[0], cy: point[1], fill: "#ffffff", r: GRID_BUBBLE_RADIUS, stroke: "#0ea5e9", strokeWidth: 1.5, vectorEffect: "non-scaling-stroke" }), _jsx("g", { transform: `translate(${point[0]} ${point[1]}) rotate(${-(renderContext?.sceneRotationDeg ?? 0)})`, children: _jsx("text", { dominantBaseline: "middle", fill: "#0369a1", fontSize: GRID_LABEL_SIZE, fontWeight: 700, textAnchor: "middle", x: 0, y: 0, children: label }) })] }, key));
+    return (_jsxs("g", { ref: groupRef, children: [start && hover && label ? (_jsxs("g", { pointerEvents: "none", children: [_jsx("line", { stroke: "#0ea5e9", strokeDasharray: "10 4 2 4", strokeWidth: 1.5, vectorEffect: "non-scaling-stroke", x1: start[0], x2: hover[0], y1: start[1], y2: hover[1] }), renderBubble(start, 'start'), renderBubble(hover, 'end')] })) : null, hover ? (_jsxs("g", { pointerEvents: "none", children: [_jsx("circle", { cx: hover[0], cy: hover[1], fill: "none", r: reticleRadius, stroke: "#0ea5e9", strokeWidth: 2, vectorEffect: "non-scaling-stroke" }), _jsx("line", { stroke: "#0ea5e9", strokeWidth: 1.5, vectorEffect: "non-scaling-stroke", x1: hover[0] - reticleRadius * 1.4, x2: hover[0] + reticleRadius * 1.4, y1: hover[1], y2: hover[1] }), _jsx("line", { stroke: "#0ea5e9", strokeWidth: 1.5, vectorEffect: "non-scaling-stroke", x1: hover[0], x2: hover[0], y1: hover[1] - reticleRadius * 1.4, y2: hover[1] + reticleRadius * 1.4 })] })) : null] }));
+}
+export default FloorplanStructuralGridToolLayer;

package/dist/structural-grid/floorplan.d.ts

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

package/dist/structural-grid/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/structural-grid/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,kBAAkB,EACnB,MAAM,kBAAkB,CAAA;AAoCzB,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+B1B"}

package/dist/structural-grid/floorplan.js

@@ -0,0 +1,61 @@
+import { withFloorplanGeometryMetadata } from '@pascal-app/editor';
+const GRID_BUBBLE_RADIUS = 0.22;
+const GRID_LABEL_SIZE = 0.18;
+function bubble(point, label, stroke) {
+    return {
+        kind: 'group',
+        children: [
+            {
+                kind: 'circle',
+                cx: point[0],
+                cy: point[1],
+                r: GRID_BUBBLE_RADIUS,
+                fill: '#ffffff',
+                stroke,
+                strokeWidth: 1.2,
+                vectorEffect: 'non-scaling-stroke',
+            },
+            {
+                kind: 'text',
+                x: point[0],
+                y: point[1],
+                text: label,
+                fontSize: GRID_LABEL_SIZE,
+                fill: stroke,
+                fontWeight: 700,
+                textAnchor: 'middle',
+                dominantBaseline: 'middle',
+                upright: true,
+            },
+        ],
+    };
+}
+export function buildStructuralGridFloorplan(node, ctx) {
+    const length = Math.hypot(node.end[0] - node.start[0], node.end[1] - node.start[1]);
+    if (length < 0.001)
+        return null;
+    const selected = ctx.viewState?.selected ?? false;
+    const highlighted = ctx.viewState?.highlighted ?? false;
+    const palette = ctx.viewState?.palette;
+    const active = selected || highlighted;
+    const stroke = active && palette ? palette.selectedStroke : '#475569';
+    const children = [
+        {
+            kind: 'line',
+            x1: node.start[0],
+            y1: node.start[1],
+            x2: node.end[0],
+            y2: node.end[1],
+            stroke,
+            strokeWidth: active ? 1.6 : 1,
+            strokeDasharray: '10 4 2 4',
+            vectorEffect: 'non-scaling-stroke',
+            pointerEvents: 'stroke',
+        },
+    ];
+    if (node.showStartBubble)
+        children.push(bubble(node.start, node.label, stroke));
+    if (node.showEndBubble)
+        children.push(bubble(node.end, node.label, stroke));
+    return withFloorplanGeometryMetadata({ kind: 'group', children }, { annotationRole: 'structural-grid' });
+}

package/dist/structural-grid/index.d.ts

@@ -0,0 +1,2 @@
+export { structuralGridDefinition } from './definition';
+//# sourceMappingURL=index.d.ts.map

package/dist/structural-grid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/structural-grid/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAA"}

package/dist/structural-grid/index.js

@@ -0,0 +1 @@
+export { structuralGridDefinition } from './definition';

package/dist/structural-grid/schema.d.ts

@@ -0,0 +1,2 @@
+export { StructuralGridNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/structural-grid/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/structural-grid/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/structural-grid/schema.js

@@ -0,0 +1 @@
+export { StructuralGridNode } from '@pascal-app/core';

package/dist/wall/construction-dimensions.d.ts

@@ -0,0 +1,32 @@
+import { type AnyNode, type FloorplanGeometry, type FloorplanPoint, type GeometryContext, type WallNode } from '@pascal-app/core';
+import { type ConstructionDimensionDrawingStandard } from '../shared/construction-dimension-standards';
+import { type ConstructionLengthProfile, type ConstructionLinearUnit } from '../shared/construction-length';
+export { formatConstructionLength } from '../shared/construction-length';
+export type ConstructionDimensionTier = 'opening-widths' | 'openings' | 'partitions' | 'structure' | 'jogs' | 'overall' | 'structural-overall' | 'interior' | 'interior-overall';
+export type PlannedConstructionDimension = {
+    tier: ConstructionDimensionTier;
+    start: FloorplanPoint;
+    end: FloorplanPoint;
+    dimensionStart?: FloorplanPoint;
+    dimensionEnd?: FloorplanPoint;
+    offsetNormal: FloorplanPoint;
+    offsetDistance: number;
+    textPrefix?: string;
+};
+export type WallConstructionDimensionPlan = ReadonlyMap<string, readonly PlannedConstructionDimension[]>;
+export declare function buildLevelWallConstructionDimensionPlan(walls: ReadonlyArray<WallNode>, nodes: Record<string, AnyNode>, standard?: ConstructionDimensionDrawingStandard): WallConstructionDimensionPlan;
+export declare function renderPlannedConstructionDimensions(planned: readonly PlannedConstructionDimension[], unit: ConstructionLinearUnit, stroke?: string, profile?: ConstructionLengthProfile, standard?: ConstructionDimensionDrawingStandard): FloorplanGeometry[];
+export declare function buildCurvedWallConstructionDimensions(wall: WallNode, { unit, stroke, profile, standard, siblings, }: {
+    unit: ConstructionLinearUnit;
+    stroke?: string;
+    profile?: ConstructionLengthProfile;
+    standard?: ConstructionDimensionDrawingStandard;
+    siblings?: ReadonlyArray<WallNode>;
+}): FloorplanGeometry[];
+export declare function buildWallConstructionDimensions(wall: WallNode, ctx: GeometryContext, { unit, stroke, profile, standard, }: {
+    unit: ConstructionLinearUnit;
+    stroke?: string;
+    profile?: ConstructionLengthProfile;
+    standard?: ConstructionDimensionDrawingStandard;
+}): FloorplanGeometry[];
+//# sourceMappingURL=construction-dimensions.d.ts.map

package/dist/wall/construction-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"construction-dimensions.d.ts","sourceRoot":"","sources":["../../src/wall/construction-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,KAAK,oCAAoC,EAE1C,MAAM,4CAA4C,CAAA;AACnD,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAE5B,MAAM,+BAA+B,CAAA;AAItC,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AAUxE,MAAM,MAAM,yBAAyB,GACjC,gBAAgB,GAChB,UAAU,GACV,YAAY,GACZ,WAAW,GACX,MAAM,GACN,SAAS,GACT,oBAAoB,GACpB,UAAU,GACV,kBAAkB,CAAA;AAYtB,MAAM,MAAM,4BAA4B,GAAG;IACzC,IAAI,EAAE,yBAAyB,CAAA;IAC/B,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;IACnB,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,YAAY,CAAC,EAAE,cAAc,CAAA;IAC7B,YAAY,EAAE,cAAc,CAAA;IAC5B,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG,WAAW,CACrD,MAAM,EACN,SAAS,4BAA4B,EAAE,CACxC,CAAA;AAiBD,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,QAAQ,GAAE,oCAA8E,GACvF,6BAA6B,CA6L/B;AAmGD,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,SAAS,4BAA4B,EAAE,EAChD,IAAI,EAAE,sBAAsB,EAC5B,MAAM,CAAC,EAAE,MAAM,EACf,OAAO,GAAE,yBAAoC,EAC7C,QAAQ,GAAE,oCAA8E,GACvF,iBAAiB,EAAE,CA2BrB;AAmCD,wBAAgB,qCAAqC,CACnD,IAAI,EAAE,QAAQ,EACd,EACE,IAAI,EACJ,MAAM,EACN,OAAkB,EAClB,QAAkD,EAClD,QAAa,GACd,EAAE;IACD,IAAI,EAAE,sBAAsB,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,QAAQ,CAAC,EAAE,oCAAoC,CAAA;IAC/C,QAAQ,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CACnC,GACA,iBAAiB,EAAE,CA+CrB;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,EACpB,EACE,IAAI,EACJ,MAAM,EACN,OAAkB,EAClB,QAAkD,GACnD,EAAE;IACD,IAAI,EAAE,sBAAsB,CAAA;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,QAAQ,CAAC,EAAE,oCAAoC,CAAA;CAChD,GACA,iBAAiB,EAAE,CAsErB"}