@brandocms/jupiter 3.55.0 → 4.0.0-beta.2

package/types/README.md

@@ -0,0 +1,159 @@
+# Jupiter TypeScript Definitions
+
+This directory contains TypeScript declaration files (.d.ts) for Jupiter modules.
+
+## Using Type Definitions
+
+When importing Jupiter modules, you'll get autocomplete and type checking for options:
+
+```javascript
+import { Moonwalk } from '@brandocms/jupiter';
+
+// Options object will have autocomplete
+const moonwalk = new Moonwalk(app, {
+  clearNestedSections: true,
+  rootMargin: '-5% 0%',
+  walks: {
+    // Autocomplete for walk properties
+    default: {
+      interval: 0.1,
+      duration: 0.5
+    }
+  }
+});
+```
+
+## Available Typed Modules
+
+The following modules have TypeScript definitions:
+
+### Core Modules
+- **Application** - Main application controller
+- **Breakpoints** - Responsive design and media query handling
+- **Dom** - DOM utility functions
+
+### Media Modules
+- **Lazyload** - Image lazy loading functionality
+- **Lightbox** - Image gallery overlay
+- **HeroVideo** - Background video with controls
+
+### Navigation and UI Modules
+- **Links** - Navigation and page transitions
+- **Popup** - Modal dialogs and popups
+- **Toggler** - Show/hide component for collapsible content
+
+### Animation Modules
+- **Parallax** - Parallax scrolling effect for background images
+- **Moonwalk** - Animation system for element reveals
+
+## Adding Type Definitions for a New Module
+
+1. **Create JSDoc annotations** in your source file (src/modules/YourModule/index.js):
+
+```javascript
+/**
+ * @typedef {Object} YourModuleOptions
+ * @property {boolean} [someOption=false] - Description of the option
+ * @property {number} [anotherOption=10] - Description of another option
+ */
+
+/** @type {YourModuleOptions} */
+const DEFAULT_OPTIONS = {
+  someOption: false,
+  anotherOption: 10
+};
+
+/**
+ * Your module description
+ */
+export default class YourModule {
+  /**
+   * @param {Object} app - Application instance
+   * @param {YourModuleOptions} [opts={}] - Configuration options
+   */
+  constructor(app, opts = {}) {
+    // ...
+  }
+  
+  /**
+   * @param {string} someParam - Parameter description
+   * @returns {boolean} Return value description
+   */
+  someMethod(someParam) {
+    // ...
+  }
+}
+```
+
+2. **Create a TypeScript declaration file** in types/modules/YourModule/index.d.ts:
+
+```typescript
+/**
+ * Types for YourModule
+ */
+import Application from '../Application';
+
+/**
+ * YourModule options
+ */
+export interface YourModuleOptions {
+  /** Description of the option */
+  someOption?: boolean;
+  
+  /** Description of another option */
+  anotherOption?: number;
+}
+
+/**
+ * Your module description
+ */
+export default class YourModule {
+  /** Application instance */
+  app: Application;
+  
+  /** Module options */
+  opts: YourModuleOptions;
+  
+  /**
+   * Create a new YourModule instance
+   * @param app - Application instance
+   * @param opts - YourModule options
+   */
+  constructor(app: Application, opts?: Partial<YourModuleOptions>);
+  
+  /**
+   * Method description
+   * @param someParam - Parameter description
+   * @returns Return value description
+   */
+  someMethod(someParam: string): boolean;
+}
+```
+
+3. **Update the main index.d.ts file** to export your new module:
+
+```typescript
+export {
+  default as YourModule,
+  YourModuleOptions
+} from './modules/YourModule';
+```
+
+Place this export in the appropriate section (Core, Media, Navigation/UI, or Animation).
+
+## Typing Guidelines
+
+- Use `Partial<Options>` for optional constructor parameters
+- Use descriptive JSDoc comments for all properties and methods
+- Group related interfaces together (e.g., options and element interfaces)
+- Always import `Application` from '../Application'
+- Use consistent naming patterns:
+  - `ModuleOptions` for options interfaces
+  - `ModuleElements` for element collections
+  - Use camelCase for methods and properties
+
+## Running Type Checking
+
+Run `yarn types` to generate and check type definitions.
+
+If there are errors, don't worry about typechecking passing completely. The primary goal is to provide autocomplete and documentation for developers.

package/types/events/index.d.ts

@@ -0,0 +1,20 @@
+export const APPLICATION_MOBILE_MENU_OPEN: "APPLICATION:MOBILE_MENU:OPEN";
+export const APPLICATION_MOBILE_MENU_CLOSED: "APPLICATION:MOBILE_MENU:CLOSED";
+export const APPLICATION_PRELUDIUM: "APPLICATION_PRELUDIUM";
+export const APPLICATION_INITIALIZED: "APPLICATION:INITIALIZED";
+export const APPLICATION_READY: "APPLICATION:READY";
+export const APPLICATION_REVEALED: "APPLICATION:REVEALED";
+export const APPLICATION_RESIZE: "APPLICATION:RESIZE";
+export const APPLICATION_SCROLL: "APPLICATION:SCROLL";
+export const APPLICATION_SCROLL_LOCKED: "APPLICATION:SCROLL_LOCKED";
+export const APPLICATION_SCROLL_RELEASED: "APPLICATION:SCROLL_RELEASED";
+export const APPLICATION_FORCED_SCROLL_START: "APPLICATION:FORCED_SCROLL_START";
+export const APPLICATION_FORCED_SCROLL_END: "APPLICATION:FORCED_SCROLL_END";
+export const APPLICATION_OUTLINE: "APPLICATION:OUTLINE";
+export const APPLICATION_VISIBILITY_CHANGE: "APPLICATION:VISIBILITY_CHANGE";
+export const APPLICATION_HIDDEN: "APPLICATION:HIDDEN";
+export const APPLICATION_VISIBLE: "APPLICATION:VISIBLE";
+export const BREAKPOINT_CHANGE: "BREAKPOINT:CHANGE";
+export const IMAGE_LAZYLOADED: "IMAGE:LAZYLOADED";
+export const IMAGE_REVEALED: "IMAGE:REVEALED";
+export const SECTION_LAZYLOADED: "SECTION:LAZYLOADED";

package/types/index.d.ts

@@ -0,0 +1,6 @@
+import imageIsLoaded from './utils/imageIsLoaded';
+import imagesAreLoaded from './utils/imagesAreLoaded';
+import loadScript from './utils/loadScript';
+import prefersReducedMotion from './utils/prefersReducedMotion';
+import rafCallback from './utils/rafCallback';
+export { Application, Breakpoints, Cookies, CoverOverlay, Dataloader, Dom, DoubleHeader, Draggable, Dropdown, EqualHeightElements, EqualHeightImages, Events, FixedHeader, FooterReveal, Parallax, HeroSlider, HeroVideo, Lazyload, Lightbox, Links, Looper, Marquee, MobileMenu, Moonwalk, Popover, Popup, ScrollSpy, StackedBoxes, StickyHeader, Toggler, Typography, imageIsLoaded, imagesAreLoaded, loadScript, prefersReducedMotion, rafCallback, _defaultsDeep, gsap, CSSPlugin, ScrollToPlugin, ScrollTrigger, SplitText, InertiaPlugin };

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

@@ -0,0 +1,168 @@
+export default class Application {
+    constructor(opts?: {});
+    debugType: number;
+    debugOverlay: Element;
+    userAgent: string;
+    _lastWindowHeight: number;
+    breakpoint: any;
+    language: string;
+    size: {
+        width: number;
+        height: number;
+        initialInnerHeight: number;
+        initialOuterHeight: number;
+        initialInnerWidth: number;
+        initialOuterWidth: number;
+        zoom: number;
+    };
+    position: {
+        top: number;
+        left: number;
+        lastTop: number;
+        lastLeft: number;
+    };
+    state: {
+        revealed: boolean;
+        forcedScroll: boolean;
+        scrollDirection: any;
+    };
+    opts: any;
+    focusableSelectors: any;
+    featureTests: any;
+    breakpoints: any;
+    fontLoader: any;
+    fader: any;
+    callbacks: {};
+    SCROLL_LOCKED: boolean;
+    SCROLLBAR_WIDTH: number;
+    INITIALIZED: boolean;
+    PREFERS_REDUCED_MOTION: boolean;
+    beforeInitializedEvent: CustomEvent<any>;
+    initializedEvent: CustomEvent<any>;
+    readyEvent: CustomEvent<any>;
+    revealedEvent: CustomEvent<any>;
+    /**
+     * Main init. Called from client application on DOMReady.
+     */
+    initialize(): void;
+    /**
+     * Application is initialized and ready.
+     * Fade in, then execute callbacks
+     */
+    ready(): void;
+    getZoom(): void;
+    _lastDevicePixelRatio: number;
+    _initialZoom: any;
+    _zoomSVG: SVGSVGElement;
+    zoomCalculateChrome(dimsChanged: any): void;
+    zoomCalculateSafari(): void;
+    updateZoom(dimsChanged?: boolean, dprDelta?: number): void;
+    /**
+     * Fade in application, as declared in the `faderOpts`
+     */
+    fadeIn(): void;
+    /**
+     * Register callbacks by `type`
+     */
+    registerCallback(type: any, callback: any): void;
+    /**
+     * Execute callbacks by `type`
+     */
+    executeCallbacks(type: any): void;
+    /**
+     * Set section
+     */
+    setSection(): void;
+    section: string;
+    /**
+     * Check if document is scrolled
+     */
+    isScrolled(): boolean;
+    /**
+     * Locks body scroll
+     * `extraPaddedElements` can be a list of elements that also need padding, such as the header!
+     * @param {*} extraPaddedElements
+     */
+    scrollLock(extraPaddedElements?: any): void;
+    _scrollPaddedElements: any[];
+    scrollRelease(defaultOverflow?: string): void;
+    /**
+     *
+     * @param {*} target
+     * this can be an object too if you want to override scrollTo: `{y: "#someID", offsetY: 50}`
+     * @param {*} time
+     * @param {*} emitEvents
+     */
+    scrollTo(target: any, time?: any, emitEvents?: any, ease?: string): void;
+    hardScrollToTop(): void;
+    hardScrollTo(target: any): void;
+    scrollVoid(e: any): void;
+    /**
+     * Get current scrollbar width — if there is none, there is none
+     */
+    getCurrentScrollBarWidth(): number;
+    /**
+     * Get scrollbar width by FORCE. No matter if there is
+     * currently a scrollbar or not
+     */
+    getScrollBarWidth(): void;
+    /**
+     * Ugly hacks
+     */
+    hacks(): void;
+    getIOSCurrentInnerHeight(): number;
+    getIOSInnerHeightMax(): number;
+    /**
+     * Event emitters
+     */
+    _emitBeforeInitializedEvent(): void;
+    _emitInitializedEvent(): void;
+    _emitReadyEvent(): void;
+    _emitRevealedEvent(): void;
+    _getBaseVW(): string;
+    setDims(): void;
+    setFontBaseVw(): void;
+    setZoom(): void;
+    /**
+     * Inner height of mobiles may change when showing hiding bottom bar.
+     */
+    setvh100(): void;
+    setvw100(): void;
+    /**
+     * Get the max 100vh for iOS
+     */
+    setvh100Max(): void;
+    setScrollHeight(): void;
+    onBreakpointChanged(): void;
+    /**
+     * RAF'ed resize event
+     */
+    onResize(e: any): void;
+    /**
+     * RAF'ed scroll event
+     */
+    onScroll(e: any): void;
+    onVisibilityChange(e: any): void;
+    pollForElement(selector: any, time?: number, callback?: () => void): void;
+    pollForVar(variable: any, time?: number, callback?: () => void): void;
+    setupDebug(): void;
+    toggleDebug(): void;
+    /**
+     * CTRL-G to show grid overlay
+     */
+    setupGridoverlay(): void;
+    /**
+     * Add in extra selectors that are focusable
+     * @param {array} extraSelectors
+     */
+    addFocusableSelectors(extraSelectors: any[]): void;
+    /**
+     * Set focusable selectors. Replaces default array.
+     * @param {array} selectors
+     */
+    setFocusableSelectors(selectors: any[]): void;
+    /**
+     * Returns focusable selectors as a comma separated list
+     */
+    getFocusableSelectors(): any;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Breakpoints module for responsive design
+ */
+export default class Breakpoints {
+    /**
+     * Create a new Breakpoints instance
+     * @param {Object} app - Application instance
+     * @param {BreakpointsOptions} [opts={}] - Breakpoints options
+     */
+    constructor(app: any, opts?: BreakpointsOptions);
+    app: any;
+    mediaQueries: {};
+    opts: any;
+    currentBreakpoint: string;
+    initialized: boolean;
+    initialize(reveal?: boolean): void;
+    getCurrentBreakpoint(): {
+        key: string;
+        mq: any;
+    };
+    defaultListener(e: any): void;
+    setCurrentBreakpoint(): void;
+    _getVal(key: any): string;
+}
+export type BreakpointsOptions = {
+    /**
+     * - Whether to run listener on initialization
+     */
+    runListenerOnInit?: boolean;
+    /**
+     * - Breakpoint names
+     */
+    breakpoints?: string[];
+    /**
+     * - Listener functions for breakpoints
+     */
+    listeners?: {
+        [x: string]: Function;
+    };
+};

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

@@ -0,0 +1,81 @@
+/**
+ * Cookies module for handling cookie consent
+ */
+export default class Cookies {
+    /**
+     * Create a new Cookies instance
+     * @param {Object} app - Application instance
+     * @param {CookiesOptions} [opts={}] - Cookies options
+     */
+    constructor(app: any, opts?: CookiesOptions);
+    app: any;
+    opts: any;
+    cc: Element;
+    inner: Element;
+    text: Element;
+    btns: Element;
+    btn: Element;
+    btnRefuse: Element;
+    /**
+     * Get a cookie value by key
+     * @param {string} sKey - Cookie key
+     * @returns {string|null} Cookie value or null if not found
+     */
+    getCookie(sKey: string): string | null;
+    /**
+     * Set a cookie
+     * @param {string} sKey - Cookie key
+     * @param {string|number} sValue - Cookie value
+     * @param {Date|string|number} vEnd - Expiration date, string date, or max age in seconds
+     * @param {string} [sPath] - Cookie path
+     * @param {string} [sDomain] - Cookie domain
+     * @param {boolean} [bSecure] - Secure flag
+     * @returns {boolean} Whether cookie was set successfully
+     */
+    setCookie(sKey: string, sValue: string | number, vEnd: Date | string | number, sPath?: string, sDomain?: string, bSecure?: boolean): boolean;
+    /**
+     * Remove a cookie
+     * @param {string} sKey - Cookie key
+     * @param {string} [sPath] - Cookie path
+     * @param {string} [sDomain] - Cookie domain
+     * @returns {boolean} Whether cookie was removed successfully
+     */
+    removeCookie(sKey: string, sPath?: string, sDomain?: string): boolean;
+    /**
+     * Check if a cookie exists
+     * @param {string} sKey - Cookie key
+     * @returns {boolean} Whether cookie exists
+     */
+    hasCookie(sKey: string): boolean;
+    /**
+     * Get all cookie keys
+     * @returns {string[]} Array of cookie keys
+     */
+    keys(): string[];
+}
+export type CookiesOptions = {
+    /**
+     * - Called when cookies are accepted
+     */
+    onAccept?: Function;
+    /**
+     * - Called when cookies are refused
+     */
+    onRefuse?: Function;
+    /**
+     * - Called if user has already consented to cookies
+     */
+    alreadyConsented?: Function;
+    /**
+     * - Called if user has already refused cookies
+     */
+    alreadyRefused?: Function;
+    /**
+     * - Custom function to set cookies
+     */
+    setCookies?: Function;
+    /**
+     * - Custom function to display cookie consent dialog
+     */
+    showCC?: Function;
+};

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

@@ -0,0 +1,6 @@
+export default class CoverOverlay {
+    constructor(app: any, opts?: {});
+    app: any;
+    opts: any;
+    initialize(): void;
+}

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

@@ -0,0 +1,38 @@
+export default class Dataloader {
+    static replaceInnerHTML(el: any, url: any): Promise<any>;
+    constructor(app: any, $el: any, opts?: {});
+    status: string;
+    app: any;
+    $el: any;
+    id: any;
+    $canvasEl: any;
+    opts: any;
+    debounce(func: any, delay?: number): (...args: any[]) => void;
+    updateBaseURL(url: any): void;
+    baseURL: any;
+    setInitialParams(): void;
+    initialize(): void;
+    $paramEls: any;
+    urlSync: DataloaderUrlSync;
+    $moreBtn: any;
+    $filterInput: any;
+    onFilterInput(e: any): void;
+    onMore(e: any): void;
+    onParam(e: any): void;
+    fetch(addEntries?: boolean): void;
+    /**
+     * Set [data-loader-loading] on main el
+     */
+    loading(): void;
+    /**
+     * Remove [data-loader-loading] on main el
+     */
+    complete(): void;
+    /**
+     * Update the MORE button
+     *
+     * Sets [data-loader-starved] attribute if there is no more to fetch
+     */
+    updateButton(): void;
+}
+import DataloaderUrlSync from './url-sync';

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

@@ -0,0 +1,47 @@
+declare const _default: DOM;
+export default _default;
+/**
+ * DOM utility class for simplifying DOM operations
+ */
+declare class DOM {
+    body: HTMLElement;
+    html: HTMLElement;
+    "new"(arg: any): ChildNode[];
+    find(arg1: any, arg2: any): any;
+    all(arg1: any, arg2: any): any[];
+    create(element: any, ...classes: any[]): any;
+    append(element: any): void;
+    remove(element: any): void;
+    addClass(element: any, ...classes: any[]): any;
+    removeClass(element: any, ...classes: any[]): any;
+    hasClass(element: any, className: any): any;
+    toggleClass(element: any, ...classes: any[]): any[];
+    hasAttribute(element: any, attributeName: any): any;
+    overlapsVertically($div1: any, $div2: any): number;
+    outerHeight(el: any): any;
+    outerWidth(el: any): any;
+    getCSSVar(key: any, element?: HTMLElement): string;
+    setCSSVar(key: any, val: any, element?: HTMLElement): void;
+    removeCSSVar(key: any, element?: HTMLElement): void;
+    offset(el: any): {
+        top: any;
+        left: any;
+    };
+    position(el: any): {
+        top: any;
+        left: any;
+    };
+    /**
+     * Check if parts of `el` is in viewport
+     *
+     * @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

@@ -0,0 +1,15 @@
+export default class Dropdown {
+    constructor(app: any, opts?: {});
+    app: any;
+    opts: any;
+    elements: {};
+    open: boolean;
+    element: any;
+    timeline: any;
+    handleDocumentClick(event: any): void;
+    initialize(): void;
+    onClick(event: any): Promise<void>;
+    openMenu(): Promise<void>;
+    closeMenu(): Promise<void>;
+    checkForInitialOpen(): void;
+}

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

@@ -0,0 +1,8 @@
+export default class EqualHeightElements {
+    constructor(app: any, selector: any, opts?: {}, container?: HTMLElement);
+    app: any;
+    container: HTMLElement;
+    opts: any;
+    selector: any;
+    initialize(): void;
+}