@pascal-app/editor 1.1.0 → 1.1.1

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

@@ -1,327 +0,0 @@
-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])
-  })
-
-  describe('ancestor transforms', () => {
-    function makeBuilding(
-      id: string,
-      position: [number, number, number],
-      rotationY = 0,
-      parentId: string | null = null,
-    ): AnyNode {
-      return {
-        object: 'node',
-        id,
-        type: 'building',
-        parentId,
-        visible: true,
-        metadata: {},
-        children: [],
-        position,
-        rotation: [0, rotationY, 0],
-      } as unknown as AnyNode
-    }
-
-    function makeLevel(id: string, parentId: string): AnyNode {
-      return {
-        object: 'node',
-        id,
-        type: 'level',
-        parentId,
-        visible: true,
-        metadata: {},
-        children: [],
-        level: 0,
-      } as unknown as AnyNode
-    }
-
-    function child(node: AnyNode, parentId: string): AnyNode {
-      return { ...node, parentId } as AnyNode
-    }
-
-    function expectClose(actual: [number, number], expected: [number, number]) {
-      expect(actual[0]).toBeCloseTo(expected[0], 9)
-      expect(actual[1]).toBeCloseTo(expected[1], 9)
-    }
-
-    test('carries building-local walls and zones through a translated building', () => {
-      const nodes = [
-        makeBuilding('building_a', [100, 0, 100]),
-        makeLevel('level_a', 'building_a'),
-        child(makeWall([-5, -4], [5, -4]), 'level_a'),
-        child(
-          makeZone([
-            [-5, -4],
-            [5, -4],
-            [5, 4],
-            [-5, 4],
-          ]),
-          'level_a',
-        ),
-      ]
-      const bounds = computeSceneBoundsXZ(nodes)!
-      expectClose(bounds.min, [95, 96])
-      expectClose(bounds.max, [105, 104])
-      expectClose(bounds.center, [100, 100])
-    })
-
-    test('turns building-local geometry by the building yaw', () => {
-      // three.js Y rotation by +90°: local (x, z) → (z, −x).
-      const nodes = [
-        makeBuilding('building_r', [10, 0, 0], Math.PI / 2),
-        makeLevel('level_r', 'building_r'),
-        child(makeWall([0, 0], [8, 0]), 'level_r'),
-        child(makeWall([8, 0], [8, 2]), 'level_r'),
-      ]
-      const bounds = computeSceneBoundsXZ(nodes)!
-      expectClose(bounds.min, [10, -8])
-      expectClose(bounds.max, [12, 0])
-      expectClose(bounds.size, [2, 8])
-    })
-
-    test('composes nested positioned and rotated ancestors', () => {
-      const item = {
-        object: 'node',
-        id: 'item_host',
-        type: 'item',
-        parentId: 'level_n',
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [2, 0, 0],
-        rotation: [0, Math.PI / 2, 0],
-      } as unknown as AnyNode
-      const hosted = {
-        object: 'node',
-        id: 'item_hosted',
-        type: 'item',
-        parentId: 'item_host',
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [1, 0, 0],
-        rotation: [0, 0, 0],
-      } as unknown as AnyNode
-      // Building at (50, 50) turned 90°: the host lands at (50, 48), and the
-      // hosted item (1, 0) under a total 180° yaw lands one metre further −x.
-      const nodes = [
-        makeBuilding('building_n', [50, 0, 50], Math.PI / 2),
-        makeLevel('level_n', 'building_n'),
-        item,
-        hosted,
-      ]
-      const bounds = computeSceneBoundsXZ(nodes)!
-      expectClose(bounds.min, [49, 48])
-      expectClose(bounds.max, [50, 50])
-    })
-
-    test('leaves geometry under an untransformed building unchanged', () => {
-      const nodes = [
-        makeBuilding('building_0', [0, 0, 0]),
-        makeLevel('level_0', 'building_0'),
-        child(makeWall([0, 0], [4, 0]), 'level_0'),
-        child(makeWall([4, 0], [4, 3]), 'level_0'),
-      ]
-      const bounds = computeSceneBoundsXZ(nodes)!
-      expect(bounds.min).toEqual([0, 0])
-      expect(bounds.max).toEqual([4, 3])
-    })
-  })
-
-  test('a door on a wall is bounded by the wall, not its wall-local position', () => {
-    const wall = makeWall([50, 50], [60, 50])
-    const door = {
-      object: 'node',
-      id: 'door_1',
-      type: 'door',
-      parentId: wall.id,
-      visible: true,
-      metadata: {},
-      position: [2, 1, 0],
-    } as unknown as AnyNode
-    const bounds = computeSceneBoundsXZ([wall, door])
-    expect(bounds).not.toBeNull()
-    expect(bounds!.min[0]).toBe(50)
-    expect(bounds!.max[0]).toBe(60)
-    expect(bounds!.center).toEqual([55, 50])
-  })
-
-  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

@@ -1,233 +0,0 @@
-/**
- * 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 { turnPlanPoint, yawOf } from '@pascal-app/core'
-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
-
-/** A node's plan frame in world XZ: local (x, z) → origin + turnPlanPoint(x, z, yaw). */
-type PlanFrame = { x: number; z: number; yaw: number }
-
-const WORLD_FRAME: PlanFrame = { x: 0, z: 0, yaw: 0 }
-
-type BoundsAcc = { minX: number; minZ: number; maxX: number; maxZ: number; hasPoint: boolean }
-
-function extendPoint(acc: BoundsAcc, frame: PlanFrame, localX: unknown, localZ: unknown): void {
-  if (typeof localX !== 'number' || typeof localZ !== 'number') return
-  if (!(Number.isFinite(localX) && Number.isFinite(localZ))) return
-  const [tx, tz] = frame.yaw === 0 ? [localX, localZ] : turnPlanPoint(localX, localZ, frame.yaw)
-  const x = frame.x + tx
-  const z = frame.z + tz
-  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.
- *
- * Each point is in its parent's frame, so it is carried to world XZ through
- * the ancestors' `position` and `rotation` yaw (a moved or turned building).
- *
- * 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: BoundsAcc = {
-    minX: Number.POSITIVE_INFINITY,
-    minZ: Number.POSITIVE_INFINITY,
-    maxX: Number.NEGATIVE_INFINITY,
-    maxZ: Number.NEGATIVE_INFINITY,
-    hasPoint: false,
-  }
-
-  const byId = new Map<string, AnyNode>()
-  for (const node of list) {
-    if (node && typeof node === 'object' && typeof node.id === 'string') byId.set(node.id, node)
-  }
-  const frameOf = createFrameResolver(byId)
-
-  for (const node of list) {
-    if (!node || typeof node !== 'object') continue
-    const anyNode = node as unknown as Record<string, unknown>
-    // A node's own fields live in its parent's frame (a building's walls are
-    // building-local), so every point goes through the ancestors' transforms.
-    const frame = frameOf(node.parentId ?? null)
-
-    // 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, frame, start[0], start[1])
-    if (Array.isArray(end) && end.length >= 2) extendPoint(acc, frame, 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, frame, 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, frame, point[0], point[1])
-          }
-        }
-      }
-    }
-
-    // Position on the XZ plane (3D position = [x, y, z]). A node hosted on a
-    // wall (door, window, wall item) has a wall-local position, and the
-    // wall's endpoints already bound it.
-    const position = anyNode.position as unknown
-    if (Array.isArray(position) && position.length >= 3 && !isWallHosted(node, byId)) {
-      extendPoint(acc, frame, 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],
-  }
-}
-
-/**
- * World plan frame of each node, composed down the parent chain the way the
- * renderers nest groups: a node with a `position` (building, item) translates
- * its children and turns them by its `rotation` yaw; nodes without one (site,
- * level) pass their parent's frame through.
- */
-function createFrameResolver(byId: Map<string, AnyNode>): (id: string | null) => PlanFrame {
-  const cache = new Map<string, PlanFrame>()
-  const resolving = new Set<string>()
-
-  const resolve = (id: string | null): PlanFrame => {
-    if (!id) return WORLD_FRAME
-    const cached = cache.get(id)
-    if (cached) return cached
-    const node = byId.get(id)
-    if (!node || resolving.has(id)) return WORLD_FRAME
-    resolving.add(id)
-    const parent = resolve(node.parentId ?? null)
-    resolving.delete(id)
-
-    const anyNode = node as unknown as Record<string, unknown>
-    const position = anyNode.position
-    let frame = parent
-    if (Array.isArray(position) && position.length >= 3) {
-      const px = Number.isFinite(position[0]) ? (position[0] as number) : 0
-      const pz = Number.isFinite(position[2]) ? (position[2] as number) : 0
-      const [tx, tz] = turnPlanPoint(px, pz, parent.yaw)
-      frame = { x: parent.x + tx, z: parent.z + tz, yaw: parent.yaw + yawOf(anyNode.rotation) }
-    }
-    cache.set(id, frame)
-    return frame
-  }
-
-  return resolve
-}
-
-function isWallHosted(node: AnyNode, byId: Map<string, AnyNode>): boolean {
-  const parent = node.parentId ? byId.get(node.parentId) : undefined
-  if (!parent) return false
-  const anyParent = parent as unknown as Record<string, unknown>
-  return Array.isArray(anyParent.start) && Array.isArray(anyParent.end)
-}
-
-/**
- * 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/typing-target.ts

@@ -1,9 +0,0 @@
-// Keys typed into a field (the room-name combobox, any input, an open dialog)
-// belong to that field, never to a canvas gesture.
-const TYPING_TARGET =
-  'input, textarea, select, [contenteditable]:not([contenteditable="false"]), [role="combobox"], [role="textbox"], [role="dialog"], [role="alertdialog"]'
-
-export function isTypingTarget(target: EventTarget | null) {
-  const element = target as { closest?: (selector: string) => unknown; isContentEditable?: boolean }
-  return !!element && (element.isContentEditable === true || !!element.closest?.(TYPING_TARGET))
-}