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

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from 'bun:test'
+import type { GeometryContext } from '@pascal-app/core'
+import {
+  createFloorplanContextExtensions,
+  normalizeFloorplanWallDimensionReference,
+  readFloorplanContext,
+} from './floorplan-extension'
+
+function context(extensions?: Readonly<Record<string, unknown>>): GeometryContext {
+  return {
+    resolve: () => undefined,
+    children: [],
+    siblings: [],
+    parent: null,
+    extensions,
+  }
+}
+
+describe('floor-plan context extensions', () => {
+  test('defaults wall dimensions to finished faces', () => {
+    expect(readFloorplanContext(context()).wallDimensionReference).toBe('finished-faces')
+  })
+
+  test('carries the selected centerline or stud-face reference', () => {
+    for (const wallDimensionReference of ['centerline', 'stud-faces'] as const) {
+      const extensions = createFloorplanContextExtensions({ wallDimensionReference })
+      expect(readFloorplanContext(context(extensions)).wallDimensionReference).toBe(
+        wallDimensionReference,
+      )
+    }
+  })
+
+  test('normalizes stale persisted references to the finished-face default', () => {
+    expect(normalizeFloorplanWallDimensionReference('unknown')).toBe('finished-faces')
+    expect(normalizeFloorplanWallDimensionReference(null)).toBe('finished-faces')
+  })
+
+  test('lets presentation code suppress automatic annotation construction', () => {
+    expect(readFloorplanContext(context()).automaticDimensions).toBe(true)
+    const extensions = createFloorplanContextExtensions({ automaticDimensions: false })
+    expect(readFloorplanContext(context(extensions)).automaticDimensions).toBe(false)
+  })
+})

package/src/lib/floorplan/floorplan-extension.ts

@@ -0,0 +1,181 @@
+import type {
+  AnyNode,
+  AnyNodeId,
+  ConstructionDrawingType,
+  FloorplanGeometry,
+  GeometryContext,
+  NodeDefinition,
+  SceneApi,
+} from '@pascal-app/core'
+import type { ComponentType } from 'react'
+
+export const FLOORPLAN_NODE_EXTENSION_KEY = 'pascal:editor/floorplan'
+export const FLOORPLAN_GEOMETRY_METADATA_KEY = 'pascal:editor/floorplan'
+export const FLOORPLAN_CONTEXT_EXTENSION_KEY = 'pascal:editor/floorplan'
+
+export type FloorplanRenderPurpose = 'edit' | 'document'
+export type FloorplanMetricNotation = 'meters' | 'millimeters'
+export type FloorplanToolMode = 'default' | 'expert'
+export type FloorplanWallDimensionReference = 'finished-faces' | 'centerline' | 'stud-faces'
+export const DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE = 'finished-faces'
+export type FloorplanAnnotationRole =
+  | 'automatic-dimension'
+  | 'contextual-dimension'
+  | 'manual-dimension'
+  | 'measurement'
+  | 'opening-mark'
+  | 'structural-grid'
+  | 'column-center'
+  | 'room-label'
+  | 'stair-annotation'
+
+export type FloorplanSchedule = {
+  id: string
+  title: string
+  columns: ReadonlyArray<{
+    key: string
+    label: string
+    weight?: number
+  }>
+  rows: ReadonlyArray<{
+    id: string
+    cells: Readonly<Record<string, string>>
+  }>
+  issues?: readonly string[]
+}
+
+export type FloorplanToolContext = {
+  sceneApi: SceneApi
+  activeLevelId: AnyNodeId | null
+  unit: 'metric' | 'imperial'
+  metricNotation: FloorplanMetricNotation
+  gridSnapStep: number
+  toolDefaults: Readonly<Record<string, unknown>> | null
+  selectNode: (id: AnyNodeId) => void
+  finishTool: () => void
+}
+
+export type FloorplanNodeExtension<N extends AnyNode = AnyNode> = {
+  tool?: () => Promise<{ default: ComponentType<FloorplanToolContext> }>
+  availableModes?: readonly FloorplanToolMode[]
+  preferredView?: '2d' | '3d'
+  referencedSelectionAnnotationRole?: FloorplanAnnotationRole
+  contextualDimensions?: (node: N, ctx: GeometryContext) => FloorplanGeometry | null
+  actionMenu?: {
+    canCurve?: (args: { node: N; nodes: Readonly<Record<AnyNodeId, AnyNode>> }) => boolean
+  }
+  schedule?: (args: {
+    siblings: ReadonlyArray<N>
+    nodes: Readonly<Record<string, AnyNode>>
+    levelId: AnyNodeId
+    unit: 'metric' | 'imperial'
+  }) => FloorplanSchedule | null
+  linkedLevelIds?: (node: N) => readonly AnyNodeId[]
+  resolveForDrawing?: (args: {
+    node: N
+    nodes: Record<string, AnyNode>
+    drawingType: ConstructionDrawingType
+  }) => AnyNode | null
+}
+
+type FloorplanGeometryMetadata = {
+  annotationRole?: FloorplanAnnotationRole
+  annotationObstacle?: 'bounds' | 'outline'
+  renderPass?: 'overlay'
+}
+
+type FloorplanContextExtension = {
+  automaticDimensions: boolean
+  purpose: FloorplanRenderPurpose
+  metricNotation: FloorplanMetricNotation
+  wallDimensionReference: FloorplanWallDimensionReference
+}
+
+export function normalizeFloorplanWallDimensionReference(
+  value: unknown,
+): FloorplanWallDimensionReference {
+  return value === 'centerline' || value === 'stud-faces'
+    ? value
+    : DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE
+}
+
+export function getFloorplanNodeExtension(
+  definition: NodeDefinition<any> | undefined,
+): FloorplanNodeExtension | undefined {
+  return definition?.extensions?.[FLOORPLAN_NODE_EXTENSION_KEY] as
+    | FloorplanNodeExtension
+    | undefined
+}
+
+export function floorplanGeometryMetadata(
+  values: FloorplanGeometryMetadata,
+): Readonly<Record<string, unknown>> {
+  return { [FLOORPLAN_GEOMETRY_METADATA_KEY]: values }
+}
+
+export function withFloorplanGeometryMetadata<T extends FloorplanGeometry | null>(
+  geometry: T,
+  values: FloorplanGeometryMetadata,
+): T {
+  if (!geometry) return geometry
+  const existing = readFloorplanGeometryMetadata(geometry)
+  return {
+    ...geometry,
+    metadata: floorplanGeometryMetadata({ ...existing, ...values }),
+  } as T
+}
+
+export function readFloorplanGeometryMetadata(geometry: unknown): FloorplanGeometryMetadata {
+  const metadata = (geometry as { metadata?: Readonly<Record<string, unknown>> } | null)?.metadata
+  const value = metadata?.[FLOORPLAN_GEOMETRY_METADATA_KEY]
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as FloorplanGeometryMetadata)
+    : {}
+}
+
+export function createFloorplanContextExtensions(
+  values: Partial<FloorplanContextExtension>,
+): Readonly<Record<string, unknown>> {
+  return {
+    [FLOORPLAN_CONTEXT_EXTENSION_KEY]: {
+      automaticDimensions: values.automaticDimensions !== false,
+      purpose: values.purpose === 'document' ? 'document' : 'edit',
+      metricNotation: values.metricNotation === 'millimeters' ? 'millimeters' : 'meters',
+      wallDimensionReference: normalizeFloorplanWallDimensionReference(
+        values.wallDimensionReference,
+      ),
+    } satisfies FloorplanContextExtension,
+  }
+}
+
+export function readFloorplanContext(ctx: GeometryContext): FloorplanContextExtension {
+  const value = ctx.extensions?.[FLOORPLAN_CONTEXT_EXTENSION_KEY]
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const extension = value as Partial<FloorplanContextExtension>
+    return {
+      automaticDimensions: extension.automaticDimensions !== false,
+      purpose: extension.purpose === 'document' ? 'document' : 'edit',
+      metricNotation: extension.metricNotation === 'millimeters' ? 'millimeters' : 'meters',
+      wallDimensionReference: normalizeFloorplanWallDimensionReference(
+        extension.wallDimensionReference,
+      ),
+    }
+  }
+  return {
+    automaticDimensions: true,
+    purpose: 'edit',
+    metricNotation: 'meters',
+    wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+  }
+}
+
+export function readFloorplanMetricNotationOverride(
+  ctx: GeometryContext,
+): FloorplanMetricNotation | undefined {
+  const value = ctx.extensions?.[FLOORPLAN_CONTEXT_EXTENSION_KEY]
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const metricNotation = (value as { metricNotation?: unknown }).metricNotation
+  return metricNotation === 'meters' || metricNotation === 'millimeters'
+    ? metricNotation
+    : undefined
+}

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

@@ -0,0 +1,120 @@
+import { describe, expect, test } from 'bun:test'
+import { DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY } from './annotation-visibility'
+import {
+  isFloorplanToolAvailableInMode,
+  normalizeFloorplanMode,
+  normalizeFloorplanModesByProject,
+  resolveFloorplanAnnotationVisibility,
+  resolveFloorplanWallDimensionReference,
+} from './floorplan-mode'
+
+describe('floor-plan mode', () => {
+  test('defaults unknown and missing values to Default', () => {
+    expect(normalizeFloorplanMode(undefined)).toBe('default')
+    expect(normalizeFloorplanMode('legacy')).toBe('default')
+    expect(normalizeFloorplanMode('expert')).toBe('expert')
+  })
+
+  test('keeps only valid per-project preferences', () => {
+    expect(
+      normalizeFloorplanModesByProject({
+        alpha: 'expert',
+        beta: 'default',
+        invalid: 'legacy',
+        empty: null,
+      }),
+    ).toEqual({ alpha: 'expert', beta: 'default' })
+  })
+
+  test('limits tools only when their registry extension declares available modes', () => {
+    expect(isFloorplanToolAvailableInMode(undefined, 'default')).toBe(true)
+    expect(isFloorplanToolAvailableInMode(['expert'], 'default')).toBe(false)
+    expect(isFloorplanToolAvailableInMode(['expert'], 'expert')).toBe(true)
+    expect(isFloorplanToolAvailableInMode(['default', 'expert'], 'default')).toBe(true)
+  })
+
+  test('preserves the existing annotation profile in Expert', () => {
+    const expertVisibility = {
+      ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+      openingMarks: false,
+      roomLabels: false,
+    }
+
+    expect(
+      resolveFloorplanAnnotationVisibility('expert', expertVisibility, {
+        selected: false,
+        target: 'editor',
+      }),
+    ).toBe(expertVisibility)
+  })
+
+  test('keeps Default clean until an item is selected', () => {
+    expect(
+      resolveFloorplanAnnotationVisibility('default', DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, {
+        selected: false,
+        target: 'editor',
+      }),
+    ).toEqual({
+      automaticDimensions: false,
+      contextualDimensions: false,
+      manualDimensions: false,
+      measurements: false,
+      openingMarks: false,
+      structuralGrids: false,
+      roomLabels: true,
+      stairAnnotations: false,
+    })
+
+    expect(
+      resolveFloorplanAnnotationVisibility('default', DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, {
+        selected: true,
+        target: 'editor',
+      }),
+    ).toMatchObject({
+      automaticDimensions: false,
+      contextualDimensions: true,
+      manualDimensions: true,
+      measurements: true,
+    })
+  })
+
+  test('reveals a measurement when a referenced object is selected', () => {
+    expect(
+      resolveFloorplanAnnotationVisibility('default', DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, {
+        referencedAnnotationRole: 'measurement',
+        target: 'editor',
+      }).measurements,
+    ).toBe(true)
+    expect(
+      resolveFloorplanAnnotationVisibility('default', DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, {
+        referencedAnnotationRole: 'manual-dimension',
+        target: 'editor',
+      }).manualDimensions,
+    ).toBe(true)
+  })
+
+  test('exports Default without selection chrome or technical annotations', () => {
+    expect(
+      resolveFloorplanAnnotationVisibility('default', DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY, {
+        selected: true,
+        target: 'export',
+      }),
+    ).toEqual({
+      automaticDimensions: false,
+      contextualDimensions: false,
+      manualDimensions: false,
+      measurements: false,
+      openingMarks: false,
+      structuralGrids: false,
+      roomLabels: true,
+      stairAnnotations: false,
+    })
+  })
+
+  test('uses centerline dimensions only in Default', () => {
+    expect(resolveFloorplanWallDimensionReference('default', 'finished-faces')).toBe('centerline')
+    expect(resolveFloorplanWallDimensionReference('expert', 'finished-faces')).toBe(
+      'finished-faces',
+    )
+  })
+})

package/src/lib/floorplan/floorplan-mode.ts

@@ -0,0 +1,73 @@
+import {
+  type FloorplanAnnotationVisibility,
+  revealFloorplanAnnotationRole,
+} from './annotation-visibility'
+import type {
+  FloorplanAnnotationRole,
+  FloorplanToolMode,
+  FloorplanWallDimensionReference,
+} from './floorplan-extension'
+
+export const FLOORPLAN_MODES = ['default', 'expert'] as const
+
+export type FloorplanMode = (typeof FLOORPLAN_MODES)[number]
+
+export const DEFAULT_FLOORPLAN_MODE: FloorplanMode = 'default'
+
+export type FloorplanPresentationContext = {
+  referencedAnnotationRole?: FloorplanAnnotationRole
+  selected?: boolean
+  target: 'editor' | 'export'
+}
+
+export function normalizeFloorplanMode(value: unknown): FloorplanMode {
+  return value === 'expert' ? 'expert' : DEFAULT_FLOORPLAN_MODE
+}
+
+export function normalizeFloorplanModesByProject(value: unknown): Record<string, FloorplanMode> {
+  if (!value || typeof value !== 'object') return {}
+  const modes: Record<string, FloorplanMode> = {}
+  for (const [projectId, mode] of Object.entries(value)) {
+    if (!projectId || (mode !== 'default' && mode !== 'expert')) continue
+    modes[projectId] = mode
+  }
+  return modes
+}
+
+export function isFloorplanToolAvailableInMode(
+  availableModes: readonly FloorplanToolMode[] | undefined,
+  mode: FloorplanMode,
+): boolean {
+  return availableModes === undefined || availableModes.includes(mode)
+}
+
+export function resolveFloorplanAnnotationVisibility(
+  mode: FloorplanMode,
+  expertVisibility: FloorplanAnnotationVisibility,
+  context: FloorplanPresentationContext,
+): FloorplanAnnotationVisibility {
+  if (mode === 'expert') return expertVisibility
+
+  const interactive = context.target === 'editor'
+  const selected = interactive && context.selected === true
+  const visibility: FloorplanAnnotationVisibility = {
+    automaticDimensions: false,
+    contextualDimensions: selected,
+    manualDimensions: selected,
+    measurements: selected,
+    openingMarks: false,
+    structuralGrids: false,
+    roomLabels: true,
+    stairAnnotations: false,
+  }
+  return interactive && context.referencedAnnotationRole
+    ? revealFloorplanAnnotationRole(visibility, context.referencedAnnotationRole)
+    : visibility
+}
+
+export function resolveFloorplanWallDimensionReference(
+  mode: FloorplanMode,
+  expertReference: FloorplanWallDimensionReference,
+): FloorplanWallDimensionReference {
+  return mode === 'default' ? 'centerline' : expertReference
+}

package/src/lib/floorplan/floorplan-pdfkit-document.ts

@@ -0,0 +1,194 @@
+import type PdfKitDocument from 'pdfkit'
+
+type PdfKitDocumentInstance = InstanceType<typeof PdfKitDocument>
+
+type PdfTextOptions = {
+  align?: 'left' | 'center' | 'right'
+  maxWidth?: number
+}
+
+type PdfShapeStyle = 'F' | 'S'
+
+export class FloorplanPdfDocument {
+  readonly raw: PdfKitDocumentInstance
+  readonly internal: {
+    pageSize: {
+      getWidth: () => number
+      getHeight: () => number
+    }
+  }
+
+  private currentFontSize = 12
+  private readonly defaultPageSize: readonly [number, number]
+
+  constructor(raw: PdfKitDocumentInstance, defaultPageSize: readonly [number, number]) {
+    this.raw = raw
+    this.defaultPageSize = defaultPageSize
+    this.internal = {
+      pageSize: {
+        getWidth: () => this.raw.page?.width ?? this.defaultPageSize[0],
+        getHeight: () => this.raw.page?.height ?? this.defaultPageSize[1],
+      },
+    }
+  }
+
+  addPage(
+    size: readonly [number, number] = this.defaultPageSize,
+    _orientation?: 'portrait' | 'landscape',
+  ): this {
+    this.raw.addPage({ size: [size[0], size[1]], margin: 0 })
+    return this
+  }
+
+  setTextColor(color: string): this {
+    this.raw.fillColor(color)
+    return this
+  }
+
+  setDrawColor(color: string): this {
+    this.raw.strokeColor(color)
+    return this
+  }
+
+  setFillColor(color: string): this {
+    this.raw.fillColor(color)
+    return this
+  }
+
+  setLineWidth(width: number): this {
+    this.raw.lineWidth(width)
+    return this
+  }
+
+  setFont(family: string, weight: string = 'normal'): this {
+    const normalizedFamily = family.toLocaleLowerCase()
+    const normalizedWeight = weight.toLocaleLowerCase()
+    const bold = normalizedWeight === 'bold' || Number.parseInt(normalizedWeight, 10) >= 500
+    const base = normalizedFamily.includes('courier') ? 'Courier' : 'Helvetica'
+    this.raw.font(bold ? `${base}-Bold` : base)
+    return this
+  }
+
+  setFontSize(size: number): this {
+    this.currentFontSize = size
+    this.raw.fontSize(size)
+    return this
+  }
+
+  getTextWidth(value: string): number {
+    return this.raw.widthOfString(value, { lineBreak: false })
+  }
+
+  splitTextToSize(value: string, maxWidth: number): string[] {
+    if (maxWidth <= 0 || this.getTextWidth(value) <= maxWidth) return [value]
+    const words = value.trim().split(/\s+/)
+    const lines: string[] = []
+    let line = ''
+    for (const word of words) {
+      const candidate = line ? `${line} ${word}` : word
+      if (!line || this.getTextWidth(candidate) <= maxWidth) {
+        line = candidate
+        continue
+      }
+      lines.push(line)
+      line = word
+    }
+    if (line) lines.push(line)
+    return lines.length > 0 ? lines : ['']
+  }
+
+  text(
+    value: string | readonly string[],
+    x: number,
+    baselineY: number,
+    options: PdfTextOptions = {},
+  ) {
+    const lines = typeof value === 'string' ? value.split('\n') : value
+    const lineHeight = this.currentFontSize * 1.2
+    lines.forEach((line, index) => {
+      const width = this.getTextWidth(line)
+      const drawX =
+        options.align === 'center' ? x - width / 2 : options.align === 'right' ? x - width : x
+      this.raw.text(line, drawX, baselineY - this.currentFontSize * 0.78 + index * lineHeight, {
+        lineBreak: false,
+        width: options.maxWidth,
+      })
+    })
+    return this
+  }
+
+  line(x1: number, y1: number, x2: number, y2: number): this {
+    this.raw.moveTo(x1, y1).lineTo(x2, y2).stroke()
+    return this
+  }
+
+  rect(x: number, y: number, width: number, height: number, style: PdfShapeStyle = 'S'): this {
+    this.raw.rect(x, y, width, height)
+    if (style === 'F') this.raw.fill()
+    else this.raw.stroke()
+    return this
+  }
+
+  roundedRect(
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+    radiusX: number,
+    _radiusY: number,
+    style: PdfShapeStyle = 'S',
+  ): this {
+    this.raw.roundedRect(x, y, width, height, radiusX)
+    if (style === 'F') this.raw.fill()
+    else this.raw.stroke()
+    return this
+  }
+
+  circle(x: number, y: number, radius: number, style: PdfShapeStyle = 'S'): this {
+    this.raw.circle(x, y, radius)
+    if (style === 'F') this.raw.fill()
+    else this.raw.stroke()
+    return this
+  }
+
+  triangle(
+    x1: number,
+    y1: number,
+    x2: number,
+    y2: number,
+    x3: number,
+    y3: number,
+    style: PdfShapeStyle = 'S',
+  ): this {
+    this.raw.polygon([x1, y1], [x2, y2], [x3, y3])
+    if (style === 'F') this.raw.fill()
+    else this.raw.stroke()
+    return this
+  }
+}
+
+export async function createFloorplanPdfDocument(defaultPageSize: readonly [number, number]) {
+  const [{ default: PDFDocument }, { default: blobStream }] = await Promise.all([
+    import('pdfkit/js/pdfkit.standalone'),
+    import('blob-stream'),
+  ])
+  const raw = new PDFDocument({ autoFirstPage: false, compress: true, margin: 0 })
+  const stream = raw.pipe(blobStream())
+  return {
+    doc: new FloorplanPdfDocument(raw, defaultPageSize),
+    save: async (filename: string) => {
+      const blob = await new Promise<Blob>((resolve, reject) => {
+        stream.on('finish', () => resolve(stream.toBlob('application/pdf')))
+        stream.on('error', reject)
+        raw.on('error', reject)
+        raw.end()
+      })
+      const url = URL.createObjectURL(blob)
+      const anchor = document.createElement('a')
+      anchor.href = url
+      anchor.download = filename
+      anchor.click()
+      setTimeout(() => URL.revokeObjectURL(url), 0)
+    },
+  }
+}