@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/lib/floorplan/apply-alignment.test.ts

@@ -0,0 +1,25 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import useAlignmentGuides from '../../store/use-alignment-guides'
+import { applyFloorplanAlignment } from './apply-alignment'
+
+describe('applyFloorplanAlignment', () => {
+  afterEach(() => {
+    useAlignmentGuides.getState().clear()
+  })
+
+  test('can publish passive guides without applying snap', () => {
+    useAlignmentGuides.getState().clear()
+
+    const result = applyFloorplanAlignment(
+      [0.04, 2],
+      [{ nodeId: 'draft', kind: 'corner', x: 0.04, z: 2 }],
+      [{ nodeId: 'wall_a', kind: 'corner', x: 0, z: 0 }],
+      { applySnap: false },
+    )
+
+    expect(result.point).toEqual([0.04, 2])
+    expect(result.snapped).toBe(false)
+    expect(result.guides).toHaveLength(1)
+    expect(useAlignmentGuides.getState().guides).toHaveLength(1)
+  })
+})

package/src/lib/floorplan/apply-alignment.ts

@@ -2,10 +2,10 @@ import {
   type AlignmentAnchor,
   type AlignmentGuide,
   collectAlignmentAnchors,
-  resolveAlignment,
   useScene,
 } from '@pascal-app/core'
-import { useAlignmentGuides } from '@pascal-app/editor'
+import useAlignmentGuides from '../../store/use-alignment-guides'
+import { resolveAlignmentForFloorplanView } from '../world-grid-snap'
 
 /**
  * Fixed Figma-style alignment threshold (meters) for floor-plan placement /
@@ -30,9 +30,9 @@ export type FloorplanAlignmentResult = {
  *
  * Publishes guides to the `useAlignmentGuides` store as a side effect — set
  * on a match, cleared otherwise — so the mounted `FloorplanAlignmentGuideLayer`
- * renders them. Returns the adjusted point. When `bypass` is true (Alt held)
- * the point is returned unchanged and guides are cleared, matching the
- * "No snap" affordance the placement tools advertise.
+ * renders them. Returns the adjusted point. When `bypass` is true (Alt for
+ * alignment-only bypass, or Shift for the full guided-constraint bypass) the
+ * point is returned unchanged and guides are cleared.
  *
  * `candidates` should be gathered ONCE per drag (`collectAlignmentAnchors`);
  * the scene is stable during a single drag, so re-collecting per pointer-move
@@ -42,14 +42,14 @@ export function applyFloorplanAlignment(
   point: readonly [number, number],
   movingAnchors: AlignmentAnchor[],
   candidates: AlignmentAnchor[],
-  opts?: { bypass?: boolean; threshold?: number },
+  opts?: { applySnap?: boolean; bypass?: boolean; threshold?: number },
 ): FloorplanAlignmentResult {
   if (opts?.bypass) {
     useAlignmentGuides.getState().clear()
     return { point: [point[0], point[1]], snapped: false, guides: [] }
   }
 
-  const result = resolveAlignment({
+  const result = resolveAlignmentForFloorplanView({
     moving: movingAnchors,
     candidates,
     threshold: opts?.threshold ?? FLOORPLAN_ALIGNMENT_THRESHOLD_M,
@@ -57,7 +57,7 @@ export function applyFloorplanAlignment(
 
   useAlignmentGuides.getState().set(result.guides)
 
-  if (!result.snap) {
+  if (!result.snap || opts?.applySnap === false) {
     return { point: [point[0], point[1]], snapped: false, guides: result.guides }
   }
   return {
@@ -81,8 +81,9 @@ export const FLOORPLAN_DRAFT_ALIGN_ID = '__floorplan_draft__'
  *
  * Used by BOTH the move-preview branch and the click-commit handler so the
  * committed vertex lands exactly where the preview showed it. Caller owns the
- * per-kind precedence (existing-wall endpoint/join snap wins; angle-snap
- * suppresses alignment) and only calls this when alignment should apply.
+ * per-kind precedence: existing-wall endpoint/join snap can still win, while
+ * angle-locked segments can pass `applySnap: false` to publish passive guide
+ * feedback without pulling the endpoint off its constrained ray.
  *
  * `excludeIds` drops those nodes' anchors from the candidate pool — used when
  * dragging a wall / fence endpoint so the moving endpoint doesn't try to
@@ -90,7 +91,12 @@ export const FLOORPLAN_DRAFT_ALIGN_ID = '__floorplan_draft__'
  */
 export function alignFloorplanDraftPoint(
   point: readonly [number, number],
-  opts?: { bypass?: boolean; threshold?: number; excludeIds?: readonly string[] },
+  opts?: {
+    applySnap?: boolean
+    bypass?: boolean
+    threshold?: number
+    excludeIds?: readonly string[]
+  },
 ): [number, number] {
   if (opts?.bypass) {
     useAlignmentGuides.getState().clear()
@@ -105,7 +111,7 @@ export function alignFloorplanDraftPoint(
     point,
     [{ nodeId: FLOORPLAN_DRAFT_ALIGN_ID, kind: 'corner', x: point[0], z: point[1] }],
     candidates,
-    { threshold: opts?.threshold },
+    { applySnap: opts?.applySnap, threshold: opts?.threshold },
   )
   return snapped
 }

package/src/lib/floorplan/drawing-coordination.test.ts

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type ConstructionDrawingType,
+  nodeRegistry,
+  registerNode,
+} from '@pascal-app/core'
+import { z } from 'zod'
+import { resolveNodeForDrawingType } from './drawing-coordination'
+import { FLOORPLAN_NODE_EXTENSION_KEY } from './floorplan-extension'
+
+describe('resolveNodeForDrawingType', () => {
+  afterEach(() => nodeRegistry._reset())
+
+  test('dispatches drawing coordination through the registered extension', () => {
+    const node = {
+      id: 'drawing-test_main',
+      type: 'drawing-test',
+      object: 'node',
+      parentId: null,
+      visible: true,
+      metadata: {},
+    } as unknown as AnyNode
+    registerNode({
+      kind: 'drawing-test',
+      schemaVersion: 1,
+      schema: z.object({ type: z.literal('drawing-test') }) as never,
+      category: 'utility',
+      defaults: () => ({}) as never,
+      extensions: {
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+          resolveForDrawing: ({ drawingType }: { drawingType: ConstructionDrawingType }) =>
+            drawingType === 'floor-plan' ? null : node,
+        },
+      },
+    } as never)
+
+    expect(resolveNodeForDrawingType(node, { [node.id]: node }, 'floor-plan')).toBeNull()
+    expect(resolveNodeForDrawingType(node, { [node.id]: node }, 'foundation-plan')).toBe(node)
+  })
+
+  test('leaves nodes without a drawing extension unchanged', () => {
+    const node = { id: 'unknown', type: 'unknown' } as unknown as AnyNode
+    expect(resolveNodeForDrawingType(node, { [node.id]: node }, 'floor-plan')).toBe(node)
+  })
+})

package/src/lib/floorplan/drawing-coordination.ts

@@ -0,0 +1,13 @@
+import { type AnyNode, type ConstructionDrawingType, nodeRegistry } from '@pascal-app/core'
+import { getFloorplanNodeExtension } from './floorplan-extension'
+
+export function resolveNodeForDrawingType(
+  node: AnyNode,
+  nodes: Record<string, AnyNode>,
+  drawingType: ConstructionDrawingType,
+): AnyNode | null {
+  const extension = getFloorplanNodeExtension(nodeRegistry.get(node.type))
+  return extension?.resolveForDrawing
+    ? extension.resolveForDrawing({ node, nodes, drawingType })
+    : node
+}

package/src/lib/floorplan/floorplan-export.test.ts

@@ -0,0 +1,319 @@
+import { describe, expect, test } from 'bun:test'
+import type { FloorplanGeometry } from '@pascal-app/core'
+import { splitFloorplanOverlay } from '../../components/editor-2d/renderers/floorplan-registry-layer'
+import { DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY } from './annotation-visibility'
+import {
+  filterFloorplanExportOverlay,
+  fitPlanToBox,
+  isFloorplanExportAnnotationGeometry,
+  partitionFloorplanExportOverlay,
+  resolveFloorplanExportAnnotationVisibility,
+  resolveFloorplanExportNodeGeometry,
+  resolveFloorplanExportPlacement,
+  resolveFloorplanExportRotationDeg,
+  resolveFloorplanExportViewport,
+  resolveFloorplanExportViewState,
+  resolveFloorplanMeasurementSize,
+  resolveFloorplanPageLayout,
+  resolveFloorplanScreenUnitsPerPixel,
+  rotateFloorplanExportBounds,
+} from './floorplan-export'
+import { floorplanGeometryMetadata } from './floorplan-extension'
+
+describe('filterFloorplanExportOverlay', () => {
+  test('preserves annotation metadata while splitting geometry passes', () => {
+    const contextualDimension = {
+      kind: 'group',
+      metadata: floorplanGeometryMetadata({ annotationRole: 'contextual-dimension' }),
+      children: [
+        {
+          kind: 'dimension',
+          start: [0, 0],
+          end: [2, 0],
+          offsetNormal: [0, 1],
+          offsetDistance: 0.3,
+          extensionOvershoot: 0.08,
+          text: '2m',
+        },
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(splitFloorplanOverlay(contextualDimension).overlay).toMatchObject(contextualDimension)
+  })
+
+  test('preserves value labels and removes editing handles', () => {
+    const label = {
+      kind: 'dimension-label',
+      appearance: 'outlined',
+      cx: 1,
+      cy: 0,
+      text: '2.00m',
+      angle: 0,
+    } satisfies FloorplanGeometry
+    const overlay = {
+      kind: 'group',
+      children: [
+        label,
+        {
+          kind: 'endpoint-handle',
+          point: [0, 0],
+          state: 'idle',
+          affordance: 'move-measurement-vertex',
+          payload: { vertexIndex: 0 },
+        },
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(filterFloorplanExportOverlay(overlay)).toEqual({
+      kind: 'group',
+      children: [label],
+    })
+  })
+
+  test('preserves wall, door, and window shapes used as annotation obstacles', () => {
+    const fixedGeometry = {
+      kind: 'group',
+      children: [
+        {
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [4, 0],
+            [4, 0.2],
+            [0, 0.2],
+          ],
+          fill: '#374151',
+          stroke: '#1f2937',
+          metadata: floorplanGeometryMetadata({ annotationObstacle: 'outline' }),
+        },
+        {
+          kind: 'path',
+          d: 'M 1 0 A 1 1 0 0 1 2 1',
+          fill: 'none',
+          stroke: '#64748b',
+          metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+        },
+        {
+          kind: 'line',
+          x1: 2.5,
+          y1: 0,
+          x2: 3.5,
+          y2: 0,
+          stroke: '#1f2937',
+          metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+        },
+        { kind: 'move-handle', point: [2, 0.1] },
+      ],
+    } satisfies FloorplanGeometry
+
+    const { overlay } = splitFloorplanOverlay(fixedGeometry)
+    expect(overlay).not.toBeNull()
+    expect(filterFloorplanExportOverlay(overlay!)).toEqual({
+      kind: 'group',
+      children: fixedGeometry.children.slice(0, 3),
+      transform: undefined,
+    })
+  })
+
+  test('keeps structural obstacles in model bounds while leaving marks as annotations', () => {
+    const wall = {
+      kind: 'polygon',
+      points: [
+        [0, 0],
+        [4, 0],
+        [4, 0.2],
+        [0, 0.2],
+      ],
+      fill: '#374151',
+      metadata: floorplanGeometryMetadata({ annotationObstacle: 'outline' }),
+    } satisfies FloorplanGeometry
+    const openingMark = {
+      kind: 'group',
+      metadata: floorplanGeometryMetadata({ annotationRole: 'opening-mark' }),
+      children: [
+        {
+          kind: 'rect',
+          x: 1,
+          y: 1,
+          width: 0.4,
+          height: 0.2,
+          fill: '#ffffff',
+          stroke: '#334155',
+        },
+        { kind: 'text', x: 1.2, y: 1.1, text: 'W01', fontSize: 0.1, upright: true },
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(
+      partitionFloorplanExportOverlay({ kind: 'group', children: [wall, openingMark] }),
+    ).toEqual({
+      model: { kind: 'group', children: [wall], transform: undefined },
+      annotations: { kind: 'group', children: [openingMark], transform: undefined },
+    })
+  })
+
+  test('moves automatic dimensions embedded in base wall geometry into the PDF annotation layer', () => {
+    const wall = {
+      kind: 'polygon',
+      points: [
+        [0, 0],
+        [4, 0],
+        [4, 0.2],
+        [0, 0.2],
+      ],
+      fill: '#374151',
+    } satisfies FloorplanGeometry
+    const dimensions = {
+      kind: 'dimension-string',
+      segments: [{ start: [0, 0], end: [4, 0], text: '4m' }],
+      offsetNormal: [0, -1],
+      offsetDistance: 1,
+      extensionOvershoot: 0.12,
+    } satisfies FloorplanGeometry
+
+    expect(
+      resolveFloorplanExportNodeGeometry(
+        { kind: 'group', children: [wall, dimensions] },
+        null,
+        false,
+      ),
+    ).toEqual({
+      model: { kind: 'group', children: [wall], transform: undefined },
+      annotations: { kind: 'group', children: [dimensions], transform: undefined },
+    })
+  })
+})
+
+describe('fitPlanToBox', () => {
+  test('preserves aspect ratio and centers the plan', () => {
+    expect(fitPlanToBox(20, 10, 10, 20, 400, 300)).toEqual({
+      x: 10,
+      y: 70,
+      width: 400,
+      height: 200,
+    })
+  })
+})
+
+describe('floor plan export policy', () => {
+  test('uses the live floor-plan formatting profile for metric and imperial dimensions', () => {
+    expect(resolveFloorplanExportViewState('metric', 'millimeters')).toMatchObject({
+      purpose: 'edit',
+      unit: 'metric',
+      metricNotation: 'millimeters',
+    })
+    expect(resolveFloorplanExportViewState('imperial', 'meters')).toMatchObject({
+      purpose: 'edit',
+      unit: 'imperial',
+      metricNotation: 'meters',
+    })
+  })
+
+  test('fits an oversized plan inside the complete export viewport', () => {
+    const placement = resolveFloorplanExportPlacement(30, 20, 10, 20, 400, 300)
+
+    expect(placement.x).toBe(10)
+    expect(placement.y).toBeCloseTo(36.67, 2)
+    expect(placement.width).toBe(400)
+    expect(placement.height).toBeCloseTo(266.67, 2)
+    expect(placement.x).toBeGreaterThanOrEqual(10)
+    expect(placement.y).toBeGreaterThanOrEqual(20)
+    expect(placement.x + placement.width).toBeLessThanOrEqual(410)
+    expect(placement.y + placement.height).toBeLessThanOrEqual(320)
+  })
+
+  test('exports the same annotation categories that are visible in the live view', () => {
+    const liveVisibility = {
+      automaticDimensions: true,
+      contextualDimensions: false,
+      manualDimensions: false,
+      measurements: true,
+      openingMarks: true,
+      structuralGrids: false,
+      roomLabels: false,
+      stairAnnotations: true,
+    }
+
+    expect(resolveFloorplanExportAnnotationVisibility('expert', liveVisibility)).toEqual(
+      liveVisibility,
+    )
+  })
+
+  test('exports only model geometry and room labels in Default', () => {
+    expect(
+      resolveFloorplanExportAnnotationVisibility(
+        'default',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+      ),
+    ).toEqual({
+      automaticDimensions: false,
+      contextualDimensions: false,
+      manualDimensions: false,
+      measurements: false,
+      openingMarks: false,
+      structuralGrids: false,
+      roomLabels: true,
+      stairAnnotations: false,
+    })
+  })
+
+  test('matches live screen sizing to the fitted export viewport', () => {
+    expect(resolveFloorplanScreenUnitsPerPixel(7, 4.5, 572, 463)).toBeCloseTo(0.012_237_762, 8)
+  })
+
+  test('keeps the export viewport anchored to the structural drawing bounds', () => {
+    expect(resolveFloorplanExportViewport({ x: -5, y: -6, width: 13, height: 13.5 })).toEqual({
+      x: -7.7,
+      y: -8.7,
+      width: 18.4,
+      height: 18.9,
+    })
+  })
+
+  test('fits the viewport around the rotated plan instead of clipping its corners', () => {
+    const bounds = rotateFloorplanExportBounds({ x: 0, y: 0, width: 10, height: 5 }, 90)
+
+    expect(bounds.x).toBeCloseTo(-5, 8)
+    expect(bounds.y).toBeCloseTo(0, 8)
+    expect(bounds.width).toBeCloseTo(5, 8)
+    expect(bounds.height).toBeCloseTo(10, 8)
+  })
+
+  test('keeps annotation-only nodes out of primary model bounds', () => {
+    expect(
+      isFloorplanExportAnnotationGeometry({
+        kind: 'group',
+        children: [],
+        metadata: { 'pascal:editor/floorplan': { annotationRole: 'measurement' } },
+      }),
+    ).toBe(true)
+    expect(
+      isFloorplanExportAnnotationGeometry({
+        kind: 'group',
+        children: [],
+        metadata: { 'pascal:editor/floorplan': { annotationRole: 'manual-dimension' } },
+      }),
+    ).toBe(true)
+    expect(isFloorplanExportAnnotationGeometry({ kind: 'polygon', points: [] })).toBe(false)
+  })
+
+  test('matches the current floor-plan rotation instead of forcing north-up', () => {
+    expect(resolveFloorplanExportRotationDeg(Math.PI / 6, Math.PI / 2)).toBeCloseTo(60, 8)
+  })
+})
+
+describe('resolveFloorplanMeasurementSize', () => {
+  test('sizes the hidden SVG in screen pixels before resolving label collisions', () => {
+    expect(
+      resolveFloorplanMeasurementSize({ x: -2, y: -3, width: 18.4, height: 18.9 }, 0.024),
+    ).toEqual({ width: 18.4 / 0.024, height: 18.9 / 0.024 })
+  })
+})
+
+describe('resolveFloorplanPageLayout', () => {
+  test('uses the available A4 page area for the fitted plan', () => {
+    expect(resolveFloorplanPageLayout(842, 595)).toEqual({
+      planBox: { x: 36, y: 64, width: 770, height: 495 },
+    })
+  })
+})