@leavepulse/ui 0.45.1 → 0.47.0

package/dist/components/LpAvatar.vue.d.ts

@@ -5,6 +5,12 @@ declare const __VLS_export: import("vue").DefineComponent<{
     src?: string;
     alt?: string;
     fallback?: string;
+    /**
+     * An icon shown while there is no picture, instead of initials. For things
+     * that have no name worth abbreviating (a world, a mod, a file), where two
+     * letters read as noise. `fallback` text still wins when both are given.
+     */
+    icon?: string;
     size?: "md" | "sm" | "lg" | "xs" | "xl" | undefined;
     /** Explicit pixel size, wins over `size` — for avatars keyed to a layout. */
     pixelSize?: number;
@@ -18,6 +24,12 @@ declare const __VLS_export: import("vue").DefineComponent<{
     src?: string;
     alt?: string;
     fallback?: string;
+    /**
+     * An icon shown while there is no picture, instead of initials. For things
+     * that have no name worth abbreviating (a world, a mod, a file), where two
+     * letters read as noise. `fallback` text still wins when both are given.
+     */
+    icon?: string;
     size?: "md" | "sm" | "lg" | "xs" | "xl" | undefined;
     /** Explicit pixel size, wins over `size` — for avatars keyed to a layout. */
     pixelSize?: number;

package/dist/components/LpAvatar.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpAvatar-C1XStdOo.js";
+import { _ as _sfc_main } from "../chunks/LpAvatar-Cb1jtOVv.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpCard.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpCard-C2IvucmX.js";
+import { _ as _sfc_main } from "../chunks/LpCard-BdxkMXjo.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpChart.vue.js

@@ -5,7 +5,7 @@ import { prefersReducedMotion, easeTravel } from "../composables/easing.js";
 import { usePillTransition } from "../composables/usePillTransition.js";
 import { useReveal } from "../composables/useReveal.js";
 import { normalise, pointCount, resolveLabels, extent, axisTicks, plotHeight, plotWidth, xAt, yAt, areaPath, linePath, barPath, markerIndex, chartSummary, niceScale, nearestIndex, formatTick } from "./chart.js";
-import { _ as _sfc_main$1 } from "../chunks/LpContextMenu-BqkAYa9X.js";
+import { _ as _sfc_main$1 } from "../chunks/LpContextMenu-1cKew_Dc.js";
 import { _ as _sfc_main$2 } from "../chunks/LpIcon-DYtaid0K.js";
 import { _ as _sfc_main$3 } from "../chunks/LpShift-DXNsauQZ.js";
 import { useMergedAttrs } from "../composables/useMergedClass.js";

package/dist/components/LpColorPicker.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpColorPicker-zz4VGkG4.js";
+import { _ as _sfc_main } from "../chunks/LpColorPicker-BLqPX5Vw.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpCommandPalette.vue.d.ts

@@ -1,3 +1,20 @@
+import { type HighlightPart, type PaletteQuery } from "./commandSearch";
+import { type RecentEntry, type RecentItem } from "./commandPalette";
+/**
+ * A picture in a row's icon slot: an avatar, a project logo, a world's
+ * thumbnail. While it loads, and for good if it fails, the row shows
+ * `fallback` (initials) or else `icon`, so a dead link never leaves a hole.
+ */
+export interface CommandImage {
+    src?: string | null;
+    alt?: string;
+    /** Text shown while there is no picture, usually initials. */
+    fallback?: string;
+    /** Icon shown while there is no picture; the command's `icon` when unset. */
+    icon?: string;
+    /** circle for people, soft or square for things. Defaults to soft. */
+    shape?: "circle" | "soft" | "square";
+}
 export interface Command {
     id: string;
     label: string;
@@ -17,6 +34,12 @@ export interface Command {
      */
     highlight?: string[];
     icon?: string;
+    /**
+     * A picture in place of the icon: a URL, or a `CommandImage` with a
+     * fallback. Sized like the icon and faded in once loaded; until then, and
+     * when it fails, the fallback (or `icon`) holds the slot.
+     */
+    image?: string | CommandImage;
     /** Right-aligned hint, e.g. "⌘P". */
     shortcut?: string;
     /** Extra search terms not shown but matched against the query. */
@@ -37,11 +60,60 @@ export interface Command {
      * and what lets the second step search a list too big to enumerate.
      *
      * `onSelect` still runs when the mode opens, so a command can both act and
-     * drill in.
+     * drill in. A fetcher is called like `search` (see CommandFetcher): its
+     * abort signal may never reach the transport, and an answer that lands
+     * after the query moved on or the mode was left is discarded.
      */
-    children?: Command[] | ((query: string, signal: AbortSignal) => Command[] | Promise<Command[]>);
+    children?: Command[] | CommandFetcher;
     /** Placeholder while inside this command's mode. */
     childPlaceholder?: string;
+    /**
+     * The mode's name in the chip beside the box, when the row's label is a
+     * sentence: "Mods" for a row reading `Search mods for "{query}"`. Without
+     * it a `{query}` placeholder and its quotes are dropped from the label.
+     */
+    modeLabel?: string;
+    /**
+     * Typed at the start of the box, enters this command's mode directly, and
+     * whatever follows the prefix becomes the query inside it: ">" for
+     * commands, "mr " for a mod search. Only for a command with `children`,
+     * matched against the list on screen (the root, or the open mode's own
+     * static children), longest prefix first, letters in any case. Entering
+     * this way does not run `onSelect`. The row shows the prefix as its hint
+     * when it has no `shortcut`.
+     */
+    prefix?: string;
+    /**
+     * Opening this mode takes the query typed so far along, operators and
+     * all, so typing "sodium", arrowing to "Search mods" and pressing Enter
+     * opens the mod search already searching for sodium instead of starting
+     * it empty. Backspace out of the mode restores the query as it was.
+     */
+    carryQuery?: boolean;
+    /**
+     * A "search somewhere else" row: listed only while words are typed, for
+     * any words (it is not matched against them), after local and fetched
+     * results: at the end of the list, or of its group when that group is
+     * already listed. `{query}` in the label becomes the
+     * typed words without the operators, `Search Modrinth for "{query}"`;
+     * `-word` and `in:group` still apply to the row's own label, keywords and
+     * group. Usually a mode with `carryQuery`, so picking it runs the search.
+     */
+    fallback?: boolean;
+    /**
+     * Keep this out of the recent history. Picks are remembered wherever they
+     * are made, inside modes and among fetched results too; a pick that is a
+     * setting rather than a destination (a language, a zoom step) can opt out.
+     * Rows offered by Tab (`actions`) are never remembered.
+     */
+    remember?: boolean;
+    /**
+     * A JSON-safe value stored with this command in the recent history and
+     * handed back to `resolveRecent`: what an app needs to rebuild a result
+     * that a search fetched (a project id, a hit), since the command's
+     * functions cannot be stored.
+     */
+    recentData?: unknown;
     /**
      * Keep the palette open after this runs. For a command that toggles
      * something the user may want to toggle again (a theme, a filter) without
@@ -69,8 +141,35 @@ export interface Command {
      * breaks are kept. Without it the pane shows the `excerpt`.
      */
     preview?: string;
+    /**
+     * This row has nothing for the pane, even with a `#preview` slot: the pane
+     * folds away while it is highlighted instead of the slot having to draw a
+     * placeholder. For a whole class of rows, `hasPreview` says it once.
+     */
+    noPreview?: boolean;
     onSelect?: () => void;
 }
+/**
+ * Commands fetched for a query: `search` at the root, a function `children`
+ * inside a mode.
+ *
+ * `query` is the box's positive words only, in the case they were typed:
+ * `sodium -forge in:mods` arrives as "sodium", because a server would treat
+ * the operators as words to find. They come in `parsed` instead (a
+ * PaletteQuery: `raw`, `text`, lowercased `include`, `exclude` and `groups`)
+ * for a provider that can scope or exclude on its side; either way the
+ * palette drops returned rows that match an exclusion or miss an `in:` scope.
+ *
+ * `signal` aborts when the query moves on, the mode is left or the palette
+ * closes. It is a courtesy, not a guarantee: hand it to `fetch` and the
+ * request is cancelled, but a transport that cannot be cancelled (a Tauri
+ * `invoke`, a worker message, most SDKs) never sees it and runs to the end.
+ * That is safe: an answer that lands after a newer request was made, or
+ * after the palette closed, is discarded and never reaches the list, so a
+ * fetcher does not need to check the signal itself. Checking it before an
+ * expensive step is only a saving.
+ */
+export type CommandFetcher = (query: string, signal: AbortSignal, parsed: PaletteQuery) => Command[] | Promise<Command[]>;
 /** Footer hints and the mode chip, spelled out so an app can translate them. */
 export type PaletteLabels = {
     navigate: string;
@@ -113,28 +212,46 @@ type __VLS_Props = {
      * (or too remote) to hand over as a list: people, files, tickets. Called
      * debounced, never for a query shorter than `minChars`, and only its
      * newest call counts: an earlier one that lands late is dropped, so a slow
-     * response can't overwrite a fresher list.
+     * response can't overwrite a fresher list. The abort signal may never
+     * reach the transport (a Tauri invoke cannot be cancelled); the late
+     * answer is discarded all the same. See CommandFetcher for what
+     * `query` and `parsed` hold: the operators are stripped from the first,
+     * and the palette applies them to the results itself.
      *
      * Results join the static commands, so a palette can do both.
      */
-    search?: (query: string, signal: AbortSignal) => Command[] | Promise<Command[]>;
+    search?: CommandFetcher;
     /** Wait after the last keystroke before `search` runs. */
     debounce?: number;
-    /** Shortest query `search` runs for. */
+    /** Shortest query `search` runs for, counted on its positive words. */
     minChars?: number;
     /**
-     * Ids of recently picked commands, newest first — bind it to storage and
-     * the palette opens on what this person actually uses. It only reorders
-     * commands already in the list; an id that no longer resolves is skipped,
-     * so a stored history never resurrects a command that has gone away.
+     * Recently picked commands, newest first — bind it to storage and the
+     * palette opens on what this person actually uses. An item is a root
+     * command's id, or a RecentEntry for a pick made inside a mode or among
+     * fetched results (the `remember` event hands over exactly what to
+     * store; `pushRecent` adds it to a list). A root id only reorders
+     * commands already in the list. An entry is found again down its path
+     * of static children, then through `resolveRecent`, then from its own
+     * `href`; what none of them finds is skipped, so a stored history never
+     * resurrects a command that has gone away.
      */
-    recent?: string[];
+    recent?: RecentItem[];
     /**
      * Let the palette keep the history itself, in localStorage under this key:
-     * every top-level command run is remembered, newest first. Ignored while
-     * `recent` is bound, which stays the way to store it somewhere else.
+     * every pick is remembered, newest first, root ones as bare ids as before
+     * and deeper ones as entries. Ignored while `recent` is bound, which
+     * stays the way to store it somewhere else.
      */
     recentKey?: string;
+    /**
+     * Finds the live command for a remembered pick the palette cannot find
+     * itself: a result a fetcher returned, or one inside a mode whose
+     * children are fetched. Gets the stored entry, with the command's
+     * `recentData` as `data`; returns the command to show and run, or
+     * nothing to drop it.
+     */
+    resolveRecent?: (entry: RecentEntry) => Command | null | undefined;
     /** How many recent commands to surface. */
     recentLimit?: number;
     /** Headings the palette adds itself. */
@@ -155,8 +272,10 @@ type __VLS_Props = {
      * `preview` text, or the `preview` slot. For palettes that search
      * content rather than commands: the excerpt says why a row matched, the
      * pane lets it be read without leaving the page. It opens only for a row
-     * with `preview` or `excerpt` (any row, with the slot): the dialog eases
-     * wider, the pane slides in, and the text arrives paragraph by paragraph.
+     * with `preview` or `excerpt` (any row, with the slot, unless `hasPreview`
+     * or the row's `noPreview` says otherwise): the dialog eases wider, the
+     * pane slides in, and the text arrives paragraph by paragraph. A slot
+     * that renders nothing for a row falls back to that built-in text.
      * Hidden below the md breakpoint, where there is no room beside the list.
      *
      * The width is an inline style rather than a pair of classes: a base
@@ -164,6 +283,14 @@ type __VLS_Props = {
      * build in an order where the base won, and the pane opened squeezed.
      */
     previewPane?: boolean;
+    /**
+     * Which rows the pane opens for. With a `#preview` slot every row would
+     * otherwise qualify, and an app whose previews cover only some kinds of
+     * row had to draw a placeholder for the rest. Return false and the pane
+     * folds away for that row, as it does for a row without text. A row's
+     * own `noPreview` wins over this.
+     */
+    hasPreview?: (command: Command) => boolean;
     /**
      * Frosted glass instead of a solid panel: the page shows through,
      * blurred, under a lighter scrim (.lp-glass-overlay, .lp-scrim--light).
@@ -173,19 +300,29 @@ type __VLS_Props = {
     glass?: boolean;
 };
 type __VLS_Slots = {
-    /** Body of the preview pane for the highlighted command. */
+    /**
+     * Body of the preview pane for the highlighted command. `highlight(text)`
+     * splits any text around the words typed (positive terms only, plus the
+     * command's own `highlight` words), the same matching the rows use; the
+     * LpPalette* blocks take its result wherever they take text, and
+     * `query` is the parsed box for anything else.
+     */
     preview?: (props: {
         command: Command;
+        highlight: (text: string) => HighlightPart[];
+        query: PaletteQuery;
     }) => unknown;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     select: (command: Command) => any;
     "update:open": (value: boolean) => any;
     run: (id: string, command: Command) => any;
+    remember: (item: RecentItem, command: Command) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onSelect?: ((command: Command) => any) | undefined;
     "onUpdate:open"?: ((value: boolean) => any) | undefined;
     onRun?: ((id: string, command: Command) => any) | undefined;
+    onRemember?: ((item: RecentItem, command: Command) => any) | undefined;
 }>, {
     placeholder: string;
     emptyText: string;