@pascal-app/editor 1.0.4 → 1.0.6

package/src/lib/point-ask/history-marks.ts

@@ -0,0 +1,39 @@
+// Counting what an ask's turn wrote in the scene's undo history. The history is bounded (the last
+// 50 steps) and the person can Cmd+Z into it, so a length cannot say how many steps are the turn's:
+// a mark holds the last step standing when the turn began, and the steps since are counted from
+// where that step is now.
+
+export type HistoryMark = { ref: unknown | null; length: number }
+
+export function markHistory(past: readonly unknown[]): HistoryMark {
+  return { ref: past.at(-1) ?? null, length: past.length }
+}
+
+/**
+ * How many steps were pushed since `mark`, or null when the marked step is gone from the history
+ * (it fell off the front, or the person undid back past it): the turn can no longer be undone as a
+ * whole.
+ */
+export function stepsSince(past: readonly unknown[], mark: HistoryMark): number | null {
+  if (mark.ref === null) return past.length
+  const at = past.lastIndexOf(mark.ref)
+  return at < 0 ? null : past.length - 1 - at
+}
+
+/**
+ * The history state the turn's first step was taken from: the scene as it stood when the turn began.
+ * Null when nothing was pushed since the mark, or the marked step has gone from the history.
+ */
+export function stateAfterMark<T>(past: readonly T[], mark: HistoryMark): T | null {
+  if (mark.ref === null) return past[0] ?? null
+  const at = past.lastIndexOf(mark.ref as T)
+  return at < 0 ? null : (past[at + 1] ?? null)
+}
+
+/** The nodes in `now` that `before` had no entry for: what an undo of the steps in between will remove. */
+export function createdSince(
+  before: Record<string, unknown>,
+  now: Record<string, unknown>,
+): string[] {
+  return Object.keys(now).filter((id) => !(id in before))
+}

package/src/lib/point-ask/host-api.ts

@@ -0,0 +1,32 @@
+import { usePointAsk } from '../../store/use-point-ask'
+import { chatWentIdle, retryAsk } from './session'
+
+// What a host app (the hosted chat) tells Point and ask about itself, without importing the store.
+
+/** The host's "Playful touches" setting: false turns the region flash, the ripples and the sounds off. */
+export function setPointAskPlayful(playful: boolean) {
+  usePointAsk.getState().setPlayful(playful)
+}
+
+/** Pascal is on a turn: the bubble's Send says Queue, and a new ask waits its turn. */
+export function setPointAskBusy(busy: boolean) {
+  usePointAsk.getState().setBusy(busy)
+  if (!busy) chatWentIdle()
+}
+
+/**
+ * Messages already wait in the chat's queue (or are held there after an error): a new ask goes
+ * behind them, and the bubble says Queue, though Pascal is on no turn.
+ */
+export function setPointAskBehindQueue(behindQueue: boolean) {
+  usePointAsk.getState().setBehindQueue(behindQueue)
+}
+
+/**
+ * The chat's Retry on a message that was a Point and ask: the same ask again, with its own pin. False
+ * when the editor no longer has the pin (a reload, a collaborator's ask): the chat sends the words
+ * again as a plain message.
+ */
+export function retryPointAsk(askId: string): Promise<boolean> {
+  return retryAsk(askId)
+}

package/src/lib/point-ask/outline-box.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test'
+import { outlineBox } from './outline-box'
+
+// A room is a floor to the person pointing: its corner brackets frame the footprint, not the
+// storey-high box that would leave two of them floating in the sky (seen on a two-storey house).
+describe('outlineBox', () => {
+  const tall = {
+    min: [0, 0, 0] as [number, number, number],
+    max: [6, 4.5, 6] as [number, number, number],
+  }
+
+  test('a room is its footprint at the floor', () => {
+    expect(outlineBox('zone', tall)).toEqual({ min: [0, 0, 0], max: [6, 0.02, 6] })
+  })
+
+  test('everything else keeps its own box', () => {
+    for (const type of ['wall', 'window', 'door', 'item', 'stair', 'roof']) {
+      expect(outlineBox(type, tall)).toEqual(tall)
+    }
+  })
+
+  test('a room that already is flat is left as it is', () => {
+    const flat = {
+      min: [0, 2.55, 0] as [number, number, number],
+      max: [4, 2.55, 4] as [number, number, number],
+    }
+
+    expect(outlineBox('zone', flat)).toEqual({ min: [0, 2.55, 0], max: [4, 2.57, 4] })
+  })
+})

package/src/lib/point-ask/outline-box.ts

@@ -0,0 +1,11 @@
+import type { WorldBox } from '../../store/use-point-ask'
+
+/**
+ * The box the overlay frames for a pointed element: its own world box, except a room, whose box
+ * spans the storey but which the person means as a floor. A flat footprint keeps the corner
+ * brackets on the ground and the bubble beside the room, not up in the air.
+ */
+export function outlineBox(type: string, box: WorldBox): WorldBox {
+  if (type !== 'zone') return box
+  return { min: [...box.min], max: [box.max[0], box.min[1] + 0.02, box.max[2]] }
+}

package/src/lib/point-ask/overlay-metrics.ts

@@ -0,0 +1,6 @@
+// Where the editor floats its own chrome over the canvas, so a bubble keeps clear of it.
+export const VIEWPORT_INSET = 12
+/** The top bar and the camera controls strip. */
+export const BUBBLE_TOP_INSET = 56
+/** The action bar at the bottom centre. */
+export const BUBBLE_BOTTOM_INSET = 84

package/src/lib/point-ask/pick.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode, NodeEvent } from '@pascal-app/core'
+import { type PointPickInput, resolvePointPick } from './pick'
+
+// Point and ask (the owner, 8 October): the hover shows exactly what the click sends, by the
+// editor's own predicate. Written first: a wall or floor picking the wall or floor instead of its
+// room; the room still picked once it is the bubble's context; Alt not reaching the surface; a
+// facade seen from outside picking the room behind it; a window picked through its wall; a node of
+// another level picked; the ambiguity line missing where a deeper pick exists.
+
+const LEVEL = 'level_0'
+const OTHER_LEVEL = 'level_1'
+
+const node = (fields: Record<string, unknown>) => fields as unknown as AnyNode
+const nodes: Record<string, AnyNode> = {
+  [LEVEL]: node({ id: LEVEL, type: 'level', parentId: 'building_1' }),
+  [OTHER_LEVEL]: node({ id: OTHER_LEVEL, type: 'level', parentId: 'building_1' }),
+  building_1: node({ id: 'building_1', type: 'building', parentId: 'site_1' }),
+  site_1: node({ id: 'site_1', type: 'site' }),
+  zone_kitchen: node({ id: 'zone_kitchen', type: 'zone', parentId: LEVEL }),
+  wall_north: node({
+    id: 'wall_north',
+    type: 'wall',
+    parentId: LEVEL,
+    start: [0, 0],
+    end: [4, 0],
+  }),
+  slab_kitchen: node({ id: 'slab_kitchen', type: 'slab', parentId: LEVEL }),
+  ceiling_kitchen: node({ id: 'ceiling_kitchen', type: 'ceiling', parentId: LEVEL }),
+  window_north: node({ id: 'window_north', type: 'window', parentId: 'wall_north' }),
+  sofa: node({ id: 'sofa', type: 'item', parentId: LEVEL }),
+  wall_up: node({ id: 'wall_up', type: 'wall', parentId: OTHER_LEVEL, start: [0, 0], end: [4, 0] }),
+  roof_1: node({ id: 'roof_1', type: 'roof', parentId: LEVEL }),
+  roof_segment_1: node({ id: 'roof_segment_1', type: 'roof-segment', parentId: 'roof_1' }),
+}
+
+const event = (
+  id: string,
+  extra: { position?: [number, number, number]; normal?: [number, number, number] } = {},
+) =>
+  ({
+    node: nodes[id],
+    position: extra.position ?? [2, 1, 0],
+    localPosition: [0, 0, 0],
+    normal: extra.normal,
+    object: {},
+    stopPropagation: () => {},
+    nativeEvent: {},
+  }) as unknown as NodeEvent
+
+const KITCHEN = { levelId: LEVEL, zoneId: 'zone_kitchen' }
+
+/** A scene where the kitchen is the room at every point south of the north wall (z > 0). */
+const input = (id: string, over: Partial<PointPickInput> = {}): PointPickInput => ({
+  event: event(id),
+  alt: false,
+  selectedTargetIds: [],
+  nodes,
+  currentLevelId: LEVEL,
+  resolveRoom: () => KITCHEN,
+  roomAtPoint: (_level, _x, z) => (z > 0 ? KITCHEN : null),
+  ...over,
+})
+
+describe('room first', () => {
+  test('a wall picks its room, and says the wall is a level deeper', () => {
+    // The camera is inside: the hit normal points into the kitchen (+z).
+    const pick = resolvePointPick(
+      input('wall_north', { event: event('wall_north', { normal: [0, 0, 1] }) }),
+    )
+
+    expect(pick).toEqual({
+      nodeId: 'zone_kitchen',
+      via: 'wall_north',
+      face: 'interior',
+      ambiguous: true,
+    })
+  })
+
+  test('a floor picks its room (face top), a ceiling its room (face bottom)', () => {
+    expect(resolvePointPick(input('slab_kitchen'))).toEqual({
+      nodeId: 'zone_kitchen',
+      via: 'slab_kitchen',
+      face: 'top',
+      ambiguous: true,
+    })
+    expect(resolvePointPick(input('ceiling_kitchen'))).toEqual({
+      nodeId: 'zone_kitchen',
+      via: 'ceiling_kitchen',
+      face: 'bottom',
+      ambiguous: true,
+    })
+  })
+
+  test('a plate or wall with no room behind it picks itself', () => {
+    expect(resolvePointPick(input('slab_kitchen', { resolveRoom: () => null }))).toEqual({
+      nodeId: 'slab_kitchen',
+      face: 'top',
+      ambiguous: false,
+    })
+  })
+
+  test('once the room is the bubble’s context, the surface itself picks', () => {
+    const wall = resolvePointPick(
+      input('wall_north', {
+        event: event('wall_north', { normal: [0, 0, 1] }),
+        selectedTargetIds: ['zone_kitchen'],
+      }),
+    )
+    expect(wall).toEqual({ nodeId: 'wall_north', face: 'interior', ambiguous: false })
+
+    const floor = resolvePointPick(input('slab_kitchen', { selectedTargetIds: ['zone_kitchen'] }))
+    expect(floor).toEqual({ nodeId: 'slab_kitchen', face: 'top', ambiguous: false })
+  })
+})
+
+describe('Alt goes one level deeper', () => {
+  test('to the wall, the floor or the ceiling under the cursor', () => {
+    expect(
+      resolvePointPick(
+        input('wall_north', { alt: true, event: event('wall_north', { normal: [0, 0, 1] }) }),
+      ),
+    ).toEqual({ nodeId: 'wall_north', face: 'interior', ambiguous: false })
+    expect(resolvePointPick(input('slab_kitchen', { alt: true }))).toEqual({
+      nodeId: 'slab_kitchen',
+      face: 'top',
+      ambiguous: false,
+    })
+    expect(resolvePointPick(input('ceiling_kitchen', { alt: true }))?.nodeId).toBe(
+      'ceiling_kitchen',
+    )
+  })
+})
+
+describe('from outside, “this” is the facade', () => {
+  const outside = event('wall_north', { normal: [0, 0, -1], position: [2, 1, 0] })
+
+  test('an exterior wall face picks the wall, not the room behind it', () => {
+    expect(resolvePointPick(input('wall_north', { event: outside }))).toEqual({
+      nodeId: 'wall_north',
+      face: 'exterior',
+      ambiguous: false,
+    })
+  })
+
+  test('the same with Alt', () => {
+    expect(resolvePointPick(input('wall_north', { event: outside, alt: true }))?.face).toBe(
+      'exterior',
+    )
+  })
+
+  test('a wall hit that carries no normal falls back to the editor’s room', () => {
+    expect(resolvePointPick(input('wall_north'))?.nodeId).toBe('zone_kitchen')
+  })
+})
+
+describe('picked directly', () => {
+  test('a window, an item and a roof segment pick themselves, with no ambiguity line', () => {
+    expect(resolvePointPick(input('window_north'))).toEqual({
+      nodeId: 'window_north',
+      ambiguous: false,
+    })
+    expect(resolvePointPick(input('sofa'))).toEqual({ nodeId: 'sofa', ambiguous: false })
+  })
+
+  test('a roof picks the segment under the cursor when the editor can say', () => {
+    expect(
+      resolvePointPick(
+        input('roof_1', { resolveRoofSegment: () => nodes.roof_segment_1 as AnyNode }),
+      ),
+    ).toEqual({ nodeId: 'roof_segment_1', ambiguous: false })
+    expect(resolvePointPick(input('roof_1'))?.nodeId).toBe('roof_1')
+  })
+
+  test('the editor’s selection proxy decides which node a body pick lands on', () => {
+    const picked = resolvePointPick(
+      input('window_north', { resolveNode: () => nodes.wall_north as AnyNode, alt: true }),
+    )
+
+    expect(picked?.nodeId).toBe('wall_north')
+  })
+})
+
+describe('what is not pickable', () => {
+  test('a node of another level', () => {
+    expect(resolvePointPick(input('wall_up'))).toBeNull()
+  })
+
+  test('with no level in view, every level is pickable', () => {
+    expect(resolvePointPick(input('wall_up', { currentLevelId: null, alt: true }))?.nodeId).toBe(
+      'wall_up',
+    )
+  })
+
+  test('the building and the site, inside a building', () => {
+    expect(resolvePointPick(input('building_1'))).toBeNull()
+    expect(resolvePointPick(input('site_1'))).toBeNull()
+  })
+
+  test('the building from the site phase', () => {
+    expect(resolvePointPick(input('building_1', { phase: 'site', currentLevelId: null }))).toEqual({
+      nodeId: 'building_1',
+      ambiguous: false,
+    })
+  })
+
+  test('a zone outside the zone layer', () => {
+    expect(resolvePointPick(input('zone_kitchen'))).toBeNull()
+    expect(resolvePointPick(input('zone_kitchen', { zonesPickable: true }))?.nodeId).toBe(
+      'zone_kitchen',
+    )
+  })
+
+  test('the ceiling grid, which belongs to the ceiling tool', () => {
+    const grid = event('ceiling_kitchen')
+    ;(grid.object as { name?: string }).name = 'ceiling-grid'
+
+    expect(resolvePointPick(input('ceiling_kitchen', { event: grid }))).toBeNull()
+  })
+})

package/src/lib/point-ask/pick.ts

@@ -0,0 +1,121 @@
+import { type AnyNode, type NodeEvent, resolveLevelId, type ZoneNode } from '@pascal-app/core'
+
+// What a pointer event picks in point mode (the owner, 8 October), by the editor's own predicate
+// (selection-manager.tsx: "hover, press and click share this predicate"), so the hover shows exactly
+// what the click sends. Pure: the editor's room lookups are handed in, so none of this needs a
+// three scene.
+
+/** A room, as the editor's room lookup names it (`RoomKey`) or as its zone. */
+type RoomRef = { zoneId: string } | Pick<ZoneNode, 'id'>
+
+export type PointPick = {
+  /** What the click sends: the room's zone, or the surface itself. */
+  nodeId: string
+  /** The surface under the cursor when the pick is its room (the wall, floor or ceiling). */
+  via?: string
+  /** Which face of the picked wall, floor or ceiling the finger is on. */
+  face?: 'interior' | 'exterior' | 'top' | 'bottom'
+  /** A deeper pick exists (Alt): the label's second line says "⌥ the wall". */
+  ambiguous: boolean
+}
+
+export type PointPickInput = {
+  event: NodeEvent
+  alt: boolean
+  /** The bubble's targets, so a room that is already the context lets its surfaces pick. */
+  selectedTargetIds: readonly string[]
+  nodes: Readonly<Record<string, AnyNode | undefined>>
+  /** The level in view; null picks on every level. */
+  currentLevelId: string | null
+  phase?: 'site' | 'building'
+  /** Zones pick directly only in the zone layer; elsewhere they are reached through their surfaces. */
+  zonesPickable?: boolean
+  /** The editor's room for a wall, floor or ceiling hit (`roomForEvent`), null when it bounds none. */
+  resolveRoom: (event: NodeEvent) => RoomRef | null
+  /** The room standing at a plan point of a level, for the side of a wall the viewer is on. */
+  roomAtPoint: (levelId: string, x: number, z: number) => RoomRef | null
+  /** The roof segment under the cursor (`resolveRoofSegmentSelectionTarget`). */
+  resolveRoofSegment?: (event: NodeEvent) => AnyNode | null
+  /** The node a body pick lands on once the editor's selection proxies are applied
+   *  (`resolveCanvasSelectionNode`). */
+  resolveNode?: (node: AnyNode) => AnyNode
+}
+
+/** How far out of a wall, along the hit normal, the viewer's side is probed for a room (m). */
+const FACE_PROBE_M = 0.15
+
+const zoneIdOf = (room: RoomRef) => ('zoneId' in room ? room.zoneId : room.id)
+
+/** A ceiling's own grid belongs to the ceiling tool, not to a pick. */
+const isCeilingGridHit = (event: NodeEvent) =>
+  !event.viaHandle &&
+  event.node.type === 'ceiling' &&
+  (event.object as { name?: string } | undefined)?.name === 'ceiling-grid'
+
+export function resolvePointPick(input: PointPickInput): PointPick | null {
+  const { event, nodes } = input
+  if (isCeilingGridHit(event)) return null
+
+  let node = input.resolveNode?.(event.node) ?? event.node
+  if (node.type === 'roof') node = input.resolveRoofSegment?.(event) ?? node
+
+  // The building and the site are not pointed at from inside a building (the select hover
+  // ignores them there too): ground and sky are an area, not a target.
+  if (node.type === 'building' || node.type === 'site') {
+    if ((input.phase ?? 'building') !== 'site') return null
+    return { nodeId: node.id, ambiguous: false }
+  }
+  if (node.type === 'zone' && !input.zonesPickable) return null
+  // Elevators are building-scoped and stay pickable across level filters.
+  if (input.currentLevelId && node.type !== 'elevator') {
+    if (resolveLevelId(node, nodes as Record<string, AnyNode>) !== input.currentLevelId) return null
+  }
+
+  const levelId = input.currentLevelId ?? resolveLevelId(node, nodes as Record<string, AnyNode>)
+
+  if (node.type === 'wall') return pickWall(input, node, levelId)
+  if (node.type === 'slab' || node.type === 'ceiling') return pickPlate(input, node)
+
+  return { nodeId: node.id, ambiguous: false }
+}
+
+function pickWall(input: PointPickInput, wall: AnyNode, levelId: string): PointPick {
+  const { event } = input
+  // From outside "this" means the facade: the side the viewer is on has no room, so the wall
+  // itself is picked, not the room behind it. A hit with no normal cannot say, so the editor's
+  // own room-first rule decides.
+  let face: 'interior' | 'exterior' | null = null
+  let viewerRoom: RoomRef | null = null
+  if (event.normal) {
+    viewerRoom = input.roomAtPoint(
+      levelId,
+      event.position[0] + event.normal[0] * FACE_PROBE_M,
+      event.position[2] + event.normal[2] * FACE_PROBE_M,
+    )
+    face = viewerRoom ? 'interior' : 'exterior'
+  }
+  const surface = (): PointPick => ({
+    nodeId: wall.id,
+    ...(face ? { face } : {}),
+    ambiguous: false,
+  })
+  if (face === 'exterior' || input.alt) return surface()
+
+  const room = viewerRoom ?? input.resolveRoom(event)
+  if (!room) return surface()
+  const zoneId = zoneIdOf(room)
+  if (input.selectedTargetIds.includes(zoneId)) return surface()
+  return { nodeId: zoneId, via: wall.id, ...(face ? { face } : {}), ambiguous: true }
+}
+
+function pickPlate(input: PointPickInput, plate: AnyNode): PointPick {
+  const face = plate.type === 'ceiling' ? 'bottom' : 'top'
+  const surface = (): PointPick => ({ nodeId: plate.id, face, ambiguous: false })
+  if (input.alt) return surface()
+
+  const room = input.resolveRoom(input.event)
+  if (!room) return surface()
+  const zoneId = zoneIdOf(room)
+  if (input.selectedTargetIds.includes(zoneId)) return surface()
+  return { nodeId: zoneId, via: plate.id, face, ambiguous: true }
+}