@egjs/flicking/declaration/Flicking.d.ts

Everyday 30 million people experience. It's reliable, flexible and extendable carousel.

import Component from "@egjs/component";
import Viewport from "./core/Viewport";
import { Panel } from "./core/panel";
import VirtualManager, { VirtualOptions } from "./core/VirtualManager";
import { Control } from "./control";
import { Camera } from "./camera";
import { Renderer, ExternalRenderer, RendererOptions } from "./renderer";
import { EVENTS, ALIGN, MOVE_TYPE, DIRECTION, CIRCULAR_FALLBACK } from "./const/external";
import { HoldStartEvent, HoldEndEvent, MoveStartEvent, SelectEvent, MoveEvent, MoveEndEvent, WillChangeEvent, WillRestoreEvent, NeedPanelEvent, VisibleChangeEvent, ReachEdgeEvent, ReadyEvent, AfterResizeEvent, BeforeResizeEvent, ChangedEvent, RestoredEvent, PanelChangeEvent } from "./type/event";
import { LiteralUnion, ValueOf } from "./type/internal";
import { ElementLike, Plugin, Status, MoveTypeOptions } from "./type/external";
export interface FlickingEvents {
    [EVENTS.READY]: ReadyEvent;
    [EVENTS.BEFORE_RESIZE]: BeforeResizeEvent;
    [EVENTS.AFTER_RESIZE]: AfterResizeEvent;
    [EVENTS.HOLD_START]: HoldStartEvent;
    [EVENTS.HOLD_END]: HoldEndEvent;
    [EVENTS.MOVE_START]: MoveStartEvent;
    [EVENTS.MOVE]: MoveEvent;
    [EVENTS.MOVE_END]: MoveEndEvent;
    [EVENTS.WILL_CHANGE]: WillChangeEvent;
    [EVENTS.CHANGED]: ChangedEvent;
    [EVENTS.WILL_RESTORE]: WillRestoreEvent;
    [EVENTS.RESTORED]: RestoredEvent;
    [EVENTS.SELECT]: SelectEvent;
    [EVENTS.NEED_PANEL]: NeedPanelEvent;
    [EVENTS.VISIBLE_CHANGE]: VisibleChangeEvent;
    [EVENTS.REACH_EDGE]: ReachEdgeEvent;
    [EVENTS.PANEL_CHANGE]: PanelChangeEvent;
}
export interface FlickingOptions {
    align: LiteralUnion<ValueOf<typeof ALIGN>> | number | {
        panel: number | string;
        camera: number | string;
    };
    defaultIndex: number;
    horizontal: boolean;
    circular: boolean;
    circularFallback: LiteralUnion<ValueOf<typeof CIRCULAR_FALLBACK>>;
    bound: boolean;
    adaptive: boolean;
    panelsPerView: number;
    noPanelStyleOverride: boolean;
    resizeOnContentsReady: boolean;
    nested: boolean;
    needPanelThreshold: number;
    preventEventsBeforeInit: boolean;
    deceleration: number;
    duration: number;
    easing: (x: number) => number;
    inputType: string[];
    moveType: ValueOf<typeof MOVE_TYPE> | MoveTypeOptions<ValueOf<typeof MOVE_TYPE>>;
    threshold: number;
    interruptable: boolean;
    bounce: number | string | [number | string, number | string];
    iOSEdgeSwipeThreshold: number;
    preventClickOnDrag: boolean;
    preventDefaultOnDrag: boolean;
    disableOnInit: boolean;
    changeOnHold: boolean;
    renderOnlyVisible: boolean;
    virtual: VirtualOptions | null;
    autoInit: boolean;
    autoResize: boolean;
    useResizeObserver: boolean;
    resizeDebounce: number;
    maxResizeDebounce: number;
    useFractionalSize: boolean;
    externalRenderer: ExternalRenderer | null;
    renderExternal: {
        renderer: new (options: RendererOptions) => ExternalRenderer;
        rendererOptions: RendererOptions;
    } | null;
}
declare class Flicking extends Component<FlickingEvents> {
    static VERSION: string;
    private _viewport;
    private _autoResizer;
    private _camera;
    private _control;
    private _renderer;
    private _virtualManager;
    private _align;
    private _defaultIndex;
    private _horizontal;
    private _circular;
    private _circularFallback;
    private _bound;
    private _adaptive;
    private _panelsPerView;
    private _noPanelStyleOverride;
    private _resizeOnContentsReady;
    private _virtual;
    private _nested;
    private _needPanelThreshold;
    private _preventEventsBeforeInit;
    private _deceleration;
    private _duration;
    private _easing;
    private _inputType;
    private _moveType;
    private _threshold;
    private _interruptable;
    private _bounce;
    private _iOSEdgeSwipeThreshold;
    private _preventClickOnDrag;
    private _preventDefaultOnDrag;
    private _disableOnInit;
    private _changeOnHold;
    private _renderOnlyVisible;
    private _autoInit;
    private _autoResize;
    private _useResizeObserver;
    private _resizeDebounce;
    private _maxResizeDebounce;
    private _useFractionalSize;
    private _externalRenderer;
    private _renderExternal;
    private _initialized;
    private _plugins;
    get control(): Control;
    get camera(): Camera;
    get renderer(): Renderer;
    get viewport(): Viewport;
    get initialized(): boolean;
    get circularEnabled(): boolean;
    get virtualEnabled(): boolean;
    get index(): number;
    get element(): HTMLElement;
    get currentPanel(): Panel;
    get panels(): Panel[];
    get panelCount(): number;
    get visiblePanels(): Panel[];
    get animating(): boolean;
    get holding(): boolean;
    get activePlugins(): Plugin[];
    get align(): FlickingOptions["align"];
    get defaultIndex(): FlickingOptions["defaultIndex"];
    get horizontal(): FlickingOptions["horizontal"];
    get circular(): FlickingOptions["circular"];
    get circularFallback(): LiteralUnion<ValueOf<{
        readonly LINEAR: "linear";
        readonly BOUND: "bound";
    }>, string>;
    get bound(): FlickingOptions["bound"];
    get adaptive(): FlickingOptions["adaptive"];
    get panelsPerView(): FlickingOptions["panelsPerView"];
    get noPanelStyleOverride(): FlickingOptions["noPanelStyleOverride"];
    get resizeOnContentsReady(): FlickingOptions["resizeOnContentsReady"];
    get nested(): FlickingOptions["nested"];
    get needPanelThreshold(): FlickingOptions["needPanelThreshold"];
    get preventEventsBeforeInit(): FlickingOptions["preventEventsBeforeInit"];
    get deceleration(): FlickingOptions["deceleration"];
    get easing(): FlickingOptions["easing"];
    get duration(): FlickingOptions["duration"];
    get inputType(): FlickingOptions["inputType"];
    get moveType(): FlickingOptions["moveType"];
    get threshold(): FlickingOptions["threshold"];
    get interruptable(): FlickingOptions["interruptable"];
    get bounce(): FlickingOptions["bounce"];
    get iOSEdgeSwipeThreshold(): FlickingOptions["iOSEdgeSwipeThreshold"];
    get preventClickOnDrag(): FlickingOptions["preventClickOnDrag"];
    get preventDefaultOnDrag(): FlickingOptions["preventDefaultOnDrag"];
    get disableOnInit(): FlickingOptions["disableOnInit"];
    get changeOnHold(): FlickingOptions["changeOnHold"];
    get renderOnlyVisible(): FlickingOptions["renderOnlyVisible"];
    get virtual(): VirtualManager;
    get autoInit(): boolean;
    get autoResize(): FlickingOptions["autoResize"];
    get useResizeObserver(): FlickingOptions["useResizeObserver"];
    get resizeDebounce(): number;
    get maxResizeDebounce(): number;
    get useFractionalSize(): boolean;
    get externalRenderer(): ExternalRenderer;
    get renderExternal(): {
        renderer: new (options: RendererOptions) => ExternalRenderer;
        rendererOptions: RendererOptions;
    };
    set align(val: FlickingOptions["align"]);
    set defaultIndex(val: FlickingOptions["defaultIndex"]);
    set horizontal(val: FlickingOptions["horizontal"]);
    set circular(val: FlickingOptions["circular"]);
    set bound(val: FlickingOptions["bound"]);
    set adaptive(val: FlickingOptions["adaptive"]);
    set panelsPerView(val: FlickingOptions["panelsPerView"]);
    set noPanelStyleOverride(val: FlickingOptions["noPanelStyleOverride"]);
    set resizeOnContentsReady(val: FlickingOptions["resizeOnContentsReady"]);
    set nested(val: FlickingOptions["nested"]);
    set needPanelThreshold(val: FlickingOptions["needPanelThreshold"]);
    set preventEventsBeforeInit(val: FlickingOptions["preventEventsBeforeInit"]);
    set deceleration(val: FlickingOptions["deceleration"]);
    set easing(val: FlickingOptions["easing"]);
    set duration(val: FlickingOptions["duration"]);
    set inputType(val: FlickingOptions["inputType"]);
    set moveType(val: FlickingOptions["moveType"]);
    set threshold(val: FlickingOptions["threshold"]);
    set interruptable(val: FlickingOptions["interruptable"]);
    set bounce(val: FlickingOptions["bounce"]);
    set iOSEdgeSwipeThreshold(val: FlickingOptions["iOSEdgeSwipeThreshold"]);
    set preventClickOnDrag(val: FlickingOptions["preventClickOnDrag"]);
    set preventDefaultOnDrag(val: FlickingOptions["preventDefaultOnDrag"]);
    set disableOnInit(val: FlickingOptions["disableOnInit"]);
    set changeOnHold(val: FlickingOptions["changeOnHold"]);
    set renderOnlyVisible(val: FlickingOptions["renderOnlyVisible"]);
    set autoResize(val: FlickingOptions["autoResize"]);
    set useResizeObserver(val: FlickingOptions["useResizeObserver"]);
    constructor(root: HTMLElement | string, { align, defaultIndex, horizontal, circular, circularFallback, bound, adaptive, panelsPerView, noPanelStyleOverride, resizeOnContentsReady, nested, needPanelThreshold, preventEventsBeforeInit, deceleration, duration, easing, inputType, moveType, threshold, interruptable, bounce, iOSEdgeSwipeThreshold, preventClickOnDrag, preventDefaultOnDrag, disableOnInit, changeOnHold, renderOnlyVisible, virtual, autoInit, autoResize, useResizeObserver, resizeDebounce, maxResizeDebounce, useFractionalSize, externalRenderer, renderExternal }?: Partial<FlickingOptions>);
    init(): Promise<void>;
    destroy(): void;
    prev(duration?: number): Promise<void>;
    next(duration?: number): Promise<void>;
    moveTo(index: number, duration?: number, direction?: ValueOf<typeof DIRECTION>): Promise<void>;
    updateAnimation(index: number, duration?: number, direction?: ValueOf<typeof DIRECTION>): void;
    stopAnimation(): void;
    getPanel(index: number): Panel | null;
    enableInput(): this;
    disableInput(): this;
    getStatus({ index, position, includePanelHTML, visiblePanelsOnly }?: Partial<{
        index: boolean;
        position: boolean;
        includePanelHTML: boolean;
        visiblePanelsOnly: boolean;
    }>): Status;
    setStatus(status: Status): void;
    addPlugins(...plugins: Plugin[]): this;
    removePlugins(...plugins: Plugin[]): this;
    resize(): Promise<void>;
    append(element: ElementLike | ElementLike[]): Panel[];
    prepend(element: ElementLike | ElementLike[]): Panel[];
    insert(index: number, element: ElementLike | ElementLike[]): Panel[];
    remove(index: number, deleteCount?: number): Panel[];
    private _createControl;
    private _createCamera;
    private _createRenderer;
    private _createExternalRenderer;
    private _createVanillaRenderer;
    private _moveToInitialPanel;
    private _initialResize;
}
export default Flicking;