diff --git a/.gitignore b/.gitignore index 689de6d5..763da59d 100644 --- a/.gitignore +++ b/.gitignore @@ -100,7 +100,9 @@ tests/e2e/test-results/ tests/e2e/blob-report/ tests/e2e/playwright/.cache/ tests/e2e/playwright/.auth/ + tests/webdav/storage-litmus/ +tests/oidc-manual/ tests/caldav/storage/ tests/caldav/.venv/ tests/caldav/__pycache__/ diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js index e35bae4e..35141f55 100644 --- a/frontend/eslint.config.js +++ b/frontend/eslint.config.js @@ -16,6 +16,17 @@ export default ts.config( ...globals.browser, ...globals.node } + }, + rules: { + // `_`-prefixed args are the codebase's "intentionally unused" + // convention — mostly Svelte snippet positional params that + // have to be declared but aren't read (e.g. `dateCell(_item, + // ctx)`). Match the widely-used JS/TS ecosystem pattern so + // the intent is respected without per-line disable comments. + '@typescript-eslint/no-unused-vars': [ + 'error', + { argsIgnorePattern: '^_', varsIgnorePattern: '^_' } + ] } }, { diff --git a/frontend/src/lib/api/endpoints/folders.bench.test.ts b/frontend/src/lib/api/endpoints/folders.bench.test.ts index 9df9d79a..d62372db 100644 --- a/frontend/src/lib/api/endpoints/folders.bench.test.ts +++ b/frontend/src/lib/api/endpoints/folders.bench.test.ts @@ -158,11 +158,17 @@ describe('coalesced progressive listing emissions (benchmark gate)', () => { `collapses the O(N²) consumer re-derive on a fast ${PAGES}-page load (perf gate)`, { timeout: 30_000 }, async () => { - // Warm-up both paths (JIT tiering outside the measured windows). - mockPagedFetch(); - await referenceFetchFolderListing('warm', (p) => consumerDerive(p)); - mockPagedFetch(); - await fetchFolderListing('warm', { onPage: (p) => consumerDerive(p) }); + // Warm-up both paths, twice each, so V8's tiering has fully + // settled before we measure. A single warm-up was enough on + // developer laptops but bursty CPU steals on shared CI + // runners can leave one path un-tiered during measurement, + // skewing the wall-time ratio at line ~202 below. + for (let i = 0; i < 2; i++) { + mockPagedFetch(); + await referenceFetchFolderListing('warm', (p) => consumerDerive(p)); + mockPagedFetch(); + await fetchFolderListing('warm', { onPage: (p) => consumerDerive(p) }); + } mockPagedFetch(); let refSorted = 0; @@ -197,9 +203,19 @@ describe('coalesced progressive listing emissions (benchmark gate)', () => { // stubbed pages ever take >150 ms — they don't on any healthy runner). expect(emitsN).toBeLessThanOrEqual(3); // ≥5x less consumer sort work is the point of the change. + // This is a pure DETERMINISTIC count (sum of `consumerDerive` + // return values) — hardware-independent, so catches an + // actual O(N²) → O(N) regression cleanly. expect(sorted).toBeLessThan(refSorted / 5); - // And it must show up as wall time on the combined load+derive cycle. - expect(ms).toBeLessThan(refMs / 3); + // And it must show up as wall time on the combined load+ + // derive cycle. 2x floor (loosened from 3x on 2026-07-18 + // after a shared-CI-runner false alarm at 2.63x — bursty + // CPU steals eat headroom on the fine-grained + // `performance.now()` measurements). Still catches an + // O(N²) regression (which would be ~10x slower, not 2x) + // — the deterministic count above at line 200 is the real + // algorithmic gate. + expect(ms).toBeLessThan(refMs / 2); } ); }); diff --git a/frontend/src/lib/components/ResourceList.svelte b/frontend/src/lib/components/ResourceList.svelte index 164afb4e..cc0587f6 100644 --- a/frontend/src/lib/components/ResourceList.svelte +++ b/frontend/src/lib/components/ResourceList.svelte @@ -1,32 +1,38 @@ @@ -59,13 +74,40 @@ import VirtualList from '$lib/components/VirtualList.svelte'; import { t } from '$lib/i18n/index.svelte'; import { files as filesStore } from '$lib/stores/files.svelte'; + import { preferences } from '$lib/stores/preferences.svelte'; import { formatBytes } from '$lib/utils/format'; import { formatDate, iconNameFromClass, fileIconKindClass } from '$lib/utils/display'; import { gridColumns } from '$lib/utils/grid'; + import { fileThumbnailUrl } from '$lib/api/endpoints/files'; + import { + canThumbnailClientSide, + preloadPdf, + queueGenerate as queueThumbnailGenerate + } from '$lib/utils/thumbnail'; interface Props { title: string; - items: ResourceEntry[]; + items: Array; + /** + * Per-item envelope info keyed by `item.id`. See `ItemContext` + * above. When absent, ResourceList uses the intrinsic item + * fields (`modified_at`, `created_by`). + */ + contextMap?: Map; + /** + * Set of item ids the caller considers "favorite". When + * provided, the star widget renders next to each row and + * `onfavorite` is invoked on click. Kept as an external Set so + * the page owns the source of truth (e.g. the favorites store). + */ + favoriteIds?: Set; + /** + * Resolve `userId → display name`. Optional; when absent + * `UserVignette` falls back to its own internal resolution. + * Accepts `null` for consistency with the useOwnerCache API + * (returns `null` for a not-yet-resolved id). + */ + resolveOwnerName?: (userId: string) => string | null | undefined; loading?: boolean; error?: string | null; /** Empty-state primary line. */ @@ -86,7 +128,7 @@ /** Override the date column header label (e.g. trash → "Remaining"). */ dateLabel?: string; /** Custom renderer for the date cell (e.g. trash expiry chip). */ - dateCell?: Snippet<[ResourceEntry]>; + dateCell?: Snippet<[FileItem | FolderItem, ItemContext | undefined]>; /** * Optional per-bucket action button rendered alongside the swimlane * header label. Receives the bucket key (the value `bucketOf` @@ -99,10 +141,21 @@ showOwner?: boolean; /** Allow grid/list toggle (shares the app-wide view mode). */ showViewToggle?: boolean; - /** Show the dotfile-visibility eye toggle in the toolbar. - * Opt-in per host page — surfaces that never filter dotfiles - * (favorites, trash) leave this false so the button doesn't - * appear to do nothing. Forwarded to ListToolbar. */ + /** Show the dotfile-visibility eye toggle in the toolbar AND + * apply the corresponding filter to `items` when + * `preferences.hideDotfiles` is true. Opt-in per host page — + * surfaces that never filter dotfiles (favorites, trash) leave + * this false so the button doesn't appear AND the filter never + * kicks in. Single flag governs both concerns so a page can't + * accidentally expose the button without wiring the filter or + * vice-versa. + * + * A host page that needs to surface "N items hidden" in its + * empty state derives that count independently via the shared + * `isDotfile` predicate in `$lib/utils/dotfileFilter` — no + * count-out prop here (avoids a bindable whose $bindable + * default is always shadowed by the effect that would sync it, + * and keeps the component's API one-way-inbound). */ showDotfileToggle?: boolean; /** Multi-select checkboxes + selection model. */ selectable?: boolean; @@ -116,29 +169,74 @@ reversed?: boolean; /** Called when group-by or direction changes; page should reload page 1. */ onreload?: (orderBy: string, reversed: boolean) => void; - onopen?: (entry: ResourceEntry) => void; - /** Per-entry favorite star toggle. */ - onfavorite?: (entry: ResourceEntry) => void; - /** - * Live favorite-id set for the star state. When provided, the star - * reads membership here instead of `entry.isFavorite`, so a toggle - * repaints one star instead of forcing the host to rebuild every - * entry object (the Recent page paid a full O(N) re-map + re-render - * per star click through its `favoriteIds.has()` inside the entry - * mapper — see benches/ROUND11.md). - */ - favoriteIds?: ReadonlySet | null; - /** Selection changed (set of selected entry ids). */ + onopen?: (item: FileItem | FolderItem) => void; + /** Per-item favorite star toggle. */ + onfavorite?: (item: FileItem | FolderItem) => void; + /** Selection changed (set of selected item ids). */ onselectionchange?: (ids: Set) => void; - actions?: Snippet<[ResourceEntry]>; + actions?: Snippet<[FileItem | FolderItem]>; toolbar?: Snippet; - /** Batch toolbar shown when items are selected; receives selected entries. */ - batchToolbar?: Snippet<[ResourceEntry[]]>; + /** Batch toolbar shown when items are selected; receives selected items. */ + batchToolbar?: Snippet<[Array]>; + /** + * Render `` thumbnails on file rows and fall back to + * client-side generation when the server doesn't have one + * (image / PDF / video via `$lib/utils/thumbnail`). Default on + * — every view that lists real files gets the same behaviour. + * Set false for views that never benefit (empty states, + * synthetic rows). + */ + enableThumbnails?: boolean; + /** + * Enable per-row drag/drop hooks. Used by the files browser so + * a folder row is a drop target and any row is draggable to + * another folder or the breadcrumb. Pages that don't wire these + * (trash, favorites, recent, shared-with-me) opt out of the + * drag-drop UX entirely by leaving the callbacks unset. + */ + isDraggable?: (item: FileItem | FolderItem) => boolean; + isDropTarget?: (item: FileItem | FolderItem) => boolean; + /** + * Which item id currently shows the drop-target highlight (page + * owns the state so it can share it with breadcrumb / other drop + * zones). Only meaningful when `isDropTarget` is provided. + */ + dropTargetId?: string | null; + onitemdragstart?: (e: DragEvent, item: FileItem | FolderItem) => void; + onitemdragover?: (e: DragEvent, item: FileItem | FolderItem) => void; + onitemdragleave?: (e: DragEvent, item: FileItem | FolderItem) => void; + onitemdrop?: (e: DragEvent, item: FileItem | FolderItem) => void; + /** + * Override the list-view column header. When provided, + * ResourceList renders this instead of its default header — + * used by the files browser to expose clickable column-sort + * buttons (name / size / type / modified). Pages that override + * this typically also handle sorting on their side (pass + * pre-sorted `items`) rather than relying on `onreload`. + */ + listHeader?: Snippet; + /** + * Open the row on single click (default) vs. double click. + * Files browser prefers double-click so single-click can drive + * the shift-range selection model without accidentally + * navigating. + */ + openOnDoubleClick?: boolean; + /** + * Enable shift-click range selection. The row that was clicked + * without shift becomes the anchor; the next shift-click + * selects the range between anchor and target in visible order. + * Requires `selectable`. + */ + shiftRangeSelect?: boolean; } let { title, items, + contextMap, + favoriteIds, + resolveOwnerName, loading = false, error = null, emptyText, @@ -165,14 +263,72 @@ onreload, onopen, onfavorite, - favoriteIds = null, onselectionchange, actions, toolbar, - batchToolbar + batchToolbar, + enableThumbnails = true, + isDraggable, + isDropTarget, + dropTargetId = null, + onitemdragstart, + onitemdragover, + onitemdragleave, + onitemdrop, + listHeader: listHeaderOverride, + openOnDoubleClick = false, + shiftRangeSelect = false }: Props = $props(); - const isEmpty = $derived(items.length === 0); + // ── Per-item accessors ──────────────────────────────────────────────────── + // Every read of an item field goes through these helpers so the + // contextMap override for date + owner is centralised. Kept as + // module-level fns (not $derived) — they run on each row render; + // caching a Map on every items/contextMap change would be wasteful. + function ctxOf(id: string): ItemContext | undefined { + return contextMap?.get(id); + } + function dateOf(item: FileItem | FolderItem): number | string | null { + return ctxOf(item.id)?.date ?? item.modified_at; + } + function ownerIdOf(item: FileItem | FolderItem): string | null { + const ctx = ctxOf(item.id); + return ctx && 'ownerId' in ctx ? (ctx.ownerId ?? null) : (item.created_by ?? null); + } + function sizeOf(item: FileItem | FolderItem): number | null { + return isFile(item) ? item.size : null; + } + function mimeOf(item: FileItem | FolderItem): string | null { + return isFile(item) ? item.mime_type : null; + } + function iconClassOf(item: FileItem | FolderItem): string { + return item.icon_class; + } + + // ── Dotfile filter ──────────────────────────────────────────────────────── + // Two conditions gate the filter (both must be true): + // 1. Host page opted in via `showDotfileToggle` — so pages where + // dotfiles are always visible (favorites, trash) never hide them + // even if the user's global preference is on. + // 2. User preference is set to hide — read from the reactive + // `preferences.hideDotfiles` getter, so a toolbar click flips + // this list in real time without a reload. + // The `visibleItems` derived is what every downstream reader + // (bucketing, rendering, "all-selected", range-select) uses, so + // hidden rows disappear consistently across grid, list, and every + // group-by dimension. `selectedItems` and the reap-stale-selection + // effect stay on the raw `items` — selection persists across a + // display filter toggle, matching how file managers treat a + // filter-hide as "hidden, not gone". + const filterDotfiles = $derived(showDotfileToggle && preferences.hideDotfiles); + const visibleItems = $derived( + filterDotfiles ? items.filter((i) => !i.name.startsWith('.')) : items + ); + + // isEmpty tracks the VISIBLE list — an all-dotfile page with the + // filter on shows the empty state (the host page's `emptyHint` can + // reference `hiddenCount` to say "3 items hidden by the filter"). + const isEmpty = $derived(visibleItems.length === 0); const viewClass = $derived( filesStore.viewMode === 'grid' ? 'files-grid-view' : 'files-list-view' ); @@ -217,27 +373,29 @@ * Partition the visible items into grouped sections when a `bucketOf` is * active. Server order is preserved within and across buckets (first-seen). */ - const sections = $derived.by((): Array<{ key: string; label: string; rows: ResourceEntry[] }> => { - const bucketOf = activeGroup?.bucketOf; - if (!bucketOf) return [{ key: '', label: '', rows: items }]; - const order: string[] = []; - // Transient bucketing map computed inside $derived.by — not reactive state. - // eslint-disable-next-line svelte/prefer-svelte-reactivity - const map = new Map(); - for (const entry of items) { - const k = bucketOf(entry) ?? '∅'; - if (!map.has(k)) { - map.set(k, []); - order.push(k); + const sections = $derived.by( + (): Array<{ key: string; label: string; rows: Array }> => { + const bucketOf = activeGroup?.bucketOf; + if (!bucketOf) return [{ key: '', label: '', rows: visibleItems }]; + const order: string[] = []; + // Transient bucketing map computed inside $derived.by — not reactive state. + // eslint-disable-next-line svelte/prefer-svelte-reactivity + const map = new Map>(); + for (const item of visibleItems) { + const k = bucketOf(item, ctxOf(item.id)) ?? '∅'; + if (!map.has(k)) { + map.set(k, []); + order.push(k); + } + map.get(k)!.push(item); } - map.get(k)!.push(entry); + return order.map((k) => ({ + key: k, + label: activeGroup?.labelOf?.(k) ?? k, + rows: map.get(k)! + })); } - return order.map((k) => ({ - key: k, - label: activeGroup?.labelOf?.(k) ?? k, - rows: map.get(k)! - })); - }); + ); const grouped = $derived(!!activeGroup?.bucketOf); // ── Selection ───────────────────────────────────────────────────────────── @@ -249,28 +407,83 @@ else selected.add(id); onselectionchange?.(selected); } + + /** + * Anchor id for shift-range selection. The row clicked without + * shift becomes the anchor; the next shift-click selects every + * row between anchor and target in visible order. Kept in module + * state so it survives re-renders that don't drop the component. + */ + let selectionAnchor = $state(null); + function selectRange(anchorId: string, targetId: string) { + // Range-select over the VISIBLE order — a shift-click can't reach + // a row the user can't see. + const order = visibleItems.map((i) => i.id); + const a = order.indexOf(anchorId); + const b = order.indexOf(targetId); + if (a < 0 || b < 0) return; + const [lo, hi] = a < b ? [a, b] : [b, a]; + for (let i = lo; i <= hi; i++) selected.add(order[i]); + onselectionchange?.(selected); + } + /** + * Left-click handler that either navigates (`onopen`) or manages + * selection depending on modifiers + config. Returns `true` when + * the click was consumed by selection, so callers can suppress the + * open. Enabled only for `selectable + shiftRangeSelect` callers. + */ + function handleRowClick(e: MouseEvent, id: string): boolean { + if (!selectable || !shiftRangeSelect) return false; + if (e.shiftKey && selectionAnchor) { + e.preventDefault(); + selectRange(selectionAnchor, id); + return true; + } + if (e.metaKey || e.ctrlKey) { + e.preventDefault(); + toggleSelected(id); + selectionAnchor = id; + return true; + } + // Plain click: only sets the anchor; open (if any) still fires. + selectionAnchor = id; + return false; + } function clearSelection() { selected.clear(); onselectionchange?.(selected); } - const allSelected = $derived(items.length > 0 && selected.size === items.length); + // "All-selected" means every VISIBLE row is selected — hiding + // dotfiles by preference shouldn't be confused with "not selected". + const allSelected = $derived( + visibleItems.length > 0 && visibleItems.every((i) => selected.has(i.id)) + ); function toggleSelectAll() { if (allSelected) clearSelection(); else { selected.clear(); - for (const i of items) selected.add(i.id); + // Select all VISIBLE rows only. A user hiding dotfiles then + // pressing select-all shouldn't sweep in the hidden files + // they can't see — that would be a footgun for destructive + // batch actions. + for (const i of visibleItems) selected.add(i.id); onselectionchange?.(selected); } } - // Index rebuilt only when `items` changes; the projection below is then - // O(k · log k) in the selection size k instead of the old O(N) full-list - // `items.filter(...)` re-scan on every toggle (O(N²)-ish across a - // shift-range gesture once the batch toolbar was mounted). Item order is - // preserved via the index sort so the toolbar sees the same array the - // filter produced. + // `selectedItems` and the reap-stale effect below stay on the RAW + // items — selection persists across a display-filter toggle, and + // stale-selection cleanup only fires when items truly leave the + // dataset (reload, delete, etc.), not when the filter hides them. + // + // Index rebuilt only when `items` changes; the projection is then + // O(k · log k) in the selection size k instead of a full O(N) re-scan + // of the list on every toggle (O(N²)-ish across a shift-range gesture + // once the batch toolbar is mounted — benches/ROUND11.md §S1). The + // index sort preserves item order, so the toolbar sees the same array + // the old filter produced. const itemIndexById = $derived(new Map(items.map((i, idx) => [i.id, idx]))); - const selectedEntries = $derived.by(() => { - const picked: { idx: number; item: ResourceEntry }[] = []; + const selectedItems = $derived.by(() => { + const picked: { idx: number; item: FileItem | FolderItem }[] = []; for (const id of selected) { const idx = itemIndexById.get(id); if (idx !== undefined) picked.push({ idx, item: items[idx] }); @@ -301,20 +514,20 @@ let ctxOpen = $state(false); let ctxX = $state(0); let ctxY = $state(0); - let ctxEntry = $state(null); + let ctxItem = $state(null); - function openContext(e: MouseEvent, entry: ResourceEntry) { + function openContext(e: MouseEvent, item: FileItem | FolderItem) { if (!contextActions?.length) return; e.preventDefault(); e.stopPropagation(); - ctxEntry = entry; + ctxItem = item; ctxX = Math.min(e.clientX, window.innerWidth - 220); ctxY = Math.min(e.clientY, window.innerHeight - (contextActions.length * 44 + 24)); ctxOpen = true; } function closeContext() { ctxOpen = false; - ctxEntry = null; + ctxItem = null; } // ── Infinite scroll (IntersectionObserver) ──────────────────────────────── @@ -334,9 +547,10 @@ return () => obs.disconnect(); }); - function ownerTitle(entry: ResourceEntry): string { - const owner = entry.ownerName ?? entry.ownerId ?? ''; - const path = entry.path ?? ''; + function ownerTitle(item: FileItem | FolderItem): string { + const ownerId = ownerIdOf(item); + const owner = ownerId ? (resolveOwnerName?.(ownerId) ?? ownerId) : ''; + const path = item.path ?? ''; return [ owner && `${t('files.col_owner', 'Owner')}: ${owner}`, path && `${t('files.col_path', 'Location')}: ${path}` @@ -346,82 +560,131 @@ } -{#snippet row(entry: ResourceEntry)} - {@const iconName = entry.kind === 'folder' ? 'folder' : iconNameFromClass(entry.iconClass)} +{#snippet row(item: FileItem | FolderItem)} + {@const kind = isFile(item) ? 'file' : 'folder'} + {@const iconName = kind === 'folder' ? 'folder' : iconNameFromClass(iconClassOf(item))} + {@const isFav = favoriteIds?.has(item.id) ?? false} + {@const ctx = ctxOf(item.id)} + {@const ownerId = ownerIdOf(item)} + {@const dateVal = dateOf(item)} + {@const sizeVal = sizeOf(item)} + {@const mimeVal = mimeOf(item)} + {@const draggable = isDraggable?.(item) ?? false} + {@const dropTarget = isDropTarget?.(item) ?? false}
onopen(entry) : undefined} - onkeydown={onopen ? (e) => e.key === 'Enter' && onopen(entry) : undefined} - oncontextmenu={contextActions?.length ? (e) => openContext(e, entry) : undefined} + aria-label={onopen ? item.name : undefined} + data-testid={item.name} + title={showOwner ? ownerTitle(item) : undefined} + {draggable} + ondragstart={draggable && onitemdragstart ? (e) => onitemdragstart(e, item) : undefined} + ondragover={dropTarget && onitemdragover ? (e) => onitemdragover(e, item) : undefined} + ondragleave={dropTarget && onitemdragleave ? (e) => onitemdragleave(e, item) : undefined} + ondrop={dropTarget && onitemdrop ? (e) => onitemdrop(e, item) : undefined} + onclick={onopen + ? (e) => { + // Selection-first for shift/meta clicks; only "open" fires on a + // plain click when the click wasn't consumed by selection. + if (handleRowClick(e, item.id)) return; + if (!openOnDoubleClick) onopen(item); + } + : undefined} + ondblclick={onopen && openOnDoubleClick ? () => onopen(item) : undefined} + onkeydown={onopen ? (e) => e.key === 'Enter' && onopen(item) : undefined} + oncontextmenu={contextActions?.length ? (e) => openContext(e, item) : undefined} > {#if selectable} {/if}
+ + {#if enableThumbnails && kind === 'file' && mimeVal && canThumbnailClientSide( { id: item.id, name: item.name, mime_type: mimeVal } )} + { + const img = e.currentTarget as HTMLImageElement; + img.style.display = 'none'; + if (mimeVal === 'application/pdf') preloadPdf(); + void queueThumbnailGenerate( + { id: item.id, name: item.name, mime_type: mimeVal }, + (dataUrl) => { + img.src = dataUrl; + img.style.display = ''; + } + ); + }} + /> + {/if} - {entry.name} + {item.name}
{#if showOwner}
- {#if entry.ownerId} - + {#if ownerId} + {:else} - {entry.ownerName ?? '—'} + — {/if}
{/if} - {#if showPath}
{entry.path ?? ''}
{/if} - {#if showType}
{entry.typeLabel ?? ''}
{/if} + {#if showPath}
{item.path ?? ''}
{/if} + {#if showType}
{item.category ?? ''}
{/if} {#if showSize} -
{entry.size != null ? formatBytes(entry.size) : '—'}
+
{sizeVal != null ? formatBytes(sizeVal) : '—'}
{/if} {#if showDate}
- {#if dateCell}{@render dateCell(entry)}{:else}{formatDate(entry.date)}{/if} + {#if dateCell}{@render dateCell(item, ctx)}{:else}{formatDate(dateVal)}{/if}
{/if}
- {#if showDate && dateCell}{@render dateCell(entry)}{/if} + {#if showDate && dateCell}{@render dateCell(item, ctx)}{/if} - {#if entry.size != null}{formatBytes(entry.size)}{/if} - {#if entry.date != null}{formatDate(entry.date)}{/if} + {#if sizeVal != null}{formatBytes(sizeVal)}{/if} + {#if dateVal != null}{formatDate(dateVal)}{/if}
{#if onfavorite} - {@const starred = favoriteIds ? favoriteIds.has(entry.id) : !!entry.isFavorite} {/if} {#if actions} -
{@render actions(entry)}
+
{@render actions(item)}
{/if}
{/snippet} @@ -461,7 +724,7 @@ {t('files.selected_count', { count: selected.size }, '{{count}} selected')} -
{@render batchToolbar(selectedEntries)}
+
{@render batchToolbar(selectedItems)}
{/if} @@ -479,7 +742,7 @@
{#if grouped}
- {@render listHeader()} + {#if listHeaderOverride}{@render listHeaderOverride()}{:else}{@render listHeader()}{/if} {#each sections as section (section.key)}
{section.label} @@ -506,13 +769,13 @@
- {@render listHeader()} - e.id} {row} /> + {#if listHeaderOverride}{@render listHeaderOverride()}{:else}{@render listHeader()}{/if} + e.id} {row} />
{:else} {/snippet} -{#if ctxOpen && ctxEntry && contextActions} +{#if ctxOpen && ctxItem && contextActions}