@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/floorplan/schedules.test.ts

@@ -0,0 +1,189 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, AnyNodeId } from '@pascal-app/core'
+import { doorSchedule, formatScheduleLength, roomSchedule, windowSchedule } from './schedules'
+
+function fixture(): Record<string, AnyNode> {
+  const nodes: Record<string, AnyNode> = {}
+  const node = (value: Record<string, unknown>) => {
+    nodes[value.id as string] = {
+      object: 'node',
+      parentId: null,
+      visible: true,
+      metadata: {},
+      children: [],
+      ...value,
+    } as unknown as AnyNode
+  }
+
+  node({ id: 'level_1', type: 'level', level: 0, children: ['w_n', 'w_s', 'zone_1'] })
+  node({
+    id: 'w_n',
+    type: 'wall',
+    parentId: 'level_1',
+    start: [0, 0],
+    end: [6, 0],
+    thickness: 0.15,
+    frontSide: 'exterior',
+    backSide: 'interior',
+    children: ['d_1', 'win_1'],
+  })
+  node({
+    id: 'w_s',
+    type: 'wall',
+    parentId: 'level_1',
+    start: [6, 4],
+    end: [0, 4],
+    thickness: 0.1,
+    frontSide: 'interior',
+    backSide: 'interior',
+    children: ['d_2'],
+  })
+  node({
+    id: 'd_1',
+    type: 'door',
+    parentId: 'w_n',
+    wallId: 'w_n',
+    doorType: 'hinged',
+    openingKind: 'door',
+    width: 0.9144,
+    height: 2.0574,
+    frameThickness: 0.05,
+    frameDepth: 0.07,
+    threshold: true,
+    doorCloser: false,
+    panicBar: false,
+    roughOpeningWidth: 0.9652,
+    roughOpeningHeight: 2.0828,
+    position: [1, 1.05, 0],
+  })
+  node({
+    id: 'd_2',
+    type: 'door',
+    parentId: 'w_s',
+    wallId: 'w_s',
+    doorType: 'pocket',
+    openingKind: 'door',
+    width: 0.762,
+    height: 2.0574,
+    frameThickness: 0.05,
+    frameDepth: 0.07,
+    threshold: false,
+    doorCloser: false,
+    panicBar: false,
+    position: [2, 1.05, 0],
+  })
+  node({
+    id: 'win_1',
+    type: 'window',
+    parentId: 'w_n',
+    wallId: 'w_n',
+    windowType: 'casement',
+    openingKind: 'window',
+    width: 1.2192,
+    height: 1.2192,
+    position: [4, 1.1, 0],
+  })
+  node({
+    id: 'zone_1',
+    type: 'zone',
+    parentId: 'level_1',
+    spaceRole: 'room',
+    name: 'Living',
+    roomNumber: '101',
+    floorFinish: 'Oak',
+    wallFinish: '',
+    ceilingFinish: '',
+    ceilingHeight: 2.44,
+    occupancy: 'Residential',
+    enclosureStatus: 'unknown',
+    polygon: [
+      [0, 0],
+      [6, 0],
+      [6, 4],
+      [0, 4],
+    ],
+  })
+  return nodes
+}
+
+describe('formatScheduleLength', () => {
+  test('imperial to sixteenths', () => {
+    expect(formatScheduleLength(0.9144, 'imperial')).toBe(`3'-0"`)
+    expect(formatScheduleLength(2.0574, 'imperial')).toBe(`6'-9"`)
+    expect(formatScheduleLength(0.1524, 'imperial')).toBe(`6"`)
+  })
+  test('metric is millimetres', () => {
+    expect(formatScheduleLength(0.9144, 'metric')).toBe('914')
+  })
+})
+
+describe('doorSchedule', () => {
+  test('rows carry mark, type, size, rough opening, frame, hardware, remarks', () => {
+    const { rows, issues } = doorSchedule(fixture(), 'level_1' as AnyNodeId)
+    expect(issues).toEqual([])
+    expect(rows).toHaveLength(2)
+    expect(rows[0]).toMatchObject({
+      mark: 'D101',
+      type: 'Hinged',
+      sizeText: `3'-0" x 6'-9"`,
+      roughOpening: `3'-2" x 6'-10"`,
+      frame: `1 15/16" / 2 3/4"`,
+      hardware: 'Threshold',
+      count: 1,
+      remarks: 'Exterior',
+    })
+    expect(rows[1]).toMatchObject({
+      mark: 'D102',
+      type: 'Pocket',
+      roughOpening: null,
+      remarks: 'VERIFY R.O.',
+    })
+  })
+
+  test('grouping collapses identical openings and counts them', () => {
+    const nodes = fixture()
+    // A second identical exterior door on the same wall.
+    ;(nodes.w_n as unknown as { children: string[] }).children = ['d_1', 'd_1b', 'win_1']
+    nodes.d_1b = {
+      ...(nodes.d_1 as unknown as Record<string, unknown>),
+      id: 'd_1b',
+      position: [3, 1.05, 0],
+    } as unknown as AnyNode
+    const { rows } = doorSchedule(nodes, 'level_1' as AnyNodeId, { group: true })
+    const hinged = rows.find((row) => row.type === 'Hinged')
+    expect(hinged?.count).toBe(2)
+  })
+})
+
+describe('windowSchedule', () => {
+  test('windows number from W101', () => {
+    const { rows } = windowSchedule(fixture(), 'level_1' as AnyNodeId)
+    expect(rows).toHaveLength(1)
+    expect(rows[0]).toMatchObject({
+      mark: 'W101',
+      type: 'Casement',
+      sizeText: `4'-0" x 4'-0"`,
+      hardware: null,
+    })
+  })
+})
+
+describe('roomSchedule', () => {
+  test('one row per room zone with area and floor finish', () => {
+    const { rows, issues } = roomSchedule(fixture(), 'level_1' as AnyNodeId)
+    expect(issues).toEqual([])
+    expect(rows).toHaveLength(1)
+    expect(rows[0]?.number).toBe('101')
+    expect(rows[0]?.name).toBe('Living')
+    expect(rows[0]?.floorFinish).toBe('Oak')
+    expect(rows[0]?.area).toBeCloseTo(24, 6)
+    expect(rows[0]?.areaText).toBe('258.3 ft²')
+  })
+
+  test('a room without a number is reported', () => {
+    const nodes = fixture()
+    ;(nodes.zone_1 as unknown as { roomNumber: string }).roomNumber = ''
+    const { issues } = roomSchedule(nodes, 'level_1' as AnyNodeId)
+    expect(issues).toEqual(['Room Living has no room number'])
+  })
+})

package/src/lib/floorplan/schedules.ts

@@ -0,0 +1,339 @@
+import type { AnyNode, AnyNodeId, DoorNode, WallNode, WindowNode, ZoneNode } from '@pascal-app/core'
+import { deriveZoneQuantityReport } from '@pascal-app/core'
+import { collectFloorplanSchedules } from './floorplan-export'
+import type { FloorplanSchedule } from './floorplan-extension'
+import { resolveMarkDetail } from './marks'
+
+/**
+ * Construction-document schedule DATA — WS3.
+ *
+ * The PDF export already renders schedules through the node registry
+ * (`collectFloorplanSchedules` in `floorplan-export.tsx`, backed by each
+ * kind's `def.extensions['pascal:editor/floorplan'].schedule`). That path is
+ * untouched and keeps working; `floorplanSchedules()` below re-exports it.
+ *
+ * What this module adds is a TYPED, renderer-agnostic row model that the
+ * sheets workstream can lay out itself (column widths, grouping, sorting)
+ * instead of re-parsing formatted cells. Marks come from `marks.ts`, so a
+ * schedule row and the tag drawn on the plan always agree.
+ */
+
+const SQUARE_FEET_PER_SQUARE_METER = 10.76391041671
+const INCHES_PER_METER = 1 / 0.0254
+
+export type ScheduleUnit = 'metric' | 'imperial'
+
+export type OpeningScheduleRow = {
+  id: string
+  mark: string
+  type: string
+  /** Metres. */
+  width: number
+  /** Metres. */
+  height: number
+  widthText: string
+  heightText: string
+  sizeText: string
+  /** Rough opening as "W x H", or `null` when it was never entered. */
+  roughOpening: string | null
+  /** Frame material / thickness-depth where the model knows it. */
+  material: string | null
+  frame: string | null
+  hardware: string | null
+  /** How many identical openings this row stands for (grouped rows only). */
+  count: number
+  remarks: string
+}
+
+export type RoomScheduleRow = {
+  id: string
+  number: string
+  name: string
+  /** Square metres. */
+  area: number
+  areaText: string
+  floorFinish: string | null
+  ceilingHeight: number
+  remarks: string
+}
+
+export type ScheduleResult<TRow> = {
+  rows: TRow[]
+  issues: string[]
+}
+
+export type ScheduleSceneInput =
+  | { nodes: Readonly<Record<string, AnyNode>> }
+  | Readonly<Record<string, AnyNode>>
+
+export type ScheduleOptions = {
+  unit?: ScheduleUnit
+  /** Collapse identical openings into one row carrying `count`. Default false. */
+  group?: boolean
+}
+
+// ── Door schedule ────────────────────────────────────────────────────
+
+export function doorSchedule(
+  scene: ScheduleSceneInput,
+  levelId?: AnyNodeId,
+  options: ScheduleOptions = {},
+): ScheduleResult<OpeningScheduleRow> {
+  return openingSchedule(scene, 'door', levelId, options)
+}
+
+export function windowSchedule(
+  scene: ScheduleSceneInput,
+  levelId?: AnyNodeId,
+  options: ScheduleOptions = {},
+): ScheduleResult<OpeningScheduleRow> {
+  return openingSchedule(scene, 'window', levelId, options)
+}
+
+function openingSchedule(
+  scene: ScheduleSceneInput,
+  kind: 'door' | 'window',
+  levelId: AnyNodeId | undefined,
+  options: ScheduleOptions,
+): ScheduleResult<OpeningScheduleRow> {
+  const nodes = normalizeNodes(scene)
+  const unit = options.unit ?? 'imperial'
+  const levelIds = levelId ? [levelId] : allLevelIds(nodes)
+
+  const rows: OpeningScheduleRow[] = []
+  const issues: string[] = []
+
+  for (const id of levelIds) {
+    const resolution = resolveMarkDetail(nodes, id as AnyNodeId)
+    issues.push(...resolution.issues)
+    for (const node of collectSubtree(nodes, id)) {
+      if (node.type !== kind) continue
+      const opening = node as DoorNode | WindowNode
+      rows.push(openingRow(opening, nodes, resolution.marks.get(opening.id) ?? '—', unit))
+    }
+  }
+
+  rows.sort((left, right) => left.mark.localeCompare(right.mark, 'en', { numeric: true }))
+  return { rows: options.group ? groupOpeningRows(rows) : rows, issues }
+}
+
+function openingRow(
+  opening: DoorNode | WindowNode,
+  nodes: Readonly<Record<string, AnyNode>>,
+  mark: string,
+  unit: ScheduleUnit,
+): OpeningScheduleRow {
+  const remarks: string[] = []
+  if (opening.roughOpeningWidth === undefined || opening.roughOpeningHeight === undefined) {
+    remarks.push('VERIFY R.O.')
+  }
+  const wall = opening.wallId ? (nodes[opening.wallId] as WallNode | undefined) : undefined
+  if (
+    wall &&
+    wall.type === 'wall' &&
+    (wall.frontSide === 'exterior' || wall.backSide === 'exterior')
+  ) {
+    remarks.push('Exterior')
+  }
+
+  return {
+    id: opening.id,
+    mark,
+    type: openingTypeLabel(opening),
+    width: opening.width,
+    height: opening.height,
+    widthText: formatScheduleLength(opening.width, unit),
+    heightText: formatScheduleLength(opening.height, unit),
+    sizeText: `${formatScheduleLength(opening.width, unit)} x ${formatScheduleLength(opening.height, unit)}`,
+    roughOpening:
+      opening.roughOpeningWidth !== undefined && opening.roughOpeningHeight !== undefined
+        ? `${formatScheduleLength(opening.roughOpeningWidth, unit)} x ${formatScheduleLength(opening.roughOpeningHeight, unit)}`
+        : null,
+    material: openingMaterial(opening),
+    frame: openingFrame(opening, unit),
+    hardware: opening.type === 'door' ? doorHardware(opening as DoorNode) : null,
+    count: 1,
+    remarks: remarks.join('; '),
+  }
+}
+
+function groupOpeningRows(rows: readonly OpeningScheduleRow[]): OpeningScheduleRow[] {
+  const grouped = new Map<string, OpeningScheduleRow>()
+  for (const row of rows) {
+    const key = [
+      row.type,
+      row.sizeText,
+      row.roughOpening,
+      row.material,
+      row.frame,
+      row.hardware,
+    ].join('|')
+    const existing = grouped.get(key)
+    if (existing) existing.count += row.count
+    else grouped.set(key, { ...row })
+  }
+  return [...grouped.values()]
+}
+
+function openingTypeLabel(opening: DoorNode | WindowNode): string {
+  if (opening.openingKind === 'opening') return 'Opening'
+  return titleCase(
+    opening.type === 'door' ? (opening as DoorNode).doorType : (opening as WindowNode).windowType,
+  )
+}
+
+function openingMaterial(opening: DoorNode | WindowNode): string | null {
+  // `slots.panel` / `material` hold a MaterialRef (`library:<id>` /
+  // `scene:<id>`). Only the ref is knowable here — no invented values.
+  const ref = opening.slots?.panel ?? opening.slots?.frame ?? undefined
+  if (typeof ref === 'string' && ref.includes(':')) return titleCase(ref.split(':')[1] ?? ref)
+  return null
+}
+
+function openingFrame(opening: DoorNode | WindowNode, unit: ScheduleUnit): string | null {
+  const thickness = (opening as DoorNode).frameThickness
+  const depth = (opening as DoorNode).frameDepth
+  if (typeof thickness !== 'number' || typeof depth !== 'number') return null
+  return `${formatScheduleLength(thickness, unit)} / ${formatScheduleLength(depth, unit)}`
+}
+
+function doorHardware(door: DoorNode): string {
+  if (door.openingKind === 'opening') return 'None'
+  const hardware: string[] = []
+  if (door.doorCloser) hardware.push('Closer')
+  if (door.panicBar) hardware.push('Panic bar')
+  if (door.threshold) hardware.push('Threshold')
+  return hardware.length > 0 ? hardware.join(', ') : 'Standard'
+}
+
+// ── Room schedule ────────────────────────────────────────────────────
+
+export function roomSchedule(
+  scene: ScheduleSceneInput,
+  levelId?: AnyNodeId,
+  options: ScheduleOptions = {},
+): ScheduleResult<RoomScheduleRow> {
+  const nodes = normalizeNodes(scene)
+  const unit = options.unit ?? 'imperial'
+  const levelIds = levelId ? [levelId] : allLevelIds(nodes)
+
+  const rows: RoomScheduleRow[] = []
+  const issues: string[] = []
+  const seenNumbers = new Map<string, string[]>()
+
+  for (const id of levelIds) {
+    for (const node of collectSubtree(nodes, id)) {
+      if (node.type !== 'zone') continue
+      const zone = node as ZoneNode
+      if (zone.spaceRole !== 'room') continue
+      const report = deriveZoneQuantityReport(zone, nodes as Record<string, AnyNode>)
+      const number = zone.roomNumber.trim()
+      if (!number) issues.push(`Room ${zone.name.trim() || zone.id} has no room number`)
+      else {
+        const owners = seenNumbers.get(number.toLocaleUpperCase())
+        if (owners) owners.push(zone.id)
+        else seenNumbers.set(number.toLocaleUpperCase(), [zone.id])
+      }
+      rows.push({
+        id: zone.id,
+        number: number || '—',
+        name: zone.name.trim() || '—',
+        area: report.footprintArea,
+        areaText: formatArea(report.footprintArea, unit),
+        floorFinish: zone.floorFinish.trim() || null,
+        ceilingHeight: zone.ceilingHeight,
+        remarks: zone.occupancy.trim(),
+      })
+    }
+  }
+
+  for (const [number, owners] of seenNumbers) {
+    if (owners.length > 1) issues.push(`Duplicate room number ${number} (${owners.length} rooms)`)
+  }
+
+  rows.sort((left, right) => left.number.localeCompare(right.number, 'en', { numeric: true }))
+  return { rows, issues }
+}
+
+// ── PDF-compatible schedules (unchanged registry path) ───────────────
+
+/**
+ * The registry-driven schedules the PDF export renders. Kept as the single
+ * source for the PDF so extending this module never forks that output.
+ */
+export function floorplanSchedules(
+  nodes: Record<string, AnyNode>,
+  levelId: AnyNodeId,
+  unit: ScheduleUnit,
+): FloorplanSchedule[] {
+  return collectFloorplanSchedules(nodes, levelId, unit)
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+export function formatScheduleLength(metres: number, unit: ScheduleUnit): string {
+  if (!Number.isFinite(metres)) return '—'
+  if (unit === 'metric') return `${Math.round(metres * 1000)}`
+  const denominator = 16
+  const sign = metres < 0 ? '-' : ''
+  const totalUnits = Math.round(Math.abs(metres) * INCHES_PER_METER * denominator)
+  const unitsPerFoot = 12 * denominator
+  const feet = Math.floor(totalUnits / unitsPerFoot)
+  const remainder = totalUnits - feet * unitsPerFoot
+  const inches = Math.floor(remainder / denominator)
+  const numerator = remainder - inches * denominator
+  const divisor = greatestCommonDivisor(numerator, denominator)
+  const fraction = numerator === 0 ? '' : `${numerator / divisor}/${denominator / divisor}`
+  const inchText = fraction ? `${inches} ${fraction}` : `${inches}`
+  return feet === 0 ? `${sign}${inchText}"` : `${sign}${feet}'-${inchText}"`
+}
+
+function formatArea(squareMetres: number, unit: ScheduleUnit): string {
+  if (!Number.isFinite(squareMetres)) return '—'
+  return unit === 'metric'
+    ? `${squareMetres.toFixed(2)} m²`
+    : `${(squareMetres * SQUARE_FEET_PER_SQUARE_METER).toFixed(1)} ft²`
+}
+
+function greatestCommonDivisor(a: number, b: number): number {
+  let left = Math.abs(a)
+  let right = Math.abs(b)
+  while (right !== 0) {
+    const next = left % right
+    left = right
+    right = next
+  }
+  return left || 1
+}
+
+function titleCase(value: string): string {
+  return value
+    .split(/[-_]/)
+    .map((part) => part.charAt(0).toLocaleUpperCase() + part.slice(1))
+    .join(' ')
+}
+
+function collectSubtree(nodes: Readonly<Record<string, AnyNode>>, rootId: string): AnyNode[] {
+  const result: AnyNode[] = []
+  const visit = (id: string) => {
+    const node = nodes[id]
+    if (!node || node.visible === false) return
+    result.push(node)
+    for (const childId of (node as { children?: string[] }).children ?? []) visit(childId)
+  }
+  visit(rootId)
+  return result
+}
+
+function allLevelIds(nodes: Readonly<Record<string, AnyNode>>): string[] {
+  return Object.values(nodes)
+    .filter((node) => node?.type === 'level')
+    .map((node) => node.id)
+}
+
+function normalizeNodes(scene: ScheduleSceneInput): Readonly<Record<string, AnyNode>> {
+  const candidate = scene as { nodes?: Readonly<Record<string, AnyNode>> }
+  return candidate && typeof candidate === 'object' && candidate.nodes
+    ? candidate.nodes
+    : (scene as Readonly<Record<string, AnyNode>>)
+}

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

@@ -0,0 +1,124 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { setProjectFileSink } from '@pascal-app/core'
+import { exportSheetsToPdf, type SheetPdfPage } from './sheet-export'
+
+const sheet = (number: string, title: string): SheetPdfPage => ({
+  number,
+  title,
+  widthIn: 36,
+  heightIn: 24,
+  plate: [],
+  windows: [],
+  overlay: [],
+})
+
+const globals = globalThis as unknown as Record<string, unknown>
+const originalDocument = globals.document
+const originalCreateObjectURL = URL.createObjectURL
+
+afterEach(() => {
+  globals.document = originalDocument
+  URL.createObjectURL = originalCreateObjectURL
+})
+
+/** Runs the export with the browser download stubbed, returning the file and its name. */
+async function exportToBytes(pages: SheetPdfPage[], documentTitle: string) {
+  let blob: Blob | null = null
+  let filename = ''
+  URL.createObjectURL = (object: Blob | MediaSource) => {
+    blob = object as Blob
+    return 'blob:sheet-export-test'
+  }
+  globals.document = {
+    createElement: () => {
+      const anchor = {
+        href: '',
+        download: '',
+        click: () => {
+          filename = anchor.download
+        },
+      }
+      return anchor
+    },
+  }
+  await exportSheetsToPdf(pages, 'qa-hip-ranch_2026-09-23.pdf', documentTitle)
+  if (!blob) throw new Error('the export produced no file')
+  const pdf = Buffer.from(await (blob as Blob).arrayBuffer()).toString('latin1')
+  return { pdf, filename }
+}
+
+/** The PDF literal string opening at `start` ("(…)"), decoded — UTF-16BE when it carries the BOM. */
+function readLiteral(pdf: string, start: number): string {
+  const escaped: Record<string, string> = { n: '\n', r: '\r', t: '\t', b: '\b', f: '\f' }
+  let bytes = ''
+  for (let i = start + 1; pdf[i] !== ')'; i += 1) {
+    if (pdf[i] === '\\') {
+      i += 1
+      bytes += escaped[pdf[i]!] ?? pdf[i]
+    } else bytes += pdf[i]
+  }
+  if (!bytes.startsWith('\xfe\xff')) return bytes
+  let text = ''
+  for (let k = 2; k < bytes.length; k += 2) {
+    text += String.fromCharCode((bytes.charCodeAt(k) << 8) | bytes.charCodeAt(k + 1))
+  }
+  return text
+}
+
+/** Every `/Title` in the file — outline entries inline, the document info's by reference. */
+function titles(pdf: string): string[] {
+  return [...pdf.matchAll(/\/Title (?:\(|(\d+) 0 R)/g)].map((match) =>
+    match[1]
+      ? readLiteral(pdf, pdf.indexOf(`\n${match[1]} 0 obj\n(`) + `\n${match[1]} 0 obj\n`.length)
+      : readLiteral(pdf, match.index + '/Title '.length),
+  )
+}
+
+describe('exportSheetsToPdf', () => {
+  test('retains the PDF in project files before downloading and reports a failed save', async () => {
+    let kept: { name: string; blob: Blob } | null = null
+    const clear = setProjectFileSink(async (file) => {
+      kept = file
+    })
+    try {
+      const { filename } = await exportToBytes([sheet('A0.0', 'Cover')], 'Project files')
+      expect(kept!.name).toBe(filename)
+      expect(await kept!.blob.text()).toStartWith('%PDF-')
+    } finally {
+      clear()
+    }
+    const clearFailed = setProjectFileSink(async () => {
+      throw new Error('File could not be saved')
+    })
+    try {
+      await expect(exportToBytes([sheet('A0.0', 'Cover')], 'Project files')).rejects.toThrow(
+        'File could not be saved',
+      )
+    } finally {
+      clearFailed()
+    }
+  })
+  test('bookmarks every sheet by its number and title and titles the document', async () => {
+    const { pdf, filename } = await exportToBytes(
+      [
+        sheet('A0.0', 'Cover sheet'),
+        sheet('A2.0', 'Ground floor floor plan'),
+        sheet('S2.0', 'Floor framing plan — Ground floor'),
+      ],
+      'QA Hip Ranch',
+    )
+
+    expect(filename).toBe('qa-hip-ranch_2026-09-23.pdf')
+    expect(titles(pdf).sort()).toEqual([
+      'A0.0 Cover sheet',
+      'A2.0 Ground floor floor plan',
+      'QA Hip Ranch',
+      'S2.0 Floor framing plan — Ground floor',
+    ])
+    // the bookmarks pane opens with the file, each entry fits its whole sheet
+    expect(pdf).toContain('/PageMode /UseOutlines')
+    expect(pdf.match(/\/Dest \[\d+ 0 R \/Fit\]/g)).toHaveLength(3)
+    // the viewer's title bar shows the project, not the file name
+    expect(pdf).toContain('/DisplayDocTitle true')
+  })
+})