@pascal-app/editor 1.0.4 → 1.0.6

package/src/lib/download-project-file.ts

@@ -0,0 +1,17 @@
+import { getProjectFileSink, type ProjectFileSink } from '@pascal-app/core'
+
+/** Persist before reporting a successful download; a failed save is shown by the export UI. */
+export async function downloadProjectFile(
+  blob: Blob,
+  name: string,
+  sink: ProjectFileSink | null = getProjectFileSink(),
+) {
+  await sink?.({ blob, name })
+  if (typeof document === 'undefined') return
+  const url = URL.createObjectURL(blob)
+  const anchor = document.createElement('a')
+  anchor.href = url
+  anchor.download = name
+  anchor.click()
+  setTimeout(() => URL.revokeObjectURL(url), 0)
+}

package/src/lib/editor-level-display.ts

@@ -1,6 +1,7 @@
 import { useViewer } from '@pascal-app/viewer'
 import { useEffect } from 'react'
-import type { CaptureMode } from '../store/use-editor'
+import useEditor, { type CaptureMode } from '../store/use-editor'
+import { useBelowGrade, useGroundWindowBox } from './below-grade'
 
 /**
  * Whether the editor shows every level. Preview and the walkthrough show the
@@ -27,9 +28,15 @@ export function showsWholeBuilding(state: {
  *
  * The walkthrough shows the whole building, so the upper levels come back
  * while it is on; Preview hands the display to the viewer's own floor rule
- * (`useViewerFloorDisplay`).
+ * (`useViewerFloorDisplay`). A level below grade is marked as shown, and its
+ * ground veiled, except on the site, where the ground is what is being worked on.
  */
 export function useEditorLevelDisplay(showWholeBuilding: boolean) {
+  const sitePhase = useEditor((state) => state.phase === 'site')
+  useBelowGrade(!(showWholeBuilding || sitePhase))
+  // The ground window (a hillside in the eye's way) follows the shown level, and the whole
+  // building while it stands whole — except on the site, where the ground is the work.
+  useGroundWindowBox(!sitePhase)
   useEffect(() => {
     if (showWholeBuilding) return
     const keepStacked = (mode: string) => {

package/src/lib/editor-views.ts

@@ -1,6 +1,6 @@
 import type { IconRef, LazyComponent } from '@pascal-app/core'
 import useEditor from '../store/use-editor'
-import { VIEW_2D, VIEW_3D } from '../store/view-layout'
+import { VIEW_2D, VIEW_3D, withoutView } from '../store/view-layout'
 
 /**
  * A view fills a pane of the stage, beside or instead of the 3D scene and the
@@ -19,6 +19,10 @@ export type EditorHostView = {
   description?: string
   /** Shown in the view bar until the user unpins it. Default false: the "More views" menu only. */
   defaultPinned?: boolean
+  /** Always in the view bar: the user cannot unpin it. */
+  alwaysPinned?: boolean
+  /** Session views such as open documents can be dismissed from the tab bar. */
+  onClose?: () => void
 }
 
 /** A view as the stage needs it. The scene views have no component: the stage owns their canvases. */
@@ -93,6 +97,31 @@ class EditorHostViewRegistryImpl {
     this.emit()
   }
 
+  updateView(id: string, patch: Pick<EditorHostView, 'label'>): void {
+    const view = this.views.get(id)
+    if (!view) return
+    this.views.set(id, { ...view, ...patch })
+    this.emit()
+  }
+
+  unregisterView(id: string): void {
+    if (!this.views.delete(id)) return
+    useEditor.getState().closeView(id)
+    useEditor.setState((state) => {
+      const { [id]: _, ...pinnedViews } = state.pinnedViews
+      return {
+        pinnedViews,
+        viewLayouts: Object.fromEntries(
+          Object.entries(state.viewLayouts).map(([workspace, layout]) => [
+            workspace,
+            withoutView(layout, id),
+          ]),
+        ),
+      }
+    })
+    this.emit()
+  }
+
   private emit(): void {
     this.cached = Array.from(this.views.values())
     for (const listener of this.listeners) listener()
@@ -105,6 +134,10 @@ export function registerEditorHostView(view: EditorHostView): void {
   editorHostViewRegistry.registerView(view)
 }
 
+export function unregisterEditorHostView(id: string): void {
+  editorHostViewRegistry.unregisterView(id)
+}
+
 /**
  * Show a view: focus it if it is on screen, else put it in the focused pane —
  * or, with `beside`, split and open it next to what is there.
@@ -140,5 +173,6 @@ export function isViewPinned(
   view: EditorViewDescriptor,
   pinnedViews: Readonly<Record<string, boolean>>,
 ): boolean {
+  if (view.alwaysPinned) return true
   return pinnedViews[view.id] ?? view.defaultPinned ?? false
 }

package/src/lib/export-texture-utils.ts

@@ -56,7 +56,6 @@ export function createExportTextureUtils(
 ): ExportTextureUtils {
   let pending: Promise<WebGPURenderer> | null = null
   let disposed = false
-  const quad = new QuadMesh()
 
   return {
     async decompress(texture, maxTextureSize = Number.POSITIVE_INFINITY) {
@@ -67,7 +66,7 @@ export function createExportTextureUtils(
       const renderer = await pending
 
       // Everything below the await is synchronous, which is what lets
-      // overlapping calls share `quad` and the renderer's colour space.
+      // overlapping calls share the renderer's size and colour space.
       const image = texture.image as { width: number; height: number }
       const width = Math.min(image.width, maxTextureSize)
       const height = Math.min(image.height, maxTextureSize)
@@ -77,9 +76,8 @@ export function createExportTextureUtils(
       const previousColorSpace = renderer.outputColorSpace
       renderer.setSize(width, height)
       renderer.outputColorSpace = texture.colorSpace
-      quad.material = material
       try {
-        quad.render(renderer)
+        new QuadMesh(material).render(renderer)
       } finally {
         renderer.outputColorSpace = previousColorSpace
         material.dispose()

package/src/lib/floor-foundation-support.test.ts

@@ -70,6 +70,7 @@ beforeEach(() => {
     readOnly: false,
   })
   useScene.temporal.getState().resume()
+  useScene.temporal.getState().clear()
   stop = initSpaceDetectionSync(useScene, { getState: () => ({ spaces: {}, setSpaces: () => {} }) })
   room(GROUND, rect(0, 0, 8, 5), 'Living')
   room(UPPER, rect(0, 0, 8, 5), 'Bedroom')

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

@@ -1,7 +1,13 @@
+/// <reference path="./pdfkit-standard-fonts.d.ts" />
+import { getProjectFileSink } from '@pascal-app/core'
 import type PdfKitDocument from 'pdfkit'
+import { downloadProjectFile } from '../download-project-file'
 
 type PdfKitDocumentInstance = InstanceType<typeof PdfKitDocument>
 
+/** pdfkit 0.20's browser-build export, which @types/pdfkit does not describe. */
+type PdfKitStandardFontRegistry = { registerStdFonts?: (...fonts: unknown[]) => void }
+
 type PdfTextOptions = {
   align?: 'left' | 'center' | 'right'
   maxWidth?: number
@@ -461,16 +467,30 @@ export async function createFloorplanPdfDocument(
   defaultPageSize: readonly [number, number],
   options: { title?: string } = {},
 ) {
-  const [{ default: PDFDocument }, { default: blobStream }, fonts] = await Promise.all([
-    import('pdfkit/js/pdfkit.standalone'),
-    import('blob-stream'),
-    // an export in the standard fonts beats no export when the font files are unreachable
-    loadFloorplanPdfFonts().catch((error: unknown) => {
-      console.warn('[floorplan-export] Falling back to the standard PDF fonts', error)
-      return null
-    }),
-  ])
-  const raw = new PDFDocument({
+  const fileSink = getProjectFileSink()
+  const [pdfkit, helvetica, helveticaBold, courier, courierBold, { default: blobStream }, fonts] =
+    await Promise.all([
+      import('pdfkit'),
+      import('pdfkit/standard-fonts/Helvetica'),
+      import('pdfkit/standard-fonts/HelveticaBold'),
+      import('pdfkit/standard-fonts/Courier'),
+      import('pdfkit/standard-fonts/CourierBold'),
+      import('blob-stream'),
+      // an export in the standard fonts beats no export when the font files are unreachable
+      loadFloorplanPdfFonts().catch((error: unknown) => {
+        console.warn('[floorplan-export] Falling back to the standard PDF fonts', error)
+        return null
+      }),
+    ])
+  // The browser build has no standard-font metrics until they are registered, and
+  // the constructor already sets Helvetica; the Node build loads its own and has no registry.
+  ;(pdfkit as PdfKitStandardFontRegistry).registerStdFonts?.(
+    helvetica.default,
+    helveticaBold.default,
+    courier.default,
+    courierBold.default,
+  )
+  const raw = new pdfkit.default({
     autoFirstPage: false,
     compress: true,
     margin: 0,
@@ -487,12 +507,7 @@ export async function createFloorplanPdfDocument(
         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)
+      await downloadProjectFile(blob, filename, fileSink)
     },
   }
 }

package/src/lib/floorplan/floorplan-pdfkit-renderer.test.ts

@@ -98,6 +98,45 @@ describe('renderFloorplanGeometryToPdfKit', () => {
     expect(pdf).toMatch(/f\*/)
   })
 
+  test('ends an unpainted shape so the next fill does not paint it', async () => {
+    // Zones emit fill/stroke 'none' outlines; walls fill right after them.
+    const geometry = {
+      kind: 'group',
+      children: [
+        {
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [4, 0],
+            [4, 4],
+            [0, 4],
+          ],
+          fill: 'none',
+          stroke: 'none',
+        },
+        {
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [1, 0],
+            [1, 0.2],
+            [0, 0.2],
+          ],
+          fill: '#374151',
+        },
+      ],
+    } as FloorplanGeometry
+
+    const pdf = await renderTestPdf(geometry)
+    const ops = pdf.split('\n')
+    const firstClose = ops.indexOf('h')
+
+    // the unpainted outline is closed and discarded ('n') before the filled one starts
+    expect(firstClose).toBeGreaterThan(-1)
+    expect(ops[firstClose + 1]).toBe('n')
+    expect(pdf).toMatch(/\bf\n/)
+  })
+
   test('writes a data-url PNG image without resolving it as an asset', async () => {
     const geometry = {
       kind: 'image',

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

@@ -217,6 +217,10 @@ function paintStyledGeometry(
   if (fill && stroke) raw.fillAndStroke(fill, stroke, fillRule)
   else if (fill) raw.fill(fill, fillRule)
   else if (stroke) raw.stroke(stroke)
+  // Unpainted shape (fill and stroke both none, e.g. zone hit areas): end the
+  // path without painting ('n'). Otherwise the open path is carried into the
+  // next fill and printed in that shape's colour.
+  else raw.addContent('n')
 }
 
 function isPaint(value: unknown): boolean {

package/src/lib/floorplan/pdfkit-standard-fonts.d.ts

@@ -0,0 +1,5 @@
+// pdfkit 0.20 ships these entry points without types, and @types/pdfkit predates them.
+declare module 'pdfkit/standard-fonts/*' {
+  const font: unknown
+  export default font
+}

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

@@ -1,4 +1,5 @@
 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 => ({
@@ -74,6 +75,29 @@ function titles(pdf: string): string[] {
 }
 
 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(
       [

package/src/lib/floorplan/site-plan/build-site-plan-drawing.ts

@@ -2,14 +2,28 @@ import {
   type AnyNode,
   type AnyNodeId,
   type BuildingNode,
+  castYardDimensionsOriented,
+  classifyEdges,
+  edgeHeadingDeg,
+  edgeLength,
   envelopeFrontEdge,
   type FloorplanGeometry,
+  footprintOutline,
+  isRoofLevel,
   type LevelNode,
+  levelFootprintLoops,
+  outwardNormal,
   type SceneSnapshot,
   type SiteNode,
+  setbackForRole,
   sightTriangle,
+  siteFrame,
+  siteFrontEdge,
+  siteSetbackEnvelope,
   streetCorners,
   terrainFieldOf,
+  type YardDimension,
+  yawOf,
 } from '@pascal-app/core'
 import { sitePlanContributions } from './contributors'
 import {
@@ -20,21 +34,11 @@ import {
 } from './coverage'
 import {
   type Bounds,
-  boundsInsidePolygon,
-  castYardDimensionsOriented,
-  classifyEdges,
   compassLabel,
-  edgeHeadingDeg,
-  edgeLength,
   formatFeetInches,
   METRES_PER_FOOT,
-  outwardNormal,
   type Pt,
   polygonBounds,
-  resolveFrontEdge,
-  setbackEnvelope,
-  setbackForRole,
-  type YardDimension,
 } from './geometry'
 import {
   contourPrimitives,
@@ -47,17 +51,14 @@ import {
   streetEdgeNames,
 } from './site-annotations'
 import {
+  aboveGradeLevels,
   findBuilding,
   findLowestLevel,
   findSite,
-  footprintOutline,
-  levelFootprintLoops,
   roofOutlineRings,
-  siteFrame,
-  yawOf,
 } from './site-parts'
 
-export { footprintOutline, levelFootprintLoops, roofOutlineRings }
+export { roofOutlineRings }
 
 /** Contract shared by every drawing producer (see docs/construction-documents.md). */
 export interface SitePlanDrawing {
@@ -71,8 +72,11 @@ export interface SitePlanDrawing {
     frontEdge: number
     lot: Pt[]
     envelope: Pt[]
-    /** The envelope edge behind the lot's front line (the envelope has its own vertex count now). */
-    envelopeFrontEdge: number
+    /**
+     * The envelope edge behind the lot's front line (the envelope has its own vertex count now);
+     * null with no envelope, or when no envelope edge faces the street.
+     */
+    envelopeFrontEdge: number | null
     /** The corner sight triangles (corner, leg end A, leg end B), site metres. */
     sightTriangles: Pt[][]
     /** Per-wall footprint bands of the lowest level, in SITE metres. */
@@ -316,10 +320,10 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
   const lot = (site?.polygon?.points ?? []) as Pt[]
   const building = findBuilding(scene, site)
   const level = findLowestLevel(scene, building)
-  const footprintLoops = levelFootprintLoops(scene, level, building)
+  const footprintLoops = levelFootprintLoops(scene.nodes, level, building)
   const footprintBounds = unionBounds(footprintLoops)
   const northRotation = site?.northRotation ?? 0
-  const frontEdge = resolveFrontEdge(lot, site?.frontEdge, northRotation)
+  const frontEdge = site ? siteFrontEdge(site) : 0
 
   const empty: SitePlanDrawing = {
     primitives: [],
@@ -330,7 +334,7 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
       frontEdge,
       lot,
       envelope: [],
-      envelopeFrontEdge: 0,
+      envelopeFrontEdge: null,
       sightTriangles: [],
       footprintLoops,
       footprintBounds,
@@ -393,9 +397,7 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
     typeof site?.sightTriangleFt === 'number' && site.sightTriangleFt > 0
       ? site.sightTriangleFt * METRES_PER_FOOT
       : 0
-  const envelope = site?.setbacks
-    ? setbackEnvelope(lot, site.setbacks, frontEdge, { streetEdges, sightTriangleM })
-    : []
+  const envelope = site ? siteSetbackEnvelope(site) : []
   // the corner sight triangles (clear-vision at a street intersection):
   // dashed, labelled with the leg — the ordinance's figure, verify locally
   const sightTriangles: Pt[][] = []
@@ -566,7 +568,11 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
   }
 
   // ── The roof line, dashed over the footprint ─────────────────────────
-  for (const ring of roofOutlineRings(scene, level, building)) {
+  // Every storey's roofs, and the roof level's above them all.
+  const roofRings = aboveGradeLevels(scene, building).flatMap((roofed) =>
+    roofOutlineRings(scene, roofed, building),
+  )
+  for (const ring of roofRings) {
     primitives.push({
       kind: 'polygon',
       points: ring,
@@ -650,7 +656,9 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
     let storeys = 0
     for (const childId of building?.children ?? []) {
       const child = scene.nodes[childId as AnyNodeId] as AnyNode | undefined
-      if (child?.type === 'level' && (child as LevelNode).level >= 0) storeys++
+      // The roof level is not a storey: a bungalow under it is one storey.
+      if (child?.type === 'level' && (child as LevelNode).level >= 0 && !isRoofLevel(child))
+        storeys++
     }
     const cx = (footprintBounds.minX + footprintBounds.maxX) / 2
     const cy = (footprintBounds.minY + footprintBounds.maxY) / 2
@@ -748,7 +756,7 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
       frontEdge,
       lot,
       envelope,
-      envelopeFrontEdge: envelope.length >= 3 ? envelopeFrontEdge(lot, frontEdge, envelope) : 0,
+      envelopeFrontEdge: envelope.length >= 3 ? envelopeFrontEdge(lot, frontEdge, envelope) : null,
       sightTriangles,
       footprintLoops,
       footprintBounds,
@@ -758,22 +766,3 @@ export function buildSitePlanDrawing(scene: SceneSnapshot): SitePlanDrawing {
     },
   }
 }
-
-/**
- * Translation (site metres, `[dx, dz]`) that centres the building's footprint
- * on the lot centroid. `null` when there is nothing to move or the footprint
- * already sits inside the ring.
- */
-export function buildingRecentreOffset(
-  lot: readonly Pt[],
-  footprintBounds: Bounds | null,
-): [number, number] | null {
-  if (lot.length < 3 || !footprintBounds) return null
-  if (boundsInsidePolygon(lot, footprintBounds)) return null
-  const lotB = polygonBounds(lot)
-  const lotCx = (lotB.minX + lotB.maxX) / 2
-  const lotCy = (lotB.minY + lotB.maxY) / 2
-  const fpCx = (footprintBounds.minX + footprintBounds.maxX) / 2
-  const fpCy = (footprintBounds.minY + footprintBounds.maxY) / 2
-  return [lotCx - fpCx, lotCy - fpCy]
-}

package/src/lib/floorplan/site-plan/coverage.ts

@@ -26,15 +26,13 @@
  * drop-in resolved one (`site.parcel.lotAreaSqFt`), else the drawn lot
  * polygon. Pure: reads a scene snapshot, touches no store.
  */
-import type { SceneSnapshot } from '@pascal-app/core'
+import { footprintOutline, levelFootprintLoops, type SceneSnapshot } from '@pascal-app/core'
 import { METRES_PER_FOOT, type Pt, pointInPolygon, polygonArea, polygonBounds } from './geometry'
 import {
   aboveGradeLevels,
   findBuilding,
   findLowestLevel,
   findSite,
-  footprintOutline,
-  levelFootprintLoops,
   type OutdoorPart,
   outdoorParts,
   roofOutlineRings,
@@ -133,7 +131,7 @@ export function computeSiteCoverage(scene: Pick<SceneSnapshot, 'nodes'>): SiteCo
   const levels = storeys.length > 0 ? storeys : ground ? [ground] : []
 
   // the footprint: every storey's wall bands, unioned, outer rings only
-  const loops = levels.flatMap((level) => levelFootprintLoops(snapshot, level, building))
+  const loops = levels.flatMap((level) => levelFootprintLoops(snapshot.nodes, level, building))
   const outline = loops.length > 0 ? footprintOutline(loops) : []
   const buildingM2 = outline.reduce((s, ring) => s + polygonArea(ring), 0)
 

package/src/lib/floorplan/site-plan/front-edge.ts

@@ -22,7 +22,8 @@
  * Coordinates are the site plan frame (metres, x east, y south), the frame
  * the lot polygon and the OSM roads share.
  */
-import { edgeLength, outwardNormal, type Pt } from './geometry'
+import { edgeLength, outwardNormal } from '@pascal-app/core'
+import type { Pt } from './geometry'
 import { parseStreetName, sameStreet } from './street-name'
 
 export interface RoadCenterline {

package/src/lib/floorplan/site-plan/geometry.test.ts

@@ -1,20 +1,22 @@
 import { describe, expect, it } from 'bun:test'
-import { sightTriangle, streetCorners } from '@pascal-app/core'
 import {
-  boundsInsidePolygon,
-  castYardDimensions,
   classifyEdges,
   edgeHeadingDeg,
-  formatFeetInches,
-  METRES_PER_FOOT,
   mostNorthFacingEdge,
   outwardNormal,
-  type Pt,
-  polygonArea,
   rayToPolygon,
   resolveFrontEdge,
   setbackEnvelope,
   setbackForRole,
+  sightTriangle,
+  streetCorners,
+} from '@pascal-app/core'
+import {
+  castYardDimensions,
+  formatFeetInches,
+  METRES_PER_FOOT,
+  type Pt,
+  polygonArea,
 } from './geometry'
 
 /**
@@ -258,14 +260,6 @@ describe('rayToPolygon + castYardDimensions', () => {
   })
 })
 
-describe('boundsInsidePolygon', () => {
-  it('is true only when every bbox corner is inside the lot', () => {
-    expect(boundsInsidePolygon(LOT, { minX: 5, minY: 5, maxX: 25, maxY: 15 })).toBe(true)
-    expect(boundsInsidePolygon(LOT, { minX: -5, minY: 5, maxX: 25, maxY: 15 })).toBe(false)
-    expect(boundsInsidePolygon(LOT, { minX: 100, minY: 100, maxX: 110, maxY: 110 })).toBe(false)
-  })
-})
-
 describe('formatFeetInches', () => {
   it('renders metres as feet-and-inches', () => {
     expect(formatFeetInches(7.62)).toBe(`25'-0"`)