@adecore/ui 0.14.0

package/dist/modality.js

@@ -0,0 +1,29 @@
+let current = null;
+let started = false;
+const set = (modality) => {
+    if (current === modality) {
+        return;
+    }
+    current = modality;
+    document.documentElement.dataset.modality = modality;
+};
+/* Which device the app was last driven with, on the root element as `data-modality`. A ring that
+   only belongs to keyboard navigation cannot ask `:focus-visible` alone. Focus that a script moves
+   (Base UI does that for the hovered menu item) keeps matching it while the browser's own keyboard
+   flag is up, which a single keystroke anywhere, a terminal included, leaves on. Once per page;
+   `UIProvider` starts it, and a second call does nothing. */
+export function startInputModality() {
+    if (started) {
+        return;
+    }
+    started = true;
+    set('pointer');
+    window.addEventListener('keydown', (event) => {
+        // A modifier on its own is half of a shift-click as often as it is a keystroke.
+        if (event.key !== 'Shift' && event.key !== 'Control' && event.key !== 'Alt' && event.key !== 'Meta') {
+            set('keyboard');
+        }
+    }, { capture: true });
+    window.addEventListener('pointerdown', () => set('pointer'), { capture: true, passive: true });
+    window.addEventListener('pointermove', () => set('pointer'), { capture: true, passive: true });
+}

package/dist/platform.d.ts

@@ -0,0 +1,2 @@
+export declare const isApplePlatform: () => boolean;
+export declare const applePlatformFrom: (platform: string | undefined) => boolean;

package/dist/platform.js

@@ -0,0 +1,9 @@
+/* True on macOS and iOS, where a shortcut is written with ⌘ instead of Ctrl. The keyboard in question is the one in front of this page. */
+export const isApplePlatform = () => {
+    if (typeof navigator === 'undefined') {
+        return false;
+    }
+    const hints = navigator.userAgentData;
+    return applePlatformFrom(hints?.platform || navigator.platform);
+};
+export const applePlatformFrom = (platform) => /mac|iphone|ipad/i.test(platform ?? '');

package/dist/popover/index.parts.d.ts

@@ -0,0 +1 @@
+export { PopoverClose as Close, PopoverDescription as Description, PopoverPopup as Popup, PopoverRoot as Root, PopoverTitle as Title, PopoverTrigger as Trigger } from './parts.tsx';

package/dist/popover/index.parts.js

@@ -0,0 +1 @@
+export { PopoverClose as Close, PopoverDescription as Description, PopoverPopup as Popup, PopoverRoot as Root, PopoverTitle as Title, PopoverTrigger as Trigger } from './parts.js';

package/dist/popover/parts.d.ts

@@ -0,0 +1,26 @@
+import type { ComponentProps } from 'react';
+import { Popover as BasePopover } from '@base-ui-components/react/popover';
+import { PreviewCard as BasePreviewCard } from '@base-ui-components/react/preview-card';
+declare const POPUP_VARIANT: {
+    readonly menu: 'menu-popup';
+    readonly picker: 'picker-popup';
+    readonly plain: '';
+};
+export type PopupVariant = keyof typeof POPUP_VARIANT;
+type Placement = Pick<ComponentProps<typeof BasePopover.Positioner>, 'side' | 'align' | 'sideOffset' | 'alignOffset' | 'collisionPadding' | 'collisionBoundary' | 'collisionAvoidance' | 'anchor' | 'sticky' | 'positionMethod'>;
+export declare const PopoverRoot: typeof BasePopover.Root;
+export declare const PopoverTrigger: BasePopover.Trigger;
+export declare const PopoverClose: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/popover").PopoverCloseProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const PopoverTitle: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/popover").PopoverTitleProps & import("react").RefAttributes<HTMLHeadingElement>>;
+export declare const PopoverDescription: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/popover").PopoverDescriptionProps & import("react").RefAttributes<HTMLParagraphElement>>;
+export type PopoverPopupProps = ComponentProps<typeof BasePopover.Popup> & Placement & {
+    variant?: PopupVariant;
+};
+export declare function PopoverPopup({ variant, side, align, sideOffset, alignOffset, collisionPadding, collisionBoundary, collisionAvoidance, anchor, sticky, positionMethod, className, ...props }: PopoverPopupProps): import("react").JSX.Element;
+export declare const PreviewCardRoot: typeof BasePreviewCard.Root;
+export declare const PreviewCardTrigger: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/preview-card").PreviewCardTriggerProps & import("react").RefAttributes<HTMLAnchorElement>>;
+export type PreviewCardPopupProps = ComponentProps<typeof BasePreviewCard.Popup> & Placement & {
+    variant?: PopupVariant;
+};
+export declare function PreviewCardPopup({ variant, side, align, sideOffset, alignOffset, collisionPadding, collisionBoundary, collisionAvoidance, anchor, sticky, positionMethod, className, ...props }: PreviewCardPopupProps): import("react").JSX.Element;
+export {};

package/dist/popover/parts.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Popover as BasePopover } from '@base-ui-components/react/popover';
+import { PreviewCard as BasePreviewCard } from '@base-ui-components/react/preview-card';
+import { withClass } from '../class-name.js';
+/*
+ * The surface a popup is drawn on. `menu` is the padded card menus use, `picker` a card whose
+ * content runs to its edges (a search field on top of a list), and `plain` leaves the surface to the caller.
+ */
+const POPUP_VARIANT = {
+    menu: 'menu-popup',
+    picker: 'picker-popup',
+    plain: ''
+};
+export const PopoverRoot = BasePopover.Root;
+export const PopoverTrigger = BasePopover.Trigger;
+export const PopoverClose = BasePopover.Close;
+export const PopoverTitle = BasePopover.Title;
+export const PopoverDescription = BasePopover.Description;
+/* The portal, the positioner and the popup of a popover: under its trigger and lined up with its start unless it says otherwise. */
+export function PopoverPopup({ variant = 'menu', side = 'bottom', align = 'start', sideOffset = 8, alignOffset, collisionPadding, collisionBoundary, collisionAvoidance, anchor, sticky, positionMethod, className, ...props }) {
+    return (_jsx(BasePopover.Portal, { children: _jsx(BasePopover.Positioner, { className: "popup-positioner", side: side, align: align, sideOffset: sideOffset, alignOffset: alignOffset, collisionPadding: collisionPadding, collisionBoundary: collisionBoundary, collisionAvoidance: collisionAvoidance, anchor: anchor, sticky: sticky, positionMethod: positionMethod, children: _jsx(BasePopover.Popup, { className: withClass(POPUP_VARIANT[variant], className), ...props }) }) }));
+}
+export const PreviewCardRoot = BasePreviewCard.Root;
+export const PreviewCardTrigger = BasePreviewCard.Trigger;
+/* A card that opens while the pointer rests on its trigger, drawn like a popover. */
+export function PreviewCardPopup({ variant = 'menu', side = 'bottom', align = 'start', sideOffset = 8, alignOffset, collisionPadding, collisionBoundary, collisionAvoidance, anchor, sticky, positionMethod, className, ...props }) {
+    return (_jsx(BasePreviewCard.Portal, { children: _jsx(BasePreviewCard.Positioner, { className: "z-(--z-popup)", side: side, align: align, sideOffset: sideOffset, alignOffset: alignOffset, collisionPadding: collisionPadding, collisionBoundary: collisionBoundary, collisionAvoidance: collisionAvoidance, anchor: anchor, sticky: sticky, positionMethod: positionMethod, children: _jsx(BasePreviewCard.Popup, { className: withClass(POPUP_VARIANT[variant], className), ...props }) }) }));
+}

package/dist/prefetch.d.ts

@@ -0,0 +1,21 @@
+export type Loader = () => Promise<unknown>;
+export type WhenIdle = (run: () => void) => void;
+export declare class Prefetcher {
+    private readonly registered;
+    private readonly queued;
+    private readonly queue;
+    private everythingOn;
+    private running;
+    private loading;
+    private readonly whenIdle;
+    private readonly allowed;
+    constructor(whenIdle: WhenIdle, allowed?: () => boolean);
+    get busy(): boolean;
+    register(load: Loader): void;
+    prefetch(load: Loader): Promise<void>;
+    prefetchEverything(): Promise<void>;
+    private enqueue;
+    private drain;
+    private loadQueue;
+}
+export declare const prefetcher: Prefetcher;

package/dist/prefetch.js

@@ -0,0 +1,99 @@
+/*
+ * Loads lazy modules ahead of their first opening, one per idle moment and never two at once, so
+ * the first open resolves from the module cache. A loader registered while everything is on
+ * joins the end, which is how a lazy surface inside another lazy one gets its turn.
+ */
+export class Prefetcher {
+    registered = [];
+    queued = new Set();
+    queue = [];
+    everythingOn = false;
+    running = null;
+    loading = false;
+    whenIdle;
+    /* Asked on every start, since a person can turn data saving on while the page runs. */
+    allowed;
+    constructor(whenIdle, allowed = () => true) {
+        this.whenIdle = whenIdle;
+        this.allowed = allowed;
+    }
+    /* True while a prefetch waits on its chunk, so a failure it causes is not taken for a person's. */
+    get busy() {
+        return this.loading;
+    }
+    register(load) {
+        this.registered.push(load);
+        if (this.everythingOn) {
+            this.enqueue(load);
+        }
+    }
+    /* Loads this one module, ahead of whatever is registered. */
+    prefetch(load) {
+        if (!this.allowed()) {
+            return Promise.resolve();
+        }
+        this.enqueue(load);
+        return this.drain();
+    }
+    /* Loads every registered module, and every one registered from now on. */
+    prefetchEverything() {
+        if (!this.allowed()) {
+            return Promise.resolve();
+        }
+        this.everythingOn = true;
+        for (const load of this.registered) {
+            this.enqueue(load);
+        }
+        return this.drain();
+    }
+    enqueue(load) {
+        if (this.queued.has(load)) {
+            return;
+        }
+        this.queued.add(load);
+        this.queue.push(load);
+        void this.drain();
+    }
+    drain() {
+        // Never on an empty queue: `loadQueue` would clear `running` before it is even set.
+        if (this.running === null && this.queue.length > 0) {
+            this.running = this.loadQueue();
+        }
+        return this.running ?? Promise.resolve();
+    }
+    async loadQueue() {
+        try {
+            for (let load = this.queue.shift(); load; load = this.queue.shift()) {
+                await new Promise((resolve) => this.whenIdle(resolve));
+                this.loading = true;
+                try {
+                    await load();
+                }
+                catch {
+                    // A later open tries again; a chunk a deploy removed is the app's to answer, and `busy` tells it this was only a prefetch.
+                }
+                finally {
+                    this.loading = false;
+                }
+            }
+        }
+        finally {
+            this.running = null;
+        }
+    }
+}
+/* Safari has no idle callback; the timeout at least lets the frame that asked finish first. */
+const FALLBACK_DELAY_MS = 50;
+/* A canvas that keeps drawing (a blinking cursor, a stream) may never leave an idle moment, and a prefetch that never runs helps nobody. */
+const IDLE_TIMEOUT_MS = 2000;
+const whenIdle = (run) => {
+    if (typeof requestIdleCallback === 'function') {
+        requestIdleCallback(() => run(), { timeout: IDLE_TIMEOUT_MS });
+        return;
+    }
+    setTimeout(run, FALLBACK_DELAY_MS);
+};
+/* Not in every DOM typing yet, and only Chromium reports it. */
+const savesData = () => navigator.connection?.saveData === true;
+/* The one every `lazyNamed` and `lazyDialog` registers with. */
+export const prefetcher = /* @__PURE__ */ new Prefetcher(whenIdle, () => !savesData());

package/dist/preview-card/index.parts.d.ts

@@ -0,0 +1 @@
+export { PreviewCardPopup as Popup, PreviewCardRoot as Root, PreviewCardTrigger as Trigger } from '../popover/parts.tsx';

package/dist/preview-card/index.parts.js

@@ -0,0 +1 @@
+export { PreviewCardPopup as Popup, PreviewCardRoot as Root, PreviewCardTrigger as Trigger } from '../popover/parts.js';

package/dist/project-switcher-row.d.ts

@@ -0,0 +1,6 @@
+import type { MouseEvent } from 'react';
+import type { ProjectSwitcherItem } from './ProjectSwitcher.tsx';
+export declare function ProjectSwitcherRow<Item extends ProjectSwitcherItem>({ project, onSelect }: {
+    project: Item;
+    onSelect(project: Item, event: MouseEvent<HTMLElement>): void;
+}): import("react").JSX.Element;

package/dist/project-switcher-row.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { useTranslation } from 'react-i18next';
+import { MoreHorizontal } from 'lucide-react';
+import * as Menu from './menu/index.parts.js';
+import { Tooltip } from './Tooltip.js';
+export function ProjectSwitcherRow({ project, onSelect }) {
+    const { t } = useTranslation('ui');
+    const hasActions = Boolean(project.actions);
+    const item = (_jsxs(Menu.Item, { className: clsx('min-w-0', project.muted && 'opacity-50'), disabled: project.disabled, label: project.name, onClick: (event) => onSelect(project, event), children: [project.icon, _jsx("span", { className: "min-w-0 truncate", children: project.name }), project.hint && _jsx("span", { className: "ml-auto truncate pl-3 text-xs text-text-faint", children: project.hint })] }));
+    const row = project.description ? (_jsx(Tooltip, { label: project.description, side: "right", sideOffset: hasActions ? 41 : undefined, children: item })) : (item);
+    if (!hasActions) {
+        return row;
+    }
+    return (_jsxs(Menu.Row, { "aria-label": project.name, children: [row, _jsxs(Menu.SubmenuRoot, { children: [_jsx(Menu.RowSubmenuTrigger, { icon: MoreHorizontal, label: t('projectSwitcher.actionsFor', { name: project.name }) }), _jsx(Menu.Popup, { className: "min-w-52", children: project.actions })] })] }));
+}

package/dist/selection.d.ts

@@ -0,0 +1,2 @@
+export declare const selectionWithin: (element: HTMLElement | null) => string;
+export declare const selectAllWithin: (element: HTMLElement | null) => void;

package/dist/selection.js

@@ -0,0 +1,22 @@
+/*
+ * The text selection, as a context menu has to read it. The app has one selection at a time and a
+ * menu belongs to the surface the click landed on, so both of these are scoped to an element.
+ * A selection somewhere else is no selection this menu can copy.
+ */
+export const selectionWithin = (element) => {
+    const selection = window.getSelection();
+    if (!element || !selection || selection.isCollapsed || selection.rangeCount === 0) {
+        return '';
+    }
+    return element.contains(selection.getRangeAt(0).commonAncestorContainer) ? selection.toString() : '';
+};
+export const selectAllWithin = (element) => {
+    const selection = window.getSelection();
+    if (!element || !selection) {
+        return;
+    }
+    const range = document.createRange();
+    range.selectNodeContents(element);
+    selection.removeAllRanges();
+    selection.addRange(range);
+};