@toolbox-web/grid 0.4.1 → 0.4.2

package/lib/plugins/selection/index.js

@@ -1,12 +1,49 @@
-function w(s) {
+function x(n, e, t, s) {
+  const r = new Set(n.selected);
+  let o = n.anchor;
+  if (t === "single")
+    r.clear(), r.add(e), o = e;
+  else if (t === "multiple") {
+    const i = s.ctrlKey || s.metaKey;
+    if (s.shiftKey && n.anchor !== null) {
+      const c = Math.min(n.anchor, e), a = Math.max(n.anchor, e);
+      for (let h = c; h <= a; h++)
+        r.add(h);
+    } else i ? (r.has(e) ? r.delete(e) : r.add(e), o = e) : (r.clear(), r.add(e), o = e);
+  }
+  return { selected: r, lastSelected: e, anchor: o };
+}
+function _(n) {
+  const e = /* @__PURE__ */ new Set();
+  for (let t = 0; t < n; t++)
+    e.add(t);
+  return e;
+}
+function D(n, e) {
+  const t = [], s = [];
+  for (const r of e)
+    n.has(r) || t.push(r);
+  for (const r of n)
+    e.has(r) || s.push(r);
+  return { added: t, removed: s };
+}
+function b(n) {
+  if (!n) return -1;
+  const e = n.getAttribute("data-row");
+  if (e) return parseInt(e, 10);
+  const t = n.closest(".data-grid-row");
+  if (!t) return -1;
+  const s = t.parentElement;
   if (!s) return -1;
-  const e = s.getAttribute("data-row");
-  return e ? parseInt(e, 10) : -1;
+  const r = s.querySelectorAll(":scope > .data-grid-row");
+  for (let o = 0; o < r.length; o++)
+    if (r[o] === t) return o;
+  return -1;
 }
-function d(s) {
-  s && s.querySelectorAll(".cell-focus").forEach((e) => e.classList.remove("cell-focus"));
+function g(n) {
+  n && n.querySelectorAll(".cell-focus").forEach((e) => e.classList.remove("cell-focus"));
 }
-const R = {
+const p = {
   expand: "▶",
   collapse: "▼",
   sortAsc: "▲",
@@ -16,7 +53,7 @@ const R = {
   dragHandle: "⋮⋮",
   toolPanel: "☰"
 };
-class C {
+class y {
   /**
    * Plugin dependencies - declare other plugins this one requires.
    *
@@ -33,8 +70,11 @@ class C {
    * ```
    */
   static dependencies;
-  /** Plugin version - override in subclass if needed */
-  version = "1.0.0";
+  /**
+   * Plugin version - defaults to grid version for built-in plugins.
+   * Third-party plugins can override with their own semver.
+   */
+  version = typeof __GRID_VERSION__ < "u" ? __GRID_VERSION__ : "dev";
   /** CSS styles to inject into the grid's shadow DOM */
   styles;
   /** Custom cell renderers keyed by type name */
@@ -121,12 +161,28 @@ class C {
   emit(e, t) {
     this.grid?.dispatchEvent?.(new CustomEvent(e, { detail: t, bubbles: !0 }));
   }
+  /**
+   * Emit a cancelable custom event from the grid.
+   * @returns `true` if the event was cancelled (preventDefault called), `false` otherwise
+   */
+  emitCancelable(e, t) {
+    const s = new CustomEvent(e, { detail: t, bubbles: !0, cancelable: !0 });
+    return this.grid?.dispatchEvent?.(s), s.defaultPrevented;
+  }
   /**
    * Request a re-render of the grid.
    */
   requestRender() {
     this.grid?.requestRender?.();
   }
+  /**
+   * Request a re-render and restore focus styling afterward.
+   * Use this when a plugin action (like expand/collapse) triggers a render
+   * but needs to maintain keyboard navigation focus.
+   */
+  requestRenderWithFocus() {
+    this.grid?.requestRenderWithFocus?.();
+  }
   /**
    * Request a lightweight style update without rebuilding DOM.
    * Use this instead of requestRender() when only CSS classes need updating.
@@ -160,6 +216,19 @@ class C {
   get visibleColumns() {
     return this.grid?._visibleColumns ?? [];
   }
+  /**
+   * Get the grid as an HTMLElement for direct DOM operations.
+   * Use sparingly - prefer the typed GridElementRef API when possible.
+   *
+   * @example
+   * ```ts
+   * const width = this.gridElement.clientWidth;
+   * this.gridElement.classList.add('my-plugin-active');
+   * ```
+   */
+  get gridElement() {
+    return this.grid;
+  }
   /**
    * Get the shadow root of the grid.
    */
@@ -192,8 +261,53 @@ class C {
    */
   get gridIcons() {
     const e = this.grid?.gridConfig?.icons ?? {};
-    return { ...R, ...e };
+    return { ...p, ...e };
+  }
+  // #region Animation Helpers
+  /**
+   * Check if animations are enabled at the grid level.
+   * Respects gridConfig.animation.mode and the CSS variable set by the grid.
+   *
+   * Plugins should use this to skip animations when:
+   * - Animation mode is 'off' or `false`
+   * - User prefers reduced motion and mode is 'reduced-motion' (default)
+   *
+   * @example
+   * ```ts
+   * private get animationStyle(): 'slide' | 'fade' | false {
+   *   if (!this.isAnimationEnabled) return false;
+   *   return this.config.animation ?? 'slide';
+   * }
+   * ```
+   */
+  get isAnimationEnabled() {
+    const e = this.grid?.effectiveConfig?.animation?.mode ?? "reduced-motion";
+    if (e === !1 || e === "off") return !1;
+    if (e === !0 || e === "on") return !0;
+    const t = this.shadowRoot?.host;
+    return t ? getComputedStyle(t).getPropertyValue("--tbw-animation-enabled").trim() !== "0" : !0;
+  }
+  /**
+   * Get the animation duration in milliseconds from CSS variable.
+   * Falls back to 200ms if not set.
+   *
+   * Plugins can use this for their animation timing to stay consistent
+   * with the grid-level animation.duration setting.
+   *
+   * @example
+   * ```ts
+   * element.animate(keyframes, { duration: this.animationDuration });
+   * ```
+   */
+  get animationDuration() {
+    const e = this.shadowRoot?.host;
+    if (e) {
+      const t = getComputedStyle(e).getPropertyValue("--tbw-animation-duration").trim(), s = parseInt(t, 10);
+      if (!isNaN(s)) return s;
+    }
+    return 200;
   }
+  // #endregion
   /**
    * Resolve an icon value to string or HTMLElement.
    * Checks plugin config first, then grid-level icons, then defaults.
@@ -223,58 +337,61 @@ class C {
   }
   // #endregion
 }
-function h(s) {
+function d(n) {
+  return n.meta?.utility === !0;
+}
+function u(n) {
   return {
-    startRow: Math.min(s.startRow, s.endRow),
-    startCol: Math.min(s.startCol, s.endCol),
-    endRow: Math.max(s.startRow, s.endRow),
-    endCol: Math.max(s.startCol, s.endCol)
+    startRow: Math.min(n.startRow, n.endRow),
+    startCol: Math.min(n.startCol, n.endCol),
+    endRow: Math.max(n.startRow, n.endRow),
+    endCol: Math.max(n.startCol, n.endCol)
   };
 }
-function m(s) {
-  const e = h(s);
+function A(n) {
+  const e = u(n);
   return {
     from: { row: e.startRow, col: e.startCol },
     to: { row: e.endRow, col: e.endCol }
   };
 }
-function u(s) {
-  return s.map(m);
+function m(n) {
+  return n.map(A);
 }
-function b(s, e, t) {
-  const r = h(t);
-  return s >= r.startRow && s <= r.endRow && e >= r.startCol && e <= r.endCol;
+function v(n, e, t) {
+  const s = u(t);
+  return n >= s.startRow && n <= s.endRow && e >= s.startCol && e <= s.endCol;
 }
-function f(s, e, t) {
-  return t.some((r) => b(s, e, r));
+function R(n, e, t) {
+  return t.some((s) => v(n, e, s));
 }
-function p(s) {
-  const e = [], t = h(s);
-  for (let r = t.startRow; r <= t.endRow; r++)
-    for (let n = t.startCol; n <= t.endCol; n++)
-      e.push({ row: r, col: n });
+function S(n) {
+  const e = [], t = u(n);
+  for (let s = t.startRow; s <= t.endRow; s++)
+    for (let r = t.startCol; r <= t.endCol; r++)
+      e.push({ row: s, col: r });
   return e;
 }
-function A(s) {
+function I(n) {
   const e = /* @__PURE__ */ new Map();
-  for (const t of s)
-    for (const r of p(t))
-      e.set(`${r.row},${r.col}`, r);
+  for (const t of n)
+    for (const s of S(t))
+      e.set(`${s.row},${s.col}`, s);
   return [...e.values()];
 }
-function g(s, e) {
+function f(n, e) {
   return {
-    startRow: s.row,
-    startCol: s.col,
+    startRow: n.row,
+    startCol: n.col,
     endRow: e.row,
     endCol: e.col
   };
 }
-const y = ':host .selecting .data-grid-row>.cell{-webkit-user-select:none;user-select:none}:host .data-grid-row.row-focus{background-color:var(--tbw-focus-background, rgba(from var(--tbw-color-accent) r g b / 12%))}:host([data-selection-mode="row"]) .cell-focus{outline:none}:host .data-grid-row>.cell.selected{background-color:var(--tbw-range-selection-bg)}:host .data-grid-row>.cell.selected.top{border-top:2px solid var(--tbw-range-border-color)}:host .data-grid-row>.cell.selected.bottom{border-bottom:2px solid var(--tbw-range-border-color)}:host .data-grid-row>.cell.selected.first{border-left:2px solid var(--tbw-range-border-color)}:host .data-grid-row>.cell.selected.last{border-right:2px solid var(--tbw-range-border-color)}:host .tbw-selection-summary{font-size:13px;color:var(--tbw-color-fg-muted);white-space:nowrap}';
-function v(s, e, t) {
-  if (s === "cell" && e.selectedCell)
+const K = ':host .selecting .data-grid-row>.cell{-webkit-user-select:none;user-select:none}:host([data-has-focus]) .data-grid-row.row-focus{background-color:var(--tbw-focus-background, rgba(from var(--tbw-color-accent) r g b / 12%))}:host([data-selection-mode="row"]) .cell-focus{outline:none}:host .data-grid-row>.cell.selected{background-color:var(--tbw-range-selection-bg)}:host .data-grid-row>.cell.selected.top{border-top:2px solid var(--tbw-range-border-color)}:host .data-grid-row>.cell.selected.bottom{border-bottom:2px solid var(--tbw-range-border-color)}:host .data-grid-row>.cell.selected.first{border-left:2px solid var(--tbw-range-border-color)}:host .data-grid-row>.cell.selected.last{border-right:2px solid var(--tbw-range-border-color)}:host .tbw-selection-summary{font-size:13px;color:var(--tbw-color-fg-muted);white-space:nowrap}';
+function q(n, e, t) {
+  if (n === "cell" && e.selectedCell)
     return {
-      mode: s,
+      mode: n,
       ranges: [
         {
           from: { row: e.selectedCell.row, col: e.selectedCell.col },
@@ -282,18 +399,18 @@ function v(s, e, t) {
         }
       ]
     };
-  if (s === "row" && e.selected.size > 0) {
-    const r = [...e.selected].map((n) => ({
-      from: { row: n, col: 0 },
-      to: { row: n, col: t - 1 }
+  if (n === "row" && e.selected.size > 0) {
+    const s = [...e.selected].map((r) => ({
+      from: { row: r, col: 0 },
+      to: { row: r, col: t - 1 }
     }));
-    return { mode: s, ranges: r };
+    return { mode: n, ranges: s };
   }
-  return s === "range" && e.ranges.length > 0 ? { mode: s, ranges: u(e.ranges) } : { mode: s, ranges: [] };
+  return n === "range" && e.ranges.length > 0 ? { mode: n, ranges: m(e.ranges) } : { mode: n, ranges: [] };
 }
-class q extends C {
+class M extends y {
   name = "selection";
-  version = "1.0.0";
+  styles = K;
   get defaultConfig() {
     return {
       mode: "cell"
@@ -321,42 +438,44 @@ class q extends C {
   // #endregion
   // #region Event Handlers
   onCellClick(e) {
-    const { rowIndex: t, colIndex: r, originalEvent: n } = e, { mode: o } = this.config;
+    const { rowIndex: t, colIndex: s, originalEvent: r } = e, { mode: o } = this.config, i = this.columns[s], c = i && d(i);
     if (o === "cell")
-      return this.selectedCell = { row: t, col: r }, this.emit("selection-change", this.#e()), this.requestAfterRender(), !1;
+      return c || (this.selectedCell = { row: t, col: s }, this.emit("selection-change", this.#e()), this.requestAfterRender()), !1;
     if (o === "row")
       return this.selected.clear(), this.selected.add(t), this.lastSelected = t, this.emit("selection-change", this.#e()), this.requestAfterRender(), !1;
     if (o === "range") {
-      const c = n.shiftKey, l = n.ctrlKey || n.metaKey;
-      if (c && this.cellAnchor) {
-        const i = g(this.cellAnchor, { row: t, col: r });
-        l ? this.ranges.length > 0 ? this.ranges[this.ranges.length - 1] = i : this.ranges.push(i) : this.ranges = [i], this.activeRange = i;
-      } else if (l) {
-        const i = {
+      if (c)
+        return !1;
+      const a = r.shiftKey, h = r.ctrlKey || r.metaKey;
+      if (a && this.cellAnchor) {
+        const l = f(this.cellAnchor, { row: t, col: s });
+        h ? this.ranges.length > 0 ? this.ranges[this.ranges.length - 1] = l : this.ranges.push(l) : this.ranges = [l], this.activeRange = l;
+      } else if (h) {
+        const l = {
           startRow: t,
-          startCol: r,
+          startCol: s,
           endRow: t,
-          endCol: r
+          endCol: s
         };
-        this.ranges.push(i), this.activeRange = i, this.cellAnchor = { row: t, col: r };
+        this.ranges.push(l), this.activeRange = l, this.cellAnchor = { row: t, col: s };
       } else {
-        const i = {
+        const l = {
           startRow: t,
-          startCol: r,
+          startCol: s,
           endRow: t,
-          endCol: r
+          endCol: s
         };
-        this.ranges = [i], this.activeRange = i, this.cellAnchor = { row: t, col: r };
+        this.ranges = [l], this.activeRange = l, this.cellAnchor = { row: t, col: s };
       }
       return this.emit("selection-change", this.#e()), this.requestAfterRender(), !1;
     }
     return !1;
   }
   onKeyDown(e) {
-    const { mode: t } = this.config, n = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Tab", "Home", "End", "PageUp", "PageDown"].includes(e.key);
+    const { mode: t } = this.config, r = ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Tab", "Home", "End", "PageUp", "PageDown"].includes(e.key);
     if (e.key === "Escape")
       return t === "cell" ? this.selectedCell = null : t === "row" ? (this.selected.clear(), this.anchor = null) : t === "range" && (this.ranges = [], this.activeRange = null, this.cellAnchor = null), this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
-    if (t === "cell" && n)
+    if (t === "cell" && r)
       return queueMicrotask(() => {
         this.selectedCell = { row: this.grid._focusRow, col: this.grid._focusCol }, this.emit("selection-change", this.#e()), this.requestAfterRender();
       }), !1;
@@ -364,42 +483,50 @@ class q extends C {
       return queueMicrotask(() => {
         this.selected.clear(), this.selected.add(this.grid._focusRow), this.lastSelected = this.grid._focusRow, this.emit("selection-change", this.#e()), this.requestAfterRender();
       }), !1;
-    if (t === "range" && n) {
-      const o = e.key === "Tab", c = e.shiftKey && !o;
-      return c && !this.cellAnchor && (this.cellAnchor = { row: this.grid._focusRow, col: this.grid._focusCol }), this.pendingKeyboardUpdate = { shiftKey: c }, queueMicrotask(() => this.requestAfterRender()), !1;
+    if (t === "range" && r) {
+      const o = e.key === "Tab", i = e.shiftKey && !o;
+      return i && !this.cellAnchor && (this.cellAnchor = { row: this.grid._focusRow, col: this.grid._focusCol }), this.pendingKeyboardUpdate = { shiftKey: i }, queueMicrotask(() => this.requestAfterRender()), !1;
     }
     if (t === "range" && e.key === "a" && (e.ctrlKey || e.metaKey)) {
-      const o = this.rows.length, c = this.columns.length;
-      if (o > 0 && c > 0) {
-        const l = {
+      const o = this.rows.length, i = this.columns.length;
+      if (o > 0 && i > 0) {
+        const c = {
           startRow: 0,
           startCol: 0,
           endRow: o - 1,
-          endCol: c - 1
+          endCol: i - 1
         };
-        return this.ranges = [l], this.activeRange = l, this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
+        return this.ranges = [c], this.activeRange = c, this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
       }
     }
     return !1;
   }
   onCellMouseDown(e) {
-    if (this.config.mode !== "range" || e.rowIndex === void 0 || e.colIndex === void 0 || e.rowIndex < 0 || e.originalEvent.shiftKey && this.cellAnchor)
+    if (this.config.mode !== "range" || e.rowIndex === void 0 || e.colIndex === void 0 || e.rowIndex < 0) return;
+    const t = this.columns[e.colIndex];
+    if (t && d(t) || e.originalEvent.shiftKey && this.cellAnchor)
       return;
     this.isDragging = !0;
-    const t = e.rowIndex, r = e.colIndex;
-    this.cellAnchor = { row: t, col: r }, e.originalEvent.ctrlKey || e.originalEvent.metaKey || (this.ranges = []);
-    const o = {
-      startRow: t,
+    const s = e.rowIndex, r = e.colIndex;
+    this.cellAnchor = { row: s, col: r }, e.originalEvent.ctrlKey || e.originalEvent.metaKey || (this.ranges = []);
+    const i = {
+      startRow: s,
       startCol: r,
-      endRow: t,
+      endRow: s,
       endCol: r
     };
-    return this.ranges.push(o), this.activeRange = o, this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
+    return this.ranges.push(i), this.activeRange = i, this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
   }
   onCellMouseMove(e) {
     if (this.config.mode !== "range" || !this.isDragging || !this.cellAnchor || e.rowIndex === void 0 || e.colIndex === void 0 || e.rowIndex < 0) return;
-    const t = g(this.cellAnchor, { row: e.rowIndex, col: e.colIndex });
-    return this.ranges.length > 0 ? this.ranges[this.ranges.length - 1] = t : this.ranges.push(t), this.activeRange = t, this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
+    let t = e.colIndex;
+    const s = this.columns[t];
+    if (s && d(s)) {
+      const o = this.columns.findIndex((i) => !d(i));
+      o >= 0 && (t = o);
+    }
+    const r = f(this.cellAnchor, { row: e.rowIndex, col: t });
+    return this.ranges.length > 0 ? this.ranges[this.ranges.length - 1] = r : this.ranges.push(r), this.activeRange = r, this.emit("selection-change", this.#e()), this.requestAfterRender(), !0;
   }
   onCellMouseUp(e) {
     if (this.config.mode === "range" && this.isDragging)
@@ -416,37 +543,46 @@ class q extends C {
     e.querySelectorAll(".cell").forEach((o) => {
       o.classList.remove("selected", "top", "bottom", "first", "last");
     });
-    const n = e.querySelectorAll(".data-grid-row");
-    if (n.forEach((o) => {
+    const r = e.querySelectorAll(".data-grid-row");
+    if (r.forEach((o) => {
       o.classList.remove("selected", "row-focus");
-    }), t === "row" && (d(e), n.forEach((o) => {
-      const c = o.querySelector(".cell[data-row]"), l = w(c);
-      l >= 0 && this.selected.has(l) && o.classList.add("selected", "row-focus");
+    }), t === "row" && (g(e), r.forEach((o) => {
+      const i = o.querySelector(".cell[data-row]"), c = b(i);
+      c >= 0 && this.selected.has(c) && o.classList.add("selected", "row-focus");
     })), t === "range" && this.ranges.length > 0) {
-      d(e);
-      const o = this.activeRange ? h(this.activeRange) : null;
-      e.querySelectorAll(".cell[data-row][data-col]").forEach((l) => {
-        const i = parseInt(l.getAttribute("data-row") ?? "-1", 10), a = parseInt(l.getAttribute("data-col") ?? "-1", 10);
-        i >= 0 && a >= 0 && f(i, a, this.ranges) && (l.classList.add("selected"), o && (i === o.startRow && l.classList.add("top"), i === o.endRow && l.classList.add("bottom"), a === o.startCol && l.classList.add("first"), a === o.endCol && l.classList.add("last")));
+      g(e);
+      const o = this.activeRange ? u(this.activeRange) : null, i = this.columns.findIndex((a) => !d(a));
+      this.columns.length - 1, e.querySelectorAll(".cell[data-row][data-col]").forEach((a) => {
+        const h = parseInt(a.getAttribute("data-row") ?? "-1", 10), l = parseInt(a.getAttribute("data-col") ?? "-1", 10);
+        if (h >= 0 && l >= 0) {
+          const w = this.columns[l];
+          if (w && d(w))
+            return;
+          if (R(h, l, this.ranges) && (a.classList.add("selected"), o)) {
+            h === o.startRow && a.classList.add("top"), h === o.endRow && a.classList.add("bottom");
+            const C = Math.max(o.startCol, i);
+            l === C && a.classList.add("first"), l === o.endCol && a.classList.add("last");
+          }
+        }
       });
     }
-    t === "cell" && this.selectedCell && d(e);
+    t === "cell" && this.selectedCell && g(e);
   }
   afterRender() {
     const e = this.shadowRoot;
     if (!e) return;
-    const t = e.children[0], { mode: r } = this.config;
-    if (this.pendingKeyboardUpdate && r === "range") {
-      const { shiftKey: n } = this.pendingKeyboardUpdate;
+    const t = e.children[0], { mode: s } = this.config;
+    if (this.pendingKeyboardUpdate && s === "range") {
+      const { shiftKey: r } = this.pendingKeyboardUpdate;
       this.pendingKeyboardUpdate = null;
-      const o = this.grid._focusRow, c = this.grid._focusCol;
-      if (n && this.cellAnchor) {
-        const l = g(this.cellAnchor, { row: o, col: c });
-        this.ranges = [l], this.activeRange = l;
-      } else n || (this.ranges = [], this.activeRange = null, this.cellAnchor = { row: o, col: c });
+      const o = this.grid._focusRow, i = this.grid._focusCol;
+      if (r && this.cellAnchor) {
+        const c = f(this.cellAnchor, { row: o, col: i });
+        this.ranges = [c], this.activeRange = c;
+      } else r || (this.ranges = [], this.activeRange = null, this.cellAnchor = { row: o, col: i });
       this.emit("selection-change", this.#e());
     }
-    this.grid.setAttribute("data-selection-mode", r), t && t.classList.toggle("selecting", this.isDragging), this.#t();
+    this.grid.setAttribute("data-selection-mode", s), t && t.classList.toggle("selecting", this.isDragging), this.#t();
   }
   /**
    * Called after scroll-triggered row rendering.
@@ -457,35 +593,62 @@ class q extends C {
   }
   // #endregion
   // #region Public API
+  /**
+   * Get the current selection as a unified result.
+   * Works for all selection modes and always returns ranges.
+   *
+   * @example
+   * ```ts
+   * const selection = plugin.getSelection();
+   * if (selection.ranges.length > 0) {
+   *   const { from, to } = selection.ranges[0];
+   *   // For cell mode: from === to (single cell)
+   *   // For row mode: from.col = 0, to.col = lastCol (full row)
+   *   // For range mode: rectangular selection
+   * }
+   * ```
+   */
+  getSelection() {
+    return {
+      mode: this.config.mode,
+      ranges: this.#e().ranges,
+      anchor: this.cellAnchor
+    };
+  }
   /**
    * Get the selected cell (cell mode only).
+   * @deprecated Use `getSelection()` instead for a unified API across all modes.
    */
   getSelectedCell() {
-    return this.selectedCell;
+    const { mode: e, ranges: t } = this.getSelection();
+    return e === "cell" && t.length > 0 ? t[0].from : null;
   }
   /**
    * Get all selected row indices (row mode).
+   * @deprecated Use `getSelection().ranges` instead - each range represents a full row.
    */
   getSelectedRows() {
-    return [...this.selected];
+    const { mode: e, ranges: t } = this.getSelection();
+    return e === "row" ? t.map((s) => s.from.row) : [];
   }
   /**
    * Get all selected cell ranges in public format.
+   * @deprecated Use `getSelection().ranges` instead.
    */
   getRanges() {
-    return u(this.ranges);
+    return this.getSelection().ranges;
   }
   /**
    * Get all selected cells across all ranges.
    */
   getSelectedCells() {
-    return A(this.ranges);
+    return I(this.ranges);
   }
   /**
    * Check if a specific cell is in range selection.
    */
   isCellSelected(e, t) {
-    return f(e, t, this.ranges);
+    return R(e, t, this.ranges);
   }
   /**
    * Clear all selection.
@@ -504,13 +667,13 @@ class q extends C {
       endCol: t.to.col
     })), this.activeRange = this.ranges.length > 0 ? this.ranges[this.ranges.length - 1] : null, this.emit("selection-change", {
       mode: this.config.mode,
-      ranges: u(this.ranges)
+      ranges: m(this.ranges)
     }), this.requestAfterRender();
   }
   // #endregion
   // #region Private Helpers
   #e() {
-    return v(
+    return q(
       this.config.mode,
       {
         selectedCell: this.selectedCell,
@@ -521,43 +684,11 @@ class q extends C {
     );
   }
   // #endregion
-  // #region Styles
-  styles = y;
-  // #endregion
-}
-function S(s, e, t, r) {
-  const n = new Set(s.selected);
-  let o = s.anchor;
-  if (t === "single")
-    n.clear(), n.add(e), o = e;
-  else if (t === "multiple") {
-    const c = r.ctrlKey || r.metaKey;
-    if (r.shiftKey && s.anchor !== null) {
-      const l = Math.min(s.anchor, e), i = Math.max(s.anchor, e);
-      for (let a = l; a <= i; a++)
-        n.add(a);
-    } else c ? (n.has(e) ? n.delete(e) : n.add(e), o = e) : (n.clear(), n.add(e), o = e);
-  }
-  return { selected: n, lastSelected: e, anchor: o };
-}
-function x(s) {
-  const e = /* @__PURE__ */ new Set();
-  for (let t = 0; t < s; t++)
-    e.add(t);
-  return e;
-}
-function I(s, e) {
-  const t = [], r = [];
-  for (const n of e)
-    s.has(n) || t.push(n);
-  for (const n of s)
-    e.has(n) || r.push(n);
-  return { added: t, removed: r };
 }
 export {
-  q as SelectionPlugin,
-  I as computeSelectionDiff,
-  S as handleRowClick,
-  x as selectAll
+  M as SelectionPlugin,
+  D as computeSelectionDiff,
+  x as handleRowClick,
+  _ as selectAll
 };
 //# sourceMappingURL=index.js.map