@pascal-app/editor 1.0.4 → 1.0.5

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

@@ -10,14 +10,16 @@ import {
   type AnyNode,
   type AnyNodeId,
   type BuildingNode,
-  calculateLevelMiters,
-  getWallPlanFootprint,
+  getRoofSegmentDeckReach,
   type LevelNode,
   migrateSiteMetadata,
+  type RoofSegmentNode,
   type SceneSnapshot,
   type SiteNode,
+  siteFrame,
+  turnPlanPoint,
   unionPolygons,
-  type WallNode,
+  yawOf,
 } from '@pascal-app/core'
 import { type Pt, pointInPolygon, polygonArea, polygonBounds } from './geometry'
 
@@ -69,98 +71,9 @@ export function findLowestLevel(
 }
 
 /**
- * Per-wall plan footprints for a level, mitred, then transformed by the
- * building's site placement. `position` is `[x, y, z]` in site metres (y is
- * height, ignored in plan); `rotation[1]` is the yaw in radians.
- */
-export function levelFootprintLoops(
-  scene: SceneSnapshot,
-  level: LevelNode | null,
-  building: BuildingNode | null,
-): Pt[][] {
-  if (!level) return []
-  const walls: WallNode[] = []
-  for (const childId of level.children ?? []) {
-    const child = scene.nodes[childId as AnyNodeId] as AnyNode | undefined
-    if (child?.type === 'wall') walls.push(child as WallNode)
-  }
-  if (walls.length === 0) return []
-
-  const miters = calculateLevelMiters(walls)
-  const yaw = building?.rotation?.[1] ?? 0
-  const cos = Math.cos(yaw)
-  const sin = Math.sin(yaw)
-  const ox = building?.position?.[0] ?? 0
-  const oz = building?.position?.[2] ?? 0
-
-  const loops: Pt[][] = []
-  for (const wall of walls) {
-    const poly = getWallPlanFootprint(wall, miters)
-    if (poly.length < 3) continue
-    // three.js Y rotation, the convention BuildingRenderer applies:
-    // world = (cos·lx + sin·lz, −sin·lx + cos·lz) + position
-    loops.push(poly.map((p) => [ox + p.x * cos + p.y * sin, oz - p.x * sin + p.y * cos] as Pt))
-  }
-  return loops
-}
-
-/**
- * The outer ring(s) of a set of wall bands: their union, minus any ring that
- * lies inside another (a room enclosed by partitions is a hole in the union,
- * not a second building). Falls back to the bands themselves when the union
- * yields nothing.
- */
-export function footprintOutline(loops: readonly Pt[][]): Pt[][] {
-  const rings = unionPolygons(loops.map((loop) => loop.map((p) => [p[0], p[1]]))) as Pt[][]
-  if (rings.length === 0) return [...loops]
-  const inside = (p: Pt, ring: Pt[]): boolean => {
-    let hit = false
-    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-      const a = ring[i] as Pt
-      const b = ring[j] as Pt
-      if (
-        a[1] > p[1] !== b[1] > p[1] &&
-        p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0]
-      ) {
-        hit = !hit
-      }
-    }
-    return hit
-  }
-  return rings.filter(
-    (ring, i) =>
-      !rings.some((other, j) => j !== i && ring[0] !== undefined && inside(ring[0], other)),
-  )
-}
-
-/** A three.js Y rotation of a plan point: local (x, z) turned by `yaw`. */
-export function turn(x: number, z: number, yaw: number): Pt {
-  const c = Math.cos(yaw)
-  const s = Math.sin(yaw)
-  return [c * x + s * z, -s * x + c * z]
-}
-
-export function yawOf(rotation: unknown): number {
-  if (typeof rotation === 'number') return rotation
-  if (Array.isArray(rotation)) return Number(rotation[1] ?? 0) || 0
-  return 0
-}
-
-/** Level-local plan (x, z) → site metres, through the building's placement (see `levelFootprintLoops`). */
-export function siteFrame(building: BuildingNode | null): (x: number, z: number) => Pt {
-  const yaw = building?.rotation?.[1] ?? 0
-  const ox = building?.position?.[0] ?? 0
-  const oz = building?.position?.[2] ?? 0
-  return (x, z) => {
-    const [tx, tz] = turn(x, z, yaw)
-    return [ox + tx, oz + tz]
-  }
-}
-
-/**
- * The roof's outline on the lot — every roof segment's plan rectangle plus
- * its overhang, through the segment's, the roof's and the building's turns,
- * unioned into the outer ring(s). Dashed on the site plan: what the eye sees
+ * The roof's outline on the lot — every roof segment's plan rectangle out to
+ * its deck's reach at its eaves and rakes, through the segment's, the roof's
+ * and the building's turns, unioned into the outer ring(s). Dashed on the site plan: what the eye sees
  * from above is the roof, and the setback is measured to the wall under it.
  */
 export function roofOutlineRings(
@@ -182,15 +95,10 @@ export function roofOutlineRings(
     if (node.type !== 'roof-segment') continue
     const roof = roofs.get(String((node as { parentId?: unknown }).parentId))
     if (!roof) continue
-    const seg = node as unknown as {
-      position?: number[]
-      rotation?: unknown
-      width?: number
-      depth?: number
-      overhang?: number
-    }
-    const w = (seg.width ?? 0) / 2 + (seg.overhang ?? 0)
-    const d = (seg.depth ?? 0) / 2 + (seg.overhang ?? 0)
+    const seg = node as RoofSegmentNode
+    const reach = getRoofSegmentDeckReach(seg)
+    const w = (seg.width ?? 0) / 2 + reach.x
+    const d = (seg.depth ?? 0) / 2 + reach.z
     if (w <= 0 || d <= 0) continue
     const segYaw = yawOf(seg.rotation)
     const roofYaw = yawOf(roof.rotation)
@@ -206,8 +114,8 @@ export function roofOutlineRings(
     ]
     rects.push(
       local.map(([lx, lz]) => {
-        const [ax, az] = turn(lx, lz, segYaw)
-        const [bx, bz] = turn(ax + sx, az + sz, roofYaw)
+        const [ax, az] = turnPlanPoint(lx, lz, segYaw)
+        const [bx, bz] = turnPlanPoint(ax + sx, az + sz, roofYaw)
         return toSite(bx + rx, bz + rz)
       }),
     )

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

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'bun:test'
-import { castYardDimensions, castYardDimensionsOriented, type Pt } from './geometry'
+import { castYardDimensionsOriented } from '@pascal-app/core'
+import { castYardDimensions, type Pt } from './geometry'
 
 // 20 m × 30 m lot centred on the origin, y south
 const LOT: Pt[] = [

package/src/lib/follow-pascal-exterior.test-fixture.ts

@@ -0,0 +1,17 @@
+import type { AnyNode } from '@pascal-app/core'
+
+// What the nodes package declares as `capabilities.exterior` for its wall, door and window, written
+// out for the tests that register their own throw-away kinds (`packages/editor` does not import
+// `@pascal-app/nodes`).
+
+/** A wall with an outdoor face. */
+export const wallExterior = (node: AnyNode) =>
+  node.type === 'wall' && (node.frontSide === 'exterior' || node.backSide === 'exterior')
+
+/** An opening in a roof segment or in such a wall. */
+export const openingExterior = (node: AnyNode, nodes: Readonly<Record<string, AnyNode>>) => {
+  if (node.type !== 'door' && node.type !== 'window') return false
+  if (node.roofSegmentId) return true
+  const host = nodes[node.wallId ?? node.parentId ?? '']
+  return host ? wallExterior(host) : false
+}

package/src/lib/follow-pascal-exterior.test.ts

@@ -0,0 +1,171 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  BuildingNode,
+  type Capabilities,
+  DoorNode,
+  ItemNode,
+  LevelNode,
+  loadPlugin,
+  nodeRegistry,
+  RoofNode,
+  RoofSegmentNode,
+  SiteNode,
+  WallNode,
+} from '@pascal-app/core'
+import { anyExterior, isExteriorNode } from './follow-pascal-exterior'
+import { openingExterior, wallExterior } from './follow-pascal-exterior.test-fixture'
+
+// The kinds are the nodes package's (it declares `capabilities.exterior` on them); fixtures of the
+// same kind stand in for them here, and plugin-style kinds that declare the same fields are held to
+// the same rules.
+const kind = (type: string, schema: unknown, exterior?: Capabilities['exterior']) =>
+  ({
+    kind: type,
+    schemaVersion: 1,
+    schema,
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: exterior === undefined ? {} : { exterior },
+    geometry: () => null,
+  }) as unknown as AnyNodeDefinition
+
+let restoreRegistry: () => void = () => {}
+beforeAll(async () => {
+  restoreRegistry = nodeRegistry._snapshot()
+  nodeRegistry._reset()
+  await loadPlugin({
+    id: 'fixture:exterior',
+    apiVersion: 1,
+    nodes: [
+      kind('site', SiteNode, true),
+      kind('building', BuildingNode, false),
+      kind('level', LevelNode, false),
+      kind('roof', RoofNode, true),
+      kind('roof-segment', RoofSegmentNode, true),
+      kind('wall', WallNode, wallExterior),
+      kind('door', DoorNode, openingExterior),
+      kind('item', ItemNode),
+      // A plugin's own kinds: outdoors, outdoors by a field, and saying nothing.
+      kind('fixture:deck', ItemNode, true),
+      kind('fixture:cover', ItemNode, (node) => (node.name === 'seen' ? true : undefined)),
+      kind('fixture:cable', ItemNode),
+    ],
+  })
+})
+afterAll(() => restoreRegistry())
+
+function scene() {
+  const site = SiteNode.parse({ id: 'site_x' })
+  const building = BuildingNode.parse({ id: 'building_x', parentId: site.id })
+  const level = LevelNode.parse({ id: 'level_x', parentId: building.id, level: 0 })
+  const outer = WallNode.parse({
+    id: 'wall_outer',
+    parentId: level.id,
+    start: [0, 0],
+    end: [4, 0],
+    frontSide: 'interior',
+    backSide: 'exterior',
+  })
+  const inner = WallNode.parse({
+    id: 'wall_inner',
+    parentId: level.id,
+    start: [0, 2],
+    end: [4, 2],
+    frontSide: 'interior',
+    backSide: 'interior',
+  })
+  const onOuter = DoorNode.parse({ id: 'door_outer', parentId: outer.id, wallId: outer.id })
+  const onInner = DoorNode.parse({ id: 'door_inner', parentId: inner.id, wallId: inner.id })
+  const sofa = ItemNode.parse({
+    id: 'item_sofa',
+    parentId: level.id,
+    asset: {
+      id: 'sofa',
+      category: 'furniture',
+      name: 'Sofa',
+      thumbnail: '',
+      src: '/sofa.glb',
+      dimensions: [2, 1, 1],
+    },
+  })
+  const bench = ItemNode.parse({ ...sofa, id: 'item_bench', parentId: site.id })
+  const segment = RoofSegmentNode.parse({ id: 'rseg_x', parentId: 'roof_x' })
+  const roof = RoofNode.parse({ id: 'roof_x', parentId: level.id, children: [segment.id] })
+  // Only their kind, name and parent matter here.
+  const plugin = (id: string, type: string, parentId: string, name?: string) =>
+    ({ id, type, parentId, name }) as unknown as AnyNode
+  const deck = plugin('deck_x', 'fixture:deck', site.id)
+  const deckOnLevel = plugin('deck_level', 'fixture:deck', level.id)
+  const underDeck = plugin('cable_deck', 'fixture:cable', deckOnLevel.id)
+  const underRoof = plugin('cable_roof', 'fixture:cable', roof.id)
+  const cableInRoom = plugin('cable_room', 'fixture:cable', level.id)
+  const seen = plugin('cover_seen', 'fixture:cover', level.id, 'seen')
+  const unseen = plugin('cover_unseen', 'fixture:cover', level.id)
+  const coverOnSite = plugin('cover_site', 'fixture:cover', site.id)
+  return Object.fromEntries(
+    [
+      site,
+      building,
+      level,
+      outer,
+      inner,
+      onOuter,
+      onInner,
+      sofa,
+      bench,
+      roof,
+      segment,
+      deck,
+      deckOnLevel,
+      underDeck,
+      underRoof,
+      cableInRoom,
+      seen,
+      unseen,
+      coverOnSite,
+    ].map((node) => [node.id, node as AnyNode]),
+  )
+}
+
+describe('what a change is seen from', () => {
+  const nodes = scene()
+
+  test('a wall with an exterior face, and an opening in it, are seen from outside', () => {
+    expect(isExteriorNode(nodes, 'wall_outer')).toBe(true)
+    expect(isExteriorNode(nodes, 'door_outer')).toBe(true)
+  })
+
+  test('an interior wall, an opening in it and furniture are looked at through a cutaway', () => {
+    expect(isExteriorNode(nodes, 'wall_inner')).toBe(false)
+    expect(isExteriorNode(nodes, 'door_inner')).toBe(false)
+    expect(isExteriorNode(nodes, 'item_sofa')).toBe(false)
+  })
+
+  test('a roof and what stands on it, the ground, and furnishing standing in no storey are outside', () => {
+    for (const id of ['roof_x', 'rseg_x', 'deck_x', 'item_bench'])
+      expect(isExteriorNode(nodes, id)).toBe(true)
+  })
+
+  // A kind that declares what the built-ins declare is treated as the built-in is.
+  test('a plugin kind is outdoors as its definition says: always, by a field, or by what holds it', () => {
+    expect(isExteriorNode(nodes, 'deck_level')).toBe(true)
+    expect(isExteriorNode(nodes, 'cover_seen')).toBe(true)
+    expect(isExteriorNode(nodes, 'cover_unseen')).toBe(false)
+    expect(isExteriorNode(nodes, 'cable_deck')).toBe(true)
+    expect(isExteriorNode(nodes, 'cable_roof')).toBe(true)
+    expect(isExteriorNode(nodes, 'cable_room')).toBe(false)
+    expect(isExteriorNode(nodes, 'cover_site')).toBe(true)
+  })
+
+  test('a node that is not in the scene is nothing', () => {
+    expect(isExteriorNode(nodes, 'wall_gone')).toBe(false)
+  })
+
+  test('a group is outside when any of its nodes is', () => {
+    expect(anyExterior(nodes, ['item_sofa', 'door_outer'])).toBe(true)
+    expect(anyExterior(nodes, ['item_sofa', 'wall_inner'])).toBe(false)
+    expect(anyExterior(nodes, [])).toBe(false)
+  })
+})

package/src/lib/follow-pascal-exterior.ts

@@ -0,0 +1,39 @@
+import { type AnyNode, type AnyNodeId, findLevelAncestorId, nodeRegistry } from '@pascal-app/core'
+
+type Nodes = Readonly<Record<string, AnyNode>>
+
+/** What a kind says about a node (`capabilities.exterior`): outdoors, never, or nothing. */
+function declaredExterior(node: AnyNode, nodes: Nodes): boolean | undefined {
+  const exterior = nodeRegistry.get(node.type)?.capabilities?.exterior
+  return typeof exterior === 'function' ? exterior(node, nodes) : exterior
+}
+
+/**
+ * Whether a change to this node is seen from outside, as its kind declares (`capabilities.exterior`:
+ * a roof, a wall with an exterior face and an opening in it, a fence). A node whose kind says nothing
+ * is outdoors when what holds it is (a chimney's cap), or when it stands in no building's storey
+ * (outdoor furnishing, plants). A sofa, an interior wall and a finish inside are not: they are looked
+ * at through a cutaway.
+ */
+export function isExteriorNode(nodes: Nodes, id: string): boolean {
+  const node = nodes[id]
+  if (!node) return false
+  const own = declaredExterior(node, nodes)
+  if (own !== undefined) return own
+  // Standing under a node that is outdoors, up to the first one that never is (a storey).
+  for (
+    let at = node.parentId ? nodes[node.parentId] : undefined, guard = 0;
+    at && guard < 16;
+    at = at.parentId ? nodes[at.parentId] : undefined, guard += 1
+  ) {
+    const held = nodeRegistry.get(at.type)?.capabilities?.exterior
+    if (held === true) return true
+    if (held === false) break
+  }
+  return findLevelAncestorId(id as AnyNodeId, nodes as never) === null
+}
+
+/** Whether any of `ids` is a change seen from outside. */
+export function anyExterior(nodes: Nodes, ids: readonly string[]): boolean {
+  return ids.some((id) => isExteriorNode(nodes, id))
+}

package/src/lib/follow-pascal-presentation.test.ts

@@ -0,0 +1,203 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  type Floor,
+  FollowPresentation,
+  type PresentationPort,
+  type ViewPresentation,
+} from './follow-pascal-presentation'
+
+// The owner, 12 October, on 3114: Follow Pascal left the view in cutaway with the upper floors hidden
+// after it stopped, and the walls looked invisible. Follow changes the presentation to see what a build
+// works on; when it ends it puts back what it changed, and only that.
+
+const GROUND: Floor = {
+  buildingId: 'b',
+  levelId: 'ground',
+  zoneId: null,
+  selectedIds: [],
+  room: null,
+}
+
+/** A view and a record of every write made to it. */
+function view(initial: Partial<ViewPresentation> = {}) {
+  const state: ViewPresentation = {
+    wall: 'up',
+    levels: 'stacked',
+    hideAbove: false,
+    floor: { ...GROUND },
+    ...initial,
+  }
+  const writes: string[] = []
+  const port: PresentationPort = {
+    read: () => ({ ...state, floor: { ...state.floor } }),
+    setWall: (mode) => {
+      writes.push(`wall:${mode}`)
+      state.wall = mode
+    },
+    setLevels: (mode) => {
+      writes.push(`levels:${mode}`)
+      state.levels = mode
+    },
+    setHideAbove: (hide) => {
+      writes.push(`hideAbove:${hide}`)
+      state.hideAbove = hide
+    },
+    // A selected floor drops the room and what was picked, as the viewer's selection does.
+    setFloor: ({ buildingId, levelId }) => {
+      writes.push(`floor:${levelId}`)
+      state.floor = {
+        buildingId: buildingId ?? state.floor.buildingId,
+        levelId,
+        zoneId: null,
+        selectedIds: [],
+        room: null,
+      }
+    },
+    putFloor: (floor) => {
+      writes.push(`put:${floor.levelId}`)
+      state.floor = { ...floor }
+    },
+  }
+  return { state, writes, port }
+}
+
+describe('what Follow changes, it puts back', () => {
+  test('the cutaway it switched to', () => {
+    const { state, port } = view({ wall: 'up' })
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    expect(state.wall).toBe('cutaway')
+    follow.restore()
+    expect(state.wall).toBe('up')
+  })
+
+  test('the floor it selected, with the room and the picks the person had', () => {
+    const had: Floor = {
+      buildingId: 'b',
+      levelId: 'upper',
+      zoneId: 'zone_kitchen',
+      selectedIds: ['item_a', 'item_b'],
+      room: { levelId: 'upper', zoneId: 'zone_kitchen' },
+    }
+    const { state, port } = view({ floor: had })
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'ground' })
+    expect(state.floor.levelId).toBe('ground')
+    expect(state.floor.room).toBeNull()
+    follow.restore()
+    expect(state.floor).toEqual(had)
+  })
+
+  test('the upper floors it hid, and the level display it set', () => {
+    const { state, port } = view({ hideAbove: false, levels: 'solo' })
+    const follow = new FollowPresentation(port)
+    follow.hideAbove(true)
+    follow.levels('stacked')
+    expect(state).toMatchObject({ hideAbove: true, levels: 'stacked' })
+    follow.restore()
+    expect(state).toMatchObject({ hideAbove: false, levels: 'solo' })
+  })
+
+  test('to what the person had before the first change, however many floors it visited', () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    follow.floor({ buildingId: 'b', levelId: 'roof' })
+    follow.wall('cutaway')
+    follow.wall('cutaway')
+    follow.restore()
+    expect(state.floor.levelId).toBe('ground')
+    expect(state.wall).toBe('up')
+  })
+
+  test('nothing it did not change: a setting already as Follow wants it is not written', () => {
+    const { writes, port } = view({ wall: 'cutaway', hideAbove: true, levels: 'stacked' })
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.hideAbove(true)
+    follow.levels('stacked')
+    follow.floor({ buildingId: 'b', levelId: 'ground' })
+    follow.restore()
+    expect(writes).toEqual([])
+  })
+
+  test('once: ending again, with nothing held, writes nothing', () => {
+    const { writes, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.restore()
+    const count = writes.length
+    follow.restore()
+    expect(writes).toHaveLength(count)
+  })
+
+  test('a later session starts from what the person has then', () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.restore()
+    state.wall = 'down'
+    follow.wall('cutaway')
+    follow.restore()
+    expect(state.wall).toBe('down')
+  })
+})
+
+describe("the person's own choices stand", () => {
+  test('a wall mode picked while Follow is on is kept, and Follow does not take it back', () => {
+    const { state, writes, port } = view({ wall: 'up' })
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    state.wall = 'translucent'
+    follow.wall('cutaway')
+    expect(state.wall).toBe('translucent')
+    follow.restore()
+    expect(state.wall).toBe('translucent')
+    expect(writes).toEqual(['wall:cutaway'])
+  })
+
+  test('a floor picked while Follow is on is kept, and Follow does not select over it', () => {
+    const { state, writes, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    state.floor = { ...state.floor, levelId: 'roof' }
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    expect(state.floor.levelId).toBe('roof')
+    follow.restore()
+    expect(state.floor.levelId).toBe('roof')
+    expect(writes).toEqual(['floor:upper'])
+  })
+
+  test('the floor stays when the person picked something on it', () => {
+    const { state, writes, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    state.floor = { ...state.floor, selectedIds: ['item_x'] }
+    follow.restore()
+    expect(state.floor).toMatchObject({ levelId: 'upper', selectedIds: ['item_x'] })
+    expect(writes).toEqual(['floor:upper'])
+  })
+
+  test('the settings are independent: a wall mode of their own, the floor still goes back', () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    follow.floor({ buildingId: 'b', levelId: 'upper' })
+    state.wall = 'down'
+    follow.restore()
+    expect(state.wall).toBe('down')
+    expect(state.floor.levelId).toBe('ground')
+  })
+
+  test("the person's choice is theirs for the session, then Follow may change it again", () => {
+    const { state, port } = view()
+    const follow = new FollowPresentation(port)
+    follow.wall('cutaway')
+    state.wall = 'down'
+    follow.restore()
+    follow.wall('cutaway')
+    expect(port.read().wall).toBe('cutaway')
+    follow.restore()
+    expect(port.read().wall).toBe('down')
+  })
+})