@brandocms/jupiter 3.55.0 → 4.0.0-beta.2

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;
+}

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

@@ -0,0 +1,220 @@
+/**
+ * StickyHeader component for sticky navigation headers with scroll behaviors.
+ * Uses position: sticky instead of position: fixed, keeping the header in document flow.
+ */
+export default class StickyHeader {
+    /**
+     * Create a new StickyHeader instance
+     * @param {Object} app - Application instance
+     * @param {StickyHeaderOptions} [opts={}] - StickyHeader options
+     */
+    constructor(app: any, opts?: StickyHeaderOptions);
+    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 StickyHeaderEvents = {
+    /**
+     * - 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 StickyHeaderSectionOptions = {
+    /**
+     * - 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 StickyHeaderOptions = {
+    /**
+     * - 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?: StickyHeaderSectionOptions;
+    /**
+     * - Section-specific options
+     */
+    sections?: {
+        [x: string]: StickyHeaderSectionOptions;
+    };
+};

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

@@ -0,0 +1,48 @@
+/**
+ * Toggler component for show/hide functionality
+ * Uses [data-toggle-trigger] for the toggle button and [data-toggle-content] for toggleable content
+ * Can be grouped using [data-toggle-group] to create accordion-like behavior
+ */
+export default class Toggler {
+    /**
+     * Create a new Toggler instance
+     * @param {Object} app - Application instance
+     * @param {HTMLElement} el - Container element with [data-toggle] attribute
+     * @param {Object} options - Configuration options
+     * @param {Function} options.onOpen - Callback when toggle opens
+     * @param {Function} options.onClose - Callback when toggle closes
+     */
+    constructor(app: any, el: HTMLElement, options?: {
+        onOpen: Function;
+        onClose: Function;
+    });
+    open: boolean;
+    app: any;
+    el: HTMLElement;
+    onOpen: Function;
+    onClose: Function;
+    onBeforeOpen: any;
+    onBeforeClose: any;
+    trigger: any;
+    triggerTarget: any;
+    group: string;
+    content: any;
+    triggerIcon: any;
+    /**
+     * Get the index of this toggle within its group (1-based)
+     * @returns {number} The 1-based index of this toggle in its group
+     */
+    getGroupIndex(): number;
+    /**
+     * Handle click on trigger element
+     */
+    onClick(): void;
+    /**
+     * Close all other togglers in the same group
+     */
+    closeOthersInGroup(): void;
+    /**
+     * Toggle open/closed state
+     */
+    toggleState(): void;
+}

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

@@ -0,0 +1,77 @@
+/**
+ * @typedef {Object} TypographySettings
+ * @property {number} [minWords=4] - Minimum number of words required to apply fixes
+ * @property {string} [selector='[data-typo]'] - Selector for elements to process
+ * @property {string} [ignoreClass='no-typo-fix'] - Class to exclude elements from processing
+ * @property {boolean} [ignoreExistingSpaceChars=false] - Whether to ignore elements with existing non-breaking spaces
+ */
+/**
+ * Typography class for enhancing text presentation, including orphan prevention
+ */
+export default class Typography {
+    /**
+     * Create a new Typography instance
+     * @param {HTMLElement|undefined} parent - Parent element to search for typography elements, or undefined for document
+     * @param {TypographySettings} settings - Typography settings
+     */
+    constructor(parent: HTMLElement | undefined, settings?: TypographySettings);
+    settings: {
+        /**
+         * - Minimum number of words required to apply fixes
+         */
+        minWords: number;
+        /**
+         * - Selector for elements to process
+         */
+        selector: string;
+        /**
+         * - Class to exclude elements from processing
+         */
+        ignoreClass: string;
+        /**
+         * - Whether to ignore elements with existing non-breaking spaces
+         */
+        ignoreExistingSpaceChars: boolean;
+    };
+    elems: any[];
+    /**
+     * Apply formatting to the loaded elements
+     * @return void
+     */
+    apply(): void;
+    /**
+     * Apply the orphans filter to the passed text and return it
+     * @param {string} textItems
+     */
+    preventOrphans(textItems: string): string;
+    /**
+     * Reset any formatting
+     * @return void
+     */
+    reset(): void;
+    /**
+     * Run checks to see if the passed element should be skipped
+     *
+     * @param {HTMLElement} elem
+     * @returns boolean
+     */
+    shouldElementBeIgnored(elem: HTMLElement): boolean;
+}
+export type TypographySettings = {
+    /**
+     * - Minimum number of words required to apply fixes
+     */
+    minWords?: number;
+    /**
+     * - Selector for elements to process
+     */
+    selector?: string;
+    /**
+     * - Class to exclude elements from processing
+     */
+    ignoreClass?: string;
+    /**
+     * - Whether to ignore elements with existing non-breaking spaces
+     */
+    ignoreExistingSpaceChars?: boolean;
+};

package/types/utils/dispatchElementEvent.d.ts

@@ -0,0 +1 @@
+export default function dispatchEvent(el: any, eventName: any): void;

package/types/utils/imageIsLoaded.d.ts

@@ -0,0 +1 @@
+export default function imageIsLoaded(img: any, lazy?: boolean): Promise<any>;

package/types/utils/imagesAreLoaded.d.ts

@@ -0,0 +1 @@
+export default function imagesAreLoaded(imgs: any, lazy?: boolean): Promise<any[]>;

package/types/utils/loadScript.d.ts

@@ -0,0 +1,2 @@
+declare function _default(url: any, completeCallback: any): void;
+export default _default;

package/types/utils/prefersReducedMotion.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if OS prefers reduced motion
+ */
+export default function _default(): boolean;

package/types/utils/rafCallback.d.ts

@@ -0,0 +1,2 @@
+declare function _default(callback: any, fps?: number): (...passedArgs: any[]) => number;
+export default _default;

package/types/utils/zoom.d.ts

@@ -0,0 +1,4 @@
+declare namespace _default {
+    function calculate(browser: any, initial: any): any;
+}
+export default _default;