@pascal-app/editor 1.0.0 → 1.0.3

package/src/lib/level-duplication.ts

@@ -1,5 +1,5 @@
 import { cloneLevelSubtree } from '@pascal-app/core/clone-scene-graph'
-import type { AnyNode, AnyNodeId, LevelNode } from '@pascal-app/core/schema'
+import { type AnyNode, type AnyNodeId, type LevelNode, UnitNode } from '@pascal-app/core/schema'
 
 export type LevelDuplicatePreset =
   | 'everything'
@@ -117,7 +117,7 @@ export function buildLevelDuplicateCreateOps({
   levels: LevelNode[]
   preset: LevelDuplicatePreset
 }) {
-  const { clonedNodes, newLevelId } = cloneLevelSubtree(nodes, level.id)
+  const { clonedNodes, newLevelId, idMap } = cloneLevelSubtree(nodes, level.id)
   const parentBuildingId =
     (level.parentId as AnyNodeId | null) ?? findLevelBuildingId(nodes, level.id)
   const nextLevelNumber = level.level + 1
@@ -145,6 +145,36 @@ export function buildLevelDuplicateCreateOps({
     } as AnyNode
   })
 
+  if (parentBuildingId && nodes[parentBuildingId]?.type === 'building') {
+    for (const unit of Object.values(nodes)) {
+      if (
+        unit.type !== 'unit' ||
+        unit.parentId !== parentBuildingId ||
+        unit.members.length === 0 ||
+        !unit.members.every((id) => {
+          const zone = nodes[id]
+          const remapped = idMap.get(id)
+          return (
+            zone?.type === 'zone' &&
+            zone.parentId === level.id &&
+            remapped !== undefined &&
+            keptIds.has(remapped as AnyNodeId)
+          )
+        })
+      )
+        continue
+      cleanedNodes.push(
+        UnitNode.parse({
+          ...unit,
+          id: undefined,
+          parentId: parentBuildingId,
+          name: `${unit.name} copy`,
+          members: unit.members.map((id) => idMap.get(id)),
+        }),
+      )
+    }
+  }
+
   return {
     createOps: cleanedNodes.map((node) => ({
       node:

package/src/lib/linear-display.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from 'bun:test'
+import { getLinearDisplay } from './linear-display'
+
+describe('linear property control units', () => {
+  test('keeps meter storage while displaying and accepting millimeters', () => {
+    const display = getLinearDisplay('m', 'metric', 'millimeters', 2, 0.05)
+    expect(display.displayUnit).toBe('mm')
+    expect(display.parseUnit).toBe('mm')
+    expect(display.toDisplay(2.5)).toBe(2500)
+    expect(display.toStored(1800)).toBe(1.8)
+    expect(display.toStored(-250)).toBe(-0.25)
+    expect(display.precision).toBe(0)
+    expect(display.step).toBe(50)
+    expect(display.toStored(display.step)).toBe(0.05)
+  })
+
+  test('retains sub-millimeter precision when the field supports it', () => {
+    const display = getLinearDisplay('m', 'metric', 'millimeters', 4, 0.0001)
+    expect(display.precision).toBe(1)
+    expect(display.step).toBe(0.1)
+    expect(display.toDisplay(0.0125)).toBe(12.5)
+    expect(display.roundStored(0.01254)).toBe(0.0125)
+  })
+
+  test('imperial preference takes precedence over the saved metric notation', () => {
+    const display = getLinearDisplay('m', 'imperial', 'millimeters', 2, 0.05)
+    expect(display.displayUnit).toBe('ft')
+    expect(display.parseUnit).toBe('ft')
+    expect(display.toDisplay(0.9144)).toBeCloseTo(3, 10)
+    expect(display.toStored(7)).toBeCloseTo(2.1336, 10)
+    expect(display.precision).toBe(2)
+    expect(display.step).toBe(0.05)
+  })
+
+  test('switching notation round-trips the same stored dimensions', () => {
+    for (const stored of [0, 0.01, 0.125, 0.9, 2.1, -0.25]) {
+      for (const [unit, notation] of [
+        ['metric', 'meters'],
+        ['metric', 'millimeters'],
+        ['imperial', 'meters'],
+      ] as const) {
+        const display = getLinearDisplay('m', unit, notation, 2, 0.01)
+        expect(display.toStored(display.toDisplay(stored))).toBeCloseTo(stored, 12)
+      }
+    }
+  })
+
+  test('leaves non-meter fields and their gesture steps unchanged', () => {
+    for (const unit of ['°', 'rad', '%', '', 'in', 'cm']) {
+      const display = getLinearDisplay(unit, 'metric', 'millimeters', 2, 0.05)
+      expect(display.displayUnit).toBe(unit)
+      expect(display.parseUnit).toBeUndefined()
+      expect(display.toDisplay(12.5)).toBe(12.5)
+      expect(display.toStored(12.5)).toBe(12.5)
+      expect(display.precision).toBe(2)
+      expect(display.step).toBe(0.05)
+    }
+  })
+})

package/src/lib/linear-display.ts

@@ -0,0 +1,39 @@
+import {
+  getLinearUnitLabel,
+  type LinearUnit,
+  linearUnitToMeters,
+  type MetricNotation,
+  metersToLinearUnit,
+} from './measurements'
+
+export function getLinearDisplay(
+  unit: string,
+  viewerUnit: LinearUnit,
+  metricNotation: MetricNotation,
+  precision: number,
+  step: number,
+) {
+  const isImperial = unit === 'm' && viewerUnit === 'imperial'
+  const isMillimeters = unit === 'm' && viewerUnit === 'metric' && metricNotation === 'millimeters'
+  const displayUnit = isImperial ? getLinearUnitLabel('imperial') : isMillimeters ? 'mm' : unit
+  const displayPrecision = isMillimeters ? Math.max(0, precision - 3) : precision
+  const displayStep = isMillimeters ? step * 1000 : step
+  const parseUnit = isImperial ? 'ft' : isMillimeters ? 'mm' : undefined
+  const toDisplay = (stored: number) =>
+    isImperial ? metersToLinearUnit(stored, 'imperial') : isMillimeters ? stored * 1000 : stored
+  const toStored = (display: number) =>
+    isImperial ? linearUnitToMeters(display, 'imperial') : isMillimeters ? display / 1000 : display
+  const roundStored = (stored: number) =>
+    toStored(Number.parseFloat(toDisplay(stored).toFixed(displayPrecision)))
+
+  return {
+    isImperial,
+    displayUnit,
+    parseUnit,
+    precision: displayPrecision,
+    step: displayStep,
+    toDisplay,
+    toStored,
+    roundStored,
+  }
+}

package/src/lib/local-guide-image.test.ts

@@ -0,0 +1,24 @@
+import { expect, mock, test } from 'bun:test'
+import * as core from '@pascal-app/core'
+
+const saveAsset = mock(async () => 'asset://stored-scan')
+
+mock.module('@pascal-app/core', () => ({ ...core, saveAsset }))
+
+const { createLocalScan } = await import('./local-guide-image')
+
+test('createLocalScan stores and attaches a scan asset to its level', async () => {
+  const createNode = mock()
+  const file = new File(['scan data'], 'living-room.glb', { type: 'model/gltf-binary' })
+
+  const { scan, url } = await createLocalScan({ createNode, file, levelId: 'level_ground' })
+
+  expect(saveAsset).toHaveBeenCalledWith(file)
+  expect(scan).toMatchObject({
+    name: 'living-room',
+    type: 'scan',
+    url: 'asset://stored-scan',
+  })
+  expect(url).toBe('asset://stored-scan')
+  expect(createNode).toHaveBeenCalledWith(scan, 'level_ground')
+})

package/src/lib/local-guide-image.ts

@@ -2,13 +2,23 @@ import {
   type AnyNodeId,
   GuideNode,
   type GuideNode as GuideNodeType,
+  ScanNode,
+  type ScanNode as ScanNodeType,
   saveAsset,
 } from '@pascal-app/core'
 
 export function getGuideImageName(filename: string) {
+  return getAssetName(filename, 'Guide image')
+}
+
+export function getScanName(filename: string) {
+  return getAssetName(filename, 'Scan')
+}
+
+function getAssetName(filename: string, fallback: string) {
   const trimmed = filename.trim()
   if (!trimmed) {
-    return 'Guide image'
+    return fallback
   }
 
   const dotIndex = trimmed.lastIndexOf('.')
@@ -40,3 +50,26 @@ export async function createLocalGuideImage({
   createNode(guide, levelId as AnyNodeId)
   return guide
 }
+
+export async function createLocalScan({
+  createNode,
+  file,
+  levelId,
+}: {
+  createNode: (node: ScanNodeType, parentId: AnyNodeId) => void
+  file: File
+  levelId: string
+}) {
+  const assetUrl = await saveAsset(file)
+  const scan = ScanNode.parse({
+    name: getScanName(file.name),
+    url: assetUrl,
+    position: [0, 0, 0],
+    rotation: [0, 0, 0],
+    scale: 1,
+    opacity: 100,
+  })
+
+  createNode(scan, levelId as AnyNodeId)
+  return { scan, url: assetUrl }
+}

package/src/lib/material-catalog-model.ts

@@ -0,0 +1,72 @@
+'use client'
+
+import {
+  getCatalogMaterialById,
+  getDynamicLibraryMaterials,
+  getLibraryMaterialIdFromRef,
+  getLibraryMaterialsVersion,
+  getMaterialsForCategory,
+  MATERIAL_CATEGORIES,
+  type MaterialSource,
+  subscribeLibraryMaterials,
+  toLibraryMaterialRef,
+} from '@pascal-app/core'
+import { useEffect, useState, useSyncExternalStore } from 'react'
+
+export type MaterialSourceFilter = MaterialSource
+const SOURCE_FILTERS: { id: MaterialSourceFilter; label: string }[] = [
+  { id: 'pascal', label: 'Pascal' },
+  { id: 'mine', label: 'Mine' },
+  { id: 'workspace', label: 'Workspace' },
+  { id: 'community', label: 'Community' },
+]
+
+export function useMaterialCatalogModel(
+  selectedMaterialPreset?: string,
+  onSelectMaterialPreset?: (ref: string) => void,
+  disabled = false,
+) {
+  const [selectedCategory, setCategory] = useState<(typeof MATERIAL_CATEGORIES)[number]>(
+    MATERIAL_CATEGORIES[0],
+  )
+  const [sourceFilter, setSourceFilter] = useState<MaterialSourceFilter>('pascal')
+  useSyncExternalStore(
+    subscribeLibraryMaterials,
+    getLibraryMaterialsVersion,
+    getLibraryMaterialsVersion,
+  )
+  const availableCategories = MATERIAL_CATEGORIES.filter(
+    (category) => getMaterialsForCategory(category).length > 0,
+  )
+  const visibleSourceFilters = SOURCE_FILTERS.filter(
+    (filter) =>
+      filter.id !== 'workspace' ||
+      getDynamicLibraryMaterials().some((item) => item.source === 'workspace'),
+  )
+  const itemsFor = (category: typeof selectedCategory) =>
+    getMaterialsForCategory(category).filter((item) => (item.source ?? 'pascal') === sourceFilter)
+  useEffect(() => {
+    const entry = getCatalogMaterialById(
+      getLibraryMaterialIdFromRef(selectedMaterialPreset) ?? undefined,
+    )
+    if (entry?.category) setCategory(entry.category)
+  }, [selectedMaterialPreset])
+  const select = (id: string) => {
+    if (!disabled) onSelectMaterialPreset?.(toLibraryMaterialRef(id))
+  }
+  const setSelectedCategory = (category: typeof selectedCategory) => {
+    setCategory(category)
+    const first = itemsFor(category)[0]
+    if (first) select(first.id)
+  }
+  return {
+    selectedCategory,
+    setSelectedCategory,
+    sourceFilter,
+    setSourceFilter,
+    visibleSourceFilters,
+    availableCategories,
+    catalogItems: itemsFor(selectedCategory),
+    select,
+  }
+}

package/src/lib/material-paint-panel-model.ts

@@ -0,0 +1,76 @@
+'use client'
+
+import {
+  type AnyNodeId,
+  generateSceneMaterialId,
+  toSceneMaterialRef,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import useEditor from '../store/use-editor'
+import { buildResetSurfaceMaterialUpdates, resolvePaintTargetFromSelection } from './material-paint'
+
+export function useMaterialPaintPanelModel(enabled = true) {
+  const activePaintMaterial = useEditor((state) => state.activePaintMaterial)
+  const activePaintTarget = useEditor((state) => state.activePaintTarget)
+  const setActivePaintMaterial = useEditor((state) => state.armMaterialPaint)
+  const setActivePaintTarget = useEditor((state) => state.setActivePaintTarget)
+  const paintEraser = useEditor((state) => state.paintEraser)
+  const setPaintEraser = useEditor((state) => state.setPaintEraser)
+  const selectedId = useViewer((state) =>
+    state.selection.selectedIds.length === 1 ? (state.selection.selectedIds[0] ?? null) : null,
+  )
+  const paintTarget = useScene((state) =>
+    resolvePaintTargetFromSelection({ nodes: state.nodes, selectedId }),
+  )
+  const materials = useScene((state) => state.materials)
+  const canResetSelection = paintTarget !== null
+  useEffect(() => {
+    if (enabled && paintTarget) setActivePaintTarget(paintTarget)
+  }, [enabled, paintTarget, setActivePaintTarget])
+  const resetSelection = () => {
+    const scene = useScene.getState()
+    const node = selectedId ? scene.nodes[selectedId as AnyNodeId] : undefined
+    if (node) scene.updateNodes(buildResetSurfaceMaterialUpdates(scene.nodes, node))
+  }
+  const createCustomMaterial = () => {
+    const scene = useScene.getState()
+    const id = generateSceneMaterialId()
+    scene.addSceneMaterial({
+      id,
+      name: `Material ${Object.keys(scene.materials).length + 1}`,
+      material: {
+        preset: 'custom',
+        properties: {
+          color: '#ffffff',
+          roughness: 0.5,
+          metalness: 0,
+          opacity: 1,
+          transparent: false,
+          side: 'front',
+        },
+      },
+    })
+    setActivePaintMaterial({
+      materialPreset: toSceneMaterialRef(id),
+      sourceTarget: useEditor.getState().activePaintTarget,
+    })
+    return id
+  }
+  const selectMaterial = (materialPreset: string) =>
+    setActivePaintMaterial({ materialPreset, sourceTarget: useEditor.getState().activePaintTarget })
+  return {
+    activePaintMaterial,
+    activePaintTarget,
+    setActivePaintMaterial,
+    paintEraser,
+    setPaintEraser,
+    materials,
+    materialCount: Object.keys(materials).length,
+    canResetSelection,
+    resetSelection,
+    createCustomMaterial,
+    selectMaterial,
+  }
+}

package/src/lib/node-action-movement.ts

@@ -0,0 +1,21 @@
+import { type AnyNode, createSceneApi, isMovable, nodeRegistry, useScene } from '@pascal-app/core'
+
+export function registryMoveDisabled(node: AnyNode): boolean {
+  const def = nodeRegistry.get(node.type)
+  return Boolean(
+    def?.capabilities.movable &&
+      !isMovable(node) &&
+      !def.floorplanMoveTarget &&
+      !def.affordanceTools?.move,
+  )
+}
+
+export function duplicateWithoutMove(node: AnyNode) {
+  const api = createSceneApi(useScene)
+  const subtree = api.getSubtree(node.id)
+  if (!subtree || !node.parentId) return null
+  return api.cloneNodesInto([subtree.root, ...subtree.descendants], {
+    rootId: node.id,
+    parentId: node.parentId as AnyNode['id'],
+  })
+}

package/src/lib/overlay-transform.test.ts

@@ -0,0 +1,28 @@
+import { test } from 'bun:test'
+import assert from 'node:assert/strict'
+import { Group } from 'three'
+import { copyOverlayWorldTransform } from './overlay-transform'
+
+test('opening overlays retain the source transform through God-mode zoom and rotation', () => {
+  const model = new Group()
+  const wall = new Group()
+  const opening = new Group()
+  model.add(wall)
+  wall.add(opening)
+  wall.rotation.y = 0.8
+  opening.position.set(2, 1.5, 0.1)
+  const portal = new Group()
+  portal.position.set(4, 1, -2)
+  portal.rotation.y = -0.4
+  const overlay = new Group()
+  portal.add(overlay)
+  for (const scale of [0.01, 0.2, 1, 4, 0.05]) {
+    model.scale.set(scale, scale * 2, scale)
+    model.rotation.y += 0.2
+    copyOverlayWorldTransform(opening, overlay)
+    overlay.updateWorldMatrix(true, false)
+    overlay.matrixWorld.elements.forEach((value, i) => {
+      assert.ok(Math.abs(value - opening.matrixWorld.elements[i]!) < 1e-8)
+    })
+  }
+})

package/src/lib/overlay-transform.ts

@@ -0,0 +1,12 @@
+import type { Object3D } from 'three'
+
+/** Preserve scale and shear when an overlay is portalled outside its source hierarchy. */
+export function copyOverlayWorldTransform(source: Object3D, overlay: Object3D) {
+  source.updateWorldMatrix(true, false)
+  overlay.parent?.updateWorldMatrix(true, false)
+  overlay.matrixAutoUpdate = false
+  if (overlay.parent)
+    overlay.matrix.copy(overlay.parent.matrixWorld).invert().multiply(source.matrixWorld)
+  else overlay.matrix.copy(source.matrixWorld)
+  overlay.matrixWorldNeedsUpdate = true
+}

package/src/lib/panel-rows.ts

@@ -0,0 +1,75 @@
+import type { AnyNode, AnyNodeDefinition, AnyNodeId } from '@pascal-app/core'
+
+export type PanelIcon = { color?: string; src?: string }
+
+export type PanelAction = {
+  icon?: PanelIcon
+  disabled?: boolean
+  id: string
+  label: string
+  onSelect?: () => void
+}
+
+export type PanelRow = { section?: string } & (
+  | {
+      id: string
+      kind: 'action'
+      icon?: PanelIcon
+      label: string
+      onSelect?: () => void
+      disabled?: boolean
+    }
+  | {
+      actions: PanelAction[]
+      id: string
+      kind: 'actions'
+    }
+  | {
+      id: string
+      kind: 'choice'
+      label: string
+      onSelect?: () => void
+      value: string
+    }
+  | {
+      getValue: () => string
+      id: string
+      kind: 'subscribed-choice'
+      label: string
+      onSelect?: () => void
+      subscribe: (listener: () => void) => () => void
+    }
+  | {
+      id: string
+      kind: 'cycle'
+      label: string
+      next: () => void
+      previous: () => void
+      value: string
+    }
+  | {
+      id: string
+      kind: 'stepper'
+      label: string
+      max: number
+      min: number
+      onChange: (value: number) => void
+      step: number
+      unit?: string
+      value: number
+    }
+)
+
+export const PANEL_MODEL_EXTENSION = 'pascal:editor/panel-model'
+
+export type NodePanelModel<N extends AnyNode = AnyNode> = {
+  rows: (context: {
+    node: N
+    nodes: Record<AnyNodeId, AnyNode>
+    update: (patch: Partial<N>) => void
+  }) => PanelRow[]
+}
+
+export function getNodePanelModel(definition: AnyNodeDefinition | undefined) {
+  return definition?.extensions?.[PANEL_MODEL_EXTENSION] as NodePanelModel | undefined
+}

package/src/lib/panel-tool-options.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from 'bun:test'
+import { createToolHintsStore } from './panel-tool-options'
+
+test('tool hints share subscriptions, react to visibility and chip state, and unsubscribe', () => {
+  let visible = false
+  let value = 'auto'
+  let subscriptions = 0
+  let cleanups = 0
+  const subscribe = (_listener: () => void) => {
+    subscriptions++
+    return () => {
+      cleanups++
+    }
+  }
+  const store = createToolHintsStore([
+    {
+      key: 'P',
+      label: 'Placement',
+      visible: { subscribe, value: () => visible },
+      chip: { subscribe, value: () => value, cycle: () => {}, labels: { auto: 'Auto' } },
+    },
+  ])
+  const cleanup = store.subscribe(() => {})
+  expect(subscriptions).toBe(1)
+  const hidden = store.getSnapshot()
+  visible = true
+  expect(store.getSnapshot()).not.toBe(hidden)
+  const shown = store.getSnapshot()
+  value = 'roof'
+  expect(store.getSnapshot()).not.toBe(shown)
+  expect(store.getSnapshot()).toBe(store.getSnapshot())
+  cleanup()
+  expect(cleanups).toBe(1)
+})

package/src/lib/panel-tool-options.ts

@@ -0,0 +1,46 @@
+'use client'
+
+import { nodeRegistry, type ToolHint, useRegistryVersion } from '@pascal-app/core'
+import { useMemo, useSyncExternalStore } from 'react'
+import useEditor from '../store/use-editor'
+
+export type PanelToolOption = {
+  id: string
+  label: string
+  value: string
+  choices: readonly { value: string; label: string; description?: string }[]
+  set: (value: string) => void
+}
+
+export function createToolHintsStore(hints: readonly ToolHint[]) {
+  return {
+    subscribe(listener: () => void) {
+      const subscriptions = hints.flatMap((hint) => [hint.chip?.subscribe, hint.visible?.subscribe])
+      const cleanups = [...new Set(subscriptions)].flatMap((subscribe) =>
+        subscribe ? [subscribe(listener)] : [],
+      )
+      return () => {
+        for (const cleanup of cleanups) cleanup()
+      }
+    },
+    getSnapshot: () =>
+      JSON.stringify(hints.map((hint) => [hint.visible?.value() ?? true, hint.chip?.value()])),
+  }
+}
+
+export function useVisibleToolHints(hints: readonly ToolHint[] = []) {
+  const draftVertexCount = useEditor((state) => state.draftVertexCount)
+  const store = useMemo(() => createToolHintsStore(hints), [hints])
+  useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot)
+  return hints.filter(
+    (hint) =>
+      !(hint.key === 'Shift' && hint.label === 'Cycle snapping mode') &&
+      (hint.visible?.value() ?? true) &&
+      (hint.minDraftVertices == null || draftVertexCount >= hint.minDraftVertices),
+  )
+}
+
+export function usePanelToolHints(kind: string | null | undefined) {
+  useRegistryVersion()
+  return useVisibleToolHints(kind ? nodeRegistry.get(kind)?.toolHints : undefined)
+}

package/src/lib/parametric-node-update.ts

@@ -0,0 +1,37 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  nodeRegistry,
+  type ParametricDescriptor,
+  useScene,
+} from '@pascal-app/core'
+
+export function commitParametricNodeFields(
+  nodeId: AnyNodeId,
+  requestedPatch: Partial<AnyNode>,
+): void {
+  const scene = useScene.getState()
+  const node = scene.nodes[nodeId]
+  if (!node) return
+
+  const parametrics = nodeRegistry.get(node.type)?.parametrics as
+    | ParametricDescriptor<AnyNode>
+    | undefined
+  let patch = requestedPatch as Record<string, unknown>
+  if (parametrics?.derive) {
+    const next = { ...node, ...patch } as AnyNode
+    patch = {
+      ...patch,
+      ...parametrics.derive(next, patch as Partial<AnyNode>, node),
+    }
+  }
+
+  const updates: { id: AnyNodeId; data: Partial<AnyNode> }[] = [
+    { id: nodeId, data: patch as Partial<AnyNode> },
+  ]
+  if (parametrics?.reconcile) {
+    const next = { ...node, ...patch } as AnyNode
+    updates.push(...parametrics.reconcile(node, next))
+  }
+  scene.updateNodes(updates)
+}