@pluot/core 0.1.0 → 0.1.1

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

@@ -0,0 +1,193 @@
+import { mat4, vec2 } from "gl-matrix";
+// Closure state inherited from dom-2d-camera.js (initialized elsewhere):
+//   element
+//   isPanX, isPanY, isPanXInverted, isPanYInverted
+//   isZoomX, isZoomY, isFixed, isNdc, isRotate
+//   panSpeed, zoomSpeed, rotateSpeed
+//   panOnMouseDownMove, isMouseDownMoveModActive, isLeftMousePressed
+//   width, height
+//   xAspectRatioModeFactor, yAspectRatioModeFactor
+//   xAlignmentTranslation, yAlignmentTranslation
+//   mouseX, mouseY, mouseRelX, mouseRelY, prevMouseX, prevMouseY
+//   scrollDist
+//   view (mat4), viewCenter (vec4)
+//   scaleXBounds, scaleYBounds
+//   scratch0, scratch1, scratch2 (Float32Array(16))
+//   isInteractivelyChanged, isProgrammaticallyChanged
+//   offsetXSupport = document.createEvent("MouseEvent").offsetX !== undefined
+//   onMouseMove, onWheel (user callbacks)
+function onMouseMove(event) {
+    // ---- Inlined: mouseMoveHandler ---------------------------------------
+    // Inlined: updateMouseXY(event)
+    mouseX = event.clientX;
+    mouseY = event.clientY;
+    //onMouseMove(event); // user callback
+    // ---- Inlined: tick() — pan + rotate branches -------------------------
+    // (In the original, tick() runs on each animation frame and consumes
+    // the mouseX/mouseY the mousemove handler just wrote. Inlining it here
+    // shows the full path of work triggered by a mousemove event.)
+    isInteractivelyChanged = false;
+    const currentMouseX = mouseX;
+    const currentMouseY = mouseY;
+    // ---- pan branch ------------------------------------------------------
+    if ((isPanX || isPanY) &&
+        isLeftMousePressed &&
+        ((panOnMouseDownMove && !isMouseDownMoveModActive) ||
+            (!panOnMouseDownMove && isMouseDownMoveModActive))) {
+        const dX = isPanXInverted
+            ? prevMouseX - currentMouseX
+            : currentMouseX - prevMouseX;
+        // Inlined: transformPanX(panSpeed * dX)
+        const transformedPanX = isPanX
+            ? (isNdc
+                ? ((panSpeed * dX) / width) * 2 * (1.0 / xAspectRatioModeFactor)
+                : panSpeed * dX)
+            : 0;
+        const dY = isPanYInverted
+            ? prevMouseY - currentMouseY
+            : currentMouseY - prevMouseY;
+        // Inlined: transformPanY(panSpeed * dY)
+        const transformedPanY = isPanY
+            ? (isNdc
+                ? ((panSpeed * dY) / height) * 2 * (1.0 / yAspectRatioModeFactor)
+                : -(panSpeed * dY))
+            : 0;
+        if (transformedPanX !== 0 || transformedPanY !== 0) {
+            // Inlined: camera.pan([transformedPanX, transformedPanY])
+            // — `pan` is an alias for `translate` in camera-2d-simple.
+            {
+                const x = transformedPanX;
+                const y = transformedPanY;
+                scratch0[0] = x;
+                scratch0[1] = y;
+                scratch0[2] = 0;
+                const t = mat4.fromTranslation(scratch1, scratch0);
+                // Translate about the viewport center
+                // (identical to `i * t * i * view` where `i` is the identity).
+                mat4.multiply(view, t, view);
+                // Inlined: withProgrammaticChange wrapper around camera.pan.
+                isProgrammaticallyChanged = true;
+            }
+            isInteractivelyChanged = true;
+        }
+    }
+    // ---- rotate branch ---------------------------------------------------
+    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;
+        // Inlined: camera.rotate(rotateSpeed * radians * Math.sign(cross))
+        // — from camera-2d-simple/dist/camera-2d.esm.js
+        {
+            const rad = rotateSpeed * radians * Math.sign(cross);
+            const r = mat4.create();
+            mat4.fromRotation(r, rad, [0, 0, 1]);
+            // Rotate about the viewport center
+            // (identical to `i * r * i * view` where `i` is the identity).
+            mat4.multiply(view, r, view);
+            // Inlined: withProgrammaticChange wrapper around camera.rotate.
+            isProgrammaticallyChanged = true;
+        }
+        isInteractivelyChanged = true;
+    }
+    // Inlined: tick()'s tail — advance prev mouse position, report change.
+    prevMouseX = currentMouseX;
+    prevMouseY = currentMouseY;
+    const isChanged = isInteractivelyChanged || isProgrammaticallyChanged;
+    isProgrammaticallyChanged = false;
+    return isChanged;
+}
+function onWheel(event) {
+    // ---- Inlined: wheelHandler -------------------------------------------
+    if ((isZoomX || isZoomY) && !isFixed) {
+        event.preventDefault();
+        // Inlined: updateMouseXY(event)
+        mouseX = event.clientX;
+        mouseY = event.clientY;
+        // Inlined: updateMouseRelXY(event)
+        if (offsetXSupport) {
+            mouseRelX = event.offsetX;
+            mouseRelY = event.offsetY;
+        }
+        else {
+            const bBox = element.getBoundingClientRect();
+            mouseRelX = event.clientX - bBox.left;
+            mouseRelY = event.clientY - bBox.top;
+        }
+        const deltaModeScale = event.deltaMode === 1 ? 12 : 1;
+        scrollDist += deltaModeScale * (event.deltaY || event.deltaX || 0);
+    }
+    //onWheel(event); // user callback
+    // ---- Inlined: tick() — zoom branch only ------------------------------
+    // (In the original, tick() runs on each animation frame and consumes
+    // the scrollDist that the wheel handler accumulated. Inlining it here
+    // shows the full path of work triggered by a wheel event.)
+    isInteractivelyChanged = false;
+    if ((isZoomX || isZoomY) && scrollDist) {
+        const dZ = zoomSpeed * Math.exp(scrollDist / height);
+        // Inlined: transformScaleX(mouseRelX)
+        const transformedX = isNdc
+            ? ((-1 + (mouseRelX / width) * 2) - xAlignmentTranslation) * (1.0 / xAspectRatioModeFactor)
+            : mouseRelX;
+        // Inlined: transformScaleY(mouseRelY)
+        const transformedY = isNdc
+            ? ((1 - (mouseRelY / height) * 2) - yAlignmentTranslation) * (1.0 / yAspectRatioModeFactor)
+            : mouseRelY;
+        // Inlined: camera.scale(
+        //   [isZoomX ? 1 / dZ : 1, isZoomY ? 1 / dZ : 1],
+        //   [transformedX, transformedY],
+        // )
+        // — from camera-2d-simple/dist/camera-2d.esm.js
+        {
+            const d = [isZoomX ? 1 / dZ : 1, isZoomY ? 1 / dZ : 1];
+            const mousePos = [transformedX, transformedY];
+            // const isArray = Array.isArray(d); // always true here
+            let dx = d[0];
+            let dy = d[1];
+            if (!(dx <= 0 || dy <= 0 || (dx === 1 && dy === 1))) {
+                // Inlined: getScaling() => mat4.getScaling(scratch0, view).slice(0, 2)
+                const scaling = mat4.getScaling(scratch0, view).slice(0, 2);
+                const newXScale = scaling[0] * dx;
+                const newYScale = scaling[1] * dy;
+                dx =
+                    Math.max(scaleXBounds[0], Math.min(newXScale, scaleXBounds[1])) /
+                        scaling[0];
+                dy =
+                    Math.max(scaleYBounds[0], Math.min(newYScale, scaleYBounds[1])) /
+                        scaling[1];
+                if (!(dx === 1 && dy === 1)) {
+                    scratch0[0] = dx;
+                    scratch0[1] = dy;
+                    scratch0[2] = 1;
+                    const s = mat4.fromScaling(scratch1, scratch0);
+                    const scaleCenter = mousePos ? [...mousePos, 0] : viewCenter;
+                    const a = mat4.fromTranslation(scratch0, scaleCenter);
+                    // Translate about the scale center (mouse position).
+                    mat4.multiply(view, a, mat4.multiply(view, s, mat4.multiply(view, mat4.invert(scratch2, a), view)));
+                    // Inlined: withProgrammaticChange wrapper around camera.scale.
+                    isProgrammaticallyChanged = true;
+                }
+            }
+        }
+        isInteractivelyChanged = true;
+    }
+    // Inlined: tick()'s tail — reset scroll delta and report change.
+    scrollDist = 0;
+    const isChanged = isInteractivelyChanged || isProgrammaticallyChanged;
+    isProgrammaticallyChanged = false;
+    return isChanged;
+}

package/dist-tsc/viewport.d.ts

@@ -19,6 +19,97 @@ export type Bounds = {
     yMin?: number;
     yMax?: number;
 };
+/**
+ * Calculate the visible data range based on camera view and viewport parameters.
+ *
+ * Bounds are expressed in normalized data coordinates where 0.0 is the
+ * left/top edge of the data and 1.0 is the right/bottom edge.
+ *
+ * @param cameraMatrix - The current camera matrix, typically from the renderer's
+ *   current state.
+ * @param viewportParams - Describes the canvas size, aspect-ratio handling, and
+ *   margins.
+ * @returns The visible data range as `{ xMin, xMax, yMin, yMax }` in normalized
+ *   data coordinates.
+ *
+ * @example
+ * ```ts
+ * import { getBounds } from "@pluot/core";
+ *
+ * const viewport = {
+ *   width: 800,
+ *   height: 600,
+ *   aspectRatioMode: "Contain",
+ *   aspectRatioAlignmentMode: "Center",
+ *   margins: { marginTop: 10, marginRight: 10, marginBottom: 10, marginLeft: 10 },
+ * };
+ *
+ * // Identity camera matrix (full data range visible).
+ * const identity = new Float32Array([
+ *   1, 0, 0, 0,
+ *   0, 1, 0, 0,
+ *   0, 0, 1, 0,
+ *   0, 0, 0, 1,
+ * ]);
+ *
+ * const bounds = getBounds(identity, viewport);
+ * // bounds.xMin, bounds.xMax, bounds.yMin, bounds.yMax are all in [0, 1]
+ * // for the identity matrix with "Contain" mode.
+ * ```
+ */
 export declare function getBounds(cameraMatrix: Float32Array, viewportParams: ViewportParams): Required<Bounds>;
+/**
+ * Given data bounds, compute the corresponding camera matrix.
+ * Missing bound values are filled in from `prevCameraMatrix` so partial updates
+ * (e.g. panning only the X axis) work without resetting the other axis.
+ *
+ * Bounds are expressed in normalized data coordinates where 0.0 is the
+ * left/top edge of the data and 1.0 is the right/bottom edge.
+ *
+ * @param bounds - The desired visible data range. Any omitted fields are
+ *   preserved from `prevCameraMatrix`.
+ * @param prevCameraMatrix - The current camera matrix, used to fill in any
+ *   omitted bound values. Typically the matrix returned by a previous call or
+ *   the renderer's current state.
+ * @param viewportParams - Describes the canvas size, aspect-ratio handling, and
+ *   margins so the zoom level can be computed correctly.
+ * @returns A column-major 4×4 `Float32Array` suitable for passing directly to
+ *   the renderer as the camera matrix.
+ *
+ * @example
+ * ```ts
+ * import { getCameraMatrixFromBounds } from "@pluot/core";
+ *
+ * const viewport = {
+ *   width: 800,
+ *   height: 600,
+ *   aspectRatioMode: "Contain",
+ *   aspectRatioAlignmentMode: "Center",
+ *   margins: { marginTop: 10, marginRight: 10, marginBottom: 10, marginLeft: 10 },
+ * };
+ *
+ * // Identity camera matrix (full data range visible).
+ * const identity = new Float32Array([
+ *   1, 0, 0, 0,
+ *   0, 1, 0, 0,
+ *   0, 0, 1, 0,
+ *   0, 0, 0, 1,
+ * ]);
+ *
+ * // Zoom into the top-left quadrant of the data.
+ * const cameraMatrix = getCameraMatrixFromBounds(
+ *   { xMin: 0.0, xMax: 0.5, yMin: 0.0, yMax: 0.5 },
+ *   identity,
+ *   viewport,
+ * );
+ *
+ * // Pan to shift only the X axis, keeping Y unchanged.
+ * const pannedMatrix = getCameraMatrixFromBounds(
+ *   { xMin: 0.1, xMax: 0.6 },
+ *   cameraMatrix,
+ *   viewport,
+ * );
+ * ```
+ */
 export declare function getCameraMatrixFromBounds(bounds: Bounds, prevCameraMatrix: Float32Array, viewportParams: ViewportParams): Float32Array;
 //# sourceMappingURL=viewport.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"viewport.d.ts","sourceRoot":"","sources":["../src/viewport.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AAC7D,MAAM,MAAM,wBAAwB,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAC;AAElE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,eAAe,CAAC;IACjC,wBAAwB,EAAE,wBAAwB,CAAC;IACnD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAKnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAGF,wBAAgB,SAAS,CAAC,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,CA4CtG;AAID,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,GAAG,YAAY,CAgEtI"}
+{"version":3,"file":"viewport.d.ts","sourceRoot":"","sources":["../src/viewport.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AAC7D,MAAM,MAAM,wBAAwB,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAC;AAElE,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,eAAe,CAAC;IACjC,wBAAwB,EAAE,wBAAwB,CAAC;IACnD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAKnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,SAAS,CAAC,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,CA4CtG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,GAAG,YAAY,CAgEtI"}

package/dist-tsc/viewport.js

@@ -1,4 +1,41 @@
-// Calculate the visible data range based on camera view and viewport parameters.
+/**
+ * Calculate the visible data range based on camera view and viewport parameters.
+ *
+ * Bounds are expressed in normalized data coordinates where 0.0 is the
+ * left/top edge of the data and 1.0 is the right/bottom edge.
+ *
+ * @param cameraMatrix - The current camera matrix, typically from the renderer's
+ *   current state.
+ * @param viewportParams - Describes the canvas size, aspect-ratio handling, and
+ *   margins.
+ * @returns The visible data range as `{ xMin, xMax, yMin, yMax }` in normalized
+ *   data coordinates.
+ *
+ * @example
+ * ```ts
+ * import { getBounds } from "@pluot/core";
+ *
+ * const viewport = {
+ *   width: 800,
+ *   height: 600,
+ *   aspectRatioMode: "Contain",
+ *   aspectRatioAlignmentMode: "Center",
+ *   margins: { marginTop: 10, marginRight: 10, marginBottom: 10, marginLeft: 10 },
+ * };
+ *
+ * // Identity camera matrix (full data range visible).
+ * const identity = new Float32Array([
+ *   1, 0, 0, 0,
+ *   0, 1, 0, 0,
+ *   0, 0, 1, 0,
+ *   0, 0, 0, 1,
+ * ]);
+ *
+ * const bounds = getBounds(identity, viewport);
+ * // bounds.xMin, bounds.xMax, bounds.yMin, bounds.yMax are all in [0, 1]
+ * // for the identity matrix with "Contain" mode.
+ * ```
+ */
 export function getBounds(cameraMatrix, viewportParams) {
     const zoomX = cameraMatrix[0];
     const zoomY = cameraMatrix[5];
@@ -43,8 +80,59 @@ export function getBounds(cameraMatrix, viewportParams) {
     const yMax = ((-translateY + 1.0 + yAdj + yAlignTranslation) / zoomY + 1.0) / 2.0;
     return { xMin, xMax, yMin, yMax };
 }
-// Given data bounds, compute the corresponding camera matrix.
-// Missing bound values are filled in from prevCameraMatrix.
+/**
+ * Given data bounds, compute the corresponding camera matrix.
+ * Missing bound values are filled in from `prevCameraMatrix` so partial updates
+ * (e.g. panning only the X axis) work without resetting the other axis.
+ *
+ * Bounds are expressed in normalized data coordinates where 0.0 is the
+ * left/top edge of the data and 1.0 is the right/bottom edge.
+ *
+ * @param bounds - The desired visible data range. Any omitted fields are
+ *   preserved from `prevCameraMatrix`.
+ * @param prevCameraMatrix - The current camera matrix, used to fill in any
+ *   omitted bound values. Typically the matrix returned by a previous call or
+ *   the renderer's current state.
+ * @param viewportParams - Describes the canvas size, aspect-ratio handling, and
+ *   margins so the zoom level can be computed correctly.
+ * @returns A column-major 4×4 `Float32Array` suitable for passing directly to
+ *   the renderer as the camera matrix.
+ *
+ * @example
+ * ```ts
+ * import { getCameraMatrixFromBounds } from "@pluot/core";
+ *
+ * const viewport = {
+ *   width: 800,
+ *   height: 600,
+ *   aspectRatioMode: "Contain",
+ *   aspectRatioAlignmentMode: "Center",
+ *   margins: { marginTop: 10, marginRight: 10, marginBottom: 10, marginLeft: 10 },
+ * };
+ *
+ * // Identity camera matrix (full data range visible).
+ * const identity = new Float32Array([
+ *   1, 0, 0, 0,
+ *   0, 1, 0, 0,
+ *   0, 0, 1, 0,
+ *   0, 0, 0, 1,
+ * ]);
+ *
+ * // Zoom into the top-left quadrant of the data.
+ * const cameraMatrix = getCameraMatrixFromBounds(
+ *   { xMin: 0.0, xMax: 0.5, yMin: 0.0, yMax: 0.5 },
+ *   identity,
+ *   viewport,
+ * );
+ *
+ * // Pan to shift only the X axis, keeping Y unchanged.
+ * const pannedMatrix = getCameraMatrixFromBounds(
+ *   { xMin: 0.1, xMax: 0.6 },
+ *   cameraMatrix,
+ *   viewport,
+ * );
+ * ```
+ */
 export function getCameraMatrixFromBounds(bounds, prevCameraMatrix, viewportParams) {
     // Fill in missing bounds from the previous camera matrix.
     const currentBounds = getBounds(prevCameraMatrix, viewportParams);

package/dist-tsc/viewport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=viewport.test.d.ts.map

package/dist-tsc/viewport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewport.test.d.ts","sourceRoot":"","sources":["../src/viewport.test.ts"],"names":[],"mappings":""}

package/dist-tsc/viewport.test.js

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import { getBounds, getCameraMatrixFromBounds } from './viewport.js';
+function identityCamera() {
+    return new Float32Array([
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        0, 0, 0, 1,
+    ]);
+}
+function zoomCamera(zoom) {
+    return new Float32Array([
+        zoom, 0, 0, 0,
+        0, zoom, 0, 0,
+        0, 0, 1, 0,
+        0, 0, 0, 1,
+    ]);
+}
+function zoomAndTranslateCamera(zoom, tx, ty) {
+    return new Float32Array([
+        zoom, 0, 0, 0,
+        0, zoom, 0, 0,
+        0, 0, 1, 0,
+        tx, ty, 0, 1,
+    ]);
+}
+function makeViewport(width, height, aspectRatioMode, aspectRatioAlignmentMode = 'Center') {
+    return { width, height, aspectRatioMode, aspectRatioAlignmentMode };
+}
+function expectArrayCloseTo(actual, expected, numDigits = 5) {
+    expect(actual.length).toBe(expected.length);
+    for (let i = 0; i < actual.length; i++) {
+        expect(actual[i]).toBeCloseTo(expected[i], numDigits);
+    }
+}
+// =================== getBounds ===================
+describe('getBounds', () => {
+    it('identity camera, square, Ignore → full [0, 1] range', () => {
+        const b = getBounds(identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expect(b.xMin).toBeCloseTo(0);
+        expect(b.xMax).toBeCloseTo(1);
+        expect(b.yMin).toBeCloseTo(0);
+        expect(b.yMax).toBeCloseTo(1);
+    });
+    it('2x zoom, square, Ignore → [0.25, 0.75]', () => {
+        const b = getBounds(zoomCamera(2), makeViewport(100, 100, 'Ignore'));
+        expect(b.xMin).toBeCloseTo(0.25);
+        expect(b.xMax).toBeCloseTo(0.75);
+        expect(b.yMin).toBeCloseTo(0.25);
+        expect(b.yMax).toBeCloseTo(0.75);
+    });
+    it('0.5x zoom (zoomed out 2x), square, Ignore → [-0.5, 1.5]', () => {
+        const b = getBounds(zoomCamera(0.5), makeViewport(100, 100, 'Ignore'));
+        expect(b.xMin).toBeCloseTo(-0.5);
+        expect(b.xMax).toBeCloseTo(1.5);
+        expect(b.yMin).toBeCloseTo(-0.5);
+        expect(b.yMax).toBeCloseTo(1.5);
+    });
+    it('wide (200×100), Contain → x extends to [-0.5, 1.5], y stays [0, 1]', () => {
+        const b = getBounds(identityCamera(), makeViewport(200, 100, 'Contain'));
+        expect(b.xMin).toBeCloseTo(-0.5);
+        expect(b.xMax).toBeCloseTo(1.5);
+        expect(b.yMin).toBeCloseTo(0);
+        expect(b.yMax).toBeCloseTo(1);
+    });
+    it('tall (100×200), Contain → x stays [0, 1], y extends to [-0.5, 1.5]', () => {
+        const b = getBounds(identityCamera(), makeViewport(100, 200, 'Contain'));
+        expect(b.xMin).toBeCloseTo(0);
+        expect(b.xMax).toBeCloseTo(1);
+        expect(b.yMin).toBeCloseTo(-0.5);
+        expect(b.yMax).toBeCloseTo(1.5);
+    });
+    it('wide (200×100), Cover → x stays [0, 1], y shrinks to [0.25, 0.75]', () => {
+        const b = getBounds(identityCamera(), makeViewport(200, 100, 'Cover'));
+        expect(b.xMin).toBeCloseTo(0);
+        expect(b.xMax).toBeCloseTo(1);
+        expect(b.yMin).toBeCloseTo(0.25);
+        expect(b.yMax).toBeCloseTo(0.75);
+    });
+    it('with margins, square (100×100), Ignore → [0, 1] × [0, 1]', () => {
+        const viewport = {
+            ...makeViewport(100, 100, 'Ignore'),
+            margins: { marginLeft: 20, marginBottom: 20 },
+        };
+        const b = getBounds(identityCamera(), viewport);
+        expect(b.xMin).toBeCloseTo(0);
+        expect(b.xMax).toBeCloseTo(1);
+        expect(b.yMin).toBeCloseTo(0);
+        expect(b.yMax).toBeCloseTo(1);
+    });
+});
+// =================== getCameraMatrixFromBounds ===================
+describe('getCameraMatrixFromBounds', () => {
+    it('full [0, 1] range → identity camera', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: 0, xMax: 1, yMin: 0, yMax: 1 }, identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expectArrayCloseTo(camera, identityCamera());
+    });
+    it('[0.25, 0.75] × [0.25, 0.75] → 2x zoom camera', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: 0.25, xMax: 0.75, yMin: 0.25, yMax: 0.75 }, identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expectArrayCloseTo(camera, zoomCamera(2));
+    });
+    it('[-0.5, 1.5] × [-0.5, 1.5] → 0.5x zoom (zoomed out 2x)', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: -0.5, xMax: 1.5, yMin: -0.5, yMax: 1.5 }, identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expectArrayCloseTo(camera, zoomCamera(0.5));
+    });
+    it('x-offset bounds → zoom=1, translateX=0.5, translateY=0', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: -0.25, xMax: 0.75, yMin: 0, yMax: 1 }, identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expectArrayCloseTo(camera, zoomAndTranslateCamera(1, 0.5, 0));
+    });
+    it('zoom + translation bounds → zoom=2, translateX=0.5, translateY=0.25', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: 0.125, xMax: 0.625, yMin: 0.1875, yMax: 0.6875 }, identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expectArrayCloseTo(camera, zoomAndTranslateCamera(2, 0.5, 0.25));
+    });
+    it('wide Contain bounds [-0.5, 1.5] × [0, 1] → identity camera', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: -0.5, xMax: 1.5, yMin: 0, yMax: 1 }, identityCamera(), makeViewport(200, 100, 'Contain'));
+        expectArrayCloseTo(camera, identityCamera());
+    });
+    it('tall Contain bounds [0, 1] × [-0.5, 1.5] → identity camera', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: 0, xMax: 1, yMin: -0.5, yMax: 1.5 }, identityCamera(), makeViewport(100, 200, 'Contain'));
+        expectArrayCloseTo(camera, identityCamera());
+    });
+    it('wide Cover bounds [0, 1] × [0.25, 0.75] → identity camera', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: 0, xMax: 1, yMin: 0.25, yMax: 0.75 }, identityCamera(), makeViewport(200, 100, 'Cover'));
+        expectArrayCloseTo(camera, identityCamera());
+    });
+    it('asymmetric ranges, Ignore → independent x/y zoom', () => {
+        const camera = getCameraMatrixFromBounds({ xMin: 0, xMax: 0.5, yMin: 0, yMax: 1 }, identityCamera(), makeViewport(100, 100, 'Ignore'));
+        expectArrayCloseTo(camera, new Float32Array([
+            2, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            1, 0, 0, 1,
+        ]));
+    });
+    it('partial bounds (x-axis only) preserves y from prevCameraMatrix', () => {
+        const prevCamera = zoomAndTranslateCamera(2, 0.5, 0.25);
+        const viewport = makeViewport(100, 100, 'Ignore');
+        const prevBounds = getBounds(prevCamera, viewport);
+        const camera = getCameraMatrixFromBounds({ xMin: 0, xMax: 1 }, prevCamera, viewport);
+        const newBounds = getBounds(camera, viewport);
+        expect(newBounds.xMin).toBeCloseTo(0);
+        expect(newBounds.xMax).toBeCloseTo(1);
+        expect(newBounds.yMin).toBeCloseTo(prevBounds.yMin);
+        expect(newBounds.yMax).toBeCloseTo(prevBounds.yMax);
+    });
+});
+// =================== getBounds / getCameraMatrixFromBounds roundtrip ===================
+describe('getBounds / getCameraMatrixFromBounds roundtrip', () => {
+    it('identity camera → bounds → identity camera', () => {
+        const viewport = makeViewport(100, 100, 'Ignore');
+        const bounds = getBounds(identityCamera(), viewport);
+        const camera = getCameraMatrixFromBounds(bounds, identityCamera(), viewport);
+        expectArrayCloseTo(camera, identityCamera());
+    });
+    it('2x zoom camera → bounds → 2x zoom camera', () => {
+        const viewport = makeViewport(100, 100, 'Ignore');
+        const camera0 = zoomCamera(2);
+        const bounds = getBounds(camera0, viewport);
+        const camera1 = getCameraMatrixFromBounds(bounds, identityCamera(), viewport);
+        expectArrayCloseTo(camera1, camera0);
+    });
+    it('wide Contain viewport, identity camera → bounds → identity camera', () => {
+        const viewport = makeViewport(200, 100, 'Contain');
+        const bounds = getBounds(identityCamera(), viewport);
+        const camera = getCameraMatrixFromBounds(bounds, identityCamera(), viewport);
+        expectArrayCloseTo(camera, identityCamera());
+    });
+    it('zoom + translation → bounds → same camera', () => {
+        const viewport = makeViewport(100, 100, 'Ignore');
+        const camera0 = zoomAndTranslateCamera(2, 0.5, 0.25);
+        const bounds = getBounds(camera0, viewport);
+        const camera1 = getCameraMatrixFromBounds(bounds, identityCamera(), viewport);
+        expectArrayCloseTo(camera1, camera0);
+    });
+    it('with margins, identity camera → bounds → identity camera', () => {
+        const viewport = {
+            ...makeViewport(100, 100, 'Ignore'),
+            margins: { marginLeft: 20, marginBottom: 20 },
+        };
+        const bounds = getBounds(identityCamera(), viewport);
+        const camera = getCameraMatrixFromBounds(bounds, identityCamera(), viewport);
+        expectArrayCloseTo(camera, identityCamera());
+    });
+});

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@pluot/core",
   "private": false,
-  "version": "0.1.0",
-  "description": "",
+  "version": "0.1.1",
+  "description": "Bindings to the Pluot Rust crate for data visualization",
   "license": "Apache-2.0",
+  "author": "Mark Keller",
+  "homepage": "https://pluot.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/keller-mark/pluot.git"
+  },
   "type": "module",
   "main": "dist/index.js",
   "files": [