@leavepulse/ui 0.45.1 → 0.47.0

package/src/components/commandSearch.ts

@@ -79,3 +79,82 @@ export function rankCommandItems<T extends SearchableCommand>(items: T[], terms:
     .sort((a, b) => b.score - a.score || a.command.label.localeCompare(b.command.label))
     .map((entry) => entry.command)
 }
+
+/**
+ * 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 function parsePaletteQuery(raw: string): PaletteQuery {
+  const terms = parseCommandQuery(raw)
+  const words: string[] = []
+  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(" ") }
+}
+
+/**
+ * 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 function applyQueryFilters<T extends SearchableCommand>(items: T[], terms: CommandSearchTerms): T[] {
+  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))
+  })
+}
+
+/** 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 function highlightParts(value: string, terms: readonly string[]): HighlightPart[] {
+  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: HighlightPart[] = []
+  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
+}

package/src/components/keys.ts

@@ -0,0 +1,13 @@
+/*
+ * How a written combo splits into caps. One key per "+", except a "+" that is
+ * the key itself: "Ctrl++" is Ctrl and plus, not Ctrl and two blanks. Spaces
+ * separate the steps of a sequence: "G I" reads "G then I".
+ */
+export function comboKeys(chord: string): string[] {
+  return chord.split(/\+(?!$)/)
+}
+
+export function comboSteps(combo: string): string[][] {
+  const trimmed = combo.trim()
+  return trimmed ? trimmed.split(/\s+/).map(comboKeys) : []
+}

package/src/composables/useClipboard.ts

@@ -13,7 +13,9 @@ import { useToast } from "./useToast"
  *
  * Why every call is allowed to fail: the Clipboard API needs a secure context
  * and, in some browsers, a permission. It is absent over plain http, rejects
- * outside a user gesture, and is missing entirely in a non-DOM test runner. A
+ * outside a user gesture, and is missing entirely in a non-DOM test runner.
+ * Where it is missing or refuses, the old copy command is tried before
+ * giving up (see `writeLegacy`). A
  * copy that cannot happen is a disappointment, not an exception, and a rejected
  * promise reaching a component means an unhandled rejection in the console of
  * an app that did nothing wrong.
@@ -23,6 +25,51 @@ import { useToast } from "./useToast"
  * than any message, and the two are complementary rather than alternatives.
  */
 
+/** The Clipboard API, where there is one and it agrees. */
+async function writeAsync(text: string): Promise<boolean> {
+  if (typeof navigator === "undefined" || !navigator.clipboard) return false
+  try {
+    await navigator.clipboard.writeText(text)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/*
+ * The old copy command, for where the Clipboard API is missing or refuses.
+ * Embedded Chromium (CEF in a Tauri or Electron-like shell) rejects
+ * `writeText` when the host answers no permission requests, and plain http
+ * has no API at all, while a copy command run inside the click still works
+ * there. It copies the selection, so a throwaway text field holds the text
+ * and the page's own selection and focus are put back afterwards.
+ */
+function writeLegacy(text: string): boolean {
+  if (typeof document === "undefined") return false
+  const active = document.activeElement as HTMLElement | null
+  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
+}
+
 /** How long `copied` stays true — long enough to read, short enough to not linger. */
 const COPIED_MS = 1400
 
@@ -81,12 +128,7 @@ export function useClipboard(): UseClipboard {
   async function copy(text: string, options: CopyOptions = {}): Promise<boolean> {
     const { toast = false, errorToast = false } = options
     try {
-      // Optional-chained: `navigator.clipboard` is undefined, not throwing, on
-      // an insecure origin, and that should take the same path as a rejection.
-      await navigator.clipboard?.writeText(text)
-      // A missing API resolves `undefined` rather than rejecting, so confirm
-      // the write was actually possible before claiming it happened.
-      if (!navigator.clipboard) throw new Error("clipboard unavailable")
+      if (!(await writeAsync(text)) && !writeLegacy(text)) throw new Error("clipboard unavailable")
 
       copied.value = true
       clearTimeout(timer)

package/src/index.ts

@@ -71,9 +71,18 @@ export {
 } 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"