@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/carousel/plugins/auto-scroll/AutoScroll.js

@@ -0,0 +1,185 @@
+// Ported from embla-carousel (packages/embla-carousel-auto-scroll/src/components/AutoScroll.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts, formatting; `'embla-carousel'` imports / module augmentation → `../../engine/` files; otherwise verbatim.
+import { defaultOptions } from "./Options.js";
+import { getAutoScrollRootNode } from "./utils.js";
+function AutoScroll(userOptions = {}) {
+    let options;
+    let emblaApi;
+    let destroyed;
+    let startDelay;
+    let timerId = 0;
+    let autoScrollActive = false;
+    let mouseIsOver = false;
+    let defaultScrollBehaviour;
+    function init(emblaApiInstance, optionsHandler) {
+        emblaApi = emblaApiInstance;
+        const { mergeOptions, optionsAtMedia } = optionsHandler;
+        const optionsBase = mergeOptions(defaultOptions, AutoScroll.globalOptions);
+        const allOptions = mergeOptions(optionsBase, userOptions);
+        options = optionsAtMedia(allOptions);
+        if (emblaApi.scrollSnapList().length <= 1)
+            return;
+        startDelay = options.startDelay;
+        destroyed = false;
+        defaultScrollBehaviour = emblaApi.internalEngine().scrollBody;
+        const { eventStore } = emblaApi.internalEngine();
+        const isDraggable = !!emblaApi.internalEngine().options.watchDrag;
+        const root = getAutoScrollRootNode(emblaApi, options.rootNode);
+        if (isDraggable) {
+            emblaApi.on("pointerDown", pointerDown);
+        }
+        if (isDraggable && !options.stopOnInteraction) {
+            emblaApi.on("pointerUp", pointerUp);
+        }
+        if (options.stopOnMouseEnter) {
+            eventStore.add(root, "mouseenter", mouseEnter);
+        }
+        if (options.stopOnMouseEnter && !options.stopOnInteraction) {
+            eventStore.add(root, "mouseleave", mouseLeave);
+        }
+        if (options.stopOnFocusIn) {
+            emblaApi.on("slideFocusStart", stopAutoScroll);
+        }
+        if (options.stopOnFocusIn && !options.stopOnInteraction) {
+            eventStore.add(emblaApi.containerNode(), "focusout", startAutoScroll);
+        }
+        if (options.playOnInit)
+            startAutoScroll();
+    }
+    function destroy() {
+        emblaApi.off("pointerDown", pointerDown).off("pointerUp", pointerUp).off("slideFocusStart", stopAutoScroll).off("settle", settle);
+        stopAutoScroll();
+        destroyed = true;
+        autoScrollActive = false;
+    }
+    function startAutoScroll() {
+        if (destroyed)
+            return;
+        if (autoScrollActive)
+            return;
+        emblaApi.emit("autoScroll:play");
+        const engine = emblaApi.internalEngine();
+        const { ownerWindow } = engine;
+        timerId = ownerWindow.setTimeout(() => {
+            engine.scrollBody = createAutoScrollBehaviour(engine);
+            engine.animation.start();
+        }, startDelay);
+        autoScrollActive = true;
+    }
+    function stopAutoScroll() {
+        if (destroyed)
+            return;
+        if (!autoScrollActive)
+            return;
+        emblaApi.emit("autoScroll:stop");
+        const engine = emblaApi.internalEngine();
+        const { ownerWindow } = engine;
+        engine.scrollBody = defaultScrollBehaviour;
+        ownerWindow.clearTimeout(timerId);
+        timerId = 0;
+        autoScrollActive = false;
+    }
+    function createAutoScrollBehaviour(engine) {
+        const { location, previousLocation, offsetLocation, target, scrollTarget, index, indexPrevious, limit: { reachedMin, reachedMax, constrain }, options: { loop }, } = engine;
+        const directionSign = options.direction === "forward" ? -1 : 1;
+        const noop = () => self;
+        let bodyVelocity = 0;
+        let scrollDirection = 0;
+        let rawLocation = location.get();
+        let rawLocationPrevious = 0;
+        let hasSettled = false;
+        function seek() {
+            let directionDiff = 0;
+            previousLocation.set(location);
+            bodyVelocity = directionSign * options.speed;
+            rawLocation += bodyVelocity;
+            location.add(bodyVelocity);
+            target.set(location);
+            directionDiff = rawLocation - rawLocationPrevious;
+            scrollDirection = Math.sign(directionDiff);
+            rawLocationPrevious = rawLocation;
+            const currentIndex = scrollTarget.byDistance(0, false).index;
+            if (index.get() !== currentIndex) {
+                indexPrevious.set(index.get());
+                index.set(currentIndex);
+                emblaApi.emit("select");
+            }
+            const reachedEnd = options.direction === "forward" ? reachedMin(offsetLocation.get()) : reachedMax(offsetLocation.get());
+            if (!loop && reachedEnd) {
+                hasSettled = true;
+                const constrainedLocation = constrain(location.get());
+                location.set(constrainedLocation);
+                target.set(location);
+                stopAutoScroll();
+            }
+            return self;
+        }
+        const self = {
+            direction: () => scrollDirection,
+            duration: () => -1,
+            velocity: () => bodyVelocity,
+            settled: () => hasSettled,
+            seek,
+            useBaseFriction: noop,
+            useBaseDuration: noop,
+            useFriction: noop,
+            useDuration: noop,
+        };
+        return self;
+    }
+    function pointerDown() {
+        if (!mouseIsOver)
+            stopAutoScroll();
+    }
+    function pointerUp() {
+        if (!mouseIsOver)
+            startAutoScrollOnSettle();
+    }
+    function mouseEnter() {
+        mouseIsOver = true;
+        stopAutoScroll();
+    }
+    function mouseLeave() {
+        mouseIsOver = false;
+        startAutoScroll();
+    }
+    function settle() {
+        emblaApi.off("settle", settle);
+        startAutoScroll();
+    }
+    function startAutoScrollOnSettle() {
+        emblaApi.on("settle", settle);
+    }
+    function play(startDelayOverride) {
+        if (typeof startDelayOverride !== "undefined") {
+            startDelay = startDelayOverride;
+        }
+        startAutoScroll();
+    }
+    function stop() {
+        if (autoScrollActive)
+            stopAutoScroll();
+    }
+    function reset() {
+        if (autoScrollActive) {
+            stopAutoScroll();
+            startAutoScrollOnSettle();
+        }
+    }
+    function isPlaying() {
+        return autoScrollActive;
+    }
+    const self = {
+        name: "autoScroll",
+        options: userOptions,
+        init,
+        destroy,
+        play,
+        stop,
+        reset,
+        isPlaying,
+    };
+    return self;
+}
+AutoScroll.globalOptions = undefined;
+export default AutoScroll;

package/carousel/plugins/auto-scroll/Options.d.ts

@@ -0,0 +1,13 @@
+import type { CreateOptionsType } from "../../engine/index.js";
+export type RootNodeType = null | ((emblaRoot: HTMLElement) => HTMLElement | null);
+export type OptionsType = CreateOptionsType<{
+    direction: "forward" | "backward";
+    speed: number;
+    startDelay: number;
+    playOnInit: boolean;
+    stopOnFocusIn: boolean;
+    stopOnInteraction: boolean;
+    stopOnMouseEnter: boolean;
+    rootNode: RootNodeType;
+}>;
+export declare const defaultOptions: OptionsType;

package/carousel/plugins/auto-scroll/Options.js

@@ -0,0 +1,12 @@
+export const defaultOptions = {
+    direction: "forward",
+    speed: 2,
+    startDelay: 1000,
+    active: true,
+    breakpoints: {},
+    playOnInit: true,
+    stopOnFocusIn: true,
+    stopOnInteraction: true,
+    stopOnMouseEnter: false,
+    rootNode: null,
+};

package/carousel/plugins/auto-scroll/index.d.ts

@@ -0,0 +1,2 @@
+export type { AutoScrollType, AutoScrollOptionsType } from "./AutoScroll.js";
+export { default, default as AutoScroll } from "./AutoScroll.js";

package/carousel/plugins/auto-scroll/index.js

@@ -0,0 +1 @@
+export { default, default as AutoScroll } from "./AutoScroll.js";

package/carousel/plugins/auto-scroll/utils.d.ts

@@ -0,0 +1,3 @@
+import type { EmblaCarouselType } from "../../engine/index.js";
+import type { RootNodeType } from "./Options.js";
+export declare function getAutoScrollRootNode(emblaApi: EmblaCarouselType, rootNode: RootNodeType): HTMLElement;

package/carousel/plugins/auto-scroll/utils.js

@@ -0,0 +1,4 @@
+export function getAutoScrollRootNode(emblaApi, rootNode) {
+    const emblaRootNode = emblaApi.rootNode();
+    return (rootNode && rootNode(emblaRootNode)) || emblaRootNode;
+}

package/carousel/plugins/autoplay/Autoplay.d.ts

@@ -0,0 +1,29 @@
+import { type OptionsType } from "./Options.js";
+import type { CreatePluginType } from "../../engine/index.js";
+declare module "../../engine/Plugins.ts" {
+    interface EmblaPluginsType {
+        autoplay: AutoplayType;
+    }
+}
+declare module "../../engine/EventHandler.ts" {
+    interface EmblaEventListType {
+        autoplayPlay: "autoplay:play";
+        autoplayStop: "autoplay:stop";
+        autoplaySelect: "autoplay:select";
+        autoplayTimerSet: "autoplay:timerset";
+        autoplayTimerStopped: "autoplay:timerstopped";
+    }
+}
+export type AutoplayType = CreatePluginType<{
+    play: (jump?: boolean) => void;
+    stop: () => void;
+    reset: () => void;
+    isPlaying: () => boolean;
+    timeUntilNext: () => number | null;
+}, OptionsType>;
+export type AutoplayOptionsType = AutoplayType["options"];
+declare function Autoplay(userOptions?: AutoplayOptionsType): AutoplayType;
+declare namespace Autoplay {
+    let globalOptions: AutoplayOptionsType | undefined;
+}
+export default Autoplay;

package/carousel/plugins/autoplay/Autoplay.js

@@ -0,0 +1,173 @@
+// Ported from embla-carousel (packages/embla-carousel-autoplay/src/components/Autoplay.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts, formatting; `'embla-carousel'` imports / module augmentation → `../../engine/` files; otherwise verbatim.
+import { defaultOptions } from "./Options.js";
+import { getAutoplayRootNode, normalizeDelay } from "./utils.js";
+function Autoplay(userOptions = {}) {
+    let options;
+    let emblaApi;
+    let destroyed;
+    let delay;
+    let timerStartTime = null;
+    let timerId = 0;
+    let autoplayActive = false;
+    let mouseIsOver = false;
+    let playOnDocumentVisible = false;
+    let jump = false;
+    function init(emblaApiInstance, optionsHandler) {
+        emblaApi = emblaApiInstance;
+        const { mergeOptions, optionsAtMedia } = optionsHandler;
+        const optionsBase = mergeOptions(defaultOptions, Autoplay.globalOptions);
+        const allOptions = mergeOptions(optionsBase, userOptions);
+        options = optionsAtMedia(allOptions);
+        if (emblaApi.scrollSnapList().length <= 1)
+            return;
+        jump = options.jump;
+        destroyed = false;
+        delay = normalizeDelay(emblaApi, options.delay);
+        const { eventStore, ownerDocument } = emblaApi.internalEngine();
+        const isDraggable = !!emblaApi.internalEngine().options.watchDrag;
+        const root = getAutoplayRootNode(emblaApi, options.rootNode);
+        eventStore.add(ownerDocument, "visibilitychange", visibilityChange);
+        if (isDraggable) {
+            emblaApi.on("pointerDown", pointerDown);
+        }
+        if (isDraggable && !options.stopOnInteraction) {
+            emblaApi.on("pointerUp", pointerUp);
+        }
+        if (options.stopOnMouseEnter) {
+            eventStore.add(root, "mouseenter", mouseEnter);
+        }
+        if (options.stopOnMouseEnter && !options.stopOnInteraction) {
+            eventStore.add(root, "mouseleave", mouseLeave);
+        }
+        if (options.stopOnFocusIn) {
+            emblaApi.on("slideFocusStart", stopAutoplay);
+        }
+        if (options.stopOnFocusIn && !options.stopOnInteraction) {
+            eventStore.add(emblaApi.containerNode(), "focusout", startAutoplay);
+        }
+        if (options.playOnInit)
+            startAutoplay();
+    }
+    function destroy() {
+        emblaApi.off("pointerDown", pointerDown).off("pointerUp", pointerUp).off("slideFocusStart", stopAutoplay);
+        stopAutoplay();
+        destroyed = true;
+        autoplayActive = false;
+    }
+    function setTimer() {
+        const { ownerWindow } = emblaApi.internalEngine();
+        ownerWindow.clearTimeout(timerId);
+        timerId = ownerWindow.setTimeout(next, delay[emblaApi.selectedScrollSnap()]);
+        timerStartTime = new Date().getTime();
+        emblaApi.emit("autoplay:timerset");
+    }
+    function clearTimer() {
+        const { ownerWindow } = emblaApi.internalEngine();
+        ownerWindow.clearTimeout(timerId);
+        timerId = 0;
+        timerStartTime = null;
+        emblaApi.emit("autoplay:timerstopped");
+    }
+    function startAutoplay() {
+        if (destroyed)
+            return;
+        if (documentIsHidden()) {
+            playOnDocumentVisible = true;
+            return;
+        }
+        if (!autoplayActive)
+            emblaApi.emit("autoplay:play");
+        setTimer();
+        autoplayActive = true;
+    }
+    function stopAutoplay() {
+        if (destroyed)
+            return;
+        if (autoplayActive)
+            emblaApi.emit("autoplay:stop");
+        clearTimer();
+        autoplayActive = false;
+    }
+    function visibilityChange() {
+        if (documentIsHidden()) {
+            playOnDocumentVisible = autoplayActive;
+            return stopAutoplay();
+        }
+        if (playOnDocumentVisible)
+            startAutoplay();
+    }
+    function documentIsHidden() {
+        const { ownerDocument } = emblaApi.internalEngine();
+        return ownerDocument.visibilityState === "hidden";
+    }
+    function pointerDown() {
+        if (!mouseIsOver)
+            stopAutoplay();
+    }
+    function pointerUp() {
+        if (!mouseIsOver)
+            startAutoplay();
+    }
+    function mouseEnter() {
+        mouseIsOver = true;
+        stopAutoplay();
+    }
+    function mouseLeave() {
+        mouseIsOver = false;
+        startAutoplay();
+    }
+    function play(jumpOverride) {
+        if (typeof jumpOverride !== "undefined")
+            jump = jumpOverride;
+        startAutoplay();
+    }
+    function stop() {
+        if (autoplayActive)
+            stopAutoplay();
+    }
+    function reset() {
+        if (autoplayActive)
+            startAutoplay();
+    }
+    function isPlaying() {
+        return autoplayActive;
+    }
+    function next() {
+        const { index } = emblaApi.internalEngine();
+        const nextIndex = index.clone().add(1).get();
+        const lastIndex = emblaApi.scrollSnapList().length - 1;
+        const kill = options.stopOnLastSnap && nextIndex === lastIndex;
+        if (emblaApi.canScrollNext()) {
+            emblaApi.scrollNext(jump);
+        }
+        else {
+            emblaApi.scrollTo(0, jump);
+        }
+        emblaApi.emit("autoplay:select");
+        if (kill)
+            return stopAutoplay();
+        startAutoplay();
+    }
+    function timeUntilNext() {
+        if (!timerStartTime)
+            return null;
+        const currentDelay = delay[emblaApi.selectedScrollSnap()];
+        const timePastSinceStart = new Date().getTime() - timerStartTime;
+        return currentDelay - timePastSinceStart;
+    }
+    const self = {
+        name: "autoplay",
+        options: userOptions,
+        init,
+        destroy,
+        play,
+        stop,
+        reset,
+        isPlaying,
+        timeUntilNext,
+    };
+    return self;
+}
+Autoplay.globalOptions = undefined;
+export default Autoplay;

package/carousel/plugins/autoplay/Options.d.ts

@@ -0,0 +1,14 @@
+import type { CreateOptionsType, EmblaCarouselType } from "../../engine/index.js";
+export type DelayOptionType = number | ((scrollSnaps: number[], emblaApi: EmblaCarouselType) => number[]);
+export type RootNodeType = null | ((emblaRoot: HTMLElement) => HTMLElement | null);
+export type OptionsType = CreateOptionsType<{
+    delay: DelayOptionType;
+    jump: boolean;
+    playOnInit: boolean;
+    stopOnFocusIn: boolean;
+    stopOnInteraction: boolean;
+    stopOnMouseEnter: boolean;
+    stopOnLastSnap: boolean;
+    rootNode: RootNodeType;
+}>;
+export declare const defaultOptions: OptionsType;

package/carousel/plugins/autoplay/Options.js

@@ -0,0 +1,12 @@
+export const defaultOptions = {
+    active: true,
+    breakpoints: {},
+    delay: 4000,
+    jump: false,
+    playOnInit: true,
+    stopOnFocusIn: true,
+    stopOnInteraction: true,
+    stopOnMouseEnter: false,
+    stopOnLastSnap: false,
+    rootNode: null,
+};

package/carousel/plugins/autoplay/index.d.ts

@@ -0,0 +1,2 @@
+export type { AutoplayType, AutoplayOptionsType } from "./Autoplay.js";
+export { default, default as Autoplay } from "./Autoplay.js";

package/carousel/plugins/autoplay/index.js

@@ -0,0 +1 @@
+export { default, default as Autoplay } from "./Autoplay.js";

package/carousel/plugins/autoplay/utils.d.ts

@@ -0,0 +1,4 @@
+import type { EmblaCarouselType } from "../../engine/index.js";
+import type { DelayOptionType, RootNodeType } from "./Options.js";
+export declare function normalizeDelay(emblaApi: EmblaCarouselType, delay: DelayOptionType): number[];
+export declare function getAutoplayRootNode(emblaApi: EmblaCarouselType, rootNode: RootNodeType): HTMLElement;

package/carousel/plugins/autoplay/utils.js

@@ -0,0 +1,11 @@
+export function normalizeDelay(emblaApi, delay) {
+    const scrollSnaps = emblaApi.scrollSnapList();
+    if (typeof delay === "number") {
+        return scrollSnaps.map(() => delay);
+    }
+    return delay(scrollSnaps, emblaApi);
+}
+export function getAutoplayRootNode(emblaApi, rootNode) {
+    const emblaRootNode = emblaApi.rootNode();
+    return (rootNode && rootNode(emblaRootNode)) || emblaRootNode;
+}

package/carousel/plugins/class-names/ClassNames.d.ts

@@ -0,0 +1,14 @@
+import { type OptionsType } from "./Options.js";
+import type { CreatePluginType } from "../../engine/index.js";
+declare module "../../engine/Plugins.ts" {
+    interface EmblaPluginsType {
+        classNames: ClassNamesType;
+    }
+}
+export type ClassNamesType = CreatePluginType<{}, OptionsType>;
+export type ClassNamesOptionsType = ClassNamesType["options"];
+declare function ClassNames(userOptions?: ClassNamesOptionsType): ClassNamesType;
+declare namespace ClassNames {
+    let globalOptions: ClassNamesOptionsType | undefined;
+}
+export default ClassNames;

package/carousel/plugins/class-names/ClassNames.js

@@ -0,0 +1,98 @@
+// Ported from embla-carousel (packages/embla-carousel-class-names/src/components/ClassNames.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts, formatting; `'embla-carousel'` imports / module augmentation → `../../engine/` files; otherwise verbatim.
+import { defaultOptions } from "./Options.js";
+import { addClass, normalizeClassNames, removeClass } from "./utils.js";
+function ClassNames(userOptions = {}) {
+    let options;
+    let emblaApi;
+    let root;
+    let slides;
+    let snappedIndexes = [];
+    let inViewIndexes = [];
+    const selectedEvents = ["select"];
+    const draggingEvents = ["pointerDown", "pointerUp"];
+    const inViewEvents = ["slidesInView"];
+    const classNames = {
+        snapped: [],
+        inView: [],
+        draggable: [],
+        dragging: [],
+        loop: [],
+    };
+    function init(emblaApiInstance, optionsHandler) {
+        emblaApi = emblaApiInstance;
+        const { mergeOptions, optionsAtMedia } = optionsHandler;
+        const optionsBase = mergeOptions(defaultOptions, ClassNames.globalOptions);
+        const allOptions = mergeOptions(optionsBase, userOptions);
+        options = optionsAtMedia(allOptions);
+        root = emblaApi.rootNode();
+        slides = emblaApi.slideNodes();
+        const { watchDrag, loop } = emblaApi.internalEngine().options;
+        const isDraggable = !!watchDrag;
+        if (options.loop && loop) {
+            classNames.loop = normalizeClassNames(options.loop);
+            addClass(root, classNames.loop);
+        }
+        if (options.draggable && isDraggable) {
+            classNames.draggable = normalizeClassNames(options.draggable);
+            addClass(root, classNames.draggable);
+        }
+        if (options.dragging) {
+            classNames.dragging = normalizeClassNames(options.dragging);
+            draggingEvents.forEach((evt) => emblaApi.on(evt, toggleDraggingClass));
+        }
+        if (options.snapped) {
+            classNames.snapped = normalizeClassNames(options.snapped);
+            selectedEvents.forEach((evt) => emblaApi.on(evt, toggleSnappedClasses));
+            toggleSnappedClasses();
+        }
+        if (options.inView) {
+            classNames.inView = normalizeClassNames(options.inView);
+            inViewEvents.forEach((evt) => emblaApi.on(evt, toggleInViewClasses));
+            toggleInViewClasses();
+        }
+    }
+    function destroy() {
+        draggingEvents.forEach((evt) => emblaApi.off(evt, toggleDraggingClass));
+        selectedEvents.forEach((evt) => emblaApi.off(evt, toggleSnappedClasses));
+        inViewEvents.forEach((evt) => emblaApi.off(evt, toggleInViewClasses));
+        removeClass(root, classNames.loop);
+        removeClass(root, classNames.draggable);
+        removeClass(root, classNames.dragging);
+        toggleSlideClasses([], snappedIndexes, classNames.snapped);
+        toggleSlideClasses([], inViewIndexes, classNames.inView);
+        Object.keys(classNames).forEach((classNameKey) => {
+            const key = classNameKey;
+            classNames[key] = [];
+        });
+    }
+    function toggleDraggingClass(_, evt) {
+        const toggleClass = evt === "pointerDown" ? addClass : removeClass;
+        toggleClass(root, classNames.dragging);
+    }
+    function toggleSlideClasses(addClassIndexes = [], removeClassIndexes = [], classNames) {
+        const removeClassSlides = removeClassIndexes.map((index) => slides[index]);
+        const addClassSlides = addClassIndexes.map((index) => slides[index]);
+        removeClassSlides.forEach((slide) => removeClass(slide, classNames));
+        addClassSlides.forEach((slide) => addClass(slide, classNames));
+        return addClassIndexes;
+    }
+    function toggleSnappedClasses() {
+        const { slideRegistry } = emblaApi.internalEngine();
+        const newSnappedIndexes = slideRegistry[emblaApi.selectedScrollSnap()];
+        snappedIndexes = toggleSlideClasses(newSnappedIndexes, snappedIndexes, classNames.snapped);
+    }
+    function toggleInViewClasses() {
+        const newInViewIndexes = emblaApi.slidesInView();
+        inViewIndexes = toggleSlideClasses(newInViewIndexes, inViewIndexes, classNames.inView);
+    }
+    const self = {
+        name: "classNames",
+        options: userOptions,
+        init,
+        destroy,
+    };
+    return self;
+}
+ClassNames.globalOptions = undefined;
+export default ClassNames;

package/carousel/plugins/class-names/Options.d.ts

@@ -0,0 +1,13 @@
+import type { CreateOptionsType } from "../../engine/index.js";
+export type ClassNameOptionType = string | string[];
+export type ClassNamesListType = {
+    snapped: string[];
+    inView: string[];
+    draggable: string[];
+    dragging: string[];
+    loop: string[];
+};
+export type OptionsType = CreateOptionsType<{
+    [Key in keyof ClassNamesListType]: ClassNameOptionType;
+}>;
+export declare const defaultOptions: OptionsType;

package/carousel/plugins/class-names/Options.js

@@ -0,0 +1,9 @@
+export const defaultOptions = {
+    active: true,
+    breakpoints: {},
+    snapped: "is-snapped",
+    inView: "is-in-view",
+    draggable: "is-draggable",
+    dragging: "is-dragging",
+    loop: "is-loop",
+};

package/carousel/plugins/class-names/index.d.ts

@@ -0,0 +1,2 @@
+export type { ClassNamesType, ClassNamesOptionsType } from "./ClassNames.js";
+export { default, default as ClassNames } from "./ClassNames.js";

package/carousel/plugins/class-names/index.js

@@ -0,0 +1 @@
+export { default, default as ClassNames } from "./ClassNames.js";

package/carousel/plugins/class-names/utils.d.ts

@@ -0,0 +1,4 @@
+import type { ClassNameOptionType } from "./Options.js";
+export declare function normalizeClassNames(classNames: ClassNameOptionType): string[];
+export declare function removeClass(node: HTMLElement, classNames: string[]): void;
+export declare function addClass(node: HTMLElement, classNames: string[]): void;

package/carousel/plugins/class-names/utils.js

@@ -0,0 +1,14 @@
+export function normalizeClassNames(classNames) {
+    const normalized = Array.isArray(classNames) ? classNames : [classNames];
+    return normalized.filter(Boolean);
+}
+export function removeClass(node, classNames) {
+    if (!node || !classNames.length)
+        return;
+    node.classList.remove(...classNames);
+}
+export function addClass(node, classNames) {
+    if (!node || !classNames.length)
+        return;
+    node.classList.add(...classNames);
+}

package/carousel/plugins/fade/Fade.d.ts

@@ -0,0 +1,14 @@
+import type { OptionsType } from "./Options.js";
+import type { CreatePluginType } from "../../engine/index.js";
+declare module "../../engine/Plugins.ts" {
+    interface EmblaPluginsType {
+        fade: FadeType;
+    }
+}
+export type FadeType = CreatePluginType<{}, OptionsType>;
+export type FadeOptionsType = FadeType["options"];
+declare function Fade(userOptions?: FadeOptionsType): FadeType;
+declare namespace Fade {
+    let globalOptions: FadeOptionsType | undefined;
+}
+export default Fade;