@toife/vue 3.5.2 → 3.5.4

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

@@ -9,7 +9,7 @@ declare const _default: import('vue').DefineComponent<ActionProps, {}, {}, {}, {
     role: string;
     shape: string;
     divider: boolean;
-    placement: import('../../core').ActionPlacement;
     visible: boolean;
+    placement: import('../../core').ActionPlacement;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/decision-modal/decision-modal.vue.d.ts

@@ -10,8 +10,8 @@ declare const _default: import('vue').DefineComponent<DecisionModalProps, {}, {}
     shape: string;
     divider: boolean;
     direction: import('../../core').DecisionModalDirection;
+    visible: boolean;
     placement: string;
     keepalive: boolean;
-    visible: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/index.d.ts

@@ -33,3 +33,4 @@ export * from './select';
 export * from './slide-range';
 export * from './tag';
 export * from './tooltip';
+export * from './virtual-list';

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

@@ -7,9 +7,9 @@ declare const _default: import('vue').DefineComponent<ModalProps, {}, {}, {}, {}
     duration: number;
     backdrop: "display" | "none" | "transparent";
     bounce: number | string;
+    visible: boolean;
     placement: "top" | "left" | "right" | "center" | "bottom";
     keepalive: boolean;
-    visible: boolean;
     gesture: boolean;
     fullscreen: boolean;
     indicator: boolean;

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

@@ -11,8 +11,8 @@ declare const _default: import('vue').DefineComponent<PresentProps, {
     duration: number;
     backdrop: "display" | "none" | "transparent";
     bounce: number | string | boolean;
+    visible: boolean;
     placement: import('../../core').PresentPlacement;
     keepalive: boolean;
-    visible: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/components/route/route-wrapper/route-wrapper.composable.d.ts

@@ -2,5 +2,5 @@ import { RouteLocationMatched } from 'vue-router';
 import { RouteStack } from '../../../core';
 export declare const useRouteWrapper: () => {
     stack: import('vue').ShallowRef<RouteStack[], RouteStack[]>;
-    updateRoutes: (matched: RouteLocationMatched[]) => void;
+    updateRoutes: (matched: RouteLocationMatched[], fullPath?: string) => void;
 };

package/dist/components/virtual-list/index.d.ts

@@ -0,0 +1 @@
+export { default as VirtualList } from './virtual-list.vue';

package/dist/components/virtual-list/virtual-list.vue.d.ts

@@ -0,0 +1,49 @@
+import { VirtualListAlign, VirtualListProps } from '../../core';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        item(props: {
+            item: unknown;
+            index: number;
+        }): unknown;
+    }> & {
+        item(props: {
+            item: unknown;
+            index: number;
+        }): unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<VirtualListProps, {
+    /** Ancestor that actually scrolls. */
+    scrollport: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    scrollToIndex: (index: number, align?: VirtualListAlign) => void;
+    scrollToOffset: (offset: number) => void;
+    /** Recompute the window after a change no observer can see. */
+    update: () => void;
+    range: {
+        start: number;
+        end: number;
+        offset: number;
+        size: number;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    visible: (range: import('../../core').VirtualListVisibleRange) => any;
+}, string, import('vue').PublicProps, Readonly<VirtualListProps> & Readonly<{
+    onVisible?: ((range: import('../../core').VirtualListVisibleRange) => any) | undefined;
+}>, {
+    direction: import('../../core').VirtualListDirection;
+    gap: number;
+    estimate: number;
+    overscan: number;
+    measure: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/features/index.d.ts

@@ -33,3 +33,4 @@ export * from './tag';
 export * from './toast';
 export * from './toolbar';
 export * from './tooltip';
+export * from './virtual-list';

package/dist/core/features/route/route.type.d.ts

@@ -2,4 +2,10 @@ export type RouteStack = {
     name: string;
     component: unknown;
     stack: RouteStack[];
+    /** Unique identity: leaf pages use `fullPath`, layouts use route `name`. */
+    key: string;
+    /** Location `fullPath` when this entry was last activated. */
+    fullPath: string;
 };
+/** Leaf pages are unique by full URL; layout segments stay unique by route name. */
+export declare const getRouteStackKey: (name: string, isLeaf: boolean, fullPath: string) => string;

package/dist/core/features/virtual-list/index.d.ts

@@ -0,0 +1,3 @@
+export * from './virtual-list.constants';
+export * from './virtual-list.type';
+export * from './virtual-list.logic';

package/dist/core/features/virtual-list/virtual-list.constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Virtual List Default Props
+ */
+export declare const VIRTUAL_LIST_DEFAULT_PROPS: {
+    readonly estimate: 48;
+    readonly overscan: 4;
+    readonly gap: 0;
+    readonly direction: "vertical";
+    readonly measure: true;
+};
+/** Unmeasured items must not collapse to 0 or the window search cannot move. */
+export declare const VIRTUAL_LIST_MIN_ESTIMATE = 1;
+/** Sub-pixel resize noise is not a real size change. */
+export declare const VIRTUAL_LIST_SIZE_EPSILON = 0.5;
+export declare const VIRTUAL_LIST_OVERFLOW_RE: RegExp;

package/dist/core/features/virtual-list/virtual-list.logic.d.ts

@@ -0,0 +1,32 @@
+import { VirtualListAlign, VirtualListAttrOptions, VirtualListDirection, VirtualListItemAttrOptions, VirtualListItemKey, VirtualListMetrics, VirtualListWindow, VirtualListWindowOptions } from './virtual-list.type';
+export declare const getVirtualListItemSize: (index: number, sizes: Array<number | undefined>, estimate: number) => number;
+export declare const getVirtualListAttrs: (options: VirtualListAttrOptions) => {
+    class: (string | {
+        [x: string]: boolean;
+    })[];
+    style: {
+        [x: string]: string;
+    };
+};
+export declare const getVirtualListItemAttrs: (options: VirtualListItemAttrOptions) => {
+    class: string[];
+    style: {
+        [x: string]: string;
+    };
+};
+export declare const getVirtualListItemKey: (item: unknown, index: number, itemKey?: VirtualListItemKey) => PropertyKey;
+/**
+ * Prefix offsets: `offsets[i]` is the start of item `i`, `offsets[count]` is
+ * the end of the last item plus a trailing `gap` that callers must subtract.
+ */
+export declare const buildVirtualListOffsets: (count: number, sizes: Array<number | undefined>, estimate: number, gap: number) => number[];
+export declare const getVirtualListTotalSize: (offsets: number[], gap: number) => number;
+/** Largest `i` whose item starts at or before `offset`. */
+export declare const findVirtualListIndex: (offsets: number[], offset: number) => number;
+export declare const getVirtualListWindow: (offsets: number[], metrics: VirtualListMetrics, options: VirtualListWindowOptions) => VirtualListWindow;
+export declare const getVirtualListScrollToOffset: (offsets: number[], index: number, viewport: number, align: VirtualListAlign, current: number, gap: number) => number;
+export declare const getVirtualListMetrics: (scrollport: HTMLElement, direction: VirtualListDirection) => VirtualListMetrics;
+export declare const getVirtualListItemExtent: (element: HTMLElement, direction: VirtualListDirection) => number;
+/** Closest overflow ancestor — `.t-scrollbar-content` when nested in `t-scrollbar`. */
+export declare const getVirtualListScrollport: (element: Element | null, direction: VirtualListDirection) => HTMLElement | null;
+export declare const scrollVirtualListTo: (scrollport: HTMLElement, direction: VirtualListDirection, offset: number, behavior?: ScrollBehavior) => void;

package/dist/core/features/virtual-list/virtual-list.type.d.ts

@@ -0,0 +1,49 @@
+export type VirtualListDirection = "vertical" | "horizontal";
+export type VirtualListAlign = "start" | "center" | "end" | "auto";
+export type VirtualListItemKey = string | ((item: unknown, index: number) => PropertyKey);
+export type VirtualListProps = {
+    items?: unknown[];
+    /** Estimated (or fixed) item size in px along the scroll axis. */
+    estimate?: number;
+    /** Extra items rendered before and after the viewport. */
+    overscan?: number;
+    /** Space between items in px. Not applied after the last item. */
+    gap?: number;
+    direction?: VirtualListDirection;
+    /** Measure rendered items and remember their sizes. */
+    measure?: boolean;
+    /** Field name or getter used as the Vue/Lit item key. Defaults to the index. */
+    itemKey?: VirtualListItemKey;
+};
+export type VirtualListVisibleRange = {
+    start: number;
+    end: number;
+};
+export type VirtualListEvent = {
+    (e: "visible", range: VirtualListVisibleRange): void;
+};
+export type VirtualListMetrics = {
+    scrollOffset: number;
+    viewport: number;
+};
+/** One window of `items` that should be in the DOM. `end` is exclusive. */
+export type VirtualListWindow = {
+    start: number;
+    end: number;
+    /** Offset of `items[start]` from the start of the list. */
+    offset: number;
+    /** Total size of the list along the scroll axis — what the scrollport must see. */
+    size: number;
+};
+export type VirtualListAttrOptions = {
+    direction: VirtualListDirection;
+    size: number;
+};
+export type VirtualListItemAttrOptions = {
+    direction: VirtualListDirection;
+    offset: number;
+};
+export type VirtualListWindowOptions = {
+    overscan: number;
+    gap: number;
+};