@svgrid/grid 1.0.2 → 1.1.0

package/src/named-views.coverage.test.ts

@@ -0,0 +1,210 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import {
+  attachAutoSavedView,
+  createNamedViews,
+  localStorageViews,
+  memoryViews,
+  type ViewStorage,
+} from './named-views'
+import type { SvGridViewState } from './svgrid-wrapper.types'
+
+function fakeHost(initial: Partial<SvGridViewState> = {}) {
+  let state = { sorting: [], columnFilters: [], ...initial } as SvGridViewState
+  return {
+    getState: () => state,
+    setState: vi.fn((s: Partial<SvGridViewState>) => {
+      state = { ...state, ...s }
+    }),
+    set: (s: SvGridViewState) => {
+      state = s
+    },
+  }
+}
+
+describe('createNamedViews - list ordering and edge cases', () => {
+  it('lists views sorted by createdAt ascending', () => {
+    const store = memoryViews([
+      { name: 'late', state: {}, createdAt: 200 },
+      { name: 'early', state: {}, createdAt: 100 },
+    ])
+    const views = createNamedViews(fakeHost(), { storage: store })
+    expect(views.list().map((v) => v.name)).toEqual(['early', 'late'])
+  })
+
+  it('defaults to memory storage when none is passed', () => {
+    const views = createNamedViews(fakeHost({ sorting: [{ id: 'a', desc: true }] }))
+    views.save('only')
+    expect(views.has('only')).toBe(true)
+    expect(views.list()).toHaveLength(1)
+  })
+
+  it('rename returns false when the source name is unknown', () => {
+    const views = createNamedViews(fakeHost(), { storage: memoryViews() })
+    views.save('a')
+    expect(views.rename('missing', 'b')).toBe(false)
+    expect(views.list().map((v) => v.name)).toEqual(['a'])
+  })
+
+  it('load returns false and does not call setState for unknown name', () => {
+    const host = fakeHost()
+    const views = createNamedViews(host, { storage: memoryViews() })
+    host.setState.mockClear()
+    expect(views.load('nope')).toBe(false)
+    expect(host.setState).not.toHaveBeenCalled()
+  })
+
+  it('save captures the current host state snapshot', () => {
+    const host = fakeHost({ sorting: [{ id: 'z', desc: false }] })
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const v = views.save('snap')
+    expect(v.state).toMatchObject({ sorting: [{ id: 'z', desc: false }] })
+    expect(typeof v.createdAt).toBe('number')
+  })
+})
+
+describe('localStorageViews', () => {
+  beforeEach(() => localStorage.clear())
+  afterEach(() => localStorage.clear())
+
+  it('reads [] when the key is absent', () => {
+    const store = localStorageViews('svgrid:absent')
+    expect(store.read()).toEqual([])
+  })
+
+  it('round-trips views through localStorage', () => {
+    const store = localStorageViews('svgrid:rt')
+    const views = [{ name: 'x', state: {}, createdAt: 1 }]
+    store.write(views)
+    expect(store.read()).toEqual(views)
+    // raw JSON is actually present
+    expect(JSON.parse(localStorage.getItem('svgrid:rt')!)).toEqual(views)
+  })
+
+  it('returns [] for corrupt JSON', () => {
+    localStorage.setItem('svgrid:bad', '{not valid json')
+    expect(localStorageViews('svgrid:bad').read()).toEqual([])
+  })
+
+  it('returns [] when the stored value is not an array', () => {
+    localStorage.setItem('svgrid:obj', JSON.stringify({ foo: 'bar' }))
+    expect(localStorageViews('svgrid:obj').read()).toEqual([])
+  })
+
+  it('swallows write errors (quota / private mode)', () => {
+    const store = localStorageViews('svgrid:quota')
+    const spy = vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+      throw new DOMException('quota', 'QuotaExceededError')
+    })
+    expect(() => store.write([{ name: 'a', state: {}, createdAt: 1 }])).not.toThrow()
+    spy.mockRestore()
+  })
+
+  it('works end-to-end as a NamedViews adapter', () => {
+    const views = createNamedViews(fakeHost({ sorting: [{ id: 'p', desc: true }] }), {
+      storage: localStorageViews('svgrid:adapter'),
+    })
+    views.save('persisted')
+    const reopened = createNamedViews(fakeHost(), {
+      storage: localStorageViews('svgrid:adapter'),
+    })
+    expect(reopened.has('persisted')).toBe(true)
+    expect(reopened.load('persisted')).toBe(true)
+  })
+})
+
+describe('attachAutoSavedView', () => {
+  beforeEach(() => vi.useFakeTimers())
+  afterEach(() => vi.useRealTimers())
+
+  it('restores an existing autosave slot on attach', () => {
+    const host = fakeHost()
+    const store: ViewStorage = memoryViews([
+      { name: '__autosave', state: { sorting: [{ id: 'restored', desc: true }] }, createdAt: 1 },
+    ])
+    const views = createNamedViews(host, { storage: store })
+    const off = attachAutoSavedView(host, views)
+    expect(host.setState).toHaveBeenCalledWith(
+      expect.objectContaining({ sorting: [{ id: 'restored', desc: true }] }),
+    )
+    off()
+  })
+
+  it('skips restore when skipRestore is set', () => {
+    const host = fakeHost()
+    const store = memoryViews([{ name: '__autosave', state: { sorting: [] }, createdAt: 1 }])
+    const views = createNamedViews(host, { storage: store })
+    const off = attachAutoSavedView(host, views, { skipRestore: true })
+    expect(host.setState).not.toHaveBeenCalled()
+    off()
+  })
+
+  it('saves when the state snapshot changes after an interval', () => {
+    const host = fakeHost({ sorting: [] })
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const off = attachAutoSavedView(host, views, { intervalMs: 500 })
+    expect(views.has('__autosave')).toBe(false)
+    // mutate the host state, then let the poller tick
+    host.set({ sorting: [{ id: 'new', desc: false }], columnFilters: [] } as SvGridViewState)
+    vi.advanceTimersByTime(500)
+    expect(views.has('__autosave')).toBe(true)
+    off()
+  })
+
+  it('does not save when the snapshot is unchanged', () => {
+    const host = fakeHost({ sorting: [] })
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const saveSpy = vi.spyOn(views, 'save')
+    const off = attachAutoSavedView(host, views, { intervalMs: 300 })
+    vi.advanceTimersByTime(900) // several ticks, no state change
+    expect(saveSpy).not.toHaveBeenCalled()
+    off()
+  })
+
+  it('uses a custom slot name', () => {
+    const host = fakeHost({ sorting: [] })
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const off = attachAutoSavedView(host, views, { name: 'mySlot', intervalMs: 200 })
+    host.set({ sorting: [{ id: 'q', desc: true }], columnFilters: [] } as SvGridViewState)
+    vi.advanceTimersByTime(200)
+    expect(views.has('mySlot')).toBe(true)
+    off()
+  })
+
+  it('clamps the interval to a minimum of 100ms', () => {
+    const host = fakeHost({ sorting: [] })
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const setIntervalSpy = vi.spyOn(globalThis, 'setInterval')
+    const off = attachAutoSavedView(host, views, { intervalMs: 5 })
+    expect(setIntervalSpy).toHaveBeenCalledWith(expect.any(Function), 100)
+    off()
+    setIntervalSpy.mockRestore()
+  })
+
+  it('recovers when getState throws inside the poll loop', () => {
+    let throwing = false
+    const host = {
+      getState: () => {
+        if (throwing) throw new Error('boom')
+        return { sorting: [], columnFilters: [] } as SvGridViewState
+      },
+      setState: vi.fn(),
+    }
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const saveSpy = vi.spyOn(views, 'save')
+    const off = attachAutoSavedView(host, views, { intervalMs: 200 })
+    throwing = true
+    expect(() => vi.advanceTimersByTime(400)).not.toThrow()
+    expect(saveSpy).not.toHaveBeenCalled()
+    off()
+  })
+
+  it('detach stops the polling interval', () => {
+    const host = fakeHost({ sorting: [] })
+    const views = createNamedViews(host, { storage: memoryViews() })
+    const clearSpy = vi.spyOn(globalThis, 'clearInterval')
+    const off = attachAutoSavedView(host, views, { intervalMs: 200 })
+    off()
+    expect(clearSpy).toHaveBeenCalled()
+    clearSpy.mockRestore()
+  })
+})

package/src/named-views.ts

@@ -118,3 +118,51 @@ export function createNamedViews(
     },
   }
 }
+
+export type AutoSavedViewOptions = {
+  /** Slot name inside the NamedViews store. Default `'__autosave'`. */
+  name?: string
+  /** Sample interval in ms. Default 800. */
+  intervalMs?: number
+  /** Skip restore-on-mount (e.g. you already loaded a URL view first). */
+  skipRestore?: boolean
+}
+
+/**
+ * Attach an "always-save-current-layout" slot to a `NamedViews` manager.
+ * Restores once on attach (if a saved view exists under `name`) and
+ * polls `host.getState()` thereafter, saving when the JSON snapshot
+ * changes.
+ *
+ * Returns a `detach()` that stops polling - call it from `onDestroy`.
+ *
+ * ```ts
+ * const views = createNamedViews(api, { storage: localStorageViews('myapp:views') })
+ * const off = attachAutoSavedView(api, views)
+ * onDestroy(off)
+ * ```
+ *
+ * Distinct from a user-saved named view: the slot is a single, fixed
+ * name reserved for "what the user left the page looking at." The user
+ * can still call `views.save('Q3 review')` etc. through the same store.
+ */
+export function attachAutoSavedView(
+  host: ViewStateHost,
+  views: NamedViews,
+  opts: AutoSavedViewOptions = {},
+): () => void {
+  const name = opts.name ?? '__autosave'
+  if (!opts.skipRestore && views.has(name)) views.load(name)
+
+  const interval = Math.max(100, opts.intervalMs ?? 800)
+  let last = JSON.stringify(host.getState())
+  const handle = setInterval(() => {
+    let next: string
+    try { next = JSON.stringify(host.getState()) } catch { return }
+    if (next === last) return
+    last = next
+    views.save(name)
+  }, interval)
+
+  return () => clearInterval(handle)
+}

package/src/row-resize.test.ts

@@ -0,0 +1,369 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { rowResize } from './row-resize'
+import type { RowResizeOptions } from './row-resize'
+
+const STRIP_CLASS = 'sv-grid-row-resize-handle'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Build a host `<table>` with `rows` body rows. Each row carries the
+ *  `tr.sv-grid-row` class + a `.sv-row-gutter` cell holding a
+ *  `data-svgrid-row` marker, matching what SvGrid renders. Extra classes
+ *  let individual tests opt rows out (header / spacer / no-gutter). */
+function buildGrid(
+  specs: Array<{ rowClasses?: string[]; gutter?: boolean; rowIndex?: number }>,
+): { host: HTMLElement; rows: HTMLTableRowElement[] } {
+  const host = document.createElement('div')
+  const table = document.createElement('table')
+  const tbody = document.createElement('tbody')
+  const rows: HTMLTableRowElement[] = []
+  specs.forEach((spec, i) => {
+    const tr = document.createElement('tr')
+    tr.className = ['sv-grid-row', ...(spec.rowClasses ?? [])].join(' ')
+    const cell = document.createElement('td')
+    cell.className = 'sv-grid-cell'
+    if (spec.gutter !== false) cell.classList.add('sv-row-gutter')
+    const marker = document.createElement('span')
+    marker.setAttribute('data-svgrid-row', String(spec.rowIndex ?? i))
+    cell.appendChild(marker)
+    tr.appendChild(cell)
+    tbody.appendChild(tr)
+    rows.push(tr)
+  })
+  table.appendChild(tbody)
+  host.appendChild(table)
+  document.body.appendChild(host)
+  return { host, rows }
+}
+
+function gutterOf(tr: HTMLTableRowElement): HTMLTableCellElement {
+  return tr.querySelector<HTMLTableCellElement>('.sv-row-gutter')!
+}
+function stripOf(tr: HTMLTableRowElement): HTMLElement | null {
+  return tr.querySelector<HTMLElement>(`.${STRIP_CLASS}`)
+}
+
+/** Mock getBoundingClientRect so a TR reports a real height in jsdom
+ *  (which otherwise returns all-zero rects). */
+function mockRowHeight(tr: HTMLTableRowElement, height: number): void {
+  tr.getBoundingClientRect = () =>
+    ({ height, width: 100, top: 0, left: 0, right: 100, bottom: height, x: 0, y: 0, toJSON() {} }) as DOMRect
+}
+
+function pointer(type: string, init: Partial<PointerEvent> = {}): PointerEvent {
+  return new PointerEvent(type, { bubbles: true, cancelable: true, pointerId: 1, ...init } as PointerEventInit)
+}
+
+const hosts: HTMLElement[] = []
+function track(host: HTMLElement): HTMLElement {
+  hosts.push(host)
+  return host
+}
+
+beforeEach(() => {
+  // jsdom lacks pointer-capture methods on elements; stub them so the action's
+  // try/catch wrapped calls have something to invoke.
+  if (!HTMLElement.prototype.setPointerCapture) {
+    HTMLElement.prototype.setPointerCapture = function () {}
+  }
+  if (!HTMLElement.prototype.releasePointerCapture) {
+    HTMLElement.prototype.releasePointerCapture = function () {}
+  }
+})
+
+afterEach(() => {
+  while (hosts.length) hosts.pop()!.remove()
+  document.body.innerHTML = ''
+  document.body.style.cursor = ''
+})
+
+// ---------------------------------------------------------------------------
+// decorate()
+// ---------------------------------------------------------------------------
+
+describe('rowResize - strip injection', () => {
+  it('injects a resize strip into every gutter cell', () => {
+    const { host, rows } = buildGrid([{}, {}, {}])
+    track(host)
+    const action = rowResize(host, { onResize: vi.fn() })
+    for (const tr of rows) {
+      const strip = stripOf(tr)
+      expect(strip).not.toBeNull()
+      expect(strip!.getAttribute('role')).toBe('separator')
+      expect(strip!.getAttribute('aria-orientation')).toBe('horizontal')
+      expect(strip!.getAttribute('aria-label')).toBe('Resize row')
+      expect(strip!.style.cursor).toBe('row-resize')
+    }
+    // Gutter cells become a positioning context with visible overflow.
+    expect(gutterOf(rows[0]).style.position).toBe('relative')
+    expect(gutterOf(rows[0]).style.overflow).toBe('visible')
+    action.destroy()
+  })
+
+  it('does not double-inject a strip on re-decorate', async () => {
+    const { host, rows } = buildGrid([{}])
+    track(host)
+    const action = rowResize(host, { onResize: vi.fn() })
+    expect(rows[0].querySelectorAll(`.${STRIP_CLASS}`).length).toBe(1)
+    // Trigger the MutationObserver by appending an unrelated node.
+    gutterOf(rows[0]).appendChild(document.createElement('span'))
+    await Promise.resolve()
+    await new Promise((r) => setTimeout(r, 0))
+    expect(rows[0].querySelectorAll(`.${STRIP_CLASS}`).length).toBe(1)
+    action.destroy()
+  })
+
+  it('skips header rows, spacer rows, and rows without a gutter cell', () => {
+    const { host, rows } = buildGrid([
+      { rowClasses: ['sv-grid-header-row'] },
+      { rowClasses: ['sv-grid-row-spacer'] },
+      { gutter: false },
+      {}, // normal row gets a strip
+    ])
+    track(host)
+    const action = rowResize(host, { onResize: vi.fn() })
+    expect(stripOf(rows[0])).toBeNull()
+    expect(stripOf(rows[1])).toBeNull()
+    expect(stripOf(rows[2])).toBeNull()
+    expect(stripOf(rows[3])).not.toBeNull()
+    action.destroy()
+  })
+
+  it('does not override an already-positioned gutter cell', () => {
+    const { host, rows } = buildGrid([{}])
+    track(host)
+    gutterOf(rows[0]).style.position = 'sticky'
+    const action = rowResize(host, { onResize: vi.fn() })
+    expect(gutterOf(rows[0]).style.position).toBe('sticky')
+    action.destroy()
+  })
+
+  it('injects no strips when created disabled', () => {
+    const { host, rows } = buildGrid([{}, {}])
+    track(host)
+    const action = rowResize(host, { onResize: vi.fn(), disabled: true })
+    expect(stripOf(rows[0])).toBeNull()
+    expect(stripOf(rows[1])).toBeNull()
+    action.destroy()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Drag lifecycle
+// ---------------------------------------------------------------------------
+
+describe('rowResize - drag', () => {
+  it('reports the new height on pointerup and fires move callbacks', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 32)
+    const onResize = vi.fn()
+    const onResizeMove = vi.fn()
+    const action = rowResize(host, { onResize, onResizeMove })
+    const strip = stripOf(rows[0])!
+
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 100 }))
+    expect(strip.classList.contains('is-resizing')).toBe(true)
+    expect(document.body.style.cursor).toBe('row-resize')
+
+    // Drag down 20px -> 52.
+    window.dispatchEvent(pointer('pointermove', { clientY: 120 }))
+    expect(onResizeMove).toHaveBeenLastCalledWith(0, 52)
+    expect(rows[0].style.height).toBe('52px')
+
+    window.dispatchEvent(pointer('pointerup', { clientY: 120 }))
+    expect(onResize).toHaveBeenCalledWith(0, 52)
+    expect(strip.classList.contains('is-resizing')).toBe(false)
+    expect(document.body.style.cursor).toBe('')
+    action.destroy()
+  })
+
+  it('clamps the height to the min bound', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 32)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize, min: 24 })
+    const strip = stripOf(rows[0])!
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 100 }))
+    // Drag far up -> would be negative, clamps to 24.
+    window.dispatchEvent(pointer('pointerup', { clientY: 0 }))
+    expect(onResize).toHaveBeenCalledWith(0, 24)
+    action.destroy()
+  })
+
+  it('clamps the height to the max bound', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 32)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize, max: 50 })
+    const strip = stripOf(rows[0])!
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 100 }))
+    window.dispatchEvent(pointer('pointerup', { clientY: 1000 }))
+    expect(onResize).toHaveBeenCalledWith(0, 50)
+    action.destroy()
+  })
+
+  it('works without an onResizeMove callback (optional)', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 30)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize })
+    const strip = stripOf(rows[0])!
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 50 }))
+    expect(() => window.dispatchEvent(pointer('pointermove', { clientY: 60 }))).not.toThrow()
+    window.dispatchEvent(pointer('pointerup', { clientY: 60 }))
+    expect(onResize).toHaveBeenCalledWith(0, 40)
+    action.destroy()
+  })
+
+  it('ignores pointermove / pointerup when no drag is active', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    const onResize = vi.fn()
+    const onResizeMove = vi.fn()
+    const action = rowResize(host, { onResize, onResizeMove })
+    // No pointerdown first - listeners were only attached on down, so these
+    // shouldn't do anything even if dispatched.
+    window.dispatchEvent(pointer('pointermove', { clientY: 10 }))
+    window.dispatchEvent(pointer('pointerup', { clientY: 10 }))
+    expect(onResize).not.toHaveBeenCalled()
+    expect(onResizeMove).not.toHaveBeenCalled()
+    action.destroy()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// pointerdown guards
+// ---------------------------------------------------------------------------
+
+describe('rowResize - pointerdown guards', () => {
+  it('ignores pointerdown when disabled', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 32)
+    const onResize = vi.fn()
+    // Start enabled so a strip exists, then disable via update.
+    const action = rowResize(host, { onResize })
+    const strip = stripOf(rows[0])!
+    action.update({ onResize, disabled: true })
+    // update removes strips, but dispatch on the (now-detached) strip anyway:
+    // even if it were still in the DOM, current.disabled short-circuits.
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 10 }))
+    window.dispatchEvent(pointer('pointerup', { clientY: 50 }))
+    expect(onResize).not.toHaveBeenCalled()
+    action.destroy()
+  })
+
+  it('ignores pointerdown on a non-strip target', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize })
+    gutterOf(rows[0]).dispatchEvent(pointer('pointerdown', { clientY: 10 }))
+    expect(document.body.style.cursor).toBe('')
+    action.destroy()
+  })
+
+  it('ignores a strip whose row has a non-finite row index', () => {
+    const { host, rows } = buildGrid([{}])
+    track(host)
+    // Remove the data-svgrid-row marker so rowIndexOf returns NaN.
+    rows[0].querySelector('[data-svgrid-row]')!.removeAttribute('data-svgrid-row')
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize })
+    const strip = stripOf(rows[0])!
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 10 }))
+    expect(document.body.style.cursor).toBe('')
+    expect(strip.classList.contains('is-resizing')).toBe(false)
+    action.destroy()
+  })
+
+  it('ignores a strip not inside a tr.sv-grid-row', () => {
+    const host = track(document.createElement('div'))
+    document.body.appendChild(host)
+    // A loose strip with no matching ancestor row.
+    const strip = document.createElement('div')
+    strip.className = STRIP_CLASS
+    host.appendChild(strip)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize })
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 10 }))
+    expect(document.body.style.cursor).toBe('')
+    action.destroy()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// update() + destroy()
+// ---------------------------------------------------------------------------
+
+describe('rowResize - update + destroy', () => {
+  it('removes strips when toggled to disabled and restores when re-enabled', () => {
+    const { host, rows } = buildGrid([{}, {}])
+    track(host)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize, disabled: false })
+    expect(stripOf(rows[0])).not.toBeNull()
+
+    action.update({ onResize, disabled: true })
+    expect(stripOf(rows[0])).toBeNull()
+    expect(stripOf(rows[1])).toBeNull()
+
+    action.update({ onResize, disabled: false })
+    expect(stripOf(rows[0])).not.toBeNull()
+    action.destroy()
+  })
+
+  it('does not repaint when disabled flag is unchanged on update', () => {
+    const { host, rows } = buildGrid([{}])
+    track(host)
+    const action = rowResize(host, { onResize: vi.fn() })
+    const firstStrip = stripOf(rows[0])
+    // Same disabled value -> decorate is NOT called, strip stays the same node.
+    action.update({ onResize: vi.fn() })
+    expect(stripOf(rows[0])).toBe(firstStrip)
+    action.destroy()
+  })
+
+  it('destroy removes all strips and detaches listeners', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 32)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize })
+    expect(stripOf(rows[0])).not.toBeNull()
+
+    action.destroy()
+    expect(stripOf(rows[0])).toBeNull()
+
+    // After destroy the pointerdown listener is gone; re-create a strip
+    // manually and confirm no drag starts.
+    const strip = document.createElement('div')
+    strip.className = STRIP_CLASS
+    gutterOf(rows[0]).appendChild(strip)
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 10 }))
+    expect(document.body.style.cursor).toBe('')
+  })
+
+  it('uses default min=20 / max=320 when bounds are omitted', () => {
+    const { host, rows } = buildGrid([{ rowIndex: 0 }])
+    track(host)
+    mockRowHeight(rows[0], 100)
+    const onResize = vi.fn()
+    const action = rowResize(host, { onResize })
+    const strip = stripOf(rows[0])!
+    strip.dispatchEvent(pointer('pointerdown', { clientY: 0 }))
+    // Drag way past max -> clamps to 320.
+    window.dispatchEvent(pointer('pointermove', { clientY: 10000 }))
+    expect(rows[0].style.height).toBe('320px')
+    // Drag way below min -> clamps to 20.
+    window.dispatchEvent(pointer('pointerup', { clientY: -10000 }))
+    expect(onResize).toHaveBeenCalledWith(0, 20)
+    action.destroy()
+  })
+})