@pascal-app/editor 1.0.7 → 1.1.1

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

@@ -1,183 +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])
-  })
-
-  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,169 +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 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/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))
-}