@x-tech-laboratories/x-libs 0.14.0 → 0.14.1

package/dist/web/react/toasts.js

@@ -1,72 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// Short notes in the page's corner after something happened, with an optional link or action such as Undo.
-import { useEffect, useState } from "react";
-let shown = [];
-let next_id = 1;
-const listeners = new Set();
-function publish(toasts) {
-    shown = toasts;
-    for (const listener of listeners)
-        listener(shown);
-}
-// Takes the toast away and tells its owner why, once only.
-function close_toast(id, reason) {
-    const item = shown.find((each) => each.id === id);
-    if (!item)
-        return;
-    publish(shown.filter((each) => each.id !== id));
-    item.on_close?.(reason);
-}
-// Shows the message and returns a function that closes it early.
-export function toast(message, options = {}) {
-    const id = next_id++;
-    publish([...shown, { ...options, id, message }]);
-    if (!(options.sticky ?? options.tone === "bad"))
-        setTimeout(() => close_toast(id, "timeout"), options.duration_in_milliseconds ?? 6000);
-    return () => close_toast(id, "closed");
-}
-// Shows the message with an Undo button, then either undoes or commits the action, exactly once.
-export function undoable(message, { commit, undo, duration_in_milliseconds = 8000, undo_label = "Undo" }) {
-    let settled = false;
-    let undo_wanted = false;
-    const settle = (reason) => {
-        if (settled)
-            return;
-        settled = true;
-        if (reason === "action" || undo_wanted)
-            undo();
-        else
-            commit();
-    };
-    const close = toast(message, {
-        action: { text: undo_label, run: () => { } },
-        duration_in_milliseconds,
-        on_close: settle,
-    });
-    return {
-        finish: () => close(),
-        undo: () => {
-            if (settled)
-                return;
-            undo_wanted = true;
-            close();
-        },
-        get settled() {
-            return settled;
-        },
-    };
-}
-// ── Host ─────────────────────────────────────────────────────────────────────
-// Where toasts stack; the Shell holds one, and a page without the Shell renders its own.
-export function Toasts() {
-    const [toasts, set_toasts] = useState(shown);
-    useEffect(() => {
-        listeners.add(set_toasts);
-        return () => void listeners.delete(set_toasts);
-    }, []);
-    return (_jsx("div", { id: "toasts", className: "toasts", children: toasts.map((item) => {
-            const tone = item.tone ?? "info";
-            const close = () => close_toast(item.id, "dismissed");
-            return (_jsxs("div", { className: `toast tone-${tone}`, role: tone === "bad" ? "alert" : "status", children: [_jsx("span", { children: item.message }), item.link && _jsx("a", { href: item.link.href, onClick: close, children: item.link.text }), item.action && _jsx("button", { className: "toast-action", onClick: () => { close_toast(item.id, "action"); item.action.run(); }, children: item.action.text }), _jsx("button", { className: "icon remove", "aria-label": "Dismiss", onClick: close, children: "\u00D7" })] }, item.id));
-        }) }));
-}

package/dist/web/react/tree.d.ts

@@ -1,28 +0,0 @@
-import { type DragEvent, type MouseEvent, type ReactNode } from "react";
-import { type DropPlacement, type TreeItem, type TreeMove } from "../tree.ts";
-export type { DropPlacement, TreeItem, TreeMove } from "../tree.ts";
-interface TreeProps<Item extends TreeItem> {
-    items: Item[];
-    label: string;
-    render_item: (item: Item) => ReactNode;
-    render_extra?: (item: Item) => ReactNode;
-    name_of?: (item: Item) => string;
-    collapsed: ReadonlySet<string>;
-    on_collapsed_change: (collapsed: Set<string>) => void;
-    selected_id?: string | null;
-    selected_ids?: ReadonlySet<string>;
-    on_select?: (item: Item) => void;
-    on_activate?: (item: Item) => void;
-    row_class?: (item: Item) => string | undefined;
-    on_move?: (item: Item, move: TreeMove) => void;
-    can_drop?: (dragged: Item, target: Item, placement: DropPlacement) => boolean;
-    allow_inside?: boolean;
-    new_item?: {
-        parent_id: string | null;
-        form: ReactNode;
-    } | null;
-    on_context_menu?: (event: MouseEvent<HTMLElement>, item: Item) => void;
-    accepts_external?: (event: DragEvent<HTMLElement>, item: Item) => boolean;
-    on_external_drop?: (event: DragEvent<HTMLElement>, item: Item) => void;
-}
-export declare function Tree<Item extends TreeItem>({ items, label, render_item, render_extra, name_of, collapsed, on_collapsed_change, selected_id, selected_ids, on_select, on_activate, row_class: class_of, on_move, can_drop, allow_inside, new_item, on_context_menu, accepts_external, on_external_drop, }: TreeProps<Item>): import("react").JSX.Element;

package/dist/web/react/tree.js

@@ -1,183 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// A tree of rows: fold and unfold, walk it with the arrow keys, and reorder it by dragging or with Alt and the arrow keys.
-import { useEffect, useRef, useState } from "react";
-import { by_position, can_drop as is_outside_subtree, key_drop, move_for_drop, nest, placement_at, } from "../tree.js";
-const KEY_MOVES = { ArrowUp: "up", ArrowDown: "down", ArrowRight: "indent", ArrowLeft: "outdent" };
-// The rows a person can see, top to bottom, skipping those inside folded rows.
-function visible_nodes(nodes, collapsed) {
-    return nodes.flatMap((node) => [node, ...(collapsed.has(node.item.id) ? [] : visible_nodes(node.children, collapsed))]);
-}
-export function Tree({ items, label, render_item, render_extra, name_of, collapsed, on_collapsed_change, selected_id = null, selected_ids, on_select, on_activate, row_class: class_of, on_move, can_drop, allow_inside = true, new_item = null, on_context_menu, accepts_external, on_external_drop, }) {
-    const [focused_id, set_focused_id] = useState(null);
-    const [dragged_id, set_dragged_id] = useState(null);
-    const [drop_target, set_drop_target] = useState(null);
-    const row_elements = useRef(new Map());
-    const moves_focus = useRef(false);
-    const roots = nest([...items].sort(by_position), items);
-    const shown = visible_nodes(roots, collapsed);
-    const is_selected = (id) => selected_id === id || Boolean(selected_ids?.has(id));
-    const first_selected = shown.find((node) => selected_ids?.has(node.item.id))?.item.id ?? null;
-    const tab_stop = [focused_id, selected_id, first_selected].find((id) => id !== null && shown.some((node) => node.item.id === id)) ?? shown[0]?.item.id;
-    useEffect(() => {
-        if (!moves_focus.current || focused_id === null)
-            return;
-        moves_focus.current = false;
-        row_elements.current.get(focused_id)?.focus();
-    }, [focused_id, items]);
-    // ── Folding ────────────────────────────────────────────────────────────────
-    function set_collapsed(id, is_collapsed) {
-        if (collapsed.has(id) === is_collapsed)
-            return;
-        const next = new Set(collapsed);
-        if (is_collapsed)
-            next.add(id);
-        else
-            next.delete(id);
-        on_collapsed_change(next);
-    }
-    // ── Moving ─────────────────────────────────────────────────────────────────
-    function is_allowed(dragged, target, placement) {
-        if (placement === "inside" && !allow_inside)
-            return false;
-        return is_outside_subtree(dragged.id, target.id, items) && (can_drop?.(dragged, target, placement) ?? true);
-    }
-    // A row dropped into a folded one unfolds it, so the moved row stays in sight.
-    function move(item, target, placement) {
-        if (placement === "inside")
-            set_collapsed(target.id, false);
-        on_move(item, move_for_drop(item, target, placement, items));
-    }
-    function placement_over(event, target) {
-        const dragged = items.find((item) => item.id === dragged_id);
-        if (!dragged)
-            return null;
-        const box = event.currentTarget.getBoundingClientRect();
-        const placement = placement_at(box.height > 0 ? (event.clientY - box.top) / box.height : 0.5, allow_inside);
-        return is_allowed(dragged, target, placement) ? placement : null;
-    }
-    // A drag from outside the tree, such as a task, lands inside the row that accepts it.
-    function accepts_from_outside(event, target) {
-        return dragged_id === null && Boolean(accepts_external?.(event, target));
-    }
-    function drag_over(event, target) {
-        const external = accepts_from_outside(event, target);
-        const placement = external ? "inside" : placement_over(event, target);
-        if (!placement)
-            return;
-        event.preventDefault();
-        // An outside drag keeps the effect its source allowed, which may not include a move.
-        if (event.dataTransfer && !external)
-            event.dataTransfer.dropEffect = "move";
-        if (drop_target?.id !== target.id || drop_target.placement !== placement)
-            set_drop_target({ id: target.id, placement });
-    }
-    function drop(event, target) {
-        if (accepts_from_outside(event, target)) {
-            event.preventDefault();
-            end_drag();
-            on_external_drop?.(event, target);
-            return;
-        }
-        const placement = placement_over(event, target);
-        const dragged = items.find((item) => item.id === dragged_id);
-        end_drag();
-        if (!placement || !dragged)
-            return;
-        event.preventDefault();
-        move(dragged, target, placement);
-    }
-    function end_drag() {
-        set_dragged_id(null);
-        set_drop_target(null);
-    }
-    // ── Keyboard ───────────────────────────────────────────────────────────────
-    function focus_row(id) {
-        if (id === undefined)
-            return;
-        moves_focus.current = true;
-        set_focused_id(id);
-    }
-    function key_down(event) {
-        const row = event.target.closest("[role='treeitem']");
-        if (row !== event.target)
-            return;
-        const index = shown.findIndex((node) => node.item.id === row.dataset.id);
-        const node = shown[index];
-        if (!node)
-            return;
-        const { item } = node;
-        const is_open = node.children.length > 0 && !collapsed.has(item.id);
-        if (event.altKey && on_move && KEY_MOVES[event.key]) {
-            const key_target = key_drop(item, KEY_MOVES[event.key], items);
-            if (key_target && is_allowed(item, key_target.target, key_target.placement)) {
-                move(item, key_target.target, key_target.placement);
-                focus_row(item.id);
-            }
-        }
-        else if (event.altKey || event.ctrlKey || event.metaKey) {
-            return;
-        }
-        else if (event.key === "ArrowDown")
-            focus_row(shown[index + 1]?.item.id);
-        else if (event.key === "ArrowUp")
-            focus_row(shown[index - 1]?.item.id);
-        else if (event.key === "Home")
-            focus_row(shown[0]?.item.id);
-        else if (event.key === "End")
-            focus_row(shown.at(-1)?.item.id);
-        else if (event.key === "ArrowRight") {
-            if (is_open)
-                focus_row(node.children[0].item.id);
-            else if (node.children.length > 0)
-                set_collapsed(item.id, false);
-            else
-                return;
-        }
-        else if (event.key === "ArrowLeft") {
-            if (is_open)
-                set_collapsed(item.id, true);
-            else if (item.parent_id !== null && shown.some((each) => each.item.id === item.parent_id))
-                focus_row(item.parent_id);
-            else
-                return;
-        }
-        else if ((event.key === "Enter" || event.key === " ") && on_select)
-            on_select(item);
-        else
-            return;
-        event.preventDefault();
-    }
-    // ── Rows ───────────────────────────────────────────────────────────────────
-    function new_item_row(parent_id) {
-        if (!new_item || new_item.parent_id !== parent_id)
-            return null;
-        return _jsx("li", { role: "none", className: "tree-new", children: new_item.form });
-    }
-    function branch(node, depth) {
-        const { item, children } = node;
-        const has_children = children.length > 0;
-        const is_collapsed = collapsed.has(item.id);
-        const name = name_of?.(item) ?? "row";
-        const new_child = new_item_row(item.id);
-        const row_class = [
-            "tree-row",
-            class_of?.(item),
-            dragged_id === item.id && "dragging",
-            drop_target?.id === item.id && `drop-${drop_target.placement}`,
-        ].filter(Boolean).join(" ");
-        return (_jsxs("li", { ref: (element) => { if (element)
-                row_elements.current.set(item.id, element);
-            else
-                row_elements.current.delete(item.id); }, role: "treeitem", className: "tree-item", "data-id": item.id, "aria-level": depth + 1, "aria-expanded": has_children ? !is_collapsed : undefined, "aria-selected": on_select || selected_ids ? is_selected(item.id) : undefined, tabIndex: tab_stop === item.id ? 0 : -1, onFocus: (event) => { if (event.target === event.currentTarget)
-                set_focused_id(item.id); }, children: [_jsxs("div", { className: row_class, draggable: on_move ? true : undefined, onDragStart: (event) => {
-                        event.dataTransfer?.setData("text/plain", item.id);
-                        if (event.dataTransfer)
-                            event.dataTransfer.effectAllowed = "move";
-                        set_dragged_id(item.id);
-                    }, onDragEnd: end_drag, onDragOver: (event) => drag_over(event, item), onDragLeave: () => { if (drop_target?.id === item.id)
-                        set_drop_target(null); }, onDrop: (event) => drop(event, item), onClick: () => { focus_row(item.id); on_select?.(item); }, onDoubleClick: on_activate && (() => on_activate(item)), onContextMenu: on_context_menu && ((event) => on_context_menu(event, item)), children: [has_children
-                            ? (_jsx("button", { type: "button", className: "tree-toggle", tabIndex: -1, "aria-label": is_collapsed ? `Expand ${name}` : `Collapse ${name}`, onClick: (event) => { event.stopPropagation(); set_collapsed(item.id, !is_collapsed); }, children: _jsx("span", { "aria-hidden": "true", children: is_collapsed ? "▸" : "▾" }) }))
-                            : _jsx("span", { className: "tree-toggle", "aria-hidden": "true" }), _jsx("span", { className: "tree-label", children: render_item(item) }), render_extra && _jsx("span", { className: "tree-extra", children: render_extra(item) })] }), ((has_children && !is_collapsed) || new_child) && (_jsxs("ul", { role: "group", className: "tree-children", children: [!is_collapsed && children.map((child) => branch(child, depth + 1)), new_child] }))] }, item.id));
-    }
-    return (_jsxs("ul", { role: "tree", className: "tree", "aria-label": label, "aria-multiselectable": selected_ids ? true : undefined, onKeyDown: key_down, children: [roots.map((node) => branch(node, 0)), new_item_row(null)] }));
-}

package/dist/web/react/volume.d.ts

@@ -1,8 +0,0 @@
-interface VolumeButtonProps {
-    volume: number;
-    on_change: (volume: number) => void;
-    step?: number;
-    label?: string;
-}
-export declare function VolumeButton({ volume, on_change, step, label }: VolumeButtonProps): import("react").JSX.Element;
-export {};

package/dist/web/react/volume.js

@@ -1,42 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// A speaker button that opens a volume slider; scrolling over it adjusts the volume and a middle-click mutes.
-import { useEffect, useRef, useState } from "react";
-import { Popover } from "./menus.js";
-const speaker_icon = (volume) => volume === 0 ? "🔇" : volume < 34 ? "🔈" : volume < 67 ? "🔉" : "🔊";
-export function VolumeButton({ volume, on_change, step = 5, label = "Volume" }) {
-    const [open, set_open] = useState(false);
-    const trigger = useRef(null);
-    // The level before muting, so unmuting returns to it.
-    const before_mute = useRef(volume || 80);
-    // The click that closed the popover by landing on its button must not open it again.
-    const closed_at = useRef(0);
-    const latest_volume = useRef(volume);
-    latest_volume.current = volume;
-    function set(next) {
-        on_change(Math.max(0, Math.min(100, Math.round(next))));
-    }
-    function toggle_mute() {
-        if (latest_volume.current > 0) {
-            before_mute.current = latest_volume.current;
-            set(0);
-        }
-        else {
-            set(before_mute.current || 80);
-        }
-    }
-    // React's wheel listener is passive and cannot stop the page scrolling, so this one is attached by hand.
-    useEffect(() => {
-        const on_wheel = (event) => {
-            event.preventDefault();
-            set(latest_volume.current + (event.deltaY < 0 ? step : -step));
-        };
-        const button = trigger.current;
-        button.addEventListener("wheel", on_wheel, { passive: false });
-        return () => button.removeEventListener("wheel", on_wheel);
-    }, [step]);
-    return (_jsxs(_Fragment, { children: [_jsx("button", { ref: trigger, type: "button", className: "icon volume-button", "aria-label": `${label} ${volume}%`, "aria-haspopup": "dialog", "aria-expanded": open, title: `${label} ${volume}% — scroll to adjust, middle-click to mute`, onClick: () => { if (Date.now() - closed_at.current > 300)
-                    set_open(!open); }, onAuxClick: (event) => { if (event.button === 1) {
-                    event.preventDefault();
-                    toggle_mute();
-                } }, children: speaker_icon(volume) }), open && (_jsx(Popover, { anchor: trigger.current, label: label, on_close: () => { closed_at.current = Date.now(); set_open(false); }, children: _jsxs("div", { className: "volume-popover", children: [_jsx("button", { type: "button", className: "icon", onClick: toggle_mute, "aria-label": volume === 0 ? "Unmute" : "Mute", children: volume === 0 ? "🔇" : "🔊" }), _jsx("input", { className: "seek input-sm", style: { "--range-progress": `${volume}%` }, type: "range", min: 0, max: 100, step: step, value: volume, "aria-label": label, onChange: (event) => set(Number(event.currentTarget.value)) }), _jsxs("span", { className: "volume-percent", children: [volume, "%"] })] }) }))] }));
-}

package/dist/web/react/watch.d.ts

@@ -1,3 +0,0 @@
-import type { Watch } from "../watch.ts";
-export type { Watch } from "../watch.ts";
-export declare function use_watch(watch: Watch): number;

package/dist/web/react/watch.js

@@ -1,5 +0,0 @@
-// Redraws a component whenever a watch it reads is bumped.
-import { useSyncExternalStore } from "react";
-export function use_watch(watch) {
-    return useSyncExternalStore(watch.subscribe, watch.version);
-}

package/dist/web/router.d.ts

@@ -1,7 +0,0 @@
-export interface Route {
-    parts: string[];
-    query: URLSearchParams;
-}
-export declare function current_route(): Route;
-export declare function link(parts: string[], values?: Record<string, string | number | null | undefined>): string;
-export declare function replace_query(changes: Record<string, string | number | null | undefined>): URLSearchParams;

package/dist/web/router.js

@@ -1,29 +0,0 @@
-// Reads and writes the hash route: a path such as #/hosts/odin, and a query holding a view's filters.
-export function current_route() {
-    const hash = location.hash.replace(/^#\/?/, "");
-    const [path, search = ""] = hash.split("?", 2);
-    return { parts: path.split("/").filter(Boolean).map(decodeURIComponent), query: new URLSearchParams(search) };
-}
-// A link to a path built from parts, each one encoded, with an optional query.
-export function link(parts, values = {}) {
-    const params = new URLSearchParams();
-    for (const [name, value] of Object.entries(values)) {
-        if (value !== null && value !== undefined && value !== "")
-            params.set(name, String(value));
-    }
-    const search = params.toString();
-    return `#/${parts.map(encodeURIComponent).join("/")}${search ? `?${search}` : ""}`;
-}
-// Changes the current route's query without a new history entry or a redraw, so typing in a filter keeps focus.
-export function replace_query(changes) {
-    const route = current_route();
-    for (const [name, value] of Object.entries(changes)) {
-        if (value === null || value === undefined || value === "")
-            route.query.delete(name);
-        else
-            route.query.set(name, String(value));
-    }
-    const search = route.query.toString();
-    history.replaceState(null, "", `#/${route.parts.map(encodeURIComponent).join("/")}${search ? `?${search}` : ""}`);
-    return route.query;
-}

package/dist/web/selection.d.ts

@@ -1,25 +0,0 @@
-export type SelectionIntent = "replace" | "toggle" | "range" | "range-add";
-export declare function intent_for(modifiers: {
-    shift?: boolean;
-    ctrl?: boolean;
-}): SelectionIntent;
-export declare class Selection<Id = number> {
-    private readonly picked;
-    private anchor;
-    get size(): number;
-    has(id: Id): boolean;
-    ids(): Id[];
-    inspect(): {
-        size: number;
-        anchor: number | null;
-    };
-    clear(): void;
-    apply(ordered: readonly Id[], index: number, intent: SelectionIntent): void;
-    select_all(ordered: readonly Id[]): void;
-    invert(ordered: readonly Id[]): void;
-    retain(ordered: readonly Id[]): void;
-}
-export declare function toggled(picked: readonly string[], id: string): string[];
-export declare function with_range(order: readonly string[], picked: readonly string[], anchor_id: string | null, id: string): string[];
-export declare function still_shown(order: readonly string[], picked: readonly string[]): string[];
-export declare function row_after_key(key: string, current: number, last: number, rows_per_page: number): number | null;

package/dist/web/selection.js

@@ -1,106 +0,0 @@
-// Picking rows in a list: plain, Ctrl and Shift clicks, an anchor ranges measure from, and the row an arrow or page key moves to.
-export function intent_for(modifiers) {
-    if (modifiers.shift)
-        return modifiers.ctrl ? "range-add" : "range";
-    return modifiers.ctrl ? "toggle" : "replace";
-}
-// ── Selection ────────────────────────────────────────────────────────────────
-export class Selection {
-    picked = new Set();
-    anchor = null;
-    get size() {
-        return this.picked.size;
-    }
-    has(id) {
-        return this.picked.has(id);
-    }
-    ids() {
-        return [...this.picked];
-    }
-    // The picks and the anchor, for finding why a range came out wrong.
-    inspect() {
-        return { size: this.picked.size, anchor: this.anchor };
-    }
-    clear() {
-        this.picked.clear();
-        this.anchor = null;
-    }
-    // Applies a click on the row at index in the list as shown.
-    apply(ordered, index, intent) {
-        if (index < 0 || index >= ordered.length)
-            return;
-        const id = ordered[index];
-        if (intent === "replace") {
-            this.picked.clear();
-            this.picked.add(id);
-            this.anchor = index;
-            return;
-        }
-        if (intent === "toggle") {
-            if (this.picked.has(id))
-                this.picked.delete(id);
-            else
-                this.picked.add(id);
-            this.anchor = index;
-            return;
-        }
-        // The anchor stays put, so every extension measures from the same row.
-        const from = this.anchor ?? index;
-        const [low, high] = from <= index ? [from, index] : [index, from];
-        if (intent === "range")
-            this.picked.clear();
-        for (let row = low; row <= high; row += 1)
-            this.picked.add(ordered[row]);
-    }
-    select_all(ordered) {
-        for (const id of ordered)
-            this.picked.add(id);
-    }
-    invert(ordered) {
-        const next = ordered.filter((id) => !this.picked.has(id));
-        this.picked.clear();
-        for (const id of next)
-            this.picked.add(id);
-    }
-    // Drops picks no longer in the list, such as after a filter narrows it.
-    retain(ordered) {
-        const kept = new Set(ordered);
-        for (const id of this.picked)
-            if (!kept.has(id))
-                this.picked.delete(id);
-    }
-}
-// ── Ids ──────────────────────────────────────────────────────────────────────
-// The same picking as plain lists of ids held in an app's state, the anchor kept by id so it survives the rows moving between clicks.
-// Adds the id when missing and takes it out when there.
-export function toggled(picked, id) {
-    return picked.includes(id) ? picked.filter((each) => each !== id) : [...picked, id];
-}
-// Every id between the anchor and the id in the shown order, both included, added to those picked; just the id when the anchor is not shown.
-export function with_range(order, picked, anchor_id, id) {
-    const anchor_index = anchor_id === null ? -1 : order.indexOf(anchor_id);
-    const index = order.indexOf(id);
-    if (anchor_index === -1 || index === -1)
-        return [id];
-    const run = order.slice(Math.min(anchor_index, index), Math.max(anchor_index, index) + 1);
-    return [...picked.filter((each) => !run.includes(each)), ...run];
-}
-// Keeps only the picked ids still shown, in the shown order.
-export function still_shown(order, picked) {
-    const picked_ids = new Set(picked);
-    return order.filter((id) => picked_ids.has(id));
-}
-// ── Keys ─────────────────────────────────────────────────────────────────────
-// The row an arrow, page, Home or End key moves to, held inside the list, or null for any other key.
-export function row_after_key(key, current, last, rows_per_page) {
-    const clamp = (row) => Math.min(last, Math.max(0, row));
-    switch (key) {
-        case "ArrowDown": return clamp(current + 1);
-        case "ArrowUp": return clamp(current - 1);
-        case "PageDown": return clamp(current + rows_per_page);
-        case "PageUp": return clamp(current - rows_per_page);
-        case "Home": return 0;
-        case "End": return Math.max(0, last);
-        default: return null;
-    }
-}

package/dist/web/split.d.ts

@@ -1,15 +0,0 @@
-export interface PaneSpec {
-    min?: number;
-    max?: number;
-    grow?: boolean;
-}
-export declare const keyboard_step = 16;
-export declare const keyboard_step_large = 64;
-export declare function resize_at(sizes: readonly number[], index: number, delta: number, specs?: readonly PaneSpec[]): number[];
-export declare function fit(sizes: readonly number[], total: number, specs?: readonly PaneSpec[]): number[];
-export declare function distribute(total: number, specs: readonly PaneSpec[], preferred?: readonly (number | undefined)[]): number[];
-export declare function stored_sizes(storage_key: string, count: number): number[] | null;
-export declare function store_sizes(storage_key: string, sizes: readonly number[]): void;
-export type Axis = "horizontal" | "vertical";
-export declare function follow_drag(handle: HTMLElement, start: PointerEvent, axis: Axis, on_move: (moved: number) => void, on_end: () => void): void;
-export declare function key_step(event: KeyboardEvent, axis: Axis): number | null;

package/dist/web/split.js

@@ -1,104 +0,0 @@
-// Resizing panes: the arithmetic of what a drag may do, and the pointer and keyboard handling of a resize handle.
-const default_minimum = 40;
-// How far one arrow press moves a handle, and how far with Shift held.
-export const keyboard_step = 16;
-export const keyboard_step_large = 64;
-const minimum_of = (spec) => spec?.min ?? default_minimum;
-const maximum_of = (spec) => spec?.max ?? Number.POSITIVE_INFINITY;
-const clamp = (value, low, high) => Math.min(Math.max(value, low), high);
-// ── Sizing ───────────────────────────────────────────────────────────────────
-// Moves the boundary after pane index by delta pixels, changing only its two neighbours and stopping where either hits a limit.
-export function resize_at(sizes, index, delta, specs = []) {
-    const before = sizes[index];
-    const after = sizes[index + 1];
-    if (before === undefined || after === undefined)
-        return [...sizes];
-    const most_growth = Math.min(maximum_of(specs[index]) - before, after - minimum_of(specs[index + 1]));
-    const most_shrink = Math.min(before - minimum_of(specs[index]), maximum_of(specs[index + 1]) - after);
-    const applied = clamp(delta, -most_shrink, most_growth);
-    const next = [...sizes];
-    next[index] = before + applied;
-    next[index + 1] = after - applied;
-    return next;
-}
-// Fits panes to the container's length, growing panes first and every pane otherwise, never below a pane's minimum.
-export function fit(sizes, total, specs = []) {
-    if (sizes.length === 0)
-        return [];
-    const next = [...sizes];
-    let difference = total - next.reduce((sum, size) => sum + size, 0);
-    if (Math.abs(difference) < 0.5)
-        return next.map(Math.round);
-    const growers = next.map((_, index) => index).filter((index) => specs[index]?.grow);
-    const targets = growers.length > 0 ? growers : next.map((_, index) => index);
-    // A pane that hits its limit hands the rest back to the others, so a few passes share it out.
-    for (let pass = 0; pass < 4 && Math.abs(difference) > 0.5; pass += 1) {
-        const with_room = targets.filter((index) => difference > 0 ? next[index] < maximum_of(specs[index]) : next[index] > minimum_of(specs[index]));
-        if (with_room.length === 0)
-            break;
-        const share = difference / with_room.length;
-        for (const index of with_room) {
-            const before = next[index];
-            next[index] = clamp(before + share, minimum_of(specs[index]), maximum_of(specs[index]));
-            difference -= next[index] - before;
-        }
-    }
-    return next.map(Math.round);
-}
-// The first sizes for a container: each pane's preferred size or minimum, fitted to the length.
-export function distribute(total, specs, preferred) {
-    return fit(specs.map((spec, index) => preferred?.[index] ?? spec.min ?? total / specs.length), total, specs);
-}
-// ── Remembering ──────────────────────────────────────────────────────────────
-// The sizes kept under the key, or null when there are none for this many panes.
-export function stored_sizes(storage_key, count) {
-    try {
-        const parsed = JSON.parse(localStorage.getItem(storage_key) ?? "null");
-        if (!Array.isArray(parsed) || parsed.length !== count)
-            return null;
-        return parsed.every((size) => typeof size === "number" && Number.isFinite(size)) ? parsed : null;
-    }
-    catch {
-        return null;
-    }
-}
-export function store_sizes(storage_key, sizes) {
-    try {
-        localStorage.setItem(storage_key, JSON.stringify(sizes));
-    }
-    catch {
-        // Without storage the sizes last until the page is closed.
-    }
-}
-// Follows a drag that starts on the handle, handing on how far the pointer has moved along the axis.
-export function follow_drag(handle, start, axis, on_move, on_end) {
-    if (start.button !== 0)
-        return;
-    start.preventDefault();
-    const origin = axis === "horizontal" ? start.clientX : start.clientY;
-    const move = (event) => on_move((axis === "horizontal" ? event.clientX : event.clientY) - origin);
-    const stop = () => {
-        if (handle.hasPointerCapture(start.pointerId))
-            handle.releasePointerCapture(start.pointerId);
-        handle.removeEventListener("pointermove", move);
-        handle.removeEventListener("pointerup", stop);
-        handle.removeEventListener("pointercancel", stop);
-        handle.classList.remove("dragging");
-        document.body.classList.remove("resizing", "vertical");
-        on_end();
-    };
-    handle.setPointerCapture(start.pointerId);
-    handle.addEventListener("pointermove", move);
-    handle.addEventListener("pointerup", stop);
-    handle.addEventListener("pointercancel", stop);
-    handle.classList.add("dragging");
-    document.body.classList.add("resizing");
-    if (axis === "vertical")
-        document.body.classList.add("vertical");
-}
-// How far an arrow key moves a handle along the axis, or null for any other key.
-export function key_step(event, axis) {
-    const step = event.shiftKey ? keyboard_step_large : keyboard_step;
-    const steps = axis === "horizontal" ? { ArrowLeft: -step, ArrowRight: step } : { ArrowUp: -step, ArrowDown: step };
-    return steps[event.key] ?? null;
-}

package/dist/web/states.d.ts

@@ -1,3 +0,0 @@
-export declare class LoginNeeded extends Error {
-}
-export declare function pass_login_needed(error: unknown): boolean;