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

package/carousel/engine/EventStore.js

@@ -0,0 +1,25 @@
+export function EventStore() {
+    let listeners = [];
+    function add(node, type, handler, options = { passive: true }) {
+        let removeListener;
+        if ("addEventListener" in node) {
+            node.addEventListener(type, handler, options);
+            removeListener = () => node.removeEventListener(type, handler, options);
+        }
+        else {
+            const legacyMediaQueryList = node;
+            legacyMediaQueryList.addListener(handler);
+            removeListener = () => legacyMediaQueryList.removeListener(handler);
+        }
+        listeners.push(removeListener);
+        return self;
+    }
+    function clear() {
+        listeners = listeners.filter((remove) => remove());
+    }
+    const self = {
+        add,
+        clear,
+    };
+    return self;
+}

package/carousel/engine/NodeRects.d.ts

@@ -0,0 +1,12 @@
+export type NodeRectType = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+};
+export type NodeRectsType = {
+    measure: (node: HTMLElement) => NodeRectType;
+};
+export declare function NodeRects(): NodeRectsType;

package/carousel/engine/NodeRects.js

@@ -0,0 +1,18 @@
+export function NodeRects() {
+    function measure(node) {
+        const { offsetTop, offsetLeft, offsetWidth, offsetHeight } = node;
+        const offset = {
+            top: offsetTop,
+            right: offsetLeft + offsetWidth,
+            bottom: offsetTop + offsetHeight,
+            left: offsetLeft,
+            width: offsetWidth,
+            height: offsetHeight,
+        };
+        return offset;
+    }
+    const self = {
+        measure,
+    };
+    return self;
+}

package/carousel/engine/Options.d.ts

@@ -0,0 +1,40 @@
+import type { AlignmentOptionType } from "./Alignment.js";
+import type { AxisDirectionOptionType, AxisOptionType } from "./Axis.js";
+import type { SlidesToScrollOptionType } from "./SlidesToScroll.js";
+import type { ScrollContainOptionType } from "./ScrollContain.js";
+import type { DragHandlerOptionType } from "./DragHandler.js";
+import type { ResizeHandlerOptionType } from "./ResizeHandler.js";
+import type { SlidesHandlerOptionType } from "./SlidesHandler.js";
+import type { SlidesInViewOptionsType } from "./SlidesInView.js";
+import type { FocusHandlerOptionType } from "./SlideFocus.js";
+export type LooseOptionsType = {
+    [key: string]: unknown;
+};
+export type CreateOptionsType<Type extends LooseOptionsType> = Type & {
+    active: boolean;
+    breakpoints: {
+        [key: string]: Omit<Partial<CreateOptionsType<Type>>, "breakpoints">;
+    };
+};
+export type OptionsType = CreateOptionsType<{
+    align: AlignmentOptionType;
+    axis: AxisOptionType;
+    container: string | HTMLElement | null;
+    slides: string | HTMLElement[] | NodeListOf<HTMLElement> | null;
+    containScroll: ScrollContainOptionType;
+    direction: AxisDirectionOptionType;
+    slidesToScroll: SlidesToScrollOptionType;
+    dragFree: boolean;
+    dragThreshold: number;
+    inViewThreshold: SlidesInViewOptionsType;
+    loop: boolean;
+    skipSnaps: boolean;
+    duration: number;
+    startIndex: number;
+    watchDrag: DragHandlerOptionType;
+    watchResize: ResizeHandlerOptionType;
+    watchSlides: SlidesHandlerOptionType;
+    watchFocus: FocusHandlerOptionType;
+}>;
+export declare const defaultOptions: OptionsType;
+export type EmblaOptionsType = Partial<OptionsType>;

package/carousel/engine/Options.js

@@ -0,0 +1,22 @@
+export const defaultOptions = {
+    align: "center",
+    axis: "x",
+    container: null,
+    slides: null,
+    containScroll: "trimSnaps",
+    direction: "ltr",
+    slidesToScroll: 1,
+    inViewThreshold: 0,
+    breakpoints: {},
+    dragFree: false,
+    dragThreshold: 10,
+    loop: false,
+    skipSnaps: false,
+    duration: 25,
+    startIndex: 0,
+    active: true,
+    watchDrag: true,
+    watchResize: true,
+    watchSlides: true,
+    watchFocus: true,
+};

package/carousel/engine/OptionsHandler.d.ts

@@ -0,0 +1,10 @@
+import type { LooseOptionsType, CreateOptionsType } from "./Options.js";
+import { type WindowType } from "./utils.js";
+type OptionsType = Partial<CreateOptionsType<LooseOptionsType>>;
+export type OptionsHandlerType = {
+    mergeOptions: <TypeA extends OptionsType, TypeB extends OptionsType>(optionsA: TypeA, optionsB?: TypeB) => TypeA;
+    optionsAtMedia: <Type extends OptionsType>(options: Type) => Type;
+    optionsMediaQueries: (optionsList: OptionsType[]) => MediaQueryList[];
+};
+export declare function OptionsHandler(ownerWindow: WindowType): OptionsHandlerType;
+export {};

package/carousel/engine/OptionsHandler.js

@@ -0,0 +1,26 @@
+import { objectKeys, objectsMergeDeep } from "./utils.js";
+export function OptionsHandler(ownerWindow) {
+    function mergeOptions(optionsA, optionsB) {
+        return objectsMergeDeep(optionsA, optionsB || {});
+    }
+    function optionsAtMedia(options) {
+        const optionsAtMedia = options.breakpoints || {};
+        const matchedMediaOptions = objectKeys(optionsAtMedia)
+            .filter((media) => ownerWindow.matchMedia(media).matches)
+            .map((media) => optionsAtMedia[media])
+            .reduce((a, mediaOption) => mergeOptions(a, mediaOption), {});
+        return mergeOptions(options, matchedMediaOptions);
+    }
+    function optionsMediaQueries(optionsList) {
+        return optionsList
+            .map((options) => objectKeys(options.breakpoints || {}))
+            .reduce((acc, mediaQueries) => acc.concat(mediaQueries), [])
+            .map(ownerWindow.matchMedia);
+    }
+    const self = {
+        mergeOptions,
+        optionsAtMedia,
+        optionsMediaQueries,
+    };
+    return self;
+}

package/carousel/engine/PercentOfView.d.ts

@@ -0,0 +1,4 @@
+export type PercentOfViewType = {
+    measure: (n: number) => number;
+};
+export declare function PercentOfView(viewSize: number): PercentOfViewType;

package/carousel/engine/PercentOfView.js

@@ -0,0 +1,9 @@
+export function PercentOfView(viewSize) {
+    function measure(n) {
+        return viewSize * (n / 100);
+    }
+    const self = {
+        measure,
+    };
+    return self;
+}

package/carousel/engine/Plugins.d.ts

@@ -0,0 +1,16 @@
+import type { CreateOptionsType, LooseOptionsType } from "./Options.js";
+import type { EmblaCarouselType } from "./EmblaCarousel.js";
+import type { OptionsHandlerType } from "./OptionsHandler.js";
+export type LoosePluginType = {
+    [key: string]: unknown;
+};
+export type CreatePluginType<TypeA extends LoosePluginType, TypeB extends LooseOptionsType> = TypeA & {
+    name: string;
+    options: Partial<CreateOptionsType<TypeB>>;
+    init: (embla: EmblaCarouselType, OptionsHandler: OptionsHandlerType) => void;
+    destroy: () => void;
+};
+export interface EmblaPluginsType {
+    [key: string]: CreatePluginType<LoosePluginType, {}>;
+}
+export type EmblaPluginType = EmblaPluginsType[keyof EmblaPluginsType];

package/carousel/engine/Plugins.js

@@ -0,0 +1 @@
+export {};

package/carousel/engine/PluginsHandler.d.ts

@@ -0,0 +1,8 @@
+import type { EmblaCarouselType } from "./EmblaCarousel.js";
+import type { OptionsHandlerType } from "./OptionsHandler.js";
+import type { EmblaPluginsType, EmblaPluginType } from "./Plugins.js";
+export type PluginsHandlerType = {
+    init: (emblaApi: EmblaCarouselType, plugins: EmblaPluginType[]) => EmblaPluginsType;
+    destroy: () => void;
+};
+export declare function PluginsHandler(optionsHandler: OptionsHandlerType): PluginsHandlerType;

package/carousel/engine/PluginsHandler.js

@@ -0,0 +1,16 @@
+export function PluginsHandler(optionsHandler) {
+    let activePlugins = [];
+    function init(emblaApi, plugins) {
+        activePlugins = plugins.filter(({ options }) => optionsHandler.optionsAtMedia(options).active !== false);
+        activePlugins.forEach((plugin) => plugin.init(emblaApi, optionsHandler));
+        return plugins.reduce((map, plugin) => Object.assign(map, { [plugin.name]: plugin }), {});
+    }
+    function destroy() {
+        activePlugins = activePlugins.filter((plugin) => plugin.destroy());
+    }
+    const self = {
+        init,
+        destroy,
+    };
+    return self;
+}

package/carousel/engine/ResizeHandler.d.ts

@@ -0,0 +1,13 @@
+import type { AxisType } from "./Axis.js";
+import type { EmblaCarouselType } from "./EmblaCarousel.js";
+import type { EventHandlerType } from "./EventHandler.js";
+import type { NodeRectsType } from "./NodeRects.js";
+import { type WindowType } from "./utils.js";
+type ResizeHandlerCallbackType = (emblaApi: EmblaCarouselType, entries: ResizeObserverEntry[]) => boolean | void;
+export type ResizeHandlerOptionType = boolean | ResizeHandlerCallbackType;
+export type ResizeHandlerType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+    destroy: () => void;
+};
+export declare function ResizeHandler(container: HTMLElement, eventHandler: EventHandlerType, ownerWindow: WindowType, slides: HTMLElement[], axis: AxisType, watchResize: ResizeHandlerOptionType, nodeRects: NodeRectsType): ResizeHandlerType;
+export {};

package/carousel/engine/ResizeHandler.js

@@ -0,0 +1,51 @@
+import { isBoolean, mathAbs } from "./utils.js";
+export function ResizeHandler(container, eventHandler, ownerWindow, slides, axis, watchResize, nodeRects) {
+    const observeNodes = [container].concat(slides);
+    let resizeObserver;
+    let containerSize;
+    let slideSizes = [];
+    let destroyed = false;
+    function readSize(node) {
+        return axis.measureSize(nodeRects.measure(node));
+    }
+    function init(emblaApi) {
+        if (!watchResize)
+            return;
+        containerSize = readSize(container);
+        slideSizes = slides.map(readSize);
+        function defaultCallback(entries) {
+            for (const entry of entries) {
+                if (destroyed)
+                    return;
+                const isContainer = entry.target === container;
+                const slideIndex = slides.indexOf(entry.target);
+                const lastSize = isContainer ? containerSize : slideSizes[slideIndex];
+                const newSize = readSize(isContainer ? container : slides[slideIndex]);
+                const diffSize = mathAbs(newSize - lastSize);
+                if (diffSize >= 0.5) {
+                    emblaApi.reInit();
+                    eventHandler.emit("resize");
+                    break;
+                }
+            }
+        }
+        resizeObserver = new ResizeObserver((entries) => {
+            if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {
+                defaultCallback(entries);
+            }
+        });
+        ownerWindow.requestAnimationFrame(() => {
+            observeNodes.forEach((node) => resizeObserver.observe(node));
+        });
+    }
+    function destroy() {
+        destroyed = true;
+        if (resizeObserver)
+            resizeObserver.disconnect();
+    }
+    const self = {
+        init,
+        destroy,
+    };
+    return self;
+}

package/carousel/engine/ScrollBounds.d.ts

@@ -0,0 +1,10 @@
+import { type LimitType } from "../../motion/Limit.js";
+import type { ScrollBodyType } from "../../motion/ScrollBody.js";
+import type { Vector1DType } from "../../motion/Vector1d.js";
+import type { PercentOfViewType } from "./PercentOfView.js";
+export type ScrollBoundsType = {
+    shouldConstrain: () => boolean;
+    constrain: (pointerDown: boolean) => void;
+    toggleActive: (active: boolean) => void;
+};
+export declare function ScrollBounds(limit: LimitType, location: Vector1DType, target: Vector1DType, scrollBody: ScrollBodyType, percentOfView: PercentOfViewType): ScrollBoundsType;

package/carousel/engine/ScrollBounds.js

@@ -0,0 +1,41 @@
+// Ported from embla-carousel (packages/embla-carousel/src/components/ScrollBounds.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts (erasable syntax), formatting; otherwise verbatim.
+import { Limit } from "../../motion/Limit.js";
+import { mathAbs } from "./utils.js";
+export function ScrollBounds(limit, location, target, scrollBody, percentOfView) {
+    const pullBackThreshold = percentOfView.measure(10);
+    const edgeOffsetTolerance = percentOfView.measure(50);
+    const frictionLimit = Limit(0.1, 0.99);
+    let disabled = false;
+    function shouldConstrain() {
+        if (disabled)
+            return false;
+        if (!limit.reachedAny(target.get()))
+            return false;
+        if (!limit.reachedAny(location.get()))
+            return false;
+        return true;
+    }
+    function constrain(pointerDown) {
+        if (!shouldConstrain())
+            return;
+        const edge = limit.reachedMin(location.get()) ? "min" : "max";
+        const diffToEdge = mathAbs(limit[edge] - location.get());
+        const diffToTarget = target.get() - location.get();
+        const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);
+        target.subtract(diffToTarget * friction);
+        if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {
+            target.set(limit.constrain(target.get()));
+            scrollBody.useDuration(25).useBaseFriction();
+        }
+    }
+    function toggleActive(active) {
+        disabled = !active;
+    }
+    const self = {
+        shouldConstrain,
+        constrain,
+        toggleActive,
+    };
+    return self;
+}

package/carousel/engine/ScrollContain.d.ts

@@ -0,0 +1,7 @@
+import { type LimitType } from "../../motion/Limit.js";
+export type ScrollContainOptionType = false | "trimSnaps" | "keepSnaps";
+export type ScrollContainType = {
+    snapsContained: number[];
+    scrollContainLimit: LimitType;
+};
+export declare function ScrollContain(viewSize: number, contentSize: number, snapsAligned: number[], containScroll: ScrollContainOptionType, pixelTolerance: number): ScrollContainType;

package/carousel/engine/ScrollContain.js

@@ -0,0 +1,52 @@
+// Ported from embla-carousel (packages/embla-carousel/src/components/ScrollContain.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts (erasable syntax), formatting; otherwise verbatim.
+import { Limit } from "../../motion/Limit.js";
+import { arrayIsLastIndex, arrayLast, deltaAbs } from "./utils.js";
+export function ScrollContain(viewSize, contentSize, snapsAligned, containScroll, pixelTolerance) {
+    const scrollBounds = Limit(-contentSize + viewSize, 0);
+    const snapsBounded = measureBounded();
+    const scrollContainLimit = findScrollContainLimit();
+    const snapsContained = measureContained();
+    function usePixelTolerance(bound, snap) {
+        return deltaAbs(bound, snap) <= 1;
+    }
+    function findScrollContainLimit() {
+        const startSnap = snapsBounded[0];
+        const endSnap = arrayLast(snapsBounded);
+        const min = snapsBounded.lastIndexOf(startSnap);
+        const max = snapsBounded.indexOf(endSnap) + 1;
+        return Limit(min, max);
+    }
+    function measureBounded() {
+        return snapsAligned
+            .map((snapAligned, index) => {
+            const { min, max } = scrollBounds;
+            const snap = scrollBounds.constrain(snapAligned);
+            const isFirst = !index;
+            const isLast = arrayIsLastIndex(snapsAligned, index);
+            if (isFirst)
+                return max;
+            if (isLast)
+                return min;
+            if (usePixelTolerance(min, snap))
+                return min;
+            if (usePixelTolerance(max, snap))
+                return max;
+            return snap;
+        })
+            .map((scrollBound) => parseFloat(scrollBound.toFixed(3)));
+    }
+    function measureContained() {
+        if (contentSize <= viewSize + pixelTolerance)
+            return [scrollBounds.max];
+        if (containScroll === "keepSnaps")
+            return snapsBounded;
+        const { min, max } = scrollContainLimit;
+        return snapsBounded.slice(min, max);
+    }
+    const self = {
+        snapsContained,
+        scrollContainLimit,
+    };
+    return self;
+}

package/carousel/engine/ScrollLimit.d.ts

@@ -0,0 +1,5 @@
+import { type LimitType } from "../../motion/Limit.js";
+export type ScrollLimitType = {
+    limit: LimitType;
+};
+export declare function ScrollLimit(contentSize: number, scrollSnaps: number[], loop: boolean): ScrollLimitType;

package/carousel/engine/ScrollLimit.js

@@ -0,0 +1,13 @@
+// Ported from embla-carousel (packages/embla-carousel/src/components/ScrollLimit.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts (erasable syntax), formatting; otherwise verbatim.
+import { Limit } from "../../motion/Limit.js";
+import { arrayLast } from "./utils.js";
+export function ScrollLimit(contentSize, scrollSnaps, loop) {
+    const max = scrollSnaps[0];
+    const min = loop ? max - contentSize : arrayLast(scrollSnaps);
+    const limit = Limit(min, max);
+    const self = {
+        limit,
+    };
+    return self;
+}

package/carousel/engine/ScrollLooper.d.ts

@@ -0,0 +1,6 @@
+import { type LimitType } from "../../motion/Limit.js";
+import type { Vector1DType } from "../../motion/Vector1d.js";
+export type ScrollLooperType = {
+    loop: (direction: number) => void;
+};
+export declare function ScrollLooper(contentSize: number, limit: LimitType, location: Vector1DType, vectors: Vector1DType[]): ScrollLooperType;

package/carousel/engine/ScrollLooper.js

@@ -0,0 +1,26 @@
+// Ported from embla-carousel (packages/embla-carousel/src/components/ScrollLooper.ts, v8.6.0), MIT, © David Jerleke.
+// Rivet: TypeScript module specifiers (`.ts`, `import type`), `as` casts (erasable syntax), formatting; otherwise verbatim.
+import { Limit } from "../../motion/Limit.js";
+export function ScrollLooper(contentSize, limit, location, vectors) {
+    const jointSafety = 0.1;
+    const min = limit.min + jointSafety;
+    const max = limit.max + jointSafety;
+    const { reachedMin, reachedMax } = Limit(min, max);
+    function shouldLoop(direction) {
+        if (direction === 1)
+            return reachedMax(location.get());
+        if (direction === -1)
+            return reachedMin(location.get());
+        return false;
+    }
+    function loop(direction) {
+        if (!shouldLoop(direction))
+            return;
+        const loopDistance = contentSize * (direction * -1);
+        vectors.forEach((v) => v.add(loopDistance));
+    }
+    const self = {
+        loop,
+    };
+    return self;
+}

package/carousel/engine/ScrollProgress.d.ts

@@ -0,0 +1,5 @@
+import type { LimitType } from "../../motion/Limit.js";
+export type ScrollProgressType = {
+    get: (n: number) => number;
+};
+export declare function ScrollProgress(limit: LimitType): ScrollProgressType;

package/carousel/engine/ScrollProgress.js

@@ -0,0 +1,11 @@
+export function ScrollProgress(limit) {
+    const { max, length } = limit;
+    function get(n) {
+        const currentLocation = n - max;
+        return length ? currentLocation / -length : 0;
+    }
+    const self = {
+        get,
+    };
+    return self;
+}

package/carousel/engine/ScrollSnaps.d.ts

@@ -0,0 +1,9 @@
+import type { AlignmentType } from "./Alignment.js";
+import type { AxisType } from "./Axis.js";
+import type { NodeRectType } from "./NodeRects.js";
+import type { SlidesToScrollType } from "./SlidesToScroll.js";
+export type ScrollSnapsType = {
+    snaps: number[];
+    snapsAligned: number[];
+};
+export declare function ScrollSnaps(axis: AxisType, alignment: AlignmentType, containerRect: NodeRectType, slideRects: NodeRectType[], slidesToScroll: SlidesToScrollType): ScrollSnapsType;

package/carousel/engine/ScrollSnaps.js

@@ -0,0 +1,26 @@
+import { arrayLast, mathAbs } from "./utils.js";
+export function ScrollSnaps(axis, alignment, containerRect, slideRects, slidesToScroll) {
+    const { startEdge, endEdge } = axis;
+    const { groupSlides } = slidesToScroll;
+    const alignments = measureSizes().map(alignment.measure);
+    const snaps = measureUnaligned();
+    const snapsAligned = measureAligned();
+    function measureSizes() {
+        return groupSlides(slideRects)
+            .map((rects) => arrayLast(rects)[endEdge] - rects[0][startEdge])
+            .map(mathAbs);
+    }
+    function measureUnaligned() {
+        return slideRects.map((rect) => containerRect[startEdge] - rect[startEdge]).map((snap) => -mathAbs(snap));
+    }
+    function measureAligned() {
+        return groupSlides(snaps)
+            .map((g) => g[0])
+            .map((snap, index) => snap + alignments[index]);
+    }
+    const self = {
+        snaps,
+        snapsAligned,
+    };
+    return self;
+}

package/carousel/engine/ScrollTarget.d.ts

@@ -0,0 +1,12 @@
+import type { LimitType } from "../../motion/Limit.js";
+import type { Vector1DType } from "../../motion/Vector1d.js";
+export type TargetType = {
+    distance: number;
+    index: number;
+};
+export type ScrollTargetType = {
+    byIndex: (target: number, direction: number) => TargetType;
+    byDistance: (force: number, snap: boolean) => TargetType;
+    shortcut: (target: number, direction: number) => number;
+};
+export declare function ScrollTarget(loop: boolean, scrollSnaps: number[], contentSize: number, limit: LimitType, targetVector: Vector1DType): ScrollTargetType;

package/carousel/engine/ScrollTarget.js

@@ -0,0 +1,47 @@
+import { arrayLast, mathAbs, mathSign } from "./utils.js";
+export function ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {
+    const { reachedAny, removeOffset, constrain } = limit;
+    function minDistance(distances) {
+        return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];
+    }
+    function findTargetSnap(target) {
+        const distance = loop ? removeOffset(target) : constrain(target);
+        const ascDiffsToSnaps = scrollSnaps
+            .map((snap, index) => ({ diff: shortcut(snap - distance, 0), index }))
+            .sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));
+        const { index } = ascDiffsToSnaps[0];
+        return { index, distance };
+    }
+    function shortcut(target, direction) {
+        const targets = [target, target + contentSize, target - contentSize];
+        if (!loop)
+            return target;
+        if (!direction)
+            return minDistance(targets);
+        const matchingTargets = targets.filter((t) => mathSign(t) === direction);
+        if (matchingTargets.length)
+            return minDistance(matchingTargets);
+        return arrayLast(targets) - contentSize;
+    }
+    function byIndex(index, direction) {
+        const diffToSnap = scrollSnaps[index] - targetVector.get();
+        const distance = shortcut(diffToSnap, direction);
+        return { index, distance };
+    }
+    function byDistance(distance, snap) {
+        const target = targetVector.get() + distance;
+        const { index, distance: targetSnapDistance } = findTargetSnap(target);
+        const reachedBound = !loop && reachedAny(target);
+        if (!snap || reachedBound)
+            return { index, distance };
+        const diffToSnap = scrollSnaps[index] - targetSnapDistance;
+        const snapDistance = distance + shortcut(diffToSnap, 0);
+        return { index, distance: snapDistance };
+    }
+    const self = {
+        byDistance,
+        byIndex,
+        shortcut,
+    };
+    return self;
+}

package/carousel/engine/ScrollTo.d.ts

@@ -0,0 +1,11 @@
+import type { AnimationsType } from "./Animations.js";
+import type { CounterType } from "./Counter.js";
+import type { EventHandlerType } from "./EventHandler.js";
+import type { ScrollBodyType } from "../../motion/ScrollBody.js";
+import type { ScrollTargetType } from "./ScrollTarget.js";
+import type { Vector1DType } from "../../motion/Vector1d.js";
+export type ScrollToType = {
+    distance: (n: number, snap: boolean) => void;
+    index: (n: number, direction: number) => void;
+};
+export declare function ScrollTo(animation: AnimationsType, indexCurrent: CounterType, indexPrevious: CounterType, scrollBody: ScrollBodyType, scrollTarget: ScrollTargetType, targetVector: Vector1DType, eventHandler: EventHandlerType): ScrollToType;

package/carousel/engine/ScrollTo.js

@@ -0,0 +1,36 @@
+export function ScrollTo(animation, indexCurrent, indexPrevious, scrollBody, scrollTarget, targetVector, eventHandler) {
+    function scrollTo(target) {
+        const distanceDiff = target.distance;
+        const indexDiff = target.index !== indexCurrent.get();
+        targetVector.add(distanceDiff);
+        if (distanceDiff) {
+            if (scrollBody.duration()) {
+                animation.start();
+            }
+            else {
+                animation.update();
+                animation.render(1);
+                animation.update();
+            }
+        }
+        if (indexDiff) {
+            indexPrevious.set(indexCurrent.get());
+            indexCurrent.set(target.index);
+            eventHandler.emit("select");
+        }
+    }
+    function distance(n, snap) {
+        const target = scrollTarget.byDistance(n, snap);
+        scrollTo(target);
+    }
+    function index(n, direction) {
+        const targetIndex = indexCurrent.clone().set(n);
+        const target = scrollTarget.byIndex(targetIndex.get(), direction);
+        scrollTo(target);
+    }
+    const self = {
+        distance,
+        index,
+    };
+    return self;
+}

package/carousel/engine/SlideFocus.d.ts

@@ -0,0 +1,13 @@
+import type { EmblaCarouselType } from "./EmblaCarousel.js";
+import type { EventHandlerType } from "./EventHandler.js";
+import type { EventStoreType } from "./EventStore.js";
+import type { ScrollBodyType } from "../../motion/ScrollBody.js";
+import type { ScrollToType } from "./ScrollTo.js";
+import type { SlideRegistryType } from "./SlideRegistry.js";
+type FocusHandlerCallbackType = (emblaApi: EmblaCarouselType, evt: FocusEvent) => boolean | void;
+export type FocusHandlerOptionType = boolean | FocusHandlerCallbackType;
+export type SlideFocusType = {
+    init: (emblaApi: EmblaCarouselType) => void;
+};
+export declare function SlideFocus(root: HTMLElement, slides: HTMLElement[], slideRegistry: SlideRegistryType["slideRegistry"], scrollTo: ScrollToType, scrollBody: ScrollBodyType, eventStore: EventStoreType, eventHandler: EventHandlerType, watchFocus: FocusHandlerOptionType): SlideFocusType;
+export {};