@leavepulse/ui 0.45.1 → 0.47.0

package/dist/components/LpShortcutsDialog.vue.js

@@ -1,14 +1,11 @@
-import { defineComponent, computed, openBlock, createBlock, unref, withCtx, createElementVNode, createElementBlock, Fragment, renderList, toDisplayString, createTextVNode, createCommentVNode } from "vue";
-import { _ as _sfc_main$1 } from "../chunks/LpModal-BzTVeNqe.js";
-import { useAppleKeyboard, mergeShortcutGroups, activeShortcuts, useHotkeys, appleModifierLabel } from "../composables/useHotkeys.js";
+import { defineComponent, computed, openBlock, createBlock, unref, withCtx, createElementVNode, createElementBlock, Fragment, renderList, toDisplayString, createTextVNode, createCommentVNode, createVNode } from "vue";
+import LpKeys from "./LpKeys.vue.js";
+import { _ as _sfc_main$1 } from "../chunks/LpModal-JNa3B_Lr.js";
+import { mergeShortcutGroups, activeShortcuts, useHotkeys } from "../composables/useHotkeys.js";
 import { useLabels } from "../composables/useLpConfig.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpShortcutsDialog-CqYX3yy6.css';const _hoisted_1 = { class: "shortcut-groups" };
+import '../assets/LpShortcutsDialog-BUp_BX4s.css';const _hoisted_1 = { class: "shortcut-groups" };
 const _hoisted_2 = ["aria-label", "title"];
-const _hoisted_3 = {
-  key: 0,
-  class: "shortcut-then"
-};
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "LpShortcutsDialog",
   props: {
@@ -25,17 +22,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const props = __props;
     const text = useLabels("shortcuts", {
       title: "Keyboard shortcuts",
-      then: "then",
       conflict: "Also bound elsewhere: only one of them runs",
       group: "General"
     });
-    const apple = useAppleKeyboard();
-    function keysOf(chord) {
-      return chord.split(/\+(?!$)/);
-    }
-    function stepsOf(combo) {
-      return combo.trim().split(/\s+/);
-    }
     const shown = computed(() => props.live ? mergeShortcutGroups(props.groups, activeShortcuts.value) : props.groups);
     const emit = __emit;
     useHotkeys(
@@ -84,18 +73,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                         }, "!", 8, _hoisted_2)) : createCommentVNode("", true)
                       ]),
                       createElementVNode("dd", null, [
-                        (openBlock(true), createElementBlock(Fragment, null, renderList(stepsOf(entry.combo), (step, stepIndex) => {
-                          return openBlock(), createElementBlock(Fragment, {
-                            key: `${step}-${stepIndex}`
-                          }, [
-                            stepIndex ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(unref(text).then), 1)) : createCommentVNode("", true),
-                            (openBlock(true), createElementBlock(Fragment, null, renderList(keysOf(step), (key, index) => {
-                              return openBlock(), createElementBlock("kbd", {
-                                key: `${key}-${index}`
-                              }, toDisplayString(unref(appleModifierLabel)(key.trim(), unref(apple))), 1);
-                            }), 128))
-                          ], 64);
-                        }), 128))
+                        createVNode(LpKeys, {
+                          combo: entry.combo
+                        }, null, 8, ["combo"])
                       ])
                     ]);
                   }), 128))
@@ -109,7 +89,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LpShortcutsDialog = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1c4cf3fa"]]);
+const LpShortcutsDialog = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-611c415f"]]);
 export {
   LpShortcutsDialog as default
 };

package/dist/components/LpSidebar.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpSidebar-Bwws_X29.js";
+import { _ as _sfc_main } from "../chunks/LpSidebar-DpEiGi8L.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpSidebarNav.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpSidebarNav-kx-LdqNU.js";
+import { _ as _sfc_main } from "../chunks/LpSidebarNav-BUuxipX-.js";
 export {
   _sfc_main as default
 };

package/dist/components/LpTable.vue.js

@@ -1,10 +1,10 @@
 import { defineComponent, computed, useAttrs, ref, shallowRef, watch, onMounted, onBeforeUnmount, openBlock, createElementBlock, normalizeClass, createVNode, withCtx, createTextVNode, toDisplayString, createCommentVNode, Fragment, renderList, createElementVNode, Transition, renderSlot, mergeProps, normalizeStyle, createBlock, TransitionGroup, unref, withModifiers, nextTick } from "vue";
 import { _ as _sfc_main$7 } from "../chunks/LpCheckbox-Bkj13CbW.js";
-import { _ as _sfc_main$6 } from "../chunks/LpContextMenu-BqkAYa9X.js";
+import { _ as _sfc_main$6 } from "../chunks/LpContextMenu-1cKew_Dc.js";
 import { _ as _sfc_main$2 } from "../chunks/LpIcon-DYtaid0K.js";
 import { _ as _sfc_main$a } from "../chunks/LpPagination-BcDlo3r_.js";
 import { _ as _sfc_main$8 } from "../chunks/LpPopover-DCKeqiVn.js";
-import { _ as _sfc_main$5 } from "../chunks/LpScrollArea-Bry1fdOM.js";
+import { _ as _sfc_main$5 } from "../chunks/LpScrollArea-Hz3-JWUG.js";
 import { _ as _sfc_main$4 } from "../chunks/LpRollingText-DB7upf-5.js";
 import { _ as _sfc_main$3 } from "../chunks/LpShift-DXNsauQZ.js";
 import { _ as _sfc_main$9 } from "../chunks/LpTableFilter-BV8PpLM9.js";
@@ -18,7 +18,7 @@ import { _ as _sfc_main$1 } from "../chunks/LpButton-CKSwC6Mu.js";
 import { toCsv, downloadFile, fileStem } from "./exportData.js";
 import { summarizeShown, parseTableState, serializeTableState, countValues } from "./tableFilter.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpTable-CPwWxTJS.css';const _hoisted_1 = {
+import '../assets/LpTable-xWwI4KPZ.css';const _hoisted_1 = {
   key: 0,
   class: "flex justify-end"
 };
@@ -544,7 +544,9 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       }
       return t.rowsTotal.replace("{total}", String(props.rows.length));
     });
-    const showBar = computed(() => props.summary || !!props.selectable || activeFilters.value.length > 0);
+    const showBar = computed(
+      () => props.summary || !!props.selectable && props.selected.length > 0 || activeFilters.value.length > 0
+    );
     const filteredOut = computed(() => {
       if (loading.value || failed.value || displayRows.value.length) return false;
       if (props.load) return Object.values(hiddenValues.value).some((set) => set.size);
@@ -726,7 +728,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
         }),
         createVNode(_sfc_main$5, mergeProps(scrollAttrs.value, {
           fade: false,
-          class: "min-h-0 flex-1 rounded-card border border-line",
+          class: "min-h-0 flex-1 rounded-card border border-line bg-surface",
           style: __props.load && floor.value ? { minHeight: `${floor.value + 2}px` } : void 0,
           "bar-inset-top": barInsetTop.value
         }), {
@@ -924,7 +926,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LpTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-fff7ed10"]]);
+const LpTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-4fa70e89"]]);
 export {
   LpTable as default
 };

package/dist/components/LpThemeSwitcher.vue.js

@@ -1,4 +1,4 @@
-import { _ as _sfc_main } from "../chunks/LpThemeSwitcher-B4aVPbNC.js";
+import { _ as _sfc_main } from "../chunks/LpThemeSwitcher-BbYFFT5w.js";
 export {
   _sfc_main as default
 };

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

@@ -0,0 +1,9 @@
+type __VLS_Props = {
+    title: string;
+    subtitle?: string;
+    icon?: string;
+    image?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/MenuTitle.vue.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "../chunks/MenuTitle-J3ZDYjpV.js";
+export {
+  _sfc_main as default
+};

package/dist/components/commandPalette.d.ts

@@ -0,0 +1,157 @@
+import { type CommandSearchTerms, type HighlightPart, type SearchableCommand } from "./commandSearch";
+/** The fields of a command that decide whether the preview pane opens for it. */
+export interface PreviewableCommand {
+    preview?: string;
+    excerpt?: string;
+    noPreview?: boolean;
+}
+/**
+ * Whether the pane has something to show for a row. `noPreview` on the row
+ * wins, then the app's `hasPreview`; without either, a row qualifies when the
+ * app supplied a `#preview` slot or the row carries text of its own.
+ */
+export declare function commandHasPreview<T extends PreviewableCommand>(command: T | undefined, options: {
+    slot: boolean;
+    hasPreview?: (command: T) => boolean;
+}): boolean;
+/** One line of LpPaletteFacts: what it is, and what it is set to now. */
+export interface PaletteFact {
+    /** Text, or the preview slot's `highlight(text)` to mark the query. */
+    label: string | HighlightPart[];
+    /** Right-aligned value; a change rolls in rather than swapping. */
+    value?: string | number;
+    /** A second, quieter line under the label. */
+    hint?: string | HighlightPart[];
+    icon?: string;
+    /** A colour dot in place of the icon: a role colour, a status. */
+    color?: string;
+    /** Marks the row that is in effect now: the current theme, the open tab. */
+    current?: boolean;
+    /** Draw the value in the monospace face: ids, paths, versions. */
+    mono?: boolean;
+}
+/** One tile of LpPaletteStats. */
+export interface PaletteStat {
+    label: string;
+    /** A number counts to its new value; text rolls. */
+    value: number | string;
+    /** Abbreviate a number: 1.2k, 3.4M. */
+    compact?: boolean;
+    suffix?: string;
+    format?: (value: number) => string;
+}
+/** The fields of a command that let typing enter its mode. */
+export interface PrefixedCommand {
+    prefix?: string;
+    children?: unknown;
+    disabled?: boolean;
+}
+/**
+ * The mode a query opens by its prefix, and the query left after it. Only a
+ * command with `children` and a non-empty `prefix` qualifies; letters match
+ * in any case, and the longest prefix wins, so "mr " and "m" can live side by
+ * side. Leading spaces are ignored: they are never what someone meant.
+ */
+export declare function matchModePrefix<T extends PrefixedCommand>(query: string, commands: readonly T[]): {
+    command: T;
+    rest: string;
+} | null;
+/** The fields of a command that make it a "search elsewhere" row. */
+export interface FallbackCommand extends SearchableCommand {
+    fallback?: boolean;
+    hidden?: boolean;
+}
+/**
+ * The fallback rows to show for a query, with their labels filled in. They
+ * appear only while positive words are typed, whatever those words are: the
+ * row offers to search somewhere else for them, so matching it against them
+ * would hide it exactly when it is needed. Exclusions and `in:` scopes still
+ * apply, to the row's own label, keywords and group. `{query}` in the label
+ * becomes the positive words, without the operators.
+ */
+export declare function fallbackRows<T extends FallbackCommand>(items: readonly T[], raw: string): {
+    command: T;
+    label: string;
+}[];
+/**
+ * A remembered pick that is not a root command: one chosen inside a mode, or
+ * a result a search fetched. It keeps what the row needs to be drawn again
+ * and where it was found, so the palette can find the live command next time
+ * (`path` through static children, or the app's `resolveRecent`), and fall
+ * back to its `href` when neither can.
+ */
+export interface RecentEntry {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    image?: string | {
+        src?: string | null;
+        alt?: string;
+        fallback?: string;
+        icon?: string;
+        shape?: "circle" | "soft" | "square";
+    };
+    href?: string;
+    /** Ids of the modes it was picked in, outermost first. */
+    path: string[];
+    /** The command's `recentData`, kept as given for `resolveRecent`. */
+    data?: unknown;
+}
+/** A stored history item: a root command id (the old format), or an entry. */
+export type RecentItem = string | RecentEntry;
+/** The fields of a command a history entry is built from and resolved to. */
+export interface RecentSource {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    image?: RecentEntry["image"];
+    href?: string;
+    recentData?: unknown;
+    disabled?: boolean;
+    children?: unknown;
+}
+/** Stored history, with anything malformed dropped rather than trusted. */
+export declare function readRecent(stored: unknown): RecentItem[];
+/**
+ * The history item for a pick. A root pick stays a bare id, the format older
+ * versions wrote and still read; anything deeper becomes an entry with only
+ * the fields that survive JSON.
+ */
+export declare function toRecentItem(command: RecentSource, path: readonly string[]): RecentItem;
+/** The history with `item` first and any earlier copy of it dropped. */
+export declare function pushRecent(list: readonly RecentItem[], item: RecentItem, keep: number): RecentItem[];
+/**
+ * The live commands a history stands for, newest first. A bare id is looked
+ * up among the root commands; an entry is followed down its path through
+ * static children, then offered to `resolve` (for results a fetcher found),
+ * and last rebuilt from its own fields when it has an `href` to follow.
+ * Whatever none of these can find is skipped, so a stored history never
+ * resurrects something that cannot run.
+ */
+export declare function resolveRecentItems<T extends RecentSource>(items: readonly RecentItem[], commands: readonly T[], options: {
+    limit: number;
+    resolve?: (entry: RecentEntry) => T | null | undefined;
+    fromEntry: (entry: RecentEntry) => T;
+}): {
+    command: T;
+    path: string[];
+}[];
+/**
+ * Whether a recent row survives the operators typed so far. Recent rows show
+ * while no positive words are typed, so "-theme" or "in:recent" filters them
+ * like any other row; an `in:` scope matches the row's own group or the
+ * Recent heading it sits under.
+ */
+export declare function recentVisible(command: SearchableCommand, terms: CommandSearchTerms, recentLabel: string): boolean;
+/**
+ * The name a mode's chip shows. `modeLabel` when given; otherwise the label,
+ * with a `{query}` placeholder and the quotes around it taken out, since the
+ * words it stood for are in the box now ("Search mods for "{query}"" reads
+ * "Search mods").
+ */
+export declare function modeChipLabel(command: {
+    label: string;
+    modeLabel?: string;
+}): string;

package/dist/components/commandPalette.js

@@ -0,0 +1,103 @@
+import { parsePaletteQuery, applyQueryFilters } from "./commandSearch.js";
+function commandHasPreview(command, options) {
+  if (!command || command.noPreview) return false;
+  if (options.hasPreview) return options.hasPreview(command);
+  return options.slot || !!(command.preview || command.excerpt);
+}
+function matchModePrefix(query, commands) {
+  const typed = query.trimStart().toLowerCase();
+  let best = null;
+  for (const command of commands) {
+    const prefix = command.prefix?.toLowerCase();
+    if (!prefix || !command.children || command.disabled || !typed.startsWith(prefix)) continue;
+    if (!best || prefix.length > (best.prefix?.length ?? 0)) best = command;
+  }
+  if (!best) return null;
+  return { command: best, rest: query.trimStart().slice(best.prefix.length) };
+}
+function fallbackRows(items, raw) {
+  const parsed = parsePaletteQuery(raw.trim());
+  if (!parsed.text) return [];
+  return applyQueryFilters(
+    items.filter((c) => c.fallback),
+    parsed
+  ).map((command) => ({ command, label: command.label.split("{query}").join(parsed.text) }));
+}
+function isEntry(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.id === "string" && typeof v.label === "string" && Array.isArray(v.path) && v.path.every((step) => typeof step === "string");
+}
+function readRecent(stored) {
+  if (!Array.isArray(stored)) return [];
+  return stored.filter((v) => typeof v === "string" || isEntry(v));
+}
+function recentKey(item) {
+  return typeof item === "string" ? item : [...item.path, item.id].join("\0");
+}
+function toRecentItem(command, path) {
+  if (!path.length) return command.id;
+  const entry = { id: command.id, label: command.label, path: [...path] };
+  if (command.description) entry.description = command.description;
+  if (command.icon) entry.icon = command.icon;
+  if (typeof command.image === "string") entry.image = command.image;
+  else if (command.image) {
+    const { src, alt, fallback, icon, shape } = command.image;
+    entry.image = { src, alt, fallback, icon, shape };
+  }
+  if (command.href) entry.href = command.href;
+  if (command.recentData !== void 0) entry.data = command.recentData;
+  return entry;
+}
+function pushRecent(list, item, keep) {
+  const key = recentKey(item);
+  return [item, ...list.filter((v) => recentKey(v) !== key)].slice(0, keep);
+}
+function resolveRecentItems(items, commands, options) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (out.length >= options.limit) break;
+    const key = recentKey(item);
+    if (seen.has(key)) continue;
+    const found = typeof item === "string" ? commands.find((c) => c.id === item) : findEntry(item, commands, options);
+    if (!found || found.disabled || found.children) continue;
+    seen.add(key);
+    out.push({ command: found, path: typeof item === "string" ? [] : [...item.path] });
+  }
+  return out;
+}
+function findEntry(entry, commands, options) {
+  let level = commands;
+  for (const step of entry.path) {
+    const mode = level?.find((c) => c.id === step);
+    level = mode && Array.isArray(mode.children) ? mode.children : null;
+  }
+  const live = level?.find((c) => c.id === entry.id);
+  if (live) return live;
+  const resolved = options.resolve?.(entry);
+  if (resolved) return resolved;
+  return entry.href ? options.fromEntry(entry) : void 0;
+}
+function recentVisible(command, terms, recentLabel) {
+  if (!applyQueryFilters([{ ...command, group: void 0 }], { ...terms, groups: [] }).length) return false;
+  return terms.groups.every(
+    (term) => [command.group, recentLabel].some((group) => group?.toLowerCase().includes(term))
+  );
+}
+function modeChipLabel(command) {
+  if (command.modeLabel) return command.modeLabel;
+  if (!command.label.includes("{query}")) return command.label;
+  return command.label.replace(/\s*["'“”«»]?\{query\}["'“”«»]?/g, "").replace(/\s+(for|in|on|:)$/i, "").trim();
+}
+export {
+  commandHasPreview,
+  fallbackRows,
+  matchModePrefix,
+  modeChipLabel,
+  pushRecent,
+  readRecent,
+  recentVisible,
+  resolveRecentItems,
+  toRecentItem
+};

package/dist/components/commandSearch.d.ts

@@ -11,3 +11,35 @@ export interface CommandSearchTerms {
 }
 export declare function parseCommandQuery(value: string): CommandSearchTerms;
 export declare function rankCommandItems<T extends SearchableCommand>(items: T[], terms: CommandSearchTerms): T[];
+/**
+ * A query as a fetcher receives it. `text` is what a remote search should be
+ * sent: the positive words and phrases, in the case they were typed, without
+ * the operators a server would not understand. The operators come alongside
+ * as data, so a provider that can scope or exclude on the server may.
+ */
+export interface PaletteQuery extends CommandSearchTerms {
+    /** The box as typed, operators and all. */
+    raw: string;
+    /** Positive terms joined by spaces, case kept, quotes dropped. */
+    text: string;
+}
+export declare function parsePaletteQuery(raw: string): PaletteQuery;
+/**
+ * The operators applied to results someone else matched: a server answered
+ * the positive words, and `-word` and `in:group` still have to hold for what
+ * it sent back. Positive terms are not re-checked here; the server may match
+ * word forms the text does not contain.
+ */
+export declare function applyQueryFilters<T extends SearchableCommand>(items: T[], terms: CommandSearchTerms): T[];
+/** A run of text, and whether it matched the query. */
+export interface HighlightPart {
+    text: string;
+    hit: boolean;
+}
+/**
+ * Text split around the terms that matched, for <mark> without v-html. Terms
+ * shorter than two characters are skipped (one letter would mark half the
+ * text), longer ones win where two start at the same place, and case is
+ * ignored. Pass positive terms only: an excluded word is never a match.
+ */
+export declare function highlightParts(value: string, terms: readonly string[]): HighlightPart[];

package/dist/components/commandSearch.js

@@ -47,7 +47,55 @@ function score(command, terms) {
 function rankCommandItems(items, terms) {
   return items.map((command) => ({ command, score: score(command, terms) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.command.label.localeCompare(b.command.label)).map((entry) => entry.command);
 }
+function parsePaletteQuery(raw) {
+  const terms = parseCommandQuery(raw);
+  const words = [];
+  QUERY_TOKEN.lastIndex = 0;
+  for (let match; match = QUERY_TOKEN.exec(raw); ) {
+    const text = (match[3] ?? match[4] ?? "").trim();
+    if (text && !match[1] && !match[2]) words.push(text);
+  }
+  return { ...terms, raw, text: words.join(" ") };
+}
+function applyQueryFilters(items, terms) {
+  if (!terms.exclude.length && !terms.groups.length) return items;
+  return items.filter((command) => {
+    const group = command.group?.toLowerCase() ?? "";
+    return !terms.exclude.some((term) => matches(command, term)) && terms.groups.every((term) => group.includes(term));
+  });
+}
+function highlightParts(value, terms) {
+  const sorted = [...new Set(terms.map((t) => t.toLowerCase()).filter((t) => t.length >= 2))].sort(
+    (a, b) => b.length - a.length
+  );
+  if (!value || sorted.length === 0) return value ? [{ text: value, hit: false }] : [];
+  const lower = value.toLowerCase();
+  const parts = [];
+  let i = 0;
+  while (i < value.length) {
+    let at = -1;
+    let term = "";
+    for (const t of sorted) {
+      const found = lower.indexOf(t, i);
+      if (found !== -1 && (at === -1 || found < at || found === at && t.length > term.length)) {
+        at = found;
+        term = t;
+      }
+    }
+    if (at === -1) {
+      parts.push({ text: value.slice(i), hit: false });
+      break;
+    }
+    if (at > i) parts.push({ text: value.slice(i, at), hit: false });
+    parts.push({ text: value.slice(at, at + term.length), hit: true });
+    i = at + term.length;
+  }
+  return parts;
+}
 export {
+  applyQueryFilters,
+  highlightParts,
   parseCommandQuery,
+  parsePaletteQuery,
   rankCommandItems
 };

package/dist/components/keys.d.ts

@@ -0,0 +1,2 @@
+export declare function comboKeys(chord: string): string[];
+export declare function comboSteps(combo: string): string[][];

package/dist/components/keys.js

@@ -0,0 +1,11 @@
+function comboKeys(chord) {
+  return chord.split(/\+(?!$)/);
+}
+function comboSteps(combo) {
+  const trimmed = combo.trim();
+  return trimmed ? trimmed.split(/\s+/).map(comboKeys) : [];
+}
+export {
+  comboKeys,
+  comboSteps
+};

package/dist/composables/useClipboard.js

@@ -1,5 +1,39 @@
 import { ref, onScopeDispose } from "vue";
 import { useToast } from "./useToast.js";
+async function writeAsync(text) {
+  if (typeof navigator === "undefined" || !navigator.clipboard) return false;
+  try {
+    await navigator.clipboard.writeText(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeLegacy(text) {
+  if (typeof document === "undefined") return false;
+  const active = document.activeElement;
+  const selection = document.getSelection();
+  const ranges = selection ? Array.from({ length: selection.rangeCount }, (_, i) => selection.getRangeAt(i)) : [];
+  const field = document.createElement("textarea");
+  field.value = text;
+  field.setAttribute("readonly", "");
+  field.style.cssText = "position:fixed;top:0;left:0;width:1px;height:1px;opacity:0;pointer-events:none";
+  document.body.appendChild(field);
+  field.select();
+  let ok = false;
+  try {
+    ok = document.execCommand("copy");
+  } catch {
+    ok = false;
+  }
+  field.remove();
+  if (selection) {
+    selection.removeAllRanges();
+    for (const range of ranges) selection.addRange(range);
+  }
+  active?.focus?.({ preventScroll: true });
+  return ok;
+}
 const COPIED_MS = 1400;
 function useClipboard() {
   const copied = ref(false);
@@ -8,8 +42,7 @@ function useClipboard() {
   async function copy(text, options = {}) {
     const { toast = false, errorToast = false } = options;
     try {
-      await navigator.clipboard?.writeText(text);
-      if (!navigator.clipboard) throw new Error("clipboard unavailable");
+      if (!await writeAsync(text) && !writeLegacy(text)) throw new Error("clipboard unavailable");
       copied.value = true;
       clearTimeout(timer);
       timer = setTimeout(() => copied.value = false, COPIED_MS);

package/dist/index.d.ts

@@ -35,9 +35,18 @@ export type { ColorPickerLabels } from "./components/LpColorPicker.vue";
 export { clampHsv, DEFAULT_SWATCHES, formatColor, hsvToHsl, hsvToRgb, isLight, normalizeHue, opaqueCss, parseColor, parseHex, rgbToHex, rgbToHsv, } from "./components/color";
 export type { ColorFormat, Hsv, Rgb } from "./components/color";
 export { default as LpCommandPalette } from "./components/LpCommandPalette.vue";
-export type { Command, PaletteLabels } from "./components/LpCommandPalette.vue";
-export { parseCommandQuery, rankCommandItems } from "./components/commandSearch";
-export type { CommandSearchTerms, SearchableCommand } from "./components/commandSearch";
+export type { Command, CommandFetcher, CommandImage, PaletteLabels } from "./components/LpCommandPalette.vue";
+export { applyQueryFilters, highlightParts, parseCommandQuery, parsePaletteQuery, rankCommandItems } from "./components/commandSearch";
+export { commandHasPreview, pushRecent, readRecent, toRecentItem } from "./components/commandPalette";
+export type { PaletteFact, PaletteStat, PreviewableCommand, RecentEntry, RecentItem } from "./components/commandPalette";
+export { default as LpPalettePreview } from "./components/LpPalettePreview.vue";
+export { default as LpPaletteHeader } from "./components/LpPaletteHeader.vue";
+export { default as LpPaletteFacts } from "./components/LpPaletteFacts.vue";
+export { default as LpPaletteStats } from "./components/LpPaletteStats.vue";
+export { default as LpPaletteSwatches } from "./components/LpPaletteSwatches.vue";
+export { default as LpKeys } from "./components/LpKeys.vue";
+export { comboKeys, comboSteps } from "./components/keys";
+export type { CommandSearchTerms, HighlightPart, PaletteQuery, SearchableCommand } from "./components/commandSearch";
 export { default as LpConfirmDialog } from "./components/LpConfirmDialog.vue";
 export type { ConfirmLabels } from "./components/LpConfirmDialog.vue";
 export { default as LpConfirmHost } from "./components/LpConfirmHost.vue";