@brandocms/jupiter 3.54.4 → 4.0.0-beta.1

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

@@ -0,0 +1,23 @@
+export default class Marquee {
+    constructor(app: any, el: any, opts: any);
+    opts: any;
+    app: any;
+    elements: {};
+    timeline: any;
+    observer: IntersectionObserver;
+    initialize(): void;
+    revealMarquee(e: any): void;
+    updateMarquee(e: any): void;
+    duration: number;
+    clearHolders(): void;
+    killTweens(): void;
+    initializeTween(): void;
+    play(rampUp?: boolean): void;
+    playing: boolean;
+    pause(): void;
+    slowDown(): void;
+    speedUp(): void;
+    setupObserver(): void;
+    fillText(): void;
+    setHeight(): void;
+}

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

@@ -0,0 +1,63 @@
+/**
+ * MobileMenu component for mobile navigation menu
+ */
+export default class MobileMenu {
+    /**
+     * Create a new MobileMenu instance
+     * @param {Object} app - Application instance
+     * @param {MobileMenuOptions} [opts={}] - MobileMenu options
+     */
+    constructor(app: any, opts?: MobileMenuOptions);
+    app: any;
+    opts: any;
+    open: boolean;
+    header: HTMLElement;
+    bg: Element;
+    logo: Element;
+    logoPath: NodeListOf<any>;
+    menuButton: Element;
+    hamburger: Element;
+    hamburgerInner: Element;
+    content: NodeListOf<any>;
+    lis: NodeListOf<any>;
+    nav: HTMLElement;
+    toggleMenu(): void;
+    toggleMenuClosed(): void;
+    toggleMenuOpen(): void;
+    _emitMobileMenuOpenEvent(): void;
+    _emitMobileMenuClosedEvent(): void;
+}
+export type MobileMenuOptions = {
+    /**
+     * - Color for logo when menu is open
+     */
+    logoColor?: string;
+    /**
+     * - Selector for logo SVG paths
+     */
+    logoPathSelector?: string;
+    /**
+     * - Selector for menu content
+     */
+    contentSelector?: string;
+    /**
+     * - Selector for menu items
+     */
+    liSelector?: string;
+    /**
+     * - Color for hamburger icon
+     */
+    hamburgerColor?: string;
+    /**
+     * - Called when window is resized
+     */
+    onResize?: Function | null;
+    /**
+     * - Animation for opening menu
+     */
+    openTween?: Function;
+    /**
+     * - Animation for closing menu
+     */
+    closeTween?: Function;
+};

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

@@ -0,0 +1,331 @@
+/**
+ * Moonwalk animation system for scroll-based reveal animations
+ */
+export default class Moonwalk {
+    /**
+     * @param {Object} app - The application instance
+     * @param {MoonwalkOptions} [opts={}] - Configuration options
+     * @param {HTMLElement} [container=document.body] - Container element
+     */
+    constructor(app: any, opts?: MoonwalkOptions, container?: HTMLElement);
+    app: any;
+    opts: any;
+    initialize(container?: HTMLElement): void;
+    sections: {
+        id: string;
+        el: any;
+        name: any;
+        timeline: any;
+        observer: any;
+        stage: {
+            name: any;
+            running: boolean;
+            firstTween: boolean;
+        };
+        elements: any[];
+    }[];
+    runs: {
+        el: Element;
+        threshold: any;
+        initialize: any;
+        callback: any;
+        onExit: any;
+        repeated: any;
+        rootMargin: any;
+    }[];
+    /**
+     * Add `moonwalk` class to html element to identify ourselves.
+     */
+    addClass(): void;
+    /**
+     * Matching moonwalk elements before the element matching the hash should be set to visible
+     * by setting the `data-moonwalked` attribute on `data-moonwalk` elements and
+     * `data-moonwalk-section-ready` on `data-moonwalk-section` elements.
+     */
+    walkToThisPoint(hash: any): void;
+    /**
+     * Remove all moonwalks. Useful for clients who prefer reduced motion
+     */
+    removeAllWalks(container?: HTMLElement): void;
+    removeFor(container: HTMLElement, selector: any): void;
+    /**
+     * Remove run matching name
+     */
+    removeRun(container: HTMLElement, name: any): void;
+    /**
+     * Remove all runs
+     */
+    removeRuns(container?: HTMLElement): void;
+    /**
+     * Add a random ID to each moonwalk element
+     *
+     * @param {*} section
+     */
+    addIds(section: any): void;
+    /**
+     * Add index to each moonwalk element in `section`
+     *
+     * @param {*} section
+     */
+    addIndexes(section: any): void;
+    /**
+     * Go through each `data-moonwalk-run`, parse children, add IDs/indexes
+     * (if wanted), initialize a new object for each.
+     */
+    initializeRuns(container?: HTMLElement): {
+        el: Element;
+        threshold: any;
+        initialize: any;
+        callback: any;
+        onExit: any;
+        repeated: any;
+        rootMargin: any;
+    }[];
+    /**
+     * Go through each `data-moonwalk-section`, parse children, add IDs/indexes
+     * (if wanted), initialize a new object for each.
+     */
+    initializeSections(container?: HTMLElement): {
+        id: string;
+        el: any;
+        name: any;
+        timeline: any;
+        observer: any;
+        stage: {
+            name: any;
+            running: boolean;
+            firstTween: boolean;
+        };
+        elements: any[];
+    }[];
+    initializeSection(section: any): {
+        id: string;
+        el: any;
+        name: any;
+        timeline: any;
+        observer: any;
+        stage: {
+            name: any;
+            running: boolean;
+            firstTween: boolean;
+        };
+        elements: any[];
+    };
+    /**
+     * Removes `data-moonwalk` from all elements who already have `data-ll-srcset´
+     * Can be used if Moonwalking interferes with custom lazyloading animations
+     */
+    clearLazyloads(container?: HTMLElement): void;
+    /**
+     * Look through section for `data-moonwalk-children` or
+     * `data-moonwalk-children="{walkName}"`, then convert all children to
+     * `data-moonwalk` or `data-moonwalk-{walkName}`
+     *
+     * @param {*} section
+     */
+    parseChildren(section: any): void;
+    /**
+     * Sets all `element`s childrens `data-moonwalk` to `val`
+     *
+     * @param {*} element
+     * @param {*} val
+     */
+    setAttrs(element: any, val: any): any[];
+    /**
+     * If we have advanced sections, either named sections or section stages.
+     * Resets the entry's `from` state, then creates an observer that will
+     * watch this section.
+     *
+     * @param {*} section
+     */
+    setupNamesAndStages(section: any): void;
+    /**
+     * Create and return an observer for `section`
+     *
+     * @param {*} section
+     */
+    sectionObserver(section: any): IntersectionObserver;
+    /**
+     * Order `children` by `data-moonwalk-order`.
+     *
+     * @param {*} children
+     */
+    orderChildren(children: any): any[];
+    onReady(): void;
+    /**
+     * Called on `APPLICATION_READY` event, if `config.fireOnReady`.
+     * Otherwise must be triggered manually
+     */
+    ready(): void;
+    /**
+     * Creates and returns the RUN observer for data-moonwalk-run elements
+     *
+     * @param {*} run
+     * @param {*} rootMargin
+     */
+    runObserver(run: any, rootMargin: any): IntersectionObserver;
+    /**
+     * Creates and returns the standard observer for all moonwalk elements
+     * inside a section.
+     *
+     * @param {*} section
+     * @param {*} rootMargin
+     */
+    observer(section: any, rootMargin: any): IntersectionObserver;
+    /**
+     * The main tween function
+     *
+     * @param {*} section
+     * @param {*} target
+     * @param {*} tweenDuration
+     * @param {*} tweenTransition
+     * @param {*} tweenOverlap
+     * @param {*} alphaTween
+     */
+    tweenJS(section: any, target: any, tweenDuration: any, tweenInterval: any, tweenTransition: any, tweenOverlap: any, alphaTween: any): void;
+    /**
+     * CSS version. Not quite ready yet.
+     *
+     * @param {*} section
+     * @param {*} target
+     * @param {*} duration
+     * @param {*} transition
+     * @param {*} overlap
+     */
+    tweenCSS(section: any, target: any, tweenDuration: any, tweenInterval: any, tweenTransition: any, tweenOverlap: any): void;
+}
+export type MoonwalkTransition = {
+    /**
+     * - Starting properties for the transition
+     */
+    from: any;
+    /**
+     * - Ending properties for the transition
+     */
+    to: any;
+};
+export type MoonwalkWalk = {
+    /**
+     * - Delay before the animation starts
+     */
+    startDelay?: number;
+    /**
+     * - Time between animations in a sequence
+     */
+    interval?: number;
+    /**
+     * - Duration of the animation
+     */
+    duration?: number;
+    /**
+     * - Whether to add a separate opacity tween
+     */
+    alphaTween?: boolean | any;
+    /**
+     * - The transition configuration
+     */
+    transition: MoonwalkTransition;
+    /**
+     * - CSS selector for targeting elements in named sections
+     */
+    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
+     */
+    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;
+    /**
+     * - Whether the run should repeat
+     */
+    repeated?: boolean;
+    /**
+     * - IntersectionObserver rootMargin
+     */
+    rootMargin?: string;
+    /**
+     * - Function called during initialization
+     */
+    initialize?: Function;
+};
+export type MoonwalkOptions = {
+    /**
+     * - Event to trigger animations
+     */
+    on?: string | Function;
+    /**
+     * - Delay before starting animations
+     */
+    initialDelay?: number;
+    /**
+     * - Clear data-ll-srcset attributes
+     */
+    clearLazyload?: boolean;
+    /**
+     * - Remove nested data-moonwalk-section attributes
+     */
+    clearNestedSections?: boolean;
+    /**
+     * - Remove nested data-moonwalk attributes
+     */
+    clearNestedWalks?: boolean;
+    /**
+     * - Disable animations when page loaded via anchor
+     */
+    clearMoonwalkOnAnchors?: boolean;
+    /**
+     * - Warn when run and section on same element
+     */
+    warnRunWithSection?: boolean;
+    /**
+     * - Default IntersectionObserver rootMargin
+     */
+    rootMargin?: string;
+    /**
+     * - Default IntersectionObserver threshold
+     */
+    threshold?: number;
+    /**
+     * - Generate unique IDs for moonwalk elements
+     */
+    uniqueIds?: boolean;
+    /**
+     * - Add index attributes to elements
+     */
+    addIndexes?: boolean;
+    /**
+     * - Run configurations
+     */
+    runs?: {
+        [x: string]: MoonwalkRun;
+    };
+    /**
+     * - Walk configurations
+     */
+    walks: {
+        [x: string]: MoonwalkWalk;
+    };
+};

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

@@ -0,0 +1,93 @@
+/**
+ * Parallax scrolling effect for background images
+ */
+export default class Parallax {
+    /**
+     * Create a new Parallax instance
+     * @param {Object} app - Application instance
+     * @param {ParallaxOptions} [opts={}] - Parallax options
+     */
+    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;
+    }>;
+    
+    /**
+     * 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 };
+    
+    /**
+     * 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;
+    
+    /**
+     * 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';
+    
+    /**
+     * - Whether to show element overflow
+     */
+    overflow?: boolean;
+};

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

@@ -0,0 +1,17 @@
+export default class Popover {
+    constructor(app: any, trigger: any, opts?: {});
+    app: any;
+    opts: any;
+    trigger: any;
+    position: any;
+    className: string;
+    orderedPositions: string[];
+    popover: HTMLDivElement;
+    handleMouseEnter(e: any): void;
+    handleMouseLeave(e: any): void;
+    handleTouchStart(e: any): void;
+    get isVisible(): boolean;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+}

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

@@ -0,0 +1,89 @@
+/**
+ * Popup component for modal dialogs and popups
+ */
+export default class Popup {
+    /**
+     * Create a new Popup instance
+     * @param {Object} app - Application instance
+     * @param {string} [selector] - CSS selector to find popup elements
+     * @param {PopupOptions} [opts={}] - Popup options
+     */
+    constructor(app: any, selector?: string, opts?: PopupOptions);
+    app: any;
+    opts: any;
+    backdrop: HTMLDivElement | null;
+    currentPopup: HTMLElement | null;
+    popupKey: string | null;
+    keyUpListener: any;
+    
+    /**
+     * 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;
+    
+    /**
+     * Open a popup
+     * @param {HTMLElement} trigger - Element that triggered the popup
+     * @param {HTMLElement|string} target - Popup element or selector
+     * @param {string|null} key - Optional popup key
+     */
+    open(trigger: HTMLElement, target: HTMLElement | string, key?: string | null): void;
+    
+    /**
+     * 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

@@ -0,0 +1,29 @@
+/**
+ * ScrollSpy component for highlighting active sections during scrolling
+ */
+export default class ScrollSpy {
+    /**
+     * Create a new ScrollSpy instance
+     * @param {Object} app - Application instance
+     * @param {ScrollSpyOptions} [opts={}] - ScrollSpy options
+     */
+    constructor(app: any, opts?: ScrollSpyOptions);
+    app: any;
+    opts: any;
+    /**
+     * Initialize ScrollSpy
+     */
+    initialize(): void;
+    triggers: any[];
+    /**
+     * Handle intersection with viewport
+     * @param {IntersectionObserverEntry} entry - Intersection observer entry
+     */
+    intersectionHandler(entry: IntersectionObserverEntry): void;
+}
+export type ScrollSpyOptions = {
+    /**
+     * - Called when a target intersects with the viewport
+     */
+    onIntersect?: Function;
+};

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

@@ -0,0 +1,9 @@
+export default class StackedBoxes {
+    constructor(app: any, opts?: {});
+    app: any;
+    opts: any;
+    initialize(): void;
+    adjustBox(box: any): void;
+    pull(box: any, amnt: any): void;
+    size(target: any, src: any): void;
+}