js-draw 0.1.12 → 0.2.0

package/dist/src/rendering/Display.js

@@ -1,3 +1,17 @@
+/**
+ * Handles `HTMLCanvasElement`s (or other drawing surfaces if being used) used to display the editor's contents.
+ *
+ * @example
+ * ```
+ * const editor = new Editor(document.body);
+ * const w = editor.display.width;
+ * const h = editor.display.height;
+ * const center = Vec2.of(w / 2, h / 2);
+ * const colorAtCenter = editor.display.getColorAt(center);
+ * ```
+ *
+ * @packageDocumentation
+ */
 import CanvasRenderer from './renderers/CanvasRenderer';
 import { EditorEventType } from '../types';
 import DummyRenderer from './renderers/DummyRenderer';
@@ -12,10 +26,15 @@ export var RenderingMode;
     // SVGRenderer is not supported by the main display
 })(RenderingMode || (RenderingMode = {}));
 export default class Display {
+    /** @internal */
     constructor(editor, mode, parent) {
         this.editor = editor;
         this.parent = parent;
         this.textRerenderOutput = null;
+        /**
+         * @returns the color at the given point on the dry ink renderer, or `null` if `screenPos`
+         * 	is not on the display.
+         */
         this.getColorAt = (_screenPos) => {
             return null;
         };
@@ -52,7 +71,7 @@ export default class Display {
                 return this.dryInkRenderer.canRenderFromWithoutDataLoss(renderer);
             },
             blockResolution: cacheBlockResolution,
-            cacheSize: 500 * 500 * 4 * 220,
+            cacheSize: 500 * 500 * 4 * 150,
             maxScale: 1.5,
             minComponentsPerCache: 45,
             minComponentsToUseCache: 105,
@@ -65,15 +84,18 @@ export default class Display {
             (_a = this.resizeSurfacesCallback) === null || _a === void 0 ? void 0 : _a.call(this);
         });
     }
-    // Returns the visible width of the display (e.g. how much
-    // space the display's element takes up in the x direction
-    // in the DOM).
+    /**
+     * @returns the visible width of the display (e.g. how much
+     * space the display's element takes up in the x direction
+     * in the DOM).
+     */
     get width() {
         return this.dryInkRenderer.displaySize().x;
     }
     get height() {
         return this.dryInkRenderer.displaySize().y;
     }
+    /** @internal */
     getCache() {
         return this.cache;
     }
@@ -135,6 +157,10 @@ export default class Display {
         textRendererOutputContainer.replaceChildren(rerenderButton, this.textRerenderOutput);
         this.editor.createHTMLOverlay(textRendererOutputContainer);
     }
+    /**
+     * Rerenders the text-based display.
+     * The text-based display is intended for screen readers and can be navigated to by pressing `tab`.
+     */
     rerenderAsText() {
         this.textRenderer.clear();
         this.editor.image.render(this.textRenderer, this.editor.viewport);
@@ -142,7 +168,11 @@ export default class Display {
             this.textRerenderOutput.innerText = this.textRenderer.getDescription();
         }
     }
-    // Clears the drawing surfaces and otherwise prepares for a rerender.
+    /**
+     * Clears the drawing surfaces and otherwise prepares for a rerender.
+     *
+     * @returns the dry ink renderer.
+     */
     startRerender() {
         var _a;
         (_a = this.resizeSurfacesCallback) === null || _a === void 0 ? void 0 : _a.call(this);
@@ -150,16 +180,25 @@ export default class Display {
         this.dryInkRenderer.clear();
         return this.dryInkRenderer;
     }
+    /**
+     * If `draftMode`, the dry ink renderer is configured to render
+     * low-quality output.
+     */
     setDraftMode(draftMode) {
         this.dryInkRenderer.setDraftMode(draftMode);
     }
+    /** @internal */
     getDryInkRenderer() {
         return this.dryInkRenderer;
     }
+    /**
+     * @returns The renderer used for showing action previews (e.g. an unfinished stroke).
+     * The `wetInkRenderer`'s surface is stacked above the `dryInkRenderer`'s.
+     */
     getWetInkRenderer() {
         return this.wetInkRenderer;
     }
-    // Re-renders the contents of the wetInkRenderer onto the dryInkRenderer
+    /** Re-renders the contents of the wetInkRenderer onto the dryInkRenderer. */
     flatten() {
         var _a;
         (_a = this.flattenCallback) === null || _a === void 0 ? void 0 : _a.call(this);

package/dist/src/rendering/caching/CacheRecord.d.ts

@@ -8,6 +8,7 @@ export default class CacheRecord {
     private renderer;
     private lastUsedCycle;
     private allocd;
+    allocCount: number;
     constructor(onBeforeDeallocCallback: BeforeDeallocCallback | null, cacheState: CacheState);
     startRender(): AbstractRenderer;
     dealloc(): void;

package/dist/src/rendering/caching/CacheRecord.js

@@ -6,6 +6,8 @@ export default class CacheRecord {
         this.onBeforeDeallocCallback = onBeforeDeallocCallback;
         this.cacheState = cacheState;
         this.allocd = false;
+        // For debugging
+        this.allocCount = 0;
         this.renderer = cacheState.props.createRenderer();
         this.lastUsedCycle = -1;
         this.allocd = true;
@@ -34,6 +36,7 @@ export default class CacheRecord {
         this.allocd = true;
         this.onBeforeDeallocCallback = newDeallocCallback;
         this.lastUsedCycle = this.cacheState.currentRenderingCycle;
+        this.allocCount++;
     }
     getLastUsedCycle() {
         return this.lastUsedCycle;

package/dist/src/rendering/caching/CacheRecordManager.d.ts

@@ -1,11 +1,12 @@
-import { BeforeDeallocCallback, PartialCacheState } from './types';
+import { BeforeDeallocCallback, CacheProps, CacheState } from './types';
 import CacheRecord from './CacheRecord';
 import Rect2 from '../../math/Rect2';
 export declare class CacheRecordManager {
-    private readonly cacheState;
     private cacheRecords;
     private maxCanvases;
-    constructor(cacheState: PartialCacheState);
+    private cacheState;
+    constructor(cacheProps: CacheProps);
+    setSharedState(state: CacheState): void;
     allocCanvas(drawTo: Rect2, onDealloc: BeforeDeallocCallback): CacheRecord;
     private getLeastRecentlyUsedRecord;
 }

package/dist/src/rendering/caching/CacheRecordManager.js

@@ -1,25 +1,37 @@
 import CacheRecord from './CacheRecord';
+const debugMode = false;
 export class CacheRecordManager {
-    constructor(cacheState) {
-        this.cacheState = cacheState;
+    constructor(cacheProps) {
         // Fixed-size array: Cache blocks are assigned indicies into [cachedCanvases].
         this.cacheRecords = [];
-        const cacheProps = cacheState.props;
         this.maxCanvases = Math.ceil(
         // Assuming four components per pixel:
         cacheProps.cacheSize / 4 / cacheProps.blockResolution.x / cacheProps.blockResolution.y);
     }
+    setSharedState(state) {
+        this.cacheState = state;
+    }
     allocCanvas(drawTo, onDealloc) {
         if (this.cacheRecords.length < this.maxCanvases) {
-            const record = new CacheRecord(onDealloc, Object.assign(Object.assign({}, this.cacheState), { recordManager: this }));
+            const record = new CacheRecord(onDealloc, this.cacheState);
             record.setRenderingRegion(drawTo);
             this.cacheRecords.push(record);
+            if (debugMode) {
+                console.log('[Cache] Cache spaces used: ', this.cacheRecords.length, ' of ', this.maxCanvases);
+            }
             return record;
         }
         else {
             const lru = this.getLeastRecentlyUsedRecord();
+            if (debugMode) {
+                console.log('[Cache] Re-alloc. Times allocated: ', lru.allocCount, '\nLast used cycle: ', lru.getLastUsedCycle(), '\nCurrent cycle: ', this.cacheState.currentRenderingCycle);
+            }
             lru.realloc(onDealloc);
             lru.setRenderingRegion(drawTo);
+            if (debugMode) {
+                console.log('[Cache] Now re-alloc\'d. Last used cycle: ', lru.getLastUsedCycle());
+                console.assert(lru['cacheState'] === this.cacheState, '[Cache] Unequal cache states! cacheState should be a shared object!');
+            }
             return lru;
         }
     }

package/dist/src/rendering/caching/RenderingCache.d.ts

@@ -1,12 +1,11 @@
 import { ImageNode } from '../../EditorImage';
 import Viewport from '../../Viewport';
 import AbstractRenderer from '../renderers/AbstractRenderer';
-import { CacheProps, CacheState } from './types';
+import { CacheProps } from './types';
 export default class RenderingCache {
-    private partialSharedState;
+    private sharedState;
     private recordManager;
     private rootNode;
     constructor(cacheProps: CacheProps);
-    getSharedState(): CacheState;
     render(screenRenderer: AbstractRenderer, image: ImageNode, viewport: Viewport): void;
 }

package/dist/src/rendering/caching/RenderingCache.js

@@ -3,36 +3,35 @@ import RenderingCacheNode from './RenderingCacheNode';
 import { CacheRecordManager } from './CacheRecordManager';
 export default class RenderingCache {
     constructor(cacheProps) {
-        this.partialSharedState = {
+        this.recordManager = new CacheRecordManager(cacheProps);
+        this.sharedState = {
             props: cacheProps,
             currentRenderingCycle: 0,
+            recordManager: this.recordManager,
         };
-        this.recordManager = new CacheRecordManager(this.partialSharedState);
-    }
-    getSharedState() {
-        return Object.assign(Object.assign({}, this.partialSharedState), { recordManager: this.recordManager });
+        this.recordManager.setSharedState(this.sharedState);
     }
     render(screenRenderer, image, viewport) {
         var _a;
         const visibleRect = viewport.visibleRect;
-        this.partialSharedState.currentRenderingCycle++;
+        this.sharedState.currentRenderingCycle++;
         // If we can't use the cache,
-        if (!this.partialSharedState.props.isOfCorrectType(screenRenderer)) {
+        if (!this.sharedState.props.isOfCorrectType(screenRenderer)) {
             image.render(screenRenderer, visibleRect);
             return;
         }
         if (!this.rootNode) {
             // Adjust the node so that it has the correct aspect ratio
-            const res = this.partialSharedState.props.blockResolution;
+            const res = this.sharedState.props.blockResolution;
             const topLeft = visibleRect.topLeft;
-            this.rootNode = new RenderingCacheNode(new Rect2(topLeft.x, topLeft.y, res.x, res.y), this.getSharedState());
+            this.rootNode = new RenderingCacheNode(new Rect2(topLeft.x, topLeft.y, res.x, res.y), this.sharedState);
         }
         while (!this.rootNode.region.containsRect(visibleRect)) {
             this.rootNode = this.rootNode.generateParent();
         }
         this.rootNode = (_a = this.rootNode.smallestChildContaining(visibleRect)) !== null && _a !== void 0 ? _a : this.rootNode;
         const visibleLeaves = image.getLeavesIntersectingRegion(viewport.visibleRect, rect => screenRenderer.isTooSmallToRender(rect));
-        if (visibleLeaves.length > this.partialSharedState.props.minComponentsToUseCache) {
+        if (visibleLeaves.length > this.sharedState.props.minComponentsToUseCache) {
             this.rootNode.renderItems(screenRenderer, [image], viewport);
         }
         else {

package/dist/src/rendering/caching/types.d.ts

@@ -12,10 +12,8 @@ export interface CacheProps {
     minComponentsPerCache: number;
     minComponentsToUseCache: number;
 }
-export interface PartialCacheState {
+export interface CacheState {
     currentRenderingCycle: number;
     props: CacheProps;
-}
-export interface CacheState extends PartialCacheState {
     recordManager: CacheRecordManager;
 }

package/dist/src/rendering/renderers/CanvasRenderer.js

@@ -43,7 +43,7 @@ export default class CanvasRenderer extends AbstractRenderer {
         }
         else {
             this.minSquareCurveApproxDist = 1;
-            this.minRenderSizeBothDimens = 1;
+            this.minRenderSizeBothDimens = 0.5;
             this.minRenderSizeAnyDimen = 0;
         }
     }

package/dist/src/toolbar/HTMLToolbar.js

@@ -29,6 +29,7 @@ export default class HTMLToolbar {
         }
         this.setupColorPickers();
     }
+    // @internal
     setupColorPickers() {
         const closePickerOverlay = document.createElement('div');
         closePickerOverlay.className = `${toolbarCSSPrefix}closeColorPickerOverlay`;

package/dist/src/toolbar/makeColorInput.js

@@ -2,7 +2,7 @@ import Color4 from '../Color4';
 import { ToolType } from '../tools/ToolController';
 import { EditorEventType } from '../types';
 import { makePipetteIcon } from './icons';
-// Returns [ input, container ].
+// Returns [ color input, input container ].
 export const makeColorInput = (editor, onColorChange) => {
     const colorInputContainer = document.createElement('span');
     const colorInput = document.createElement('input');

package/dist/src/toolbar/widgets/PenWidget.js

@@ -1,3 +1,4 @@
+// @internal @packageDocumentation
 import { makeArrowBuilder } from '../../components/builders/ArrowBuilder';
 import { makeFreehandLineBuilder } from '../../components/builders/FreehandLineBuilder';
 import { makeLineBuilder } from '../../components/builders/LineBuilder';

package/dist/src/tools/Pen.d.ts

@@ -4,7 +4,7 @@ import { PointerEvt } from '../types';
 import BaseTool from './BaseTool';
 import { ToolType } from './ToolController';
 import { ComponentBuilderFactory } from '../components/builders/types';
-interface PenStyle {
+export interface PenStyle {
     color: Color4;
     thickness: number;
 }
@@ -32,4 +32,3 @@ export default class Pen extends BaseTool {
     getColor(): Color4;
     getStrokeFactory(): ComponentBuilderFactory;
 }
-export {};

package/dist/src/tools/Pen.js

@@ -20,7 +20,14 @@ export default class Pen extends BaseTool {
     getStrokePoint(pointer) {
         var _a;
         const minPressure = 0.3;
-        const pressure = Math.max((_a = pointer.pressure) !== null && _a !== void 0 ? _a : 1.0, minPressure);
+        let pressure = Math.max((_a = pointer.pressure) !== null && _a !== void 0 ? _a : 1.0, minPressure);
+        if (!isFinite(pressure)) {
+            console.warn('Non-finite pressure!', pointer);
+            pressure = minPressure;
+        }
+        console.assert(isFinite(pointer.canvasPos.length()), 'Non-finite canvas position!');
+        console.assert(isFinite(pointer.screenPos.length()), 'Non-finite screen position!');
+        console.assert(isFinite(pointer.timeStamp), 'Non-finite timeStamp on pointer!');
         return {
             pos: pointer.canvasPos,
             width: pressure * this.getPressureMultiplier(),

package/dist/src/tools/PipetteTool.js

@@ -1,3 +1,4 @@
+// @internal @packageDocumentation
 import BaseTool from './BaseTool';
 import { ToolType } from './ToolController';
 export default class PipetteTool extends BaseTool {

package/dist/src/tools/SelectionTool.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import Command from '../commands/Command';
+var _a;
 import Duplicate from '../commands/Duplicate';
 import Erase from '../commands/Erase';
 import Mat33 from '../math/Mat33';
@@ -18,6 +18,7 @@ import { EditorEventType } from '../types';
 import Viewport from '../Viewport';
 import BaseTool from './BaseTool';
 import { ToolType } from './ToolController';
+import SerializableCommand from '../commands/SerializableCommand';
 const handleScreenSize = 30;
 const styles = `
 	.handleOverlay {
@@ -118,6 +119,7 @@ const makeDraggable = (element, onDrag, onDragEnd) => {
 };
 // Maximum number of strokes to transform without a re-render.
 const updateChunkSize = 100;
+// @internal
 class Selection {
     constructor(startPoint, editor) {
         this.startPoint = startPoint;
@@ -228,7 +230,7 @@ class Selection {
         this.transform = Mat33.identity;
         this.region = this.region.transformedBoundingBox(inverseTransform);
         // Make the commands undo-able
-        this.editor.dispatch(new Selection.ApplyTransformationCommand(this, currentTransfmCommands, fullTransform, inverseTransform, deltaBoxRotation));
+        this.editor.dispatch(new Selection.ApplyTransformationCommand(this, currentTransfmCommands, fullTransform, deltaBoxRotation));
     }
     // Preview the effects of the current transformation on the selection
     previewTransformCmds() {
@@ -352,36 +354,57 @@ class Selection {
         return new Duplicate(this.selectedElems);
     }
 }
-Selection.ApplyTransformationCommand = class extends Command {
-    constructor(selection, currentTransfmCommands, fullTransform, inverseTransform, deltaBoxRotation) {
-        super();
+_a = Selection;
+(() => {
+    SerializableCommand.register('selection-tool-transform', (json, editor) => {
+        // The selection box is lost when serializing/deserializing. No need to store box rotation
+        const guiBoxRotation = 0;
+        const fullTransform = new Mat33(...json.transform);
+        const commands = json.commands.map(data => SerializableCommand.deserialize(data, editor));
+        return new _a.ApplyTransformationCommand(null, commands, fullTransform, guiBoxRotation);
+    });
+})();
+Selection.ApplyTransformationCommand = class extends SerializableCommand {
+    constructor(selection, currentTransfmCommands, fullTransform, deltaBoxRotation) {
+        super('selection-tool-transform');
         this.selection = selection;
         this.currentTransfmCommands = currentTransfmCommands;
         this.fullTransform = fullTransform;
-        this.inverseTransform = inverseTransform;
         this.deltaBoxRotation = deltaBoxRotation;
     }
     apply(editor) {
+        var _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             // Approximate the new selection
-            this.selection.region = this.selection.region.transformedBoundingBox(this.fullTransform);
-            this.selection.boxRotation += this.deltaBoxRotation;
-            this.selection.updateUI();
+            if (this.selection) {
+                this.selection.region = this.selection.region.transformedBoundingBox(this.fullTransform);
+                this.selection.boxRotation += this.deltaBoxRotation;
+                this.selection.updateUI();
+            }
             yield editor.asyncApplyCommands(this.currentTransfmCommands, updateChunkSize);
-            this.selection.recomputeRegion();
-            this.selection.updateUI();
+            (_b = this.selection) === null || _b === void 0 ? void 0 : _b.recomputeRegion();
+            (_c = this.selection) === null || _c === void 0 ? void 0 : _c.updateUI();
         });
     }
     unapply(editor) {
+        var _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            this.selection.region = this.selection.region.transformedBoundingBox(this.inverseTransform);
-            this.selection.boxRotation -= this.deltaBoxRotation;
-            this.selection.updateUI();
+            if (this.selection) {
+                this.selection.region = this.selection.region.transformedBoundingBox(this.fullTransform.inverse());
+                this.selection.boxRotation -= this.deltaBoxRotation;
+                this.selection.updateUI();
+            }
             yield editor.asyncUnapplyCommands(this.currentTransfmCommands, updateChunkSize);
-            this.selection.recomputeRegion();
-            this.selection.updateUI();
+            (_b = this.selection) === null || _b === void 0 ? void 0 : _b.recomputeRegion();
+            (_c = this.selection) === null || _c === void 0 ? void 0 : _c.updateUI();
         });
     }
+    serializeToJSON() {
+        return {
+            commands: this.currentTransfmCommands.map(command => command.serialize()),
+            transform: this.fullTransform.toArray(),
+        };
+    }
     description(_editor, localizationTable) {
         return localizationTable.transformedElements(this.currentTransfmCommands.length);
     }
@@ -397,9 +420,9 @@ export default class SelectionTool extends BaseTool {
         this.handleOverlay.style.display = 'none';
         this.handleOverlay.classList.add('handleOverlay');
         editor.notifier.on(EditorEventType.ViewportChanged, _data => {
-            var _a, _b;
-            (_a = this.selectionBox) === null || _a === void 0 ? void 0 : _a.recomputeRegion();
-            (_b = this.selectionBox) === null || _b === void 0 ? void 0 : _b.updateUI();
+            var _b, _c;
+            (_b = this.selectionBox) === null || _b === void 0 ? void 0 : _b.recomputeRegion();
+            (_c = this.selectionBox) === null || _c === void 0 ? void 0 : _c.updateUI();
         });
         this.editor.handleKeyEventsFrom(this.handleOverlay);
     }
@@ -447,11 +470,11 @@ export default class SelectionTool extends BaseTool {
         this.onGestureEnd();
     }
     onGestureCancel() {
-        var _a, _b;
+        var _b, _c;
         // Revert to the previous selection, if any.
-        (_a = this.selectionBox) === null || _a === void 0 ? void 0 : _a.cancelSelection();
+        (_b = this.selectionBox) === null || _b === void 0 ? void 0 : _b.cancelSelection();
         this.selectionBox = this.prevSelectionBox;
-        (_b = this.selectionBox) === null || _b === void 0 ? void 0 : _b.appendBackgroundBoxTo(this.handleOverlay);
+        (_c = this.selectionBox) === null || _c === void 0 ? void 0 : _c.appendBackgroundBoxTo(this.handleOverlay);
     }
     onKeyPress(event) {
         let rotationSteps = 0;

package/dist/src/types.d.ts

@@ -7,6 +7,7 @@ import AbstractComponent from './components/AbstractComponent';
 import Rect2 from './math/Rect2';
 import Pointer from './Pointer';
 import Color4 from './Color4';
+import Command from './commands/Command';
 export interface PointerEvtListener {
     onPointerDown(event: PointerEvt): boolean;
     onPointerMove(event: PointerEvt): void;
@@ -61,11 +62,13 @@ export declare enum EditorEventType {
     ToolDisabled = 1,
     ToolUpdated = 2,
     UndoRedoStackUpdated = 3,
-    ObjectAdded = 4,
-    ViewportChanged = 5,
-    DisplayResized = 6,
-    ColorPickerToggled = 7,
-    ColorPickerColorSelected = 8
+    CommandDone = 4,
+    CommandUndone = 5,
+    ObjectAdded = 6,
+    ViewportChanged = 7,
+    DisplayResized = 8,
+    ColorPickerToggled = 9,
+    ColorPickerColorSelected = 10
 }
 declare type EditorToolEventType = EditorEventType.ToolEnabled | EditorEventType.ToolDisabled | EditorEventType.ToolUpdated;
 export interface EditorToolEvent {
@@ -90,6 +93,14 @@ export interface EditorUndoStackUpdated {
     readonly undoStackSize: number;
     readonly redoStackSize: number;
 }
+export interface CommandDoneEvent {
+    readonly kind: EditorEventType.CommandDone;
+    readonly command: Command;
+}
+export interface CommandUndoneEvent {
+    readonly kind: EditorEventType.CommandUndone;
+    readonly command: Command;
+}
 export interface ColorPickerToggled {
     readonly kind: EditorEventType.ColorPickerToggled;
     readonly open: boolean;
@@ -98,7 +109,7 @@ export interface ColorPickerColorSelected {
     readonly kind: EditorEventType.ColorPickerColorSelected;
     readonly color: Color4;
 }
-export declare type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | ColorPickerToggled | ColorPickerColorSelected;
+export declare type EditorEventDataType = EditorToolEvent | EditorObjectEvent | EditorViewportChangedEvent | DisplayResizedEvent | EditorUndoStackUpdated | CommandDoneEvent | CommandUndoneEvent | ColorPickerToggled | ColorPickerColorSelected;
 export declare type OnProgressListener = (amountProcessed: number, totalToProcess: number) => Promise<void> | null;
 export declare type ComponentAddedListener = (component: AbstractComponent) => void;
 export declare type OnDetermineExportRectListener = (exportRect: Rect2) => void;

package/dist/src/types.js

@@ -15,9 +15,11 @@ export var EditorEventType;
     EditorEventType[EditorEventType["ToolDisabled"] = 1] = "ToolDisabled";
     EditorEventType[EditorEventType["ToolUpdated"] = 2] = "ToolUpdated";
     EditorEventType[EditorEventType["UndoRedoStackUpdated"] = 3] = "UndoRedoStackUpdated";
-    EditorEventType[EditorEventType["ObjectAdded"] = 4] = "ObjectAdded";
-    EditorEventType[EditorEventType["ViewportChanged"] = 5] = "ViewportChanged";
-    EditorEventType[EditorEventType["DisplayResized"] = 6] = "DisplayResized";
-    EditorEventType[EditorEventType["ColorPickerToggled"] = 7] = "ColorPickerToggled";
-    EditorEventType[EditorEventType["ColorPickerColorSelected"] = 8] = "ColorPickerColorSelected";
+    EditorEventType[EditorEventType["CommandDone"] = 4] = "CommandDone";
+    EditorEventType[EditorEventType["CommandUndone"] = 5] = "CommandUndone";
+    EditorEventType[EditorEventType["ObjectAdded"] = 6] = "ObjectAdded";
+    EditorEventType[EditorEventType["ViewportChanged"] = 7] = "ViewportChanged";
+    EditorEventType[EditorEventType["DisplayResized"] = 8] = "DisplayResized";
+    EditorEventType[EditorEventType["ColorPickerToggled"] = 9] = "ColorPickerToggled";
+    EditorEventType[EditorEventType["ColorPickerColorSelected"] = 10] = "ColorPickerColorSelected";
 })(EditorEventType || (EditorEventType = {}));

package/firebase.json

@@ -0,0 +1,16 @@
+{
+  "hosting": {
+    "public": "docs",
+    "ignore": [
+      "firebase.json",
+      "src/**",
+      ".husky/**",
+      ".vscode/**",
+      "build_tools/**",
+      "dist/**",
+      "__mocks__/**",
+      "**/.*",
+      "**/node_modules/**"
+    ]
+  }
+}