Phase 5 Stage E: full kind migration into packages/nodes

Wholesale move of every remaining kind into its own subdirectory under `packages/nodes/src/`, finishing the registry-driven migration. Each kind now ships its definition, schema (re-exported from core), and any of `geometry` / `renderer` / `system` / `floorplan` / `tool` / `move-tool` / `panel` / `floorplan-move` / `floorplan-affordances` / `parametrics` / `preview` it needs — no per-kind code remains under `packages/editor/src/components/tools/` or `packages/viewer/src/components/renderers/`. Deleted (replaced by registry-driven equivalents): - `tools/{ceiling,column,door,fence,item,slab,spawn,wall,window}/...` (boundary editors, hole editors, placement tools, move tools, endpoint movers, curve tools, helpers, math libs) - `ui/helpers/{ceiling,slab,wall}-helper.tsx` - `ui/panels/{column,door,elevator,item,roof,roof-segment,spawn, stair,stair-segment,wall,window}-panel.tsx` - `viewer/src/components/renderers/{building,ceiling,column,door, elevator,fence,guide,item,level,roof,roof-segment,scan,site,slab, spawn,stair,stair-segment,wall,window,zone}-renderer.tsx` - `viewer/src/components/viewer/legacy-system.tsx` Added under `packages/nodes/src/`: - `building/`, `column/`, `elevator/`, `guide/`, `level/`, `roof/`, `roof-segment/`, `scan/`, `shared/`, `site/`, `stair/`, `stair-segment/` packages with definition + schema + renderer / system / floorplan / panel as appropriate. - New `floorplan-move.ts` for every kind that supports 2D moves (ceiling, door, item, shelf, slab, window) — single registry-driven dispatch path via `def.floorplanMoveTarget`. - New `floorplan-affordances.ts` for kinds with polygon / endpoint drags (ceiling, fence, slab, wall) — using the shared `polygon-vertex-affordance` factories. - New per-kind `panel.tsx` for kinds with custom inspector content (door, item, shelf, spawn, wall, window). - New per-kind `tool.tsx` for placement (door, item, shelf, window). - New per-kind `move-tool.tsx` for kinds with custom 3D move flows (door, item, slab, window). Coordinator + manager updates in `packages/editor/`: - `tool-manager.tsx` resolves tools from the registry only — no hardcoded type→component map. - `panel-manager.tsx` resolves inspector panels the same way. - `placement-{coordinator,strategies,types}.ts` extended with shelf-surface placement. - `selection-manager.tsx` adds the registry-selectable fallback. - `floorplan-panel.tsx`, `floorplan-background-placement.ts`, `floorplan-render-context.tsx` updated for the registry layer's new contract (props, affordance dispatch, render context). Viewer updates: - `viewer/index.tsx` drops legacy renderer mounts. - `node-renderer.tsx` resolves by registry only. - `scene-bvh.tsx`, `use-node-events.ts`, `level-system.tsx`, `wall-cutout.tsx`, `zone-system.tsx`, `materials.ts` adjusted for the registry-only world. Sidebar tree nodes for ceiling / fence / slab / shelf / tree-node updated to read from the registered nodes instead of the deleted legacy renderer trees. Wiki: new `plugin-authoring.md` page, README index updated. Tests in `packages/nodes/src/index.test.ts` validate every registered kind has the required shape. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-19 15:14:12 -04:00
parent 11015ea1ed
commit d747d2f0ea
204 changed files with 6888 additions and 7877 deletions
@@ -0,0 +1,285 @@
+import {
+  type AnyNodeId,
+  type FloorplanAffordance,
+  type FloorplanAffordanceSession,
+  useScene,
+} from '@pascal-app/core'
+import { snapPointToGrid, type WallPlanPoint } from '@pascal-app/editor'
+
+/**
+ * Shared "edit polygon" floor-plan affordances. Used by kinds whose
+ * primary editable shape is a `polygon: [number, number][]` field
+ * (slab, ceiling, site, zone) with optional `holes: [number, number][][]`.
+ *
+ * Each affordance accepts an optional `holeIndex` in its payload — when
+ * present, the operation targets `node.holes[holeIndex]`; otherwise it
+ * targets the outer `node.polygon`. The same factory wires both
+ * boundary and hole interactions without duplicating the math.
+ *
+ * Three affordances available:
+ *
+ * - `move-vertex` — drag an existing vertex.
+ * - `add-vertex` — insert a new vertex at an edge midpoint, then drag
+ *   it (click-without-drag reverts to the snapshot).
+ * - `move-edge` — drag a whole edge perpendicular to itself (both
+ *   endpoints translate by `normal * projection`).
+ */
+
+export type PolygonVertexPayload = {
+  /** Target a hole's polygon instead of the boundary. */
+  holeIndex?: number
+  vertexIndex: number
+}
+
+export type AddVertexPayload = {
+  holeIndex?: number
+  edgeIndex: number
+}
+
+export type EdgeDragPayload = {
+  holeIndex?: number
+  edgeIndex: number
+}
+
+type PolygonShape = {
+  polygon: ReadonlyArray<readonly [number, number]>
+  holes?: ReadonlyArray<ReadonlyArray<readonly [number, number]>>
+}
+
+function getRing(node: PolygonShape, holeIndex: number | undefined): [number, number][] | null {
+  if (holeIndex === undefined) {
+    return node.polygon.map(([x, y]) => [x, y] as [number, number])
+  }
+  const hole = node.holes?.[holeIndex]
+  if (!hole) return null
+  return hole.map(([x, y]) => [x, y] as [number, number])
+}
+
+/**
+ * Returns a patch object that, when applied to the node, updates the
+ * targeted ring (boundary polygon or specific hole) to `nextRing`. The
+ * cast through `unknown → Partial<unknown> → never` satisfies the
+ * generic `updateNodes` patch type without forcing every variant of
+ * the kind union into scope here.
+ */
+function buildRingPatch(
+  node: PolygonShape,
+  holeIndex: number | undefined,
+  nextRing: ReadonlyArray<[number, number]>,
+): unknown {
+  if (holeIndex === undefined) {
+    return { polygon: nextRing }
+  }
+  const nextHoles = (node.holes ?? []).map((hole, i) =>
+    i === holeIndex ? nextRing : hole.map(([x, y]) => [x, y] as [number, number]),
+  )
+  return { holes: nextHoles }
+}
+
+export function createPolygonVertexAffordance<N extends PolygonShape & { id: AnyNodeId }>(
+  kind: string,
+): FloorplanAffordance<N> {
+  return {
+    start({ node, payload }): FloorplanAffordanceSession {
+      const { vertexIndex, holeIndex } = payload as PolygonVertexPayload
+      const originalRing = getRing(node, holeIndex)
+      if (!originalRing) {
+        return {
+          affectedIds: [node.id],
+          apply() {},
+          canCommit() {
+            return false
+          },
+        }
+      }
+
+      return {
+        affectedIds: [node.id],
+        apply({ planPoint, modifiers }) {
+          const snapped: WallPlanPoint = modifiers.shiftKey
+            ? (planPoint as WallPlanPoint)
+            : snapPointToGrid(planPoint as WallPlanPoint)
+          const nextRing: [number, number][] = originalRing.map((p, i) =>
+            i === vertexIndex ? [snapped[0], snapped[1]] : p,
+          )
+          const patch = buildRingPatch(node, holeIndex, nextRing)
+          useScene
+            .getState()
+            .updateNodes([{ id: node.id, data: patch as Partial<unknown> as never }])
+        },
+        canCommit() {
+          const final = useScene.getState().nodes[node.id] as N | undefined
+          if (!final || (final as unknown as { type: string }).type !== kind) return false
+          const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex]
+          return !!finalRing && finalRing.length >= 3
+        },
+      }
+    },
+  }
+}
+
+/**
+ * Companion to `createPolygonVertexAffordance`. Inserts a new vertex at
+ * the midpoint of edge `edgeIndex` (between vertices i and i+1) and
+ * then drags that new vertex with the pointer. The dispatcher's
+ * snapshot was taken **before** `start()` ran, so a pointer-up without
+ * movement reverts to the pre-insert ring — "click without drag" is a
+ * no-op, matching the legacy slab boundary editor.
+ */
+export function createPolygonAddVertexAffordance<N extends PolygonShape & { id: AnyNodeId }>(
+  kind: string,
+): FloorplanAffordance<N> {
+  return {
+    start({ node, payload }): FloorplanAffordanceSession {
+      const { edgeIndex, holeIndex } = payload as AddVertexPayload
+      const originalRing = getRing(node, holeIndex)
+      if (!originalRing) {
+        return {
+          affectedIds: [node.id],
+          apply() {},
+          canCommit() {
+            return false
+          },
+        }
+      }
+      const a = originalRing[edgeIndex]
+      const b = originalRing[(edgeIndex + 1) % originalRing.length]
+      if (!a || !b) {
+        return {
+          affectedIds: [node.id],
+          apply() {},
+          canCommit() {
+            return false
+          },
+        }
+      }
+      const midpoint: [number, number] = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]
+      const newVertexIndex = edgeIndex + 1
+      const initialRing: [number, number][] = [
+        ...originalRing.slice(0, newVertexIndex),
+        midpoint,
+        ...originalRing.slice(newVertexIndex),
+      ]
+
+      // Apply the insert immediately so the user sees the new vertex
+      // before they even move.
+      const initialPatch = buildRingPatch(node, holeIndex, initialRing)
+      useScene
+        .getState()
+        .updateNodes([{ id: node.id, data: initialPatch as Partial<unknown> as never }])
+
+      return {
+        affectedIds: [node.id],
+        apply({ planPoint, modifiers }) {
+          const snapped: WallPlanPoint = modifiers.shiftKey
+            ? (planPoint as WallPlanPoint)
+            : snapPointToGrid(planPoint as WallPlanPoint)
+          const nextRing: [number, number][] = initialRing.map((p, i) =>
+            i === newVertexIndex ? [snapped[0], snapped[1]] : p,
+          )
+          const patch = buildRingPatch(node, holeIndex, nextRing)
+          useScene
+            .getState()
+            .updateNodes([{ id: node.id, data: patch as Partial<unknown> as never }])
+        },
+        canCommit() {
+          const final = useScene.getState().nodes[node.id] as N | undefined
+          if (!final || (final as unknown as { type: string }).type !== kind) return false
+          const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex]
+          return !!finalRing && finalRing.length >= 3
+        },
+      }
+    },
+  }
+}
+
+/**
+ * Edge-drag: move a whole edge perpendicular to itself. Both endpoints
+ * translate by `edgeNormal * projectedDelta`. The other vertices of
+ * the ring stay put — adjacent edges effectively pivot around their
+ * far endpoints.
+ *
+ * Snap is grid-aligned on the projected scalar (so a Shift-free drag
+ * lands on grid lines along the edge normal).
+ */
+export function createPolygonMoveEdgeAffordance<N extends PolygonShape & { id: AnyNodeId }>(
+  kind: string,
+): FloorplanAffordance<N> {
+  return {
+    start({ node, payload, initialPlanPoint }): FloorplanAffordanceSession {
+      const { edgeIndex, holeIndex } = payload as EdgeDragPayload
+      const originalRing = getRing(node, holeIndex)
+      if (!originalRing) {
+        return {
+          affectedIds: [node.id],
+          apply() {},
+          canCommit() {
+            return false
+          },
+        }
+      }
+      const startVertex = originalRing[edgeIndex]
+      const endVertex = originalRing[(edgeIndex + 1) % originalRing.length]
+      if (!startVertex || !endVertex) {
+        return {
+          affectedIds: [node.id],
+          apply() {},
+          canCommit() {
+            return false
+          },
+        }
+      }
+      const dx = endVertex[0] - startVertex[0]
+      const dy = endVertex[1] - startVertex[1]
+      const len = Math.hypot(dx, dy)
+      if (len < 1e-6) {
+        return {
+          affectedIds: [node.id],
+          apply() {},
+          canCommit() {
+            return false
+          },
+        }
+      }
+      // Perpendicular unit normal (rotate 90° CCW).
+      const normalX = -dy / len
+      const normalY = dx / len
+      const startX = initialPlanPoint[0]
+      const startY = initialPlanPoint[1]
+      const edgeStartIndex = edgeIndex
+      const edgeEndIndex = (edgeIndex + 1) % originalRing.length
+
+      return {
+        affectedIds: [node.id],
+        apply({ planPoint, modifiers }) {
+          // Project the pointer delta onto the edge normal — that's the
+          // signed perpendicular distance the edge should travel.
+          const deltaX = planPoint[0] - startX
+          const deltaY = planPoint[1] - startY
+          let projection = deltaX * normalX + deltaY * normalY
+          if (!modifiers.shiftKey) {
+            // Snap the projection scalar to a 0.5m grid (legacy uses the
+            // same half-meter snap for slab edges).
+            projection = Math.round(projection * 2) / 2
+          }
+          const nextRing: [number, number][] = originalRing.map((p, i) => {
+            if (i === edgeStartIndex || i === edgeEndIndex) {
+              return [p[0] + normalX * projection, p[1] + normalY * projection]
+            }
+            return [p[0], p[1]] as [number, number]
+          })
+          const patch = buildRingPatch(node, holeIndex, nextRing)
+          useScene
+            .getState()
+            .updateNodes([{ id: node.id, data: patch as Partial<unknown> as never }])
+        },
+        canCommit() {
+          const final = useScene.getState().nodes[node.id] as N | undefined
+          if (!final || (final as unknown as { type: string }).type !== kind) return false
+          const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex]
+          return !!finalRing && finalRing.length >= 3
+        },
+      }
+    },
+  }
+}