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

package/src/lib/elevation-guides.ts

@@ -0,0 +1,236 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  getWallBaseElevationForNodes,
+  getWallEffectiveHeightForNodes,
+  resolveCeilingHeight,
+} from '@pascal-app/core'
+import useElevationGuides from '../store/use-elevation-guides'
+
+export const ELEVATION_ALIGNMENT_THRESHOLD_M = 0.08
+const GUIDE_MATCH_EPSILON_M = 1e-4
+
+export type ElevationGuideSource = {
+  nodeId: string
+  levelId: string | null | undefined
+  anchor: readonly [number, number]
+}
+
+export type ElevationSnapTarget = {
+  id: string
+  elevation: number
+  anchor: readonly [number, number]
+  label: string
+}
+
+export type ElevationSnapMatch = {
+  target: ElevationSnapTarget
+  elevation: number
+}
+
+function polygonCenter(polygon: ReadonlyArray<readonly [number, number]>): [number, number] {
+  if (polygon.length === 0) return [0, 0]
+  let x = 0
+  let z = 0
+  for (const point of polygon) {
+    x += point[0]
+    z += point[1]
+  }
+  return [x / polygon.length, z / polygon.length]
+}
+
+function segmentCenter(
+  start: readonly [number, number],
+  end: readonly [number, number],
+): [number, number] {
+  return [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2]
+}
+
+function fenceBaseElevation(node: AnyNode, nodes: Record<string, AnyNode>): number {
+  if (node.type !== 'fence') return 0
+  const host = node.supportSlabId ? nodes[node.supportSlabId as AnyNodeId] : undefined
+  const hostElevation =
+    host?.type === 'slab' && (host.parentId ?? null) === (node.parentId ?? null)
+      ? (host.elevation ?? 0)
+      : 0
+  return hostElevation + (node.supportOffset ?? 0)
+}
+
+/**
+ * Structural Y datums on the source node's level. This is editor-runtime
+ * collection over authoritative vertical resolvers; matching remains a pure
+ * scalar operation in {@link resolveElevationSnapMatch}.
+ */
+export function collectElevationSnapTargets(
+  source: ElevationGuideSource,
+  nodes: Record<string, AnyNode>,
+): ElevationSnapTarget[] {
+  if (!source.levelId) return []
+
+  const targets: ElevationSnapTarget[] = [
+    {
+      id: `${source.levelId}:level`,
+      elevation: 0,
+      anchor: source.anchor,
+      label: 'Level',
+    },
+  ]
+  const level = nodes[source.levelId as AnyNodeId]
+  if (level?.type !== 'level') return targets
+
+  for (const childId of level.children) {
+    if (childId === source.nodeId) continue
+    const node = nodes[childId as AnyNodeId]
+    if (!node) continue
+
+    if (node.type === 'slab') {
+      const center = polygonCenter(node.polygon)
+      const top = node.elevation ?? 0.05
+      targets.push({
+        id: `${node.id}:top`,
+        elevation: top,
+        anchor: center,
+        label: 'Slab top',
+      })
+      if (!node.recessed) {
+        targets.push({
+          id: `${node.id}:base`,
+          elevation: top - (node.thickness ?? 0.05),
+          anchor: center,
+          label: 'Slab underside',
+        })
+      }
+      continue
+    }
+
+    if (node.type === 'ceiling') {
+      targets.push({
+        id: `${node.id}:ceiling`,
+        elevation: resolveCeilingHeight(node, nodes as Record<AnyNodeId, AnyNode>),
+        anchor: polygonCenter(node.polygon),
+        label: 'Ceiling',
+      })
+      continue
+    }
+
+    if (node.type === 'wall') {
+      const base = getWallBaseElevationForNodes(node, nodes)
+      const center = segmentCenter(node.start, node.end)
+      targets.push({
+        id: `${node.id}:base`,
+        elevation: base,
+        anchor: center,
+        label: 'Wall base',
+      })
+      targets.push({
+        id: `${node.id}:top`,
+        elevation: base + getWallEffectiveHeightForNodes(node, nodes),
+        anchor: center,
+        label: 'Wall top',
+      })
+      continue
+    }
+
+    if (node.type === 'fence') {
+      const base = fenceBaseElevation(node, nodes)
+      const center = segmentCenter(node.start, node.end)
+      targets.push({
+        id: `${node.id}:base`,
+        elevation: base,
+        anchor: center,
+        label: 'Fence base',
+      })
+      targets.push({
+        id: `${node.id}:top`,
+        elevation: base + (node.height ?? 1.8),
+        anchor: center,
+        label: 'Fence top',
+      })
+    }
+  }
+
+  return targets
+}
+
+export function resolveElevationSnapMatch(
+  proposedElevation: number,
+  sourceAnchor: readonly [number, number],
+  targets: readonly ElevationSnapTarget[],
+  threshold = ELEVATION_ALIGNMENT_THRESHOLD_M,
+): ElevationSnapMatch | null {
+  let best: ElevationSnapTarget | null = null
+  let bestDelta = Number.POSITIVE_INFINITY
+  let bestPlanDistance = Number.POSITIVE_INFINITY
+
+  for (const target of targets) {
+    const delta = Math.abs(target.elevation - proposedElevation)
+    if (delta > threshold) continue
+    const dx = target.anchor[0] - sourceAnchor[0]
+    const dz = target.anchor[1] - sourceAnchor[1]
+    const planDistance = dx * dx + dz * dz
+    if (
+      delta < bestDelta - 1e-9 ||
+      (Math.abs(delta - bestDelta) <= 1e-9 && planDistance < bestPlanDistance)
+    ) {
+      best = target
+      bestDelta = delta
+      bestPlanDistance = planDistance
+    }
+  }
+
+  return best ? { target: best, elevation: best.elevation } : null
+}
+
+export function resolveStructuralElevationSnap(
+  source: ElevationGuideSource,
+  proposedElevation: number,
+  nodes: Record<string, AnyNode>,
+): number {
+  return (
+    resolveElevationSnapMatch(
+      proposedElevation,
+      source.anchor,
+      collectElevationSnapTargets(source, nodes),
+    )?.elevation ?? proposedElevation
+  )
+}
+
+export function publishStructuralElevationGuide(
+  source: ElevationGuideSource,
+  elevation: number,
+  nodes: Record<string, AnyNode>,
+): void {
+  if (!source.levelId) {
+    clearStructuralElevationGuide(source.nodeId)
+    return
+  }
+
+  const match = resolveElevationSnapMatch(
+    elevation,
+    source.anchor,
+    collectElevationSnapTargets(source, nodes),
+    GUIDE_MATCH_EPSILON_M,
+  )
+  if (!match) {
+    clearStructuralElevationGuide(source.nodeId)
+    return
+  }
+
+  const dx = match.target.anchor[0] - source.anchor[0]
+  const dz = match.target.anchor[1] - source.anchor[1]
+  const length = Math.hypot(dx, dz)
+  const direction: [number, number] = length > 1e-6 ? [dx / length, dz / length] : [1, 0]
+
+  useElevationGuides.getState().publish({
+    ownerId: source.nodeId,
+    levelId: source.levelId,
+    center: source.anchor,
+    direction,
+    elevation: match.elevation,
+    label: match.target.label,
+  })
+}
+
+export function clearStructuralElevationGuide(ownerId: string): void {
+  useElevationGuides.getState().clear(ownerId)
+}

package/src/lib/floorplan/annotation-visibility.test.ts

@@ -0,0 +1,327 @@
+import { describe, expect, test } from 'bun:test'
+import type { FloorplanGeometry } from '@pascal-app/core'
+import {
+  DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+  filterFloorplanAnnotationGeometry,
+  normalizeFloorplanAnnotationVisibility,
+} from './annotation-visibility'
+import { floorplanGeometryMetadata, withFloorplanGeometryMetadata } from './floorplan-extension'
+
+describe('floor-plan annotation visibility', () => {
+  test('fills missing persisted categories with visible defaults', () => {
+    expect(normalizeFloorplanAnnotationVisibility({ measurements: false })).toEqual({
+      ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+      measurements: false,
+    })
+  })
+
+  test('removes automatic dimension primitives without removing plan geometry', () => {
+    const line = { kind: 'line', x1: 0, y1: 0, x2: 2, y2: 0 } satisfies FloorplanGeometry
+    const geometry = {
+      kind: 'group',
+      children: [
+        line,
+        {
+          kind: 'dimension-string',
+          segments: [{ start: [0, 0], end: [2, 0], text: '2.00m' }],
+          offsetNormal: [0, 1],
+          offsetDistance: 0.3,
+          extensionOvershoot: 0.1,
+        },
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(geometry, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        automaticDimensions: false,
+      }),
+    ).toEqual({ kind: 'group', children: [line] })
+  })
+
+  test('removes a complete curved automatic dimension group', () => {
+    const curvedDimension = {
+      kind: 'group',
+      metadata: floorplanGeometryMetadata({ annotationRole: 'automatic-dimension' }),
+      children: [
+        { kind: 'line', x1: 0, y1: 0, x2: 2, y2: 2 },
+        { kind: 'dimension-label', cx: 1, cy: 1, text: 'R 2m', angle: 0 },
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(curvedDimension, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        automaticDimensions: false,
+      }),
+    ).toBeNull()
+  })
+
+  test('removes only the opening mark from door geometry', () => {
+    const body = {
+      kind: 'polygon',
+      points: [
+        [0, 0],
+        [1, 0],
+        [1, 0.1],
+      ],
+    } satisfies FloorplanGeometry
+    const mark = {
+      kind: 'group',
+      metadata: floorplanGeometryMetadata({ annotationRole: 'opening-mark' }),
+      children: [
+        { kind: 'line', x1: 0.5, y1: 0, x2: 0.5, y2: 0.5 },
+        { kind: 'rect', x: 0.3, y: 0.5, width: 0.4, height: 0.3 },
+        { kind: 'text', x: 0.5, y: 0.65, text: '101', fontSize: 0.15, upright: true },
+      ],
+    } satisfies FloorplanGeometry
+    const geometry = { kind: 'group', children: [body, mark] } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(geometry, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        openingMarks: false,
+      }),
+    ).toEqual({ kind: 'group', children: [body] })
+  })
+
+  test('hides manual dimensions and measurements independently', () => {
+    const manualDimension = {
+      kind: 'text',
+      x: 0,
+      y: 0,
+      text: 'Annotation',
+      fontSize: 0.15,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'manual-dimension' }),
+    } satisfies FloorplanGeometry
+    const measurement = {
+      ...manualDimension,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'measurement' }),
+    } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(manualDimension, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        manualDimensions: false,
+      }),
+    ).toBeNull()
+    expect(
+      filterFloorplanAnnotationGeometry(
+        {
+          kind: 'group',
+          metadata: floorplanGeometryMetadata({ annotationRole: 'manual-dimension' }),
+          children: [
+            {
+              kind: 'dimension',
+              start: [0, 0],
+              end: [1, 0],
+              offsetNormal: [0, 1],
+              offsetDistance: 0.5,
+              extensionOvershoot: 0.1,
+              text: '1m',
+            },
+          ],
+        },
+        {
+          ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+          automaticDimensions: false,
+        },
+      ),
+    ).not.toBeNull()
+    expect(
+      filterFloorplanAnnotationGeometry(measurement, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        measurements: false,
+      }),
+    ).toBeNull()
+  })
+
+  test('keeps a contextual dimension when automatic dimensions are hidden', () => {
+    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(
+      filterFloorplanAnnotationGeometry(contextualDimension, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        automaticDimensions: false,
+        contextualDimensions: true,
+      }),
+    ).toEqual(contextualDimension)
+  })
+
+  test('removes a nested automatic wall string beside a contextual dimension', () => {
+    const wallBody = {
+      kind: 'polygon',
+      points: [
+        [0, 0],
+        [0.2, 0],
+        [0.2, 6],
+        [0, 6],
+      ],
+    } satisfies FloorplanGeometry
+    const automaticDimension = {
+      kind: 'dimension-string',
+      segments: [{ start: [0, 0], end: [0, 18], text: '18m' }],
+      offsetNormal: [1, 0],
+      offsetDistance: 0.55,
+      extensionOvershoot: 0.12,
+    } satisfies FloorplanGeometry
+    const contextualDimension = withFloorplanGeometryMetadata(
+      {
+        kind: 'dimension',
+        start: [0, 0],
+        end: [0, 6],
+        offsetNormal: [1, 0],
+        offsetDistance: 0.34,
+        extensionOvershoot: 0.08,
+        text: '6m',
+      } satisfies FloorplanGeometry,
+      { annotationRole: 'contextual-dimension' },
+    )
+    const geometry = {
+      kind: 'group',
+      children: [
+        {
+          kind: 'group',
+          children: [wallBody, automaticDimension],
+        },
+        contextualDimension,
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(geometry, {
+        ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        automaticDimensions: false,
+        contextualDimensions: true,
+      }),
+    ).toEqual({
+      kind: 'group',
+      children: [{ kind: 'group', children: [wallBody] }, contextualDimension],
+    })
+  })
+
+  test('hides structural grids and only the center marks within column geometry', () => {
+    const centerMark = {
+      kind: 'line',
+      x1: -0.1,
+      y1: -0.1,
+      x2: 0.1,
+      y2: 0.1,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
+    } satisfies FloorplanGeometry
+    const gridReference = {
+      kind: 'text',
+      x: 0,
+      y: 0.3,
+      text: 'B-2',
+      fontSize: 0.13,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
+    } satisfies FloorplanGeometry
+    const footprint = {
+      kind: 'rect',
+      x: -0.2,
+      y: -0.2,
+      width: 0.4,
+      height: 0.4,
+    } satisfies FloorplanGeometry
+    const visibility = {
+      ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+      structuralGrids: false,
+    }
+
+    expect(
+      filterFloorplanAnnotationGeometry(
+        {
+          kind: 'group',
+          children: [footprint, centerMark, gridReference],
+        },
+        visibility,
+      ),
+    ).toEqual({ kind: 'group', children: [footprint] })
+    expect(
+      filterFloorplanAnnotationGeometry(
+        {
+          kind: 'group',
+          metadata: floorplanGeometryMetadata({ annotationRole: 'structural-grid' }),
+          children: [footprint],
+        },
+        visibility,
+      ),
+    ).toBeNull()
+  })
+
+  test('hides room labels without removing the room footprint', () => {
+    const footprint = {
+      kind: 'polygon',
+      points: [
+        [0, 0],
+        [4, 0],
+        [4, 3],
+      ],
+    } satisfies FloorplanGeometry
+    const roomName = {
+      kind: 'text',
+      x: 2,
+      y: 1.5,
+      text: 'Office',
+      fontSize: 0.2,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'room-label' }),
+    } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(
+        { kind: 'group', children: [footprint, roomName] },
+        { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, roomLabels: false },
+      ),
+    ).toEqual({ kind: 'group', children: [footprint] })
+  })
+
+  test('hides stair notes and break lines without removing stair geometry', () => {
+    const footprint = {
+      kind: 'polygon',
+      points: [
+        [0, 0],
+        [1, 0],
+        [1, 3],
+        [0, 3],
+      ],
+    } satisfies FloorplanGeometry
+    const direction = {
+      kind: 'text',
+      x: 0.5,
+      y: 0.5,
+      text: 'UP',
+      fontSize: 0.16,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
+    } satisfies FloorplanGeometry
+    const breakLine = {
+      kind: 'polyline',
+      points: [
+        [0, 2],
+        [1, 2],
+      ],
+      metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
+    } satisfies FloorplanGeometry
+
+    expect(
+      filterFloorplanAnnotationGeometry(
+        { kind: 'group', children: [footprint, direction, breakLine] },
+        { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, stairAnnotations: false },
+      ),
+    ).toEqual({ kind: 'group', children: [footprint] })
+  })
+})

package/src/lib/floorplan/annotation-visibility.ts

@@ -0,0 +1,133 @@
+import type { FloorplanGeometry } from '@pascal-app/core'
+import { type FloorplanAnnotationRole, readFloorplanGeometryMetadata } from './floorplan-extension'
+
+export type FloorplanAnnotationCategory =
+  | 'automaticDimensions'
+  | 'contextualDimensions'
+  | 'manualDimensions'
+  | 'measurements'
+  | 'openingMarks'
+  | 'structuralGrids'
+  | 'roomLabels'
+  | 'stairAnnotations'
+
+export type FloorplanAnnotationVisibility = Record<FloorplanAnnotationCategory, boolean>
+
+export const DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY: FloorplanAnnotationVisibility = {
+  automaticDimensions: true,
+  contextualDimensions: false,
+  manualDimensions: true,
+  measurements: true,
+  openingMarks: true,
+  structuralGrids: true,
+  roomLabels: true,
+  stairAnnotations: true,
+}
+
+export function revealFloorplanAnnotationRole(
+  visibility: FloorplanAnnotationVisibility,
+  role: FloorplanAnnotationRole,
+): FloorplanAnnotationVisibility {
+  const category = annotationCategoryForRole(role)
+  return visibility[category] ? visibility : { ...visibility, [category]: true }
+}
+
+export function normalizeFloorplanAnnotationVisibility(
+  value: unknown,
+): FloorplanAnnotationVisibility {
+  if (!value || typeof value !== 'object') return { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY }
+  const persisted = value as Partial<Record<FloorplanAnnotationCategory, unknown>>
+  return {
+    automaticDimensions:
+      typeof persisted.automaticDimensions === 'boolean'
+        ? persisted.automaticDimensions
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.automaticDimensions,
+    contextualDimensions:
+      typeof persisted.contextualDimensions === 'boolean'
+        ? persisted.contextualDimensions
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.contextualDimensions,
+    manualDimensions:
+      typeof persisted.manualDimensions === 'boolean'
+        ? persisted.manualDimensions
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.manualDimensions,
+    measurements:
+      typeof persisted.measurements === 'boolean'
+        ? persisted.measurements
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.measurements,
+    openingMarks:
+      typeof persisted.openingMarks === 'boolean'
+        ? persisted.openingMarks
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.openingMarks,
+    structuralGrids:
+      typeof persisted.structuralGrids === 'boolean'
+        ? persisted.structuralGrids
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.structuralGrids,
+    roomLabels:
+      typeof persisted.roomLabels === 'boolean'
+        ? persisted.roomLabels
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.roomLabels,
+    stairAnnotations:
+      typeof persisted.stairAnnotations === 'boolean'
+        ? persisted.stairAnnotations
+        : DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY.stairAnnotations,
+  }
+}
+
+export function filterFloorplanAnnotationGeometry(
+  geometry: FloorplanGeometry,
+  visibility: FloorplanAnnotationVisibility,
+  inheritedRole?: FloorplanAnnotationRole,
+): FloorplanGeometry | null {
+  const role = readFloorplanGeometryMetadata(geometry).annotationRole ?? inheritedRole
+  if (role && !isAnnotationRoleVisible(role, visibility)) return null
+  if (
+    !visibility.automaticDimensions &&
+    (role === undefined || role === 'automatic-dimension') &&
+    (geometry.kind === 'dimension' ||
+      geometry.kind === 'dimension-string' ||
+      geometry.kind === 'dimension-label' ||
+      geometry.kind === 'equal-spacing-badge')
+  ) {
+    return null
+  }
+  if (geometry.kind !== 'group') return geometry
+
+  const children = geometry.children
+    .map((child) => filterFloorplanAnnotationGeometry(child, visibility, role))
+    .filter((child): child is FloorplanGeometry => child !== null)
+  if (children.length === 0) return null
+  const childrenUnchanged =
+    children.length === geometry.children.length &&
+    children.every((child, index) => child === geometry.children[index])
+  if (childrenUnchanged) return geometry
+  return { ...geometry, children }
+}
+
+function isAnnotationRoleVisible(
+  role: FloorplanAnnotationRole,
+  visibility: FloorplanAnnotationVisibility,
+): boolean {
+  return visibility[annotationCategoryForRole(role)]
+}
+
+function annotationCategoryForRole(role: FloorplanAnnotationRole): FloorplanAnnotationCategory {
+  switch (role) {
+    case 'automatic-dimension':
+      return 'automaticDimensions'
+    case 'contextual-dimension':
+      return 'contextualDimensions'
+    case 'manual-dimension':
+      return 'manualDimensions'
+    case 'measurement':
+      return 'measurements'
+    case 'opening-mark':
+      return 'openingMarks'
+    case 'structural-grid':
+    case 'column-center':
+      return 'structuralGrids'
+    case 'room-label':
+      return 'roomLabels'
+    case 'stair-annotation':
+      return 'stairAnnotations'
+  }
+}