Point-and-click deletion of lofts, shells, and offset planes

src/lang/modifyAst.ts

@@ -1149,11 +1149,17 @@ export async function deleteFromSelection(
     ((selection?.artifact?.type === 'wall' ||
       selection?.artifact?.type === 'cap') &&
       varDec.node.init.type === 'PipeExpression') ||
-    selection.artifact?.type === 'sweep'
+    selection.artifact?.type === 'sweep' ||
+    selection.artifact?.type === 'plane' ||
+    !selection.artifact // aka expected to be a shell at this point
   ) {
     let extrudeNameToDelete = ''
     let pathToNode: PathToNode | null = null
-    if (selection.artifact?.type !== 'sweep') {
+    if (
+      selection.artifact &&
+      selection.artifact.type !== 'sweep' &&
+      selection.artifact.type !== 'plane'
+    ) {
       const varDecName = varDec.node.id.name
       traverse(astClone, {
         enter: (node, path) => {
@@ -1169,6 +1175,17 @@ export async function deleteFromSelection(
               pathToNode = path
               extrudeNameToDelete = dec.id.name
             }
+            if (
+              dec.init.type === 'CallExpression' &&
+              dec.init.callee.name === 'loft' &&
+              dec.init.arguments?.[0].type === 'ArrayExpression' &&
+              dec.init.arguments?.[0].elements.some(
+                (a) => a.type === 'Identifier' && a.name === varDecName
+              )
+            ) {
+              pathToNode = path
+              extrudeNameToDelete = dec.id.name
+            }
           }
         },
       })

src/lang/std/artifactGraph.ts

@@ -69,15 +69,15 @@ interface SegmentArtifactRich extends BaseArtifact {
 /** A Sweep is a more generic term for extrude, revolve, loft and sweep*/
 interface SweepArtifact extends BaseArtifact {
   type: 'sweep'
-  subType: 'extrusion' | 'revolve'
+  subType: 'extrusion' | 'revolve' | 'loft'
   pathId: string
   surfaceIds: Array<string>
   edgeIds: Array<string>
   codeRef: CodeRef
 }
 interface SweepArtifactRich extends BaseArtifact {
   type: 'sweep'
-  subType: 'extrusion' | 'revolve'
+  subType: 'extrusion' | 'revolve' | 'loft'
   path: PathArtifact
   surfaces: Array<WallArtifact | CapArtifact>
   edges: Array<SweepEdge>
@@ -393,6 +393,32 @@ export function getArtifactsToUpdate({
         artifact: { ...path, sweepId: id },
       })
     return returnArr
+  } else if (
+    cmd.type === 'loft' &&
+    response.type === 'modeling' &&
+    response.data.modeling_response.type === 'loft'
+  ) {
+    returnArr.push({
+      id,
+      artifact: {
+        type: 'sweep',
+        subType: 'loft',
+        id,
+        pathId: response.data.modeling_response.data.solid_id,
+        surfaceIds: [],
+        edgeIds: [],
+        codeRef: { range, pathToNode },
+      },
+    })
+    for (const sectionId of cmd.section_ids) {
+      const path = getArtifact(sectionId)
+      if (path?.type === 'path')
+        returnArr.push({
+          id: sectionId,
+          artifact: { ...path, sweepId: id },
+        })
+    }
+    return returnArr
   } else if (
     cmd.type === 'solid3d_get_extrusion_face_info' &&
     response?.type === 'modeling' &&

src/lib/commandBarConfigs/modelingCommandConfig.ts

@@ -40,6 +40,9 @@ export type ModelingCommandSchema = {
   Loft: {
     selection: Selections
   }
+  'Delete selection': {
+    selection: Selections
+  }
   Shell: {
     selection: Selections
     thickness: KclCommandValue

src/lib/selections.ts

@@ -208,6 +208,7 @@ export async function getEventForSelectWithPoint({
   }
 
   let _artifact = engineCommandManager.artifactGraph.get(data.entity_id)
+  console.log('found _artifact from selection', _artifact)
   const codeRefs = getCodeRefsByArtifactId(
     data.entity_id,
     engineCommandManager.artifactGraph
@@ -841,6 +842,7 @@ export function updateSelections(
 ): Selections | Error {
   if (err(ast)) return ast
 
+  console.log('updateSelections pathToNodeMap', pathToNodeMap)
   const newSelections = Object.entries(pathToNodeMap)
     .map(([index, pathToNode]): Selection | undefined => {
       const previousSelection =

src/machines/modelingMachine.ts

@@ -237,6 +237,7 @@ export type ModelingMachineEvent =
     }
   | {
       type: 'Delete selection'
+      data?: ModelingCommandSchema['Delete selection']
     }
   | { type: 'Sketch no face' }
   | { type: 'Toggle gui mode' }
@@ -731,38 +732,6 @@ export const modelingMachine = setup({
         }
       })().catch(reportRejection)
     },
-    'AST delete selection': ({ context: { selectionRanges } }) => {
-      ;(async () => {
-        const errorMessage =
-          'Unable to delete selection. Please edit manually in code pane.'
-        let ast = kclManager.ast
-
-        const modifiedAst = await deleteFromSelection(
-          ast,
-          selectionRanges.graphSelections[0],
-          kclManager.programMemory,
-          getFaceDetails
-        )
-        if (err(modifiedAst)) {
-          toast.error(errorMessage)
-          return
-        }
-
-        const testExecute = await executeAst({
-          ast: modifiedAst,
-          engineCommandManager,
-          // We make sure to send an empty program memory to denote we mean mock mode.
-          programMemoryOverride: ProgramMemory.empty(),
-        })
-        if (testExecute.errors.length) {
-          toast.error(errorMessage)
-          return
-        }
-
-        await kclManager.updateAst(modifiedAst, true)
-        await codeManager.updateEditorWithAstAndWriteToFile(modifiedAst)
-      })().catch(reportRejection)
-    },
     'AST fillet': ({ event }) => {
       if (event.type !== 'Fillet') return
       if (!event.data) return
@@ -1689,6 +1658,45 @@ export const modelingMachine = setup({
         }
       }
     ),
+    deleteSelectionAstMod: fromPromise(
+      async ({
+        input,
+      }: {
+        input: ModelingCommandSchema['Delete selection'] | undefined
+      }) => {
+        if (!input) {
+          return new Error('No input provided')
+        }
+
+        // Extract inputs
+        const ast = kclManager.ast
+        const { selection } = input
+
+        const modifiedAst = await deleteFromSelection(
+          ast,
+          selection.graphSelections[0],
+          kclManager.programMemory,
+          getFaceDetails
+        )
+        if (err(modifiedAst)) {
+          return
+        }
+
+        const testExecute = await executeAst({
+          ast: modifiedAst,
+          engineCommandManager,
+          // We make sure to send an empty program memory to denote we mean mock mode.
+          programMemoryOverride: ProgramMemory.empty(),
+        })
+        if (testExecute.errors.length) {
+          toast.error('Unable to delete part')
+          return
+        }
+
+        await kclManager.updateAst(modifiedAst, true)
+        await codeManager.updateEditorWithAstAndWriteToFile(modifiedAst)
+      }
+    ),
     'submit-prompt-edit': fromPromise(
       async ({ input }: { input: ModelingCommandSchema['Prompt-to-edit'] }) => {
         console.log('doing thing', input)
@@ -1759,10 +1767,9 @@ export const modelingMachine = setup({
         },
 
         'Delete selection': {
-          target: 'idle',
+          target: 'Applying selection delete',
           guard: 'has valid selection for deletion',
-          actions: ['AST delete selection'],
-          reenter: false,
+          reenter: true,
         },
 
         'Text-to-CAD': {
@@ -2542,6 +2549,21 @@ export const modelingMachine = setup({
       },
     },
 
+    'Applying selection delete': {
+      invoke: {
+        src: 'deleteSelectionAstMod',
+        id: 'deleteSelectionAstMod',
+        input: ({ event, context }) => {
+          if (event.type !== 'Delete selection') return undefined
+          // TODO: there has to be a better way to pass `context` right?
+          if (!context.selectionRanges) return undefined
+          return { selection: context.selectionRanges }
+        },
+        onDone: ['idle'],
+        onError: ['idle'],
+      },
+    },
+
     'Applying Prompt-to-edit': {
       invoke: {
         src: 'submit-prompt-edit',

src/wasm-lib/kcl/src/std/extrude.rs

@@ -125,7 +125,7 @@ async fn inner_extrude(
             ModelingCmd::SketchModeDisable(mcmd::SketchModeDisable {}),
         )
         .await?;
-        solids.push(do_post_extrude(sketch.clone(), length, exec_state, args.clone()).await?);
+        solids.push(do_post_extrude(sketch.clone(), length, exec_state, args.clone(), None).await?);
     }
 
     Ok(solids.into())
@@ -136,6 +136,7 @@ pub(crate) async fn do_post_extrude(
     length: f64,
     exec_state: &mut ExecState,
     args: Args,
+    force_object_id: Option<Uuid>,
 ) -> Result<Box<Solid>, KclError> {
     // Bring the object to the front of the scene.
     // See: https://github.com/KittyCAD/modeling-app/issues/806
@@ -161,12 +162,13 @@ pub(crate) async fn do_post_extrude(
         sketch.id = face.solid.sketch.id;
     }
 
+    let object_id = force_object_id.unwrap_or(sketch.id);
     let solid3d_info = args
         .send_modeling_cmd(
             exec_state.next_uuid(),
             ModelingCmd::from(mcmd::Solid3dGetExtrusionFaceInfo {
                 edge_id: any_edge_id,
-                object_id: sketch.id,
+                object_id: object_id,
             }),
         )
         .await?;

src/wasm-lib/kcl/src/std/loft.rs

@@ -4,7 +4,10 @@ use std::num::NonZeroU32;
 
 use anyhow::Result;
 use derive_docs::stdlib;
-use kcmc::{each_cmd as mcmd, length_unit::LengthUnit, ModelingCmd};
+use kcmc::{
+    each_cmd as mcmd, length_unit::LengthUnit, ok_response::OkModelingCmdResponse, websocket::OkWebSocketResponseData,
+    ModelingCmd,
+};
 use kittycad_modeling_cmds as kcmc;
 
 use crate::{
@@ -142,19 +145,32 @@ async fn inner_loft(
         }));
     }
 
-    let id = exec_state.next_uuid();
-    args.batch_modeling_cmd(
-        id,
-        ModelingCmd::from(mcmd::Loft {
-            section_ids: sketches.iter().map(|group| group.id).collect(),
-            base_curve_index,
-            bez_approximate_rational,
-            tolerance: LengthUnit(tolerance.unwrap_or(default_tolerance(&args.ctx.settings.units))),
-            v_degree,
-        }),
-    )
-    .await?;
+    let id: uuid::Uuid = exec_state.next_uuid();
+    let resp = args
+        .send_modeling_cmd(
+            id,
+            ModelingCmd::from(mcmd::Loft {
+                section_ids: sketches.iter().map(|group| group.id).collect(),
+                base_curve_index,
+                bez_approximate_rational,
+                tolerance: LengthUnit(tolerance.unwrap_or(default_tolerance(&args.ctx.settings.units))),
+                v_degree,
+            }),
+        )
+        .await?;
+    let OkWebSocketResponseData::Modeling {
+        modeling_response: OkModelingCmdResponse::Loft(data),
+    } = &resp
+    else {
+        return Err(KclError::Engine(KclErrorDetails {
+            message: format!("mcmd::Loft response was not as expected: {:?}", resp),
+            source_ranges: vec![args.source_range],
+        }));
+    };
+
+    #[cfg(target_arch = "wasm32")]
+    web_sys::console::log_1(&format!("Rust Loft solid_id={:?}", data.solid_id).into());
 
     // Using the first sketch as the base curve, idk we might want to change this later.
-    do_post_extrude(sketches[0].clone(), 0.0, exec_state, args).await
+    do_post_extrude(sketches[0].clone(), 0.0, exec_state, args, Some(data.solid_id)).await
 }

src/wasm-lib/kcl/src/std/revolve.rs

@@ -296,7 +296,7 @@ async fn inner_revolve(
         }
     }
 
-    do_post_extrude(sketch, 0.0, exec_state, args).await
+    do_post_extrude(sketch, 0.0, exec_state, args, None).await
 }
 
 #[cfg(test)]

src/wasm-lib/kcl/src/std/sweep.rs

@@ -99,5 +99,5 @@ async fn inner_sweep(
     )
     .await?;
 
-    do_post_extrude(sketch, 0.0, exec_state, args).await
+    do_post_extrude(sketch, 0.0, exec_state, args, None).await
 }