@pascal-app/editor 0.9.2 → 1.0.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/editor",
-  "version": "0.9.2",
+  "version": "1.0.0-beta.1",
   "description": "Pascal building editor component",
   "type": "module",
   "exports": {
@@ -11,8 +11,8 @@
     "check-types": "tsgo --noEmit"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^0.9.2",
-    "@pascal-app/viewer": "^0.9.2",
+    "@pascal-app/core": "^1.0.0-beta.1",
+    "@pascal-app/viewer": "^1.0.0-beta.1",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "next": ">=15",
@@ -40,27 +40,29 @@
     "@radix-ui/react-tabs": "^1.1.13",
     "@radix-ui/react-tooltip": "^1.2.8",
     "@visual-json/react": "^0.4.0",
+    "blob-stream": "^0.1.3",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
     "howler": "^2.2.4",
-    "jspdf": "^4.2.1",
     "lucide-react": "^1.7.0",
     "mitt": "^3.0.1",
     "motion": "^12.34.3",
     "nanoid": "^5.1.6",
-    "svg2pdf.js": "^2.7.0",
+    "pdfkit": "^0.19.1",
     "tailwind-merge": "^3.5.0",
     "three-mesh-bvh": "~0.9.8",
     "zod": "^4.3.6",
     "zustand": "^5.0.11"
   },
   "devDependencies": {
-    "@pascal-app/core": "^0.9.2",
-    "@pascal-app/viewer": "^0.9.2",
+    "@pascal-app/core": "^1.0.0-beta.1",
+    "@pascal-app/viewer": "^1.0.0-beta.1",
     "@pascal/typescript-config": "*",
+    "@types/blob-stream": "^0.1.33",
     "@types/bun": "^1.3.0",
     "@types/howler": "^2.2.12",
+    "@types/pdfkit": "^0.17.6",
     "@types/react": "19.2.2",
     "@types/react-dom": "19.2.2",
     "@types/three": "^0.184.0",

package/src/components/editor/bake-exporter.tsx

@@ -29,7 +29,9 @@ export function BakeExporter({
         await nextFrames()
         const sceneGroup = scene.getObjectByName('scene-renderer')
         if (!sceneGroup) throw new Error('scene-renderer group not found')
-        const buffer = await exportSceneToGlb(sceneGroup, useScene.getState().nodes)
+        const buffer = await exportSceneToGlb(sceneGroup, useScene.getState().nodes, {
+          textures: 'reference',
+        })
         onComplete(buffer)
       } catch (err) {
         // The bake worker relays page console output into the job's error

package/src/components/editor/bake-thumbnail.tsx

@@ -0,0 +1,95 @@
+'use client'
+
+import {
+  computeHeroFraming,
+  createSnapshotPipeline,
+  GRID_LAYER,
+  heroCameraPose,
+  temporarilyHideNodeTypes,
+  useViewer,
+} from '@pascal-app/viewer'
+import { useThree } from '@react-three/fiber'
+import { useEffect, useRef } from 'react'
+import { PerspectiveCamera } from 'three'
+import type { WebGPURenderer } from 'three/webgpu'
+import { EDITOR_LAYER } from '../../lib/constants'
+
+export function BakeThumbnail({
+  active,
+  onComplete,
+  onError,
+}: {
+  active: boolean
+  onComplete: (blob: Blob, size: { w: number; h: number }) => void
+  onError: (message: string) => void
+}) {
+  const renderer = useThree((state) => state.gl)
+  const scene = useThree((state) => state.scene)
+  const doneRef = useRef(false)
+
+  useEffect(() => {
+    if (!(active && !doneRef.current)) return
+    doneRef.current = true
+
+    const run = async () => {
+      const restoreNodeVisibility = temporarilyHideNodeTypes(['scan', 'guide', 'spawn'])
+      let pipeline: Awaited<ReturnType<typeof createSnapshotPipeline>> = null
+
+      try {
+        const framing = computeHeroFraming()
+        if (!framing) {
+          onError('scene has no framable content')
+          return
+        }
+
+        const { width, height } = renderer.domElement
+        const aspect = width / height
+        const camera = new PerspectiveCamera(60, aspect, 0.1, 1000)
+        camera.layers.disable(EDITOR_LAYER)
+        camera.layers.disable(GRID_LAYER)
+        const pose = heroCameraPose({
+          boxes: framing.boxes,
+          aim: framing.aim,
+          azimuthRad: framing.azimuthRad,
+          aspect,
+        })
+        camera.position.set(pose.position[0], pose.position[1], pose.position[2])
+        camera.lookAt(pose.target[0], pose.target[1], pose.target[2])
+        camera.updateMatrixWorld()
+
+        pipeline = await createSnapshotPipeline({
+          renderer: renderer as unknown as WebGPURenderer,
+          scene,
+          camera,
+        })
+        if (!pipeline) {
+          onError('thumbnail pipeline failed to build')
+          return
+        }
+
+        pipeline.applyEnvironment({
+          theme: useViewer.getState().sceneTheme,
+          transparent: false,
+          grade: true,
+          edges: useViewer.getState().edges,
+          camera,
+        })
+        const { blob, outW, outH } = await pipeline.capture({ captureMode: 'standard' })
+        onComplete(blob, { w: outW, h: outH })
+      } catch (error) {
+        console.error(
+          '[bake-thumbnail]',
+          error instanceof Error ? (error.stack ?? error.message) : error,
+        )
+        onError(error instanceof Error ? error.message : String(error))
+      } finally {
+        pipeline?.dispose()
+        restoreNodeVisibility()
+      }
+    }
+
+    void run()
+  }, [active, onComplete, onError, renderer, scene])
+
+  return null
+}

package/src/components/editor/camera-dragging-lifecycle.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'bun:test'
+import { createCameraDraggingLifecycle } from './camera-dragging-lifecycle'
+
+describe('camera dragging lifecycle', () => {
+  test('releases wheel interactions even when camera controls never report rest', () => {
+    const dragging: boolean[] = []
+    let scheduled: (() => void) | null = null
+    const lifecycle = createCameraDraggingLifecycle({
+      setDragging: (value) => dragging.push(value),
+      schedule: (callback) => {
+        scheduled = callback
+        return 1 as unknown as ReturnType<typeof globalThis.setTimeout>
+      },
+      cancel: () => {
+        scheduled = null
+      },
+    })
+
+    lifecycle.begin()
+    lifecycle.scheduleEnd()
+    expect(dragging).toEqual([true])
+
+    const release = scheduled as (() => void) | null
+    release?.()
+    expect(dragging).toEqual([true, false])
+  })
+
+  test('cancels a pending wheel release when another interaction begins', () => {
+    const dragging: boolean[] = []
+    let scheduled: (() => void) | null = null
+    const lifecycle = createCameraDraggingLifecycle({
+      setDragging: (value) => dragging.push(value),
+      schedule: (callback) => {
+        scheduled = callback
+        return 1 as unknown as ReturnType<typeof globalThis.setTimeout>
+      },
+      cancel: () => {
+        scheduled = null
+      },
+    })
+
+    lifecycle.begin()
+    lifecycle.scheduleEnd()
+    lifecycle.begin()
+
+    expect(scheduled).toBeNull()
+    expect(dragging).toEqual([true, true])
+  })
+})

package/src/components/editor/camera-dragging-lifecycle.ts

@@ -0,0 +1,41 @@
+type TimerHandle = ReturnType<typeof globalThis.setTimeout>
+
+export function createCameraDraggingLifecycle({
+  setDragging,
+  fallbackMs = 500,
+  schedule = globalThis.setTimeout,
+  cancel = globalThis.clearTimeout,
+}: {
+  setDragging: (dragging: boolean) => void
+  fallbackMs?: number
+  schedule?: (callback: () => void, delay: number) => TimerHandle
+  cancel?: (timer: TimerHandle) => void
+}) {
+  let releaseTimer: TimerHandle | null = null
+
+  const clearScheduledEnd = () => {
+    if (releaseTimer === null) return
+    cancel(releaseTimer)
+    releaseTimer = null
+  }
+
+  const begin = () => {
+    clearScheduledEnd()
+    setDragging(true)
+  }
+
+  const end = () => {
+    clearScheduledEnd()
+    setDragging(false)
+  }
+
+  const scheduleEnd = () => {
+    clearScheduledEnd()
+    releaseTimer = schedule(() => {
+      releaseTimer = null
+      setDragging(false)
+    }, fallbackMs)
+  }
+
+  return { begin, end, scheduleEnd }
+}