@leavepulse/ui 0.74.2 → 0.76.0

package/dist/components/LpTable.vue.js

@@ -25,10 +25,10 @@ import { useResizeObserver } from "../composables/useResizeObserver.js";
 import { compareValues } from "./tableSort.js";
 import { _ as _sfc_main$2 } from "../chunks/LpButton-CFb44IjC.js";
 import { toCsv, downloadFile, fileStem } from "./exportData.js";
-import { summarizeShown, parseTableState, serializeTableState } from "./tableFilter.js";
+import { toHiddenSets, sameHidden, summarizeShown, parseTableState, mergeRestored, serializeTableState, fromHiddenSets } from "./tableFilter.js";
 import { resolveRowMenu } from "./tableRowMenu.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpTable-DHvorDiU.css';const _hoisted_1 = {
+import '../assets/LpTable-Bv-EcQs7.css';const _hoisted_1 = {
   key: 0,
   class: "flex justify-end"
 };
@@ -89,6 +89,8 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     selectable: { type: [Boolean, String], default: false },
     selected: { default: () => [] },
     sort: { default: void 0 },
+    filters: { default: void 0 },
+    filtered: { type: Boolean, default: false },
     stickyHeader: { type: Boolean },
     rowMenu: {},
     sortAscLabel: {},
@@ -105,7 +107,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     persist: {},
     allMatching: { type: Boolean, default: false }
   },
-  emits: ["update:selected", "update:sort", "update:allMatching", "rowClick"],
+  emits: ["update:selected", "update:sort", "update:filters", "resetFilters", "update:allMatching", "rowClick"],
   setup(__props, { expose: __expose, emit: __emit }) {
     const props = __props;
     const labelSet = useLabels(
@@ -221,7 +223,19 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       const height = frameEl.value?.querySelector("table")?.offsetHeight ?? 0;
       if (height > floor.value) floor.value = height;
     }
-    const hiddenValues = ref({});
+    const ownHidden = ref({});
+    let lastHidden = {};
+    const hiddenValues = computed(() => {
+      const next = props.filters !== void 0 ? toHiddenSets(props.filters) : ownHidden.value;
+      if (sameHidden(next, lastHidden)) return lastHidden;
+      lastHidden = next;
+      return next;
+    });
+    function writeHidden(next) {
+      if (sameHidden(next, hiddenValues.value)) return;
+      ownHidden.value = next;
+      emit("update:filters", fromHiddenSets(next));
+    }
     const animating = ref(false);
     let motionTimer;
     function withMotion(change) {
@@ -252,21 +266,23 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       hidden: () => hiddenValues.value
     });
     function valuesOf(col) {
-      if (props.load) return facets.value[col.key] ?? [...new Set(sourceRows.value.map((row) => row[col.key]))];
-      return localFacets.distinct(col.key);
+      const found = props.load ? facets.value[col.key] ?? [...new Set(sourceRows.value.map((row) => row[col.key]))] : localFacets.distinct(col.key);
+      return col.filterValues ? [.../* @__PURE__ */ new Set([...col.filterValues, ...found])] : found;
     }
     function showAllValues(key) {
-      withMotion(() => hiddenValues.value = { ...hiddenValues.value, [key]: /* @__PURE__ */ new Set() });
+      writeHidden({ ...hiddenValues.value, [key]: /* @__PURE__ */ new Set() });
     }
     function setHidden(key, next) {
-      withMotion(() => hiddenValues.value = { ...hiddenValues.value, [key]: next });
+      writeHidden({ ...hiddenValues.value, [key]: next });
     }
+    watch(hiddenValues, () => withMotion(() => {
+    }));
     function labelOf(col, value) {
       return col.valueLabel?.(value) ?? String(value ?? "—");
     }
     const facetOptions = computed(() => new Map(props.columns.filter((col) => col.filterable).map((col) => {
       return [col.key, computed(() => {
-        const counts = props.load ? void 0 : localFacets.counts(col.key);
+        const counts = props.load || col.filterCounts === false ? void 0 : localFacets.counts(col.key);
         return valuesOf(col).map((value) => ({
           value,
           label: labelOf(col, value),
@@ -282,7 +298,11 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
       })
     );
     function clearAllFilters() {
-      withMotion(() => hiddenValues.value = {});
+      writeHidden({});
+    }
+    function resetFilters() {
+      clearAllFilters();
+      emit("resetFilters");
     }
     function filterLabels() {
       const t = text.value;
@@ -459,9 +479,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
             ownSort.value = state.sort;
             emit("update:sort", state.sort);
           }
-          if (state.hidden) {
-            hiddenValues.value = Object.fromEntries(Object.entries(state.hidden).map(([k, v]) => [k, new Set(v)]));
-          }
+          if (state.hidden) writeHidden(mergeRestored(hiddenValues.value, state.hidden));
           if (state.columns) hiddenColumns.value = new Set(state.columns);
         }
       }
@@ -583,6 +601,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     );
     const filteredOut = computed(() => {
       if (busy.value || failed.value || displayRows.value.length) return false;
+      if (props.filtered) return true;
       if (props.load) return Object.values(hiddenValues.value).some((set) => set.size);
       return props.rows.length > 0;
     });
@@ -946,7 +965,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
                                 key: 0,
                                 variant: "outline",
                                 size: "sm",
-                                onClick: clearAllFilters
+                                onClick: resetFilters
                               }, {
                                 default: withCtx(() => [
                                   createTextVNode(toDisplayString(text.value.resetFilters), 1)
@@ -1024,7 +1043,7 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     };
   }
 });
-const LpTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c1911001"]]);
+const LpTable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-d2bafc29"]]);
 export {
   LpTable as default
 };

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

@@ -52,6 +52,14 @@ type __VLS_Props = {
      * icon keep their label.
      */
     compact?: boolean;
+    /**
+     * Record each switch as a browser history entry, so Back returns to the
+     * previous tab. Unset follows the overlay the tabs sit in (a modal or a
+     * drawer with history on, see `provideOverlayHistory`) and is off
+     * elsewhere: a page's own tabs belong in its URL. `false` opts out inside
+     * an overlay, `true` opts in on a page that keeps no URL of its own.
+     */
+    history?: boolean;
 };
 declare var __VLS_67: {
     value: string;
@@ -66,6 +74,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
 }>, {
+    history: boolean;
     block: boolean;
     variant: "contained" | "plain" | "underline" | "bottom";
     accent: boolean;

package/dist/components/LpTabs.vue.js

@@ -3,13 +3,14 @@ import { usePaletteScope, usePaletteCommands } from "../composables/usePaletteCo
 import { Motion } from "motion-v";
 import { TabsRoot, TabsList, TabsTrigger, TabsContent } from "reka-ui";
 import { usePillTransition } from "../composables/usePillTransition.js";
+import { useStepHistory } from "../composables/useOverlayHistory.js";
 import { prefersReducedMotion } from "../composables/easing.js";
 import { _ as _sfc_main$1 } from "../chunks/LpContextMenu-rx2tCjwk.js";
 import { _ as _sfc_main$3 } from "../chunks/LpSkeleton-BB6XIV-w.js";
 import { _ as _sfc_main$2 } from "../chunks/LpTabFace-DPCwKkH2.js";
 import { pickTab, BOTTOM_BAR, BOTTOM_ITEM, BOTTOM_MARKER } from "./tabs.js";
 import { _ as _export_sfc } from "../chunks/_plugin-vue_export-helper-1tPrXgE0.js";
-import '../assets/LpTabs-CDchzoRL.css';const _sfc_main = /* @__PURE__ */ defineComponent({
+import '../assets/LpTabs-CJ0rYQbx.css';const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "LpTabs",
   props: {
     modelValue: {},
@@ -20,7 +21,8 @@ import '../assets/LpTabs-CDchzoRL.css';const _sfc_main = /* @__PURE__ */ defineC
     block: { type: Boolean, default: false },
     label: {},
     hoverFollow: { type: Boolean, default: true },
-    compact: { type: Boolean, default: false }
+    compact: { type: Boolean, default: false },
+    history: { type: Boolean, default: void 0 }
   },
   emits: ["update:modelValue"],
   setup(__props, { emit: __emit }) {
@@ -54,10 +56,22 @@ import '../assets/LpTabs-CDchzoRL.css';const _sfc_main = /* @__PURE__ */ defineC
         row.scrollTo({ left, behavior: prefersReducedMotion() ? "auto" : "smooth" });
       });
     });
-    function select(value) {
+    function show(value) {
       if (props.modelValue === void 0) current.value = value;
       emit("update:modelValue", value);
     }
+    const { record } = useStepHistory({
+      mode: () => props.history,
+      set: show,
+      has: (value) => props.items.some((item) => item.value === value && !item.disabled)
+    });
+    function select(value) {
+      const from = current.value;
+      show(value);
+      void nextTick(() => {
+        if (from !== void 0 && current.value === value) record(from, value);
+      });
+    }
     const pillId = `lp-tab-indicator-${useId()}`;
     const hovered = ref(null);
     const pillTransition = usePillTransition();
@@ -195,7 +209,7 @@ import '../assets/LpTabs-CDchzoRL.css';const _sfc_main = /* @__PURE__ */ defineC
     };
   }
 });
-const LpTabs = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-9f51a497"]]);
+const LpTabs = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-1d673b52"]]);
 export {
   LpTabs as default
 };

package/dist/components/tableFilter.d.ts

@@ -6,6 +6,34 @@ export declare function hideAllValues(values: readonly unknown[]): Set<unknown>;
 export declare function invertHidden(values: readonly unknown[], hidden: ReadonlySet<unknown>): Set<unknown>;
 /** Show these values again, leaving the rest of the filter as it was. */
 export declare function unhideValues(hidden: ReadonlySet<unknown>, values: readonly unknown[]): Set<unknown>;
+/**
+ * A table's header filters as a consumer holds them (v-model:filters on
+ * LpTable): per column key, the values hidden. A column that is absent or has
+ * an empty list is not filtered. Hidden rather than shown for the same reason
+ * as inside the table: a value nobody has seen before shows up.
+ */
+export type TableFilters = Record<string, unknown[]>;
+/** The hidden list that leaves only `keep` of `values` showing. */
+export declare function showOnly(values: readonly unknown[], keep: readonly unknown[]): unknown[];
+/** Which of `values` a column's filter still shows. */
+export declare function shownValues(values: readonly unknown[], hidden: readonly unknown[] | undefined): unknown[];
+/**
+ * The rows a set of header filters leaves, for the same data drawn somewhere
+ * the table is not (cards on a phone, a CSV built by the page).
+ */
+export declare function filterRows<Row extends Record<string, unknown>>(rows: readonly Row[], filters: TableFilters): Row[];
+/** Sets per column, from the plain lists a consumer writes. */
+export declare function toHiddenSets(filters: TableFilters): Record<string, Set<unknown>>;
+/** The plain lists a consumer reads, empty columns left out. */
+export declare function fromHiddenSets(hidden: Record<string, ReadonlySet<unknown>>): TableFilters;
+/** Whether two filter states hide the same values, empty columns counting as absent. */
+export declare function sameHidden(a: Record<string, ReadonlySet<unknown>>, b: Record<string, ReadonlySet<unknown>>): boolean;
+/**
+ * Persisted filters meeting the ones a parent already set: the parent's
+ * explicit state (a deep link, a control above the table) wins per column,
+ * and what was remembered fills only the columns it leaves alone.
+ */
+export declare function mergeRestored(current: Record<string, ReadonlySet<unknown>>, restored: Record<string, unknown[]>): Record<string, Set<unknown>>;
 /** Lower-cased and stripped of accents, so "cafe" finds "Café". */
 export declare function foldText(text: string): string;
 /** Every word of the query appears somewhere in the label, in any order. */

package/dist/components/tableFilter.js

@@ -13,6 +13,42 @@ function unhideValues(hidden, values) {
   for (const v of values) next.delete(v);
   return next;
 }
+function showOnly(values, keep) {
+  return [...onlyValues(values, keep)];
+}
+function shownValues(values, hidden) {
+  if (!hidden?.length) return [...values];
+  const out = new Set(hidden);
+  return values.filter((v) => !out.has(v));
+}
+function filterRows(rows, filters) {
+  const active = Object.entries(filters).filter(([, hidden]) => hidden.length).map(([key, hidden]) => [key, new Set(hidden)]);
+  if (!active.length) return [...rows];
+  return rows.filter((row) => active.every(([key, hidden]) => !hidden.has(row[key])));
+}
+function toHiddenSets(filters) {
+  return Object.fromEntries(Object.entries(filters).map(([key, values]) => [key, new Set(values)]));
+}
+function fromHiddenSets(hidden) {
+  return Object.fromEntries(Object.entries(hidden).filter(([, set]) => set.size).map(([key, set]) => [key, [...set]]));
+}
+function sameHidden(a, b) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const key of keys) {
+    const x = a[key];
+    const y = b[key];
+    if ((x?.size ?? 0) !== (y?.size ?? 0)) return false;
+    if (x && y) {
+      for (const v of x) if (!y.has(v)) return false;
+    }
+  }
+  return true;
+}
+function mergeRestored(current, restored) {
+  const out = Object.fromEntries(Object.entries(current).map(([k, v]) => [k, new Set(v)]));
+  for (const [key, values] of Object.entries(restored)) if (!out[key]?.size) out[key] = new Set(values);
+  return out;
+}
 function foldText(text) {
   return text.normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "").toLocaleLowerCase();
 }
@@ -72,13 +108,20 @@ function parseTableState(raw, columnKeys) {
 }
 export {
   countValues,
+  filterRows,
   foldText,
+  fromHiddenSets,
   hideAllValues,
   invertHidden,
   matchesQuery,
+  mergeRestored,
   onlyValues,
   parseTableState,
+  sameHidden,
   serializeTableState,
+  showOnly,
+  shownValues,
   summarizeShown,
+  toHiddenSets,
   unhideValues
 };

package/dist/composables/overlayHistory.d.ts

@@ -0,0 +1,33 @@
+export interface HistoryEntry {
+    /** Back left this entry: undo what it recorded (close the overlay, restore the tab). */
+    back: () => void;
+    /** Forward came back to it: redo it, and say whether that happened. */
+    forward?: () => boolean;
+    /** The page moved on to another path while this entry was live. */
+    navigated?: () => void;
+    /** The component that pushed it is still mounted. */
+    alive: boolean;
+}
+/**
+ * What the kit needs of a router: vue-router's `listening` switch, or the same
+ * flag on any router that skips its popstate handling while it is false.
+ */
+export interface HistoryRouter {
+    listening: boolean;
+}
+/** The app's router, told not to listen while a step only concerns the kit. */
+export declare function setHistoryRouter(router: HistoryRouter | null): void;
+/** Record an entry on top of the history, under the current address. */
+export declare function pushEntry(entry: HistoryEntry): void;
+/**
+ * The thing behind an entry ended without Back (a close button, Escape, the
+ * app setting `open` to false, an unmount): take the entry and everything
+ * pushed above it out of history, so Back is never spent on a dead step.
+ * When the page is not sitting on the kit's entries (another push came on top),
+ * the entry stays in place and is skipped when Back or Forward lands on it.
+ */
+export declare function dropEntry(entry: HistoryEntry): void;
+/** Whether the entry is live: pushed and not yet popped or dropped. */
+export declare function isLive(entry: HistoryEntry): boolean;
+/** Live entries, bottom first. For tests and devtools. */
+export declare function liveEntries(): number;

package/dist/composables/overlayHistory.js

@@ -0,0 +1,237 @@
+const KEY = "__lpOverlay";
+const SETTLE_MS = 300;
+const STATE_KEY = /* @__PURE__ */ Symbol.for("@leavepulse/ui:overlay-history");
+const g = globalThis;
+const fresh = {
+  router: null,
+  replaying: false,
+  popping: null,
+  installed: false,
+  live: [],
+  closed: /* @__PURE__ */ new Map(),
+  dead: /* @__PURE__ */ new Map(),
+  silent: 0,
+  waiting: [],
+  href: "",
+  serial: 0,
+  internal: false,
+  settle: 0
+};
+const s = g[STATE_KEY] ??= fresh;
+function markOf(state) {
+  if (!state || typeof state !== "object") return null;
+  const mark = state[KEY];
+  if (!mark || typeof mark !== "object") return null;
+  const { token, depth } = mark;
+  return typeof token === "string" && typeof depth === "number" ? { token, depth } : null;
+}
+function pathOf(href) {
+  try {
+    return new URL(href, location.href).pathname;
+  } catch {
+    return href;
+  }
+}
+function own(run) {
+  s.internal = true;
+  try {
+    return run();
+  } finally {
+    s.internal = false;
+  }
+}
+function silentGo(delta) {
+  if (delta === 0) return;
+  s.silent++;
+  mute();
+  own(() => history.go(delta));
+}
+function whenSettled(run) {
+  if (s.silent > 0) s.waiting.push(run);
+  else run();
+}
+function flushWaiting() {
+  if (s.silent > 0) return;
+  const queued = s.waiting.splice(0);
+  for (const run of queued) run();
+}
+function current() {
+  return markOf(history.state);
+}
+function onTop() {
+  const top = s.live[s.live.length - 1];
+  return !!top && current()?.token === top.token;
+}
+function leavePage() {
+  const gone = s.live.splice(0);
+  for (const item of gone.reverse()) {
+    bury(item);
+    item.entry.navigated?.();
+  }
+  s.closed.clear();
+}
+function handlePop(event) {
+  const before = s.href;
+  s.href = location.href;
+  if (s.silent > 0) {
+    s.silent--;
+    if (before === location.href) event.stopImmediatePropagation();
+    flushWaiting();
+    return;
+  }
+  window.clearTimeout(s.settle);
+  const sameAddress = before === location.href;
+  const mark = markOf(event.state);
+  const at = mark ? s.live.findIndex((item) => item.token === mark.token) : -1;
+  if (at >= 0) {
+    closeAbove(at);
+    if (sameAddress) event.stopImmediatePropagation();
+    return;
+  }
+  const reopen = mark ? s.closed.get(mark.token) : void 0;
+  if (reopen && sameAddress) {
+    event.stopImmediatePropagation();
+    if (reopen.entry.alive && reopen.entry.forward?.()) {
+      s.closed.delete(reopen.token);
+      s.live.push(reopen);
+      return;
+    }
+    silentGo(-1);
+    return;
+  }
+  if (mark && (s.dead.has(mark.token) || reopen)) {
+    if (sameAddress) event.stopImmediatePropagation();
+    if (!sameAddress) {
+      silentGo(-mark.depth);
+      return;
+    }
+    const depth = mark.depth;
+    own(() => history.forward());
+    s.settle = window.setTimeout(() => {
+      if (markOf(history.state)?.token === mark.token) silentGo(-depth);
+      else mute();
+    }, SETTLE_MS);
+    return;
+  }
+  if (s.live.length === 0) return;
+  if (sameAddress) {
+    closeAbove(-1);
+    event.stopImmediatePropagation();
+  } else if (pathOf(before) !== pathOf(location.href)) {
+    leavePage();
+  }
+}
+const DEAD_LIMIT = 200;
+function bury(item) {
+  s.dead.set(item.token, item);
+  if (s.dead.size > DEAD_LIMIT) s.dead.delete(s.dead.keys().next().value);
+}
+function closeAbove(index) {
+  const popped = s.live.splice(index + 1);
+  for (const item of popped.reverse()) {
+    s.closed.set(item.token, item);
+    if (item.entry.alive) item.entry.back();
+  }
+}
+function onPop(event) {
+  if (s.replaying) return;
+  s.popping = { muted: !!s.router && !s.router.listening, before: s.href };
+  handlePop(event);
+  if (event.cancelBubble) {
+    s.popping = null;
+    mute();
+  }
+}
+function afterPop(event) {
+  if (s.replaying || !s.popping) return;
+  const { muted, before } = s.popping;
+  s.popping = null;
+  if (muted && before !== location.href) replay(event.state);
+  mute();
+}
+function replay(state) {
+  if (!s.router) return;
+  s.router.listening = true;
+  s.replaying = true;
+  try {
+    window.dispatchEvent(new PopStateEvent("popstate", { state }));
+  } finally {
+    s.replaying = false;
+  }
+}
+function mute() {
+  if (s.popping) return;
+  if (s.router) s.router.listening = !(current() || s.silent > 0);
+}
+function setHistoryRouter(router) {
+  if (s.router && s.router !== router) s.router.listening = true;
+  s.router = router;
+  if (typeof window === "undefined") return;
+  window.removeEventListener("popstate", afterPop);
+  window.addEventListener("popstate", afterPop);
+  mute();
+}
+function install() {
+  if (s.installed || typeof window === "undefined") return;
+  s.installed = true;
+  s.href = location.href;
+  window.addEventListener("popstate", onPop, { capture: true });
+  window.removeEventListener("popstate", afterPop);
+  window.addEventListener("popstate", afterPop);
+  const push = history.pushState.bind(history);
+  const replace = history.replaceState.bind(history);
+  history.pushState = function(data, unused, url) {
+    const before = location.href;
+    push(data, unused, url);
+    s.href = location.href;
+    if (s.internal) return;
+    s.closed.clear();
+    if (pathOf(before) !== pathOf(location.href)) leavePage();
+    mute();
+  };
+  history.replaceState = function(data, unused, url) {
+    const mark = s.internal ? null : current();
+    const keep = mark && data && typeof data === "object" && !markOf(data) ? { ...data, [KEY]: mark } : data;
+    replace(keep, unused, url);
+    s.href = location.href;
+  };
+}
+function pushEntry(entry) {
+  if (typeof window === "undefined") return;
+  install();
+  whenSettled(() => {
+    if (!entry.alive) return;
+    const token = `${Date.now().toString(36)}-${(s.serial++).toString(36)}`;
+    const depth = (current()?.depth ?? 0) + 1;
+    const base = history.state && typeof history.state === "object" ? history.state : {};
+    own(() => history.pushState({ ...base, [KEY]: { token, depth } }, "", location.href));
+    s.href = location.href;
+    s.closed.clear();
+    s.live.push({ entry, token, depth });
+    mute();
+  });
+}
+function dropEntry(entry) {
+  const at = s.live.findIndex((item) => item.entry === entry);
+  if (at === -1) return;
+  const positioned = onTop();
+  const removed = s.live.splice(at);
+  if (positioned) {
+    silentGo(-removed.length);
+    return;
+  }
+  for (const item of removed) bury(item);
+}
+function isLive(entry) {
+  return s.live.some((item) => item.entry === entry);
+}
+function liveEntries() {
+  return s.live.length;
+}
+export {
+  dropEntry,
+  isLive,
+  liveEntries,
+  pushEntry,
+  setHistoryRouter
+};

package/dist/composables/useOverlayHistory.d.ts

@@ -0,0 +1,45 @@
+import { type MaybeRefOrGetter } from "vue";
+import { type HistoryRouter } from "./overlayHistory";
+export type OverlayHistoryMode = boolean | "reopen";
+export interface ProvideOverlayHistoryOptions {
+    /**
+     * The app's router, so a Back or Forward that only closes an overlay does
+     * not reach it as a navigation (vue-router: the router instance). Its
+     * popstate listener runs before the kit's, so without this it sees each of
+     * those steps as a visit to the page it is already on: guards and
+     * `afterEach` run again and the route object is replaced, though nothing
+     * remounts. One router per page; the latest one given is used.
+     */
+    router?: HistoryRouter;
+}
+/** Turn browser history on for every overlay below the calling component. */
+export declare function provideOverlayHistory(mode?: MaybeRefOrGetter<OverlayHistoryMode>, options?: ProvideOverlayHistoryOptions): void;
+export interface OverlayHistoryOptions {
+    /** The overlay's own `history` prop; `undefined` follows `provideOverlayHistory`. */
+    mode: () => OverlayHistoryMode | undefined;
+    open: () => boolean;
+    /** Back left the entry: close the way the overlay's own ways out do. */
+    close: () => Promise<unknown>;
+    /** Forward under `"reopen"`: ask the app to open it again (`update:open` true). */
+    reopen: () => void;
+    /** The page went to another path: close without asking, the place it belonged to is gone. */
+    navigated: () => void;
+}
+/** Wire an overlay's `open` to a history entry. */
+export declare function useOverlayHistory(options: OverlayHistoryOptions): void;
+export interface StepHistoryOptions {
+    /** The component's own `history` prop; `undefined` follows the overlay it sits in. */
+    mode: () => boolean | undefined;
+    /** Show this value without recording it. */
+    set: (value: string) => void;
+    /** Whether the value can still be shown (the tab exists and is enabled). */
+    has: (value: string) => boolean;
+}
+/**
+ * Steps inside an overlay (a tab switch) as history entries. Outside an overlay
+ * it is off unless asked for: a page's own tabs belong in its URL, where the
+ * app's router already keeps them.
+ */
+export declare function useStepHistory(options: StepHistoryOptions): {
+    record: (from: string, to: string) => void;
+};