@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/floorplan/items.ts

@@ -2,6 +2,8 @@ import {
   type AnyNode,
   type AnyNodeId,
   getScaledDimensions,
+  getWallBodyCenterOffset,
+  getWallLocalFaceZ,
   type ItemNode,
   type LevelNode,
   useLiveTransforms,
@@ -82,8 +84,9 @@ export function getItemFloorplanTransform(
       )
       const wallLocalZ =
         item.asset.attachTo === 'wall-side'
-          ? ((parentNode.thickness ?? 0.1) / 2) * (item.side === 'front' ? 1 : -1)
-          : item.position[2]
+          ? getWallLocalFaceZ(parentNode, item.side === 'front' ? 'a' : 'b')
+          : item.position[2] +
+            (item.asset.attachTo === 'wall' ? getWallBodyCenterOffset(parentNode) : 0)
       const [offsetX, offsetY] = rotatePlanVector(item.position[0], wallLocalZ, wallRotation)
 
       result = {

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

@@ -0,0 +1,213 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, AnyNodeId } from '@pascal-app/core'
+import { persistResolvedMarks, resolveMarkDetail, resolveMarks } from './marks'
+
+/**
+ * Fixture: a rectangular level, walls running clockwise on screen from the
+ * north-west corner.
+ *
+ *   north  [0,0] → [6,0]      doors d_n1 @1, d_n2 @4
+ *   east   [6,0] → [6,4]      window w_e1 @2
+ *   south  [6,4] → [0,4]      door d_s1 @2
+ *   west   [0,4] → [0,0]      (interior partition, no openings)
+ */
+function fixture(levelOrdinal = 0): 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: levelOrdinal,
+    children: ['w_n', 'w_e', 'w_s', 'w_w'],
+  })
+  node({
+    id: 'w_n',
+    type: 'wall',
+    parentId: 'level_1',
+    start: [0, 0],
+    end: [6, 0],
+    thickness: 0.15,
+    frontSide: 'exterior',
+    backSide: 'interior',
+    children: ['d_n1', 'd_n2'],
+  })
+  node({
+    id: 'w_e',
+    type: 'wall',
+    parentId: 'level_1',
+    start: [6, 0],
+    end: [6, 4],
+    thickness: 0.15,
+    frontSide: 'exterior',
+    backSide: 'interior',
+    children: ['win_e1'],
+  })
+  node({
+    id: 'w_s',
+    type: 'wall',
+    parentId: 'level_1',
+    start: [6, 4],
+    end: [0, 4],
+    thickness: 0.15,
+    frontSide: 'exterior',
+    backSide: 'interior',
+    children: ['d_s1'],
+  })
+  node({
+    id: 'w_w',
+    type: 'wall',
+    parentId: 'level_1',
+    start: [0, 4],
+    end: [0, 0],
+    thickness: 0.1,
+    frontSide: 'interior',
+    backSide: 'interior',
+    children: [],
+  })
+
+  const door = (id: string, wallId: string, along: number) =>
+    node({
+      id,
+      type: 'door',
+      parentId: wallId,
+      wallId,
+      width: 0.9,
+      height: 2.1,
+      position: [along, 1.05, 0],
+    })
+  door('d_n1', 'w_n', 1)
+  door('d_n2', 'w_n', 4)
+  door('d_s1', 'w_s', 2)
+  node({
+    id: 'win_e1',
+    type: 'window',
+    parentId: 'w_e',
+    wallId: 'w_e',
+    width: 1.2,
+    height: 1.2,
+    position: [2, 1.1, 0],
+  })
+  return nodes
+}
+
+describe('resolveMarks', () => {
+  test('doors are D101…, windows W101… on level 0', () => {
+    const marks = resolveMarks(fixture(), 'level_1' as AnyNodeId)
+    expect(marks.get('d_n1')).toBe('D101')
+    expect(marks.get('d_n2')).toBe('D102')
+    expect(marks.get('d_s1')).toBe('D103')
+    expect(marks.get('win_e1')).toBe('W101')
+  })
+
+  test('level ordinal shifts the base by 100', () => {
+    const marks = resolveMarks(fixture(1), 'level_1' as AnyNodeId)
+    expect(marks.get('d_n1')).toBe('D201')
+    expect(marks.get('win_e1')).toBe('W201')
+  })
+
+  test('openings are ordered clockwise from the north-west, exterior walls first', () => {
+    const nodes = fixture()
+    // Move the west partition's opening onto it to prove interior comes last.
+    ;(nodes.w_w as unknown as { children: string[] }).children = ['d_w1']
+    nodes.d_w1 = {
+      object: 'node',
+      id: 'd_w1',
+      type: 'door',
+      parentId: 'w_w',
+      wallId: 'w_w',
+      visible: true,
+      metadata: {},
+      width: 0.8,
+      height: 2.1,
+      position: [2, 1.05, 0],
+      children: [],
+    } as unknown as AnyNode
+    const marks = resolveMarks(nodes, 'level_1' as AnyNodeId)
+    // North (exterior) first, then the other exterior walls, interior last.
+    expect(marks.get('d_w1')).toBe('D104')
+  })
+
+  test('an explicit mark wins and is never reassigned', () => {
+    const nodes = fixture()
+    ;(nodes.d_n2 as unknown as { mark: string }).mark = 'D-GARAGE'
+    const marks = resolveMarks(nodes, 'level_1' as AnyNodeId)
+    expect(marks.get('d_n2')).toBe('D-GARAGE')
+    expect(marks.get('d_n1')).toBe('D101')
+    expect(marks.get('d_s1')).toBe('D102')
+  })
+
+  test('duplicate explicit marks are reported, not silently renumbered', () => {
+    const nodes = fixture()
+    ;(nodes.d_n1 as unknown as { mark: string }).mark = 'D101'
+    ;(nodes.d_n2 as unknown as { mark: string }).mark = 'D101'
+    const resolution = resolveMarkDetail(nodes, 'level_1' as AnyNodeId)
+    expect(resolution.issues).toEqual(['Duplicate door mark D101 (2 instances)'])
+  })
+
+  test('numbering is stable under insertion once persisted', () => {
+    const nodes = fixture()
+    const first = resolveMarkDetail(nodes, 'level_1' as AnyNodeId)
+    expect([...first.assignments.values()]).toEqual(['D101', 'D102', 'D103', 'W101'])
+
+    // Persist, the way an edit session does the first time it resolves.
+    const written = persistResolvedMarks(first, (id, data) => {
+      ;(nodes[id] as unknown as Record<string, unknown>).mark = data.mark
+    })
+    expect(written).toBe(4)
+
+    // Insert a door BETWEEN d_n1 and d_n2 on the same wall.
+    ;(nodes.w_n as unknown as { children: string[] }).children = ['d_n1', 'd_new', 'd_n2']
+    nodes.d_new = {
+      object: 'node',
+      id: 'd_new',
+      type: 'door',
+      parentId: 'w_n',
+      wallId: 'w_n',
+      visible: true,
+      metadata: {},
+      width: 0.8,
+      height: 2.1,
+      position: [2.5, 1.05, 0],
+      children: [],
+    } as unknown as AnyNode
+
+    const second = resolveMarkDetail(nodes, 'level_1' as AnyNodeId)
+    // Existing doors keep their marks; the new one takes the next free number.
+    expect(second.marks.get('d_n1')).toBe('D101')
+    expect(second.marks.get('d_n2')).toBe('D102')
+    expect(second.marks.get('d_s1')).toBe('D103')
+    expect(second.marks.get('d_new')).toBe('D104')
+    expect([...second.assignments.keys()]).toEqual(['d_new'])
+  })
+
+  test('WITHOUT persisting, inserting mid-wall renumbers — which is why we persist', () => {
+    const nodes = fixture()
+    ;(nodes.w_n as unknown as { children: string[] }).children = ['d_n1', 'd_new', 'd_n2']
+    nodes.d_new = {
+      object: 'node',
+      id: 'd_new',
+      type: 'door',
+      parentId: 'w_n',
+      wallId: 'w_n',
+      visible: true,
+      metadata: {},
+      width: 0.8,
+      height: 2.1,
+      position: [2.5, 1.05, 0],
+      children: [],
+    } as unknown as AnyNode
+    const marks = resolveMarks(nodes, 'level_1' as AnyNodeId)
+    expect(marks.get('d_new')).toBe('D102')
+    expect(marks.get('d_n2')).toBe('D103')
+  })
+})

package/src/lib/floorplan/marks.ts

@@ -0,0 +1,238 @@
+import type {
+  AnyNode,
+  AnyNodeId,
+  DoorNode,
+  LevelNode,
+  WallNode,
+  WindowNode,
+} from '@pascal-app/core'
+
+/**
+ * Deterministic door / window marks per level — WS3.
+ *
+ * `packages/core/src/schema/nodes/door.ts:75-79` promises "the deterministic
+ * level fallback (101, 102, ...)"; this is the implementation.
+ *
+ * Numbering
+ * ---------
+ *   base   = (level.level + 1) * 100          — level 0 → 100, level 1 → 200
+ *   doors  = `D${base + n}`   → D101, D102 …
+ *   windows= `W${base + n}`   → W101, W102 …
+ *
+ * Order
+ * -----
+ * Openings are visited **clockwise** around the level, starting from the
+ * north-west-most exterior wall, exterior walls first and interior walls
+ * after. Clockwise is the ascending-angle sweep of the wall midpoint about
+ * the level centroid, anchored on the north-west diagonal (plan axes are
+ * x east, z south — z grows down the screen — so a screen-clockwise sweep
+ * is increasing atan2(z, x)). Openings on the same wall are ordered along
+ * the wall direction.
+ *
+ * Stability
+ * ---------
+ * An explicit `mark` on the node always wins and is never reassigned.
+ * `resolveMarks` also reports, in `assignments`, the marks it invented for
+ * nodes that had none — the caller is expected to PERSIST those back onto
+ * `node.mark` the first time they are resolved in an edit session
+ * (`persistResolvedMarks`). That is what makes numbering stable under
+ * insertion: once written, an existing opening keeps its number forever and
+ * a newly inserted opening only ever takes the next free number. Without
+ * the write-back, inserting a door in the middle of a wall would silently
+ * renumber every door after it.
+ */
+
+export type OpeningMarkKind = 'door' | 'window'
+
+export type MarkResolution = {
+  /** Every door and window on the level → its mark. */
+  marks: ReadonlyMap<string, string>
+  /** Only the marks that were invented (node.mark was empty). */
+  assignments: ReadonlyMap<string, string>
+  /** Duplicate explicit marks and other reportable defects. */
+  issues: readonly string[]
+}
+
+export type MarkSceneInput = {
+  nodes: Readonly<Record<string, AnyNode>>
+}
+
+/**
+ * Resolve marks for every door and window under `levelId`.
+ *
+ * `scene` may be a `{ nodes }` snapshot or the raw node map.
+ */
+export function resolveMarks(
+  scene: MarkSceneInput | Readonly<Record<string, AnyNode>>,
+  levelId: AnyNodeId,
+): Map<string, string> {
+  return new Map(resolveMarkDetail(scene, levelId).marks)
+}
+
+export function resolveMarkDetail(
+  scene: MarkSceneInput | Readonly<Record<string, AnyNode>>,
+  levelId: AnyNodeId,
+): MarkResolution {
+  const nodes = normalizeNodes(scene)
+  const level = nodes[levelId]
+  const ordinal = level && level.type === 'level' ? ((level as LevelNode).level ?? 0) : 0
+  const base = (Math.max(0, ordinal) + 1) * 100
+
+  const openings = orderedOpenings(nodes, levelId)
+  const marks = new Map<string, string>()
+  const assignments = new Map<string, string>()
+  const issues: string[] = []
+
+  for (const kind of ['door', 'window'] as const) {
+    const prefix = kind === 'door' ? 'D' : 'W'
+    const list = openings.filter((opening) => opening.type === kind)
+    const used = new Set<string>()
+    const explicitOwners = new Map<string, string[]>()
+
+    for (const opening of list) {
+      const explicit = opening.mark?.trim()
+      if (!explicit) continue
+      marks.set(opening.id, explicit)
+      const normalized = explicit.toLocaleUpperCase()
+      used.add(normalized)
+      const owners = explicitOwners.get(normalized)
+      if (owners) owners.push(opening.id)
+      else explicitOwners.set(normalized, [opening.id])
+    }
+
+    let sequence = 1
+    for (const opening of list) {
+      if (marks.has(opening.id)) continue
+      let candidate = `${prefix}${base + sequence}`
+      while (used.has(candidate.toLocaleUpperCase())) {
+        sequence++
+        candidate = `${prefix}${base + sequence}`
+      }
+      marks.set(opening.id, candidate)
+      assignments.set(opening.id, candidate)
+      used.add(candidate.toLocaleUpperCase())
+      sequence++
+    }
+
+    for (const [mark, owners] of explicitOwners) {
+      if (owners.length > 1) {
+        issues.push(`Duplicate ${kind} mark ${mark} (${owners.length} instances)`)
+      }
+    }
+  }
+
+  return { marks, assignments, issues }
+}
+
+/**
+ * Write invented marks back onto the nodes so numbering never drifts.
+ *
+ * Call once per level per edit session (the caller decides when — this
+ * module stays pure). `update` is typically `sceneApi.update`.
+ */
+export function persistResolvedMarks(
+  resolution: MarkResolution,
+  update: (id: AnyNodeId, data: Record<string, unknown>) => void,
+): number {
+  let written = 0
+  for (const [id, mark] of resolution.assignments) {
+    update(id as AnyNodeId, { mark })
+    written++
+  }
+  return written
+}
+
+// ── Ordering ─────────────────────────────────────────────────────────
+
+type Opening = (DoorNode | WindowNode) & { type: 'door' | 'window' }
+
+/**
+ * Every door and window under the level, clockwise from the NW-most
+ * exterior wall, exterior walls first.
+ */
+export function orderedOpenings(
+  nodes: Readonly<Record<string, AnyNode>>,
+  levelId: AnyNodeId,
+): Opening[] {
+  const walls: WallNode[] = []
+  const orphanOpenings: Opening[] = []
+
+  const visit = (id: string) => {
+    const node = nodes[id]
+    if (!node) return
+    if (node.visible === false) return
+    if (node.type === 'wall') walls.push(node as WallNode)
+    else if (node.type === 'door' || node.type === 'window') {
+      const opening = node as Opening
+      if (!opening.wallId || !nodes[opening.wallId]) orphanOpenings.push(opening)
+    }
+    for (const childId of (node as { children?: string[] }).children ?? []) visit(childId)
+  }
+  visit(levelId)
+
+  const centroid = wallCentroid(walls)
+  const ordered = [...walls].sort((left, right) => {
+    const leftExterior = isExteriorWall(left) ? 0 : 1
+    const rightExterior = isExteriorWall(right) ? 0 : 1
+    if (leftExterior !== rightExterior) return leftExterior - rightExterior
+    return clockwiseKey(left, centroid) - clockwiseKey(right, centroid)
+  })
+
+  const result: Opening[] = []
+  for (const wall of ordered) {
+    const wallOpenings: Opening[] = []
+    for (const childId of wall.children ?? []) {
+      const child = nodes[childId]
+      if (child && child.visible !== false && (child.type === 'door' || child.type === 'window')) {
+        wallOpenings.push(child as Opening)
+      }
+    }
+    wallOpenings.sort((left, right) => left.position[0] - right.position[0])
+    result.push(...wallOpenings)
+  }
+  result.push(...orphanOpenings)
+  return result
+}
+
+function wallCentroid(walls: readonly WallNode[]): [number, number] {
+  if (walls.length === 0) return [0, 0]
+  let x = 0
+  let z = 0
+  for (const wall of walls) {
+    x += (wall.start[0] + wall.end[0]) / 2
+    z += (wall.start[1] + wall.end[1]) / 2
+  }
+  return [x / walls.length, z / walls.length]
+}
+
+/**
+ * Sweep key: 0 at the north-west direction, increasing clockwise on screen.
+ *
+ * Plan axes are x east, z south — z grows DOWN the screen — so a clockwise
+ * screen sweep (up → right → down → left) is the INCREASING atan2(z, x)
+ * direction. The north-west diagonal sits at atan2(-1, -1) = -3π/4, so
+ * anchoring there and wrapping into [0, 2π) yields north, east, south, west.
+ */
+const NORTH_WEST_ANGLE = (-3 * Math.PI) / 4
+
+function clockwiseKey(wall: WallNode, centroid: readonly [number, number]): number {
+  const midX = (wall.start[0] + wall.end[0]) / 2 - centroid[0]
+  const midZ = (wall.start[1] + wall.end[1]) / 2 - centroid[1]
+  let sweep = Math.atan2(midZ, midX) - NORTH_WEST_ANGLE
+  while (sweep < 0) sweep += Math.PI * 2
+  while (sweep >= Math.PI * 2) sweep -= Math.PI * 2
+  return sweep
+}
+
+function isExteriorWall(wall: WallNode): boolean {
+  return wall.frontSide === 'exterior' || wall.backSide === 'exterior'
+}
+
+function normalizeNodes(
+  scene: MarkSceneInput | Readonly<Record<string, AnyNode>>,
+): Readonly<Record<string, AnyNode>> {
+  const candidate = scene as MarkSceneInput
+  return candidate && typeof candidate === 'object' && 'nodes' in candidate
+    ? candidate.nodes
+    : (scene as Readonly<Record<string, AnyNode>>)
+}