@marimo-team/islands 0.20.1 → 0.20.2

package/dist/main.js

@@ -73400,7 +73400,7 @@ Image URL: ${r.imageUrl}`)), contextToXml({
       return Logger.warn("Failed to get version from mount config"), null;
     }
   }
-  const marimoVersionAtom = atom(getVersionFromMountConfig() || "0.20.1"), showCodeInRunModeAtom = atom(true);
+  const marimoVersionAtom = atom(getVersionFromMountConfig() || "0.20.2"), showCodeInRunModeAtom = atom(true);
   atom(null);
   var import_compiler_runtime$88 = require_compiler_runtime();
   function useKeydownOnElement(e, r) {
@@ -94128,6 +94128,10 @@ ${c}
     let d = Math.min(r.x, c.x), f = Math.max(r.x, c.x), _ = Math.min(r.y, c.y), v = Math.max(r.y, c.y);
     return e.x >= d && e.x <= f && e.y >= _ && e.y <= v;
   }
+  function isInAxes(e, r) {
+    let [c, d, f, _] = r.axesPixelBounds;
+    return e.x >= c && e.x <= f && e.y >= d && e.y <= _;
+  }
   var MatplotlibRenderer = (_k = class {
     constructor(e, r) {
       __privateAdd(this, _MatplotlibRenderer_instances);
@@ -94259,6 +94263,7 @@ ${c}
         __privateGet(this, _e8).setPointerCapture(e.pointerId), __privateGet(this, _t5).focus();
         let r = __privateGet(this, _d2).call(this, e), c = __privateGet(this, _r2);
         if (e.shiftKey) {
+          if (!isInAxes(r, __privateGet(this, _n4))) return;
           __privateSet(this, _r2, {
             type: "lasso",
             points: [
@@ -94307,7 +94312,7 @@ ${c}
           });
           return;
         }
-        __privateGet(this, _h2).call(this) && __privateGet(this, _m).call(this);
+        if (__privateGet(this, _h2).call(this) && __privateGet(this, _m).call(this), !isInAxes(r, __privateGet(this, _n4))) return;
         let d = clampToAxes(r, __privateGet(this, _n4));
         __privateSet(this, _r2, {
           type: "box",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/plugins/impl/matplotlib/__tests__/matplotlib-renderer.test.ts

@@ -3,8 +3,14 @@ import { describe, expect, it } from "vitest";
 import type { Data } from "../matplotlib-renderer";
 import { visibleForTesting } from "../matplotlib-renderer";
 
-const { pixelToData, dataToPixel, pointInPolygon, clampToAxes, isPointInBox } =
-  visibleForTesting;
+const {
+  pixelToData,
+  dataToPixel,
+  pointInPolygon,
+  clampToAxes,
+  isPointInBox,
+  isInAxes,
+} = visibleForTesting;
 
 // A simple axes geometry for testing:
 // axes occupy pixels [100, 50] to [500, 350] (400px wide, 300px tall)
@@ -150,3 +156,32 @@ describe("isPointInBox", () => {
     expect(isPointInBox({ x: 5, y: 30 }, boxEnd, boxStart)).toBe(false);
   });
 });
+
+describe("isInAxes", () => {
+  it("returns true for a point inside the axes", () => {
+    expect(isInAxes({ x: 300, y: 200 }, LINEAR_AXES)).toBe(true);
+  });
+
+  it("returns true for a point on the boundary", () => {
+    expect(isInAxes({ x: 100, y: 50 }, LINEAR_AXES)).toBe(true); // top-left
+    expect(isInAxes({ x: 500, y: 350 }, LINEAR_AXES)).toBe(true); // bottom-right
+    expect(isInAxes({ x: 100, y: 350 }, LINEAR_AXES)).toBe(true); // bottom-left
+    expect(isInAxes({ x: 500, y: 50 }, LINEAR_AXES)).toBe(true); // top-right
+  });
+
+  it("returns false for a point left of axes", () => {
+    expect(isInAxes({ x: 99, y: 200 }, LINEAR_AXES)).toBe(false);
+  });
+
+  it("returns false for a point right of axes", () => {
+    expect(isInAxes({ x: 501, y: 200 }, LINEAR_AXES)).toBe(false);
+  });
+
+  it("returns false for a point above axes", () => {
+    expect(isInAxes({ x: 300, y: 49 }, LINEAR_AXES)).toBe(false);
+  });
+
+  it("returns false for a point below axes", () => {
+    expect(isInAxes({ x: 300, y: 351 }, LINEAR_AXES)).toBe(false);
+  });
+});

package/src/plugins/impl/matplotlib/matplotlib-renderer.ts

@@ -257,6 +257,11 @@ function isPointInBox(
   return pt.x >= minX && pt.x <= maxX && pt.y >= minY && pt.y <= maxY;
 }
 
+function isInAxes(pt: PixelPoint, g: AxesGeometry): boolean {
+  const [axLeft, axTop, axRight, axBottom] = g.axesPixelBounds;
+  return pt.x >= axLeft && pt.x <= axRight && pt.y >= axTop && pt.y <= axBottom;
+}
+
 export const visibleForTesting = {
   createScale,
   pixelToData,
@@ -264,6 +269,7 @@ export const visibleForTesting = {
   pointInPolygon,
   clampToAxes,
   isPointInBox,
+  isInAxes,
 };
 
 export class MatplotlibRenderer {
@@ -568,6 +574,9 @@ export class MatplotlibRenderer {
 
     // Shift+click -> start lasso
     if (e.shiftKey) {
+      if (!isInAxes(pt, this.#state)) {
+        return;
+      }
       this.#interaction = {
         type: "lasso",
         points: [clampToAxes(pt, this.#state)],
@@ -620,7 +629,10 @@ export class MatplotlibRenderer {
       this.#clearSelection();
     }
 
-    // Start new box selection
+    // Start new box selection (only inside axes)
+    if (!isInAxes(pt, this.#state)) {
+      return;
+    }
     const clamped = clampToAxes(pt, this.#state);
     this.#interaction = {
       type: "box",