@leavepulse/ui 0.43.4 → 0.45.0

package/dist/components/tags.js

@@ -0,0 +1,37 @@
+function splitTags(text, delimiter) {
+  const parts = delimiter instanceof RegExp ? text.split(new RegExp(delimiter.source, delimiter.flags.includes("g") ? delimiter.flags : `${delimiter.flags}g`)) : (typeof delimiter === "string" ? [delimiter] : delimiter).reduce(
+    (acc, d) => d ? acc.flatMap((p) => p.split(d)) : acc,
+    [text]
+  );
+  return parts.map((p) => p.trim()).filter(Boolean);
+}
+function addTags(current, candidates, options = {}) {
+  const tags = [...current];
+  const rejected = [];
+  const ignored = [];
+  const duplicates = options.duplicates ?? "reject";
+  for (const candidate of candidates) {
+    const value = options.normalize ? options.normalize(candidate) : candidate;
+    if (!value) continue;
+    if (tags.includes(value) && duplicates !== "allow") {
+      if (duplicates === "reject") rejected.push({ value: candidate, reason: "duplicate" });
+      else ignored.push(value);
+      continue;
+    }
+    if (options.max && tags.length >= options.max) {
+      rejected.push({ value: candidate, reason: "max" });
+      continue;
+    }
+    const message = options.validate?.(value, tags);
+    if (typeof message === "string" && message) {
+      rejected.push({ value: candidate, reason: "invalid", message });
+      continue;
+    }
+    tags.push(value);
+  }
+  return { tags, rejected, ignored };
+}
+export {
+  addTags,
+  splitTags
+};

package/dist/composables/useField.d.ts

@@ -0,0 +1,38 @@
+import { type ComputedRef, type InjectionKey } from "vue";
+import type { FieldNoticeOptions } from "./useFieldNotice";
+export interface FieldContext {
+    id: string;
+    /** Id of the visible label, for controls a `<label for>` cannot name (groups). */
+    labelId?: string;
+    describedBy?: string;
+    invalid: boolean;
+    required: boolean;
+    disabled: boolean;
+    /** Float a short note under the control without moving the layout (see useFieldNotice). */
+    notify?: (text: string, options?: FieldNoticeOptions) => void;
+    clearNotice?: () => void;
+}
+export declare const LP_FIELD: InjectionKey<ComputedRef<FieldContext>>;
+export declare function provideField(context: ComputedRef<FieldContext>): void;
+/** The nearest LpFormField's context, or null outside one. */
+export declare function useField(): ComputedRef<FieldContext> | null;
+export declare function fieldMessageId(id: string): string;
+export interface FieldControlState {
+    /** The control wraps itself in its own LpFormField (it has a label, hint or error prop). */
+    wrapped: boolean;
+    /** That own field renders a hint or error line. */
+    hasMessage?: boolean;
+    /** An id the consumer set on the control, which must win over a generated one. */
+    id?: string;
+    invalid?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+}
+/**
+ * The field state a control renders with: its own wrapping field when it has
+ * one, otherwise the field around it, with the control's own flags or-ed in.
+ * `id` is undefined only for a bare control outside any field.
+ */
+export declare function useFieldControl(own: () => FieldControlState): ComputedRef<Omit<FieldContext, "id"> & {
+    id?: string;
+}>;

package/dist/composables/useField.js

@@ -0,0 +1,45 @@
+import { provide, useId, computed, inject } from "vue";
+const LP_FIELD = /* @__PURE__ */ Symbol.for("lp-field");
+function provideField(context) {
+  provide(LP_FIELD, context);
+}
+function useField() {
+  return inject(LP_FIELD, null);
+}
+function fieldMessageId(id) {
+  return `${id}-message`;
+}
+function useFieldControl(own) {
+  const outer = useField();
+  const generated = useId();
+  return computed(() => {
+    const state = own();
+    if (state.wrapped) {
+      const id = state.id ?? generated;
+      return {
+        id,
+        labelId: void 0,
+        describedBy: state.hasMessage ? fieldMessageId(id) : void 0,
+        invalid: !!state.invalid,
+        required: !!state.required,
+        disabled: !!state.disabled
+      };
+    }
+    const field = outer?.value;
+    return {
+      id: state.id ?? field?.id,
+      labelId: field?.labelId,
+      describedBy: field?.describedBy,
+      invalid: !!state.invalid || !!field?.invalid,
+      required: !!state.required || !!field?.required,
+      disabled: !!state.disabled || !!field?.disabled
+    };
+  });
+}
+export {
+  LP_FIELD,
+  fieldMessageId,
+  provideField,
+  useField,
+  useFieldControl
+};

package/dist/composables/useFieldNotice.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from "vue";
+export type FieldNoticeTone = "info" | "danger";
+export interface FieldNoticeOptions {
+    tone?: FieldNoticeTone;
+    /** How long it stays, in ms. 0 keeps it until `clear()`. */
+    duration?: number;
+}
+export interface FieldNotice {
+    message: Ref<string>;
+    tone: Ref<FieldNoticeTone>;
+    /** Bumped on every `show`, so a repeat of the same note can nudge rather than sit still. */
+    seq: Ref<number>;
+    show: (text: string, options?: FieldNoticeOptions) => void;
+    clear: () => void;
+}
+export declare const FIELD_NOTICE_MS = 2600;
+export declare function useFieldNotice(defaultDuration?: number): FieldNotice;

package/dist/composables/useFieldNotice.js

@@ -0,0 +1,28 @@
+import { ref, getCurrentScope, onScopeDispose } from "vue";
+const FIELD_NOTICE_MS = 2600;
+function useFieldNotice(defaultDuration = FIELD_NOTICE_MS) {
+  const message = ref("");
+  const tone = ref("info");
+  const seq = ref(0);
+  let timer;
+  function clear() {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+    message.value = "";
+  }
+  function show(text, options = {}) {
+    if (timer) clearTimeout(timer);
+    timer = void 0;
+    message.value = text;
+    tone.value = options.tone ?? "info";
+    seq.value++;
+    const duration = options.duration ?? defaultDuration;
+    if (duration > 0 && text) timer = setTimeout(clear, duration);
+  }
+  if (getCurrentScope()) onScopeDispose(clear);
+  return { message, tone, seq, show, clear };
+}
+export {
+  FIELD_NOTICE_MS,
+  useFieldNotice
+};

package/dist/composables/useForm.d.ts

@@ -0,0 +1,53 @@
+import { type ComputedRef, type MaybeRefOrGetter, type Ref, type UnwrapRef } from "vue";
+export type FormErrorMessage = string | null | undefined | void | false;
+export type FieldRule<V, T> = (value: V, values: T) => FormErrorMessage | Promise<FormErrorMessage>;
+export type FormRules<T> = {
+    [K in keyof T]?: FieldRule<T[K], T> | FieldRule<T[K], T>[];
+};
+export type FormErrors<T> = Partial<Record<keyof T | "form", string>>;
+export interface UseFormOptions<T extends object> {
+    initial: MaybeRefOrGetter<T>;
+    rules?: FormRules<T>;
+    /** Cross-field checks; return messages by field, or under `form` for the whole form. */
+    validate?: (values: T) => FormErrors<T> | void | Promise<FormErrors<T> | void>;
+}
+export interface FieldBinding<V> {
+    modelValue: V;
+    "onUpdate:modelValue": (value: V) => void;
+    onBlur: () => void;
+    error: string | undefined;
+    invalid: boolean;
+}
+export interface UseForm<T extends object> {
+    values: UnwrapRef<T>;
+    /** Errors as currently computed, shown or not. */
+    errors: ComputedRef<FormErrors<T>>;
+    /** Errors the user should see now. */
+    visibleErrors: ComputedRef<FormErrors<T>>;
+    touched: Partial<Record<keyof T, boolean>>;
+    dirty: ComputedRef<boolean>;
+    valid: ComputedRef<boolean>;
+    validating: Ref<boolean>;
+    submitting: Ref<boolean>;
+    submitCount: Ref<number>;
+    isDirty: (name: keyof T) => boolean;
+    /** Props for a kit control: `<LpInput v-bind="form.field('email')" />`. */
+    field: <K extends keyof T>(name: K) => FieldBinding<T[K]>;
+    set: <K extends keyof T>(name: K, value: T[K]) => void;
+    setValues: (values: Partial<T>) => void;
+    touch: (name: keyof T) => void;
+    /** Run the checks for one field, or all of them; resolves to whether it passed. */
+    validate: (name?: keyof T) => Promise<boolean>;
+    /** Errors from elsewhere, a server reply most often. Cleared field by field on edit. */
+    setErrors: (errors: FormErrors<T>) => void;
+    /** Back to `values` (or the current initial), which also become the new baseline. */
+    reset: (values?: T) => void;
+    /**
+     * Wrap the submit handler: touches everything, validates, and calls `fn`
+     * only when valid and not already submitting. A successful `fn` makes the
+     * submitted values the new baseline.
+     */
+    handleSubmit: (fn: (values: T) => unknown) => (event?: Event) => Promise<void>;
+}
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+export declare function useForm<T extends object>(options: UseFormOptions<T>): UseForm<T>;

package/dist/composables/useForm.js

@@ -0,0 +1,207 @@
+import { toValue, reactive, ref, computed, watch, toRaw } from "vue";
+function clone(value) {
+  try {
+    return structuredClone(toRaw(value));
+  } catch {
+    return JSON.parse(JSON.stringify(value));
+  }
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const ka = Object.keys(a);
+  const kb = Object.keys(b);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => deepEqual(a[k], b[k]));
+}
+function message(result) {
+  return typeof result === "string" && result ? result : void 0;
+}
+function useForm(options) {
+  let baseline = clone(toValue(options.initial));
+  const values = reactive(clone(baseline));
+  const plain = () => values;
+  const errors = reactive({});
+  const external = reactive({});
+  const touched = reactive({});
+  const validating = ref(false);
+  const submitting = ref(false);
+  const submitCount = ref(0);
+  const runs = /* @__PURE__ */ new Map();
+  const baseVersion = ref(0);
+  const keys = () => Object.keys(plain());
+  const dirty = computed(() => {
+    void baseVersion.value;
+    return !deepEqual(plain(), baseline);
+  });
+  function isDirty(name) {
+    void baseVersion.value;
+    return !deepEqual(plain()[name], baseline[name]);
+  }
+  async function checkField(name) {
+    const rule = options.rules?.[name];
+    const list = Array.isArray(rule) ? rule : rule ? [rule] : [];
+    for (const r of list) {
+      const found = message(await r(plain()[name], plain()));
+      if (found) return found;
+    }
+    return void 0;
+  }
+  async function runField(name) {
+    const run = (runs.get(name) ?? 0) + 1;
+    runs.set(name, run);
+    const found = await checkField(name);
+    if (runs.get(name) !== run) return !errors[name];
+    if (found) errors[name] = found;
+    else delete errors[name];
+    return !found && !external[name];
+  }
+  async function runForm() {
+    if (!options.validate) return true;
+    const run = (runs.get("form") ?? 0) + 1;
+    runs.set("form", run);
+    const found = await options.validate(plain()) ?? {};
+    if (runs.get("form") !== run) return true;
+    let ok = true;
+    for (const [name, text] of Object.entries(found)) {
+      if (!text) continue;
+      ok = false;
+      if (!errors[name]) errors[name] = text;
+    }
+    return ok;
+  }
+  async function validate(name) {
+    validating.value = true;
+    try {
+      if (name !== void 0) return await runField(name);
+      if (errors.form) delete errors.form;
+      const fields = await Promise.all(keys().map(runField));
+      const form = await runForm();
+      return fields.every(Boolean) && form && !Object.values(external).some(Boolean);
+    } finally {
+      validating.value = false;
+    }
+  }
+  function touch(name) {
+    touched[name] = true;
+    void validate(name);
+  }
+  function set(name, value) {
+    values[name] = value;
+  }
+  function setValues(next) {
+    for (const [k, v] of Object.entries(next)) set(k, v);
+  }
+  function clearState() {
+    for (const k of Object.keys(errors)) delete errors[k];
+    for (const k of Object.keys(external)) delete external[k];
+    for (const k of Object.keys(touched)) delete touched[k];
+    runs.clear();
+    submitCount.value = 0;
+  }
+  function adopt(next) {
+    baseline = clone(next);
+    const target = values;
+    for (const k of Object.keys(target)) if (!(k in baseline)) delete target[k];
+    Object.assign(target, clone(baseline));
+    baseVersion.value++;
+  }
+  function reset(next) {
+    adopt(next ?? toValue(options.initial));
+    clearState();
+  }
+  function setErrors(next) {
+    for (const [k, v] of Object.entries(next)) {
+      if (v) external[k] = v;
+      else delete external[k];
+    }
+  }
+  watch(
+    () => toValue(options.initial),
+    (next) => {
+      if (!dirty.value && !deepEqual(next, baseline)) adopt(next);
+    },
+    { deep: true }
+  );
+  let snapshot = clone(plain());
+  watch(
+    plain,
+    () => {
+      const now = clone(plain());
+      for (const name of Object.keys(now)) {
+        if (deepEqual(now[name], snapshot[name])) continue;
+        if (external[name]) delete external[name];
+        if (touched[name] || submitCount.value) void validate(name);
+      }
+      snapshot = now;
+    },
+    { deep: true }
+  );
+  const merged = computed(() => ({ ...errors, ...external }));
+  const visibleErrors = computed(() => {
+    const all = merged.value;
+    if (submitCount.value) return all;
+    const shown = {};
+    for (const [k, v] of Object.entries(all)) {
+      if (touched[k] || external[k]) shown[k] = v;
+    }
+    return shown;
+  });
+  const valid = computed(() => !Object.values(merged.value).some(Boolean));
+  function field(name) {
+    const error = visibleErrors.value[name];
+    return {
+      modelValue: values[name],
+      "onUpdate:modelValue": (value) => set(name, value),
+      onBlur: () => touch(name),
+      error,
+      invalid: !!error
+    };
+  }
+  function handleSubmit(fn) {
+    return async (event) => {
+      event?.preventDefault();
+      if (submitting.value) return;
+      submitting.value = true;
+      try {
+        submitCount.value++;
+        for (const name of keys()) touched[name] = true;
+        if (!await validate()) return;
+        const submitted = clone(plain());
+        await fn(submitted);
+        if (deepEqual(plain(), submitted)) {
+          baseline = submitted;
+          baseVersion.value++;
+        }
+      } finally {
+        submitting.value = false;
+      }
+    };
+  }
+  return {
+    values,
+    errors: merged,
+    visibleErrors,
+    touched,
+    dirty,
+    valid,
+    validating,
+    submitting,
+    submitCount,
+    isDirty,
+    field,
+    set,
+    setValues,
+    touch,
+    validate,
+    setErrors,
+    reset,
+    handleSubmit
+  };
+}
+export {
+  deepEqual,
+  useForm
+};

package/dist/composables/useFormDraft.d.ts

@@ -24,9 +24,16 @@ export interface UseFormDraftOptions<T> {
     disabled?: MaybeRefOrGetter<boolean>;
 }
 export interface UseFormDraft<T> {
-    /** A draft was found for this key, and has not been restored or discarded. */
+    /**
+     * A draft was found for this key, and has not been restored or discarded.
+     * Only a draft found on reading counts: the writes this composable makes as
+     * the user types never raise it. While it is up, automatic writes are held
+     * back, so the draft on offer cannot be overwritten by the form's own state
+     * (an async load of the record, or typing past the banner) before the user
+     * has answered.
+     */
     hasDraft: Ref<boolean>;
-    /** When that draft was written, ISO-8601, or `null` when there is none. */
+    /** When the found draft was written, ISO-8601, or `null` when there is none. */
     savedAt: Ref<string | null>;
     /**
      * The stored value, or `null`. Reading does not apply it — the caller decides
@@ -35,7 +42,7 @@ export interface UseFormDraft<T> {
     read: () => T | null;
     /** Forget the draft. Call after applying it, and after a successful save. */
     discard: () => void;
-    /** Write now, ignoring `dirty`. For "save and come back to this later". */
+    /** Write now, ignoring `dirty` and a pending draft. For "save and come back to this later". */
     save: () => void;
 }
 /**

package/dist/composables/useFormDraft.js

@@ -16,6 +16,11 @@ function useFormDraft(options) {
   function currentKey() {
     return String(toValue(options.key) || "").trim();
   }
+  function fresh(parsed) {
+    if (!parsed || parsed.version !== ENVELOPE_VERSION) return false;
+    if (maxAge <= 0) return true;
+    return !(Date.now() - Date.parse(parsed.savedAt) > maxAge);
+  }
   function read() {
     const store = storage();
     const key = currentKey();
@@ -29,17 +34,10 @@ function useFormDraft(options) {
     if (!raw) return null;
     try {
       const parsed = JSON.parse(raw);
-      if (!parsed || parsed.version !== ENVELOPE_VERSION) {
+      if (!fresh(parsed)) {
         discard();
         return null;
       }
-      if (maxAge > 0) {
-        const age = Date.now() - Date.parse(parsed.savedAt);
-        if (age > maxAge) {
-          discard();
-          return null;
-        }
-      }
       return parsed.value;
     } catch {
       discard();
@@ -50,21 +48,18 @@ function useFormDraft(options) {
     const store = storage();
     const key = currentKey();
     if (!store || !key) return;
-    const stamp = (/* @__PURE__ */ new Date()).toISOString();
     try {
       store.setItem(
         key,
         JSON.stringify({
           version: ENVELOPE_VERSION,
-          savedAt: stamp,
+          savedAt: (/* @__PURE__ */ new Date()).toISOString(),
           value
         })
       );
     } catch {
       return;
     }
-    hasDraft.value = true;
-    savedAt.value = stamp;
   }
   function discard() {
     const store = storage();
@@ -97,7 +92,7 @@ function useFormDraft(options) {
       if (!raw) return;
       try {
         const parsed = JSON.parse(raw);
-        if (parsed?.version !== ENVELOPE_VERSION) return;
+        if (!fresh(parsed)) return;
         hasDraft.value = true;
         savedAt.value = parsed.savedAt;
       } catch {
@@ -108,7 +103,7 @@ function useFormDraft(options) {
   watch(
     () => [toValue(options.value), toValue(options.dirty), toValue(options.disabled)],
     ([value, dirty, disabled]) => {
-      if (disabled) return;
+      if (disabled || hasDraft.value) return;
       if (options.dirty !== void 0 && !dirty) return;
       write(value);
     },

package/dist/composables/useHotkeys.d.ts

@@ -1,7 +1,18 @@
 import { type MaybeRefOrGetter } from "vue";
-export interface HotkeyBinding {
-    /** Layout-produced key, compared case-insensitively ("l", "f2", "escape"). */
+/** One key of a sequence: a bare key ("g") or a full chord. */
+export interface HotkeyStep {
     key: string;
+    code?: string;
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+}
+export interface HotkeyBinding {
+    /**
+     * Layout-produced key, compared case-insensitively ("l", "f2", "escape").
+     * Required unless the binding is a `sequence`.
+     */
+    key?: string;
     /**
      * Physical key position ("KeyL", "F2", "Digit1"). Matches on its own, which
      * is what makes non-Latin layouts work.
@@ -11,11 +22,31 @@ export interface HotkeyBinding {
     ctrl?: boolean;
     shift?: boolean;
     alt?: boolean;
+    /**
+     * Keys pressed one after another: `"g i"`, or steps for chords and physical
+     * positions (`[{ key: "g", code: "KeyG" }, { key: "i", code: "KeyI" }]`).
+     * The string form splits on spaces, so a Space step needs the array form.
+     */
+    sequence?: string | (string | HotkeyStep)[];
+    /** How long a sequence waits for its next key, in ms. Default 1000. */
+    timeout?: number;
+    /** Extra condition checked on every press; `false` leaves the key alone. */
+    when?: (event: KeyboardEvent) => boolean;
     /**
      * Runs even while a text field has focus. Only for shortcuts that mean
      * something there — Escape, and the palette the user reaches from anywhere.
      */
     allowInInput?: boolean;
+    /**
+     * Runs even while an overlay owns the keyboard. By default a binding declared
+     * outside the topmost modal stays quiet while that modal is open, and an
+     * Escape binding declared outside the topmost dismissable layer (dialog,
+     * popover, menu) leaves Escape to that layer, so a page-level shortcut can
+     * neither act behind a dialog nor stop the dialog from closing.
+     */
+    overLayers?: boolean;
+    /** Set `false` to ignore auto-repeat while the key is held. */
+    repeat?: boolean;
     /**
      * How the key reference lists this binding while it is mounted. Bindings
      * without it still work, they just stay out of `activeShortcuts`.
@@ -38,14 +69,19 @@ export interface HotkeyHelp {
     /**
      * Written the way it reads, "+"-separated. Defaults to one built from the
      * binding; set it where the binding is not the whole story, such as the
-     * second key of a chord ("G+D") or a key that needs Shift to type ("?").
+     * key that needs Shift to type ("?"). Sequences read with spaces: "G I".
      */
     combo?: string;
 }
 export interface ShortcutEntry {
-    /** Rendered one <kbd> per "+"-separated key, so write it the way it reads. */
+    /**
+     * Rendered one <kbd> per "+"-separated key, so write it the way it reads.
+     * Spaces separate the steps of a sequence ("G I", "Ctrl+K Ctrl+S").
+     */
     combo: string;
     label: string;
+    /** Another mounted binding answers the same keys at the same priority. */
+    conflict?: boolean;
 }
 export interface ShortcutGroup {
     title: string;
@@ -57,11 +93,25 @@ export interface ShortcutGroup {
  * used to pick a label.
  */
 export declare const isAppleKeyboard: boolean;
+/**
+ * `isAppleKeyboard` for render paths: false until mounted, so the server and
+ * the hydrating client print the same label and the client switches after.
+ */
+export declare function useAppleKeyboard(): import("vue").Ref<boolean, boolean>;
 /**
  * The symbol to print for a modifier on this platform. Bindings treat Ctrl and
  * Meta as one modifier, so only the label may differ — never the binding.
  */
-export declare function appleModifierLabel(key: string): string;
+export declare function appleModifierLabel(key: string, apple?: boolean): string;
+type KeyLike = Pick<KeyboardEvent, "key" | "code" | "ctrlKey" | "metaKey" | "shiftKey" | "altKey">;
+export declare function matchesHotkey(event: KeyLike, binding: HotkeyBinding | HotkeyStep): boolean;
+/** The keys a binding waits for, in order: one step for a plain binding. */
+export declare function hotkeySteps(binding: HotkeyBinding): HotkeyStep[];
+/**
+ * Where a run of presses stands against a binding: "full" when they spell it
+ * out, "prefix" when more keys would, otherwise null.
+ */
+export declare function sequenceProgress(presses: KeyLike[], binding: HotkeyBinding): "full" | "prefix" | null;
 /**
  * Bind a list of hotkeys for as long as the calling component is mounted.
  *
@@ -86,7 +136,32 @@ export interface UseHotkeysOptions {
      */
     scope?: MaybeRefOrGetter<HTMLElement | null | undefined>;
 }
+/**
+ * The keys of a sequence typed so far ("G" after the first key of "g i"),
+ * empty when nothing is pending. For a "G…" hint while the next key is awaited.
+ */
+export declare const pendingHotkey: import("vue").ComputedRef<string[]>;
 export declare function useHotkeys(bindings: MaybeRefOrGetter<HotkeyBinding[]>, options?: UseHotkeysOptions): void;
+export interface HotkeyConflict {
+    /** The keys both answer, written as in the shortcut reference. */
+    combo: string;
+    /** `help` labels of the clashing bindings; unlabelled ones are omitted. */
+    labels: string[];
+    priority: number;
+}
+/**
+ * Pure part of `hotkeyConflicts`: bindings from different `useHotkeys` calls
+ * answering the same keys at the same priority within the same scope. Within
+ * one call a repeat is deliberate (the first may decline), and a binding with
+ * `when` is conditional by design, so neither counts.
+ */
+export declare function findHotkeyConflicts(groups: {
+    bindings: HotkeyBinding[];
+    priority: number;
+    scope: unknown;
+}[]): HotkeyConflict[];
+/** Bindings among the mounted ones that answer the same keys. */
+export declare const hotkeyConflicts: import("vue").ComputedRef<HotkeyConflict[]>;
 /**
  * The shortcuts that work right now, grouped for `LpShortcutsDialog`: every
  * binding with `help` from every mounted `useHotkeys`. A screen that binds its
@@ -99,3 +174,4 @@ export declare const activeShortcuts: import("vue").ComputedRef<ShortcutGroup[]>
  * when it lists both its own entries and the live ones.
  */
 export declare function mergeShortcutGroups(...lists: ShortcutGroup[][]): ShortcutGroup[];
+export {};