Updates code to mark isGenerated

lib/code/dot.ts

     super({
       id: uuid(),
       type: ShapeType.Dot,
-      isGenerated: false,
+      isGenerated: true,
       name: "Dot",
       parentId: "page0",
       childIndex: 0,

lib/code/ellipse.ts

     super({
       id: uuid(),
       type: ShapeType.Ellipse,
-      isGenerated: false,
+      isGenerated: true,
       name: "Ellipse",
       parentId: "page0",
       childIndex: 0,

lib/code/index.ts

 import { Shape } from "types"
-import { getShapeUtils, ShapeUtility } from "lib/shape-utils"
+import shapeUtilityMap, {
+  createShape,
+  getShapeUtils,
+  ShapeUtility,
+} from "lib/shape-utils"
 import * as vec from "utils/vec"
 import Vector from "./vector"
 import { vectorToPoint } from "utils/utils"
  */
 export default class CodeShape<T extends Shape> {
   private _shape: T
-  private utils: ShapeUtility<Shape>
+  private utils: ShapeUtility<T>
 
   constructor(props: T) {
-    this._shape = props
-    this.utils = getShapeUtils(this.shape)
-
+    this._shape = createShape<T>(props.type, props)
+    this.utils = getShapeUtils<T>(this._shape)
     codeShapes.add(this)
   }
 

lib/code/line.ts

     super({
       id: uuid(),
       type: ShapeType.Line,
-      isGenerated: false,
+      isGenerated: true,
       name: "Line",
       parentId: "page0",
       childIndex: 0,

lib/code/polyline.ts

     super({
       id: uuid(),
       type: ShapeType.Polyline,
-      isGenerated: false,
+      isGenerated: true,
       name: "Polyline",
       parentId: "page0",
       childIndex: 0,

lib/code/ray.ts

     super({
       id: uuid(),
       type: ShapeType.Ray,
-      isGenerated: false,
+      isGenerated: true,
       name: "Ray",
       parentId: "page0",
       childIndex: 0,

lib/shape-utils/circle.tsx

 import { v4 as uuid } from "uuid"
 import * as vec from "utils/vec"
 import { CircleShape, ShapeType, Corner, Edge } from "types"
-import { registerShapeUtils } from "./index"
+import shapeUtilityMap, { registerShapeUtils } from "./index"
 import { boundsContained } from "utils/bounds"
 import { intersectCircleBounds } from "utils/intersections"
 import { pointInCircle } from "utils/hitTests"

lib/shape-utils/index.tsx

   return Object.freeze(shape)
 }
 
-export function createShape<T extends ShapeType>(
-  type: T,
-  props: Partial<ShapeByType<T>>
+export function createShape<T extends Shape>(
+  type: T["type"],
+  props: Partial<T>
 ) {
-  return shapeUtilityMap[type].create(props) as ShapeByType<T>
+  return shapeUtilityMap[type].create(props) as T
 }
 
 export default shapeUtilityMap

pages/_document.tsx

         ),
       }
     } catch (e) {
-      console.log(e.message)
+      console.error(e.message)
     } finally {
     }
   }

state/state.ts

     SELECTED_RECTANGLE_TOOL: { unless: "isReadOnly", to: "rectangle" },
     TOGGLED_CODE_PANEL_OPEN: "toggleCodePanel",
     RESET_CAMERA: "resetCamera",
-    ZOOMED_TO_FIT: "zoomCameraToFit",
-    ZOOMED_TO_SELECTION: { if: "hasSelection", do: "zoomCameraToSelection" },
+    ZOOMED_TO_FIT: {
+      if: "hasSelection",
+      do: "zoomCameraToFit",
+      else: "resetCamera",
+    },
+    ZOOMED_TO_SELECTION: {
+      if: "hasSelection",
+      do: "zoomCameraToSelection",
+      else: "resetCamera",
+    },
     ZOOMED_TO_ACTUAL: {
       if: "hasSelection",
       do: "zoomCameraToSelectionActual",