aptechka 0.16.0 → 0.17.0

package/lib/scroll/ScrollBulletButtonsElement.d.ts

@@ -0,0 +1,11 @@
+import { ScrollUserElement } from './ScrollUserElement';
+export declare class ScrollBulletButtonsElement extends ScrollUserElement {
+    #private;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-bullet-buttons': ScrollBulletButtonsElement;
+    }
+}

package/lib/scroll/ScrollButtonElement.d.ts

@@ -0,0 +1,5 @@
+import { ScrollUserElement } from './ScrollUserElement';
+export declare abstract class ScrollButtonElement extends ScrollUserElement {
+    constructor();
+    protected abstract handleClick(): void;
+}

package/lib/scroll/ScrollElement.d.ts

@@ -0,0 +1,81 @@
+import { Damped } from '../animation';
+import { Store } from '../store';
+import { Axes2D, EasingFunction } from '../utils';
+import { CSSProperty } from '../css-property';
+import { ScrollSection } from './ScrollSection';
+export type ScrollBehaviour = 'smooth' | 'instant';
+export interface ScrollSetOptions {
+    behaviour?: ScrollBehaviour;
+    tween?: {
+        easing?: EasingFunction;
+        duration: number;
+    };
+}
+export declare class ScrollElement extends HTMLElement {
+    #private;
+    constructor();
+    get damped(): Damped;
+    get controlsCSSProperty(): CSSProperty<boolean>;
+    get axisCSSProperty(): CSSProperty<Axes2D>;
+    get directionCSSProperty(): CSSProperty<number>;
+    get pagesCSSProperty(): CSSProperty<number>;
+    get splitCSSProperty(): CSSProperty<boolean>;
+    get sectionalCSSProperty(): CSSProperty<boolean>;
+    get autoSizeCSSProperty(): CSSProperty<boolean>;
+    get wheelMaxDeltaCSSProperty(): CSSProperty<boolean>;
+    get sectionsInViewCSSProperty(): CSSProperty<number>;
+    get loopCSSProperty(): CSSProperty<boolean>;
+    get dampingCSSProperty(): CSSProperty<number>;
+    get massCSSProperty(): CSSProperty<number>;
+    get stiffnessCSSProperty(): CSSProperty<number>;
+    get mouseDragCSSProperty(): CSSProperty<boolean>;
+    get sectionDistanceScaleCSSProperty(): CSSProperty<number>;
+    get autoplayCSSProperty(): CSSProperty<number>;
+    get autoplayPauseDurationCSSProperty(): CSSProperty<number>;
+    get autoplayUserDirectionCSSProperty(): CSSProperty<boolean>;
+    get classesCSSProperty(): CSSProperty<number>;
+    get currentIndexStartOffsetCSSProperty(): CSSProperty<number>;
+    get currentIndexEndOffsetCSSProperty(): CSSProperty<number>;
+    get focusDelayCSSProperty(): CSSProperty<number>;
+    get focusDurationCSSProperty(): CSSProperty<number>;
+    get disabledCSSProperty(): CSSProperty<boolean>;
+    get hibernatedCSSProperty(): CSSProperty<boolean>;
+    get currentScrollValue(): number;
+    get targetScrollValue(): number;
+    get contentElement(): HTMLElement;
+    get sections(): ScrollSection[];
+    get position(): number;
+    get contentPosition(): number;
+    get viewportSize(): number;
+    get scrollSize(): number;
+    get gap(): number;
+    get counter(): Store<number>;
+    get limit(): number;
+    get distance(): number;
+    get loopDistance(): number;
+    get overscroll(): number;
+    get vertical(): boolean;
+    get currentProgress(): number;
+    get targetProgress(): number;
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    onScroll(...parameters: Parameters<Damped['subscribe']>): () => void;
+    offScroll(...parameters: Parameters<Damped['unsubscribe']>): void;
+    range(from: number, distance: number, margin?: number): number;
+    curve(from: number, distance: number, margin?: number): number;
+    visible(from: number, distance: number, margin?: number): boolean;
+    scrollToSection(sectionIndex: number, options?: ScrollSetOptions): void;
+    shiftSections(step: number, options?: ScrollSetOptions): void;
+    setPosition(value: number, options?: ScrollSetOptions): void;
+    shiftPosition(value: number, options?: ScrollSetOptions): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll': ScrollElement;
+    }
+    interface HTMLElementEventMap {
+        sectionsChange: CustomEvent;
+    }
+}

package/lib/scroll/ScrollSection.d.ts

@@ -0,0 +1,22 @@
+import { ScrollElement } from './ScrollElement';
+export type ScrollSectionMark = 'current' | 'previous' | 'next' | null;
+export type ScrollSectionMarkChangeEvent = CustomEvent<{
+    mark: ScrollSectionMark;
+}>;
+export declare class ScrollSection {
+    #private;
+    constructor(element: HTMLElement, index: number, scrollElement: ScrollElement);
+    get index(): number;
+    get size(): number;
+    get position(): number;
+    destroy(): void;
+    setSize(value?: number): void;
+    resize(): void;
+    transform(): void;
+    mark(mark: ScrollSectionMark): void;
+}
+declare global {
+    interface HTMLElementEventMap {
+        sectionMarkChange: ScrollSectionMarkChangeEvent;
+    }
+}

package/lib/scroll/ScrollSegmentElement.d.ts

@@ -0,0 +1,62 @@
+import { CSSProperty } from '../css-property';
+import { Store } from '../store';
+import { Damped } from '../animation';
+import { ScrollUserElement } from './ScrollUserElement';
+export interface ScrollSegmentResizeDetail {
+    start: number;
+    distance: number;
+    finish: number;
+}
+export declare class ScrollSegmentElement extends ScrollUserElement {
+    #private;
+    constructor();
+    get distanceOffsetCSSProperty(): CSSProperty<number>;
+    get startOffsetCSSProperty(): CSSProperty<number>;
+    get captureOnceCSSProperty(): CSSProperty<boolean>;
+    get capturedCSSProperty(): CSSProperty<string>;
+    get releasedCSSProperty(): CSSProperty<string>;
+    get capturedFromStartCSSProperty(): CSSProperty<string>;
+    get capturedFromFinishCSSProperty(): CSSProperty<string>;
+    get releasedFromStartCSSProperty(): CSSProperty<string>;
+    get releasedFromFinishCSSProperty(): CSSProperty<string>;
+    get passedVarCSSProperty(): CSSProperty<string>;
+    get progressVarCSSProperty(): CSSProperty<string>;
+    get distanceVarCSSProperty(): CSSProperty<string>;
+    get startVarCSSProperty(): CSSProperty<string>;
+    get finishVarCSSProperty(): CSSProperty<string>;
+    get disabledCSSProperty(): CSSProperty<boolean>;
+    get dampingCSSProperty(): CSSProperty<number>;
+    get massCSSProperty(): CSSProperty<number>;
+    get stiffnessCSSProperty(): CSSProperty<number>;
+    get targetCSSProperty(): CSSProperty<string>;
+    get isCaptured(): Store<boolean>;
+    get isReleased(): Store<boolean>;
+    get isCapturedFromStart(): Store<boolean>;
+    get isReleasedFromStart(): Store<boolean>;
+    get isCapturedFromFinish(): Store<boolean>;
+    get isReleasedFromFinish(): Store<boolean>;
+    get directionPosition(): number;
+    get directionSize(): number;
+    get passed(): Damped;
+    get progress(): number;
+    get start(): number;
+    get finish(): number;
+    get distance(): number;
+    get isCapturedOnce(): boolean;
+    get isDisabled(): boolean;
+    resize(): void;
+    tick(): void;
+    disable(): void;
+    enable(): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+    protected removeVar(name: string | undefined): void;
+    protected setVar(name: string | undefined, value: string | number): void;
+    protected getDistance(): number;
+    protected getStart(): number;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-segment': ScrollSegmentElement;
+    }
+}

package/lib/scroll/ScrollSetButtonElement.d.ts

@@ -0,0 +1,9 @@
+import { ScrollButtonElement } from './ScrollButtonElement';
+export declare class ScrollSetButtonElement extends ScrollButtonElement {
+    protected handleClick(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-set-button': ScrollSetButtonElement;
+    }
+}

package/lib/scroll/ScrollStepButtonElement.d.ts

@@ -0,0 +1,9 @@
+import { ScrollButtonElement } from './ScrollButtonElement';
+export declare class ScrollStepButtonElement extends ScrollButtonElement {
+    protected handleClick(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scroll-step-button': ScrollStepButtonElement;
+    }
+}

package/lib/scroll/ScrollUserElement.d.ts

@@ -0,0 +1,6 @@
+import { ScrollElement } from './ScrollElement';
+export declare class ScrollUserElement extends HTMLElement {
+    #private;
+    get scrollElement(): ScrollElement;
+    protected connectedCallback(): void;
+}

package/lib/scroll/ScrollbarElement.d.ts

@@ -0,0 +1,13 @@
+import { ScrollUserElement } from './ScrollUserElement';
+export declare class ScrollbarElement extends ScrollUserElement {
+    #private;
+    constructor();
+    get thumbElement(): HTMLElement;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-scrollbar': ScrollbarElement;
+    }
+}

package/lib/scroll/index.d.ts

@@ -0,0 +1,6 @@
+export { ScrollElement, type ScrollBehaviour } from './ScrollElement';
+export { ScrollbarElement } from './ScrollbarElement';
+export { ScrollSetButtonElement } from './ScrollSetButtonElement';
+export { ScrollStepButtonElement } from './ScrollStepButtonElement';
+export { ScrollBulletButtonsElement } from './ScrollBulletButtonsElement';
+export { ScrollSegmentElement } from './ScrollSegmentElement';

package/lib/scroll-entries/index.d.ts

@@ -0,0 +1,20 @@
+import { Notifier } from '../notifier';
+import { Axes2D } from '../utils';
+export interface ScrollEntry {
+    axis: Axes2D;
+    value: number;
+    element: HTMLElement;
+}
+export type ScrollEntriesRegisterCallback = () => void;
+declare class ScrollEntries {
+    #private;
+    get notifier(): Notifier<ScrollEntriesRegisterCallback>;
+    register(element: HTMLElement): void;
+    unregister(element: HTMLElement): void;
+    update(element: HTMLElement, axis: Axes2D, value: number): void;
+    hasEntry(element: HTMLElement): boolean;
+    getEntry(element: HTMLElement): ScrollEntry;
+    getAll(element: HTMLElement): ScrollEntry[];
+}
+export declare const scrollEntries: ScrollEntries;
+export {};

package/lib/sequence/index.d.ts

@@ -0,0 +1,20 @@
+import { CanvasElement } from '../canvas';
+import { SourceElement, SourceManagerSourceSet } from '../source';
+export interface SequenceElementParameters {
+    srcset: SourceManagerSourceSet;
+    pad?: number;
+}
+export declare class SequenceElement extends SourceElement<CanvasElement> {
+    #private;
+    constructor(parameters?: SequenceElementParameters);
+    setProgress(value: number): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+    protected createConsumer(): CanvasElement;
+    protected consumeSource(url: string | null): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-sequence': SequenceElement;
+    }
+}

package/lib/slicer/Letter.d.ts

@@ -0,0 +1,11 @@
+export interface LetterParameters {
+    index: number;
+    text: string;
+    clone?: boolean;
+}
+export declare class Letter {
+    #private;
+    constructor(parameters: LetterParameters);
+    get index(): number;
+    get element(): HTMLSpanElement;
+}

package/lib/slicer/SlicerElement.d.ts

@@ -0,0 +1,20 @@
+import { Word } from './Word.js';
+import { Letter } from './Letter.js';
+export interface SlicerParameters {
+    wordConstructor?: typeof Word;
+    letterConstructor?: typeof Letter;
+}
+export declare class SlicerElement extends HTMLElement {
+    #private;
+    constructor(parameters?: SlicerParameters);
+    get wordsArray(): Word[];
+    get lettersArray(): Letter[];
+    get originalText(): string;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'e-slicer': SlicerElement;
+    }
+}

package/lib/slicer/Word.d.ts

@@ -0,0 +1,16 @@
+import { Letter } from './Letter';
+export interface WordParameters {
+    index: number;
+    text: string;
+    letters?: boolean;
+    lettersAcc?: number;
+    letterConstructor?: typeof Letter;
+    clone?: boolean;
+}
+export declare class Word {
+    #private;
+    constructor(parameters: WordParameters);
+    get index(): number;
+    get element(): HTMLSpanElement;
+    get letters(): Letter[];
+}

package/lib/slicer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Word';
+export * from './Letter';
+export * from './SlicerElement';

package/lib/source/SourceClass.d.ts

@@ -0,0 +1,11 @@
+export declare class Source {
+    #private;
+    constructor(url: string);
+    get url(): string;
+    get name(): string;
+    get density(): number;
+    get query(): string;
+    get extension(): string;
+    get queryType(): "min" | "max" | "max-ratio" | "min-ratio";
+    get queryValue(): number;
+}

package/lib/source/SourceElement.d.ts

@@ -0,0 +1,24 @@
+import { SourceManager } from './SourceManager';
+import { ClassLinkedStatus } from '../class-linked-status';
+export declare abstract class SourceElement<T extends HTMLElement> extends HTMLElement {
+    #private;
+    constructor();
+    get consumerElement(): T;
+    get sourceManager(): SourceManager;
+    get status(): ClassLinkedStatus<{
+        loading: false;
+        loaded: false;
+        error: false;
+    }>;
+    get isLazy(): boolean;
+    protected abstract createConsumer(): T;
+    protected abstract consumeSource(url: string | null): void;
+    protected connectedCallback(): void;
+    protected disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementEventMap {
+        sourceCapture: CustomEvent;
+        sourceRelase: CustomEvent;
+    }
+}

package/lib/source/SourceManager.d.ts

@@ -0,0 +1,13 @@
+import { Store } from '../store';
+import { Source } from './SourceClass';
+export type SourceManagerSourceSet = string | Array<string>;
+export interface SourceManagerParameters {
+    srcset: SourceManagerSourceSet;
+}
+export declare class SourceManager extends Store<Source | undefined> {
+    #private;
+    constructor(parameters: SourceManagerParameters);
+    close(): void;
+    connect(): void;
+    disconnect(): void;
+}

package/lib/source/SourceSet.d.ts

@@ -0,0 +1,8 @@
+import { Source } from './SourceClass';
+export type SourceSetMediaSources = Array<Source>;
+export type SourceSetMediaBucket = Map<string, SourceSetMediaSources>;
+export declare class SourceSet {
+    #private;
+    constructor(sourceSet: string | Array<string>);
+    get mediaBuckets(): SourceSetMediaBucket;
+}

package/lib/source/index.d.ts

@@ -0,0 +1,4 @@
+export { Source } from './SourceClass';
+export { SourceSet, type SourceSetMediaSources, type SourceSetMediaBucket, } from './SourceSet';
+export { SourceManager, type SourceManagerSourceSet, type SourceManagerParameters, } from './SourceManager';
+export { SourceElement } from './SourceElement';

package/lib/store/Composed.d.ts

@@ -0,0 +1,7 @@
+import { Store, StoreOptions } from './Store';
+export type ComposedCallback<ComposedType> = () => ComposedType;
+export declare class Composed<ComposedType> extends Store<ComposedType> {
+    #private;
+    constructor(stores: Array<Store<any>>, callback: ComposedCallback<ComposedType>, parameters?: StoreOptions<ComposedType>);
+    close(): void;
+}

package/lib/store/Derived.d.ts

@@ -0,0 +1,7 @@
+import { Store, StoreOptions } from './Store';
+export type DerivedCallback<SourceType, Type, Return = Type> = (value: SourceType) => Return;
+export declare class Derived<Type, SourceType> extends Store<Type> {
+    #private;
+    constructor(store: Store<SourceType>, callback: DerivedCallback<SourceType, Type>, parameters?: StoreOptions<Type>);
+    close(): void;
+}

package/lib/store/DerivedArray.d.ts

@@ -0,0 +1,7 @@
+import { Store, StoreOptions } from './Store';
+export type DerivedArrayCallback<Type, SourceType extends Array<any>, Return = Type> = (value: SourceType[number], index: number, arr: SourceType) => Return;
+export declare class DerivedArray<Type, SourceType extends Array<any>> extends Store<Array<Type>> {
+    #private;
+    constructor(store: Store<SourceType>, callback: DerivedArrayCallback<Type, SourceType>, parameters?: StoreOptions<Array<Type>>);
+    close(): void;
+}

package/lib/store/Resource.d.ts

@@ -0,0 +1,11 @@
+import { Store, StoreOptions } from './Store';
+export type ResourceFetcher<StoreType = unknown> = () => Promise<StoreType>;
+export interface ResourceOptions<StoreType> extends StoreOptions<StoreType> {
+    manualControl?: boolean;
+}
+export declare class Resource<StoreType> extends Store<StoreType> {
+    #private;
+    constructor(defaultValue: StoreType, fetcher: ResourceFetcher<StoreType>, options?: ResourceOptions<StoreType>);
+    get isPending(): Store<boolean>;
+    refetch(): void;
+}

package/lib/store/Store.d.ts

@@ -0,0 +1,35 @@
+export interface StoreState<StoreType> {
+    current: StoreType;
+    previous: StoreType | undefined;
+    initial: StoreType;
+}
+export type StoreCallback<StoreType> = (state: StoreState<StoreType>) => void;
+export type StoreEqualityCheckCallback<StoreType> = (currentValue: StoreType, newValue: StoreType) => boolean;
+export type StoreMiddleware<T> = (value: T) => T;
+export interface StoreOptions<StoreType> {
+    name?: string;
+    __manager?: any;
+    equalityCheck?: StoreEqualityCheckCallback<StoreType>;
+    validate?: StoreMiddleware<StoreType>;
+    skipSubscribeNotification?: boolean;
+    notifyAndClose?: boolean;
+    invisible?: boolean;
+}
+export declare class Store<StoreType = unknown> {
+    #private;
+    __manager?: any;
+    constructor(value: StoreType, options?: StoreOptions<StoreType>);
+    get name(): string | undefined;
+    get initial(): StoreType;
+    get previous(): StoreType | undefined;
+    get current(): StoreType;
+    set current(value: StoreType);
+    get subscribers(): Set<StoreCallback<StoreType>>;
+    addMiddleware(middleware: StoreMiddleware<StoreType>): void;
+    removeMiddleware(middleware: StoreMiddleware<StoreType>): void;
+    subscribe(callback: StoreCallback<StoreType>): () => void;
+    unsubscribe(callback: StoreCallback<StoreType>): void;
+    reset(): void;
+    close(): void;
+}
+export declare const activeStores: Store<Store<any>[]>;

package/lib/store/StoreRegistry.d.ts

@@ -0,0 +1,22 @@
+import { Store } from './Store';
+export interface StoreRegistryStateStore {
+    name: string;
+    value: any;
+}
+export type StoreRegistryState = {
+    stores: Array<StoreRegistryStateStore>;
+};
+declare class StoreRegistry {
+    #private;
+    storage: Storage;
+    name: string;
+    constructor();
+    get loadedState(): StoreRegistryState | null;
+    saveState(): void;
+    loadState(state?: string | StoreRegistryState | null): void;
+    resetState(): void;
+    updateStore(store: Store<any>): Store<any>;
+    getState(): StoreRegistryState;
+}
+export declare const storeRegistry: StoreRegistry;
+export {};

package/lib/store/index.d.ts

@@ -0,0 +1,6 @@
+export { Store, activeStores, type StoreCallback, type StoreMiddleware, type StoreOptions, type StoreEqualityCheckCallback, } from './Store';
+export { Derived, type DerivedCallback } from './Derived';
+export { DerivedArray, type DerivedArrayCallback } from './DerivedArray';
+export { Resource, type ResourceFetcher } from './Resource';
+export { Composed, type ComposedCallback } from './Composed';
+export { storeRegistry, type StoreRegistryState, type StoreRegistryStateStore, } from './StoreRegistry';

package/lib/test/starting-style/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/ticker/index.d.ts

@@ -0,0 +1,21 @@
+import { ElementOrSelector } from '../utils';
+export interface TickerCallbackEntry {
+    timestamp: number;
+    subscribeTimestamp: number;
+    timeBetweenFrames: number;
+    timeElapsedSinceSubscription: number;
+}
+export type TickerCallback = (entry: TickerCallbackEntry) => void;
+export interface TickerAddOptions {
+    maxFPS?: number;
+    order?: number;
+    culling?: ElementOrSelector | false | undefined | null;
+}
+export declare class Ticker {
+    #private;
+    constructor();
+    subscribe(callback: TickerCallback, options?: TickerAddOptions): () => void;
+    unsubscribe(callback: TickerCallback): void;
+    destroy(): void;
+}
+export declare const ticker: Ticker;

package/lib/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare function insert(arr: Array<any>, index: number, ...newItems: any[]): any[];
+export declare function shiftArray<T>(arr: T[], positions: number): T[];

package/lib/utils/attributes.d.ts

@@ -0,0 +1,2 @@
+export declare function parseAttribute(element: HTMLElement, attributeName: string): string | number | boolean | null;
+export declare function parseAttributeValue(value: string | null | undefined): string | number | boolean | null;

package/lib/utils/browser.d.ts

@@ -0,0 +1 @@
+export declare const isBrowser: boolean;

package/lib/utils/bytes.d.ts

@@ -0,0 +1 @@
+export declare function formatBytes(bytes: number, decimals?: number): string;

package/lib/utils/canvas.d.ts

@@ -0,0 +1,7 @@
+export declare function measureText(context: CanvasRenderingContext2D, text: string): {
+    height: number;
+    width: number;
+};
+export declare function fixPosition(position: number): number;
+export declare function cover(contentWidth: number, contentHeight: number, containerWidth: number, containerHeight: number, offsetLeft?: number, offsetTop?: number): readonly [number, number, number, number];
+export declare function contain(contentWidth: number, contentHeight: number, containerWidth: number, containerHeight: number, offsetLeft?: number, offsetTop?: number): readonly [number, number, number, number];

package/lib/utils/collisions.d.ts

@@ -0,0 +1,3 @@
+import { Circle, Dot2D, Rect2D } from './ts-shape.js';
+export declare function dotRectCollision(dot: Dot2D, rect: Rect2D): boolean;
+export declare function dotCircleCollision(dot: Dot2D, circle: Circle): boolean;

package/lib/utils/coordinates.d.ts

@@ -0,0 +1,13 @@
+import { Dimension2D, Dot2D, Rect2D } from './ts-shape.js';
+export declare function screenToCartesian(screenCoordinate: Dot2D, container: Pick<Rect2D, 'width' | 'height'>, normalize?: boolean): {
+    x: number;
+    y: number;
+};
+export declare function normalize(coordinate: Dot2D, size: Dimension2D): {
+    x: number;
+    y: number;
+};
+export declare function getPointerPosition(event: MouseEvent | PointerEvent | Dot2D, rect?: Rect2D): {
+    x: number;
+    y: number;
+};

package/lib/utils/cssom.d.ts

@@ -0,0 +1,5 @@
+export declare function getRootVariables<T extends string, V extends {
+    [key in T]: string;
+} = {
+    [key in T]: string;
+}>(...names: T[]): V;

package/lib/utils/decoding.d.ts

@@ -0,0 +1,2 @@
+export declare function encode(string: string): string;
+export declare function decode(string: string): string;

package/lib/utils/dom.d.ts

@@ -0,0 +1,5 @@
+export declare function findParentElement<T extends CustomElementConstructor>(element: Element | null, Constructor: T): InstanceType<T> | null;
+export type ElementOrSelector<T extends Element = Element> = string | T;
+export declare function getElement<T extends Element>(elementOrSelector: ElementOrSelector<T> | undefined, from?: Document): T | null | undefined;
+export declare function findScrollParentElement(node: Node | null, _initial?: Node | null): HTMLElement;
+export declare function getAllParentElements(node: Node): HTMLElement[];

package/lib/utils/easings.d.ts

@@ -0,0 +1,17 @@
+export type EasingFunction = (t: number) => number;
+export declare const linear: EasingFunction;
+export declare const easeInQuad: EasingFunction;
+export declare const easeOutQuad: EasingFunction;
+export declare const easeInOutQuad: EasingFunction;
+export declare const easeInCubic: EasingFunction;
+export declare const easeOutCubic: EasingFunction;
+export declare const easeInOutCubic: EasingFunction;
+export declare const easeInQuart: EasingFunction;
+export declare const easeOutQuart: EasingFunction;
+export declare const easeInOutQuart: EasingFunction;
+export declare const easeInQuint: EasingFunction;
+export declare const easeOutQuint: EasingFunction;
+export declare const easeInOutQuint: EasingFunction;
+export declare const easeInExpo: EasingFunction;
+export declare const easeOutExpo: EasingFunction;
+export declare const easeInOutExpo: EasingFunction;

package/lib/utils/events.d.ts

@@ -0,0 +1,8 @@
+export declare function dispatchSizeChangeEvent(node: Node): void;
+export declare function dispatchBeforeSizeChangeEvent(node: Node): void;
+declare global {
+    interface HTMLElementEventMap {
+        sizeChange: CustomEvent;
+        beforeSizeChange: CustomEvent;
+    }
+}

package/lib/utils/file.d.ts

@@ -0,0 +1 @@
+export declare function createJSONAndSave(filename: string, dataObjToWrite: object): void;

package/lib/utils/function.d.ts

@@ -0,0 +1,2 @@
+export declare const debounce: <F extends (...args: Parameters<F>) => ReturnType<F>>(callback: F, delay?: number) => ((...args: Parameters<F>) => void);
+export declare const throttle: <F extends (...args: Parameters<F>) => ReturnType<F>>(callback: F, delay?: number) => ((...args: Parameters<F>) => void);

package/lib/utils/gestures.d.ts

@@ -0,0 +1 @@
+export declare function setupDrag(onMove: (moveEvent: PointerEvent) => void, onDrop?: () => void): void;