@xleddyl/443-components-vue 0.10.2 → 0.12.0

package/dist/grid/GridToolbar.vue

@@ -12,6 +12,46 @@
             :aria-label="text.search"
          />
       </div>
+      <span v-if="$slots.filters" class="k-data-grid-filters">
+         <Button
+            variant="outline"
+            tone="neutral"
+            size="sm"
+            icon="funnel"
+            square
+            :aria-label="filtersLabel"
+            aria-haspopup="dialog"
+            :aria-expanded="filtersOpen ? 'true' : 'false'"
+            :class="{ 'is-active': activeFilters > 0 }"
+            @click="filtersOpen = true"
+         />
+         <Badge
+            v-if="activeFilters > 0"
+            class="k-data-grid-filters-count"
+            tone="accent"
+            variant="solid"
+            size="sm"
+            :label="activeFilters"
+            aria-hidden="true"
+         />
+      </span>
+      <Modal v-if="$slots.filters" v-model:open="filtersOpen" :title="text.filters" size="sm">
+         <div class="k-data-grid-filters-body">
+            <slot name="filters" :close="closeFilters" :count="activeFilters" />
+         </div>
+         <template #footer="{ close }">
+            <Button
+               class="k-data-grid-filters-reset"
+               variant="ghost"
+               tone="neutral"
+               icon="arrow-path"
+               :label="text.resetFilters"
+               :aria-disabled="activeFilters === 0 ? 'true' : void 0"
+               @click="resetFilters"
+            />
+            <Button :label="text.showResults" @click="close" />
+         </template>
+      </Modal>
       <div class="k-data-grid-toolbar-actions">
          <slot />
          <DropdownMenu
@@ -47,8 +87,11 @@
 import { computed, onBeforeUnmount, ref, watch } from "vue";
 import Button from "../components/core/Button.vue";
 import Input from "../components/core/Input.vue";
+import Badge from "../components/data/Badge.vue";
 import DropdownMenu from "../components/overlays/DropdownMenu.vue";
+import Modal from "../components/overlays/Modal.vue";
 import { useLocale } from "../composables/useLocale";
+import { formatLocaleMessage } from "../locale";
 const props = defineProps({
   api: { type: [Object, null], required: false },
   messages: { type: Object, required: false },
@@ -56,15 +99,21 @@ const props = defineProps({
   columnMenu: { type: Boolean, required: false, default: true },
   exportable: { type: Boolean, required: false, default: true },
   exportFileName: { type: String, required: false, default: "export" },
-  debounce: { type: Number, required: false, default: 0 }
+  debounce: { type: Number, required: false, default: 0 },
+  filterCount: { type: Number, required: false, default: 0 }
 });
-const emit = defineEmits(["resetColumns"]);
+const emit = defineEmits(["resetColumns", "filtersReset"]);
 const query = defineModel({ type: String, ...{ default: "" } });
 const { locale } = useLocale();
+const filtersOpen = ref(false);
+const activeFilters = computed(() => Math.max(0, Math.floor(props.filterCount)));
 const text = computed(() => ({
   ...locale.value.messages.grid,
   ...props.messages
 }));
+const filtersLabel = computed(
+  () => formatLocaleMessage(locale.value.code, text.value.filtersActive, { count: activeFilters.value })
+);
 const draft = ref(query.value);
 const columns = ref([]);
 const visibleCount = computed(() => columns.value.filter((column) => column.visible).length);
@@ -130,6 +179,12 @@ function resetColumns() {
   props.api?.resetColumnState();
   emit("resetColumns");
 }
+function resetFilters() {
+  if (activeFilters.value > 0) emit("filtersReset");
+}
+function closeFilters() {
+  filtersOpen.value = false;
+}
 function exportCsv() {
   props.api?.exportDataAsCsv({ fileName: props.exportFileName });
 }

package/dist/grid/GridToolbar.vue.d.ts

@@ -1,7 +1,13 @@
 import type { GridMessages } from './types';
-declare var __VLS_8: {};
+declare function closeFilters(): void;
+declare var __VLS_28: {
+    close: typeof closeFilters;
+    count: number;
+}, __VLS_45: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    filters?: (props: typeof __VLS_28) => any;
+} & {
+    default?: (props: typeof __VLS_45) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<{
     api?: import("ag-grid-community").GridApi | null;
@@ -11,6 +17,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
     exportable?: boolean;
     exportFileName?: string;
     debounce?: number;
+    filterCount?: number;
     modelValue?: string;
     key?: PropertyKey | undefined;
     prefix?: string | undefined | undefined;
@@ -207,6 +214,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
 }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     resetColumns: () => any;
     "update:modelValue": (value: string) => any;
+    filtersReset: () => any;
 }, string, import("vue").PublicProps, Readonly<{
     api?: import("ag-grid-community").GridApi | null;
     messages?: Partial<GridMessages>;
@@ -215,6 +223,7 @@ declare const __VLS_base: import("vue").DefineComponent<{
     exportable?: boolean;
     exportFileName?: string;
     debounce?: number;
+    filterCount?: number;
     modelValue?: string;
     key?: PropertyKey | undefined;
     prefix?: string | undefined | undefined;
@@ -411,12 +420,14 @@ declare const __VLS_base: import("vue").DefineComponent<{
 }> & Readonly<{
     onResetColumns?: (() => any) | undefined;
     "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onFiltersReset?: (() => any) | undefined;
 }>, {
     debounce: number;
     searchable: boolean;
     columnMenu: boolean;
     exportable: boolean;
     exportFileName: string;
+    filterCount: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/grid/cells/BadgeCell.vue

@@ -1,11 +1,60 @@
 <template>
-   <template v-if="text">
-      <Badge v-if="params.variant" :class="badgeClass" :tone :variant="params.variant" :size>{{
-         text
-      }}</Badge>
-      <span v-else class="k-data-grid-badge" :class="[`k-data-grid-badge-${tone}`, badgeClass]">{{
-         text
-      }}</span>
+   <span
+      v-if="isList && entries.length"
+      class="k-data-grid-badges"
+      :class="{ 'is-wrap': params.wrap }"
+      :title="fullText"
+   >
+      <template v-for="entry in shown" :key="entry.key">
+         <Badge
+            v-if="params.variant"
+            :class="entry.badgeClass"
+            :tone="entry.tone"
+            :variant="params.variant"
+            :size
+            >{{ entry.text }}</Badge
+         >
+         <span
+            v-else
+            class="k-data-grid-badge"
+            :class="[`k-data-grid-badge-${entry.tone}`, entry.badgeClass]"
+            >{{ entry.text }}</span
+         >
+      </template>
+      <template v-if="hiddenCount > 0">
+         <Badge
+            v-if="params.variant"
+            class="k-data-grid-badge-more"
+            tone="neutral"
+            :variant="params.variant"
+            :size
+            aria-hidden="true"
+            >+{{ hiddenCount }}</Badge
+         >
+         <span
+            v-else
+            class="k-data-grid-badge k-data-grid-badge-neutral k-data-grid-badge-more"
+            aria-hidden="true"
+            >+{{ hiddenCount }}</span
+         >
+         <span class="k-visually-hidden">{{ moreText }}</span>
+      </template>
+   </span>
+   <template v-else-if="!isList && single">
+      <Badge
+         v-if="params.variant"
+         :class="single.badgeClass"
+         :tone="single.tone"
+         :variant="params.variant"
+         :size
+         >{{ single.text }}</Badge
+      >
+      <span
+         v-else
+         class="k-data-grid-badge"
+         :class="[`k-data-grid-badge-${single.tone}`, single.badgeClass]"
+         >{{ single.text }}</span
+      >
    </template>
    <EmptyCell v-else :context="cellContext" />
 </template>
@@ -13,22 +62,45 @@
 <script setup>
 import { computed } from "vue";
 import Badge from "../../components/data/Badge.vue";
+import { formatLocaleMessage } from "../../locale";
 import EmptyCell from "./EmptyCell.vue";
 const props = defineProps({
   params: { type: Object, required: true }
 });
-const key = computed(() => {
-  const raw = props.params.value;
-  return raw === null || raw === void 0 ? "" : String(raw);
-});
-const text = computed(() => key.value ? props.params.labels?.[key.value] ?? key.value : "");
-const tone = computed(
-  () => props.params.tones?.[key.value] ?? props.params.defaultTone ?? "neutral"
-);
+const cellContext = computed(() => props.params.context);
 const size = computed(() => props.params.size ?? "sm");
-const badgeClass = computed(() => {
+const isList = computed(() => Array.isArray(props.params.value));
+function keyOf(raw) {
+  return raw === null || raw === void 0 ? "" : String(raw);
+}
+function entryFor(raw, index) {
+  const key = keyOf(raw);
+  if (!key) return null;
   const source = props.params.badgeClass;
-  return typeof source === "function" ? source(props.params.value, props.params.data) : source;
+  return {
+    key: `${index}-${key}`,
+    text: props.params.labels?.[key] ?? key,
+    tone: props.params.tones?.[key] ?? props.params.defaultTone ?? "neutral",
+    badgeClass: typeof source === "function" ? source(raw, props.params.data) : source
+  };
+}
+const single = computed(() => isList.value ? null : entryFor(props.params.value, 0));
+const entries = computed(() => {
+  if (!isList.value) return [];
+  return props.params.value.map((raw, index) => entryFor(raw, index)).filter((entry) => entry !== null);
 });
-const cellContext = computed(() => props.params.context);
+const limit = computed(() => {
+  const max = props.params.max;
+  return max === void 0 || max < 1 ? entries.value.length : Math.floor(max);
+});
+const shown = computed(() => entries.value.slice(0, limit.value));
+const hiddenCount = computed(() => entries.value.length - shown.value.length);
+const fullText = computed(() => entries.value.map((entry) => entry.text).join(", "));
+const moreText = computed(
+  () => formatLocaleMessage(
+    cellContext.value?.locale ?? "en",
+    cellContext.value?.messages?.moreValues ?? "{count} more",
+    { count: hiddenCount.value }
+  )
+);
 </script>

package/dist/grid/cells/BadgeCell.vue.d.ts

@@ -1,13 +1,6 @@
 import type { BadgeCellParams, GridCellContext } from '../types';
 declare const __VLS_export: import("vue").DefineComponent<{
     params: import("ag-grid-community").ICellRendererParams<any, any, any> & BadgeCellParams<unknown>;
-    label?: string | number;
-    tone?: import("../../index.ts").Tone;
-    variant?: import("../../index.ts").BadgeVariant;
-    size?: import("../../index.ts").BadgeSize;
-    dot?: boolean;
-    pulse?: boolean;
-    icon?: import("../../index.ts").IconName;
     innerHTML?: string | undefined | undefined;
     class?: import("vue").ClassValue;
     style?: import("vue").StyleValue;
@@ -200,6 +193,13 @@ declare const __VLS_export: import("vue").DefineComponent<{
     ref?: import("vue").VNodeRef | undefined;
     ref_for?: boolean | undefined | undefined;
     ref_key?: string | undefined | undefined;
+    label?: string | number;
+    tone?: import("../../index.ts").Tone;
+    variant?: import("../../index.ts").BadgeVariant;
+    size?: import("../../index.ts").BadgeSize;
+    dot?: boolean;
+    pulse?: boolean;
+    icon?: import("../../index.ts").IconName;
     onVnodeBeforeMount?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
     onVnodeMounted?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
     onVnodeBeforeUpdate?: (((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]) | undefined;
@@ -209,13 +209,6 @@ declare const __VLS_export: import("vue").DefineComponent<{
     context?: GridCellContext;
 }, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
     params: import("ag-grid-community").ICellRendererParams<any, any, any> & BadgeCellParams<unknown>;
-    label?: string | number;
-    tone?: import("../../index.ts").Tone;
-    variant?: import("../../index.ts").BadgeVariant;
-    size?: import("../../index.ts").BadgeSize;
-    dot?: boolean;
-    pulse?: boolean;
-    icon?: import("../../index.ts").IconName;
     innerHTML?: string | undefined | undefined;
     class?: import("vue").ClassValue;
     style?: import("vue").StyleValue;
@@ -408,6 +401,13 @@ declare const __VLS_export: import("vue").DefineComponent<{
     ref?: import("vue").VNodeRef | undefined;
     ref_for?: boolean | undefined | undefined;
     ref_key?: string | undefined | undefined;
+    label?: string | number;
+    tone?: import("../../index.ts").Tone;
+    variant?: import("../../index.ts").BadgeVariant;
+    size?: import("../../index.ts").BadgeSize;
+    dot?: boolean;
+    pulse?: boolean;
+    icon?: import("../../index.ts").IconName;
     onVnodeBeforeMount?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
     onVnodeMounted?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
     onVnodeBeforeUpdate?: (((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]) | undefined;

package/dist/grid/data-grid.css

@@ -20,6 +20,39 @@
    max-width: 22rem;
 }
 
+.k-data-grid-filters {
+   position: relative;
+   display: inline-flex;
+   flex: none;
+}
+
+.k-data-grid-filters > .k-btn.is-active {
+   color: var(--k-accent-text);
+}
+
+.k-data-grid-filters > .k-data-grid-filters-count {
+   position: absolute;
+   inset-block-start: -0.4375rem;
+   inset-inline-end: -0.4375rem;
+   min-width: 1.125rem;
+   height: 1.125rem;
+   padding-inline: 0.25rem;
+   justify-content: center;
+   font-size: 0.75rem;
+   line-height: 1;
+   pointer-events: none;
+}
+
+.k-data-grid-filters-body {
+   display: flex;
+   flex-direction: column;
+   gap: 0.875rem;
+}
+
+.k-data-grid-filters-reset {
+   margin-inline-end: auto;
+}
+
 .k-data-grid-toolbar-actions {
    display: flex;
    flex-wrap: wrap;
@@ -163,6 +196,30 @@
    white-space: nowrap;
 }
 
+.k-data-grid-badges {
+   display: flex;
+   flex-wrap: nowrap;
+   align-items: center;
+   gap: 0.25rem;
+   min-width: 0;
+   max-width: 100%;
+   overflow: hidden;
+}
+
+.k-data-grid-badges.is-wrap {
+   flex-wrap: wrap;
+   padding-block: 0.25rem;
+   line-height: 1.2;
+}
+
+.k-data-grid-badges > * {
+   flex-shrink: 0;
+}
+
+.k-data-grid-badges > .k-data-grid-badge-more {
+   font-variant-numeric: tabular-nums;
+}
+
 .k-data-grid-badge-accent {
    --k-badge-tone: var(--k-accent-text);
 }

package/dist/grid/spreadsheet.mjs

@@ -102,15 +102,19 @@ export function createGridSpreadsheet(options) {
     const inside = cell.row >= rect.top && cell.row <= rect.bottom && cell.col >= rect.left && cell.col <= rect.right;
     return inside ? cell : null;
   }
+  function onRangeEdge(params, edge) {
+    const cell = rangeCell(params);
+    return !!cell && !!rect && edge(cell, rect);
+  }
   const classRules = {
     "is-range": (params) => {
       const cell = rangeCell(params);
       return !!cell && !sameCell(cell, active);
     },
-    "is-range-top": (params) => rangeCell(params)?.row === rect?.top,
-    "is-range-bottom": (params) => rangeCell(params)?.row === rect?.bottom,
-    "is-range-left": (params) => rangeCell(params)?.col === rect?.left,
-    "is-range-right": (params) => rangeCell(params)?.col === rect?.right,
+    "is-range-top": (params) => onRangeEdge(params, (cell, area) => cell.row === area.top),
+    "is-range-bottom": (params) => onRangeEdge(params, (cell, area) => cell.row === area.bottom),
+    "is-range-left": (params) => onRangeEdge(params, (cell, area) => cell.col === area.left),
+    "is-range-right": (params) => onRangeEdge(params, (cell, area) => cell.col === area.right),
     "is-active": (params) => !!active && sameCell(cellOf(params), active),
     "is-fill-corner": (params) => {
       if (!rect) return false;

package/dist/grid/types.d.ts

@@ -31,6 +31,7 @@ export interface GridToolbarProps {
     exportable?: boolean;
     exportFileName?: string;
     debounce?: number;
+    filterCount?: number;
 }
 export interface BooleanCellParams {
     trueLabel?: string;
@@ -49,6 +50,8 @@ export interface BadgeCellParams<T = unknown> {
     variant?: BadgeVariant;
     size?: BadgeSize;
     badgeClass?: string | ((value: unknown, data: T | undefined) => string | undefined);
+    max?: number;
+    wrap?: boolean;
 }
 export type ImageCellFit = 'cover' | 'contain';
 export interface ImageCellParams<T = unknown> {

package/dist/icons/builtin.d.ts

@@ -7,6 +7,8 @@ export declare const builtinIcons: {
     readonly 'chevron-up': readonly ["m4.5 15.75 7.5-7.5 7.5 7.5"];
     readonly 'chevron-left': readonly ["M15.75 19.5 8.25 12l7.5-7.5"];
     readonly 'chevron-right': readonly ["m8.25 4.5 7.5 7.5-7.5 7.5"];
+    readonly 'sidebar-collapse': readonly ["M15.75 19.5 8.25 12l7.5-7.5"];
+    readonly 'sidebar-expand': readonly ["m8.25 4.5 7.5 7.5-7.5 7.5"];
     readonly 'chevron-up-down': readonly ["M8.25 15 12 18.75 15.75 15m-7.5-6L12 5.25 15.75 9"];
     readonly 'chevron-double-left': readonly ["m18.75 4.5-7.5 7.5 7.5 7.5m-6-15L5.25 12l7.5 7.5"];
     readonly 'chevron-double-right': readonly ["m5.25 4.5 7.5 7.5-7.5 7.5m6-15 7.5 7.5-7.5 7.5"];

package/dist/icons/builtin.mjs

@@ -7,6 +7,8 @@ export const builtinIcons = {
   "chevron-up": ["m4.5 15.75 7.5-7.5 7.5 7.5"],
   "chevron-left": ["M15.75 19.5 8.25 12l7.5-7.5"],
   "chevron-right": ["m8.25 4.5 7.5 7.5-7.5 7.5"],
+  "sidebar-collapse": ["M15.75 19.5 8.25 12l7.5-7.5"],
+  "sidebar-expand": ["m8.25 4.5 7.5 7.5-7.5 7.5"],
   "chevron-up-down": ["M8.25 15 12 18.75 15.75 15m-7.5-6L12 5.25 15.75 9"],
   "chevron-double-left": ["m18.75 4.5-7.5 7.5 7.5 7.5m-6-15L5.25 12l7.5 7.5"],
   "chevron-double-right": ["m5.25 4.5 7.5 7.5-7.5 7.5m6-15 7.5 7.5-7.5 7.5"],

package/dist/internal/data/sortable.d.ts

@@ -0,0 +1,5 @@
+export type SortableAxis = 'horizontal' | 'vertical';
+export declare const SORTABLE_ATTR = "data-k-sortable";
+export declare function sortableElements(container: HTMLElement | null | undefined): HTMLElement[];
+export declare function isRtl(element: Element | null | undefined): boolean;
+export declare function insertionIndex(elements: HTMLElement[], x: number, y: number, axis: SortableAxis, rtl: boolean): number;

package/dist/internal/data/sortable.mjs

@@ -0,0 +1,23 @@
+export const SORTABLE_ATTR = "data-k-sortable";
+export function sortableElements(container) {
+  if (!container) return [];
+  return Array.from(container.querySelectorAll(`[${SORTABLE_ATTR}]`)).sort(
+    (a, b) => Number(a.getAttribute(SORTABLE_ATTR)) - Number(b.getAttribute(SORTABLE_ATTR))
+  );
+}
+export function isRtl(element) {
+  return element ? getComputedStyle(element).direction === "rtl" : false;
+}
+function isBefore(rect, x, y, axis, rtl) {
+  if (axis === "vertical") return rect.top + rect.height / 2 < y;
+  if (rect.bottom <= y) return true;
+  if (rect.top > y) return false;
+  const center = rect.left + rect.width / 2;
+  return rtl ? center > x : center < x;
+}
+export function insertionIndex(elements, x, y, axis, rtl) {
+  let index = 0;
+  for (const element of elements)
+    if (isBefore(element.getBoundingClientRect(), x, y, axis, rtl)) index++;
+  return index;
+}

package/dist/internal/layout/query.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeRefOrGetter } from 'vue';
+import type { RouterLike } from './route';
+export type RouteHistory = 'push' | 'replace';
+export declare function firstQueryValue(value: unknown): string | undefined;
+export declare function useQueryValue(router: RouterLike | undefined, key: MaybeRefOrGetter<string | undefined>): import("vue").ComputedRef<string | undefined>;
+export declare function writeQueryValue(router: RouterLike, key: string, value: string | undefined, history: RouteHistory): Promise<boolean>;

package/dist/internal/layout/query.mjs

@@ -0,0 +1,64 @@
+import { computed, toValue } from "vue";
+import { isClient } from "../core/env.mjs";
+const batches = /* @__PURE__ */ new WeakMap();
+export function firstQueryValue(value) {
+  if (Array.isArray(value)) return firstQueryValue(value[0]);
+  return typeof value === "string" ? value : void 0;
+}
+export function useQueryValue(router, key) {
+  return computed(() => {
+    const name = toValue(key);
+    if (!router || !name) return void 0;
+    return firstQueryValue(router.currentRoute?.value?.query?.[name]);
+  });
+}
+function isPreviousEntry(router, location) {
+  if (!router.back || !router.resolve) return false;
+  const back = window.history.state?.back;
+  if (typeof back !== "string") return false;
+  return router.resolve(location).fullPath === back;
+}
+async function flush(router, batch) {
+  batches.delete(router);
+  const route = router.currentRoute?.value;
+  const query = { ...route?.query };
+  let changed = false;
+  for (const [key, value] of batch.changes) {
+    if (value === void 0) {
+      if (!(key in query)) continue;
+      delete query[key];
+      changed = true;
+    } else if (query[key] !== value) {
+      query[key] = value;
+      changed = true;
+    }
+  }
+  if (!changed) return true;
+  const location = { path: route?.path, query, hash: route?.hash };
+  try {
+    if (batch.history === "push" && isPreviousEntry(router, location)) {
+      router.back?.();
+      return true;
+    }
+    const failure = batch.history === "replace" && router.replace ? await router.replace(location) : await router.push(location);
+    return !failure;
+  } catch {
+    return false;
+  }
+}
+export function writeQueryValue(router, key, value, history) {
+  if (!isClient()) return Promise.resolve(true);
+  let batch = batches.get(router);
+  if (!batch) {
+    const created = {
+      changes: /* @__PURE__ */ new Map(),
+      history,
+      promise: Promise.resolve().then(() => flush(router, created))
+    };
+    batch = created;
+    batches.set(router, batch);
+  }
+  batch.changes.set(key, value === "" ? void 0 : value);
+  if (history === "push") batch.history = "push";
+  return batch.promise;
+}

package/dist/internal/layout/route.d.ts

@@ -1,9 +1,17 @@
 import type { MaybeRefOrGetter } from 'vue';
-interface RouteLike {
+export interface RouteLike {
     path?: string;
+    fullPath?: string;
+    hash?: string;
+    query?: Record<string, unknown>;
 }
 export interface RouterLike {
     push: (to: unknown) => unknown;
+    replace?: (to: unknown) => unknown;
+    back?: () => unknown;
+    resolve?: (to: unknown) => {
+        fullPath?: string;
+    };
     beforeEach: (guard: (to: RouteLike, from: RouteLike) => boolean | void | Promise<boolean | void>) => () => void;
     currentRoute?: {
         value?: RouteLike;
@@ -13,4 +21,3 @@ export declare function useRouterLike(): RouterLike | undefined;
 export declare function useCurrentPath(override?: MaybeRefOrGetter<string | undefined>): import("vue").ComputedRef<string | undefined>;
 export declare function targetPath(target: unknown): string | undefined;
 export declare function matchesPath(current: string, target: string, exact: boolean): boolean;
-export {};

package/dist/internal/overlays/avoid.d.ts

@@ -0,0 +1,26 @@
+import type { Ref } from 'vue';
+export interface ToasterInsets {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface ToasterAvoidanceOptions {
+    outlet: () => HTMLElement | null;
+    toaster: Readonly<Ref<HTMLElement | null | undefined>>;
+    position: () => string;
+}
+export declare function useToasterAvoidance(options: ToasterAvoidanceOptions): {
+    insets: Ref<{
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }, ToasterInsets | {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    }>;
+    refresh: () => void;
+};