pxt-common-packages 12.2.12 → 12.2.14

package/built/common-sim.d.ts

@@ -341,15 +341,25 @@ declare namespace pxsim.browserEvents {
         ArrowRight = 39,
         PageDown = 34,
         End = 35,
-        Home = 36
+        Home = 36,
+        LeftShift = 1016,
+        RightShift = 1017,
+        LeftControl = 1018,
+        RightControl = 1019,
+        Backspace = 8,
+        Delete = 46
     }
     function onKeyboardEvent(event: KeyboardEvent, pressed: boolean): void;
-    function getValueForKey(event: KeyboardEvent): 0 | Key;
+    function getValueForKey(event: KeyboardEvent): 0 | Key.Zero | Key.One | Key.Two | Key.Three | Key.Four | Key.Five | Key.Six | Key.Seven | Key.Eight | Key.Nine | Key.BackTick | Key.Hyphen | Key.Equals | Key.Q | Key.W | Key.E | Key.R | Key.T | Key.Y | Key.U | Key.I | Key.O | Key.P | Key.OpenBracket | Key.CloseBracket | Key.BackSlash | Key.A | Key.S | Key.D | Key.F | Key.G | Key.H | Key.Space | Key.PageUp | Key.J | Key.K | Key.L | Key.SemiColon | Key.Apostrophe | Key.Z | Key.X | Key.C | Key.V | Key.B | Key.N | Key.M | Key.Comma | Key.Period | Key.ForwardSlash | Key.Shift | Key.Enter | Key.CapsLock | Key.Tab | Key.Control | Key.Meta | Key.Alt | Key.ArrowUp | Key.ArrowDown | Key.ArrowLeft | Key.ArrowRight | Key.PageDown | Key.End | Key.Home | Key.Backspace | Key.Delete;
 }
 declare namespace pxsim.browserEvents {
     interface BrowserEventsBoard extends CommonBoard {
         mouseState: MouseState;
     }
+    const INTERNAL_KEY_DOWN = 6870;
+    const INTERNAL_KEY_UP = 6871;
+    const INTERNAL_POINTER_DOWN = 6868;
+    const INTERNAL_POINTER_UP = 6869;
     type MouseEvent = "pointerdown" | "pointerup" | "pointermove" | "pointerleave" | "pointerenter" | "pointercancel" | "pointerover" | "pointerout";
     class MouseState {
         protected x: number;

package/built/common-sim.js

@@ -813,16 +813,42 @@ var pxsim;
             Key[Key["PageDown"] = 34] = "PageDown";
             Key[Key["End"] = 35] = "End";
             Key[Key["Home"] = 36] = "Home";
+            Key[Key["LeftShift"] = 1016] = "LeftShift";
+            Key[Key["RightShift"] = 1017] = "RightShift";
+            Key[Key["LeftControl"] = 1018] = "LeftControl";
+            Key[Key["RightControl"] = 1019] = "RightControl";
+            Key[Key["Backspace"] = 8] = "Backspace";
+            Key[Key["Delete"] = 46] = "Delete";
         })(Key = browserEvents.Key || (browserEvents.Key = {}));
         function onKeyboardEvent(event, pressed) {
+            const eventValue = getValueForKey(event);
+            fireEvent(eventValue, pressed);
+            if (eventValue === Key.Shift) {
+                if (event.location === event.DOM_KEY_LOCATION_LEFT) {
+                    fireEvent(Key.LeftShift, pressed);
+                }
+                else if (event.location === event.DOM_KEY_LOCATION_RIGHT) {
+                    fireEvent(Key.RightShift, pressed);
+                }
+            }
+            if (eventValue === Key.Control) {
+                if (event.location === event.DOM_KEY_LOCATION_LEFT) {
+                    fireEvent(Key.LeftControl, pressed);
+                }
+                else if (event.location === event.DOM_KEY_LOCATION_RIGHT) {
+                    fireEvent(Key.RightControl, pressed);
+                }
+            }
+        }
+        browserEvents.onKeyboardEvent = onKeyboardEvent;
+        function fireEvent(key, pressed) {
             if (pressed) {
-                pxsim.board().bus.queue(6866, getValueForKey(event));
+                pxsim.board().bus.queue(browserEvents.INTERNAL_KEY_DOWN, key);
             }
             else {
-                pxsim.board().bus.queue(6867, getValueForKey(event));
+                pxsim.board().bus.queue(browserEvents.INTERNAL_KEY_UP, key);
             }
         }
-        browserEvents.onKeyboardEvent = onKeyboardEvent;
         function getValueForKey(event) {
             switch (event.key) {
                 case "0":
@@ -998,6 +1024,10 @@ var pxsim;
                     return Key.End;
                 case "Home":
                     return Key.Home;
+                case "Delete":
+                    return Key.Delete;
+                case "Backspace":
+                    return Key.Backspace;
                 default:
                     return 0;
             }
@@ -1010,6 +1040,10 @@ var pxsim;
     var browserEvents;
     (function (browserEvents) {
         const THROTTLE_INTERVAL = 50;
+        browserEvents.INTERNAL_KEY_DOWN = 6870;
+        browserEvents.INTERNAL_KEY_UP = 6871;
+        browserEvents.INTERNAL_POINTER_DOWN = 6868;
+        browserEvents.INTERNAL_POINTER_UP = 6869;
         class MouseState {
             constructor() {
                 this.onMove = pxsim.U.throttle(() => {
@@ -1032,9 +1066,16 @@ var pxsim;
                     "pointerover",
                     "pointerout",
                 ];
+                let eventId = 6857 + events.indexOf(event.type);
+                if (event.type === "pointerdown") {
+                    eventId = browserEvents.INTERNAL_POINTER_DOWN;
+                }
+                else if (event.type === "pointerup") {
+                    eventId = browserEvents.INTERNAL_POINTER_UP;
+                }
                 // We add 1 to the button here because the left button is 0 and
                 // that's used as a wildcard in our event bus
-                pxsim.board().bus.queue(6857 + events.indexOf(event.type), (event.button || 0) + 1);
+                pxsim.board().bus.queue(eventId, (event.button || 0) + 1);
             }
             onWheelEvent(dx, dy, dz) {
                 this.dx = dx;

package/libs/browser-events/browserEvents.cpp

@@ -27,6 +27,10 @@ int wheelDz() {
     return -1;
 }
 
+//%
+void _setCursorVisible(bool visible) {
+}
+
 //%
 int currentTime() {
     return -1;

package/libs/browser-events/browserEvents.ts

@@ -4,66 +4,94 @@
 //% block="Browser Events"
 namespace browserEvents {
     export enum Event {
+        //% block="pointer down"
         PointerDown = 6857,
+        //% block="pointer up"
         PointerUp = 6858,
+        //% block="pointer move"
         PointerMove = 6859,
+        //% block="pointer leave"
         PointerLeave = 6860,
+        //% block="pointer enter"
         PointerEnter = 6861,
+        //% block="pointer cancel"
         PointerCancel = 6862,
+        //% block="pointer over"
         PointerOver = 6863,
+        //% block="pointer out"
         PointerOut = 6864,
+        //% block="wheel"
         Wheel = 6865,
+        //% block="key down"
         KeyDown = 6866,
+        //% block="key up"
         KeyUp = 6867
     }
 
     export enum MouseButtonId {
+        //% block="left"
         Left = 1,
+        //% block="right"
         Right = 3,
+        //% block="wheel"
         Wheel = 2,
+        //% block="back"
         Back = 4,
+        //% block="forward"
         Forward = 5
     }
 
     export enum MouseButtonEvent {
+        //% block="pressed"
         Pressed = Event.PointerDown,
+        //% block="released"
         Released = Event.PointerUp,
     }
 
+    //% whenUsed
+    const INTERNAL_POINTER_DOWN = 6868;
+    //% whenUsed
+    const INTERNAL_POINTER_UP = 6869;
+
+    type MouseHandler = (x: number, y: number) => void;
+
     //% fixedInstances
     export class MouseButton {
         protected _pressed: boolean;
-        protected pressHandler: (x: number, y: number) => void;
-        protected pressListeners: ((x: number, y: number) => void)[];
-        protected releaseHandler: (x: number, y: number) => void;
-        protected releaseListeners: ((x: number, y: number) => void)[];
+
+        protected sceneStack: _SceneButtonHandlers<MouseHandler>[];
+
+        protected get state(): _SceneButtonHandlers<MouseHandler> {
+            return this.sceneStack[this.sceneStack.length - 1];
+        }
 
         constructor(public id: number) {
-            control.internalOnEvent(Event.PointerDown, this.id, () => this.setPressed(true), 16);
-            control.internalOnEvent(Event.PointerUp, this.id, () => this.setPressed(false), 16);
+            control.internalOnEvent(INTERNAL_POINTER_DOWN, this.id, () => this.setPressed(true), 16);
+            control.internalOnEvent(INTERNAL_POINTER_UP, this.id, () => this.setPressed(false), 16);
 
             this._pressed = false;
-            this.pressListeners = [];
-            this.releaseListeners = [];
+
+            this.sceneStack = [new _SceneButtonHandlers<MouseHandler>(id, invokeMouseHandler)];
+
+            game.addScenePushHandler(() => {
+                this.sceneStack.push(new _SceneButtonHandlers<MouseHandler>(id, invokeMouseHandler));
+            });
+            game.addScenePopHandler(() => {
+                this.sceneStack.pop();
+                if (this.sceneStack.length === 0) {
+                    this.sceneStack = [new _SceneButtonHandlers<MouseHandler>(id, invokeMouseHandler)];
+                }
+            });
         }
 
         setPressed(pressed: boolean) {
             this._pressed = pressed;
+
             if (pressed) {
-                if (this.pressHandler) {
-                    this.pressHandler(mouseX(), mouseY());
-                }
-                for (const handler of this.pressListeners) {
-                    handler(mouseX(), mouseY());
-                }
+                control.raiseEvent(MouseButtonEvent.Pressed, this.id);
             }
             else {
-                if (this.releaseHandler) {
-                    this.releaseHandler(mouseX(), mouseY());
-                }
-                for (const handler of this.releaseListeners) {
-                    handler(mouseX(), mouseY());
-                }
+                control.raiseEvent(MouseButtonEvent.Released, this.id);
             }
         }
 
@@ -73,12 +101,7 @@ namespace browserEvents {
         //% group="Mouse"
         //% weight=50
         onEvent(event: MouseButtonEvent, handler: (x: number, y: number) => void) {
-            if (event === MouseButtonEvent.Pressed) {
-                this.pressHandler = handler;
-            }
-            else {
-                this.releaseHandler = handler;
-            }
+            this.state.onEvent(event, handler);
         }
 
         //% blockId=browserEvents_mouseButton_isPressed
@@ -98,24 +121,72 @@ namespace browserEvents {
         }
 
         addEventListener(event: MouseButtonEvent, handler: (x: number, y: number) => void) {
-            if (event === MouseButtonEvent.Pressed) {
-                this.pressListeners.push(handler);
-            }
-            else {
-                this.releaseListeners.push(handler);
-            }
+            this.state.addEventListener(event, handler);
         }
 
         removeEventListener(event: MouseButtonEvent, handler: (x: number, y: number) => void) {
-            if (event === MouseButtonEvent.Pressed) {
-                this.pressListeners = this.pressListeners.filter(p => p !== handler);
+            this.state.removeEventListener(event, handler);
+        }
+    }
+
+    export class _SceneButtonHandlers<U> {
+        protected handlers: ButtonHandler<U>[];
+
+        constructor(public id: number, protected invokeHandler: (handler: U) => void) {
+            this.handlers = [];
+        }
+
+        onEvent(event: number, handler: U) {
+            this.getHandler(event, true).handler = handler;
+        }
+
+        addEventListener(event: number, handler: U) {
+            this.getHandler(event, true).listeners.push(handler);
+        }
+
+        removeEventListener(event: number, handler: U) {
+            const eventHandler = this.getHandler(event);
+
+            if (eventHandler) {
+                eventHandler.listeners = eventHandler.listeners.filter(h => h !== handler);
             }
-            else {
-                this.releaseListeners = this.releaseListeners.filter(p => p !== handler);
+        }
+
+        protected getHandler(event: number, createIfMissing?: boolean) {
+            for (const handler of this.handlers) {
+                if (handler.event === event) return handler;
             }
+
+            if (createIfMissing) {
+                const newHandler = new ButtonHandler<U>(event, this.id, this.invokeHandler);
+                this.handlers.push(newHandler);
+                return newHandler;
+            }
+
+            return undefined;
         }
     }
 
+    class ButtonHandler<U> {
+        handler: U;
+        listeners: U[] = [];
+
+        constructor(public readonly event: number, id: number, invokeHandler: (handler: U) => void) {
+            control.onEvent(event, id, () => {
+                if (this.handler) {
+                    invokeHandler(this.handler);
+                }
+                for (const listener of this.listeners) {
+                    invokeHandler(listener);
+                }
+            });
+        }
+    }
+
+    function invokeMouseHandler(handler: MouseHandler) {
+        handler(mouseX(), mouseY());
+    }
+
     //% blockId=browserEvents_onEvent
     //% block="on browser event $event"
     //% draggableParameters="reporter"
@@ -147,6 +218,14 @@ namespace browserEvents {
         });
     }
 
+    //% blockId=browserEvents_setCursorVisible
+    //% block="set cursor visible $visible"
+    //% group="Mouse"
+    //% weight=0
+    export function setCursorVisible(visible: boolean) {
+        _setCursorVisible(visible);
+    }
+
     //% fixedInstance whenUsed block="left"
     export const MouseLeft = new MouseButton(MouseButtonId.Left);
 

package/libs/browser-events/keyboard.ts

@@ -62,14 +62,29 @@ namespace browserEvents {
         ArrowRight = 39,
         PageDown = 34,
         End = 35,
-        Home = 36
+        Home = 36,
+        LeftShift = 1016,
+        RightShift = 1017,
+        LeftControl = 1018,
+        RightControl = 1019,
+        Backspace = 8,
+        Delete = 46,
     }
 
     export enum KeyEvent {
-        Pressed,
-        Released
+        //% block="pressed"
+        Pressed = 6872,
+        //% block="released"
+        Released = 6873,
+        //% block="repeat"
+        Repeat = 6874
     }
 
+    //% whenUsed
+    const INTERNAL_KEY_DOWN = 6870;
+    //% whenUsed
+    const INTERNAL_KEY_UP = 6871;
+
     export function keyToString(key: Key) {
         switch (key) {
             case Key.Q:
@@ -198,44 +213,95 @@ namespace browserEvents {
                 return "-";
             case Key.Equals:
                 return "=";
+            case Key.LeftShift:
+                return "LeftShift";
+            case Key.RightShift:
+                return "RightShift";
+            case Key.LeftControl:
+                return "LeftControl";
+            case Key.RightControl:
+                return "RightControl";
+            case Key.Backspace:
+                return "Backspace";
+            case Key.Delete:
+                return "Delete";
         }
     }
 
+    //% whenUsed
+    let _buttonsPendingInit: KeyButton[];
+
+    let defaultRepeatDelay = 500;
+    let defaultRepeatInterval = 30;
+
+    type KeyHandler = () => void;
 
     //% fixedInstances
     export class KeyButton {
         protected _pressed: boolean;
-        protected pressHandler: () => void;
-        protected pressListeners: (() => void)[];
-        protected releaseHandler: () => void;
-        protected releaseListeners: (() => void)[];
+        public repeatDelay: number;
+        public repeatInterval: number;
+        private _repeatCount: number;
+        private _pressedElapsed: number;
 
-        constructor(public id: number) {
-            control.onEvent(Event.KeyUp, this.id, () => this.setPressed(false), 16);
-            control.onEvent(Event.KeyDown, this.id, () => this.setPressed(true), 16);
+        protected sceneStack: _SceneButtonHandlers<KeyHandler>[];
+
+        protected get state(): _SceneButtonHandlers<KeyHandler> {
+            return this.sceneStack[this.sceneStack.length - 1];
+        }
 
+        constructor(public id: number) {
+            // use internalOnEvent so that events fire regardless of the current scene
+            control.internalOnEvent(INTERNAL_KEY_UP, this.id, () => this.setPressed(false), 16);
+            control.internalOnEvent(INTERNAL_KEY_DOWN, this.id, () => this.setPressed(true), 16);
             this._pressed = false;
-            this.pressListeners = [];
-            this.releaseListeners = [];
+
+            // this code may run before game/scene.ts, in which case calling this.__registerUpdate
+            // will trigger an exception. to prevent that, start a thread that pauses until we
+            // detect that an event context has been registered and then call it
+            if (control.eventContext()) {
+                this.__registerUpdate();
+            }
+            else {
+                if (!_buttonsPendingInit) {
+                    _buttonsPendingInit = [];
+                    control.runInBackground(() => {
+                        pauseUntil(() => !!control.eventContext());
+                        for (const button of _buttonsPendingInit) {
+                            button.__registerUpdate();
+                        }
+                        _buttonsPendingInit = undefined;
+                    });
+                }
+                _buttonsPendingInit.push(this);
+            }
+
+            this.sceneStack = [new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler)];
+
+            game.addScenePushHandler(() => {
+                this.sceneStack.push(new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler));
+                this.__registerUpdate();
+            });
+            game.addScenePopHandler(() => {
+                this.sceneStack.pop();
+                if (this.sceneStack.length === 0) {
+                    this.sceneStack = [new _SceneButtonHandlers<KeyHandler>(id, invokeKeyHandler)];
+                    this.__registerUpdate();
+                }
+            });
         }
 
         setPressed(pressed: boolean) {
+            if (this._pressed === pressed) return;
+
             this._pressed = pressed;
             if (pressed) {
-                if (this.pressHandler) {
-                    this.pressHandler();
-                }
-                for (const handler of this.pressListeners) {
-                    handler();
-                }
+                this._repeatCount = 0;
+                this._pressedElapsed = 0;
+                control.raiseEvent(KeyEvent.Pressed, this.id);
             }
             else {
-                if (this.releaseHandler) {
-                    this.releaseHandler();
-                }
-                for (const handler of this.releaseListeners) {
-                    handler();
-                }
+                control.raiseEvent(KeyEvent.Released, this.id);
             }
         }
 
@@ -244,12 +310,7 @@ namespace browserEvents {
         //% group="Keyboard"
         //% weight=100
         onEvent(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressHandler = handler;
-            }
-            else {
-                this.releaseHandler = handler;
-            }
+            this.state.onEvent(event, handler);
         }
 
         //% blockId=browserEvents_key_isPressed
@@ -269,22 +330,38 @@ namespace browserEvents {
         }
 
         addEventListener(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressListeners.push(handler);
-            }
-            else {
-                this.releaseListeners.push(handler);
-            }
+            this.state.addEventListener(event, handler);
         }
 
         removeEventListener(event: KeyEvent, handler: () => void) {
-            if (event === KeyEvent.Pressed) {
-                this.pressListeners = this.pressListeners.filter(p => p !== handler);
-            }
-            else {
-                this.releaseListeners = this.releaseListeners.filter(p => p !== handler);
+            this.state.removeEventListener(event, handler);
+        }
+
+        __update() {
+            const delay = this.repeatDelay === undefined ? defaultRepeatDelay : this.repeatDelay;
+            const interval = this.repeatInterval === undefined ? defaultRepeatInterval : this.repeatInterval;
+            if (!this._pressed) return;
+            this._pressedElapsed += game.eventContext().deltaTimeMillis;
+
+            // inital delay
+            if (this._pressedElapsed < delay)
+                return;
+
+            // repeat count for this step
+            const count = Math.floor((this._pressedElapsed - delay - interval) / interval);
+            if (count != this._repeatCount) {
+                this._repeatCount = count;
+                control.raiseEvent(KeyEvent.Repeat, this.id);
             }
         }
+
+        __registerUpdate() {
+            game.eventContext().registerFrameHandler(scene.CONTROLLER_PRIORITY, () => this.__update());
+        }
+    }
+
+    function invokeKeyHandler(handler: KeyHandler) {
+        handler();
     }
 
     //% fixedInstance whenUsed
@@ -476,6 +553,35 @@ namespace browserEvents {
     //% fixedInstance whenUsed
     export const Home = new KeyButton(Key.Home);
 
+    //% fixedInstance whenUsed
+    export const LeftShift = new KeyButton(Key.LeftShift);
+
+    //% fixedInstance whenUsed
+    export const RightShift = new KeyButton(Key.RightShift);
+
+    //% fixedInstance whenUsed
+    export const LeftControl = new KeyButton(Key.LeftControl);
+
+    //% fixedInstance whenUsed
+    export const RightControl = new KeyButton(Key.RightControl);
+
+    //% fixedInstance whenUsed
+    export const Backspace = new KeyButton(Key.Backspace);
+
+    //% fixedInstance whenUsed
+    export const Delete = new KeyButton(Key.Delete);
+
     //% fixedInstance whenUsed
     export const Any = new KeyButton(0);
+
+    //% blockId=browser_events_setKeyboardRepeatDefault
+    //% block="set keyboard repeat delay $delay ms interval $interval ms"
+    //% delay.defl=500
+    //% interval.defl=30
+    //% group="Keyboard"
+    //% weight=0
+    export function setKeyboardRepeatDefault(delay: number, interval: number) {
+        defaultRepeatDelay = Math.max(delay, 0);
+        defaultRepeatInterval = Math.max(interval, 1);
+    }
 }

package/libs/browser-events/shims.d.ts

@@ -9,6 +9,8 @@ declare namespace browserEvents {
     function wheelDy(): number;
     //% shim=browserEvents::wheelDz
     function wheelDz(): number;
+    //% shim=browserEvents::_setCursorVisible
+    function _setCursorVisible(visible: boolean): void;
 
     //% shim=browserEvents::currentTime
     function currentTime(): number;

package/libs/browser-events/sim/keyboard.ts

@@ -62,15 +62,44 @@ namespace pxsim.browserEvents {
         ArrowRight = 39,
         PageDown = 34,
         End = 35,
-        Home = 36
+        Home = 36,
+        LeftShift = 1016,
+        RightShift = 1017,
+        LeftControl = 1018,
+        RightControl = 1019,
+        Backspace = 8,
+        Delete = 46,
     }
 
     export function onKeyboardEvent(event: KeyboardEvent, pressed: boolean) {
+        const eventValue = getValueForKey(event);
+
+        fireEvent(eventValue as Key, pressed);
+
+        if (eventValue === Key.Shift) {
+            if (event.location === event.DOM_KEY_LOCATION_LEFT) {
+                fireEvent(Key.LeftShift, pressed);
+            }
+            else if (event.location === event.DOM_KEY_LOCATION_RIGHT) {
+                fireEvent(Key.RightShift, pressed);
+            }
+        }
+        if (eventValue === Key.Control) {
+            if (event.location === event.DOM_KEY_LOCATION_LEFT) {
+                fireEvent(Key.LeftControl, pressed);
+            }
+            else if (event.location === event.DOM_KEY_LOCATION_RIGHT) {
+                fireEvent(Key.RightControl, pressed);
+            }
+        }
+    }
+
+    function fireEvent(key: Key, pressed: boolean) {
         if (pressed) {
-            board().bus.queue(6866, getValueForKey(event));
+            board().bus.queue(INTERNAL_KEY_DOWN, key);
         }
         else {
-            board().bus.queue(6867, getValueForKey(event));
+            board().bus.queue(INTERNAL_KEY_UP, key);
         }
     }
 
@@ -249,6 +278,10 @@ namespace pxsim.browserEvents {
                 return Key.End;
             case "Home":
                 return Key.Home;
+            case "Delete":
+                return Key.Delete;
+            case "Backspace":
+                return Key.Backspace;
             default:
                 return 0;
         }

package/libs/browser-events/sim/mouseState.ts

@@ -5,6 +5,11 @@ namespace pxsim.browserEvents {
 
     const THROTTLE_INTERVAL = 50;
 
+    export const INTERNAL_KEY_DOWN = 6870;
+    export const INTERNAL_KEY_UP = 6871;
+    export const INTERNAL_POINTER_DOWN = 6868;
+    export const INTERNAL_POINTER_UP = 6869;
+
     export type MouseEvent = "pointerdown" | "pointerup" | "pointermove" | "pointerleave" | "pointerenter" | "pointercancel" | "pointerover" | "pointerout";
     export class MouseState {
         protected x: number;
@@ -43,10 +48,19 @@ namespace pxsim.browserEvents {
                 "pointerout",
             ];
 
+            let eventId = 6857 + events.indexOf(event.type);
+
+            if (event.type === "pointerdown") {
+                eventId = INTERNAL_POINTER_DOWN;
+            }
+            else if (event.type === "pointerup") {
+                eventId = INTERNAL_POINTER_UP;
+            }
+
             // We add 1 to the button here because the left button is 0 and
             // that's used as a wildcard in our event bus
             board().bus.queue(
-                6857 + events.indexOf(event.type),
+                eventId,
                 (event.button || 0) + 1
             );
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pxt-common-packages",
-  "version": "12.2.12",
+  "version": "12.2.14",
   "description": "Microsoft MakeCode (PXT) common packages",
   "keywords": [
     "MakeCode",