improve session api

state/session.ts

     return this
   }
 
-  get current() {
-    return this._current
+  update<T extends BaseSession>(...args: Parameters<T['update']>) {
+    this._current.update.call(null, ...args)
+    return this
   }
 
-  set current(session: BaseSession) {
+  start(session: BaseSession) {
     this._current = session
+    return this
+  }
+
+  compplete<T extends BaseSession>(...args: Parameters<T['complete']>) {
+    this._current.complete.call(null, ...args)
+    return this
+  }
+
+  cancel<T extends BaseSession>(...args: Parameters<T['cancel']>) {
+    this._current.cancel.call(null, ...args)
+    return this
+  }
+
+  get current() {
+    return this._current
   }
 }
 

state/state.ts

 
     // Editing
     startEditSession(data) {
-      session.current = new Sessions.EditSession(data)
+      session.start(new Sessions.EditSession(data))
     },
     updateEditSession(data, payload: { change: Partial<Shape> }) {
-      session.current.update(data, payload.change)
+      session.update<Sessions.EditSession>(data, payload.change)
     },
 
     // Brushing
     startBrushSession(data, payload: PointerInfo) {
-      session.current = new Sessions.BrushSession(
-        data,
-        screenToWorld(payload.point, data)
+      session.start(
+        new Sessions.BrushSession(data, screenToWorld(payload.point, data))
       )
     },
     updateBrushSession(data, payload: PointerInfo) {
-      session.current.update(data, screenToWorld(payload.point, data))
+      session.update<Sessions.BrushSession>(
+        data,
+        screenToWorld(payload.point, data)
+      )
     },
 
     // Rotating
     startRotateSession(data, payload: PointerInfo) {
-      session.current = new Sessions.RotateSession(
-        data,
-        screenToWorld(payload.point, data)
+      session.start(
+        new Sessions.RotateSession(data, screenToWorld(payload.point, data))
       )
     },
     keyUpdateRotateSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.RotateSession>(
         data,
         screenToWorld(inputs.pointer.point, data),
         payload.shiftKey
       )
     },
     updateRotateSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.RotateSession>(
         data,
         screenToWorld(payload.point, data),
         payload.shiftKey
 
     // Dragging / Translating
     startTranslateSession(data) {
-      session.current = new Sessions.TranslateSession(
-        data,
-        screenToWorld(inputs.pointer.origin, data)
+      session.start(
+        new Sessions.TranslateSession(
+          data,
+          screenToWorld(inputs.pointer.origin, data)
+        )
       )
     },
     keyUpdateTranslateSession(
       data,
       payload: { shiftKey: boolean; altKey: boolean }
     ) {
-      session.current.update(
+      session.update<Sessions.TranslateSession>(
         data,
         screenToWorld(inputs.pointer.point, data),
         payload.shiftKey,
       )
     },
     updateTranslateSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.TranslateSession>(
         data,
         screenToWorld(payload.point, data),
         payload.shiftKey,
       const shapeId = Array.from(getSelectedIds(data).values())[0]
       const handleId = payload.target
 
-      session.current = new Sessions.HandleSession(
-        data,
-        shapeId,
-        handleId,
-        screenToWorld(inputs.pointer.origin, data)
+      session.start(
+        new Sessions.HandleSession(
+          data,
+          shapeId,
+          handleId,
+          screenToWorld(inputs.pointer.origin, data)
+        )
       )
     },
     keyUpdateHandleSession(
       data,
       payload: { shiftKey: boolean; altKey: boolean }
     ) {
-      session.current.update(
+      session.update<Sessions.HandleSession>(
         data,
         screenToWorld(inputs.pointer.point, data),
-        payload.shiftKey,
-        payload.altKey
+        payload.shiftKey
       )
     },
     updateHandleSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.HandleSession>(
         data,
         screenToWorld(payload.point, data),
-        payload.shiftKey,
-        payload.altKey
+        payload.shiftKey
       )
     },
 
       payload: PointerInfo & { target: Corner | Edge }
     ) {
       const point = screenToWorld(inputs.pointer.origin, data)
-      session.current =
+      session.start(
         getSelectedIds(data).size === 1
           ? new Sessions.TransformSingleSession(data, payload.target, point)
           : new Sessions.TransformSession(data, payload.target, point)
+      )
     },
     startDrawTransformSession(data, payload: PointerInfo) {
-      session.current = new Sessions.TransformSingleSession(
-        data,
-        Corner.BottomRight,
-        screenToWorld(payload.point, data),
-        true
+      session.start(
+        new Sessions.TransformSingleSession(
+          data,
+          Corner.BottomRight,
+          screenToWorld(payload.point, data),
+          true
+        )
       )
     },
     keyUpdateTransformSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.TransformSession>(
         data,
         screenToWorld(inputs.pointer.point, data),
-        payload.shiftKey,
-        payload.altKey
+        payload.shiftKey
       )
     },
     updateTransformSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.TransformSession>(
         data,
         screenToWorld(payload.point, data),
-        payload.shiftKey,
-        payload.altKey
+        payload.shiftKey
       )
     },
 
     // Direction
     startDirectionSession(data) {
-      session.current = new Sessions.DirectionSession(
-        data,
-        screenToWorld(inputs.pointer.origin, data)
+      session.start(
+        new Sessions.DirectionSession(
+          data,
+          screenToWorld(inputs.pointer.origin, data)
+        )
       )
     },
     updateDirectionSession(data, payload: PointerInfo) {
-      session.current.update(data, screenToWorld(payload.point, data))
+      session.update<Sessions.DirectionSession>(
+        data,
+        screenToWorld(payload.point, data)
+      )
     },
 
     // Drawing
     startDrawSession(data, payload: PointerInfo) {
       const id = Array.from(getSelectedIds(data).values())[0]
-      session.current = new Sessions.DrawSession(
-        data,
-        id,
-        screenToWorld(inputs.pointer.origin, data),
-        payload.shiftKey
+      session.start(
+        new Sessions.DrawSession(
+          data,
+          id,
+          screenToWorld(inputs.pointer.origin, data),
+          payload.shiftKey
+        )
       )
     },
     keyUpdateDrawSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.DrawSession>(
         data,
         screenToWorld(inputs.pointer.point, data),
         payload.pressure,
       )
     },
     updateDrawSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.DrawSession>(
         data,
         screenToWorld(payload.point, data),
         payload.pressure,
     // Arrow
     startArrowSession(data, payload: PointerInfo) {
       const id = Array.from(getSelectedIds(data).values())[0]
-      session.current = new Sessions.ArrowSession(
-        data,
-        id,
-        screenToWorld(inputs.pointer.origin, data),
-        payload.shiftKey
+
+      session.start(
+        new Sessions.ArrowSession(
+          data,
+          id,
+          screenToWorld(inputs.pointer.origin, data),
+          payload.shiftKey
+        )
       )
     },
     keyUpdateArrowSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.ArrowSession>(
         data,
         screenToWorld(inputs.pointer.point, data),
         payload.shiftKey
       )
     },
     updateArrowSession(data, payload: PointerInfo) {
-      session.current.update(
+      session.update<Sessions.ArrowSession>(
         data,
         screenToWorld(payload.point, data),
         payload.shiftKey