@brandocms/jupiter 4.0.0-beta.1 → 4.0.0-beta.2

package/types/modules/Dataloader/url-sync.d.ts

@@ -0,0 +1,36 @@
+/**
+ * URL synchronization module for Dataloader
+ * Handles bidirectional sync between dataloader parameters and browser URL
+ */
+export default class DataloaderUrlSync {
+    constructor(dataloader: any, config: any);
+    dataloader: any;
+    config: any;
+    language: string;
+    languageInPath: any;
+    hideDefaultLanguage: boolean;
+    defaultLanguage: any;
+    omitFromUrl: any;
+    initialize(): void;
+    popstateHandler: () => void;
+    /**
+     * Build URL from parameters using template
+     */
+    buildUrl(params: any): any;
+    /**
+     * Parse current URL and extract parameters based on template
+     */
+    parseUrl(): any;
+    /**
+     * Update browser URL with current parameters
+     */
+    updateUrl(params: any): void;
+    /**
+     * Sync dataloader parameters from current URL
+     */
+    syncFromUrl(): void;
+    /**
+     * Clean up event listeners
+     */
+    destroy(): void;
+}

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

@@ -37,4 +37,11 @@ declare class DOM {
      * @param {*} el
      */
     inViewport(el: any): boolean;
+    /**
+     * Strict viewport check - element must be fully contained within viewport bounds
+     * Useful for popovers/tooltips that need to be completely visible
+     *
+     * @param {*} el
+     */
+    inViewportStrict(el: any): boolean;
 }

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

@@ -0,0 +1,63 @@
+export default class DoubleHeader {
+    constructor(app: any, opts?: {});
+    app: any;
+    mainOpts: any;
+    preventUnpin: boolean;
+    el: any;
+    opts: any;
+    auxEl: any;
+    lis: any;
+    preventPin: boolean;
+    _isResizing: boolean;
+    _firstLoad: boolean;
+    _pinned: boolean;
+    _top: boolean;
+    _bottom: boolean;
+    _small: boolean;
+    _hiding: boolean;
+    lastKnownScrollY: number;
+    currentScrollY: number;
+    mobileMenuOpen: boolean;
+    timer: any;
+    resetResizeTimer: any;
+    firstReveal: boolean;
+    initialize(): void;
+    setupObserver(): void;
+    observer: IntersectionObserver;
+    _navVisible: boolean;
+    bindObserver(): void;
+    setResizeTimer(): void;
+    _hideAlt(): void;
+    _showAlt(): void;
+    update(): void;
+    lock(): void;
+    unlock(): void;
+    checkSize(force: any): void;
+    checkTop(force: any): void;
+    checkBot(force: any): void;
+    checkPin(force: any, toleranceExceeded: any): void;
+    redraw(force?: boolean): void;
+    notTop(): void;
+    top(): void;
+    notBottom(): void;
+    bottom(): void;
+    unpin(): void;
+    pin(): void;
+    notSmall(): void;
+    small(): 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;
+}

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

@@ -1,37 +1,14 @@
-interface DropdownOptions {
-    multipleActive?: boolean;
-    selectors?: {
-        trigger: string;
-        menu: string;
-        menuItems: string;
-    };
-    overlapTweens?: boolean;
-    menuOpenDuration?: number;
-    tweens?: {
-        items: {
-            duration: number;
-            autoAlpha: number;
-            stagger: number;
-        }
-    };
-    onBeforeOpen?: (dropdown: Dropdown) => Promise<void>;
-    onAfterOpen?: (dropdown: Dropdown) => Promise<void>;
-    onBeforeClose?: (dropdown: Dropdown) => Promise<void>;
-    onAfterClose?: (dropdown: Dropdown) => Promise<void>;
-    el?: HTMLElement;
-}
-
 export default class Dropdown {
-    constructor(app: any, opts?: Partial<DropdownOptions>);
+    constructor(app: any, opts?: {});
     app: any;
-    opts: DropdownOptions;
-    elements: Record<string, HTMLElement>;
+    opts: any;
+    elements: {};
     open: boolean;
-    element: HTMLElement;
-    timeline: gsap.core.Timeline;
-    handleDocumentClick(event: Event): void;
+    element: any;
+    timeline: any;
+    handleDocumentClick(event: any): void;
     initialize(): void;
-    onClick(event: Event): Promise<void>;
+    onClick(event: any): Promise<void>;
     openMenu(): Promise<void>;
     closeMenu(): Promise<void>;
     checkForInitialOpen(): void;

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

@@ -5,7 +5,7 @@ export default class EqualHeightImages {
     opts: any;
     run(): void;
     initialize(): void;
-    canvases: any[];
+    canvases: any;
     getRenderedSize(contains: any, cWidth: any, cHeight: any, width: any, height: any, pos: any): any;
     getImgSizeInfo(img: any): any;
 }

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

@@ -30,7 +30,7 @@ export default class FixedHeader {
     mobileMenuOpen: boolean;
     timer: any;
     resetResizeTimer: any;
-    intersectingElements: any[];
+    intersectingElements: any;
     initialize(): void;
     pageIsScrolledOnReady: boolean;
     preflight(): void;

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

@@ -10,22 +10,22 @@ export default class Lazyload {
     constructor(app: any, opts?: LazyloadOptions);
     app: any;
     opts: any;
+    target: any;
+    resizePending: Map<any, any>;
+    rafId: number;
+    srcsetReadyObserver: MutationObserver;
     watch(): void;
     initialize(): void;
-    lazyPictures: NodeListOf<Element>;
+    lazyPictures: any;
     loadObserver: IntersectionObserver;
     revealObserver: IntersectionObserver;
     imageObserver: IntersectionObserver;
-    lazyImages: NodeListOf<Element>;
+    lazyImages: any;
     initObserver(observer: any, setAttrs?: boolean): void;
     forceLoad($container?: HTMLElement): void;
-    initializeAutoSizes(): void;
-    $autoSizesImages: any[];
-    /**
-     * Set sizes attribute for all imgs with `data-sizes="auto"` and source within the <picture>
-     */
-    autoSizes(): void;
-    getWidth(img: any): any;
+    initializeResizeObserver(): void;
+    sizeObserver: ResizeObserver;
+    flushSizeUpdates(): void;
     initializeSections(): void;
     handleLoadEntries(elements: any): void;
     handleRevealEntries(elements: any): void;

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

@@ -36,7 +36,6 @@ export default class Lightbox {
     onKeyup(e: any, section: any): void;
     onMouseMove(e: any): void;
     pointerDirection: string;
-    attachSwiper(section: any, el: any, initialIdx: any): void;
 }
 export type LightboxElements = {
     /**
@@ -65,10 +64,6 @@ export type LightboxOptions = {
      * - Enable index numbers
      */
     numbers?: boolean;
-    /**
-     * - Enable swipe - this breaks native zoom
-     */
-    swipe?: boolean;
     /**
      * - Selector for trigger element to open the lightbox
      */

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

@@ -0,0 +1,127 @@
+/**
+ * Options for configuring the Looper module
+ */
+export interface LooperOptions {
+  /** Center the loop container. Can be true, false, or a selector string */
+  center?: boolean | string;
+  /** Enable snap-to-item behavior. Can be true, false, or a number for custom snap distance */
+  snap?: boolean | number;
+  /** Enable continuous auto-scrolling */
+  crawl?: boolean;
+  /** Enable infinite looping. If false, creates linear scrolling */
+  loop?: boolean;
+  /** Enable drag interaction with mouse/touch */
+  draggable?: boolean;
+  /** Speed multipliers for different breakpoints */
+  speed?: {
+    sm?: number;
+    lg?: number;
+  };
+  /** Easing configuration for hover interactions */
+  ease?: {
+    mouseOver?: {
+      speed?: number;
+      duration?: number;
+    };
+    mouseOut?: {
+      speed?: number;
+      duration?: number;
+    };
+  };
+  /** CSS selector for looper elements */
+  selector?: string;
+  /** Extra padding on the right side in pixels */
+  paddingRight?: number | string;
+  /** Start in reversed direction */
+  reversed?: boolean;
+}
+
+/**
+ * Loop controller returned by horizontalLoop function
+ */
+export interface LoopController {
+  /** Motion value tracking the current position */
+  position: any;
+  /** Main animation instance */
+  animation: any;
+  /** Array of item elements */
+  items: HTMLElement[];
+  /** Array of snap time positions */
+  times: number[];
+  /** Whether the loop is reversed */
+  isReversed: boolean;
+  /** Whether the loop is in looping mode */
+  isLooping: boolean;
+
+  /** Start/resume the loop animation */
+  play(): void;
+
+  /** Pause the loop animation */
+  pause(): void;
+
+  /** Get the current active item index */
+  current(): number;
+
+  /** Find the closest item index to current position */
+  closestIndex(setCurrent?: boolean): number;
+
+  /** Navigate to the next item */
+  next(vars?: { duration?: number; easing?: string }): any;
+
+  /** Navigate to the previous item */
+  previous(vars?: { duration?: number; easing?: string }): any;
+
+  /** Navigate to a specific item index */
+  toIndex(index: number, vars?: { duration?: number; easing?: string }): any;
+
+  /** Refresh measurements and recalculate (useful after resize) */
+  refresh(deep?: boolean): void;
+
+  /** Clean up and destroy the loop */
+  destroy(): void;
+}
+
+/**
+ * Looper Module
+ * Creates seamless horizontal infinite scrolling carousels with drag interaction,
+ * momentum/inertia, auto-crawl, snap-to-item, and responsive resize handling
+ */
+export default class Looper {
+  /**
+   * Create a new Looper instance
+   * @param app - Jupiter application instance
+   * @param opts - Configuration options
+   */
+  constructor(app: any, opts?: Partial<LooperOptions>);
+
+  /** Configuration options */
+  opts: LooperOptions;
+
+  /** Jupiter application instance */
+  app: any;
+
+  /** Array of active loop controllers */
+  loopers: LoopController[];
+
+  /** Array of pending loopers waiting for initialization */
+  pendingLoopers: any[];
+
+  /** DOM elements matching the selector */
+  looperElements: HTMLElement[];
+
+  /**
+   * Initialize the module and find all looper elements
+   */
+  init(): void;
+
+  /**
+   * Finalize loopers after APPLICATION:REVEALED event
+   * This is when actual measurements and animations are set up
+   */
+  finalizeLoopers(): void;
+
+  /**
+   * Destroy all loopers and clean up
+   */
+  destroy(): void;
+}

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

@@ -28,6 +28,7 @@ export default class Moonwalk {
         el: Element;
         threshold: any;
         initialize: any;
+        onReady: any;
         callback: any;
         onExit: any;
         repeated: any;
@@ -76,6 +77,7 @@ export default class Moonwalk {
         el: Element;
         threshold: any;
         initialize: any;
+        onReady: any;
         callback: any;
         onExit: any;
         repeated: any;
@@ -230,15 +232,6 @@ export type MoonwalkWalk = {
      */
     sectionTargets?: string;
 };
-export type MoonwalkRunMeta = {
-    /**
-     * - Direction of viewport crossing ('top', 'bottom', 'left', 'right', or null)
-     * - For entry callbacks: indicates which side the element entered from
-     * - For exit callbacks: indicates which side the element exited to
-     */
-    direction: string | null;
-};
-
 export type MoonwalkRun = {
     /**
      * - IntersectionObserver threshold
@@ -246,16 +239,10 @@ export type MoonwalkRun = {
     threshold?: number;
     /**
      * - Function called when element enters viewport
-     * - @param {HTMLElement} element - The element that triggered the callback
-     * - @param {boolean} repeated - Whether this is a repeated trigger
-     * - @param {MoonwalkRunMeta} meta - Information about how the element entered the viewport
      */
     callback: Function;
     /**
      * - Function called when element exits viewport
-     * - @param {HTMLElement} element - The element that triggered the callback
-     * - @param {boolean} repeated - Whether this is a repeated exit
-     * - @param {MoonwalkRunMeta} meta - Information about how the element exited the viewport
      */
     onExit?: Function;
     /**
@@ -270,6 +257,10 @@ export type MoonwalkRun = {
      * - Function called during initialization
      */
     initialize?: Function;
+    /**
+     * - Function called when APPLICATION_REVEALED fires, before viewport observers start
+     */
+    onReady?: Function;
 };
 export type MoonwalkOptions = {
     /**

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

@@ -1,5 +1,5 @@
 /**
- * Parallax scrolling effect for background images
+ * Parallax scrolling effect inspired by SimpleParallax.js
  */
 export default class Parallax {
     /**
@@ -10,82 +10,60 @@ export default class Parallax {
     constructor(app: any, opts?: ParallaxOptions);
     app: any;
     opts: any;
-    elements: Record<string, HTMLElement>;
-    parallaxElements: Array<{
-        element: HTMLElement;
-        factor: number;
-        fadeContent: boolean;
-        orientation: string;
-        content: HTMLElement | null;
-        figure: HTMLElement | null;
-        elementHeight: number;
-        elementWidth: number;
-        lastPosition: number;
-    }>;
-    
+    elements: {};
+    parallaxElements: any[];
+    /**
+     * Handle scroll event to update parallax effect
+     */
+    onScroll(): void;
     /**
      * Set up a parallax element with its properties
      * @param {HTMLElement} el - Element to set up
      */
     setupParallaxElement(el: HTMLElement): void;
-    
     /**
      * Calculate the transform value based on scroll position
      * @param {Object} item - Parallax element data
      * @param {number} scrollPosition - Current scroll position
      * @returns {Object} Transform and opacity values
      */
-    calculateTransform(item: any, scrollPosition: number): { transform: string, opacity: number };
-    
+    calculateTransform(item: any, scrollPosition: number): any;
     /**
      * Apply a smooth transition between current and target position
      * @param {Object} item - Parallax element data
      * @param {Object} target - Target transform and opacity values
      */
-    applyTransform(item: any, target: { transform: string, opacity: number }): void;
-    
-    /**
-     * Handle scroll event to update parallax effect
-     */
-    onScroll(): void;
-    
+    applyTransform(item: any, target: any): void;
     /**
      * Destroy the parallax instance and clean up
      */
     destroy(): void;
 }
-
 export type ParallaxOptions = {
     /**
      * - Target element selector or element
      */
     el?: string | HTMLElement;
-    
     /**
      * - Default parallax movement factor
      */
     factor?: number;
-    
     /**
      * - Whether to fade content while scrolling
      */
     fadeContent?: boolean;
-    
     /**
      * - Scale factor to apply to parallax images
      */
     scale?: number;
-    
     /**
      * - Delay factor to smooth the effect
      */
     delay?: number;
-    
     /**
      * - Direction of parallax effect ('up', 'down', 'left', 'right')
      */
-    orientation?: 'up' | 'down' | 'left' | 'right';
-    
+    orientation?: string;
     /**
      * - Whether to show element overflow
      */

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

@@ -6,12 +6,24 @@ export default class Popover {
     position: any;
     className: string;
     orderedPositions: string[];
+    currentPosition: any;
     popover: HTMLDivElement;
+    boundHandleDocumentClick: any;
+    boundHandleScroll: any;
     handleMouseEnter(e: any): void;
     handleMouseLeave(e: any): void;
     handleTouchStart(e: any): void;
+    handleClick(e: any): void;
     get isVisible(): boolean;
     show(): void;
+    updatePosition(animate?: boolean): void;
     hide(): void;
     toggle(): void;
+    addDocumentClickHandler(): void;
+    removeDocumentClickHandler(): void;
+    handleDocumentClick(e: any): void;
+    closeAllExcept(exceptPopover: any): void;
+    handleScroll(): void;
+    addScrollListener(): void;
+    removeScrollListener(): void;
 }

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

@@ -11,30 +11,25 @@ export default class Popup {
     constructor(app: any, selector?: string, opts?: PopupOptions);
     app: any;
     opts: any;
-    backdrop: HTMLDivElement | null;
-    currentPopup: HTMLElement | null;
-    popupKey: string | null;
-    keyUpListener: any;
-    
+    backdrop: HTMLElement;
+    currentPopup: string | HTMLElement;
+    popupKey: string;
     /**
      * Bind click handlers to popup triggers and close buttons
      */
     bindTriggers(): void;
-    
     /**
      * Extract key from target selector or element
      * @param {HTMLElement|string} target - Target element or selector
      * @returns {string|null} - The popup key or null
      */
     getKeyFromTarget(target: HTMLElement | string): string | null;
-    
     /**
      * Create backdrop element for popup
      * @param {string|null} key - Optional popup key to associate with backdrop
      * @returns {HTMLElement} The created backdrop element
      */
-    createBackdrop(key?: string | null): HTMLElement;
-    
+    createBackdrop(key: string | null): HTMLElement;
     /**
      * Open a popup
      * @param {HTMLElement} trigger - Element that triggered the popup
@@ -42,48 +37,40 @@ export default class Popup {
      * @param {string|null} key - Optional popup key
      */
     open(trigger: HTMLElement, target: HTMLElement | string, key?: string | null): void;
-    
+    keyUpListener: any;
     /**
      * Close the popup
      */
     close(): void;
-    
     /**
      * Handle keyup event for Escape key to close popup
      * @param {KeyboardEvent} e - Keyboard event
      */
     onKeyup(e: KeyboardEvent): void;
 }
-
 export type PopupOptions = {
     /**
      * - CSS selector to find popup elements
-     * Default: '[data-popup]'
      */
     selector?: string;
-    
     /**
      * - Function that determines if popup should be shown on current breakpoint
      */
     responsive?: Function;
-    
     /**
      * - Called when popup opens
      */
     onOpen?: Function;
-    
     /**
      * - Called when popup closes
      */
     onClose?: Function;
-    
     /**
      * - Animation function for opening popup
      */
     tweenIn?: Function;
-    
     /**
      * - Animation function for closing popup
      */
     tweenOut?: Function;
-};
+};

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

@@ -14,7 +14,7 @@ export default class ScrollSpy {
      * Initialize ScrollSpy
      */
     initialize(): void;
-    triggers: any[];
+    triggers: any;
     /**
      * Handle intersection with viewport
      * @param {IntersectionObserverEntry} entry - Intersection observer entry