@pascal-app/editor 1.0.1 → 1.0.4

package/src/components/tools/item/placement-strategies.ts

@@ -4,7 +4,6 @@ import type {
   CeilingEvent,
   CeilingNode,
   GridEvent,
-  ItemNode,
   NodeEvent,
   RoofEvent,
   RoofNode,
@@ -17,18 +16,23 @@ import type {
 } from '@pascal-app/core'
 import {
   clampRectToRoofWallFace,
+  clearFaceHostItemFields,
   createSceneApi,
   getRoofSegmentWallFace,
   getScaledDimensions,
+  getWallBodyCenterOffset,
+  getWallLocalFaceZ,
   nodeRegistry,
   resolveSurfacePlacement,
   roofFacePointToSegment,
   sceneRegistry,
+  snapLocalXZInWorld,
   useScene,
+  wouldCreateHostingCycle,
 } from '@pascal-app/core'
 import { Euler, Quaternion, Vector3 } from 'three'
 import { hasRoofFaceChildOverlap, resolveRoofWallHit } from '../../../lib/roof-wall-hit'
-import { snapWorldXZForActiveBuilding } from '../../../lib/world-grid-snap'
+import { getActiveBuildingPose } from '../../../lib/world-grid-snap'
 import { itemEventToSurfaceHit, surfaceWorldNormalY } from '../shared/surface-hit'
 import {
   calculateItemRotation,
@@ -49,20 +53,6 @@ import type {
 } from './placement-types'
 
 const DEFAULT_DIMENSIONS: [number, number, number] = [1, 1, 1]
-function isDescendantOfItem(
-  candidate: AnyNode,
-  ancestorId: string,
-  nodes: Record<string, AnyNode>,
-): boolean {
-  let parentId = candidate.parentId
-  while (parentId) {
-    if (parentId === ancestorId) return true
-    const parent = nodes[parentId as AnyNodeId]
-    parentId = parent?.parentId ?? null
-  }
-  return false
-}
-
 // ============================================================================
 // FLOOR STRATEGY
 // ============================================================================
@@ -89,11 +79,12 @@ export const floorStrategy = {
     // the world grid.
     // Snapping is governed by the active mode (snapToGrid returns raw in Off /
     // non-grid modes); Alt is force-place only and never bypasses snapping here.
-    const [x, z] = snapWorldXZForActiveBuilding(
-      snapToGrid(event.position[0], swapDims ? dimZ : dimX),
-      snapToGrid(event.position[2], swapDims ? dimX : dimZ),
-      0,
-    ).local
+    const dimensions = [swapDims ? dimZ : dimX, swapDims ? dimX : dimZ] as const
+    const [x, z] = snapLocalXZInWorld(
+      [event.localPosition[0], event.localPosition[2]],
+      getActiveBuildingPose(),
+      (value, axis) => snapToGrid(value, dimensions[axis]),
+    )
     const y = ctx.gridPosition.y
 
     return {
@@ -179,7 +170,9 @@ function resolveWallPlacementPose(
   cursorRotationY: number
 } {
   const localZ =
-    attachTo === 'wall-side' ? ((event.node.thickness ?? 0.1) / 2) * (side === 'front' ? 1 : -1) : 0
+    attachTo === 'wall-side'
+      ? getWallLocalFaceZ(event.node, side === 'front' ? 'a' : 'b')
+      : getWallBodyCenterOffset(event.node)
   event.object.updateWorldMatrix(true, false)
   const world = event.object.localToWorld(new Vector3(localX, localY, localZ))
   const wallYaw = -Math.atan2(
@@ -187,7 +180,7 @@ function resolveWallPlacementPose(
     event.node.end[0] - event.node.start[0],
   )
   return {
-    position: [localX, localY, localZ],
+    position: [localX, localY, attachTo === 'wall' ? 0 : localZ],
     cursorPosition: [world.x, world.y, world.z],
     // Same composition the 2D floorplan resolves a wall child with
     // (`resolveItemTransform`): the cursor frame IS the item frame.
@@ -212,6 +205,12 @@ export const wallStrategy = {
     if (attachTo !== 'wall' && attachTo !== 'wall-side') return null
     if (!isValidWallSideFace(event.normal)) return null
 
+    if (
+      ctx.draftItem &&
+      wouldCreateHostingCycle(ctx.draftItem.id, event.node, createSceneApi(useScene))
+    )
+      return null
+
     // Level guard
     const wallLevelId = resolveLevelId(event.node, nodes)
     if (ctx.levelId !== wallLevelId) return null
@@ -416,6 +415,11 @@ function resolveRoofWallTarget(
 
   const hit = resolveRoofWallHit(event.node as RoofNode, event.position, event.normal, event.object)
   if (!hit) return null
+  if (
+    ctx.draftItem &&
+    wouldCreateHostingCycle(ctx.draftItem.id, hit.segment, createSceneApi(useScene))
+  )
+    return null
 
   const rawDims = ctx.draftItem
     ? getScaledDimensions(ctx.draftItem)
@@ -428,7 +432,7 @@ function resolveRoofWallTarget(
   const u = snapToHalf(hit.u)
   const centerV = snapToHalf(hit.v) + height / 2
   const fitted = freePlace ? null : clampRectToRoofWallFace(hit.face, u, centerV, width, height)
-  if (!fitted && !freePlace) return null
+  if (!(fitted || freePlace)) return null
   const finalU = fitted?.u ?? u
   const finalV = fitted?.v ?? centerV
 
@@ -559,7 +563,7 @@ export const roofWallStrategy = {
     if (!(ctx.draftItem && ctx.state.roofSegmentId)) return null
     // Alt mirrors the wall flow's stubbed validators: skip profile-fit
     // and overlap checks entirely.
-    if (!freePlace && !canPlaceOnRoofWall(ctx)) return null
+    if (!(freePlace || canPlaceOnRoofWall(ctx))) return null
 
     return {
       nodeUpdate: {
@@ -605,6 +609,11 @@ export const roofWallStrategy = {
 // ============================================================================
 
 function resolveFaceHostTarget(ctx: PlacementContext, event: NodeEvent) {
+  if (
+    ctx.draftItem &&
+    wouldCreateHostingCycle(ctx.draftItem.id, event.node, createSceneApi(useScene))
+  )
+    return null
   const faceHost = nodeRegistry.get(event.node.type)?.capabilities.faceHost
   if (!faceHost) return null
   const rawDimensions = ctx.draftItem
@@ -624,18 +633,6 @@ function resolveFaceHostTarget(ctx: PlacementContext, event: NodeEvent) {
   })
 }
 
-function clearFaceHostItemFields(ctx: PlacementContext): Partial<ItemNode> {
-  const host = ctx.state.blockId ? useScene.getState().nodes[ctx.state.blockId] : undefined
-  const clearFields = host
-    ? nodeRegistry.get(host.type)?.capabilities.faceHost?.clearItemFields
-    : undefined
-  const patch: Partial<ItemNode> = {}
-  for (const field of clearFields ?? []) {
-    ;(patch as Record<string, unknown>)[field] = undefined
-  }
-  return patch
-}
-
 export const faceHostStrategy = {
   enter(ctx: PlacementContext, event: NodeEvent): TransitionResult | null {
     const target = resolveFaceHostTarget(ctx, event)
@@ -695,7 +692,9 @@ export const faceHostStrategy = {
     return {
       stateUpdate: { surface: 'floor', blockId: null },
       nodeUpdate: {
-        ...clearFaceHostItemFields(ctx),
+        ...clearFaceHostItemFields(
+          ctx.state.blockId ? useScene.getState().nodes[ctx.state.blockId] : undefined,
+        ),
         position: floorPosition,
         parentId: ctx.levelId,
         rotation: [0, ctx.currentCursorRotationY, 0],
@@ -725,6 +724,12 @@ export const ceilingStrategy = {
   ): TransitionResult | null {
     if (ctx.asset.attachTo !== 'ceiling') return null
 
+    if (
+      ctx.draftItem &&
+      wouldCreateHostingCycle(ctx.draftItem.id, event.node, createSceneApi(useScene))
+    )
+      return null
+
     // Level guard
     const ceilingLevelId = resolveLevelId(event.node, nodes)
     if (ctx.levelId !== ceilingLevelId) return null
@@ -860,6 +865,8 @@ function resolveCatalogItemSurfacePlacement(
   worldYaw: number,
   onReject?: PlacementContext['onSurfaceReject'],
   rawEvent = event,
+  childId?: string,
+  childRotation?: [number, number, number],
 ) {
   const mesh = sceneRegistry.nodes.get(host.id)
   if (!mesh) return null
@@ -870,7 +877,12 @@ function resolveCatalogItemSurfacePlacement(
   const placement = resolveSurfacePlacement({
     host,
     childKind: 'item',
-    childFootprint: { size: dimensions, rotationY: worldYaw - hostYaw },
+    childId,
+    childFootprint: {
+      size: dimensions,
+      rotationY: worldYaw - hostYaw,
+      rotation: [childRotation?.[0] ?? 0, worldYaw - hostYaw, childRotation?.[2] ?? 0],
+    },
     hit: host.type === 'procedural-item' ? (itemEventToSurfaceHit(host, rawEvent) ?? hit) : hit,
     origin: host.type === 'procedural-item' ? hit.point : undefined,
     scene: createSceneApi(useScene),
@@ -890,17 +902,12 @@ function resolveCatalogItemSurfacePlacement(
 export function validCatalogCounterPose(ctx: PlacementContext): boolean {
   const hostId = ctx.state.surface === 'shelf-surface' ? ctx.state.shelfId : ctx.state.surfaceItemId
   const host = hostId ? useScene.getState().nodes[hostId as AnyNodeId] : undefined
-  if (
-    host?.type !== 'cabinet' &&
-    host?.type !== 'shelf' &&
-    host?.type !== 'item' &&
-    host?.type !== 'procedural-item'
-  )
-    return true
+  if (!host) return true
   if (!ctx.draftItem) return false
   const placement = resolveSurfacePlacement({
     host,
     childKind: 'item',
+    childId: ctx.draftItem.id,
     childFootprint: {
       size: getScaledDimensions(ctx.draftItem),
       rotationY: ctx.draftItem.rotation[1],
@@ -936,7 +943,7 @@ export const itemSurfaceStrategy = {
       : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
     if (
       ctx.draftItem &&
-      isDescendantOfItem(surfaceItem, ctx.draftItem.id, useScene.getState().nodes)
+      wouldCreateHostingCycle(ctx.draftItem.id, surfaceItem, createSceneApi(useScene))
     )
       return null
     const pose = resolveCatalogItemSurfacePlacement(
@@ -945,6 +952,9 @@ export const itemSurfaceStrategy = {
       ourDims,
       ctx.currentCursorRotationY,
       ctx.onSurfaceReject,
+      event,
+      ctx.draftItem?.id,
+      ctx.draftItem?.rotation,
     )
     if (!pose) return null
     const draftRotation = ctx.draftItem?.rotation ?? [0, 0, 0]
@@ -984,6 +994,8 @@ export const itemSurfaceStrategy = {
       ctx.currentCursorRotationY,
       ctx.onSurfaceReject,
       rawEvent,
+      ctx.draftItem.id,
+      ctx.draftItem.rotation,
     )
     if (!pose) return null
 
@@ -1030,6 +1042,7 @@ function resolveShelfSurfacePlacement(
   worldYaw: number,
   entering: boolean,
   onReject?: PlacementContext['onSurfaceReject'],
+  childId?: string,
 ) {
   const mesh = sceneRegistry.nodes.get(host.id)
   if (!mesh) return null
@@ -1039,6 +1052,7 @@ function resolveShelfSurfacePlacement(
   const placement = resolveSurfacePlacement({
     host,
     childKind: 'item',
+    childId,
     childFootprint: { size: dimensions, rotationY: worldYaw - hostYaw },
     hit: {
       point: local.toArray(),
@@ -1085,6 +1099,7 @@ export const shelfSurfaceStrategy = {
       ctx.currentCursorRotationY,
       true,
       ctx.onSurfaceReject,
+      ctx.draftItem?.id,
     )
     if (!pose) return null
     const draftRotation = ctx.draftItem?.rotation ?? [0, 0, 0]
@@ -1119,6 +1134,7 @@ export const shelfSurfaceStrategy = {
       ctx.currentCursorRotationY,
       false,
       ctx.onSurfaceReject,
+      ctx.draftItem.id,
     )
     if (!pose) return null
 

package/src/components/tools/item/shelf-surface-strategy-resolver.test.ts

@@ -3,7 +3,6 @@ import * as core from '@pascal-app/core'
 import {
   ItemNode,
   nodeRegistry,
-  registerNode,
   type ShelfEvent,
   ShelfNode,
   sceneRegistry,
@@ -12,6 +11,7 @@ import {
 import { Euler, Group, Quaternion, Vector3 } from 'three'
 import useEditor from '../../../store/use-editor'
 import useInteractionScope from '../../../store/use-interaction-scope'
+import { registerHostingTestNode } from '../__fixtures__/hosting'
 import { shelfSurfaceStrategy } from './placement-strategies'
 import type { PlacementContext } from './placement-types'
 
@@ -39,7 +39,7 @@ beforeEach(() => {
   restoreRegistry = nodeRegistry._snapshot()
   nodeRegistry._reset()
   rows = [0.5, 1.5]
-  registerNode({
+  registerHostingTestNode({
     kind: 'shelf',
     schemaVersion: 1,
     schema: ShelfNode,
@@ -51,7 +51,7 @@ beforeEach(() => {
       },
     },
   })
-  registerNode({
+  registerHostingTestNode({
     kind: 'item',
     schemaVersion: 1,
     schema: ItemNode,