@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/editor-views.ts

@@ -0,0 +1,178 @@
+import type { IconRef, LazyComponent } from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import { VIEW_2D, VIEW_3D, withoutView } from '../store/view-layout'
+
+/**
+ * A view fills a pane of the stage, beside or instead of the 3D scene and the
+ * 2D plan. Hosts and plugins register views the way they register rail panels;
+ * a plugin registers as many as it needs, each tagged with its `pluginId`.
+ */
+export type EditorHostView = {
+  id: string
+  label: string
+  icon: IconRef
+  component: LazyComponent
+  /** The view exists in a project only while this plugin is installed there. */
+  pluginId?: string
+  /** Workspaces the view is offered in. Default `['edit']`, like panels. */
+  workspaces?: readonly string[]
+  description?: string
+  /** Shown in the view bar until the user unpins it. Default false: the "More views" menu only. */
+  defaultPinned?: boolean
+  /** Always in the view bar: the user cannot unpin it. */
+  alwaysPinned?: boolean
+  /** Session views such as open documents can be dismissed from the tab bar. */
+  onClose?: () => void
+}
+
+/** A view as the stage needs it. The scene views have no component: the stage owns their canvases. */
+export type EditorViewDescriptor = Omit<EditorHostView, 'component'> & {
+  component?: LazyComponent
+  /** 3D and 2D: the views the level selector, tool dock and scene overlays belong to. */
+  scene?: boolean
+}
+
+export const SCENE_VIEWS: readonly EditorViewDescriptor[] = [
+  {
+    id: VIEW_3D,
+    label: '3D',
+    icon: { kind: 'url', src: '/icons/building.webp' },
+    scene: true,
+    defaultPinned: true,
+  },
+  {
+    id: VIEW_2D,
+    label: '2D',
+    icon: { kind: 'url', src: '/icons/blueprint.webp' },
+    scene: true,
+    defaultPinned: true,
+  },
+]
+
+export function isSceneView(viewId: string): boolean {
+  return viewId === VIEW_3D || viewId === VIEW_2D
+}
+
+function isDevMode(): boolean {
+  if (typeof process !== 'undefined' && process.env?.NODE_ENV) {
+    return process.env.NODE_ENV !== 'production'
+  }
+  return false
+}
+
+class EditorHostViewRegistryImpl {
+  private readonly views = new Map<string, EditorHostView>()
+  private readonly listeners = new Set<() => void>()
+  private cached: EditorHostView[] = []
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): EditorHostView[] => this.cached
+
+  reset(): void {
+    this.views.clear()
+    this.emit()
+  }
+
+  registerView(view: EditorHostView): void {
+    if (typeof view.id !== 'string' || view.id.length === 0) {
+      throw new Error('[editor:host-views] view id must be a non-empty string')
+    }
+    if (isSceneView(view.id)) {
+      throw new Error(`[editor:host-views] "${view.id}" is a built-in view`)
+    }
+    if (this.views.has(view.id)) {
+      if (isDevMode()) {
+        console.warn(`[editor:host-views] re-registering view "${view.id}" (HMR)`)
+      } else {
+        throw new Error(`[editor:host-views] duplicate view id: "${view.id}" already registered`)
+      }
+    }
+    this.views.set(view.id, view)
+    this.emit()
+  }
+
+  updateView(id: string, patch: Pick<EditorHostView, 'label'>): void {
+    const view = this.views.get(id)
+    if (!view) return
+    this.views.set(id, { ...view, ...patch })
+    this.emit()
+  }
+
+  unregisterView(id: string): void {
+    if (!this.views.delete(id)) return
+    useEditor.getState().closeView(id)
+    useEditor.setState((state) => {
+      const { [id]: _, ...pinnedViews } = state.pinnedViews
+      return {
+        pinnedViews,
+        viewLayouts: Object.fromEntries(
+          Object.entries(state.viewLayouts).map(([workspace, layout]) => [
+            workspace,
+            withoutView(layout, id),
+          ]),
+        ),
+      }
+    })
+    this.emit()
+  }
+
+  private emit(): void {
+    this.cached = Array.from(this.views.values())
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const editorHostViewRegistry = new EditorHostViewRegistryImpl()
+
+export function registerEditorHostView(view: EditorHostView): void {
+  editorHostViewRegistry.registerView(view)
+}
+
+export function unregisterEditorHostView(id: string): void {
+  editorHostViewRegistry.unregisterView(id)
+}
+
+/**
+ * Show a view: focus it if it is on screen, else put it in the focused pane —
+ * or, with `beside`, split and open it next to what is there.
+ */
+export function openEditorView(viewId: string, options?: { beside?: boolean }): void {
+  useEditor.getState().showView(viewId, options)
+}
+
+/**
+ * The views a project can show in a workspace: the scene views, then every
+ * registered view offered there whose plugin (if any) is installed.
+ */
+export function availableViews({
+  registered,
+  workspaceMode,
+  installedPlugins,
+}: {
+  registered: readonly EditorViewDescriptor[]
+  workspaceMode: string
+  installedPlugins: readonly string[]
+}): EditorViewDescriptor[] {
+  return [
+    ...SCENE_VIEWS,
+    ...registered.filter(
+      (view) =>
+        (view.workspaces ?? ['edit']).includes(workspaceMode) &&
+        (!view.pluginId || installedPlugins.includes(view.pluginId)),
+    ),
+  ]
+}
+
+export function isViewPinned(
+  view: EditorViewDescriptor,
+  pinnedViews: Readonly<Record<string, boolean>>,
+): boolean {
+  if (view.alwaysPinned) return true
+  return pinnedViews[view.id] ?? view.defaultPinned ?? false
+}

package/src/lib/export-geometry-wait.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  DoorNode,
+  nodeRegistry,
+  registerNode,
+  sceneRegistry,
+} from '@pascal-app/core'
+import * as THREE from 'three'
+import { nodesAwaitingExportGeometry, waitForExportGeometry } from './glb-export'
+
+const node = (id: string, type: string, fields: Record<string, unknown> = {}) =>
+  ({
+    object: 'node',
+    id,
+    type,
+    parentId: 'level_a',
+    visible: true,
+    metadata: {},
+    ...fields,
+  }) as unknown as AnyNode
+
+const definition = (kind: string, extra: Record<string, unknown> = {}) =>
+  ({
+    kind,
+    schemaVersion: 1,
+    schema: DoorNode,
+    category: 'utility',
+    defaults: () => ({}) as never,
+    capabilities: {},
+    bake: 'replace',
+    ...extra,
+  }) as AnyNodeDefinition
+
+let restoreRegistry: () => void
+
+beforeEach(() => {
+  restoreRegistry = nodeRegistry._snapshot()
+  registerNode(definition('test:plant'))
+  registerNode(definition('test:baked', { bakeGeometry: () => new THREE.Group() }))
+})
+
+afterEach(() => {
+  restoreRegistry()
+  sceneRegistry.clear()
+})
+
+// Live objects as the editor registers them: still empty, i.e. the export
+// geometry has not mounted.
+function mount(ids: string[]) {
+  for (const id of ids) sceneRegistry.nodes.set(id, new THREE.Group())
+}
+
+describe('waitForExportGeometry', () => {
+  const nodes: Record<string, AnyNode> = {
+    level_a: node('level_a', 'level', { parentId: null }),
+    plant_a: node('plant_a', 'test:plant'),
+    plant_hidden: node('plant_hidden', 'test:plant', { visible: false }),
+    baked_a: node('baked_a', 'test:baked'),
+  }
+
+  test('waits only for included collective kinds that mount their own geometry', () => {
+    mount(['plant_a', 'plant_hidden', 'baked_a'])
+    expect(nodesAwaitingExportGeometry(nodes)).toEqual(['plant_a'])
+    expect(nodesAwaitingExportGeometry(nodes, { onlyVisible: false })).toEqual([
+      'plant_a',
+      'plant_hidden',
+    ])
+    expect(nodesAwaitingExportGeometry(nodes, { excludedNodeTypes: ['test:plant'] })).toEqual([])
+    sceneRegistry.nodes.get('plant_a')!.add(new THREE.Mesh())
+    expect(nodesAwaitingExportGeometry(nodes)).toEqual([])
+  })
+
+  test('times out on its own timer when geometry never mounts and frames never run', async () => {
+    mount(['plant_a'])
+    const started = Date.now()
+    await waitForExportGeometry(nodes, {}, 300)
+    const elapsed = Date.now() - started
+    expect(elapsed).toBeGreaterThanOrEqual(280)
+    expect(elapsed).toBeLessThan(1500)
+  })
+
+  test('returns as soon as nothing is pending', async () => {
+    mount(['plant_a', 'baked_a'])
+    const started = Date.now()
+    await waitForExportGeometry(nodes, { excludedNodeTypes: ['test:plant'] }, 5_000)
+    expect(Date.now() - started).toBeLessThan(1_000)
+  })
+})

package/src/lib/export-texture-utils.ts

@@ -56,7 +56,6 @@ export function createExportTextureUtils(
 ): ExportTextureUtils {
   let pending: Promise<WebGPURenderer> | null = null
   let disposed = false
-  const quad = new QuadMesh()
 
   return {
     async decompress(texture, maxTextureSize = Number.POSITIVE_INFINITY) {
@@ -67,7 +66,7 @@ export function createExportTextureUtils(
       const renderer = await pending
 
       // Everything below the await is synchronous, which is what lets
-      // overlapping calls share `quad` and the renderer's colour space.
+      // overlapping calls share the renderer's size and colour space.
       const image = texture.image as { width: number; height: number }
       const width = Math.min(image.width, maxTextureSize)
       const height = Math.min(image.height, maxTextureSize)
@@ -77,9 +76,8 @@ export function createExportTextureUtils(
       const previousColorSpace = renderer.outputColorSpace
       renderer.setSize(width, height)
       renderer.outputColorSpace = texture.colorSpace
-      quad.material = material
       try {
-        quad.render(renderer)
+        new QuadMesh(material).render(renderer)
       } finally {
         renderer.outputColorSpace = previousColorSpace
         material.dispose()

package/src/lib/floor-edit-session.ts

@@ -0,0 +1,153 @@
+import {
+  type AnyNode,
+  area,
+  emitter,
+  type FloorOpeningNode,
+  intersection,
+  openingsForSurface,
+  removeFloorOpening,
+  structureChangeBatch,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import { markToolCancelConsumed } from '../hooks/use-keyboard'
+import useEditor from '../store/use-editor'
+import { cancelOpeningDraft } from './floor-opening-draft'
+import { completeElementAction } from './room-zone-routing'
+
+// "Edit floor": the room's floor openings, outlined in 3D and on the plan,
+// each a click away, with "Cut opening" to draw another. Like "Edit ceiling"
+// it is a standing mode rather than an interaction scope, so the scene stays
+// clickable; it ends with Done or Escape (back to the room), when the room is
+// deselected, or when another room is picked.
+
+export type FloorEditSession = { zoneId: string; levelId: string }
+
+export const useFloorEditSession = create<{ session: FloorEditSession | null }>(() => ({
+  session: null,
+}))
+
+type Nodes = Readonly<Record<string, AnyNode>>
+
+/**
+ * The openings through one surface of a room: those whose cut reaches that
+ * surface on the room's level (a floor opening here, a ceiling opening from
+ * the storey below) and overlap the room's outline.
+ */
+export function roomSurfaceOpenings(
+  nodes: Nodes,
+  zoneId: string,
+  surface: 'floor' | 'ceiling',
+): FloorOpeningNode[] {
+  const zone = nodes[zoneId]
+  if (zone?.type !== 'zone' || !zone.parentId) return []
+  const outline = { outer: zone.polygon, holes: zone.holes ?? [] }
+  const mezzanine = zone.floor?.support === 'open'
+  return openingsForSurface(nodes, zone.parentId, surface).filter((opening) =>
+    mezzanine
+      ? opening.hostZoneId === zoneId
+      : !opening.hostZoneId && area(intersection(opening.polygon, outline)) > 1e-6,
+  )
+}
+
+let stop: (() => void) | null = null
+
+export function startFloorEdit(zoneId: string): boolean {
+  const zone =
+    useScene.getState().nodes[zoneId as keyof ReturnType<typeof useScene.getState>['nodes']]
+  if (zone?.type !== 'zone' || !zone.parentId) return false
+  endFloorEdit()
+  useFloorEditSession.setState({ session: { zoneId, levelId: zone.parentId } })
+  stop = watch(zoneId)
+  return true
+}
+
+export function endFloorEdit() {
+  stop?.()
+  stop = null
+  if (useFloorEditSession.getState().session) useFloorEditSession.setState({ session: null })
+}
+
+/** Done / Escape: ends the session on the room it edited. */
+export function finishFloorEdit() {
+  const session = useFloorEditSession.getState().session
+  if (!session) return false
+  endFloorEdit()
+  completeElementAction({ room: session, point: null })
+  return true
+}
+
+function watch(zoneId: string) {
+  const stopEditor = useEditor.subscribe((state) => {
+    if (state.room?.zoneId !== zoneId && !openingSelectedIn(zoneId)) endFloorEdit()
+  })
+  const stopScene = useScene.subscribe((state) => {
+    if (state.nodes[zoneId as keyof typeof state.nodes]?.type !== 'zone') endFloorEdit()
+  })
+  const onToolCancel = () => {
+    if (useViewer.getState().selection.selectedIds.length) return
+    if (finishFloorEdit()) markToolCancelConsumed()
+  }
+  emitter.on('tool:cancel', onToolCancel)
+  return () => {
+    stopEditor()
+    stopScene()
+    emitter.off('tool:cancel', onToolCancel)
+  }
+}
+
+function openingSelectedIn(zoneId: string) {
+  const nodes = useScene.getState().nodes as Nodes
+  const [id] = useViewer.getState().selection.selectedIds
+  return (
+    !!id &&
+    nodes[id]?.type === 'floor-opening' &&
+    roomSurfaceOpenings(nodes, zoneId, 'floor').some((opening) => opening.id === id)
+  )
+}
+
+/** The room an opening belongs to: the selected room, else the room it overlaps most. */
+export function openingRoom(nodes: Nodes, opening: FloorOpeningNode): string | null {
+  if (opening.hostZoneId) return opening.hostZoneId
+  const selected = useEditor.getState().room
+  if (selected && selected.levelId === opening.parentId) return selected.zoneId
+  let best: { id: string; overlap: number } | null = null
+  for (const node of Object.values(nodes)) {
+    if (node.type !== 'zone' || node.parentId !== opening.parentId || node.spaceRole !== 'room')
+      continue
+    const overlap = area(
+      intersection(opening.polygon, { outer: node.polygon, holes: node.holes ?? [] }),
+    )
+    if (overlap > (best?.overlap ?? 1e-6)) best = { id: node.id, overlap }
+  }
+  return best?.id ?? null
+}
+
+/** Deletes an opening (one undo step) and lands on its room. */
+export function deleteFloorOpening(openingId: string) {
+  const nodes = useScene.getState().nodes as Nodes
+  const opening = nodes[openingId]
+  if (opening?.type !== 'floor-opening' || useScene.getState().readOnly) return false
+  if (opening.source === 'stair' || opening.source === 'elevator') return false
+  const zoneId = openingRoom(nodes, opening)
+  cancelOpeningDraft()
+  const plan = removeFloorOpening(nodes, openingId)
+  useScene.getState().applyNodeChanges(structureChangeBatch(plan.changes))
+  useViewer.getState().setSelection({ selectedIds: [] })
+  if (zoneId && opening.parentId)
+    completeElementAction({ room: { levelId: opening.parentId, zoneId }, point: null })
+  return true
+}
+
+/** Done in the opening's panel: back to its room. */
+export function finishFloorOpening(openingId: string) {
+  const nodes = useScene.getState().nodes as Nodes
+  const opening = nodes[openingId]
+  if (opening?.type !== 'floor-opening') return false
+  const zoneId = openingRoom(nodes, opening)
+  useViewer.getState().setSelection({ selectedIds: [] })
+  if (zoneId && opening.parentId)
+    completeElementAction({ room: { levelId: opening.parentId, zoneId }, point: null })
+  return true
+}