myrta-ui 17.0.19 → 17.0.20

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/plugins/Autoplay/Autoplay.d.ts

@@ -0,0 +1,62 @@
+import { Plugin } from "../../../shared/Base/Plugin";
+import { Carousel } from "../../Carousel";
+type AutoplayEventsType = "start" | "set" | "pause" | "resume" | "stop";
+type AutoplayEvents = Record<AutoplayEventsType, (...args: any[]) => void>;
+export type AutoplayOptionsType = {
+    /**
+     * If autoplay should start automatically after initialization
+     */
+    autoStart: boolean;
+    /**
+     * Optional event listeners
+     */
+    on?: Partial<AutoplayEvents>;
+    /**
+     * If autoplay should pause when the user hovers over the container
+     */
+    pauseOnHover: boolean;
+    /**
+     * Change where progress bar is appended
+     */
+    progressParentEl: HTMLElement | null | ((any: any) => HTMLElement | null);
+    /**
+     * If element should be created to display the autoplay progress
+     */
+    showProgress: boolean;
+    /**
+     * Delay (in milliseconds) before the slide change
+     */
+    timeout: number;
+};
+declare module "../../../Carousel/options" {
+    interface PluginsOptionsType {
+        Autoplay: Boolean | Partial<AutoplayOptionsType>;
+    }
+}
+export declare class Autoplay extends Plugin<Carousel, AutoplayOptionsType, AutoplayEventsType> {
+    static defaults: AutoplayOptionsType;
+    private state;
+    private inHover;
+    private timer;
+    private progressBar;
+    get isActive(): boolean;
+    private onReady;
+    private onChange;
+    private onSettle;
+    private onVisibilityChange;
+    private onMouseEnter;
+    private onMouseLeave;
+    private onTimerEnd;
+    private removeProgressBar;
+    private createProgressBar;
+    private set;
+    private clear;
+    start(): void;
+    stop(): void;
+    pause(): void;
+    resume(): void;
+    toggle(): void;
+    attach(): void;
+    detach(): void;
+}
+export {};

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/plugins/Dots/Dots.d.ts

@@ -0,0 +1,44 @@
+import { Plugin } from "../../../shared/Base/Plugin";
+import { Carousel } from "../../Carousel";
+export type DotsOptionsType = {
+    classes: {
+        list: string;
+        dot: string;
+        isDynamic: string;
+        hasDots: string;
+        isBeforePrev: string;
+        isPrev: string;
+        isCurrent: string;
+        isNext: string;
+        isAfterNext: string;
+    };
+    dotTpl: string;
+    dynamicFrom: number | false;
+    maxCount: number;
+    minCount: number;
+};
+declare module "../../../Carousel/options" {
+    interface PluginsOptionsType {
+        Dots?: Boolean | Partial<DotsOptionsType>;
+    }
+}
+type DotsEventsType = "";
+export declare class Dots extends Plugin<Carousel, DotsOptionsType, DotsEventsType> {
+    static defaults: DotsOptionsType;
+    /**
+     * If this instance is currently in "dynamic" mode
+     */
+    isDynamic: boolean;
+    private list;
+    private onRefresh;
+    private build;
+    /**
+     * Refresh the elements to match the current state of the carousel
+     */
+    refresh(): void;
+    private createItem;
+    private cleanup;
+    attach(): void;
+    detach(): void;
+}
+export {};

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/plugins/Navigation/Navigation.d.ts

@@ -0,0 +1,41 @@
+import { Plugin } from "../../../shared/Base/Plugin";
+import { Carousel } from "../../Carousel";
+export type NavigationOptionsType = {
+    /**
+     * Class names for DOM elements
+     */
+    classes: {
+        container: string;
+        button: string;
+        isNext: string;
+        isPrev: string;
+    };
+    /**
+     * HTML template for left arrow
+     */
+    nextTpl: string;
+    /**
+     * HTML template for right arrow
+     */
+    prevTpl: string;
+};
+declare module "../../../Carousel/options" {
+    interface PluginsOptionsType {
+        Navigation: Boolean | Partial<NavigationOptionsType>;
+    }
+}
+type NavigationEventsType = "";
+export declare class Navigation extends Plugin<Carousel, NavigationOptionsType, NavigationEventsType> {
+    static defaults: NavigationOptionsType;
+    container: HTMLElement | null;
+    prev: HTMLElement | null;
+    next: HTMLElement | null;
+    private isDom;
+    private onRefresh;
+    private addBtn;
+    private build;
+    cleanup(): void;
+    attach(): void;
+    detach(): void;
+}
+export {};

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/plugins/Sync/Sync.d.ts

@@ -0,0 +1,44 @@
+import { Plugin } from "../../../shared/Base/Plugin";
+import { Carousel } from "../../Carousel";
+export type SyncOptionsType = {
+    /**
+     * Target carousel sliding animation friction (after clicking navigation carousel slide)
+     */
+    friction: number;
+    /**
+     * An instance of a carousel acting as navigation
+     */
+    nav?: Carousel;
+    /**
+     * An instance of a carousel acting as target
+     */
+    target?: Carousel;
+};
+declare module "../../../Carousel/options" {
+    interface PluginsOptionsType {
+        /**
+         * Sync instance to another and make it act as navigation
+         */
+        Sync?: Boolean | Partial<SyncOptionsType>;
+    }
+}
+type SyncEventsType = "";
+export declare class Sync extends Plugin<Carousel, SyncOptionsType, SyncEventsType> {
+    static defaults: SyncOptionsType;
+    private selectedIndex;
+    private target;
+    private nav;
+    private addAsTargetFor;
+    private addAsNavFor;
+    private attachEvents;
+    private onNavReady;
+    private onTargetReady;
+    private onNavClick;
+    private onNavTouch;
+    private onNavCreateSlide;
+    private onTargetChange;
+    private markSelectedSlide;
+    attach(): void;
+    detach(): void;
+}
+export {};

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/plugins/Thumbs/Thumbs.d.ts

@@ -0,0 +1,99 @@
+import { Plugin } from "../../../shared/Base/Plugin";
+import { OptionsType as PanzoomOptionsType } from "../../../Panzoom/options";
+import type { Carousel } from "../../Carousel";
+import { OptionsType as CarouselOptionsType } from "../../options";
+export type ThumbsOptionsType = {
+    /**
+     * Customize carousel options
+     */
+    Carousel?: Partial<CarouselOptionsType>;
+    /**
+     * Customize panzoom options
+     */
+    Panzoom?: Partial<PanzoomOptionsType>;
+    /**
+     * Class names for DOM elements
+     */
+    classes: {
+        container?: string;
+        viewport?: string;
+        track?: string;
+        slide?: string;
+        isResting?: string;
+        isSelected?: string;
+        isLoading?: string;
+        hasThumbs?: string;
+    };
+    /**
+     * Minimum number of slides with thumbnails in the carousel to create Thumbs
+     */
+    minCount: number;
+    /**
+     * Optional event listeners
+     */
+    on?: Record<"ready", (...any: any) => void>;
+    /**
+     * Change where thumbnail container is appended
+     */
+    parentEl?: HTMLElement | null | (() => HTMLElement | null);
+    /**
+     * Template for the thumbnail element
+     */
+    thumbTpl: string;
+    /**
+     * Choose a type - "classic" (syncs two instances of the carousel) or "modern" (Apple Photos style)
+     */
+    type: "classic" | "modern";
+};
+export declare const defaultOptions: ThumbsOptionsType;
+declare module "../../../Carousel/options" {
+    interface PluginsOptionsType {
+        Thumbs: Boolean | Partial<ThumbsOptionsType>;
+    }
+}
+declare module "../../../Carousel/types" {
+    interface slideType {
+        thumbSrc?: string;
+        thumbClipWidth?: number;
+        thumbWidth?: number;
+        thumbHeight?: number;
+        thumbSlideEl?: HTMLElement;
+    }
+}
+export declare enum States {
+    Init = 0,
+    Ready = 1,
+    Hidden = 2
+}
+export declare class Thumbs extends Plugin<Carousel, ThumbsOptionsType, "ready" | "createSlide"> {
+    static defaults: ThumbsOptionsType;
+    type: "modern" | "classic";
+    get isModern(): boolean;
+    container: HTMLElement | null;
+    track: HTMLElement | null;
+    private carousel;
+    private thumbWidth;
+    private thumbClipWidth;
+    private thumbHeight;
+    private thumbGap;
+    private thumbExtraGap;
+    state: States;
+    private onInitSlide;
+    private onInitSlides;
+    private onChange;
+    private onRefresh;
+    isDisabled(): Boolean;
+    private getThumb;
+    private addSlide;
+    private getSlides;
+    private resizeModernSlide;
+    private updateProps;
+    build(): void;
+    private onClick;
+    private getShift;
+    private setProps;
+    private shiftModern;
+    private cleanup;
+    attach(): void;
+    detach(): void;
+}

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/plugins/index.d.ts

@@ -0,0 +1,5 @@
+import { PluginsType } from '../types';
+export * from './Dots/Dots';
+export * from './Navigation/Navigation';
+export * from './Sync/Sync';
+export declare const CarouselPlugins: PluginsType;

package/src/lib/helpers/mrx-gallery-lib/types/Carousel/types.d.ts

@@ -0,0 +1,94 @@
+export interface slideType {
+    html: string | HTMLElement;
+    el: HTMLElement | null;
+    isDom: boolean;
+    class: string;
+    customClass: string;
+    index: number;
+    dim: number;
+    gap: number;
+    pos: number;
+    transition: string | false;
+    thumb?: string | HTMLImageElement;
+    thumbSrc?: string;
+    thumbElSrc?: string;
+    thumbEl?: HTMLImageElement;
+}
+import { Constructor , ComponentEventsType } from '../shared/Base/types';
+import { Plugin } from '../shared/Base/Plugin';
+import { Carousel } from './Carousel';
+export type PluginsType = Record<string, Constructor<Plugin<Carousel, any, any>>>;
+export type userSlideType = string | HTMLElement | Partial<slideType>;
+export type pageType = {
+    index: number;
+    slides: Array<slideType>;
+    dim: number;
+    pos: number;
+};
+import { EventsType as PanzoomEventsType } from '../Panzoom/types';
+export type CarouselEventsType = ComponentEventsType
+/**
+ * Initialization has started, plugins have been added
+ */
+ | 'init'
+/**
+ * The layout is initialized
+ */
+ | 'initLayout'
+/**
+ * Priority event when the slide object is created
+ */
+ | 'beforeInitSlide'
+/**
+ * The slide object is created
+ */
+ | 'initSlide'
+/**
+ * All slides have objects created
+ */
+ | 'initSlides'
+/**
+ * A corresponding DOM element is created for the slide
+ */
+ | 'createSlide'
+/**
+ * The element corresponding to the slide is removed from the DOM
+ */
+ | 'removeSlide'
+/**
+ * Slide is marked as being on the active page
+ */
+ | 'selectSlide'
+/**
+ * Slide is no longer on the active page
+ */
+ | 'unselectSlide'
+/**
+ * Initialization has been completed
+ */
+ | 'ready'
+/**
+ * Carousel metrics have been updated
+ */
+ | 'refresh'
+/**
+ * Right before the active page of the carousel is changed
+ */
+ | 'beforeChange'
+/**
+ * The active page of the carousel is changed
+ */
+ | 'change'
+/**
+ * Single click event has been detected
+ */
+ | 'click'
+/**
+ * The image is lazy loaded
+ */
+ | 'load'
+/**
+ * The slide change animation has finished
+ */
+ | 'settle' | `Panzoom.${PanzoomEventsType}`;
+export type Events = Record<CarouselEventsType, (...args: any[]) => void>;

package/src/lib/helpers/mrx-gallery-lib/types/Fancybox/Fancybox.d.ts

@@ -0,0 +1,231 @@
+import { OptionsType } from './options';
+import { EventsType, PluginsType } from './types';
+import { States, SlideStates } from './consts';
+import { Component } from '../shared/Base/Component';
+export * from './plugins/index';
+import { Carousel } from '../Carousel/Carousel';
+import { slideType, userSlideType } from '../Carousel/types';
+declare module '../Carousel/types' {
+    interface slideType {
+        src?: string | HTMLElement;
+        width?: number | 'auto';
+        height?: number | 'auto';
+        id?: string;
+        display?: string;
+        error?: string;
+        filter?: string;
+        caption?: string | HTMLElement;
+        downloadSrc?: string;
+        downloadFilename?: string;
+        contentEl?: HTMLElement;
+        captionEl?: HTMLElement;
+        spinnerEl?: HTMLElement;
+        closeBtnEl?: HTMLElement;
+        triggerEl?: HTMLElement;
+        thumbEl?: HTMLImageElement;
+        thumbElSrc?: string;
+        poster?: string;
+        state?: SlideStates;
+    }
+}
+export declare class Fancybox extends Component<OptionsType, EventsType> {
+    static version: string;
+    static defaults: Partial<OptionsType>;
+    static Plugins: PluginsType;
+    static openers: Map<HTMLElement, Map<string, Partial<OptionsType>>>;
+    private userSlides;
+    private userPlugins;
+    private idle;
+    private idleTimer;
+    private clickTimer;
+    private pwt;
+    private ignoreFocusChange;
+    state: States;
+    id: number | string;
+    container: HTMLElement | null;
+    footer: HTMLElement | null;
+    caption: HTMLElement | null;
+    carousel: Carousel | null;
+    lastFocus: HTMLElement | null;
+    prevMouseMoveEvent: MouseEvent | undefined;
+    fsAPI: {
+        request: (el: Element) => Promise<void>;
+        exit: () => Promise<void> | undefined;
+        isFullscreen: () => HTMLElement | undefined;
+    } | undefined;
+    get isIdle(): boolean;
+    get isCompact(): boolean;
+    constructor(userSlides?: Array<userSlideType>, userOptions?: Partial<OptionsType>, userPlugins?: PluginsType);
+    private init;
+    private initLayout;
+    private initCarousel;
+    private attachEvents;
+    private detachEvents;
+    private scale;
+    private onClick;
+    private onWheel;
+    private onKeydown;
+    private onResize;
+    private onFocus;
+    private onMousemove;
+    private onVisibilityChange;
+    private manageCloseBtn;
+    private manageCaption;
+    /**
+     * Make sure the element, that has the focus, is inside the container
+     */
+    checkFocus(event?: FocusEvent): void;
+    /**
+     * Place focus on the first focusable element inside current slide
+     */
+    focus(event?: FocusEvent): void;
+    /**
+     * Slide carousel to the next page
+     */
+    next(): void;
+    /**
+     * Slide carousel to the previous page
+     */
+    prev(): void;
+    /**
+     * Slide carousel to page by its index with optional parameters
+     */
+    jumpTo(...args: any): void;
+    /**
+     * Check if there is another instance on top of this one
+     */
+    isTopmost(): boolean;
+    animate(element?: HTMLElement | null, className?: string, callback?: () => void | null): void;
+    stop(element: HTMLElement): void;
+    /**
+     * Set new content for the given slide
+     */
+    setContent(slide: slideType, html?: string | HTMLElement, shouldReveal?: boolean): void;
+    revealContent(slide: slideType, showClass?: string | false): void;
+    done(slide: slideType): void;
+    /**
+     * Check if the given slide is the current slide in the carousel
+     */
+    isCurrentSlide(slide: slideType): boolean;
+    /**
+     * Check if the given slide is opening slide
+     */
+    isOpeningSlide(slide: slideType): boolean;
+    /**
+     * Show loading icon inside given slide
+     */
+    showLoading(slide: slideType): void;
+    /**
+     * Hide loading icon inside given slide
+     */
+    hideLoading(slide: slideType): void;
+    /**
+     * Show error message for given slide
+     */
+    setError(slide: slideType, message: string): void;
+    /**
+     * Clear content for given slide
+     */
+    clearContent(slide: slideType): void;
+    /**
+     * Retrieve current carousel slide
+     */
+    getSlide(): slideType | undefined;
+    /**
+     * Initiate closing
+     */
+    close(event?: Event, hideClass?: string | false): void;
+    /**
+     * Clear idle state timer
+     */
+    clearIdle(): void;
+    /**
+     * Activate idle state
+     */
+    setIdle(now?: boolean): void;
+    /**
+     * Deactivate idle state
+     */
+    endIdle(): void;
+    /**
+     * Reset idle state timer
+     */
+    resetIdle(): void;
+    /**
+     * Toggle idle state
+     */
+    toggleIdle(): void;
+    /**
+     * Toggle full-screen mode
+     */
+    toggleFullscreen(): void;
+    /**
+     * Check if the instance is being closed or already destroyed
+     */
+    isClosing(): boolean;
+    private proceedClose;
+    /**
+     * Destroy the instance
+     */
+    destroy(): void;
+    /**
+     * Add a click handler that launches Fancybox after clicking on items that match the provided selector
+     */
+    static bind(selector: string, userOptions?: Partial<OptionsType>): void;
+    /**
+     * Add a click handler to the given container that launches Fancybox after clicking items that match the provided selector
+     */
+    static bind(container: HTMLElement | null, selector: string, userOptions?: Partial<OptionsType>): void;
+    /**
+     * Remove selector from the list of selectors that triggers Fancybox
+     */
+    static unbind(selector: string): void;
+    /**
+     * Remove all or one selector from the list of selectors that triggers Fancybox for the given container
+     */
+    static unbind(container: HTMLElement | null, selector?: string): void;
+    /**
+     * Immediately destroy all instances (without closing animation) and clean up
+     */
+    static destroy(): void;
+    /**
+     * Start Fancybox using click event
+     */
+    static fromEvent(event: MouseEvent): Fancybox;
+    /**
+     * Start Fancybox using the previously assigned selector
+     */
+    static fromSelector(selector: string, options?: Partial<OptionsType>): void;
+    /**
+     * Start Fancybox using the previously assigned selector for the given container
+     */
+    static fromSelector(container: HTMLElement | null, selector: string, options?: Partial<OptionsType>): void;
+    /**
+     * Start Fancybox using HTML elements
+     */
+    static fromNodes(nodes: Array<HTMLElement>, options?: Partial<OptionsType>): Fancybox;
+    /**
+     * Retrieve instance by identifier or the top most instance, if identifier is not provided
+     */
+    static getInstance(id?: number): Fancybox | null;
+    /**
+     * Retrieve reference to the current slide of the highest active Fancybox instance
+     */
+    static getSlide(): slideType | null;
+    /**
+     * Create new Fancybox instance with provided options
+     */
+    static show(slides?: Array<userSlideType>, options?: Partial<OptionsType>): Fancybox;
+    /**
+     * Slide carousel of the current instance to the next page
+     */
+    static next(): void;
+    /**
+     * Slide carousel of the current instance to the previous page
+     */
+    static prev(): void;
+    /**
+     * Close all or topmost currently active instance
+     */
+    static close(all?: boolean, ...args: any): void;
+}

package/src/lib/helpers/mrx-gallery-lib/types/Fancybox/consts.d.ts

@@ -0,0 +1,13 @@
+export declare enum States {
+    Init = 0,
+    Ready = 1,
+    Closing = 2,
+    CustomClosing = 3,
+    Destroy = 4
+}
+export declare enum SlideStates {
+    Loading = 0,
+    Opening = 1,
+    Ready = 2,
+    Closing = 3
+}