@toife/vue 3.3.11 → 3.4.1

package/dist/components/index.d.ts

@@ -23,6 +23,7 @@ export * from './segmented-field';
 export * from './container';
 export * from './refresher';
 export * from './route';
+export * from './scrollbar';
 export * from './page';
 export * from './collapse';
 export * from './form-group';

package/dist/components/scrollbar/index.d.ts

@@ -0,0 +1 @@
+export { default as Scrollbar } from './scrollbar.vue';

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

@@ -0,0 +1,28 @@
+import { ScrollbarProps } from '../../core';
+declare const _default: import('vue').DefineComponent<ScrollbarProps, {
+    /** The element that actually scrolls. */
+    scrollport: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    /** Re-measure after a change no observer can see. */
+    update: () => void;
+    metrics: {
+        clientWidth: number;
+        clientHeight: number;
+        scrollWidth: number;
+        scrollHeight: number;
+        scrollLeft: number;
+        scrollTop: number;
+    };
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    scroll: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<ScrollbarProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+}>, {
+    role: string;
+    size: number;
+    direction: import('../../core').ScrollbarDirection;
+    thumbSize: number;
+    minThumb: number;
+    autoHide: boolean;
+    hideDelay: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -21,6 +21,7 @@ export * from './present';
 export * from './radio';
 export * from './refresher';
 export * from './route';
+export * from './scrollbar';
 export * from './segmented-field';
 export * from './select';
 export * from './skeleton';

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

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

package/dist/core/features/scrollbar/scrollbar.constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Scrollbar Default Props
+ */
+export declare const SCROLLBAR_DEFAULT_PROPS: {
+    readonly direction: "vertical";
+    readonly size: 10;
+    readonly thumbSize: 6;
+    readonly minThumb: 24;
+    readonly autoHide: true;
+    readonly hideDelay: 500;
+    readonly role: "";
+};
+/** Overflow of 1px or less is rounding noise, not something worth a scrollbar. */
+export declare const SCROLLBAR_OVERFLOW_EPSILON = 1;
+/** `WheelEvent.deltaMode: 1` is lines; browsers expose no size for one. */
+export declare const SCROLLBAR_WHEEL_LINE = 16;
+/** A `click` this soon after a drag is that drag's release, not a new click. */
+export declare const SCROLLBAR_CLICK_AFTER_DRAG = 200;

package/dist/core/features/scrollbar/scrollbar.logic.d.ts

@@ -0,0 +1,51 @@
+import { ScrollbarAttrOptions, ScrollbarAxis, ScrollbarAxisGeometry, ScrollbarDirection, ScrollbarGeometryOptions, ScrollbarMetrics, ScrollbarThumbAttrOptions, ScrollbarTrackAttrOptions } from './scrollbar.type';
+export declare const getScrollbarAttrs: (options: ScrollbarAttrOptions) => {
+    class: (string | {
+        visible: boolean;
+        dragging: boolean;
+    })[];
+    style: {
+        [x: string]: string;
+    };
+};
+export declare const getScrollbarContentAttrs: () => {
+    class: string[];
+};
+export declare const getScrollbarTrackAttrs: (options: ScrollbarTrackAttrOptions) => {
+    class: (string | {
+        [x: string]: boolean;
+    })[];
+    style: {
+        [x: string]: string;
+    };
+};
+export declare const getScrollbarThumbAttrs: (options: ScrollbarThumbAttrOptions) => {
+    class: string[];
+    style: {
+        [x: string]: string;
+    };
+};
+/** Hit-testing a press against the thumb needs the class as a selector. */
+export declare const getScrollbarThumbSelector: () => string;
+/** Read the scrollport in one go — every number the geometry needs. */
+export declare const getScrollbarMetrics: (element: Element) => ScrollbarMetrics;
+/** Is this axis both allowed by `direction` and actually overflowing? */
+export declare const hasScrollbarAxis: (axis: ScrollbarAxis, direction: ScrollbarDirection, metrics: ScrollbarMetrics) => boolean;
+/**
+ * Everything the track and thumb need for one axis. The thumb is the visible
+ * share of the content, floored at `minThumb` so long documents keep a grabbable
+ * handle.
+ */
+export declare const getScrollbarGeometry: (axis: ScrollbarAxis, metrics: ScrollbarMetrics, options: ScrollbarGeometryOptions) => ScrollbarAxisGeometry;
+/**
+ * Scroll offset that centers the thumb on `point`, measured in px from the start
+ * of the track — what a click on the empty part of the track jumps to.
+ */
+export declare const getScrollbarScrollFromPoint: (geometry: ScrollbarAxisGeometry, point: number) => number;
+/**
+ * Scroll offset for a drag that has moved `delta` px since it grabbed the thumb
+ * at `origin`. One px of thumb travel is `maxScroll / travel` px of content.
+ */
+export declare const getScrollbarScrollFromDelta: (geometry: ScrollbarAxisGeometry, origin: number, delta: number) => number;
+/** Wheel deltas arrive in px, lines or pages depending on the device. */
+export declare const getScrollbarWheelScale: (deltaMode: number, page: number) => number;

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

@@ -0,0 +1,61 @@
+export type ScrollbarDirection = "vertical" | "horizontal" | "both";
+export type ScrollbarAxis = "x" | "y";
+export type ScrollbarProps = {
+    direction?: ScrollbarDirection;
+    /** Gutter width in px — the hit area of the track. */
+    size?: number;
+    /** Painted thumb width in px, centered inside the gutter. */
+    thumbSize?: number;
+    /** Shortest the thumb may get on very long content. */
+    minThumb?: number;
+    /** Fade the tracks out when idle. */
+    autoHide?: boolean;
+    /** Idle time in ms before fading out after a scroll. */
+    hideDelay?: number;
+    role?: string;
+};
+export type ScrollbarEvent = {
+    (e: "scroll", event: Event): void;
+};
+/** Live geometry of the scrollport, read straight off the element. */
+export type ScrollbarMetrics = {
+    clientWidth: number;
+    clientHeight: number;
+    scrollWidth: number;
+    scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+};
+export type ScrollbarGeometryOptions = {
+    /** Px taken off the track end so the two tracks never meet in the corner. */
+    inset: number;
+    minThumb: number;
+};
+/** One axis of `ScrollbarMetrics`, resolved into px the track can be drawn from. */
+export type ScrollbarAxisGeometry = {
+    /** Length of the track. */
+    track: number;
+    /** Length of the thumb. */
+    thumb: number;
+    /** How far the thumb can travel — the scale between thumb px and content px. */
+    travel: number;
+    /** How far the content can scroll. */
+    maxScroll: number;
+    /** Where the thumb sits right now. */
+    offset: number;
+};
+export type ScrollbarAttrOptions = {
+    role: string;
+    size: number;
+    thumbSize: number;
+    visible: boolean;
+    dragging: boolean;
+};
+export type ScrollbarTrackAttrOptions = {
+    axis: ScrollbarAxis;
+    inset: number;
+};
+export type ScrollbarThumbAttrOptions = {
+    length: number;
+    offset: number;
+};

package/dist/core/utils/fullscreen.d.ts

@@ -0,0 +1,7 @@
+export declare function createFullscreen(): {
+    isFullscreen: () => boolean;
+    enter: (element: HTMLElement) => Promise<void>;
+    exit: () => Promise<void>;
+    toggle: (element: HTMLElement) => Promise<void>;
+    subscribe: (listener: (isFullscreen: boolean) => void) => () => void;
+};

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

@@ -1,3 +1,4 @@
 export * from './element';
 export * from './events';
 export * from './style';
+export * from './fullscreen';

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './factory';
 export * from './components';
+export * from './utils';
 export * from './core';