@pluot/core 0.1.0

package/dist-tsc/dom-2d-camera.js

@@ -0,0 +1,323 @@
+// License copied from https://github.com/flekschas/dom-2d-camera/blob/master/LICENSE.md
+//
+// This software is released under the MIT license:
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// Reference: https://github.com/flekschas/dom-2d-camera/blob/cd59ea035a0ea72c2c0535fa3721f8127946576c/src/index.js
+// TODO: contribute modifications back upstream once things are working.
+import { vec2 } from "gl-matrix";
+import createCamera from "camera-2d-simple";
+const MOUSE_DOWN_MOVE_ACTIONS = ["pan", "rotate"];
+const KEY_MAP = {
+    alt: "altKey",
+    cmd: "metaKey",
+    ctrl: "ctrlKey",
+    meta: "metaKey",
+    shift: "shiftKey"
+};
+const dom2dCamera = (element, { distance = 1.0, target = [0, 0], rotation = 0, isNdc = true, isFixed = false, isPan = true, isPanInverted = [false, true], panSpeed = 1, isRotate = true, rotateSpeed = 1, defaultMouseDownMoveAction = "pan", mouseDownMoveModKey = "alt", isZoom = true, zoomSpeed = 1, viewCenter, scaleBounds, translationBounds, onKeyDown = () => { }, onKeyUp = () => { }, onMouseDown = () => { }, onMouseUp = () => { }, onMouseMove = () => { }, onWheel = () => { }, aspectRatioMode = "Ignore", aspectRatioAlignmentMode = "Center", } = {}) => {
+    let camera = createCamera(target, distance, rotation, viewCenter, scaleBounds, translationBounds);
+    let mouseX = 0;
+    let mouseY = 0;
+    let mouseRelX = 0;
+    let mouseRelY = 0;
+    let prevMouseX = 0;
+    let prevMouseY = 0;
+    let isLeftMousePressed = false;
+    let scrollDist = 0;
+    let width = 1;
+    let height = 1;
+    let aspectRatio = 1;
+    let isInteractivelyChanged = false;
+    let isProgrammaticallyChanged = false;
+    let isMouseDownMoveModActive = false;
+    let panOnMouseDownMove = defaultMouseDownMoveAction === "pan";
+    let isPanX = isPan;
+    let isPanY = isPan;
+    let isPanXInverted = isPanInverted;
+    let isPanYInverted = isPanInverted;
+    let isZoomX = isZoom;
+    let isZoomY = isZoom;
+    const spreadXYSettings = () => {
+        isPanX = Array.isArray(isPan) ? Boolean(isPan[0]) : isPan;
+        isPanY = Array.isArray(isPan) ? Boolean(isPan[1]) : isPan;
+        isPanXInverted = Array.isArray(isPanInverted)
+            ? Boolean(isPanInverted[0])
+            : isPanInverted;
+        isPanYInverted = Array.isArray(isPanInverted)
+            ? Boolean(isPanInverted[1])
+            : isPanInverted;
+        isZoomX = Array.isArray(isZoom) ? Boolean(isZoom[0]) : isZoom;
+        isZoomY = Array.isArray(isZoom) ? Boolean(isZoom[1]) : isZoom;
+    };
+    spreadXYSettings();
+    let xAspectRatioModeFactor = 1.0;
+    let yAspectRatioModeFactor = 1.0;
+    let xAlignmentTranslation = 0.0;
+    let yAlignmentTranslation = 0.0;
+    /*
+      // Logic for aspect ratio handling in point_layer.wgsl
+      if (aspect_ratio_mode == 1u) {
+          // fit/contain
+          if (layer_aspect_ratio > 1.0) {
+              // Wide rectangle
+              // Show more than (0, 1) in x direction. Show exactly (0, 1) in y direction.
+              x_scale_for_aspect_ratio_mode = 1.0 / layer_aspect_ratio;
+          } else if(layer_aspect_ratio < 1.0) {
+              // Tall layer
+              // Show exactly (0, 1) in x direction. Show more than (0, 1) in y direction.
+              y_scale_for_aspect_ratio_mode = layer_aspect_ratio;
+          } else {
+              // Square layer; no change needed.
+              // Show exactly (0, 1) in both directions.
+          }
+      } else if (aspect_ratio_mode == 2u) {
+          // fill/cover
+          if(layer_aspect_ratio > 1.0) {
+              // Wide rectangle
+              // Show exactly (0, 1) in x direction. Show less than (0, 1) in y direction.
+              y_scale_for_aspect_ratio_mode = layer_aspect_ratio;
+          } else if(layer_aspect_ratio < 1.0) {
+              // Tall layer
+              // Show less than (0, 1) in x direction. Show exactly (0, 1) in y direction.
+              x_scale_for_aspect_ratio_mode = 1.0 / layer_aspect_ratio;
+          } else {
+              // Square layer; no change needed.
+              // Show exactly (0, 1) in both directions.
+          }
+      }
+    */
+    const updateAspectRatioModeFactors = () => {
+        xAspectRatioModeFactor = 1.0;
+        yAspectRatioModeFactor = 1.0;
+        if (aspectRatioMode === "Contain") {
+            if (aspectRatio > 1.0) {
+                xAspectRatioModeFactor = 1.0 / aspectRatio;
+            }
+            else if (aspectRatio < 1.0) {
+                yAspectRatioModeFactor = aspectRatio;
+            }
+        }
+        else if (aspectRatioMode === "Cover") {
+            if (aspectRatio > 1.0) {
+                yAspectRatioModeFactor = aspectRatio;
+            }
+            else if (aspectRatio < 1.0) {
+                xAspectRatioModeFactor = 1.0 / aspectRatio;
+            }
+        }
+        xAlignmentTranslation = 0.0;
+        yAlignmentTranslation = 0.0;
+        if (aspectRatioAlignmentMode === "Start") {
+            xAlignmentTranslation = xAspectRatioModeFactor - 1.0;
+            yAlignmentTranslation = yAspectRatioModeFactor - 1.0;
+        }
+        else if (aspectRatioAlignmentMode === "End") {
+            xAlignmentTranslation = 1.0 - xAspectRatioModeFactor;
+            yAlignmentTranslation = 1.0 - yAspectRatioModeFactor;
+        }
+    };
+    updateAspectRatioModeFactors();
+    const transformPanX = isNdc
+        ? dX => (dX / width) * 2 * (1.0 / xAspectRatioModeFactor) // to normalized device coords
+        : dX => dX;
+    const transformPanY = isNdc
+        ? dY => (dY / height) * 2 * (1.0 / yAspectRatioModeFactor) // to normalized device coords
+        : dY => -dY;
+    const transformScaleX = isNdc
+        ? x => ((-1 + (x / width) * 2) - xAlignmentTranslation) * (1.0 / xAspectRatioModeFactor)
+        : x => x;
+    const transformScaleY = isNdc
+        ? y => ((1 - (y / height) * 2) - yAlignmentTranslation) * (1.0 / yAspectRatioModeFactor)
+        : y => y;
+    const tick = () => {
+        if (isFixed) {
+            const isChanged = isProgrammaticallyChanged;
+            isProgrammaticallyChanged = false;
+            return isChanged;
+        }
+        isInteractivelyChanged = false;
+        const currentMouseX = mouseX;
+        const currentMouseY = mouseY;
+        if ((isPanX || isPanY) &&
+            isLeftMousePressed &&
+            ((panOnMouseDownMove && !isMouseDownMoveModActive) ||
+                (!panOnMouseDownMove && isMouseDownMoveModActive))) {
+            const dX = isPanXInverted
+                ? prevMouseX - currentMouseX
+                : currentMouseX - prevMouseX;
+            const transformedPanX = isPanX ? transformPanX(panSpeed * dX) : 0;
+            const dY = isPanYInverted
+                ? prevMouseY - currentMouseY
+                : currentMouseY - prevMouseY;
+            const transformedPanY = isPanY ? transformPanY(panSpeed * dY) : 0;
+            if (transformedPanX !== 0 || transformedPanY !== 0) {
+                camera.pan([transformedPanX, transformedPanY]);
+                isInteractivelyChanged = true;
+            }
+        }
+        if ((isZoomX || isZoomY) && scrollDist) {
+            const dZ = zoomSpeed * Math.exp(scrollDist / height);
+            const transformedX = transformScaleX(mouseRelX);
+            const transformedY = transformScaleY(mouseRelY);
+            camera.scale([isZoomX ? 1 / dZ : 1, isZoomY ? 1 / dZ : 1], [transformedX, transformedY]);
+            isInteractivelyChanged = true;
+        }
+        if (isRotate &&
+            isLeftMousePressed &&
+            ((panOnMouseDownMove && isMouseDownMoveModActive) ||
+                (!panOnMouseDownMove && !isMouseDownMoveModActive)) &&
+            Math.abs(prevMouseX - currentMouseX) +
+                Math.abs(prevMouseY - currentMouseY) >
+                0) {
+            const wh = width / 2;
+            const hh = height / 2;
+            const x1 = prevMouseX - wh;
+            const y1 = hh - prevMouseY;
+            const x2 = currentMouseX - wh;
+            const y2 = hh - currentMouseY;
+            // Angle between the start and end mouse position with respect to the
+            // viewport center
+            const radians = vec2.angle([x1, y1], [x2, y2]);
+            // Determine the orientation
+            const cross = x1 * y2 - x2 * y1;
+            camera.rotate(rotateSpeed * radians * Math.sign(cross));
+            isInteractivelyChanged = true;
+        }
+        // Reset scroll delta and mouse position
+        scrollDist = 0;
+        prevMouseX = currentMouseX;
+        prevMouseY = currentMouseY;
+        const isChanged = isInteractivelyChanged || isProgrammaticallyChanged;
+        isProgrammaticallyChanged = false;
+        return isChanged;
+    };
+    const config = ({ defaultMouseDownMoveAction: newDefaultMouseDownMoveAction = null, isFixed: newIsFixed = null, isPan: newIsPan = null, isPanInverted: newIsPanInverted = null, isRotate: newIsRotate = null, isZoom: newIsZoom = null, panSpeed: newPanSpeed = null, rotateSpeed: newRotateSpeed = null, zoomSpeed: newZoomSpeed = null, mouseDownMoveModKey: newMouseDownMoveModKey = null } = {}) => {
+        defaultMouseDownMoveAction =
+            newDefaultMouseDownMoveAction !== null &&
+                MOUSE_DOWN_MOVE_ACTIONS.includes(newDefaultMouseDownMoveAction)
+                ? newDefaultMouseDownMoveAction
+                : defaultMouseDownMoveAction;
+        panOnMouseDownMove = defaultMouseDownMoveAction === "pan";
+        isFixed = newIsFixed !== null ? newIsFixed : isFixed;
+        isPan = newIsPan !== null ? newIsPan : isPan;
+        isPanInverted =
+            newIsPanInverted !== null ? newIsPanInverted : isPanInverted;
+        isRotate = newIsRotate !== null ? newIsRotate : isRotate;
+        isZoom = newIsZoom !== null ? newIsZoom : isZoom;
+        panSpeed = +newPanSpeed > 0 ? newPanSpeed : panSpeed;
+        rotateSpeed = +newRotateSpeed > 0 ? newRotateSpeed : rotateSpeed;
+        zoomSpeed = +newZoomSpeed > 0 ? newZoomSpeed : zoomSpeed;
+        spreadXYSettings();
+        mouseDownMoveModKey =
+            newMouseDownMoveModKey !== null &&
+                Object.keys(KEY_MAP).includes(newMouseDownMoveModKey)
+                ? newMouseDownMoveModKey
+                : mouseDownMoveModKey;
+    };
+    const refresh = () => {
+        const bBox = element.getBoundingClientRect();
+        width = bBox.width;
+        height = bBox.height;
+        aspectRatio = width / height;
+        updateAspectRatioModeFactors();
+    };
+    const keyUpHandler = event => {
+        isMouseDownMoveModActive = false;
+        onKeyUp(event);
+    };
+    const keyDownHandler = event => {
+        isMouseDownMoveModActive = event[KEY_MAP[mouseDownMoveModKey]];
+        onKeyDown(event);
+    };
+    const mouseUpHandler = event => {
+        isLeftMousePressed = false;
+        onMouseUp(event);
+    };
+    const mouseDownHandler = event => {
+        isLeftMousePressed = event.buttons === 1;
+        onMouseDown(event);
+    };
+    const offsetXSupport = document.createEvent("MouseEvent").offsetX !== undefined;
+    const updateMouseRelXY = offsetXSupport
+        ? event => {
+            mouseRelX = event.offsetX;
+            mouseRelY = event.offsetY;
+        }
+        : event => {
+            const bBox = element.getBoundingClientRect();
+            mouseRelX = event.clientX - bBox.left;
+            mouseRelY = event.clientY - bBox.top;
+        };
+    const updateMouseXY = event => {
+        mouseX = event.clientX;
+        mouseY = event.clientY;
+    };
+    const mouseMoveHandler = event => {
+        updateMouseXY(event);
+        onMouseMove(event);
+    };
+    const wheelHandler = event => {
+        if ((isZoomX || isZoomY) && !isFixed) {
+            event.preventDefault();
+            updateMouseXY(event);
+            updateMouseRelXY(event);
+            const scale = event.deltaMode === 1 ? 12 : 1;
+            scrollDist += scale * (event.deltaY || event.deltaX || 0);
+        }
+        onWheel(event);
+    };
+    const dispose = () => {
+        camera = undefined;
+        element.removeEventListener("keydown", keyDownHandler);
+        element.removeEventListener("keyup", keyUpHandler);
+        element.removeEventListener("mousedown", mouseDownHandler);
+        element.removeEventListener("mouseup", mouseUpHandler);
+        element.removeEventListener("mousemove", mouseMoveHandler);
+        element.removeEventListener("wheel", wheelHandler);
+    };
+    element.addEventListener("keydown", keyDownHandler, { passive: true });
+    element.addEventListener("keyup", keyUpHandler, { passive: true });
+    element.addEventListener("mousedown", mouseDownHandler, { passive: true });
+    element.addEventListener("mouseup", mouseUpHandler, { passive: true });
+    element.addEventListener("mousemove", mouseMoveHandler, { passive: true });
+    element.addEventListener("wheel", wheelHandler, { passive: false });
+    camera.config = config;
+    camera.dispose = dispose;
+    camera.refresh = refresh;
+    camera.tick = tick;
+    const withProgrammaticChange = fn => function () {
+        fn.apply(null, arguments);
+        isProgrammaticallyChanged = true;
+    };
+    camera.lookAt = withProgrammaticChange(camera.lookAt);
+    camera.translate = withProgrammaticChange(camera.translate);
+    camera.pan = withProgrammaticChange(camera.pan);
+    camera.rotate = withProgrammaticChange(camera.rotate);
+    camera.scale = withProgrammaticChange(camera.scale);
+    camera.zoom = withProgrammaticChange(camera.zoom);
+    camera.reset = withProgrammaticChange(camera.reset);
+    camera.set = withProgrammaticChange(camera.set);
+    camera.setScaleBounds = withProgrammaticChange(camera.setScaleBounds);
+    camera.setTranslationBounds = withProgrammaticChange(camera.setTranslationBounds);
+    camera.setView = withProgrammaticChange(camera.setView);
+    camera.setViewCenter = withProgrammaticChange(camera.setViewCenter);
+    refresh();
+    return camera;
+};
+export default dom2dCamera;

package/dist-tsc/feature-detection.d.ts

@@ -0,0 +1,2 @@
+export declare function checkWebGpuFeatureDetection(): [boolean, string | null];
+//# sourceMappingURL=feature-detection.d.ts.map

package/dist-tsc/feature-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-detection.d.ts","sourceRoot":"","sources":["../src/feature-detection.ts"],"names":[],"mappings":"AAGA,wBAAgB,2BAA2B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC,CAqDpE"}

package/dist-tsc/feature-detection.js

@@ -0,0 +1,58 @@
+import UserAgent from "lightua";
+// Returns the tuple [supportsWebGpu, supportsWebGpuMessage]
+export function checkWebGpuFeatureDetection() {
+    const isSupported = typeof navigator !== 'undefined' && navigator.gpu;
+    if (isSupported) {
+        return [true, null];
+    }
+    const ua = UserAgent.parse(navigator.userAgent);
+    // WebGPU is supported in the following cases:
+    // - Browser Engine: Chromium. Major: 113+. OS: mac, windows, chromeOS
+    // - Browser Engine: Chromium. Major: 121+. OS: android
+    // - Browser Engine: Chromium. Major: 144+. OS: linux
+    // - Browser: Firefox. Major: 141+. OS: windows
+    // - Browser: Firefox. Major: 145+. OS: macos
+    // - Browser: Safari. Major: 26+. OS: macOS. OS version: tahoe 26+.
+    // - Browser: Safari. Major: 26+. OS: iOS/iPadOS. OS version: tahoe 26+.
+    // Else: suggest upgrading browser version or OS version (if different version of same browser has support)
+    // Else: suggest using different browser version.
+    const browserName = ua.browser.name;
+    const browserMajor = ua.browser.major;
+    const osName = ua.os.name;
+    const osVersion = ua.os.version;
+    // Should be supported according to UA but support wasn't detected.
+    const shouldSupportResult = [false, `WebGPU support was not detected. Please ensure the WebGPU feature is enabled or try a different browser.`];
+    if (["Chrome", "Chromium"].includes(browserName)) {
+        if (["Windows", "macOS", "ChromeOS"].includes(osName)) {
+            if (browserMajor < 113) {
+                return [false, `WebGPU is not supported in your web browser. If using Chrome or a Chromium-based browser on Windows/macOS/ChromeOS, WebGPU is supported in browser versions 113 and above.`];
+            }
+        }
+        else if (osName === "Android") {
+            if (browserMajor < 121) {
+                return [false, `WebGPU is not supported in your web browser. If using Chrome or a Chromium-based browser on Android, WebGPU is supported in browser versions 121 and above.`];
+            }
+        }
+        else if (osName === "Linux") {
+            if (browserMajor < 144) {
+                return [false, `WebGPU is not supported in your web browser. If using Chrome or a Chromium-based browser on Linux, WebGPU is supported in browser versions 144 and above.`];
+            }
+        }
+    }
+    else if (browserName === "Firefox") {
+        if (osName === "Windows") {
+            if (browserMajor < 141) {
+                return [false, `WebGPU is not supported in your web browser. If using Firefox on Windows, WebGPU is supported in browser versions 141 and above.`];
+            }
+        }
+    }
+    else if (browserName === "Safari") {
+        if (["macOS", "iOS"].includes(osName)) {
+            const osVersionFloat = parseFloat(osVersion);
+            if (browserMajor < 26 || osVersionFloat < 26) {
+                return [false, `WebGPU is not supported in your web browser. If using Safari, WebGPU is supported in Safari version 26 and above on macOS 26 (Tahoe) and above.`];
+            }
+        }
+    }
+    return shouldSupportResult;
+}

package/dist-tsc/functional-2d-camera.d.ts

@@ -0,0 +1,9 @@
+import { ViewportParams } from './viewport.js';
+export type CameraMatrix = Float32Array;
+export declare function onWheel(viewportParams: ViewportParams, prevCameraMatrix: CameraMatrix, event: WheelEvent): CameraMatrix;
+export declare function onMouseMove(viewportParams: ViewportParams, prevCameraMatrix: CameraMatrix, event: MouseEvent): CameraMatrix;
+export declare function onMouseDown(_viewportParams: ViewportParams, prevCameraMatrix: CameraMatrix, _event: MouseEvent): CameraMatrix;
+export declare function onMouseUp(_viewportParams: ViewportParams, prevCameraMatrix: CameraMatrix, _event: MouseEvent): CameraMatrix;
+export declare function onKeyDown(_viewportParams: ViewportParams, prevCameraMatrix: CameraMatrix, _event: KeyboardEvent): CameraMatrix;
+export declare function onKeyUp(_viewportParams: ViewportParams, prevCameraMatrix: CameraMatrix, _event: KeyboardEvent): CameraMatrix;
+//# sourceMappingURL=functional-2d-camera.d.ts.map

package/dist-tsc/functional-2d-camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functional-2d-camera.d.ts","sourceRoot":"","sources":["../src/functional-2d-camera.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC;AAsGxC,wBAAgB,OAAO,CAAC,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,YAAY,CA6BvH;AAED,wBAAgB,WAAW,CAAC,cAAc,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,YAAY,CA2D3H;AAMD,wBAAgB,WAAW,CAAC,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,GAAG,YAAY,CAE7H;AAED,wBAAgB,SAAS,CAAC,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,GAAG,YAAY,CAE3H;AAED,wBAAgB,SAAS,CAAC,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,GAAG,YAAY,CAE9H;AAED,wBAAgB,OAAO,CAAC,eAAe,EAAE,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,GAAG,YAAY,CAE5H"}

package/dist-tsc/functional-2d-camera.js

@@ -0,0 +1,178 @@
+// Functional version of `dom-2d-camera`.
+// Each event handler accepts viewportParams, the previous camera matrix, and the event object,
+// then returns the next camera matrix. No global camera object or tick function required.
+import { mat4, vec2 } from 'gl-matrix';
+// Camera configuration constants (matching dom-2d-camera defaults)
+const isFixed = false;
+const isNdc = true;
+const isPan = true;
+const isPanInverted = [false, true];
+const panSpeed = 1;
+const isRotate = true;
+const rotateSpeed = 1;
+const defaultMouseDownMoveAction = "pan";
+const mouseDownMoveModKey = "alt";
+const isZoom = true;
+const zoomSpeed = 1;
+// Derived settings
+const isPanX = Array.isArray(isPan) ? Boolean(isPan[0]) : Boolean(isPan);
+const isPanY = Array.isArray(isPan) ? Boolean(isPan[1]) : Boolean(isPan);
+const isPanXInverted = Array.isArray(isPanInverted) ? Boolean(isPanInverted[0]) : Boolean(isPanInverted);
+const isPanYInverted = Array.isArray(isPanInverted) ? Boolean(isPanInverted[1]) : Boolean(isPanInverted);
+const isZoomX = Array.isArray(isZoom) ? Boolean(isZoom[0]) : Boolean(isZoom);
+const isZoomY = Array.isArray(isZoom) ? Boolean(isZoom[1]) : Boolean(isZoom);
+const panOnMouseDownMove = defaultMouseDownMoveAction === "pan";
+const KEY_MAP = {
+    alt: "altKey",
+    cmd: "metaKey",
+    ctrl: "ctrlKey",
+    meta: "metaKey",
+    shift: "shiftKey",
+};
+// --- Aspect ratio helpers ---
+function computeAspectRatioFactors(vp) {
+    const aspectRatio = vp.width / vp.height;
+    let xFactor = 1.0;
+    let yFactor = 1.0;
+    if (vp.aspectRatioMode === "Contain") {
+        if (aspectRatio > 1.0)
+            xFactor = 1.0 / aspectRatio;
+        else if (aspectRatio < 1.0)
+            yFactor = aspectRatio;
+    }
+    else if (vp.aspectRatioMode === "Cover") {
+        if (aspectRatio > 1.0)
+            yFactor = aspectRatio;
+        else if (aspectRatio < 1.0)
+            xFactor = 1.0 / aspectRatio;
+    }
+    let xAlignTranslation = 0.0;
+    let yAlignTranslation = 0.0;
+    if (vp.aspectRatioAlignmentMode === "Start") {
+        xAlignTranslation = xFactor - 1.0;
+        yAlignTranslation = yFactor - 1.0;
+    }
+    else if (vp.aspectRatioAlignmentMode === "End") {
+        xAlignTranslation = 1.0 - xFactor;
+        yAlignTranslation = 1.0 - yFactor;
+    }
+    return { xFactor, yFactor, xAlignTranslation, yAlignTranslation };
+}
+// --- Matrix operation helpers (pure, no mutation of input) ---
+function applyTranslate(view, dx, dy) {
+    const t = mat4.create();
+    mat4.fromTranslation(t, [dx, dy, 0]);
+    const result = mat4.create();
+    mat4.multiply(result, t, view);
+    return result;
+}
+function applyScale(view, sx, sy, cx, cy) {
+    // Replicate camera-2d-simple's scale: view = a * s * inv(a) * view
+    // where a = translate to scale center, s = scale matrix
+    const s = mat4.create();
+    mat4.fromScaling(s, [sx, sy, 1]);
+    const a = mat4.create();
+    mat4.fromTranslation(a, [cx, cy, 0]);
+    const aInv = mat4.create();
+    mat4.invert(aInv, a);
+    const temp1 = mat4.create();
+    mat4.multiply(temp1, aInv, view); // inv(a) * view
+    const temp2 = mat4.create();
+    mat4.multiply(temp2, s, temp1); // s * inv(a) * view
+    const result = mat4.create();
+    mat4.multiply(result, a, temp2); // a * s * inv(a) * view
+    return result;
+}
+function applyRotate(view, rad) {
+    const r = mat4.create();
+    mat4.fromRotation(r, rad, [0, 0, 1]);
+    const result = mat4.create();
+    mat4.multiply(result, r, view);
+    return result;
+}
+// --- Event handlers ---
+export function onWheel(viewportParams, prevCameraMatrix, event) {
+    if (isFixed || (!isZoomX && !isZoomY))
+        return prevCameraMatrix;
+    const { width, height } = viewportParams;
+    const { xFactor, yFactor, xAlignTranslation, yAlignTranslation } = computeAspectRatioFactors(viewportParams);
+    const scaleFactor = event.deltaMode === 1 ? 12 : 1;
+    const scrollDist = scaleFactor * (event.deltaY || event.deltaX || 0);
+    if (scrollDist === 0)
+        return prevCameraMatrix;
+    const dZ = zoomSpeed * Math.exp(scrollDist / height);
+    // Transform mouse position to camera space
+    const mouseRelX = event.offsetX;
+    const mouseRelY = event.offsetY;
+    const transformedX = isNdc
+        ? ((-1 + (mouseRelX / width) * 2) - xAlignTranslation) * (1.0 / xFactor)
+        : mouseRelX;
+    const transformedY = isNdc
+        ? ((1 - (mouseRelY / height) * 2) - yAlignTranslation) * (1.0 / yFactor)
+        : mouseRelY;
+    return applyScale(prevCameraMatrix, isZoomX ? 1 / dZ : 1, isZoomY ? 1 / dZ : 1, transformedX, transformedY);
+}
+export function onMouseMove(viewportParams, prevCameraMatrix, event) {
+    if (isFixed)
+        return prevCameraMatrix;
+    const isLeftMousePressed = (event.buttons & 1) !== 0;
+    if (!isLeftMousePressed)
+        return prevCameraMatrix;
+    const modKey = KEY_MAP[mouseDownMoveModKey];
+    const isMouseDownMoveModActive = Boolean(modKey && event[modKey]);
+    const { width, height } = viewportParams;
+    const { xFactor, yFactor } = computeAspectRatioFactors(viewportParams);
+    // Pan (uses event.movementX/Y for the pixel delta since last mousemove)
+    if ((isPanX || isPanY) &&
+        ((panOnMouseDownMove && !isMouseDownMoveModActive) ||
+            (!panOnMouseDownMove && isMouseDownMoveModActive))) {
+        const rawDX = isPanXInverted ? -event.movementX : event.movementX;
+        const rawDY = isPanYInverted ? -event.movementY : event.movementY;
+        const transformedPanX = isPanX
+            ? (isNdc ? (rawDX / width) * 2 * (1.0 / xFactor) : rawDX) * panSpeed
+            : 0;
+        const transformedPanY = isPanY
+            ? (isNdc ? (rawDY / height) * 2 * (1.0 / yFactor) : -rawDY) * panSpeed
+            : 0;
+        if (transformedPanX !== 0 || transformedPanY !== 0) {
+            return applyTranslate(prevCameraMatrix, transformedPanX, transformedPanY);
+        }
+    }
+    // Rotate
+    if (isRotate &&
+        ((panOnMouseDownMove && isMouseDownMoveModActive) ||
+            (!panOnMouseDownMove && !isMouseDownMoveModActive))) {
+        const wh = width / 2;
+        const hh = height / 2;
+        // Derive previous position from current + movementX/Y
+        const currentX = event.offsetX;
+        const currentY = event.offsetY;
+        const prevX = currentX - event.movementX;
+        const prevY = currentY - event.movementY;
+        const x1 = prevX - wh;
+        const y1 = hh - prevY;
+        const x2 = currentX - wh;
+        const y2 = hh - currentY;
+        if (Math.abs(x1 - x2) + Math.abs(y1 - y2) > 0) {
+            const radians = vec2.angle([x1, y1], [x2, y2]);
+            const cross = x1 * y2 - x2 * y1;
+            return applyRotate(prevCameraMatrix, rotateSpeed * radians * Math.sign(cross));
+        }
+    }
+    return prevCameraMatrix;
+}
+// These handlers don't modify the camera matrix in the functional approach.
+// Button state is read from event.buttons in onMouseMove; modifier key state
+// is read from event.altKey/etc. in onMouseMove.
+export function onMouseDown(_viewportParams, prevCameraMatrix, _event) {
+    return prevCameraMatrix;
+}
+export function onMouseUp(_viewportParams, prevCameraMatrix, _event) {
+    return prevCameraMatrix;
+}
+export function onKeyDown(_viewportParams, prevCameraMatrix, _event) {
+    return prevCameraMatrix;
+}
+export function onKeyUp(_viewportParams, prevCameraMatrix, _event) {
+    return prevCameraMatrix;
+}

package/dist-tsc/index.d.ts

@@ -0,0 +1,6 @@
+export { initialize, getIsWasmReady, render_wasm, pick_wasm, setStore, setStoreByName, getStore, } from './core.js';
+export { default as create2dCamera } from "./dom-2d-camera.js";
+export { default as create3dCamera } from "./3d-view-controls.js";
+export { checkWebGpuFeatureDetection } from './feature-detection.js';
+export { getBounds, getCameraMatrixFromBounds } from './viewport.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-tsc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,cAAc,EACd,WAAW,EACX,SAAS,EACT,QAAQ,EACR,cAAc,EACd,QAAQ,GACT,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC"}

package/dist-tsc/index.js

@@ -0,0 +1,5 @@
+export { initialize, getIsWasmReady, render_wasm, pick_wasm, setStore, setStoreByName, getStore, } from './core.js';
+export { default as create2dCamera } from "./dom-2d-camera.js";
+export { default as create3dCamera } from "./3d-view-controls.js";
+export { checkWebGpuFeatureDetection } from './feature-detection.js';
+export { getBounds, getCameraMatrixFromBounds } from './viewport.js';

package/dist-tsc/lru-store.d.ts

@@ -0,0 +1,13 @@
+import type { AsyncReadable } from 'zarrita';
+export declare function createGetRange<S extends AsyncReadable>(store: S): (...args: Parameters<NonNullable<S["getRange"]>>) => Promise<Uint8Array | undefined>;
+export declare class LruStore<S extends AsyncReadable> implements AsyncReadable {
+    #private;
+    constructor(store: S, maxSize?: number);
+    get(...args: Parameters<S["get"]>): Promise<Uint8Array | undefined>;
+    getPeek(...args: Parameters<S["get"]>): 'pending' | 'fulfilled' | 'rejected' | undefined;
+    getRange(...args: Parameters<NonNullable<S["getRange"]>>): Promise<Uint8Array | undefined>;
+    getRangePeek(...args: Parameters<NonNullable<S["getRange"]>>): 'pending' | 'fulfilled' | 'rejected' | undefined;
+    clearCache(): void;
+}
+export declare function lru(inner_store: AsyncReadable, maxSize?: number): LruStore<AsyncReadable>;
+//# sourceMappingURL=lru-store.d.ts.map

package/dist-tsc/lru-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-store.d.ts","sourceRoot":"","sources":["../src/lru-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAc,aAAa,EAAgB,MAAM,SAAS,CAAC;AAavE,wBAAgB,cAAc,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC,IAEhD,GAAG,MAAM,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAmBhG;AAID,qBAAa,QAAQ,CAAC,CAAC,SAAS,aAAa,CAAE,YAAW,aAAa;;gBASzD,KAAK,EAAE,CAAC,EAAE,OAAO,SAAM;IAW7B,GAAG,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IA8BzE,OAAO,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS;IAQlF,QAAQ,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IAmChG,YAAY,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS;IAO/G,UAAU;CAUX;AAED,wBAAgB,GAAG,CAAC,WAAW,EAAE,aAAa,EAAE,OAAO,SAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,CAEtF"}