refactor selections (#876)

* migrate selection types

* extract selection event into selections.ts

* move code-mirror selection functions into selections.ts

* move more selection logit out of code mirror and engine connection

* add selection functions pure

* tidy up naming

* write a novel about how selections work

* final comments

src/hooks/useEngineConnectionSubscriptions.ts

@@ -4,6 +4,7 @@ import { engineCommandManager } from '../lang/std/engineConnection'
 import { useModelingContext } from './useModelingContext'
 import { v4 as uuidv4 } from 'uuid'
 import { SourceRange } from 'lang/wasm'
+import { getEventForSelectWithPoint } from 'lib/selections'
 
 export function useEngineConnectionSubscriptions() {
   const { setHighlightRange, highlightRange } = useStore((s) => ({
@@ -37,63 +38,11 @@ export function useEngineConnectionSubscriptions() {
     })
     const unSubClick = engineCommandManager.subscribeTo({
       event: 'select_with_point',
-      callback: ({ data }) => {
-        if (!data?.entity_id) {
-          send({
-            type: 'Set selection',
-            data: { selectionType: 'singleCodeCursor' },
-          })
-          return
-        }
-        const sourceRange =
-          engineCommandManager.artifactMap[data.entity_id]?.range
-        if (engineCommandManager.artifactMap[data.entity_id]) {
-          send({
-            type: 'Set selection',
-            data: {
-              selectionType: 'singleCodeCursor',
-              selection: { range: sourceRange, type: 'default' },
-            },
-          })
-        } else {
-          // selected a vertex
-          engineCommandManager
-            .sendSceneCommand({
-              type: 'modeling_cmd_req',
-              cmd_id: uuidv4(),
-              cmd: {
-                type: 'path_get_curve_uuids_for_vertices',
-                vertex_ids: [data.entity_id],
-                path_id: context.sketchEnginePathId,
-              },
-            })
-            .then((res) => {
-              const curveIds = res?.data?.data?.curve_ids
-              const ranges: RangeAndId[] = curveIds
-                .map(
-                  (id: string): RangeAndId => ({
-                    id,
-                    range: engineCommandManager.artifactMap[id].range,
-                  })
-                )
-                .sort((a: RangeAndId, b: RangeAndId) => a.range[0] - b.range[0])
-              // default to the head of the curve selected
-              const _sourceRange = ranges?.[0].range
-              const artifact = engineCommandManager.artifactMap[ranges?.[0]?.id]
-              if (artifact.type === 'result') {
-                artifact.headVertexId = data.entity_id
-              }
-              send({
-                type: 'Set selection',
-                data: {
-                  selectionType: 'singleCodeCursor',
-                  // line-end is used to indicate that headVertexId should be sent to the engine as "selected"
-                  // not the whole curve
-                  selection: { range: _sourceRange, type: 'line-end' },
-                },
-              })
-            })
-        }
+      callback: async (engineEvent) => {
+        const event = await getEventForSelectWithPoint(engineEvent, {
+          sketchEnginePathId: context.sketchEnginePathId,
+        })
+        send(event)
       },
     })
     return () => {