@pascal-app/editor 0.6.0 → 0.7.0

package/src/lib/scene-bounds.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core/schema'
+import { computeSceneBoundsXZ } from './scene-bounds'
+
+function makeWall(start: [number, number], end: [number, number]): AnyNode {
+  return {
+    object: 'node',
+    id: `wall_${start.join('_')}_${end.join('_')}`,
+    type: 'wall',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    children: [],
+    start,
+    end,
+    frontSide: 'unknown',
+    backSide: 'unknown',
+  } as unknown as AnyNode
+}
+
+function makeZone(polygon: [number, number][]): AnyNode {
+  return {
+    object: 'node',
+    id: `zone_${polygon.length}_${polygon[0]?.[0] ?? 0}`,
+    type: 'zone',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    name: 'Zone',
+    polygon,
+    color: '#000000',
+  } as unknown as AnyNode
+}
+
+function makeSite(points: [number, number][]): AnyNode {
+  return {
+    object: 'node',
+    id: 'site_test',
+    type: 'site',
+    parentId: null,
+    visible: true,
+    metadata: {},
+    polygon: { type: 'polygon', points },
+    children: [],
+  } as unknown as AnyNode
+}
+
+describe('computeSceneBoundsXZ', () => {
+  test('returns null when given an empty array', () => {
+    expect(computeSceneBoundsXZ([])).toBeNull()
+  })
+
+  test('returns null when no geometry is found on any node', () => {
+    const barren = [
+      {
+        object: 'node',
+        id: 'building_1',
+        type: 'building',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+      } as unknown as AnyNode,
+    ]
+    expect(computeSceneBoundsXZ(barren)).toBeNull()
+  })
+
+  test('computes bounds from wall endpoints', () => {
+    const nodes: AnyNode[] = [makeWall([0, 0], [4, 0]), makeWall([4, 0], [4, 3])]
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    expect(bounds!.min).toEqual([0, 0])
+    expect(bounds!.max).toEqual([4, 3])
+    expect(bounds!.size).toEqual([4, 3])
+    expect(bounds!.center).toEqual([2, 1.5])
+  })
+
+  test('includes zone polygons', () => {
+    const nodes: AnyNode[] = [
+      makeZone([
+        [-10, -5],
+        [10, -5],
+        [10, 5],
+        [-10, 5],
+      ]),
+    ]
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    expect(bounds!.min).toEqual([-10, -5])
+    expect(bounds!.max).toEqual([10, 5])
+    expect(bounds!.size).toEqual([20, 10])
+  })
+
+  test('ignores the default 30×30 site bootstrap polygon', () => {
+    const nodes: AnyNode[] = [
+      makeSite([
+        [-15, -15],
+        [15, -15],
+        [15, 15],
+        [-15, 15],
+      ]),
+      makeWall([1, 1], [2, 2]),
+    ]
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    // Only the wall should count — the default site polygon is skipped.
+    expect(bounds!.min).toEqual([1, 1])
+    expect(bounds!.max).toEqual([2, 2])
+  })
+
+  test('honours a non-default site polygon', () => {
+    const nodes: AnyNode[] = [
+      makeSite([
+        [-25, -20],
+        [25, -20],
+        [25, 20],
+        [-25, 20],
+      ]),
+    ]
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    expect(bounds!.min).toEqual([-25, -20])
+    expect(bounds!.max).toEqual([25, 20])
+  })
+
+  test('combines walls, zones and positions across the flat dict', () => {
+    const nodes: Record<string, AnyNode> = {
+      wallA: makeWall([-8, -3], [4, -3]),
+      wallB: makeWall([4, -3], [4, 6]),
+      zoneA: makeZone([
+        [-8, -3],
+        [4, -3],
+        [4, 6],
+        [-8, 6],
+      ]),
+      item1: {
+        object: 'node',
+        id: 'item_1',
+        type: 'item',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [7, 0, 8],
+        rotation: [0, 0, 0],
+        scale: [1, 1, 1],
+        children: [],
+        asset: {
+          id: 'a',
+          category: 'furniture',
+          name: 'Chair',
+          thumbnail: '',
+          src: '',
+          dimensions: [1, 1, 1],
+          offset: [0, 0, 0],
+          rotation: [0, 0, 0],
+          scale: [1, 1, 1],
+        },
+      } as unknown as AnyNode,
+    }
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    expect(bounds!.min).toEqual([-8, -3])
+    expect(bounds!.max).toEqual([7, 8])
+  })
+
+  test('handles a single degenerate point with a minimum extent', () => {
+    const nodes: AnyNode[] = [makeWall([2, 2], [2, 2])]
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    expect(bounds!.size[0]).toBeGreaterThan(0)
+    expect(bounds!.size[1]).toBeGreaterThan(0)
+    expect(bounds!.center).toEqual([2, 2])
+  })
+
+  test('skips non-finite coordinates', () => {
+    const nodes: AnyNode[] = [makeWall([Number.NaN, 0], [4, 2]), makeWall([0, 0], [1, 1])]
+    const bounds = computeSceneBoundsXZ(nodes)
+    expect(bounds).not.toBeNull()
+    // NaN should be ignored; the usable points are (4,2), (0,0), (1,1).
+    expect(bounds!.min).toEqual([0, 0])
+    expect(bounds!.max).toEqual([4, 2])
+  })
+})

package/src/lib/scene-bounds.ts

@@ -0,0 +1,169 @@
+/**
+ * Scene bounds in the X/Z plane.
+ *
+ * Used by the auto-frame hook to fit the camera onto a freshly loaded scene
+ * (see `../hooks/use-auto-frame`). The hook subscribes to the core scene
+ * store and, when `nodes` transitions from empty → non-empty, fires a
+ * `camera-controls:fit-scene` event on the core event bus carrying the
+ * computed bounds.
+ *
+ * This module contains no rendering code: it only walks the flat-dict node
+ * tree and derives an axis-aligned bounding box on the XZ (plan) plane.
+ */
+
+import type { AnyNode } from '@pascal-app/core/schema'
+
+export type SceneBoundsXZ = {
+  /** Min [x, z] in world units (meters). */
+  min: [number, number]
+  /** Max [x, z] in world units (meters). */
+  max: [number, number]
+  /** Center [x, z] = (min + max) / 2. */
+  center: [number, number]
+  /** Size [w, d] = max - min. */
+  size: [number, number]
+}
+
+// A very small guard against degenerate bounds (e.g. a single wall of zero length).
+const MIN_BOUNDS_EXTENT = 0.0001
+
+function extendPoint(
+  acc: { minX: number; minZ: number; maxX: number; maxZ: number; hasPoint: boolean },
+  x: unknown,
+  z: unknown,
+): void {
+  if (typeof x !== 'number' || typeof z !== 'number') return
+  if (!Number.isFinite(x) || !Number.isFinite(z)) return
+  if (x < acc.minX) acc.minX = x
+  if (x > acc.maxX) acc.maxX = x
+  if (z < acc.minZ) acc.minZ = z
+  if (z > acc.maxZ) acc.maxZ = z
+  acc.hasPoint = true
+}
+
+/**
+ * Compute the axis-aligned XZ bounds of a scene.
+ *
+ * Walks every node and extracts 2D footprint points from the fields most
+ * nodes carry:
+ *   - `start`/`end`  → wall and fence endpoints in level coordinates.
+ *   - `polygon`      → zone, slab, site-boundary polygons.
+ *   - `position`     → building/item/door/window position; uses [x, z] only.
+ *
+ * Site-node polygons are intentionally excluded when they are the default
+ * 30×30 bootstrap polygon — otherwise a brand-new empty scene would frame
+ * an empty square around the origin. We still include site polygons that
+ * look intentional (> 4 points, or any point outside the ±15 m default).
+ *
+ * Returns `null` if no usable geometry was found.
+ */
+export function computeSceneBoundsXZ(
+  nodes: AnyNode[] | Record<string, AnyNode>,
+): SceneBoundsXZ | null {
+  const list: AnyNode[] = Array.isArray(nodes) ? nodes : Object.values(nodes)
+  if (list.length === 0) return null
+
+  const acc = {
+    minX: Number.POSITIVE_INFINITY,
+    minZ: Number.POSITIVE_INFINITY,
+    maxX: Number.NEGATIVE_INFINITY,
+    maxZ: Number.NEGATIVE_INFINITY,
+    hasPoint: false,
+  }
+
+  for (const node of list) {
+    if (!node || typeof node !== 'object') continue
+    const anyNode = node as unknown as Record<string, unknown>
+
+    // Wall / fence endpoints in level coordinates.
+    const start = anyNode.start as unknown
+    const end = anyNode.end as unknown
+    if (Array.isArray(start) && start.length >= 2) extendPoint(acc, start[0], start[1])
+    if (Array.isArray(end) && end.length >= 2) extendPoint(acc, end[0], end[1])
+
+    // Zone / slab polygons (and explicit polygon-shaped site boundaries).
+    const polygon = anyNode.polygon as unknown
+    if (Array.isArray(polygon)) {
+      // Zones/slabs expose a plain array of [x,z] tuples. Site nodes nest the
+      // points under `polygon.points` (a discriminated PropertyLineData shape).
+      for (const point of polygon) {
+        if (Array.isArray(point) && point.length >= 2) {
+          extendPoint(acc, point[0], point[1])
+        }
+      }
+    } else if (
+      polygon &&
+      typeof polygon === 'object' &&
+      Array.isArray((polygon as { points?: unknown }).points)
+    ) {
+      // Site nodes only: skip the default bootstrap square so a blank scene
+      // isn't auto-framed around an empty ±15 m box. Include any other site
+      // polygon (more than 4 points, or any coordinate beyond the default).
+      const points = (polygon as { points: unknown[] }).points
+      if (node.type === 'site' && isDefaultSitePolygon(points)) {
+        // Skip — default bootstrap polygon.
+      } else {
+        for (const point of points) {
+          if (Array.isArray(point) && point.length >= 2) {
+            extendPoint(acc, point[0], point[1])
+          }
+        }
+      }
+    }
+
+    // Position on the XZ plane (3D position = [x, y, z]).
+    const position = anyNode.position as unknown
+    if (Array.isArray(position) && position.length >= 3) {
+      extendPoint(acc, position[0], position[2])
+    }
+  }
+
+  if (!acc.hasPoint) return null
+
+  // Ensure a minimum extent so a single-point scene still yields a box.
+  let minX = acc.minX
+  let minZ = acc.minZ
+  let maxX = acc.maxX
+  let maxZ = acc.maxZ
+  if (maxX - minX < MIN_BOUNDS_EXTENT) {
+    const cx = (minX + maxX) / 2
+    minX = cx - MIN_BOUNDS_EXTENT / 2
+    maxX = cx + MIN_BOUNDS_EXTENT / 2
+  }
+  if (maxZ - minZ < MIN_BOUNDS_EXTENT) {
+    const cz = (minZ + maxZ) / 2
+    minZ = cz - MIN_BOUNDS_EXTENT / 2
+    maxZ = cz + MIN_BOUNDS_EXTENT / 2
+  }
+
+  const centerX = (minX + maxX) / 2
+  const centerZ = (minZ + maxZ) / 2
+  return {
+    min: [minX, minZ],
+    max: [maxX, maxZ],
+    center: [centerX, centerZ],
+    size: [maxX - minX, maxZ - minZ],
+  }
+}
+
+/**
+ * Matches the `SiteNode` bootstrap polygon defined in
+ * `packages/core/src/schema/nodes/site.ts` (a 30×30 square at the origin).
+ * We ignore it so the default scene doesn't "auto-frame" onto an empty box.
+ */
+function isDefaultSitePolygon(points: unknown[]): boolean {
+  if (points.length !== 4) return false
+  const expected: [number, number][] = [
+    [-15, -15],
+    [15, -15],
+    [15, 15],
+    [-15, 15],
+  ]
+  for (let i = 0; i < 4; i++) {
+    const p = points[i]
+    const e = expected[i]!
+    if (!Array.isArray(p) || p.length < 2) return false
+    if (p[0] !== e[0] || p[1] !== e[1]) return false
+  }
+  return true
+}

package/src/lib/stair-duplication.ts

@@ -0,0 +1,126 @@
+import {
+  generateId,
+  type AnyNodeId,
+  sceneRegistry,
+  type StairNode,
+  StairNode as StairNodeSchema,
+  type StairSegmentNode,
+  StairSegmentNode as StairSegmentNodeSchema,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../store/use-editor'
+
+type DuplicateStairOptions = {
+  mode?: 'select' | 'move'
+  offset?: [number, number, number]
+  parentId?: AnyNodeId
+}
+
+type DuplicateStairResult = {
+  stair: StairNode
+  segmentIds: StairSegmentNode['id'][]
+}
+
+const MOVE_REGISTRY_RETRY_LIMIT = 12
+
+function stripDuplicateFlags(metadata: unknown) {
+  if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
+    return metadata
+  }
+
+  const nextMeta = { ...(metadata as Record<string, unknown>) }
+  delete nextMeta.isNew
+  delete nextMeta.isTransient
+  return nextMeta
+}
+
+function moveStairWhenRegistered(stairId: StairNode['id'], attempt = 0) {
+  const latestStair = useScene.getState().nodes[stairId as AnyNodeId]
+  if (!latestStair || latestStair.type !== 'stair') {
+    return
+  }
+
+  if (sceneRegistry.nodes.has(stairId)) {
+    useEditor.getState().setMovingNode(latestStair)
+    useViewer.getState().setSelection({ selectedIds: [] })
+    return
+  }
+
+  if (attempt >= MOVE_REGISTRY_RETRY_LIMIT) {
+    console.warn(`Duplicated stair "${stairId}" did not register before move mode started`)
+    return
+  }
+
+  requestAnimationFrame(() => moveStairWhenRegistered(stairId, attempt + 1))
+}
+
+export function duplicateStairSubtree(
+  sourceStairId: AnyNodeId,
+  options: DuplicateStairOptions = {},
+): DuplicateStairResult {
+  const { mode = 'move', offset = [1, 0, 1], parentId: explicitParentId } = options
+
+  const scene = useScene.getState()
+  const sourceStair = scene.nodes[sourceStairId]
+
+  if (!sourceStair || sourceStair.type !== 'stair') {
+    throw new Error(`Node "${sourceStairId}" is not a stair`)
+  }
+
+  const parentId = explicitParentId ?? (sourceStair.parentId as AnyNodeId | null)
+  if (!parentId) {
+    throw new Error(`Stair "${sourceStairId}" is missing a parent level`)
+  }
+
+  const stairClone = StairNodeSchema.parse({
+    ...structuredClone(sourceStair),
+    id: generateId('stair'),
+    parentId,
+    children: [],
+    position: [
+      sourceStair.position[0] + offset[0],
+      sourceStair.position[1] + offset[1],
+      sourceStair.position[2] + offset[2],
+    ] as StairNode['position'],
+    metadata: stripDuplicateFlags(sourceStair.metadata),
+  })
+
+  const segmentClones: StairSegmentNode[] = []
+  for (const childId of sourceStair.children ?? []) {
+    const childNode = scene.nodes[childId as AnyNodeId]
+    if (!childNode || childNode.type !== 'stair-segment') {
+      continue
+    }
+
+    const childClone = StairSegmentNodeSchema.parse({
+      ...structuredClone(childNode),
+      id: generateId('sseg'),
+      parentId: stairClone.id,
+      metadata: stripDuplicateFlags(childNode.metadata),
+    })
+    segmentClones.push(childClone)
+  }
+
+  scene.createNodes([
+    { node: stairClone, parentId },
+    ...segmentClones.map((segment) => ({ node: segment, parentId: stairClone.id as AnyNodeId })),
+  ])
+
+  const createdStair = useScene.getState().nodes[stairClone.id as AnyNodeId]
+  if (!createdStair || createdStair.type !== 'stair') {
+    throw new Error(`Duplicated stair "${stairClone.id}" was not created`)
+  }
+
+  if (mode === 'select') {
+    useViewer.getState().setSelection({ selectedIds: [createdStair.id] })
+  } else {
+    useViewer.getState().setSelection({ selectedIds: [createdStair.id] })
+    requestAnimationFrame(() => moveStairWhenRegistered(createdStair.id))
+  }
+
+  return {
+    stair: createdStair,
+    segmentIds: segmentClones.map((segment) => segment.id),
+  }
+}

package/src/lib/window-interaction.ts

@@ -0,0 +1,86 @@
+import {
+  type AnyNodeId,
+  useInteractive,
+  useScene,
+  type WindowInteractiveState,
+} from '@pascal-app/core'
+
+export const WINDOW_TOGGLE_ANIMATION_MS = 520
+
+type WindowOpenAnimationOptions = {
+  persist?: boolean
+}
+
+export function isOperableWindowType(windowType: string | undefined) {
+  return (
+    windowType === 'sliding' ||
+    windowType === 'casement' ||
+    windowType === 'awning' ||
+    windowType === 'hopper' ||
+    windowType === 'single-hung' ||
+    windowType === 'double-hung' ||
+    windowType === 'louvered'
+  )
+}
+
+function getDisplayedWindowValue(windowId: AnyNodeId, nodeValue: number | undefined) {
+  const interactive = useInteractive.getState()
+  const runtimeValue = interactive.windows[windowId]?.operationState
+  if (runtimeValue !== undefined) return runtimeValue
+
+  const queuedValue = interactive.windowAnimations[windowId]?.from
+  if (queuedValue !== undefined) return queuedValue
+
+  return nodeValue ?? 0
+}
+
+function startWindowOpenAnimation(
+  windowId: AnyNodeId,
+  field: keyof WindowInteractiveState,
+  from: number,
+  to: number,
+  options?: WindowOpenAnimationOptions,
+) {
+  useInteractive.getState().startWindowAnimation(windowId, {
+    field,
+    from,
+    to,
+    startedAt: null,
+    durationMs: WINDOW_TOGGLE_ANIMATION_MS,
+    persist: options?.persist ?? true,
+  })
+}
+
+export function toggleWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
+  const node = useScene.getState().nodes[windowId]
+  if (
+    node?.type !== 'window' ||
+    node.openingKind === 'opening' ||
+    !isOperableWindowType(node.windowType)
+  ) {
+    return
+  }
+
+  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
+  startWindowOpenAnimation(
+    windowId,
+    'operationState',
+    currentOpenAmount,
+    currentOpenAmount >= 0.5 ? 0 : 1,
+    options,
+  )
+}
+
+export function closeWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
+  const node = useScene.getState().nodes[windowId]
+  if (
+    node?.type !== 'window' ||
+    node.openingKind === 'opening' ||
+    !isOperableWindowType(node.windowType)
+  ) {
+    return
+  }
+
+  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
+  startWindowOpenAnimation(windowId, 'operationState', currentOpenAmount, 0, options)
+}