@brandocms/jupiter 5.0.0-beta.11 → 5.0.0-beta.13

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

@@ -1,5 +1,12 @@
 export default class Dataloader {
-    static replaceInnerHTML(el: any, url: any): Promise<any>;
+    /**
+     * Replace an element's innerHTML with content fetched from a URL
+     *
+     * @param {HTMLElement} el - Target element
+     * @param {string} url - URL to fetch HTML from
+     * @returns {Promise<HTMLElement>} The element with updated content
+     */
+    static replaceInnerHTML(el: HTMLElement, url: string): Promise<HTMLElement>;
     constructor(app: any, $el: any, opts?: {});
     status: string;
     app: any;
@@ -7,19 +14,28 @@ export default class Dataloader {
     id: any;
     $canvasEl: any;
     opts: any;
-    debounce(func: any, delay?: number): (...args: any[]) => void;
+    debounce(func: any, delay: any): (...args: any[]) => void;
     updateBaseURL(url: any): void;
     baseURL: any;
     setInitialParams(): void;
     initialize(): void;
     $paramEls: any;
+    _boundOnParam: any;
+    _boundOnMore: any;
+    _boundOnFilter: (...args: any[]) => void;
     urlSync: DataloaderUrlSync;
     $moreBtn: any;
     $filterInput: any;
     onFilterInput(e: any): void;
     onMore(e: any): void;
+    getParamKey(el: any): any;
+    handleCheckboxParam(el: any): void;
+    handleDeselectParam(el: any, multiVals: any): void;
+    handleMultiSelectParam(el: any): void;
+    handleSingleSelectParam(el: any): void;
     onParam(e: any): void;
     fetch(addEntries?: boolean): void;
+    _abortController: AbortController;
     /**
      * Set [data-loader-loading] on main el
      */
@@ -34,5 +50,35 @@ export default class Dataloader {
      * Sets [data-loader-starved] attribute if there is no more to fetch
      */
     updateButton(): void;
+    /**
+     * Remove all event listeners and clean up resources
+     */
+    destroy(): void;
 }
+export type DataloaderOptions = {
+    /**
+     * - Starting page index for pagination
+     */
+    page: number;
+    /**
+     * - Initial parameter key/value pairs for API requests
+     */
+    loaderParam: any;
+    /**
+     * - Initial search filter string
+     */
+    filter: string;
+    /**
+     * - Debounce delay in ms for filter input
+     */
+    filterDebounce: number;
+    /**
+     * - URL sync config keyed by loader ID
+     */
+    urlSync: any | null;
+    /**
+     * - Callback after fetch completes, receives dataloader instance
+     */
+    onFetch: Function;
+};
 import DataloaderUrlSync from './url-sync';

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

@@ -5,6 +5,7 @@ export default class FeatureTests {
         touch: () => boolean;
     };
     results: {};
+    deviceLastTouched: number;
     runTests(tests: any): void;
     testFor(feature: any, result: any): void;
     /**
@@ -17,7 +18,6 @@ export default class FeatureTests {
      * listen for events as well
      */
     testTouchMouseEvents(): void;
-    deviceLastTouched: number;
     bindEventTests(): void;
     testTouch(): boolean;
     testIE11(): boolean;

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

@@ -9,6 +9,58 @@ export default class FixedHeader {
      */
     constructor(app: any, opts?: FixedHeaderOptions);
     app: any;
+    _rawSections: {
+        [k: string]: {
+            /**
+             * - 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;
+        };
+    };
     mainOpts: any;
     el: any;
     opts: any;
@@ -69,6 +121,12 @@ export default class FixedHeader {
     getElementPhysicalHeight(el: any): number;
     getScrollY(): any;
     toleranceExceeded(): boolean;
+    /**
+     * Reconfigure the header for a new section/page.
+     * Call this after a view transition or SPA navigation
+     * to re-resolve section options and reset scroll state.
+     */
+    reconfigure(): void;
     _getOptionsForSection(section: any, opts: any): any;
     _bindMobileMenuListeners(): void;
     _onMobileMenuOpen(): void;

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

@@ -29,17 +29,40 @@ export default class Lazyload {
     imageObserver: IntersectionObserver;
     lazyImages: any;
     initObserver(observer: any, setAttrs?: boolean): void;
-    forceLoad($container?: HTMLElement): void;
+    /**
+     * Force load all lazyload elements within a container, bypassing intersection observers.
+     * Used by modules like Looper when dynamically adding content that needs immediate loading.
+     * @param {HTMLElement} [$container=document.body] - Container to search for lazyload elements
+     * @param {Object} [options]
+     * @param {boolean} [options.reveal=true] - Whether to also reveal (set data-ll-loaded) after loading
+     */
+    forceLoad($container?: HTMLElement, { reveal }?: {
+        reveal?: boolean;
+    }): void;
     initializeResizeObserver(): void;
     sizeObserver: ResizeObserver;
     flushSizeUpdates(): void;
     initializeSections(): void;
-    handleLoadEntries(elements: any): void;
-    handleRevealEntries(elements: any): void;
+    handleLoadEntries(entries: any): void;
+    handleRevealEntries(entries: any): void;
     loadPicture(picture: any): void;
-    revealPicture(picture: any): void;
-    lazyloadImages(elements: any): void;
+    /**
+     * Reveal a picture element by setting `data-ll-loaded` on its img child.
+     * @param {HTMLElement} picture - The picture element to reveal
+     */
+    revealPicture(picture: HTMLElement): void;
+    /**
+     * Swap source attributes on a picture element for the native lazyload path.
+     * Copies data-srcset to srcset on all sources and the img element.
+     * @param {HTMLElement} picture - The picture element to swap
+     */
+    swapPicture(picture: HTMLElement): void;
+    lazyloadImages(entries: any): void;
     swapImage(image: any): void;
+    /**
+     * Destroy the Lazyload instance, disconnecting all observers and freeing resources.
+     */
+    destroy(): void;
 }
 export type IntersectionObserverConfig = {
     /**
@@ -60,18 +83,10 @@ export type LazyloadOptions = {
      * - 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
      */
@@ -84,4 +99,8 @@ export type LazyloadOptions = {
      * - Whether to register a callback for APPLICATION_REVEALED event
      */
     registerCallback?: boolean;
+    /**
+     * - Container element to scope lazyloading to. Defaults to document.body
+     */
+    target?: HTMLElement | null;
 };

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

@@ -1,5 +1,39 @@
 /**
- * Moonwalk animation system for scroll-based reveal animations
+ * Normalize alphaTween config into a consistent object form.
+ * Returns a new object (never mutates the original).
+ */
+export function normalizeAlphaTween(alphaTween: any, duration: any): any;
+/**
+ * Moonwalk animation system for scroll-based reveal animations.
+ *
+ * ## HTML attributes
+ *
+ * - `data-moonwalk` / `data-moonwalk="{walkName}"` — marks an element for scroll-triggered animation
+ * - `data-moonwalk-section` / `data-moonwalk-section="{walkName}"` — groups elements; unnamed sections
+ *   animate children individually, named sections stagger-reveal all children at once
+ * - `data-moonwalk-children` / `data-moonwalk-children="{walkName}"` — converts direct children
+ *   into `data-moonwalk` (or `data-moonwalk="{walkName}"`) elements automatically
+ * - `data-moonwalk-stage="{walkName}"` — applies a walk transition to the section element itself
+ *   before its children animate (e.g. fade in a container, then reveal items)
+ * - `data-moonwalk-order="{number}"` — overrides the DOM order of children inside a named section;
+ *   elements with order are sorted first, unordered elements keep their relative position
+ * - `data-moonwalk-run="{runName}"` — standalone observer-based callback (not part of walk system)
+ * - `data-placeholder` / `data-ll-placeholder` — skip waiting for image load before tweening
+ *
+ * ## CSS-only mode
+ *
+ * Set `transition: null` on a walk to use CSS-only animations. Moonwalk will stagger-add the
+ * `data-moonwalked` attribute instead of running JS tweens. Style the reveal via CSS:
+ * ```css
+ * [data-moonwalk="fade"] { opacity: 0; transition: opacity 0.5s; }
+ * [data-moonwalk="fade"][data-moonwalked] { opacity: 1; }
+ * ```
+ *
+ * ## alphaTween
+ *
+ * Can be `true` (defaults: duration from walk, ease `'easeIn'`) or an object:
+ * `{ duration?: number, ease?: string, delay?: number }` for fine-grained control
+ * over a separate opacity animation layered on top of the main transition.
  */
 export default class Moonwalk {
     /**
@@ -11,7 +45,8 @@ export default class Moonwalk {
     app: any;
     opts: any;
     initialize(container?: HTMLElement): void;
-    sections: {
+    _observers: any[];
+    sections: any[] | {
         id: string;
         el: any;
         name: any;
@@ -28,7 +63,7 @@ export default class Moonwalk {
         };
         elements: any[];
     }[];
-    runs: {
+    runs: any[] | {
         el: Element;
         threshold: any;
         initialize: any;
@@ -38,6 +73,7 @@ export default class Moonwalk {
         repeated: any;
         rootMargin: any;
     }[];
+    _boundOnReady: any;
     /**
      * Add `moonwalk` class to html element to identify ourselves.
      */
@@ -183,12 +219,29 @@ export default class Moonwalk {
      * @param {*} duration - The duration of the animation
      */
     updateAnimationState(section: any, delay: any, duration: any): void;
+    destroy(): void;
     onReady(): void;
     /**
      * Called on `APPLICATION_READY` event, if `config.fireOnReady`.
      * Otherwise must be triggered manually
      */
     ready(): void;
+    /**
+     * Get the viewport entry direction based on current scroll direction.
+     * When entering, elements appear from the opposite side of scroll direction.
+     *
+     * @param {boolean} isEntry - Whether this is an entry (true) or exit (false)
+     * @returns {string|null}
+     */
+    getScrollDirection(isEntry: boolean): string | null;
+    /**
+     * Get the exit direction for an element, falling back to position-based
+     * detection when scroll direction is unavailable.
+     *
+     * @param {IntersectionObserverEntry} entry
+     * @returns {string|null}
+     */
+    getExitDirection(entry: IntersectionObserverEntry): string | null;
     /**
      * Creates and returns the RUN observer for data-moonwalk-run elements
      *
@@ -210,6 +263,7 @@ export default class Moonwalk {
      * @param {*} section
      * @param {*} target
      * @param {*} tweenDuration
+     * @param {*} tweenInterval
      * @param {*} tweenTransition
      * @param {*} tweenOverlap
      * @param {*} alphaTween
@@ -220,9 +274,10 @@ export default class Moonwalk {
      *
      * @param {*} section
      * @param {*} target
-     * @param {*} duration
-     * @param {*} transition
-     * @param {*} overlap
+     * @param {*} tweenDuration
+     * @param {*} tweenInterval
+     * @param {*} tweenTransition
+     * @param {*} tweenOverlap
      */
     tweenCSS(section: any, target: any, tweenDuration: any, tweenInterval: any, tweenTransition: any, tweenOverlap: any): void;
 }
@@ -236,6 +291,20 @@ export type MoonwalkTransition = {
      */
     to: any;
 };
+export type AlphaTweenConfig = {
+    /**
+     * - Duration of the alpha tween (defaults to walk duration)
+     */
+    duration?: number;
+    /**
+     * - Easing function (defaults to 'easeIn')
+     */
+    ease?: string;
+    /**
+     * - Additional delay before the alpha tween starts
+     */
+    delay?: number;
+};
 export type MoonwalkWalk = {
     /**
      * - Delay before the animation starts
@@ -250,18 +319,24 @@ export type MoonwalkWalk = {
      */
     duration?: number;
     /**
-     * - Whether to add a separate opacity tween
+     * - Whether to add a separate opacity tween. Pass `true` for defaults or an AlphaTweenConfig object for control.
      */
-    alphaTween?: boolean | any;
+    alphaTween?: boolean | AlphaTweenConfig;
     /**
-     * - The transition configuration
+     * - The transition configuration. Set to `null` for CSS-only mode (uses `data-moonwalked` attribute for CSS transitions).
      */
-    transition: MoonwalkTransition;
+    transition: MoonwalkTransition | null;
     /**
-     * - CSS selector for targeting elements in named sections
+     * - CSS selector for targeting elements in named sections (instead of using direct children)
      */
     sectionTargets?: string;
 };
+export type MoonwalkRunMeta = {
+    /**
+     * - The viewport entry/exit direction ('top', 'bottom', 'left', 'right', or null)
+     */
+    direction: string | null;
+};
 export type MoonwalkRun = {
     /**
      * - IntersectionObserver threshold
@@ -270,11 +345,11 @@ export type MoonwalkRun = {
     /**
      * - Function called when element enters viewport
      */
-    callback: Function;
+    callback: (el: HTMLElement, repeated: boolean, meta: MoonwalkRunMeta) => void;
     /**
      * - Function called when element exits viewport
      */
-    onExit?: Function;
+    onExit?: (el: HTMLElement, exited: boolean, meta: MoonwalkRunMeta) => void;
     /**
      * - Whether the run should repeat
      */
@@ -286,17 +361,17 @@ export type MoonwalkRun = {
     /**
      * - Function called during initialization
      */
-    initialize?: Function;
+    initialize?: (el: HTMLElement) => void;
     /**
      * - Function called when APPLICATION_REVEALED fires, before viewport observers start
      */
-    onReady?: Function;
+    onReady?: (el: HTMLElement) => void;
 };
 export type MoonwalkOptions = {
     /**
-     * - Event to trigger animations
+     * - Event name to trigger animations. Set to `null` to trigger manually via `ready()`.
      */
-    on?: string | Function;
+    on?: string | null;
     /**
      * - Delay before starting animations
      */
@@ -346,7 +421,7 @@ export type MoonwalkOptions = {
     /**
      * - Walk configurations
      */
-    walks: {
+    walks?: {
         [x: string]: MoonwalkWalk;
     };
 };