@amazon-devices/vega-carousel 0.1.3

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Amazon.com, Inc. or its affiliates.  All rights reserved.
+
+These materials are licensed as "Program Materials" under the Program Materials License Agreement (the "Agreement").  The Agreement is available at https://developer.amazon.com/support/legal/pml.  See the Agreement for the specific terms and conditions of the Agreement.  Capitalized terms not defined in this file have the meanings given to them in the Agreement.  
+
+If you do not agree to the above terms and conditions, you may not use any file in this package. 
+
+YOUR USE OF THE PROGRAM MATERIALS IN OR ASSOCIATED WITH THIS PACKAGE IS AT YOUR SOLE RISK.  IN NO EVENT WILL AMAZON BE LIABLE FOR ANY DAMAGES, INCLUDING WITHOUT LIMITATION ANY DIRECT, INDIRECT, CONSEQUENTIAL, SPECIAL, INCIDENTAL, OR PUNITIVE DAMAGES (INCLUDING FOR ANY LOSS OF GOODWILL, BUSINESS INTERRUPTION, LOST PROFITS OR DATA, OR COMPUTER FAILURE OR MALFUNCTION) ARISING FROM OR RELATING TO SUCH PROGRAM MATERIALS, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, EVEN IF AMAZON HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS AND DISCLAIMERS APPLY EXCEPT TO THE EXTENT PROHIBITED BY APPLICABLE LAW.

package/dist/Carousel/Carousel.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2022 - 2025 Amazon.com, Inc. or its affiliates.  All rights
+ * reserved.
+ * PROPRIETARY/CONFIDENTIAL.  USE IS SUBJECT TO LICENSE TERMS.
+ */
+import React from 'react';
+import { CarouselProps, CarouselRef } from './types';
+declare function Scrollable<Item, Key = String>({ dataAdapter: { getItem, getItemCount, getItemKey, notifyDataError }, renderItem: renderItemProp, testID, uniqueId, orientation, renderedItemsCount, numOffsetItems, navigableScrollAreaMargin, hasPreferredFocus, initialStartIndex, hideItemsBeforeSelection, trapSelectionOnOrientation, containerStyle, itemStyle, animationDuration, selectionStrategy, pinnedSelectedItemOffset, onSelectionChanged, selectionBorder, }: CarouselProps<Item, Key>, ref: React.Ref<CarouselRef<Key>>): React.JSX.Element;
+/**
+ * Carousel is used to implement a single row of content metadata tiles in a
+ * Kepler application UI screen.
+ */
+export declare const Carousel: <ItemT, KeyT = string>(props: CarouselProps<ItemT, KeyT> & {
+    ref?: React.Ref<CarouselRef<KeyT>> | undefined;
+}) => ReturnType<typeof Scrollable>;
+export {};

package/dist/Carousel/Carousel.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Carousel = void 0;
+/**
+ * Copyright (c) 2022 - 2025 Amazon.com, Inc. or its affiliates.  All rights
+ * reserved.
+ * PROPRIETARY/CONFIDENTIAL.  USE IS SUBJECT TO LICENSE TERMS.
+ */
+const react_1 = __importStar(require("react"));
+const CarouselScrollable_1 = require("../CarouselScrollable");
+const Utils_1 = require("./Utils");
+function Scrollable({ dataAdapter: { getItem, getItemCount, getItemKey, notifyDataError }, renderItem: renderItemProp, testID, uniqueId, orientation = 'horizontal', renderedItemsCount = 8, numOffsetItems = 2, navigableScrollAreaMargin = 0, hasPreferredFocus = false, initialStartIndex = 0, hideItemsBeforeSelection = false, trapSelectionOnOrientation = false, containerStyle, itemStyle = {
+    itemPadding: 20,
+    pressedItemScaleFactor: 0.8,
+    selectedItemScaleFactor: 1,
+}, animationDuration = {
+    itemPressedDuration: 0.15,
+    itemScrollDuration: 0.2,
+}, selectionStrategy = 'anchored', pinnedSelectedItemOffset = '0%', onSelectionChanged, selectionBorder, }, ref) {
+    const { borderStrategy, ...borderStyleProps } = selectionBorder || {};
+    var { itemPadding, itemPaddingOnSelection, pressedItemScaleFactor, selectedItemScaleFactor, getSelectedItemOffset, } = itemStyle;
+    if (itemPaddingOnSelection === undefined)
+        itemPaddingOnSelection = itemPadding;
+    var { itemPressedDuration, itemScrollDuration, containerSelectionChangeDuration } = animationDuration;
+    if (containerSelectionChangeDuration === undefined)
+        containerSelectionChangeDuration = itemScrollDuration;
+    const carouselRef = react_1.default.useRef(null);
+    // Map selectionStrategy to ListSelectionStrategy
+    const listSelectionStrategy = react_1.default.useMemo(() => {
+        if (selectionStrategy === 'anchored') {
+            return CarouselScrollable_1.ListSelectionStrategy.ANCHORED;
+        }
+        else if (selectionStrategy === 'pinned') {
+            return CarouselScrollable_1.ListSelectionStrategy.PINNED;
+        }
+        else {
+            return CarouselScrollable_1.ListSelectionStrategy.NATURAL;
+        }
+    }, [selectionStrategy]);
+    (0, react_1.useImperativeHandle)(ref, () => ({
+        scrollTo(index, animated) {
+            carouselRef.current?.setSelectedItem(index, animated);
+        },
+        scrollToKey(key, animated) {
+            console.warn('[Carousel-V2] scrollToKey called with key:', key, 'animated:', animated);
+        },
+        enableDpad(enable) {
+            carouselRef.current?.enableInputEvents(enable);
+        },
+        notifyDataChange(changes, animated) {
+            carouselRef.current?.notifyDataChange(changes, animated);
+        },
+    }));
+    const renderItem = react_1.default.useCallback((item, index) => {
+        const result = renderItemProp(item);
+        return result === null ? undefined : result;
+    }, [renderItemProp]);
+    const getItemScrollable = react_1.default.useCallback((index) => {
+        const item = getItem(index);
+        if (item !== undefined) {
+            const renderInfo = { item, index };
+            return renderInfo;
+        }
+        return undefined;
+    }, [getItem]);
+    const notifyDataErrorScrollable = react_1.default.useCallback((error) => {
+        return notifyDataError(error);
+    }, [notifyDataError]);
+    return (react_1.default.createElement(CarouselScrollable_1.CarouselScrollable, { ref: carouselRef, getItem: getItemScrollable, getItemCount: getItemCount, getItemKey: getItemKey, notifyDataError: notifyDataErrorScrollable, renderItem: renderItem, testID: testID, uniqueId: uniqueId, orientation: orientation === 'horizontal'
+            ? CarouselScrollable_1.ListOrientation.HORIZONTAL
+            : CarouselScrollable_1.ListOrientation.VERTICAL, renderedItemsCount: renderedItemsCount, numOffsetItems: numOffsetItems, navigableScrollOffset: navigableScrollAreaMargin, hasPreferredFocus: hasPreferredFocus, initialStartIndex: initialStartIndex, hideItemsBeforeSelection: hideItemsBeforeSelection, trapFocusOnOrientation: trapSelectionOnOrientation, style: containerStyle, itemPadding: itemPadding, itemPaddingOnFocus: itemPaddingOnSelection, pressedItemScaleFactor: pressedItemScaleFactor, focusedItemScaleFactor: selectedItemScaleFactor, getSelectedItemOffset: getSelectedItemOffset, itemPressedDuration: itemPressedDuration, itemScrollDuration: itemScrollDuration, containerFocusChangeDuration: containerSelectionChangeDuration, selectionStrategy: listSelectionStrategy, pinnedFocusOffset: selectionStrategy === 'pinned'
+            ? (0, Utils_1.percentageStringToNumber)(pinnedSelectedItemOffset)
+            : 0, onSelectionChanged: onSelectionChanged, showSelectionBorder: selectionBorder !== undefined, selectionBorderStyle: borderStyleProps, selectionBorderStrategy: borderStrategy }));
+}
+/**
+ * Carousel is used to implement a single row of content metadata tiles in a
+ * Kepler application UI screen.
+ */
+exports.Carousel = react_1.default.forwardRef(Scrollable);

package/dist/Carousel/Utils.d.ts

@@ -0,0 +1,4 @@
+import { Percentage, PinnedPlacement } from './types';
+export declare function isValidPinnedPlacement(value: string | undefined): value is PinnedPlacement;
+export declare function isValidPercentage(value: string | undefined): value is Percentage;
+export declare function percentageStringToNumber(value: string | undefined): number | undefined;

package/dist/Carousel/Utils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.percentageStringToNumber = exports.isValidPercentage = exports.isValidPinnedPlacement = void 0;
+const PERCENTAGE_REGEX = /^(\d+(?:\.\d+)?)%$/;
+function isValidPinnedPlacement(value) {
+    return value === 'start' || value === 'center' || value === 'end';
+}
+exports.isValidPinnedPlacement = isValidPinnedPlacement;
+function isValidPercentage(value) {
+    if (typeof value === 'undefined') {
+        return false;
+    }
+    const match = value.match(PERCENTAGE_REGEX);
+    if (!match)
+        return false;
+    const percentage = parseFloat(match[1]);
+    return percentage >= 0 && percentage <= 100;
+}
+exports.isValidPercentage = isValidPercentage;
+function percentageStringToNumber(value) {
+    if (!isValidPercentage(value)) {
+        if (isValidPinnedPlacement(value)) {
+            if (value === 'start')
+                return 0;
+            if (value === 'center')
+                return 0.5;
+            if (value === 'end')
+                return 1;
+        }
+        return 0; // default to 0%
+    }
+    const match = value.match(PERCENTAGE_REGEX);
+    return !match ? 0 : Math.min(Math.max(parseFloat(match[1]) / 100, 0.0), 1.0);
+}
+exports.percentageStringToNumber = percentageStringToNumber;

package/dist/Carousel/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) 2022 - 2025 Amazon.com, Inc. or its affiliates.  All rights
+ * reserved.
+ * PROPRIETARY/CONFIDENTIAL.  USE IS SUBJECT TO LICENSE TERMS.
+ */
+export * from './Carousel';
+export * from './types';

package/dist/Carousel/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Copyright (c) 2022 - 2025 Amazon.com, Inc. or its affiliates.  All rights
+ * reserved.
+ * PROPRIETARY/CONFIDENTIAL.  USE IS SUBJECT TO LICENSE TERMS.
+ */
+__exportStar(require("./Carousel"), exports);
+__exportStar(require("./types"), exports);

package/dist/Carousel/types.d.ts

@@ -0,0 +1,406 @@
+/// <reference types="react" />
+/**
+ * Copyright (c) 2022 - 2025 Amazon.com, Inc. or its affiliates.  All rights
+ * reserved.
+ * PROPRIETARY/CONFIDENTIAL.  USE IS SUBJECT TO LICENSE TERMS.
+ */
+import { ColorValue, StyleProp, ViewStyle } from 'react-native';
+import { CarouselDataError, CarouselDataChange } from '../CarouselData';
+export type Orientation = 'horizontal' | 'vertical';
+/**
+ * SelectionStrategy - Specifies how the position of the selected item in the
+ * list moves within the carousel's navigable content area in response to DPad
+ * key presses.
+ *
+ * natural - Causes the selected item to float along the carousel's orientation
+ * until it reaches either end of the list.
+ * anchored - Causes the selected item to stay anchored on the initial item’s
+ * position when scrolling in either direction along the orientation.
+ * pinned - Enables the selected item to follow natural scrolling behavior at
+ * the start and end of the list, while keeping it pinned to a specific position
+ * defined by the {@link pinnedSelectedItemOffset} prop during the rest of the scrolling.
+ */
+export type SelectionStrategy = 'natural' | 'anchored' | 'pinned';
+/**
+ * BorderStrategy - Specifies how the item's border and content are drawn when
+ * the item is selected.
+ *
+ * inset - The border is drawn within the original item's size. The content maintains
+ * its original size so the border is drawn over the content, thus cropping some of
+ * the content out.
+ * outset - The border is drawn outside the original item's size, increasing the
+ * item's total size. The content remains the same size.
+ */
+export type BorderStrategy = 'inset' | 'outset';
+export type Percentage = `${number}%`;
+/**
+ * PinnedPlacement - Specifies where the selected item should be pinned in terms
+ * of relative position rather than percentage.
+ *
+ * start - The start of the carousel's navigable content area, i.e. 0%.
+ * center - The center of the carousel's navigable content area, i.e. 50%.
+ * end - The end of the carousel's navigable content area, i.e. 100%.
+ */
+export type PinnedPlacement = 'start' | 'center' | 'end';
+/**
+ * Describes a view and its dimensions for use in a carousel item.
+ * @template Prop - The type of props passed to the view component.
+ * @property view - A React functional component to be used as a carousel
+ * item.
+ * @property dimension - The dimensions of the view, including width and height.
+ */
+export type ItemInfo<Prop = any> = {
+    view: React.FC<Prop>;
+    dimension: {
+        width: number;
+        height: number;
+    };
+};
+export type ShiftFactor = {
+    width: number;
+    height: number;
+};
+/**
+ * Contract for an object representing an **inclusive** range of data indexes.
+ */
+export type DataIndexRange = {
+    /**
+     * The first index in the range. Accessing an item at this index should give
+     * you the _first_ item.
+     */
+    start: number;
+    /**
+     * The last index in the range. Accessing an item at this index should give
+     * you the _last_ item.
+     */
+    end: number;
+};
+/**
+ * The current selection state in the list.
+ *
+ * It has information about the items being rendered at the moment, as well as
+ * the current selected one.
+ *
+ * @see {@link OnSelectionChangedCallback}
+ */
+export type CarouselSelectionChangeEvent = {
+    /**
+     * After the selection is changed, this range represents the indexes of all
+     * items being rendered in the carousel.
+     */
+    renderedRange: DataIndexRange;
+    /**
+     * This is the index of the item selected after the selection change finished.
+     */
+    selectedIndex: number;
+};
+export type SelectionBorderProps = {
+    /**
+     * Specifies how the content and the border are drawn for the selected item.
+     *
+     * @default 'outset'
+     */
+    borderStrategy?: BorderStrategy;
+    /**
+     * Specifies the thickness of the border around the selected item.
+     *
+     * @default 8
+     */
+    borderWidth?: number;
+    /**
+     * Specifies the color of the border around the selected item.
+     *
+     * @default 'white'
+     */
+    borderColor?: ColorValue;
+    /**
+     * Determines the corner radius of the border for rounded edges.
+     *
+     * @default 8
+     */
+    borderRadius?: number;
+    /**
+     * Specifies the thickness of the outline stroke that separates the border
+     * from the item's content
+     *
+     * @default 3
+     */
+    borderStrokeWidth?: number;
+    /**
+     * Defines the corner radius for the outline stroke that separates the border
+     * from the item's content.
+     *
+     * @default 4
+     */
+    borderStrokeRadius?: number;
+    /**
+     * Specifies the color of the outline stroke for the selection border.
+     *
+     * @default 'black'
+     */
+    borderStrokeColor?: ColorValue;
+};
+export type AnimationDurationProps = {
+    /**
+     * Number of seconds that the animation for pressing on the item takes to complete.
+     *
+     * @default 0.15 seconds
+     */
+    itemPressedDuration?: number;
+    /**
+     * Amount of time, in seconds, used to scroll each item.
+     *
+     * @default 0.2 seconds
+     */
+    itemScrollDuration?: number;
+    /**
+     * Number of seconds that the animation for changing the selected container
+     * takes to complete.
+     *
+     * @default itemScrollDuration
+     */
+    containerSelectionChangeDuration?: number;
+};
+export type CarouselItemStyleProps = {
+    /**
+     * The space between the adjacent items along the carousel's orientation, in pixels.
+     *
+     * @default 20 dp
+     */
+    itemPadding?: number;
+    /**
+     * The space between the adjacent items along the carousel's orientation, in pixels
+     * when the carousel is selected.
+     *
+     * @default 20 dp
+     */
+    itemPaddingOnSelection?: number;
+    /**
+     * A scale multiplier to be applied to the item when it is pressed by the user.
+     *
+     * @default 0.8
+     */
+    pressedItemScaleFactor?: number;
+    /**
+     * A scale multiplier to be applied to the item when it is selected.
+     *
+     * When this value is `1.0`, it means there will be no scaling happening to
+     * the selected item while the user scrolls through the list.
+     *
+     * @default 1.0
+     */
+    selectedItemScaleFactor?: number;
+    /**
+     * A function to retrieve the offset value to be applied for an item relative
+     * to its current position.
+     * @param info - The data item and index for which to get the offset.
+     * @returns The width and height of the offset
+     */
+    getSelectedItemOffset?: (info: CarouselRenderInfo) => ShiftFactor | undefined;
+};
+export type CarouselItemDataAdapter<ItemT, KeyT = React.Key> = {
+    /**
+     * A function that will receive an index, and return an item's data object.
+     *
+     * The object returned will be used to call other data-access functions to
+     * retrieve information about specific items.
+     * @param index - The item index
+     * @returns the item's data object
+     */
+    getItem: (index: number) => ItemT | undefined;
+    /**
+     * A function that will return the item count for the list.
+     * @returns The item count
+     */
+    getItemCount: () => number;
+    /**
+     * Function to provide a unique key for each item based on the data and index.
+     * @param info - The data item and index for which to generate the key.
+     * @returns A unique key for the data item
+     */
+    getItemKey: (info: CarouselRenderInfo) => KeyT | undefined;
+    /**
+     * This function is called by the carousel when an item cannot be used
+     * in the carousel.
+     *
+     * This happens when either {@link getItem} or {@link renderItem} functions
+     * return an `undefined` value.
+     * @param error - The information regarding the error
+     * @returns Whether or not to retry
+     */
+    notifyDataError: (error: CarouselDataError) => boolean;
+};
+/**
+ * Interface for the properties of the carousel component.
+ *
+ * @template ItemT - The type of the items in the data array.
+ * @template KeyT - The type of the keys for each item. Defaults to `string`.
+ */
+export interface CarouselProps<ItemT, KeyT = string> {
+    /**
+     * The object used to retrieve carousel items and other information about them.
+     */
+    dataAdapter: CarouselItemDataAdapter<ItemT, KeyT>;
+    /**
+     * Function to render an individual item.
+     * @param info - The information needed to render the item.
+     * @returns A React element representing the item, or null.
+     */
+    renderItem: (info: CarouselRenderInfo) => React.ReactElement | null;
+    /**
+     * Unique string identifier for e2e testing.
+     *
+     * @default undefined
+     */
+    testID?: string;
+    /**
+     * An arbitrary and unique identifier for this list that will be used
+     * to determine when to recycle the list and its items.
+     *
+     * Commonly used by horizontal carousels within a vertical carousel
+     * (i.e. nested carousels).
+     *
+     * @default undefined
+     */
+    uniqueId?: string;
+    /**
+     * Specifies the direction and layout for rendering items in a carousel.
+     *
+     * @default horizontal
+     */
+    orientation?: Orientation;
+    /**
+     * The number of items to render at a given time when recycling through the
+     * carousel for performance optimization.
+     *
+     * @default 8
+     */
+    renderedItemsCount?: number;
+    /**
+     * Number of items to keep to the top/start of the carousel before recycling
+     * the item component to the end.
+     *
+     * @default 2
+     */
+    numOffsetItems?: number;
+    /**
+     * The margin space (in density-independent pixels) on either side of the carousel's navigable
+     * content area in the direction of the carousel's orientation (i.e. left and right for
+     * horizontal carousels, top and bottom for vertical carousels).
+     *
+     * @default 0
+     */
+    navigableScrollAreaMargin?: number;
+    /**
+     * Determines whether this component should automatically receive focus when rendered.
+     * When true, the component will attempt to gain focus during the initial mount or when
+     * the prop value changes.
+     *
+     * @default false
+     */
+    hasPreferredFocus?: boolean;
+    /**
+     * Indicates the first item index in the carousel to be selected.
+     *
+     * @default 0
+     */
+    initialStartIndex?: number;
+    /**
+     * Determines whether items before the selected one should be hidden.
+     *
+     * @default false
+     */
+    hideItemsBeforeSelection?: boolean;
+    /**
+     * This flag will prevent selection from progressing to the nearest component outside the
+     * carousel alongside its orientation. If the carousel is horizontal and the user is
+     * at the start item and presses to move backward, or at the end item and presses to
+     * move forward, this flag will prevent selection from escaping the carousel.
+     *
+     * @default false
+     */
+    trapSelectionOnOrientation?: boolean;
+    /**
+     * Style applied to the carousel container.
+     *
+     * @default undefined
+     */
+    containerStyle?: StyleProp<ViewStyle>;
+    /**
+     * Style applied to the carousel items.
+     */
+    itemStyle?: CarouselItemStyleProps;
+    /**
+     * The durations of various animations related to the carousel and its items
+     */
+    animationDuration?: AnimationDurationProps;
+    /**
+     * Specifies how the selected item moves in the carousel in response to
+     * the DPad key presses.
+     *
+     * @default anchored
+     */
+    selectionStrategy?: SelectionStrategy;
+    /**
+     * The value determines the relative position from the leading edge of the
+     * carousel where the selected item is pinned.
+     *
+     * This value must be of type {@link Percentage} or of type {@link PinnedPlacement},
+     * both of which will be converted to a numerical value between 0 and 1.
+     *
+     * @default '0%'
+     */
+    pinnedSelectedItemOffset?: Percentage | PinnedPlacement;
+    /**
+     * Function called whenever the current selected item on the list changes
+     * (it's not called when the list is selected or unselected).
+     * @param event - the current selection state of the list
+     */
+    onSelectionChanged?: (event: CarouselSelectionChangeEvent) => void;
+    /**
+     * When border style is specified, the selected item will
+     * have a style-able border enveloping the selected item.
+     *
+     * All the style related props in selectionBorder property defines the
+     * look-and-feel of the border surrounding the selected item when it is
+     * enabled.
+     *
+     * @default - No border will be shown
+     */
+    selectionBorder?: SelectionBorderProps;
+}
+/**
+ * Interface definition for renderItem function
+ */
+export interface CarouselRenderInfo<ItemT = any> {
+    /**
+     * The data to be used to render the current item.
+     * This will be an element in the {@link CarouselProps.data `data`} array
+     * passed into the carousel.
+     */
+    item: ItemT;
+    /**
+     * The zero based index of the current item being rendered by the
+     * {@link Carousel.renderItem `renderItem`} function.
+     */
+    index: number;
+}
+export interface CarouselRef<KeyT> {
+    /**
+     * Scrolls to the item at the specified index
+     */
+    scrollTo(index: number, animated: boolean): void;
+    /**
+     * To support DPAD HW key events on the carousel.
+     */
+    enableDpad(enable: boolean): void;
+    /**
+     * Scrolls to the item belonging to a unique key.
+     */
+    scrollToKey(key: KeyT, animated: boolean): void;
+    /**
+     * Notifies the carousel of data changes for efficient updates.
+     */
+    notifyDataChange(changes: Array<CarouselDataChange>, animated?: boolean): void;
+}
+export type LayoutIdType = React.FC<any>;

package/dist/Carousel/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });