ng-virtual-list 18.11.2 → 18.12.0

package/lib/components/ng-scroll-bar/ng-scroll-bar.component.d.ts

@@ -1,8 +1,9 @@
-import { Signal, TemplateRef } from '@angular/core';
+import { EventEmitter, TemplateRef } from '@angular/core';
 import { GradientColorPositions } from '../../types/gradient-color-positions';
 import { NgScrollView } from '../ng-scroll-view';
 import { IScrollBarDragEvent, IScrollBarTemplateContext } from './interfaces';
 import { NgScrollBarService } from './ng-scroll-bar.service';
+import { TextDirection } from '../../types';
 import * as i0 from "@angular/core";
 /**
  * ScrollBar component.
@@ -13,39 +14,89 @@ import * as i0 from "@angular/core";
  * @email djonnyx@gmail.com
  */
 export declare class NgScrollBarComponent extends NgScrollView {
-    protected _defaultRenderer: Signal<TemplateRef<any> | undefined>;
-    protected _service: NgScrollBarService;
+    protected _defaultRenderer: TemplateRef<any> | undefined;
+    protected _scrollBarService: NgScrollBarService;
     private _apiService;
-    readonly loading: import("@angular/core").InputSignal<boolean>;
-    readonly onDrag: import("@angular/core").OutputEmitterRef<IScrollBarDragEvent>;
-    readonly onDragEnd: import("@angular/core").OutputEmitterRef<IScrollBarDragEvent>;
-    readonly thumbGradientPositions: import("@angular/core").InputSignal<GradientColorPositions>;
-    readonly size: import("@angular/core").InputSignal<number>;
-    readonly thickness: import("@angular/core").InputSignal<number>;
-    readonly scrollbarMinSize: import("@angular/core").InputSignal<number>;
-    readonly prepared: import("@angular/core").InputSignal<boolean>;
-    readonly interactive: import("@angular/core").InputSignal<boolean>;
-    readonly show: import("@angular/core").InputSignal<boolean>;
-    readonly params: import("@angular/core").InputSignal<{
+    private _$loading;
+    readonly $loading: import("rxjs").Observable<boolean>;
+    set loading(v: boolean);
+    get loading(): boolean;
+    onDrag: EventEmitter<IScrollBarDragEvent>;
+    onDragEnd: EventEmitter<IScrollBarDragEvent>;
+    private _$thumbGradientPositions;
+    readonly $thumbGradientPositions: import("rxjs").Observable<GradientColorPositions>;
+    set thumbGradientPositions(v: GradientColorPositions);
+    get thumbGradientPositions(): GradientColorPositions;
+    private _$size;
+    readonly $size: import("rxjs").Observable<number>;
+    set size(v: number);
+    get size(): number;
+    private _$thickness;
+    readonly $thickness: import("rxjs").Observable<number>;
+    set thickness(v: number);
+    get thickness(): number;
+    private _$scrollbarMinSize;
+    readonly $scrollbarMinSize: import("rxjs").Observable<number>;
+    set scrollbarMinSize(v: number);
+    get scrollbarMinSize(): number;
+    private _$prepared;
+    readonly $prepared: import("rxjs").Observable<boolean>;
+    set prepared(v: boolean);
+    get prepared(): boolean;
+    private _$langTextDir;
+    readonly $langTextDir: import("rxjs").Observable<TextDirection>;
+    set langTextDir(v: TextDirection);
+    get langTextDir(): TextDirection;
+    private _$interactive;
+    readonly $interactive: import("rxjs").Observable<boolean>;
+    set interactive(v: boolean);
+    get interactive(): boolean;
+    private _$overlapping;
+    readonly $overlapping: import("rxjs").Observable<boolean>;
+    set overlapping(v: boolean);
+    get overlapping(): boolean;
+    private _$show;
+    readonly $show: import("rxjs").Observable<boolean>;
+    set show(v: boolean);
+    get show(): boolean;
+    private _$params;
+    readonly $params: import("rxjs").Observable<{
         [propName: string]: any;
     } | null>;
-    readonly renderer: import("@angular/core").InputSignal<TemplateRef<any> | null>;
-    readonly thumbRenderer: import("@angular/core").WritableSignal<TemplateRef<any> | null>;
-    protected readonly hoverState: import("@angular/core").WritableSignal<boolean>;
-    protected readonly pressedState: import("@angular/core").WritableSignal<boolean>;
-    protected readonly templateContext: Signal<IScrollBarTemplateContext>;
-    protected readonly styles: Signal<{
-        [sName: string]: any;
+    set params(v: {
+        [propName: string]: any;
+    } | null);
+    get params(): {
+        [propName: string]: any;
+    } | null;
+    private _$renderer;
+    readonly $renderer: import("rxjs").Observable<TemplateRef<any> | null>;
+    set renderer(v: TemplateRef<any> | null);
+    get renderer(): TemplateRef<any> | null;
+    private _$thumbRenderer;
+    readonly $thumbRenderer: import("rxjs").Observable<TemplateRef<any> | null>;
+    private _$hoverState;
+    readonly $hoverState: import("rxjs").Observable<boolean>;
+    private _$pressedState;
+    readonly $pressedState: import("rxjs").Observable<boolean>;
+    private _$templateContext;
+    readonly $templateContext: import("rxjs").Observable<IScrollBarTemplateContext>;
+    private _$styles;
+    readonly $styles: import("rxjs").Observable<{
+        [styleName: string]: any;
     }>;
-    protected readonly thumbWidth: Signal<number>;
-    protected readonly thumbHeight: Signal<number>;
+    private _$thumbWidth;
+    readonly $thumbWidth: import("rxjs").Observable<number>;
+    private _$thumbHeight;
+    readonly $thumbHeight: import("rxjs").Observable<number>;
     private _$scrollingCancel;
     protected readonly $scrollingCancel: import("rxjs").Observable<void>;
     private _elementRef;
     constructor();
+    ngAfterViewInit(): void;
     private createDragEvent;
     private thumbHit;
     click(event: PointerEvent | MouseEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgScrollBarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgScrollBarComponent, "ng-scroll-bar", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "thumbGradientPositions": { "alias": "thumbGradientPositions"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; "isSignal": true; }; "prepared": { "alias": "prepared"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; "params": { "alias": "params"; "required": false; "isSignal": true; }; "renderer": { "alias": "renderer"; "required": false; "isSignal": true; }; }, { "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgScrollBarComponent, "ng-scroll-bar", never, { "loading": { "alias": "loading"; "required": false; }; "thumbGradientPositions": { "alias": "thumbGradientPositions"; "required": false; }; "size": { "alias": "size"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "scrollbarMinSize": { "alias": "scrollbarMinSize"; "required": false; }; "prepared": { "alias": "prepared"; "required": false; }; "langTextDir": { "alias": "langTextDir"; "required": false; }; "interactive": { "alias": "interactive"; "required": false; }; "overlapping": { "alias": "overlapping"; "required": false; }; "show": { "alias": "show"; "required": false; }; "params": { "alias": "params"; "required": false; }; "renderer": { "alias": "renderer"; "required": false; }; }, { "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; }, never, never, false, never>;
 }

package/lib/components/ng-scroll-view/base/base-scroll-view.component.d.ts

@@ -1,7 +1,8 @@
-import { DestroyRef, ElementRef, Signal } from '@angular/core';
-import { Subject } from 'rxjs';
+import { ElementRef } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
 import { ScrollerDirections } from '../enums';
 import { ISize } from '../../../interfaces';
+import { DisposableComponent } from '../../../utils/disposable-component';
 import * as i0 from "@angular/core";
 /**
  * BaseScrollView
@@ -11,18 +12,42 @@ import * as i0 from "@angular/core";
  * @author Evgenii Alexandrovich Grebennikov
  * @email djonnyx@gmail.com
  */
-export declare class BaseScrollView {
-    readonly scrollContent: Signal<ElementRef<HTMLDivElement> | undefined>;
-    readonly scrollViewport: Signal<ElementRef<HTMLDivElement> | undefined>;
-    readonly direction: import("@angular/core").InputSignal<ScrollerDirections>;
-    readonly startOffset: import("@angular/core").InputSignal<number>;
-    readonly endOffset: import("@angular/core").InputSignal<number>;
-    readonly isVertical: Signal<boolean>;
-    readonly grabbing: import("@angular/core").WritableSignal<boolean>;
+export declare class BaseScrollView extends DisposableComponent {
+    scrollContent: ElementRef<HTMLDivElement> | undefined;
+    scrollViewport: ElementRef<HTMLDivElement> | undefined;
+    protected _$direction: BehaviorSubject<any>;
+    readonly $direction: import("rxjs").Observable<any>;
+    set direction(v: ScrollerDirections | any);
+    get direction(): ScrollerDirections | any;
+    protected _$startOffset: BehaviorSubject<number>;
+    readonly $startOffset: import("rxjs").Observable<number>;
+    set startOffset(v: number);
+    get startOffset(): number;
+    protected _$endOffset: BehaviorSubject<number>;
+    readonly $endOffset: import("rxjs").Observable<number>;
+    set endOffset(v: number);
+    get endOffset(): number;
+    protected _$alignmentStartOffset: BehaviorSubject<number>;
+    readonly $alignmentStartOffset: import("rxjs").Observable<number>;
+    set alignmentStartOffset(v: number);
+    get alignmentStartOffset(): number;
+    protected _$alignmentEndOffset: BehaviorSubject<number>;
+    readonly $alignmentEndOffset: import("rxjs").Observable<number>;
+    set alignmentEndOffset(v: number);
+    get alignmentEndOffset(): number;
+    protected _$isInfinity: BehaviorSubject<boolean>;
+    readonly $isInfinity: import("rxjs").Observable<boolean>;
+    set isInfinity(v: boolean);
+    get isInfinity(): boolean;
+    protected _$isVertical: BehaviorSubject<boolean>;
+    readonly $isVertical: import("rxjs").Observable<boolean>;
+    protected _$grabbing: BehaviorSubject<boolean>;
+    readonly $grabbing: import("rxjs").Observable<boolean>;
+    protected _inversion: boolean;
+    protected _overscrollEnabled: boolean;
     protected _$updateScrollBar: Subject<void>;
     protected $updateScrollBar: import("rxjs").Observable<void>;
     get scrollable(): boolean;
-    protected _destroyRef: DestroyRef;
     protected _isMoving: boolean;
     get isMoving(): boolean;
     protected _x: number;
@@ -34,6 +59,10 @@ export declare class BaseScrollView {
     protected _actualTotalSize: number;
     protected _totalSize: number;
     set totalSize(v: number);
+    get totalSize(): number;
+    protected _startLayoutOffset: number;
+    set startLayoutOffset(v: number);
+    get startLayoutOffset(): number;
     get actualScrollHeight(): number;
     get actualScrollWidth(): number;
     protected _actualX: number;
@@ -44,13 +73,17 @@ export declare class BaseScrollView {
     get scrollTop(): number;
     get scrollWidth(): number;
     get scrollHeight(): number;
-    readonly viewportBounds: import("@angular/core").WritableSignal<ISize>;
-    readonly contentBounds: import("@angular/core").WritableSignal<ISize>;
-    protected _inversion: boolean;
+    protected _$viewportBounds: BehaviorSubject<ISize>;
+    readonly $viewportBounds: import("rxjs").Observable<ISize>;
+    protected _$contentBounds: BehaviorSubject<ISize>;
+    readonly $contentBounds: import("rxjs").Observable<ISize>;
+    protected _isCoordinatesOverrided: boolean;
     constructor();
     tick(): void;
+    protected overrideCoordinates(x: number, y: number): void;
+    protected normalizeScrollSize(): boolean;
     protected onResizeViewport(): void;
-    protected onResizeContent(): void;
+    protected onResizeContent(value?: number | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseScrollView, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<BaseScrollView, "base-scroll-view", never, { "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "startOffset": { "alias": "startOffset"; "required": false; "isSignal": true; }; "endOffset": { "alias": "endOffset"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BaseScrollView, "base-scroll-view", never, { "direction": { "alias": "direction"; "required": false; }; "startOffset": { "alias": "startOffset"; "required": false; }; "endOffset": { "alias": "endOffset"; "required": false; }; "alignmentStartOffset": { "alias": "alignmentStartOffset"; "required": false; }; "alignmentEndOffset": { "alias": "alignmentEndOffset"; "required": false; }; "isInfinity": { "alias": "isInfinity"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/components/ng-scroll-view/const/index.d.ts

@@ -1,5 +1,7 @@
 import { InjectionToken } from "@angular/core";
 export declare const SCROLL_VIEW_INVERSION: InjectionToken<boolean>;
+export declare const SCROLL_VIEW_OVERSCROLL_ENABLED: InjectionToken<boolean>;
 export declare const SCROLL_VIEW_NORMALIZE_VALUE_FROM_ZERO: InjectionToken<boolean>;
-export declare const TOP = "top", LEFT = "left", INSTANT = "instant", AUTO = "auto", SMOOTH = "smooth", DURATION = 2000, FRICTION_FORCE = 0.035, MAX_DURATION = 4000, ANIMATION_DURATION = 50, MASS = 0.005, MAX_DIST = 12500, MAX_VELOCITY_TIMESTAMP = 100, SPEED_SCALE = 15, OVERSCROLL_START_ITERATION = 2;
+export declare const TOP = "top", LEFT = "left", INSTANT = "instant", AUTO = "auto", SMOOTH = "smooth", DURATION = 2000, FRICTION_FORCE = 0.035, MAX_DURATION = 4000, ANIMATION_DURATION = 50, MASS = 0.005, MAX_DIST = 12500, MAX_VELOCITY_TIMESTAMP = 100, SPEED_SCALE = 15, OVERSCROLL_START_ITERATION = 2, INTERSECTION_DISTANCE = 1;
+export declare const MAX_ITERATIONS_FOR_AVERAGE_CALCULATIONS = 5, INSTANT_VELOCITY_SCALE = 1000;
 export declare const SCROLL_EVENT: Event;

package/lib/components/ng-scroll-view/interfaces/scroll-to-params.d.ts

@@ -10,8 +10,11 @@ export interface IScrollToParams {
     y?: number;
     left?: number;
     top?: number;
+    snap?: boolean;
+    normalize?: boolean;
+    force?: boolean;
     blending?: boolean;
-    behavior?: ScrollBehavior;
+    behavior?: ScrollBehavior | "auto" | "instant" | "smooth";
     ease?: Easing;
     fireUpdate?: boolean;
     userAction?: boolean;

package/lib/components/ng-scroll-view/ng-scroll-view.component.d.ts

@@ -1,9 +1,12 @@
 import { CdkScrollable } from '@angular/cdk/scrolling';
-import { Subject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 import { Animator, Easing } from '../../utils/animator';
 import { IScrollToParams } from './interfaces';
 import { BaseScrollView } from './base/base-scroll-view.component';
-import { IScrollingSettings } from '../../interfaces';
+import { IAnimationParams, IScrollingSettings } from '../../interfaces';
+import { NgVirtualListService } from '../../ng-virtual-list.service';
+import { Id, SnappingDistance, SnapToItemAlign } from '../../types';
+import { ScrollingDirection } from '../../utils/scrolling-direction';
 import * as i0 from "@angular/core";
 /**
  * NgScrollView
@@ -15,42 +18,107 @@ import * as i0 from "@angular/core";
  */
 export declare class NgScrollView extends BaseScrollView {
     readonly cdkScrollable: CdkScrollable | undefined;
-    readonly scrollBehavior: import("@angular/core").InputSignal<ScrollBehavior>;
-    readonly scrollingSettings: import("@angular/core").InputSignal<IScrollingSettings>;
-    readonly overscrollEnabled: import("@angular/core").InputSignal<boolean>;
+    protected _service: NgVirtualListService;
+    protected _$scrollBehavior: BehaviorSubject<ScrollBehavior>;
+    readonly $scrollBehavior: import("rxjs").Observable<ScrollBehavior>;
+    set scrollBehavior(v: ScrollBehavior);
+    get scrollBehavior(): ScrollBehavior;
+    protected _$overscrollEnabled: BehaviorSubject<boolean>;
+    readonly $overscrollEnabled: import("rxjs").Observable<boolean>;
+    set overscrollEnabled(v: boolean);
+    get overscrollEnabled(): boolean;
+    protected _$scrollingSettings: BehaviorSubject<IScrollingSettings>;
+    readonly $scrollingSettings: import("rxjs").Observable<IScrollingSettings>;
+    set scrollingSettings(v: IScrollingSettings);
+    get scrollingSettings(): IScrollingSettings;
+    protected _$snapToItem: BehaviorSubject<boolean>;
+    readonly $snapToItem: import("rxjs").Observable<boolean>;
+    set snapToItem(v: boolean);
+    get snapToItem(): boolean;
+    protected _$scrollingOneByOne: BehaviorSubject<boolean>;
+    readonly $scrollingOneByOne: import("rxjs").Observable<boolean>;
+    set scrollingOneByOne(v: boolean);
+    get scrollingOneByOne(): boolean;
+    protected _$snapToItemAlign: BehaviorSubject<SnapToItemAlign>;
+    readonly $snapToItemAlign: import("rxjs").Observable<SnapToItemAlign>;
+    set snapToItemAlign(v: SnapToItemAlign);
+    get snapToItemAlign(): SnapToItemAlign;
+    protected _$snappingDistance: BehaviorSubject<SnappingDistance>;
+    readonly $snappingDistance: import("rxjs").Observable<SnappingDistance>;
+    set snappingDistance(v: SnappingDistance);
+    get snappingDistance(): SnappingDistance;
+    protected _$animationParams: BehaviorSubject<IAnimationParams>;
+    readonly $animationParams: import("rxjs").Observable<IAnimationParams>;
+    set animationParams(v: IAnimationParams);
+    get animationParams(): IAnimationParams;
     protected _normalizeValueFromZero: boolean;
+    protected _isScrollsTo: boolean;
+    protected _scrollDirection: ScrollingDirection;
+    get scrollDirection(): import("../../types").ScrollDirection;
+    get $scrollDirection(): import("rxjs").Observable<import("../../types").ScrollDirection>;
+    protected _$wheel: Subject<number>;
+    readonly $wheel: import("rxjs").Observable<number>;
     protected _$scroll: Subject<boolean>;
     readonly $scroll: import("rxjs").Observable<boolean>;
     protected _$scrollEnd: Subject<boolean>;
     readonly $scrollEnd: import("rxjs").Observable<boolean>;
+    protected _velocities: Array<number>;
+    protected _$velocity: BehaviorSubject<number>;
+    protected $velocity: import("rxjs").Observable<number>;
+    get velocity(): number;
+    protected _$averageVelocity: BehaviorSubject<number>;
+    protected $averageVelocity: import("rxjs").Observable<number>;
+    get averageVelocity(): number;
+    private _measureVelocityTimestamp;
+    private _measureVelocityLastPosition;
     private _startPosition;
     protected _animator: Animator;
     protected _interactive: boolean;
     private _overscrollIteration;
+    set x(v: number);
+    get x(): number;
+    protected setX(x: number, snap?: boolean, normalize?: boolean): void;
+    set y(v: number);
+    get y(): number;
+    protected setY(y: number, snap?: boolean, normalize?: boolean): void;
+    protected _delta: number;
     set delta(v: number);
+    set startLayoutOffset(v: number);
+    get startLayoutOffset(): number;
+    protected _intersectionComponentId: Id | null;
+    protected _isAlignmentAnimation: boolean;
     constructor();
+    ngAfterViewInit(): void;
+    protected updateDirection(position: number, prePosition: number): void;
+    protected overrideCoordinates(x: number, y: number): void;
+    protected measureVelocity(): void;
+    protected stopMoving(): void;
+    private snapIfNecessary;
+    protected snapWithInitialForceIfNecessary(v0?: number | null, animated?: boolean, force?: boolean): boolean;
     private calculatePosition;
     private cancelOverscroll;
     private checkOverscrollByAxis;
     private checkOverscroll;
     private calculateVelocity;
     private calculateAcceleration;
-    stopScrolling(): void;
+    stopScrolling(force?: boolean): void;
     protected move(isVertical: boolean, position: number, blending?: boolean, userAction?: boolean, fireUpdate?: boolean): void;
     protected moveWithAcceleration(isVertical: boolean, position: number, v0: number, v: number, a0: number, timestamp: number): void;
     protected normalizeValue(value: number): number;
-    protected animate(startValue: number, endValue: number, duration?: number, easingFunction?: Easing, userAction?: boolean): void;
+    protected animate(startValue: number, endValue: number, duration?: number, easingFunction?: Easing, userAction?: boolean, alignmentAtComplete?: boolean, skipOverridedCoordinates?: boolean): void;
+    protected getSnappedComponentSize(): number | null;
+    protected alignPosition(animated?: boolean, force?: boolean): boolean;
+    protected checkIntersectionComponent(): void;
     protected onAnimationComplete(position: number): void;
     fireScroll(userAction?: boolean): void;
-    scrollLimits(value?: number | undefined): boolean;
+    scrollLimits(value?: number | undefined, silent?: boolean): boolean;
     scroll(params: IScrollToParams): void;
     protected emitScrollableEvent(): void;
-    refreshX(value: number): void;
-    refreshY(value: number): void;
+    refreshCoordinate(x: number, y: number): void;
     protected fireScrollEvent(userAction: boolean): void;
     protected onDragStart(): void;
     reset(offset?: number): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgScrollView, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgScrollView, "ng-scroll-view", never, { "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; "scrollingSettings": { "alias": "scrollingSettings"; "required": false; "isSignal": true; }; "overscrollEnabled": { "alias": "overscrollEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgScrollView, "ng-scroll-view", never, { "scrollBehavior": { "alias": "scrollBehavior"; "required": false; }; "overscrollEnabled": { "alias": "overscrollEnabled"; "required": false; }; "scrollingSettings": { "alias": "scrollingSettings"; "required": false; }; "snapToItem": { "alias": "snapToItem"; "required": false; }; "scrollingOneByOne": { "alias": "scrollingOneByOne"; "required": false; }; "snapToItemAlign": { "alias": "snapToItemAlign"; "required": false; }; "snappingDistance": { "alias": "snappingDistance"; "required": false; }; "animationParams": { "alias": "animationParams"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/components/ng-scroll-view/utils/calculate-direction.d.ts

@@ -1 +1,7 @@
+/**
+ * calculateDirection
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/18.x/projects/ng-virtual-list/src/lib/components/ng-scroll-view/utils/calculate-direction.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
 export declare const calculateDirection: (buffer: Array<[number, number]>) => number;

package/lib/components/ng-scroll-view/utils/calculate-velocity.d.ts

@@ -0,0 +1,7 @@
+/**
+ * calculateVelocity
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/18.x/projects/ng-virtual-list/src/lib/components/ng-scroll-view/utils/calculate-velocity.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export declare const calculateVelocity: (startPosition: number, currentPosition: number, timestamp: number) => number;

package/lib/components/ng-scroll-view/utils/get-dir.d.ts

@@ -0,0 +1,7 @@
+/**
+ * getDir
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/18.x/projects/ng-virtual-list/src/lib/components/ng-scroll-view/utils/get-dir.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export declare const getDir: (p: number, c: number) => 1 | -1 | 0;

package/lib/components/ng-scroll-view/utils/index.d.ts

@@ -1,3 +1,5 @@
 import { calculateDirection } from "./calculate-direction";
 import { ScrollBox } from "./scroll-box";
-export { calculateDirection, ScrollBox, };
+import { matrix3d } from "./matrix-3d";
+import { getDir } from "./get-dir";
+export { calculateDirection, getDir, matrix3d, ScrollBox, };

package/lib/components/ng-scroll-view/utils/matrix-3d.d.ts

@@ -0,0 +1,7 @@
+/**
+ * matrix3d
+ * @link https://github.com/DjonnyX/ng-virtual-list/blob/18.x/projects/ng-virtual-list/src/lib/components/ng-scroll-view/utils/matrix-3d.ts
+ * @author Evgenii Alexandrovich Grebennikov
+ * @email djonnyx@gmail.com
+ */
+export declare const matrix3d: (x: number, y: number) => string;

package/lib/components/ng-scroller/enums/scroller-directions.d.ts

@@ -1,2 +1,3 @@
+import { Directions } from "../../../enums";
 import { ScrollerDirection } from "./scroller-direction";
-export type ScrollerDirections = ScrollerDirection | 'horizontal' | 'vertical';
+export type ScrollerDirections = ScrollerDirection | Directions | 'horizontal' | 'vertical';