@brandocms/jupiter 3.55.0 → 4.0.0-beta.2

package/types/modules/EqualHeightImages/index.d.ts

@@ -0,0 +1,11 @@
+export default class EqualHeightImages {
+    constructor(app: any, opts?: {}, container?: HTMLElement);
+    app: any;
+    container: HTMLElement;
+    opts: any;
+    run(): void;
+    initialize(): void;
+    canvases: any;
+    getRenderedSize(contains: any, cWidth: any, cHeight: any, width: any, height: any, pos: any): any;
+    getImgSizeInfo(img: any): any;
+}

package/types/modules/FeatureTests/index.d.ts

@@ -0,0 +1,27 @@
+export default class FeatureTests {
+    constructor(app: any, tests: any);
+    app: any;
+    testFns: {
+        touch: () => boolean;
+    };
+    results: {};
+    runTests(tests: any): void;
+    testFor(feature: any, result: any): void;
+    /**
+     * Check if we should outline elements. If the user hits TAB, we should outline,
+     * otherwise we skip it.
+     */
+    testOutlineEvents(): void;
+    /**
+     * Sometimes the initial test for touch/mouse fail, so
+     * listen for events as well
+     */
+    testTouchMouseEvents(): void;
+    deviceLastTouched: number;
+    bindEventTests(): void;
+    testTouch(): boolean;
+    testIE11(): boolean;
+    testIOS(): RegExpMatchArray;
+    testBrowsers(): string;
+    testWebview(): RegExpMatchArray;
+}

package/types/modules/FixedHeader/index.d.ts

@@ -0,0 +1,219 @@
+/**
+ * FixedHeader component for sticky navigation headers with scroll behaviors
+ */
+export default class FixedHeader {
+    /**
+     * Create a new FixedHeader instance
+     * @param {Object} app - Application instance
+     * @param {FixedHeaderOptions} [opts={}] - FixedHeader options
+     */
+    constructor(app: any, opts?: FixedHeaderOptions);
+    app: any;
+    mainOpts: any;
+    el: any;
+    opts: any;
+    lis: any;
+    preventPin: boolean;
+    preventUnpin: boolean;
+    _firstLoad: boolean;
+    _pinned: boolean;
+    _top: boolean;
+    _bottom: boolean;
+    _small: boolean;
+    _altBg: boolean;
+    _isResizing: boolean;
+    _hiding: boolean;
+    lastKnownScrollY: number;
+    lastKnownScrollHeight: number;
+    currentScrollHeight: number;
+    currentScrollY: number;
+    mobileMenuOpen: boolean;
+    timer: any;
+    resetResizeTimer: any;
+    intersectingElements: any;
+    initialize(): void;
+    pageIsScrolledOnReady: boolean;
+    preflight(): void;
+    lock(): void;
+    unlock(): void;
+    isScrolled(): boolean;
+    unpinIfScrolled(): void;
+    enter(): void;
+    setResizeTimer(): void;
+    update(): void;
+    checkSize(force: any): void;
+    checkBg(force: any): void;
+    checkTop(force: any): void;
+    checkBot(force: any): void;
+    checkPin(force: any, toleranceExceeded: any): void;
+    redraw(): void;
+    notTop(): void;
+    top(): void;
+    notBottom(): void;
+    bottom(): void;
+    unpin(): void;
+    pin(): void;
+    notSmall(): void;
+    small(): void;
+    notAltBg(): void;
+    altBg(): void;
+    shouldUnpin(toleranceExceeded: any): any;
+    shouldPin(toleranceExceeded: any): any;
+    isOutOfBounds(): boolean;
+    getScrollerPhysicalHeight(): number;
+    getScrollerHeight(): number;
+    getDocumentHeight(): number;
+    getViewportHeight(): number;
+    getElementHeight(el: any): number;
+    getElementPhysicalHeight(el: any): number;
+    getScrollY(): any;
+    toleranceExceeded(): boolean;
+    _getOptionsForSection(section: any, opts: any): any;
+    _bindMobileMenuListeners(): void;
+    _onMobileMenuOpen(): void;
+    _onMobileMenuClose(): void;
+}
+export type FixedHeaderEvents = {
+    /**
+     * - Called when header is pinned
+     */
+    onPin?: Function;
+    /**
+     * - Called when header is unpinned
+     */
+    onUnpin?: Function;
+    /**
+     * - Called when alternate background is applied
+     */
+    onAltBg?: Function;
+    /**
+     * - Called when regular background is applied
+     */
+    onNotAltBg?: Function;
+    /**
+     * - Called when header becomes small
+     */
+    onSmall?: Function;
+    /**
+     * - Called when header becomes normal size
+     */
+    onNotSmall?: Function;
+    /**
+     * - Called when page is at the top
+     */
+    onTop?: Function;
+    /**
+     * - Called when page is not at the top
+     */
+    onNotTop?: Function;
+    /**
+     * - Called when page is at the bottom
+     */
+    onBottom?: Function;
+    /**
+     * - Called when page is not at the bottom
+     */
+    onNotBottom?: Function;
+    /**
+     * - Called when mobile menu opens
+     */
+    onMobileMenuOpen?: Function;
+    /**
+     * - Called when mobile menu closes
+     */
+    onMobileMenuClose?: Function;
+    /**
+     * - Called when header intersects with an element
+     */
+    onIntersect?: Function;
+    /**
+     * - Called when user tabs (outline mode)
+     */
+    onOutline?: Function;
+};
+export type FixedHeaderSectionOptions = {
+    /**
+     * - Whether to unpin header on window resize
+     */
+    unPinOnResize?: boolean;
+    /**
+     * - Scrolling element
+     */
+    canvas?: Window | HTMLElement;
+    /**
+     * - Selector for elements to check intersection with
+     */
+    intersects?: string | null;
+    /**
+     * - Called before header enters
+     */
+    beforeEnter?: Function;
+    /**
+     * - Called when header enters
+     */
+    enter?: Function;
+    /**
+     * - Delay before enter animation
+     */
+    enterDelay?: number;
+    /**
+     * - Scroll tolerance before triggering hide/show
+     */
+    tolerance?: number;
+    /**
+     * - Offset from top before triggering hide
+     */
+    offset?: number | string | Function;
+    /**
+     * - Offset from top before shrinking header
+     */
+    offsetSmall?: number | string | Function;
+    /**
+     * - Offset from top before changing background color
+     */
+    offsetBg?: number | string | Function;
+    /**
+     * - Regular background color
+     */
+    regBgColor?: string | null;
+    /**
+     * - Alternate background color
+     */
+    altBgColor?: string | null;
+};
+export type FixedHeaderOptions = {
+    /**
+     * - Header element or selector
+     */
+    el?: string | HTMLElement;
+    /**
+     * - Event to initialize on
+     */
+    on?: string;
+    /**
+     * - Whether to unpin on forced scroll start
+     */
+    unpinOnForcedScrollStart?: boolean;
+    /**
+     * - Whether to pin on forced scroll end
+     */
+    pinOnForcedScrollEnd?: boolean;
+    /**
+     * - Whether to ignore forced scroll events
+     */
+    ignoreForcedScroll?: boolean;
+    /**
+     * - Whether to use requestAnimationFrame for scrolling
+     */
+    rafScroll?: boolean;
+    /**
+     * - Default options for all sections
+     */
+    default?: FixedHeaderSectionOptions;
+    /**
+     * - Section-specific options
+     */
+    sections?: {
+        [x: string]: FixedHeaderSectionOptions;
+    };
+};

package/types/modules/Fontloader/index.d.ts

@@ -0,0 +1,5 @@
+export default class Fontloader {
+    constructor(app: any);
+    app: any;
+    loadFonts(): Promise<any>;
+}

package/types/modules/FooterReveal/index.d.ts

@@ -0,0 +1,5 @@
+export default class FooterReveal {
+    constructor(app: any, opts: any);
+    app: any;
+    opts: any;
+}

package/types/modules/HeroSlider/index.d.ts

@@ -0,0 +1,28 @@
+export default class HeroSlider {
+    constructor(app: any, opts?: {});
+    app: any;
+    opts: any;
+    el: any;
+    initialize(): void;
+    slides: any;
+    images: any;
+    slideCount: number;
+    _currentSlideIdx: any;
+    /**
+     * Calculate which slide is next, and call the slide function
+     */
+    next(): void;
+    _previousSlide: any;
+    _nextSlide: any;
+    _currentSlide: any;
+    /**
+     * Switches between slides
+     */
+    slide(type: any): void;
+    /**
+     * Add a window resize handler that resizes slide widths
+     */
+    _addResizeHandler(): void;
+    observer: IntersectionObserver;
+    _resizeSlides(): void;
+}

package/types/modules/HeroVideo/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * HeroVideo component for handling responsive background videos with controls
+ */
+export default class HeroVideo {
+    /**
+     * Create a new HeroVideo instance
+     * @param {Object} app - Application instance
+     * @param {HeroVideoOptions} [opts={}] - HeroVideo options
+     */
+    constructor(app: any, opts?: HeroVideoOptions);
+    app: any;
+    booting: boolean;
+    playing: boolean;
+    forcePaused: boolean;
+    opts: any;
+    elements: {};
+    el: any;
+    initialize(): void;
+    cover: any;
+    videoDiv: any;
+    video: any;
+    setSrc(): void;
+    addEvents(): void;
+    play(): void;
+    pause(): void;
+    fadeIn(): void;
+    fadeInCover(): void;
+    addObserver(): void;
+    /**
+     * Add a window resize handler that resizes video width
+     */
+    _addResizeHandler(): void;
+    observer: IntersectionObserver;
+    _resize(): void;
+}
+export type HeroVideoElementGenerators = {
+    /**
+     * - Function that returns the pause button HTML
+     */
+    pause?: Function;
+    /**
+     * - Function that returns the play button HTML
+     */
+    play?: Function;
+};
+export type HeroVideoOptions = {
+    /**
+     * - Target element selector or element
+     */
+    el?: string | HTMLElement;
+    /**
+     * - Called when video fades in
+     */
+    onFadeIn?: Function;
+    /**
+     * - Called when cover fades in
+     */
+    onFadeInCover?: Function;
+    /**
+     * - Called when cover fades out
+     */
+    onFadeOutCover?: Function;
+    /**
+     * - Called when video is ready to play
+     */
+    onPlayReady?: Function;
+    /**
+     * - Called when play button is clicked
+     */
+    onClickPlay?: Function;
+    /**
+     * - Called when pause button is clicked
+     */
+    onClickPause?: Function;
+    /**
+     * - Selector for parent element to append pause button to
+     */
+    pauseParent?: string;
+    /**
+     * - Element generators for UI components
+     */
+    elements?: HeroVideoElementGenerators;
+};

package/types/modules/Lazyload/index.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Lazyload class for handling image lazy loading
+ */
+export default class Lazyload {
+    /**
+     * Create a new Lazyload instance
+     * @param {Object} app - Application instance
+     * @param {LazyloadOptions} [opts={}] - Lazyload options
+     */
+    constructor(app: any, opts?: LazyloadOptions);
+    app: any;
+    opts: any;
+    target: any;
+    resizePending: Map<any, any>;
+    rafId: number;
+    srcsetReadyObserver: MutationObserver;
+    watch(): void;
+    initialize(): void;
+    lazyPictures: any;
+    loadObserver: IntersectionObserver;
+    revealObserver: IntersectionObserver;
+    imageObserver: IntersectionObserver;
+    lazyImages: any;
+    initObserver(observer: any, setAttrs?: boolean): void;
+    forceLoad($container?: HTMLElement): void;
+    initializeResizeObserver(): void;
+    sizeObserver: ResizeObserver;
+    flushSizeUpdates(): void;
+    initializeSections(): void;
+    handleLoadEntries(elements: any): void;
+    handleRevealEntries(elements: any): void;
+    loadPicture(picture: any): void;
+    revealPicture(picture: any): void;
+    lazyloadImages(elements: any): void;
+    swapImage(image: any): void;
+}
+export type IntersectionObserverConfig = {
+    /**
+     * - Margin around the root
+     */
+    rootMargin?: string;
+    /**
+     * - Threshold for intersection
+     */
+    threshold?: number;
+};
+export type LazyloadOptions = {
+    /**
+     * - Configuration for the reveal intersection observer
+     */
+    revealIntersectionObserverConfig?: IntersectionObserverConfig;
+    /**
+     * - Configuration for the load intersection observer
+     */
+    loadIntersectionObserverConfig?: IntersectionObserverConfig;
+    /**
+     * - Configuration for general intersection observers
+     */
+    intersectionObserverConfig?: IntersectionObserverConfig;
+    /**
+     * - Whether to use native lazyloading if available
+     */
+    useNativeLazyloadIfAvailable?: boolean;
+    /**
+     * - Lazyload mode
+     */
+    mode?: string;
+    /**
+     * - Minimum size for auto sizing
+     */
+    minSize?: number;
+    /**
+     * - Whether to update sizes attribute
+     */
+    updateSizes?: boolean;
+    /**
+     * - Whether to register a callback for APPLICATION_REVEALED event
+     */
+    registerCallback?: boolean;
+};

package/types/modules/Lightbox/index.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Lightbox component for displaying images in a fullscreen overlay
+ */
+export default class Lightbox {
+    /**
+     * Create a new Lightbox instance
+     * @param {Object} app - Application instance
+     * @param {LightboxOptions} [opts={}] - Lightbox options
+     */
+    constructor(app: any, opts?: LightboxOptions);
+    app: any;
+    opts: any;
+    lightboxes: NodeListOf<Element>;
+    elements: {};
+    imgAlts: any[];
+    imgs: any[];
+    sections: {};
+    currentIndex: any;
+    firstTransition: boolean;
+    previousCaption: any;
+    timelines: {
+        caption: any;
+        image: any;
+    };
+    showBox(section: any, index: any): void;
+    buildBox(section: any, index: any): void;
+    keyUpCallback: (event: any) => void;
+    close(): void;
+    currentImage: any;
+    destroy(): void;
+    setImg(section: any, index: any): void;
+    nextImage: any;
+    getNextIdx(section: any): any;
+    getPrevIdx(section: any): number;
+    onClick(e: any, section: any): void;
+    onKeyup(e: any, section: any): void;
+    onMouseMove(e: any): void;
+    pointerDirection: string;
+}
+export type LightboxElements = {
+    /**
+     * - Function to create right arrow element
+     */
+    arrowRight?: Function;
+    /**
+     * - Function to create left arrow element
+     */
+    arrowLeft?: Function;
+    /**
+     * - Function to create close button element
+     */
+    close?: Function;
+    /**
+     * - Function to create dot/indicator element
+     */
+    dot?: Function;
+};
+export type LightboxOptions = {
+    /**
+     * - Enable captions
+     */
+    captions?: boolean;
+    /**
+     * - Enable index numbers
+     */
+    numbers?: boolean;
+    /**
+     * - Selector for trigger element to open the lightbox
+     */
+    trigger?: string | boolean;
+    /**
+     * - Custom elements configuration
+     */
+    elements?: LightboxElements;
+    /**
+     * - Click handler for lightbox
+     */
+    onClick?: Function;
+    /**
+     * - Called when pointer moves left
+     */
+    onPointerLeft?: Function;
+    /**
+     * - Called when pointer moves right
+     */
+    onPointerRight?: Function;
+    /**
+     * - Called when caption fades out
+     */
+    onCaptionOut?: Function;
+    /**
+     * - Called when caption fades in
+     */
+    onCaptionIn?: Function;
+    /**
+     * - Called when image fades out
+     */
+    onImageOut?: Function;
+    /**
+     * - Called when image fades in
+     */
+    onImageIn?: Function;
+    /**
+     * - Called when numbers display updates
+     */
+    onNumbers?: Function;
+    /**
+     * - Called before opening lightbox
+     */
+    onBeforeOpen?: Function;
+    /**
+     * - Called when lightbox opens
+     */
+    onOpen?: Function;
+    /**
+     * - Called after lightbox closes
+     */
+    onAfterClose?: Function;
+    /**
+     * - Called when lightbox closes
+     */
+    onClose?: Function;
+};

package/types/modules/Links/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Links handler for navigation and transitions
+ */
+export default class Links {
+    /**
+     * Create a new Links instance
+     * @param {Object} app - Application instance
+     * @param {LinksOptions} [opts={}] - Links options
+     */
+    constructor(app: any, opts?: LinksOptions);
+    app: any;
+    opts: any;
+    bindHeroLink(): void;
+    bindAnchors(anchors: any): void;
+    bindLinks(links: any): void;
+    normalizeHostname(hostname: any): any;
+}
+export type LinksOptions = {
+    /**
+     * - Whether to trigger events when scrolling
+     */
+    triggerEvents?: boolean;
+    /**
+     * - Duration of scroll animation
+     */
+    scrollDuration?: number;
+    /**
+     * - Whether to offset scroll for nav header
+     */
+    scrollOffsetNav?: boolean;
+    /**
+     * - Delay for mobile menu before scrolling
+     */
+    mobileMenuDelay?: number;
+    /**
+     * - Whether to open external links in new window
+     */
+    openExternalInWindow?: boolean;
+    /**
+     * - Query selector for regular links
+     */
+    linkQuery?: string;
+    /**
+     * - Query selector for anchor links
+     */
+    anchorQuery?: string;
+    /**
+     * - Called when an anchor link is clicked
+     */
+    onAnchor?: Function;
+    /**
+     * - Called when transitioning between pages
+     */
+    onTransition?: Function;
+};