@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/point-ask/__fixtures__/consumer-browser.tsx

@@ -0,0 +1,76 @@
+import { useScene } from '@pascal-app/core'
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { PerspectiveCamera, Raycaster } from 'three'
+import { setEditorThreeContext } from '../../../components/editor/three-context-bridge'
+import { PointAskLayer } from '../../../components/point-ask/point-ask-layer'
+import { useAutoSave } from '../../../hooks/use-auto-save'
+import useEditor from '../../../store/use-editor'
+import { type PointBubble, usePointAsk } from '../../../store/use-point-ask'
+import { changeMore, endCompare, redoAsk, sendBubble, startCompare, undoAsk } from '../session'
+
+// Same-package entry: the private fixture uses this window boundary, never Editor src imports.
+const saves: unknown[] = []
+let saveControls: ReturnType<typeof useAutoSave>
+function Host() {
+  saveControls = useAutoSave({
+    onSave: async (scene) => {
+      saves.push(structuredClone(scene))
+    },
+  })
+  return <PointAskLayer />
+}
+const element = document.createElement('div')
+element.id = 'point-consumer-editor'
+document.body.append(element)
+const root = createRoot(element)
+// Only the DOM mode precondition and CPU projection: no renderer or GPU is created.
+const canvas = document.createElement('canvas')
+canvas.width = 800
+canvas.height = 600
+document.body.append(canvas)
+const camera = new PerspectiveCamera(50, 4 / 3, 0.1, 100)
+camera.position.set(2, 5, 8)
+camera.lookAt(2, 0, 2)
+setEditorThreeContext({ camera, raycaster: new Raycaster(), domElement: canvas })
+useEditor.setState({
+  viewMode: '3d',
+  workspaceMode: 'edit',
+  isPreviewMode: false,
+  isFirstPersonMode: false,
+})
+;(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+await act(async () => {
+  root.render(<Host />)
+})
+
+const fixture = {
+  scene: useScene,
+  point: usePointAsk,
+  act,
+  saves,
+  open: (bubble: PointBubble) =>
+    act(async () => {
+      usePointAsk.getState().openBubble(bubble)
+    }),
+  send: (text: string) =>
+    act(async () => {
+      await sendBubble(text, { x: 0, y: 0, width: 100, height: 20 })
+    }),
+  changeMore,
+  undo: undoAsk,
+  redo: redoAsk,
+  startCompare,
+  endCompare,
+  beginLoad: () => saveControls.beginSceneLoad(),
+  completeLoad: () => saveControls.completeSceneLoad(),
+  saveNow: () => saveControls.saveNow(),
+  unmount: () =>
+    act(async () => {
+      root.unmount()
+      setEditorThreeContext(null)
+      canvas.remove()
+    }),
+}
+;(window as unknown as { pointEditorFixture: typeof fixture }).pointEditorFixture = fixture
+window.dispatchEvent(new Event('point-editor-fixture-ready'))

package/src/lib/point-ask/__fixtures__/house.ts

@@ -0,0 +1,81 @@
+import {
+  type AnyNode,
+  ItemNode,
+  LevelNode,
+  WallNode,
+  WindowNode,
+  ZoneNode,
+  DoorNode,
+} from '@pascal-app/core'
+
+// One 4 × 3 m kitchen on a ground level, as the point-ask tests share it: four walls, the room they
+// make, a window in the north wall, a door in the south wall and a sofa on the floor.
+export const LEVEL_ID = 'level_0'
+
+const wall = (id: string, start: [number, number], end: [number, number]) =>
+  WallNode.parse({ id, parentId: LEVEL_ID, start, end, height: 2.6 })
+
+const walls = [
+  wall('wall_north', [0, 0], [4, 0]),
+  wall('wall_east', [4, 0], [4, 3]),
+  wall('wall_south', [4, 3], [0, 3]),
+  wall('wall_west', [0, 3], [0, 0]),
+]
+
+const zone = ZoneNode.parse({
+  id: 'zone_kitchen',
+  parentId: LEVEL_ID,
+  name: 'Kitchen',
+  polygon: [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+  ],
+  boundaryWallIds: walls.map((w) => w.id),
+})
+
+const window = WindowNode.parse({
+  id: 'window_north',
+  parentId: 'wall_north',
+  wallId: 'wall_north',
+  position: [2, 1.4, 0],
+  width: 1.2,
+  height: 1.4,
+})
+
+const door = DoorNode.parse({
+  id: 'door_front',
+  parentId: 'wall_south',
+  wallId: 'wall_south',
+  position: [2, 1.05, 0],
+  width: 0.9,
+  height: 2.1,
+})
+
+const sofa = ItemNode.parse({
+  id: 'item_sofa',
+  parentId: LEVEL_ID,
+  name: 'Sofa',
+  position: [1.5, 0, 1.5],
+  asset: {
+    id: 'sofa',
+    category: 'furniture',
+    name: 'Oslo 3-seat',
+    thumbnail: '',
+    src: 'asset://sofa.glb',
+    dimensions: [2.1, 0.85, 0.95],
+  },
+})
+
+const level = LevelNode.parse({
+  id: LEVEL_ID,
+  children: [...walls.map((w) => w.id), zone.id, sofa.id],
+})
+
+/** The scene as `useScene` holds it: nodes by id. */
+export function house(extra: AnyNode[] = []): Record<string, AnyNode> {
+  return Object.fromEntries(
+    [level, ...walls, zone, window, door, sofa, ...extra].map((node) => [node.id, node as AnyNode]),
+  )
+}

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

@@ -0,0 +1,195 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  BuildingNode,
+  clearSceneHistory,
+  emitter,
+  endScenePreview,
+  ItemNode,
+  isScenePreviewing,
+  LevelNode,
+  registerPointAskHandler,
+  useScene,
+  ZoneNode,
+} from '@pascal-app/core'
+import { type BubbleTarget, usePointAsk } from '../../store/use-point-ask'
+import { endCompare, sendBubble, startCompare, startPointAskSession } from './session'
+
+// Hold to see before, for a turn that BUILDS: "Furnish this room" on an empty room creates nodes
+// the "before" has never heard of. The ask-flow suite holds turns that only change a wall; the
+// owner held an ask that furnished an empty room (13 October) and the furniture stayed. Real
+// stores; only the chat's words (statuses) and the DOM are stood in for.
+
+const building = BuildingNode.parse({ id: 'building_created' })
+const level = LevelNode.parse({ id: 'level_created', parentId: building.id })
+const room = ZoneNode.parse({
+  id: 'zone_created',
+  parentId: level.id,
+  name: 'Formal Dining Room',
+  polygon: [
+    [0, 0],
+    [5, 0],
+    [5, 4],
+    [0, 4],
+  ],
+})
+building.children = [level.id]
+level.children = [room.id]
+
+const original = useScene.getState()
+const originalWindow = globalThis.window
+const originalDocument = globalThis.document
+const originalRaf = globalThis.requestAnimationFrame
+const originalCancelRaf = globalThis.cancelAnimationFrame
+let stopSession = () => {}
+let unregisterHandler = () => {}
+
+const target = {
+  id: room.id,
+  type: 'zone',
+  name: 'Formal Dining Room',
+  levelId: level.id,
+  size: { length: 5, height: 0, thickness: 4 },
+  box: { min: [0, 0, 0], max: [5, 2.6, 4] },
+} as unknown as BubbleTarget
+
+const furniture = (id: string, position: [number, number, number]) =>
+  ItemNode.parse({
+    id,
+    parentId: level.id,
+    position,
+    asset: {
+      id: `asset_${id}`,
+      name: 'Chair',
+      category: 'chair',
+      src: '/fixture-chair.glb',
+      thumbnail: '',
+      dimensions: [0.5, 0.8, 0.5],
+    },
+  })
+
+function resetScene() {
+  useScene.setState({
+    nodes: { [building.id]: building, [level.id]: level, [room.id]: room },
+    rootNodeIds: [building.id],
+    dirtyNodes: new Set(),
+    readOnly: false,
+  } as never)
+  clearSceneHistory()
+}
+
+beforeEach(() => {
+  const stub = { addEventListener() {}, removeEventListener() {} }
+  globalThis.window = { ...stub, innerWidth: 1280, innerHeight: 800 } as never
+  globalThis.document = { ...stub, hidden: false } as never
+  globalThis.requestAnimationFrame = (callback) => {
+    callback(0)
+    return 0
+  }
+  globalThis.cancelAnimationFrame = () => {}
+  resetScene()
+  usePointAsk.setState({ pins: {}, pinOrder: [], bubble: null, comparing: null, busy: false })
+  unregisterHandler = registerPointAskHandler(async () => ({ ok: true }))
+  stopSession = startPointAskSession()
+})
+
+afterEach(() => {
+  endCompare()
+  endScenePreview()
+  stopSession()
+  unregisterHandler()
+  useScene.setState(original, true)
+  clearSceneHistory()
+  globalThis.window = originalWindow
+  globalThis.document = originalDocument
+  if (originalRaf) globalThis.requestAnimationFrame = originalRaf
+  else Reflect.deleteProperty(globalThis, 'requestAnimationFrame')
+  if (originalCancelRaf) globalThis.cancelAnimationFrame = originalCancelRaf
+  else Reflect.deleteProperty(globalThis, 'cancelAnimationFrame')
+})
+
+async function sendAsk(text = 'furnish this room') {
+  usePointAsk.getState().openBubble({
+    targets: [target],
+    anchor: [2.5, 0, 2],
+    hit: { point: [2.5, 0, 2], normal: [0, 1, 0] },
+    gesture: 'click',
+    capturedAt: new Date().toISOString(),
+    camera: null,
+    crop: { state: 'failed' },
+    draft: '',
+    error: null,
+  })
+  await sendBubble(text, { x: 0, y: 0, width: 10, height: 10 })
+  const askId = usePointAsk.getState().pinOrder.at(-1)
+  if (!askId) throw new Error('the ask did not plant a pin')
+  return askId
+}
+
+const status = (askId: string, rest: Record<string, unknown>) =>
+  emitter.emit('point-ask:status', { askId, ...rest } as never)
+
+/** A scene action of the agent: history tracks it, and is left as it was found. */
+function agentWrite(write: () => void) {
+  const wasTracking = useScene.temporal.getState().isTracking
+  useScene.temporal.getState().resume()
+  try {
+    write()
+  } finally {
+    if (!wasTracking) useScene.temporal.getState().pause()
+  }
+}
+
+const has = (id: string) => Boolean(useScene.getState().nodes[id as never])
+
+describe('hold to see before, for a turn that builds', () => {
+  test('the furniture the turn placed is not in the before', async () => {
+    const askId = await sendAsk()
+    status(askId, { status: 'working', sentence: 'Furnishing the room' })
+    agentWrite(() =>
+      useScene.getState().createNodes([
+        { node: furniture('item_table', [2.5, 0, 2]), parentId: level.id },
+        { node: furniture('item_chair_a', [1.5, 0, 2]), parentId: level.id },
+        { node: furniture('item_chair_b', [3.5, 0, 2]), parentId: level.id },
+      ] as never),
+    )
+    status(askId, { status: 'ended', outcome: 'completed', asked: false, wroteScene: true })
+    expect(usePointAsk.getState().pins[askId]?.model.state).toBe('done')
+    expect(has('item_table')).toBe(true)
+
+    expect(startCompare(askId)).toBe(true)
+    expect(isScenePreviewing()).toBe(true)
+    expect(has('item_table')).toBe(false)
+    expect(has('item_chair_a')).toBe(false)
+    expect(has('item_chair_b')).toBe(false)
+    expect(
+      (useScene.getState().nodes[level.id] as { children: string[] }).children.includes(
+        'item_table',
+      ),
+    ).toBe(false)
+
+    endCompare()
+    expect(has('item_table')).toBe(true)
+    expect(has('item_chair_b')).toBe(true)
+  })
+
+  test('furniture placed in several steps, one after another, is all out of the before', async () => {
+    const askId = await sendAsk()
+    status(askId, { status: 'working', sentence: 'Furnishing the room' })
+    agentWrite(() =>
+      useScene
+        .getState()
+        .createNodes([{ node: furniture('item_table', [2.5, 0, 2]), parentId: level.id }] as never),
+    )
+    agentWrite(() =>
+      useScene
+        .getState()
+        .createNodes([
+          { node: furniture('item_chair_a', [1.5, 0, 2]), parentId: level.id },
+        ] as never),
+    )
+    status(askId, { status: 'ended', outcome: 'completed', asked: false, wroteScene: true })
+    expect(startCompare(askId)).toBe(true)
+    expect(has('item_table')).toBe(false)
+    expect(has('item_chair_a')).toBe(false)
+  })
+})