@axium/client 0.28.0 → 0.29.0

package/assets/styles.css

@@ -50,7 +50,7 @@ button {
 	cursor: pointer;
 
 	&:hover {
-		background-color: hsl(var(--hue) 15 calc(var(--bg-light) + (var(--light-step) * 2)));
+		background-color: var(--bg-accent);
 	}
 }
 
@@ -145,7 +145,7 @@ details {
 dialog {
 	border-radius: 1em;
 	background: var(--bg-menu);
-	border: 1px solid #8888;
+	border: var(--border-elevated);
 	padding: 1em;
 	max-width: calc(100% - 2em);
 	word-wrap: normal;
@@ -177,11 +177,11 @@ progress::-webkit-progress-bar {
 }
 
 progress::-webkit-progress-value {
-	background-color: hsl(0 0 var(--fg-light));
+	background-color: var(--fg-normal);
 }
 
 progress::-moz-progress-bar {
-	background-color: hsl(0 0 var(--fg-light));
+	background-color: var(--fg-normal);
 }
 
 ::selection,
@@ -233,7 +233,7 @@ div.success {
 
 .danger {
 	border: var(--border-error);
-	background-color: hsl(0 20 calc(var(--bg-light) + var(--light-step)));
+	background-color: hsl(from var(--bg-strong) 0 s l);
 	color: hsl(0 33 var(--fg-light));
 	--fill: hsl(0 33 var(--fg-light));
 	accent-color: hsl(0 33 var(--fg-light));
@@ -252,8 +252,8 @@ div.success {
 }
 
 :popover-open {
-	border: 1px solid hsl(var(--hue) 10 calc(var(--fg-light) - var(--light-step)));
-	background-color: hsl(from var(--bg-menu) h s l / 95%);
+	border: var(--border-elevated);
+	background-color: var(--bg-elevated);
 	border-radius: 0.5em;
 	padding: 0.25em;
 	margin: 0;
@@ -275,6 +275,14 @@ div.success {
 			cursor: pointer;
 		}
 	}
+
+	.menu-header {
+		padding: 0.5em 0.75em;
+		font-size: 0.85em;
+		font-weight: bold;
+		color: var(--fg-normal);
+		user-select: none;
+	}
 }
 
 .icon-text {
@@ -283,6 +291,47 @@ div.success {
 	gap: 1em;
 }
 
+.drag-indicator {
+	position: fixed;
+	z-index: 100;
+	display: inline-flex;
+	align-items: center;
+	gap: 0.5em;
+	pointer-events: none;
+	padding: 0.5em 0.75em;
+	border-radius: 0.5em;
+	background-color: var(--bg-elevated);
+	border: var(--border-elevated);
+	transform: translate(0.75em, 0.75em);
+	max-width: 20em;
+	white-space: nowrap;
+
+	> :not(.drag-name) {
+		flex-shrink: 0;
+	}
+
+	.drag-name {
+		overflow: hidden;
+		text-overflow: ellipsis;
+	}
+
+	.drag-count {
+		font-weight: bold;
+	}
+}
+
+.drag-over {
+	outline: 2px solid var(--fg-accent);
+	outline-offset: -2px;
+	border-radius: 0.5em;
+}
+
+body.dragging-items,
+body.dragging-items * {
+	cursor: grabbing !important;
+	user-select: none;
+}
+
 a:has(button, div) {
 	display: contents;
 }
@@ -290,7 +339,6 @@ a:has(button, div) {
 .version {
 	font-family: monospace;
 	font-size: 0.9em;
-	color: #aaa;
 }
 
 h1,
@@ -300,13 +348,15 @@ h4,
 h5,
 h6 {
 	.version {
+		opacity: 80%;
 		margin-left: 1em;
 	}
 }
 
 .version::before {
 	content: 'v';
-	color: #888;
+	color: var(--fg-disabled);
+	opacity: 80%;
 }
 
 .inline-button {

package/assets/theme.css

@@ -35,6 +35,7 @@ html {
 	--bg-accent: hsl(var(--hue) 15 calc(var(--bg-light) + (var(--light-step) * 2)));
 	--bg-alt: hsl(var(--hue) 5 calc(var(--bg-light) + var(--light-step)));
 	--bg-strong: hsl(var(--hue) 20 calc(var(--bg-light) + var(--light-step)));
+	--bg-elevated: hsl(from var(--bg-menu) h s l / 95%);
 
 	--bg-error: hsl(0 40 var(--bg-light-status));
 	--bg-warning: hsl(60 40 var(--bg-light-status));
@@ -52,6 +53,7 @@ html {
 	--border-accent: 1px solid hsl(var(--hue) 10 calc(var(--bg-light) + (var(--light-step) * 3)));
 	--border-alt: 1px solid var(--bg-alt);
 	--border-strong: 1px solid hsl(var(--hue) 20 calc(var(--bg-light) + (var(--light-step) * 3)));
+	--border-elevated: 1px solid hsl(var(--hue) 10 calc(var(--fg-light) - var(--light-step)));
 
 	--border-error: 1px solid hsl(0 50 var(--fg-light));
 	--border-warning: 1px solid hsl(60 50 var(--fg-light));

package/dist/cache.js

@@ -37,7 +37,7 @@ export class Cache {
         return this.items.size;
     }
     valid(timestamp) {
-        return !this.options.ttl || !timestamp || timestamp.valueOf() + this.options.ttl < Date.now();
+        return !this.options.ttl || !timestamp || timestamp + this.options.ttl > Date.now();
     }
     write(key, value) {
         if (isThenable(value)) {

package/dist/cli/cache.d.ts

@@ -11,7 +11,7 @@ export declare class Handle<S extends z.ZodObject> {
     save(): void;
     update(): Promise<void>;
     isValid(): Promise<boolean>;
-    get data(): z.infer<S>;
+    get data(): z.infer<S> | undefined;
     static [create]<S extends z.ZodObject>(init: Init<S>): Handle<S>;
 }
 export interface Init<S extends z.ZodObject> {

package/dist/cli/index.js

@@ -52,9 +52,9 @@ program.command('logout').action(async () => {
 program.command('status').action(() => {
     if (!config.token)
         return console.log('Not logged in.');
-    if (!config.cache)
+    const { session } = cache.meta.data || {};
+    if (!session)
         return console.log('No session data available.');
-    const { session } = cache.meta.data;
     console.log('Logged in to', new URL(prefix).host);
     console.log(styleText('whiteBright', 'Session:'), 'valid until', session.expires.toLocaleDateString(), styleText('dim', `(${session.id})`));
     const { user } = session;

package/lib/AccessControlDialog.svelte

@@ -6,7 +6,7 @@
 	import Discovery, * as discovery from './Discovery.svelte';
 	import Icon from './Icon.svelte';
 	import UserCard from './UserCard.svelte';
-	import { closeOnBackGesture } from './attachments.js';
+	import { closeOnBackGesture } from './attachments/gestures.js';
 	import { toast, toastStatus } from './toast.js';
 
 	interface Props extends HTMLDialogAttributes {

package/lib/FormDialog.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
 	import { text } from '@axium/client';
 	import type { HTMLDialogAttributes } from 'svelte/elements';
-	import { closeOnBackGesture } from './attachments.js';
+	import { closeOnBackGesture } from './attachments/gestures.js';
 
 	let {
 		children,

package/lib/Upload.svelte

@@ -20,7 +20,7 @@
 			<Icon i={forMime(file.type)} />
 			{#if !progress[i]}
 				<div class="name">
-					<span>{file.name}</span>
+					<span>{file.webkitRelativePath || file.name}</span>
 				</div>
 				<button
 					onclick={e => {
@@ -35,12 +35,12 @@
 				</button>
 			{:else if progress[i][0] == progress[i][1]}
 				<div class="name">
-					<span>{file.name}</span>
+					<span>{file.webkitRelativePath || file.name}</span>
 				</div>
 				<Icon i="cloud-check" />
 			{:else}
 				<div class="name">
-					<span>{file.name}</span>
+					<span>{file.webkitRelativePath || file.name}</span>
 					<progress value={progress[i][0]} max={progress[i][1]}></progress>
 				</div>
 				<Icon i="cloud-arrow-up" />

package/lib/attachments/context-menu.ts

@@ -0,0 +1,123 @@
+import { mount, unmount } from 'svelte';
+import type { Attachment } from 'svelte/attachments';
+import Icon from '../Icon.svelte';
+
+export interface ContextMenuItem {
+	/** Icon name */
+	i?: string;
+	text: string;
+	danger?: boolean;
+	action(): unknown;
+}
+
+/** A non-interactive label, e.g. to describe what it acts on. */
+export interface ContextMenuHeader {
+	header: string;
+}
+
+export type ContextMenuEntry = ContextMenuItem | ContextMenuHeader | false | null | undefined;
+
+/**
+ * Attach a context menu to an element with the given actions.
+ *
+ * Pass a function instead of a fixed list to have the menu rebuilt every time it opens — useful when
+ * the available actions or their labels depend on state that changes after the menu is attached (e.g. a
+ * selection).
+ */
+export function contextMenu(...menuItems: ContextMenuEntry[] | [() => ContextMenuEntry[]]): Attachment<HTMLElement> {
+	return function _attachContextMenu(element: HTMLElement) {
+		const menu = document.createElement('div');
+		menu.popover = 'auto';
+		menu.className = 'context-menu';
+
+		const mountedIcons = new Set<Record<string, any>>();
+
+		function build(items: ContextMenuEntry[]) {
+			for (const item of items) {
+				if (!item) continue;
+
+				if ('header' in item) {
+					const header = document.createElement('div');
+					header.classList.add('menu-header');
+					header.appendChild(document.createTextNode(item.header));
+					menu.appendChild(header);
+					continue;
+				}
+
+				const div = document.createElement('div');
+				div.classList.add('icon-text', 'menu-item');
+				if (item.danger) div.classList.add('danger');
+
+				div.onclick = e => {
+					e.stopPropagation();
+					menu.hidePopover();
+					item.action();
+				};
+
+				if (item.i) mountedIcons.add(mount<any, {}>(Icon, { target: div, props: { i: item.i } }));
+
+				div.appendChild(document.createTextNode(item.text));
+
+				menu.appendChild(div);
+			}
+		}
+
+		if (typeof menuItems[0] != 'function') build(menuItems as ContextMenuEntry[]);
+
+		document.body.appendChild(menu);
+
+		let _forcePopover = false;
+
+		element.oncontextmenu = (e: MouseEvent) => {
+			for (let node = e.target as HTMLElement | null; node && node !== element; node = node.parentElement) {
+				if (node instanceof HTMLDialogElement || (node.popover && node !== menu)) return;
+			}
+
+			e.preventDefault();
+			e.stopPropagation();
+
+			if (typeof menuItems[0] == 'function') {
+				for (const icon of mountedIcons) unmount(icon);
+				mountedIcons.clear();
+				menu.replaceChildren();
+				build(menuItems[0]());
+			}
+
+			menu.showPopover();
+			_forcePopover = true;
+
+			const x = e.clientX;
+			const y = e.clientY;
+
+			menu.style.left = x + 'px';
+			menu.style.top = y + 'px';
+
+			const rect = menu.getBoundingClientRect();
+			if (rect.right > window.innerWidth) {
+				menu.style.left = '';
+				menu.style.right = window.innerWidth - x + 'px';
+			}
+			if (rect.bottom > window.innerHeight) {
+				menu.style.top = '';
+				menu.style.bottom = window.innerHeight - y + 'px';
+			}
+		};
+
+		/**
+		 * Workaround for https://github.com/whatwg/html/issues/10905
+		 * @todo Remove when the problem is fixed.
+		 */
+		element.onpointerup = (e: PointerEvent) => {
+			if (!_forcePopover) return;
+			e.stopPropagation();
+			e.preventDefault();
+			menu.togglePopover();
+			_forcePopover = false;
+		};
+
+		return function _disposeContextMenu() {
+			for (const icon of mountedIcons) unmount(icon);
+			menu.remove();
+		};
+	};
+}

package/lib/attachments/drag-and-drop.ts

@@ -0,0 +1,257 @@
+import { mount, unmount } from 'svelte';
+import type { Attachment } from 'svelte/attachments';
+import Icon from '../Icon.svelte';
+import { SvelteSet } from 'svelte/reactivity';
+import type { Selection } from './selection.js';
+
+/** A grabbable item, used to populate the floating drag indicator. */
+export interface Item {
+	id: string;
+	name: string;
+	icon?: string;
+}
+
+/**
+ * Coordinates a press-and-hold drag of one or more things onto a {@link target}.
+ *
+ * Things are made grabbable with the {@link source} attachment,
+ * and targets accept them with {@link target}.
+ *
+ * While a drag is in progress a floating indicator follows the pointer showing
+ * the grabbed item's name and icon, with a bold `+ N` when several are grabbed.
+ *
+ * The grabbed elements expose the `dragging` class for styling.
+ */
+export class Controller extends SvelteSet<string> implements Disposable {
+	#indicator?: HTMLElement;
+	#indicatorIcon?: Record<string, any>;
+
+	/** Registered drop targets, keyed by their element. */
+	readonly #targets = new Map<HTMLElement, (ids: string[]) => unknown>();
+
+	#activeTarget?: HTMLElement;
+
+	/** Whether a drag is currently in progress. */
+	get active(): boolean {
+		return this.size > 0;
+	}
+
+	_registerTarget(element: HTMLElement, onDrop: (ids: string[]) => unknown): () => void {
+		this.#targets.set(element, onDrop);
+		return () => this.#targets.delete(element);
+	}
+
+	/** Begin dragging the given ids, showing a floating indicator labelled for `lead`. */
+	begin(ids: string[], lead: Item): void {
+		if (!ids.length) return;
+		for (const id of ids) this.add(id);
+
+		const indicator = document.createElement('div');
+		indicator.className = 'drag-indicator';
+		if (lead.icon) this.#indicatorIcon = mount<any, {}>(Icon, { target: indicator, props: { i: lead.icon } });
+
+		const name = document.createElement('span');
+		name.className = 'drag-name';
+		name.textContent = lead.name;
+		indicator.appendChild(name);
+
+		if (ids.length > 1) {
+			const extra = document.createElement('b');
+			extra.className = 'drag-count';
+			extra.textContent = `+ ${ids.length - 1}`;
+			indicator.appendChild(extra);
+		}
+
+		document.body.appendChild(indicator);
+		this.#indicator = indicator;
+		document.body.classList.add('dragging-items');
+	}
+
+	/** Move the floating indicator and update which drop target is under the pointer. */
+	move(x: number, y: number): void {
+		if (!this.#indicator) return;
+		this.#indicator.style.left = x + 'px';
+		this.#indicator.style.top = y + 'px';
+
+		// Find the drop target under the pointer (ignoring the indicator itself, which is pointer-events: none).
+		let target: HTMLElement | undefined;
+		for (let node = document.elementFromPoint(x, y) as HTMLElement | null; node; node = node.parentElement) {
+			if (this.#targets.has(node)) {
+				target = node;
+				break;
+			}
+		}
+
+		if (target == this.#activeTarget) return;
+		this.#activeTarget?.classList.remove('drag-over');
+		this.#activeTarget = target;
+		this.#activeTarget?.classList.add('drag-over');
+	}
+
+	/** Finish the drag, dropping onto the active target (if any), and clean up. */
+	end(): void {
+		const onDrop = this.#activeTarget && this.#targets.get(this.#activeTarget);
+		try {
+			if (onDrop && this.size) onDrop([...this]);
+		} finally {
+			this.dispose();
+		}
+	}
+
+	/** Abort the drag without dropping. */
+	cancel(): void {
+		this.dispose();
+	}
+
+	dispose(): void {
+		this.clear();
+		this.#activeTarget?.classList.remove('drag-over');
+		this.#activeTarget = undefined;
+		if (this.#indicatorIcon) unmount(this.#indicatorIcon);
+		this.#indicatorIcon = undefined;
+		this.#indicator?.remove();
+		this.#indicator = undefined;
+		document.body.classList.remove('dragging-items');
+	}
+
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+}
+
+/**
+ * The default drag-and-drop controller.
+ */
+const defaultController = new Controller();
+
+export { defaultController as controller };
+
+/** How long, in milliseconds, a touch must be held before it starts a drag (rather than scrolling). */
+const HOLD_DELAY = 400;
+
+/**
+ * Make an element a draggable source for a {@link Controller}.
+ *
+ * Pressing and dragging the pointer out of the item grabs either the current {@link Selection} (when
+ * this item is part of a non-empty selection) or just this item, then follows the pointer until release.
+ */
+export function source(
+	item: Item,
+	selectedIds: Iterable<string> = [item.id],
+	controller: Controller = defaultController
+): Attachment<HTMLElement> {
+	const selection = Array.from(selectedIds);
+	if (!selection.length) selection.push(item.id);
+
+	return function _attachDraggable(element: HTMLElement) {
+		let lastX = 0,
+			lastY = 0,
+			started = false,
+			pointerId: number | undefined,
+			holdTimer: number | undefined;
+
+		function _clearTimer() {
+			clearTimeout(holdTimer);
+			holdTimer = undefined;
+			pointerId = undefined;
+		}
+
+		function start() {
+			if (started || pointerId === undefined) return;
+			started = true;
+
+			controller.begin(selection, item);
+			element.setPointerCapture(pointerId);
+			controller.move(lastX, lastY);
+		}
+
+		function onPointerDown(e: PointerEvent) {
+			if (e.button !== 0) return;
+			for (let node = e.target as HTMLElement | null; node && node !== element; node = node.parentElement) {
+				if (node.hasAttribute('data-no-select')) return;
+			}
+			lastX = e.clientX;
+			lastY = e.clientY;
+			started = false;
+			pointerId = e.pointerId;
+
+			// Touch presses scroll the list, so require a deliberate press-and-hold before grabbing.
+			if (e.pointerType === 'touch') holdTimer = setTimeout(start, HOLD_DELAY);
+		}
+
+		// The drag begins once the pointer leaves the item it was pressed on.
+		function onPointerLeave(e: PointerEvent) {
+			if (pointerId === undefined || e.pointerId !== pointerId || started) return;
+			// A touch that leaves the item before the hold fires is a scroll, not a drag.
+			if (holdTimer !== undefined) return _clearTimer();
+
+			lastX = e.clientX;
+			lastY = e.clientY;
+			start();
+		}
+
+		function onPointerMove(e: PointerEvent) {
+			if (pointerId === undefined || e.pointerId !== pointerId || !started) return;
+			lastX = e.clientX;
+			lastY = e.clientY;
+			e.preventDefault();
+			controller.move(e.clientX, e.clientY);
+		}
+
+		function onPointerUp(e: PointerEvent) {
+			if (pointerId === undefined || e.pointerId !== pointerId) return;
+			if (element.hasPointerCapture(pointerId)) element.releasePointerCapture(pointerId);
+			_clearTimer();
+			if (started) {
+				e.preventDefault();
+				e.stopPropagation();
+				suppressClick = true;
+				controller.end();
+			}
+			started = false;
+		}
+
+		function onPointerCancel() {
+			_clearTimer();
+			if (started) controller.cancel();
+			started = false;
+		}
+
+		// A drag may be followed by a synthetic click; swallow it so it doesn't re-select or open the item.
+		let suppressClick = false;
+		function onClick(e: MouseEvent) {
+			if (!suppressClick) return;
+			suppressClick = false;
+			e.preventDefault();
+			e.stopPropagation();
+		}
+
+		element.addEventListener('pointerdown', onPointerDown);
+		element.addEventListener('pointerleave', onPointerLeave);
+		element.addEventListener('pointermove', onPointerMove);
+		element.addEventListener('pointerup', onPointerUp);
+		element.addEventListener('pointercancel', onPointerCancel);
+		element.addEventListener('click', onClick, { capture: true });
+
+		return () => {
+			element.removeEventListener('pointerdown', onPointerDown);
+			element.removeEventListener('pointerleave', onPointerLeave);
+			element.removeEventListener('pointermove', onPointerMove);
+			element.removeEventListener('pointerup', onPointerUp);
+			element.removeEventListener('pointercancel', onPointerCancel);
+			element.removeEventListener('click', onClick, { capture: true });
+		};
+	};
+}
+
+/**
+ * Register an element as a drop target for a {@link DragController}.
+ *
+ * When grabbed items are released over the element, `onDrop` is called with the dragged ids. While a
+ * drag hovers the element it carries the `drag-over` class.
+ */
+export function target(onDrop: (ids: string[]) => unknown, controller: Controller = defaultController): Attachment<HTMLElement> {
+	return function _attachDropTarget(element: HTMLElement) {
+		return controller._registerTarget(element, onDrop);
+	};
+}

package/lib/attachments/gestures.ts

@@ -0,0 +1,36 @@
+import type { Attachment } from 'svelte/attachments';
+
+/**
+ * Enabled the use of back gestures to close dialogs
+ */
+export function closeOnBackGesture(element: HTMLDialogElement) {
+	if (!globalThis.history) {
+		throw new Error('Can not attach back gesture handling because the History API is unavailable');
+	}
+
+	const showModal = element.showModal.bind(element);
+
+	let closedByBack = false,
+		historyKey = Math.random().toString(16).slice(2);
+
+	element.showModal = () => {
+		closedByBack = false;
+		/* popstate's state will be the "upcoming" state.
+		i.e, the state after having pushed 1 then 2 would be 1 */
+		history.replaceState(historyKey, '');
+		history.pushState(null, '');
+		showModal();
+	};
+
+	element.addEventListener('close', () => {
+		if (closedByBack) return;
+		history.replaceState(null, '');
+	});
+
+	window.addEventListener('popstate', e => {
+		if (e.state != historyKey) return;
+		closedByBack = true;
+		element.close();
+	});
+}
+closeOnBackGesture satisfies Attachment<HTMLDialogElement>;

package/lib/attachments/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Svelte attachments
+ * @see https://svelte.dev/docs/svelte/@attach
+ */
+import type { Attachment } from 'svelte/attachments';
+
+export * from './context-menu.js';
+export * as drag from './drag-and-drop.js';
+export * from './gestures.js';
+export * from './selection.js';
+
+/**
+ * Dynamically resize `<textarea>`s based on content.
+ * @todo Remove this once `field-sizing` works everywhere
+ */
+export function dynamicRows(max: number = 40, min: number = 3): Attachment<HTMLTextAreaElement> {
+	return function _attachDynamicRows(element: HTMLTextAreaElement) {
+		element.style.resize = 'none';
+		element.style.fieldSizing = 'content';
+		element.style.height = 'max-content';
+		element.style.overflowY = 'scroll';
+
+		function update() {
+			if (!element.value) return;
+			element.rows = Math.max(Math.min(element.value.split('\n').length, max), min);
+		}
+
+		if (!navigator.userAgent.includes('Firefox')) return;
+		update();
+		element.addEventListener('input', update);
+		element.addEventListener('keyup', update);
+		return () => {
+			element.removeEventListener('input', update);
+			element.removeEventListener('keyup', update);
+		};
+	};
+}

package/lib/attachments/selection.ts

@@ -0,0 +1,90 @@
+import type { Attachment } from 'svelte/attachments';
+import { SvelteSet } from 'svelte/reactivity';
+
+/**
+ * Manages a reusable, list-wide selection across items rendered with the {@link selectable} attachment.
+ *
+ * Click semantics (matching common file managers):
+ * - Plain click: select only the clicked item, clearing the rest.
+ * - Ctrl/Cmd click: toggle the clicked item's selection.
+ * - Shift click: select the range between the last-clicked item and the clicked item, clearing everything outside it.
+ */
+export class Selection extends SvelteSet<string> {
+	/** The ordered list of ids, set by the caller so ranges (shift-click) can be computed. */
+	#order: string[] = [];
+
+	/** The id of the last item interacted with, used as the anchor for shift-click ranges. */
+	#anchor?: string;
+
+	/**
+	 * Update the ordered list of item ids. Call this whenever the rendered order changes
+	 * (e.g. after sorting or loading a new directory).
+	 */
+	setOrder(ids: string[]): void {
+		this.#order = ids;
+		for (const id of this) if (!ids.includes(id)) this.delete(id);
+		if (this.#anchor && !ids.includes(this.#anchor)) this.#anchor = undefined;
+	}
+
+	/** Clear the entire selection. */
+	clear(): void {
+		super.clear();
+		this.#anchor = undefined;
+	}
+
+	/** Apply selection behavior for a click on `id` with the given modifier keys. */
+	handleClick(id: string, e: { shiftKey: boolean; ctrlKey: boolean; metaKey: boolean }): void {
+		if (e.shiftKey && this.#anchor) {
+			const start = this.#order.indexOf(this.#anchor);
+			const end = this.#order.indexOf(id);
+			if (start != -1 && end != -1) {
+				const [lo, hi] = start < end ? [start, end] : [end, start];
+				const range = new Set(this.#order.slice(lo, hi + 1));
+				super.clear();
+				for (const rangeId of range) this.add(rangeId);
+				return;
+			}
+		}
+
+		if (e.ctrlKey || e.metaKey) {
+			if (this.has(id)) this.delete(id);
+			else this.add(id);
+			this.#anchor = id;
+			return;
+		}
+
+		super.clear();
+		this.add(id);
+		this.#anchor = id;
+	}
+}
+
+/**
+ * Wire an element into a {@link Selection} as the item identified by `id`.
+ *
+ * Reflects selection state via the `selected` class and handles select-on-click (with shift/ctrl/meta
+ * modifiers). The handler runs in the capture phase so it can be combined with other click handlers on
+ * the element that perform navigation/preview only when the click was not a selection gesture.
+ */
+export function selectable(selection: Selection, id: string): Attachment<HTMLElement> {
+	return function _attachSelectable(element: HTMLElement) {
+		function onclick(e: MouseEvent) {
+			// Let interactive descendants (action buttons, etc.) opt out of triggering selection.
+			for (let node = e.target as HTMLElement | null; node && node != element; node = node.parentElement) {
+				if (node.hasAttribute('data-no-select')) return;
+			}
+
+			if (e.shiftKey || e.ctrlKey || e.metaKey) {
+				e.preventDefault();
+				e.stopPropagation();
+			}
+			selection.handleClick(id, e);
+		}
+
+		element.addEventListener('click', onclick, { capture: true });
+
+		return () => {
+			element.removeEventListener('click', onclick, { capture: true });
+		};
+	};
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@axium/client",
-	"version": "0.28.0",
+	"version": "0.29.0",
 	"author": "James Prevett <jp@jamespre.dev>",
 	"funding": {
 		"type": "individual",
@@ -38,7 +38,7 @@
 		"./components": "./lib/index.js",
 		"./components/*": "./lib/*.svelte",
 		"./toast": "./lib/toast.js",
-		"./attachments": "./lib/attachments.js",
+		"./attachments": "./lib/attachments/index.js",
 		"./styles/*": "./styles/*.css"
 	},
 	"scripts": {
@@ -54,7 +54,7 @@
 	},
 	"dependencies": {
 		"@simplewebauthn/browser": "^13.1.0",
-		"commander": "^14.0.0",
+		"commander": "^15.0.0",
 		"music-metadata": "^11.12.3"
 	}
 }

package/styles/list.css

@@ -45,6 +45,7 @@ div.list-header {
 	overflow: hidden;
 	text-wrap: nowrap;
 	flex: 0 0 auto;
+	user-select: none;
 }
 
 .list-item:not(.list-header, :first-child) {
@@ -52,9 +53,17 @@ div.list-header {
 }
 
 .list-item:not(.list-header):hover {
+	background-color: var(--bg-strong);
+}
+
+.list-item.selected {
 	background-color: var(--bg-alt);
 }
 
+.list-item.dragging {
+	opacity: 0.5;
+}
+
 p.list-empty {
 	text-align: center;
 	color: #888;

package/lib/attachments.ts

@@ -1,158 +0,0 @@
-/**
- * Svelte attachments
- * @see https://svelte.dev/docs/svelte/@attach
- */
-import { mount, unmount } from 'svelte';
-import type { Attachment } from 'svelte/attachments';
-import Icon from './Icon.svelte';
-
-export interface ContextMenuItem {
-	/** Icon name */
-	i?: string;
-	text: string;
-	danger?: boolean;
-	action(): unknown;
-}
-
-/**
- * Attach a context menu to an element with the given actions
- */
-export function contextMenu(...menuItems: (ContextMenuItem | false | null | undefined)[]): Attachment<HTMLElement> {
-	return function _attachContextMenu(element: HTMLElement) {
-		const menu = document.createElement('div');
-		menu.popover = 'auto';
-		menu.className = 'context-menu';
-
-		const mountedIcons = new Set<Record<string, any>>();
-
-		for (const item of menuItems) {
-			if (!item) continue;
-			const div = document.createElement('div');
-			div.classList.add('icon-text', 'menu-item');
-			if (item.danger) div.classList.add('danger');
-
-			div.onclick = e => {
-				e.stopPropagation();
-				menu.hidePopover();
-				item.action();
-			};
-
-			if (item.i) mountedIcons.add(mount<any, {}>(Icon, { target: div, props: { i: item.i } }));
-
-			div.appendChild(document.createTextNode(item.text));
-
-			menu.appendChild(div);
-		}
-
-		document.body.appendChild(menu);
-
-		let _forcePopover = false;
-
-		element.oncontextmenu = (e: MouseEvent) => {
-			for (let node = e.target as HTMLElement | null; node && node !== element; node = node.parentElement) {
-				if (node instanceof HTMLDialogElement || (node.popover && node !== menu)) return;
-			}
-
-			e.preventDefault();
-			e.stopPropagation();
-
-			menu.showPopover();
-			_forcePopover = true;
-
-			const x = e.clientX;
-			const y = e.clientY;
-
-			menu.style.left = x + 'px';
-			menu.style.top = y + 'px';
-
-			const rect = menu.getBoundingClientRect();
-			if (rect.right > window.innerWidth) {
-				menu.style.left = '';
-				menu.style.right = window.innerWidth - x + 'px';
-			}
-			if (rect.bottom > window.innerHeight) {
-				menu.style.top = '';
-				menu.style.bottom = window.innerHeight - y + 'px';
-			}
-		};
-
-		/**
-		 * Workaround for https://github.com/whatwg/html/issues/10905
-		 * @todo Remove when the problem is fixed.
-		 */
-		element.onpointerup = (e: PointerEvent) => {
-			if (!_forcePopover) return;
-			e.stopPropagation();
-			e.preventDefault();
-			menu.togglePopover();
-			_forcePopover = false;
-		};
-
-		return function _disposeContextMenu() {
-			for (const icon of mountedIcons) unmount(icon);
-			menu.remove();
-		};
-	};
-}
-
-/**
- * Dynamically resize `<textarea>`s based on content.
- * @todo Remove this once `field-sizing` works everywhere
- */
-export function dynamicRows(max: number = 40, min: number = 3): Attachment<HTMLTextAreaElement> {
-	return function _attachDynamicRows(element: HTMLTextAreaElement) {
-		element.style.resize = 'none';
-		element.style.fieldSizing = 'content';
-		element.style.height = 'max-content';
-		element.style.overflowY = 'scroll';
-
-		function update() {
-			if (!element.value) return;
-			element.rows = Math.max(Math.min(element.value.split('\n').length, max), min);
-		}
-
-		if (!navigator.userAgent.includes('Firefox')) return;
-		update();
-		element.addEventListener('input', update);
-		element.addEventListener('keyup', update);
-		return () => {
-			element.removeEventListener('input', update);
-			element.removeEventListener('keyup', update);
-		};
-	};
-}
-
-/**
- * Enabled the use of back gestures to close dialogs
- */
-export function closeOnBackGesture(element: HTMLDialogElement) {
-	if (!globalThis.history) {
-		throw new Error('Can not attach back gesture handling because the History API is unavailable');
-	}
-
-	const showModal = element.showModal.bind(element);
-
-	let closedByBack = false,
-		historyKey = Math.random().toString(16).slice(2);
-
-	element.showModal = () => {
-		closedByBack = false;
-		/* popstate's state will be the "upcoming" state.
-		i.e, the state after having pushed 1 then 2 would be 1 */
-		history.replaceState(historyKey, '');
-		history.pushState(null, '');
-		showModal();
-	};
-
-	element.addEventListener('close', () => {
-		if (closedByBack) return;
-		history.replaceState(null, '');
-	});
-
-	window.addEventListener('popstate', e => {
-		if (e.state != historyKey) return;
-		closedByBack = true;
-		element.close();
-	});
-}
-closeOnBackGesture satisfies Attachment<HTMLDialogElement>;