#7690 Plane selection improvements

src/components/ModelingSidebar/ModelingPanes/FeatureTreePane.tsx

@@ -39,12 +39,12 @@ import {
   kclEditorActor,
   selectionEventSelector,
 } from '@src/machines/kclEditorMachine'
-import type { Plane } from '@rust/kcl-lib/bindings/Artifact'
 import {
   selectDefaultSketchPlane,
   selectOffsetSketchPlane,
 } from '@src/lib/selections'
 import type { DefaultPlaneStr } from '@src/lib/planes'
+import { findOperationArtifact, isOffsetPlane } from '@src/lang/queryAst'
 
 export const FeatureTreePane = () => {
   const isEditorMounted = useSelector(kclEditorActor, editorIsMountedSelector)
@@ -363,7 +363,10 @@ const OperationItem = (props: {
   function selectOperation() {
     if (props.sketchNoFace) {
       if (isOffsetPlane(props.item)) {
-        const artifact = findOperationArtifact(props.item)
+        const artifact = findOperationArtifact(
+          props.item,
+          kclManager.artifactGraph
+        )
         void selectOffsetSketchPlane(artifact)
       }
     } else {
@@ -459,7 +462,10 @@ const OperationItem = (props: {
 
   function startSketchOnOffsetPlane() {
     if (isOffsetPlane(props.item)) {
-      const artifact = findOperationArtifact(props.item)
+      const artifact = findOperationArtifact(
+        props.item,
+        kclManager.artifactGraph
+      )
       if (artifact?.id) {
         sceneInfra.modelingSend({
           type: 'Enter sketch',
@@ -715,17 +721,3 @@ const DefaultPlanes = () => {
     </div>
   )
 }
-
-type StdLibCallOp = Extract<Operation, { type: 'StdLibCall' }>
-
-const isOffsetPlane = (item: Operation): item is StdLibCallOp => {
-  return item.type === 'StdLibCall' && item.name === 'offsetPlane'
-}
-
-const findOperationArtifact = (item: StdLibCallOp) => {
-  const nodePath = JSON.stringify(item.nodePath)
-  const artifact = [...kclManager.artifactGraph.values()].find(
-    (a) => JSON.stringify((a as Plane).codeRef?.nodePath) === nodePath
-  )
-  return artifact
-}

src/hooks/useEngineConnectionSubscriptions.ts

@@ -109,7 +109,9 @@ export function useEngineConnectionSubscriptions() {
               }
 
               const artifact = kclManager.artifactGraph.get(planeOrFaceId)
-              if (await selectOffsetSketchPlane(artifact)) {
+              const offsetPlaneSelected =
+                await selectOffsetSketchPlane(artifact)
+              if (!err(offsetPlaneSelected) && offsetPlaneSelected) {
                 return
               }
 

src/lang/queryAst.test.ts

@@ -13,11 +13,13 @@
   doesSceneHaveExtrudedSketch,
   doesSceneHaveSweepableSketch,
   findAllPreviousVariables,
+  findOperationArtifact,
   findUsesOfTagInPipe,
   getNodeFromPath,
   hasSketchPipeBeenExtruded,
   isCursorInFunctionDefinition,
   isNodeSafeToReplace,
+  isOffsetPlane,
   traverse,
 } from '@src/lang/queryAst'
 import { getNodePathFromSourceRange } from '@src/lang/queryAstNodePathUtils'
@@ -30,6 +32,7 @@
 import { type Selection } from '@src/lib/selections'
 import { enginelessExecutor } from '@src/lib/testHelpers'
 import { err } from '@src/lib/trap'
+import { kclManager } from '@src/lib/singletons'
 
 beforeAll(async () => {
   await initPromise
@@ -778,3 +781,56 @@
     expect(result).toEqual(false)
   })
 })
+
+describe('Testing findOperationArtifact', () => {
+  it('should find the correct artifact for a given operation', async () => {
+    const code = `sketch001 = startSketchOn(XY)
+  |> startProfile(at = [0, 0])
+  |> line(end = [10, 0])
+  |> line(end = [10, 10])
+  |> line(end = [0, 10])
+  |> close()
+
+plane001 = offsetPlane(YZ, offset = 10)
+part001 = startSketchOn(plane001)
+  |> startProfile(at = [0, 0])
+  |> line(end = [5, 0])
+  |> line(end = [5, 5])
+  |> line(end = [0, 5])
+  |> close()
+`
+
+    // const ast = assertParse(code)
+    // await kclManager.executeAst({ ast })
+    // const operations = kclManager.lastSuccessfulOperations
+
+    const ast = assertParse(code)
+    const execState = await enginelessExecutor(ast, false)
+    const operations = execState.operations
+
+    //expect(kclManager.errors).toEqual([])
+
+    expect(operations).toBeTruthy()
+    expect(operations.length).toBeGreaterThan(0)
+
+    // Find an offsetPlane operation
+    const offsetPlaneOp = operations.find(
+      (op) => op.type === 'StdLibCall' && op.name === 'offsetPlane'
+    )
+    expect(offsetPlaneOp).toBeTruthy()
+
+    if (offsetPlaneOp && isOffsetPlane(offsetPlaneOp)) {
+      const artifact = findOperationArtifact(
+        offsetPlaneOp,
+        kclManager.artifactGraph
+      )
+
+      expect(artifact).toBeTruthy()
+      expect(artifact?.type).toBe('plane')
+
+      // const artifactNodePath = JSON.stringify(artifact?.codeRef?.nodePath)
+      // const operationNodePath = JSON.stringify(offsetPlaneOp.nodePath)
+      // expect(artifactNodePath).toBe(operationNodePath)
+    }
+  })
+})

src/lang/queryAst.ts

@@ -51,11 +51,16 @@
 import { err } from '@src/lib/trap'
 import { getAngle, isArray } from '@src/lib/utils'
 
-import type { OpKclValue, Operation } from '@rust/kcl-lib/bindings/Operation'
+import type {
+  OpKclValue,
+  Operation,
+  StdLibCallOp,
+} from '@rust/kcl-lib/bindings/Operation'
 import { ARG_INDEX_FIELD, LABELED_ARG_FIELD } from '@src/lang/queryAstConstants'
 import type { KclCommandValue } from '@src/lib/commandTypes'
 import type { UnaryExpression } from 'typescript'
 import type { NumericType } from '@rust/kcl-lib/bindings/NumericType'
+import type { Plane } from '@rust/kcl-lib/bindings/Artifact'
 
 /**
  * Retrieves a node from a given path within a Program node structure, optionally stopping at a specified node type.
@@ -1158,6 +1163,21 @@
   }
 }
 
+export function findOperationArtifact(
+  item: StdLibCallOp,
+  artifactGraph: ArtifactGraph
+) {
+  const nodePath = JSON.stringify(item.nodePath)
+  const artifact = [...artifactGraph.values()].find(
+    (a) => JSON.stringify((a as Plane).codeRef?.nodePath) === nodePath
+  )
+  return artifact
+}
+
+export function isOffsetPlane(item: Operation): item is StdLibCallOp {
+  return item.type === 'StdLibCall' && item.name === 'offsetPlane'
+}
+
 export function locateVariableWithCallOrPipe(
   ast: Program,
   pathToNode: PathToNode

src/lib/selections.ts

@@ -883,77 +883,76 @@ export function selectDefaultSketchPlane(
   return true
 }
 
-export async function selectOffsetSketchPlane(artifact: Artifact | undefined) {
-  return new Promise((resolve) => {
-    if (artifact?.type === 'plane') {
-      const planeId = artifact.id
-      void sceneEntitiesManager
-        .getFaceDetails(planeId)
-        .then((planeInfo) => {
-          // Apply camera-based orientation logic similar to default planes
-          let zAxis: [number, number, number] = [
-            planeInfo.z_axis.x,
-            planeInfo.z_axis.y,
-            planeInfo.z_axis.z,
-          ]
-          let yAxis: [number, number, number] = [
-            planeInfo.y_axis.x,
-            planeInfo.y_axis.y,
-            planeInfo.y_axis.z,
-          ]
-
-          // Get camera vector to determine which side of the plane we're viewing from
-          const camVector = sceneInfra.camControls.camera.position
-            .clone()
-            .sub(sceneInfra.camControls.target)
-
-          // Determine the canonical (absolute) plane orientation
-          const absZAxis: [number, number, number] = [
-            Math.abs(zAxis[0]),
-            Math.abs(zAxis[1]),
-            Math.abs(zAxis[2]),
-          ]
-
-          // Find the dominant axis (like default planes do)
-          const maxComponent = Math.max(...absZAxis)
-          const dominantAxisIndex = absZAxis.indexOf(maxComponent)
-
-          // Check camera position against canonical orientation (like default planes)
-          const cameraComponents = [camVector.x, camVector.y, camVector.z]
-          let negated = cameraComponents[dominantAxisIndex] < 0
-          if (dominantAxisIndex === 1) {
-            // offset of the XZ is being weird, not sure if this is a camera bug
-            negated = !negated
-          }
-          sceneInfra.modelingSend({
-            type: 'Select sketch plane',
-            data: {
-              type: 'offsetPlane',
-              zAxis,
-              yAxis,
-              position: [
-                planeInfo.origin.x,
-                planeInfo.origin.y,
-                planeInfo.origin.z,
-              ].map((num) => num / sceneInfra._baseUnitMultiplier) as [
-                number,
-                number,
-                number,
-              ],
-              planeId,
-              pathToNode: artifact.codeRef.pathToNode,
-              negated,
-            },
-          })
-          resolve(true)
-        })
-        .catch((error) => {
-          console.error('Error getting face details:', error)
-          resolve(false)
-        })
-    } else {
-      // selectOffsetSketchPlane called with an invalid artifact type',
-      resolve(false)
+export async function selectOffsetSketchPlane(
+  artifact: Artifact | undefined
+): Promise<Error | boolean> {
+  if (artifact?.type !== 'plane') {
+    return new Error(
+      `Invalid artifact type for offset sketch plane selection: ${artifact?.type}`
+    )
+  }
+  const planeId = artifact.id
+  try {
+    const planeInfo = await sceneEntitiesManager.getFaceDetails(planeId)
+
+    // Apply camera-based orientation logic similar to default planes
+    let zAxis: [number, number, number] = [
+      planeInfo.z_axis.x,
+      planeInfo.z_axis.y,
+      planeInfo.z_axis.z,
+    ]
+    let yAxis: [number, number, number] = [
+      planeInfo.y_axis.x,
+      planeInfo.y_axis.y,
+      planeInfo.y_axis.z,
+    ]
+
+    // Get camera vector to determine which side of the plane we're viewing from
+    const camVector = sceneInfra.camControls.camera.position
+      .clone()
+      .sub(sceneInfra.camControls.target)
+
+    // Determine the canonical (absolute) plane orientation
+    const absZAxis: [number, number, number] = [
+      Math.abs(zAxis[0]),
+      Math.abs(zAxis[1]),
+      Math.abs(zAxis[2]),
+    ]
+
+    // Find the dominant axis (like default planes do)
+    const maxComponent = Math.max(...absZAxis)
+    const dominantAxisIndex = absZAxis.indexOf(maxComponent)
+
+    // Check camera position against canonical orientation (like default planes)
+    const cameraComponents = [camVector.x, camVector.y, camVector.z]
+    let negated = cameraComponents[dominantAxisIndex] < 0
+    if (dominantAxisIndex === 1) {
+      // offset of the XZ is being weird, not sure if this is a camera bug
+      negated = !negated
     }
-  })
+    sceneInfra.modelingSend({
+      type: 'Select sketch plane',
+      data: {
+        type: 'offsetPlane',
+        zAxis,
+        yAxis,
+        position: [
+          planeInfo.origin.x,
+          planeInfo.origin.y,
+          planeInfo.origin.z,
+        ].map((num) => num / sceneInfra._baseUnitMultiplier) as [
+          number,
+          number,
+          number,
+        ],
+        planeId,
+        pathToNode: artifact.codeRef.pathToNode,
+        negated,
+      },
+    })
+  } catch (err) {
+    console.error(err)
+    return new Error('Error getting face details')
+  }
+  return true
 }