@kaspernj/api-maker 1.0.2159 → 1.0.2161

package/build/draggable-sort/controller.js

@@ -1,53 +1,108 @@
+// @ts-check
 import { digg } from "diggerize";
 import { EventEmitter } from "eventemitter3"; // eslint-disable-line sort-imports
+/** @typedef {import("eventemitter3").EventEmitter} DraggableSortEventEmitter */
+/** @typedef {import("react-native").LayoutRectangle} DraggableSortLayout */
+/** @typedef {import("react-native").PanResponderGestureState} DraggableSortGestureState */
+/** @typedef {{x: number, y: number}} DraggableSortPosition */
+/** @typedef {(item: object) => string} DraggableSortKeyExtractor */
+/**
+ * @typedef {object} DraggableSortItemData
+ * @property {number} index
+ * @property {object} item
+ * @property {number} position
+ * @property {number} [baseX]
+ * @property {DraggableSortEventEmitter} [events]
+ * @property {DraggableSortLayout} [initialLayout]
+ * @property {string} [key]
+ * @property {DraggableSortLayout} [layout]
+ */
+/**
+ * @typedef {object} DraggableSortDragEndArgs
+ * @property {number} fromIndex
+ * @property {object} fromItem
+ * @property {number} fromPosition
+ * @property {object} item
+ * @property {DraggableSortItemData} itemData
+ * @property {object|null} toItem
+ * @property {number|null} toPosition
+ */
 /** Controller for drag-sort row state and events. */
 export default class DraggableSortController {
-    /** Constructor. */
+    /**
+     * Set up drag-sort state for a list of draggable items.
+     * @param {object} root0
+     * @param {object[]} root0.data
+     * @param {DraggableSortEventEmitter} [root0.events]
+     * @param {DraggableSortKeyExtractor} root0.keyExtractor
+     */
     constructor({ data, events, keyExtractor }) {
-        this.data = data;
-        this.currentOrder = [...data];
-        this.events = events || new EventEmitter();
-        this.keyExtractor = keyExtractor;
-        this.draggedItem = null;
-        this.draggedItemData = null;
-        this.draggedItemNewPosition = null;
-        this.draggedOverItem = null;
-        this.draggedOverItemData = null;
-        this.itemData = {};
-        for (const itemIndex in data) {
+        this.data = /** @type {object[]} */ (data);
+        this.currentOrder = /** @type {object[]} */ ([...data]);
+        this.events = /** @type {DraggableSortEventEmitter} */ (events || new EventEmitter());
+        this.keyExtractor = /** @type {DraggableSortKeyExtractor} */ (keyExtractor);
+        this.draggedItem = /** @type {object|null} */ (null);
+        this.draggedItemData = /** @type {DraggableSortItemData|null} */ (null);
+        this.draggedItemNewPosition = /** @type {number|null} */ (null);
+        this.draggedOverItem = /** @type {object|null} */ (null);
+        this.draggedOverItemData = /** @type {DraggableSortItemData|null} */ (null);
+        this.itemData = /** @type {Record<number, DraggableSortItemData>} */ ({});
+        for (const [itemIndex, item] of data.entries()) {
             this.itemData[itemIndex] = {
                 index: itemIndex,
-                item: data[itemIndex],
+                item,
                 position: itemIndex
             };
         }
     }
-    /** getEvents. */
+    /** @returns {DraggableSortEventEmitter} */
     getEvents = () => this.events;
-    /** getItemDataForItem. */
+    /**
+     * Return the tracked drag metadata for the given item instance.
+     * @param {object} item
+     * @returns {DraggableSortItemData|undefined}
+     */
     getItemDataForItem = (item) => this.getItemDataForIndex(this.data.indexOf(item));
-    /** getItemDataForKey. */
-    getItemDataForKey = (key) => this.itemData.find((itemDataI) => digg(itemDataI, "key") == key);
-    /** getItemDataForIndex. */
+    /**
+     * Look up item metadata by its extracted stable key.
+     * @param {string} key
+     * @returns {DraggableSortItemData|undefined}
+     */
+    getItemDataForKey = (key) => Object.values(this.itemData).find((itemDataI) => digg(itemDataI, "key") == key);
+    /**
+     * Return the tracked drag metadata stored for a list index.
+     * @param {number} index
+     * @returns {DraggableSortItemData|undefined}
+     */
     getItemDataForIndex = (index) => digg(this, "itemData", index);
-    /** onDragStart. */
+    /**
+     * Mark an item as the active dragged row and publish the drag-start event.
+     * @param {object} root0
+     * @param {object} root0.item
+     * @param {number} root0.itemIndex
+     */
     onDragStart = ({ item, itemIndex }) => {
         if (item) {
             this.draggedItem = item;
             this.draggedItemData = this.getItemDataForIndex(itemIndex);
+            if (!this.draggedItemData)
+                throw new Error(`Item data not found for index ${itemIndex}`);
             this.draggedItemIndex = itemIndex;
             this.draggedItemPosition = this.draggedItemData.position;
             this.events.emit("onDragStart", { item, itemData: this.draggedItemData });
         }
     };
-    /** onDragEnd. */
+    /** Finish the current drag and notify listeners about the final ordering. */
     onDragEnd = () => {
+        if (!this.draggedItemData || !this.draggedItem)
+            throw new Error("Cannot end drag without an active dragged item");
         const itemData = this.draggedItemData;
         const fromIndex = itemData.index;
         const fromPosition = digg(this, "draggedItemPosition");
         const toPosition = this.draggedItemNewPosition;
         const fromItem = this.draggedItem;
         const toItem = this.draggedOverItem;
+        /** @type {DraggableSortDragEndArgs} */
         const callbackArgs = { item: itemData.item, itemData, fromIndex, fromItem, fromPosition, toItem, toPosition };
         this.draggedItemData.events.emit("resetPosition", {
             callback: () => {
@@ -61,7 +116,14 @@ export default class DraggableSortController {
         this.draggedOverItemData = null;
         this.events.emit("onDragEnd", callbackArgs);
     };
-    /** onItemLayout. */
+    /**
+     * Store layout data and event bindings for a rendered draggable item.
+     * @param {object} root0
+     * @param {DraggableSortEventEmitter} root0.events
+     * @param {number} root0.index
+     * @param {object} root0.item
+     * @param {DraggableSortLayout} root0.layout
+     */
     onItemLayout = ({ events, index, item, layout }) => {
         if (!(index in this.itemData))
             throw new Error(`Item not found for index ${index}`);
@@ -74,18 +136,23 @@ export default class DraggableSortController {
             itemData.key = this.keyExtractor(item);
         }
     };
-    /** onMove. */
+    /**
+     * Update ordering as the active dragged item crosses other item positions.
+     * @param {object} root0
+     * @param {DraggableSortGestureState} root0.gestate
+     */
     onMove = ({ gestate }) => {
+        if (!this.draggedItemData || !this.initialDragPosition)
+            return;
         // Send move-event to the item being dragged so it will actually move around
         this.draggedItemData?.events?.emit("move", { gestate });
         const moveX = gestate.dx + this.initialDragPosition.x;
-        for (const itemIndex in this.itemData) {
-            const itemData = this.getItemDataForIndex(itemIndex);
+        for (const itemData of Object.values(this.itemData)) {
             const baseX = digg(itemData, "baseX");
             let smallestWidth = this.draggedItemData.layout.width;
             if (itemData.layout.width < smallestWidth)
                 smallestWidth = itemData.layout.width;
-            if (moveX > baseX && moveX < baseX + smallestWidth && itemIndex != this.draggedItemData.index) {
+            if (moveX > baseX && moveX < baseX + smallestWidth && itemData.index != this.draggedItemData.index) {
                 this.draggedOverItem = itemData.item;
                 this.draggedOverItemData = itemData;
                 const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item);
@@ -99,15 +166,20 @@ export default class DraggableSortController {
             }
         }
     };
-    /** setInitialDragPosition. */
+    /**
+     * Store the touch position where the current drag gesture started.
+     * @param {DraggableSortPosition} initialDragPosition
+     */
     setInitialDragPosition = (initialDragPosition) => {
         this.initialDragPosition = initialDragPosition;
     };
-    /** updatePositionOfItems. */
+    /** Animate non-dragged items into their current ordered positions. */
     updatePositionOfItems() {
         let currentPosition = 0;
         for (const item of this.currentOrder) {
             const itemData = this.getItemDataForItem(item);
+            if (!itemData)
+                throw new Error("Could not find item data while updating positions");
             if (digg(itemData, "index") != digg(this, "draggedItemData", "index")) {
                 // Dont animate dragged element to a new position because it is currently being dragged
                 itemData.events.emit("moveToPosition", {
@@ -120,4 +192,4 @@ export default class DraggableSortController {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"/src/","sources":["draggable-sort/controller.js"],"names":[],"mappings":"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","sourcesContent":["import {digg} from \"diggerize\"\nimport {EventEmitter} from \"eventemitter3\" // eslint-disable-line sort-imports\n\n/** Controller for drag-sort row state and events. */\nexport default class DraggableSortController {\n  /** Constructor. */\n  constructor({data, events, keyExtractor}) {\n    this.data = data\n    this.currentOrder = [...data]\n    this.events = events || new EventEmitter()\n    this.keyExtractor = keyExtractor\n\n    this.draggedItem = null\n    this.draggedItemData = null\n    this.draggedItemNewPosition = null\n\n    this.draggedOverItem = null\n    this.draggedOverItemData = null\n\n    this.itemData = {}\n\n    for (const itemIndex in data) {\n      this.itemData[itemIndex] = {\n        index: itemIndex,\n        item: data[itemIndex],\n        position: itemIndex\n      }\n    }\n  }\n\n  /** getEvents. */\n  getEvents = () => this.events\n\n  /** getItemDataForItem. */\n  getItemDataForItem = (item) => this.getItemDataForIndex(this.data.indexOf(item))\n\n  /** getItemDataForKey. */\n  getItemDataForKey = (key) => this.itemData.find((itemDataI) => digg(itemDataI, \"key\") == key)\n\n  /** getItemDataForIndex. */\n  getItemDataForIndex = (index) => digg(this, \"itemData\", index)\n\n  /** onDragStart. */\n  onDragStart = ({item, itemIndex}) => {\n    if (item) {\n      this.draggedItem = item\n      this.draggedItemData = this.getItemDataForIndex(itemIndex)\n      this.draggedItemIndex = itemIndex\n      this.draggedItemPosition = this.draggedItemData.position\n      this.events.emit(\"onDragStart\", {item, itemData: this.draggedItemData})\n    }\n  }\n\n  /** onDragEnd. */\n  onDragEnd = () => {\n    const itemData = this.draggedItemData\n    const fromIndex = itemData.index\n    const fromPosition = digg(this, \"draggedItemPosition\")\n    const toPosition = this.draggedItemNewPosition\n    const fromItem = this.draggedItem\n    const toItem = this.draggedOverItem\n    const callbackArgs = {item: itemData.item, itemData, fromIndex, fromItem, fromPosition, toItem, toPosition}\n\n    this.draggedItemData.events.emit(\"resetPosition\", {\n      callback: () => {\n        this.events.emit(\"onDragEndAnimation\", callbackArgs)\n      }\n    })\n\n    this.draggedItem = null\n    this.draggedItemData = null\n    this.draggedItemNewPosition = null\n\n    this.draggedOverItem = null\n    this.draggedOverItemData = null\n\n    this.events.emit(\"onDragEnd\", callbackArgs)\n  }\n\n  /** onItemLayout. */\n  onItemLayout = ({events, index, item, layout}) => {\n    if (!(index in this.itemData)) throw new Error(`Item not found for index ${index}`)\n\n    const itemData = this.itemData[index]\n\n    itemData.layout = layout\n\n    if (!itemData.initialLayout) {\n      itemData.baseX = layout.x\n      itemData.events = events\n      itemData.initialLayout = layout\n      itemData.key = this.keyExtractor(item)\n    }\n  }\n\n  /** onMove. */\n  onMove = ({gestate}) => {\n    // Send move-event to the item being dragged so it will actually move around\n    this.draggedItemData?.events?.emit(\"move\", {gestate})\n\n    const moveX = gestate.dx + this.initialDragPosition.x\n\n    for (const itemIndex in this.itemData) {\n      const itemData = this.getItemDataForIndex(itemIndex)\n      const baseX = digg(itemData, \"baseX\")\n      let smallestWidth = this.draggedItemData.layout.width\n\n      if (itemData.layout.width < smallestWidth) smallestWidth = itemData.layout.width\n\n      if (moveX > baseX && moveX < baseX + smallestWidth && itemIndex != this.draggedItemData.index) {\n        this.draggedOverItem = itemData.item\n        this.draggedOverItemData = itemData\n\n        const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item)\n        const positionOfOverItem = this.currentOrder.indexOf(this.draggedOverItemData.item)\n\n        this.currentOrder[positionOfDraggedItem] = this.draggedOverItemData.item\n        this.currentOrder[positionOfOverItem] = this.draggedItemData.item\n\n        this.draggedItemData.position = positionOfOverItem\n        this.draggedOverItemData.position = positionOfDraggedItem\n\n        this.updatePositionOfItems()\n        this.draggedItemNewPosition = positionOfOverItem\n      }\n    }\n  }\n\n  /** setInitialDragPosition. */\n  setInitialDragPosition = (initialDragPosition) => {\n    this.initialDragPosition = initialDragPosition\n  }\n\n  /** updatePositionOfItems. */\n  updatePositionOfItems() {\n    let currentPosition = 0\n\n    for (const item of this.currentOrder) {\n      const itemData = this.getItemDataForItem(item)\n\n      if (digg(itemData, \"index\") != digg(this, \"draggedItemData\", \"index\")) {\n        // Dont animate dragged element to a new position because it is currently being dragged\n        itemData.events.emit(\"moveToPosition\", {\n          x: currentPosition,\n          y: 0\n        })\n      }\n\n      itemData.baseX = currentPosition\n      currentPosition += digg(itemData, \"layout\", \"width\")\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"/src/","sources":["draggable-sort/controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport {digg} from \"diggerize\"\nimport {EventEmitter} from \"eventemitter3\" // eslint-disable-line sort-imports\n\n/** @typedef {import(\"eventemitter3\").EventEmitter} DraggableSortEventEmitter */\n/** @typedef {import(\"react-native\").LayoutRectangle} DraggableSortLayout */\n/** @typedef {import(\"react-native\").PanResponderGestureState} DraggableSortGestureState */\n/** @typedef {{x: number, y: number}} DraggableSortPosition */\n/** @typedef {(item: object) => string} DraggableSortKeyExtractor */\n/**\n * @typedef {object} DraggableSortItemData\n * @property {number} index\n * @property {object} item\n * @property {number} position\n * @property {number} [baseX]\n * @property {DraggableSortEventEmitter} [events]\n * @property {DraggableSortLayout} [initialLayout]\n * @property {string} [key]\n * @property {DraggableSortLayout} [layout]\n */\n/**\n * @typedef {object} DraggableSortDragEndArgs\n * @property {number} fromIndex\n * @property {object} fromItem\n * @property {number} fromPosition\n * @property {object} item\n * @property {DraggableSortItemData} itemData\n * @property {object|null} toItem\n * @property {number|null} toPosition\n */\n\n/** Controller for drag-sort row state and events. */\nexport default class DraggableSortController {\n  /**\n   * Set up drag-sort state for a list of draggable items.\n   * @param {object} root0\n   * @param {object[]} root0.data\n   * @param {DraggableSortEventEmitter} [root0.events]\n   * @param {DraggableSortKeyExtractor} root0.keyExtractor\n   */\n  constructor({data, events, keyExtractor}) {\n    this.data = /** @type {object[]} */ (data)\n    this.currentOrder = /** @type {object[]} */ ([...data])\n    this.events = /** @type {DraggableSortEventEmitter} */ (events || new EventEmitter())\n    this.keyExtractor = /** @type {DraggableSortKeyExtractor} */ (keyExtractor)\n    this.draggedItem = /** @type {object|null} */ (null)\n    this.draggedItemData = /** @type {DraggableSortItemData|null} */ (null)\n    this.draggedItemNewPosition = /** @type {number|null} */ (null)\n    this.draggedOverItem = /** @type {object|null} */ (null)\n    this.draggedOverItemData = /** @type {DraggableSortItemData|null} */ (null)\n    this.itemData = /** @type {Record<number, DraggableSortItemData>} */ ({})\n\n    for (const [itemIndex, item] of data.entries()) {\n      this.itemData[itemIndex] = {\n        index: itemIndex,\n        item,\n        position: itemIndex\n      }\n    }\n  }\n\n  /** @returns {DraggableSortEventEmitter} */\n  getEvents = () => this.events\n\n  /**\n   * Return the tracked drag metadata for the given item instance.\n   * @param {object} item\n   * @returns {DraggableSortItemData|undefined}\n   */\n  getItemDataForItem = (item) => this.getItemDataForIndex(this.data.indexOf(item))\n\n  /**\n   * Look up item metadata by its extracted stable key.\n   * @param {string} key\n   * @returns {DraggableSortItemData|undefined}\n   */\n  getItemDataForKey = (key) => Object.values(this.itemData).find((itemDataI) => digg(itemDataI, \"key\") == key)\n\n  /**\n   * Return the tracked drag metadata stored for a list index.\n   * @param {number} index\n   * @returns {DraggableSortItemData|undefined}\n   */\n  getItemDataForIndex = (index) => digg(this, \"itemData\", index)\n\n  /**\n   * Mark an item as the active dragged row and publish the drag-start event.\n   * @param {object} root0\n   * @param {object} root0.item\n   * @param {number} root0.itemIndex\n   */\n  onDragStart = ({item, itemIndex}) => {\n    if (item) {\n      this.draggedItem = item\n      this.draggedItemData = this.getItemDataForIndex(itemIndex)\n      if (!this.draggedItemData) throw new Error(`Item data not found for index ${itemIndex}`)\n\n      this.draggedItemIndex = itemIndex\n      this.draggedItemPosition = this.draggedItemData.position\n      this.events.emit(\"onDragStart\", {item, itemData: this.draggedItemData})\n    }\n  }\n\n  /** Finish the current drag and notify listeners about the final ordering. */\n  onDragEnd = () => {\n    if (!this.draggedItemData || !this.draggedItem) throw new Error(\"Cannot end drag without an active dragged item\")\n\n    const itemData = this.draggedItemData\n    const fromIndex = itemData.index\n    const fromPosition = digg(this, \"draggedItemPosition\")\n    const toPosition = this.draggedItemNewPosition\n    const fromItem = this.draggedItem\n    const toItem = this.draggedOverItem\n\n    /** @type {DraggableSortDragEndArgs} */\n    const callbackArgs = {item: itemData.item, itemData, fromIndex, fromItem, fromPosition, toItem, toPosition}\n\n    this.draggedItemData.events.emit(\"resetPosition\", {\n      callback: () => {\n        this.events.emit(\"onDragEndAnimation\", callbackArgs)\n      }\n    })\n\n    this.draggedItem = null\n    this.draggedItemData = null\n    this.draggedItemNewPosition = null\n\n    this.draggedOverItem = null\n    this.draggedOverItemData = null\n\n    this.events.emit(\"onDragEnd\", callbackArgs)\n  }\n\n  /**\n   * Store layout data and event bindings for a rendered draggable item.\n   * @param {object} root0\n   * @param {DraggableSortEventEmitter} root0.events\n   * @param {number} root0.index\n   * @param {object} root0.item\n   * @param {DraggableSortLayout} root0.layout\n   */\n  onItemLayout = ({events, index, item, layout}) => {\n    if (!(index in this.itemData)) throw new Error(`Item not found for index ${index}`)\n\n    const itemData = this.itemData[index]\n\n    itemData.layout = layout\n\n    if (!itemData.initialLayout) {\n      itemData.baseX = layout.x\n      itemData.events = events\n      itemData.initialLayout = layout\n      itemData.key = this.keyExtractor(item)\n    }\n  }\n\n  /**\n   * Update ordering as the active dragged item crosses other item positions.\n   * @param {object} root0\n   * @param {DraggableSortGestureState} root0.gestate\n   */\n  onMove = ({gestate}) => {\n    if (!this.draggedItemData || !this.initialDragPosition) return\n\n    // Send move-event to the item being dragged so it will actually move around\n    this.draggedItemData?.events?.emit(\"move\", {gestate})\n\n    const moveX = gestate.dx + this.initialDragPosition.x\n\n    for (const itemData of Object.values(this.itemData)) {\n      const baseX = digg(itemData, \"baseX\")\n      let smallestWidth = this.draggedItemData.layout.width\n\n      if (itemData.layout.width < smallestWidth) smallestWidth = itemData.layout.width\n\n      if (moveX > baseX && moveX < baseX + smallestWidth && itemData.index != this.draggedItemData.index) {\n        this.draggedOverItem = itemData.item\n        this.draggedOverItemData = itemData\n\n        const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item)\n        const positionOfOverItem = this.currentOrder.indexOf(this.draggedOverItemData.item)\n\n        this.currentOrder[positionOfDraggedItem] = this.draggedOverItemData.item\n        this.currentOrder[positionOfOverItem] = this.draggedItemData.item\n\n        this.draggedItemData.position = positionOfOverItem\n        this.draggedOverItemData.position = positionOfDraggedItem\n\n        this.updatePositionOfItems()\n        this.draggedItemNewPosition = positionOfOverItem\n      }\n    }\n  }\n\n  /**\n   * Store the touch position where the current drag gesture started.\n   * @param {DraggableSortPosition} initialDragPosition\n   */\n  setInitialDragPosition = (initialDragPosition) => {\n    this.initialDragPosition = initialDragPosition\n  }\n\n  /** Animate non-dragged items into their current ordered positions. */\n  updatePositionOfItems() {\n    let currentPosition = 0\n\n    for (const item of this.currentOrder) {\n      const itemData = this.getItemDataForItem(item)\n\n      if (!itemData) throw new Error(\"Could not find item data while updating positions\")\n\n      if (digg(itemData, \"index\") != digg(this, \"draggedItemData\", \"index\")) {\n        // Dont animate dragged element to a new position because it is currently being dragged\n        itemData.events.emit(\"moveToPosition\", {\n          x: currentPosition,\n          y: 0\n        })\n      }\n\n      itemData.baseX = currentPosition\n      currentPosition += digg(itemData, \"layout\", \"width\")\n    }\n  }\n}\n"]}

package/build/draggable-sort/index.d.ts

@@ -1,3 +1,59 @@
-declare const _default: any;
+declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type DraggableSortEventEmitter = import("eventemitter3").EventEmitter;
+export type DraggableTouchProps = import("react-native").GestureResponderHandlers;
+export type DraggablePosition = {
+    x: number;
+    y: number;
+};
+export type DraggableSortAnimationArgs = {
+    duration: number;
+    easing: (value: number) => number;
+    toValue: DraggablePosition;
+    useNativeDriver: boolean;
+};
+export type DraggableSortOnItemMovedArgs = {
+    animationArgs?: DraggableSortAnimationArgs;
+    itemIndex: number;
+    x: number;
+    y: number;
+};
+export type DraggableSortDragItemData = {
+    index: number;
+    item: object;
+    position: number;
+};
+export type DraggableSortDragStartArgs = {
+    itemData: DraggableSortDragItemData;
+};
+export type DraggableSortDragEndArgs = {
+    fromIndex: number;
+    fromItem: object;
+    fromPosition: number;
+    item: object;
+    itemData: DraggableSortDragItemData;
+    toItem: object | null;
+    toPosition: number | null;
+};
+export type DraggableSortRenderItemArgs = {
+    isActive: boolean;
+    item: object;
+    touchProps: DraggableTouchProps;
+};
+export type Props = {
+    activeItemStyle?: import("react-native").ViewStyle;
+    cacheKeyExtractor?: (item: object) => string;
+    data: object[];
+    dataSet?: object;
+    events?: DraggableSortEventEmitter;
+    horizontal?: boolean;
+    keyExtractor: (item: object) => string;
+    onDragItemEnd?: (args: DraggableSortDragEndArgs) => void;
+    onDragItemStart?: (args: DraggableSortDragStartArgs) => void;
+    onItemMoved?: (args: DraggableSortOnItemMovedArgs) => void;
+    onReordered: (args: DraggableSortDragEndArgs) => void | Promise<void>;
+    renderItem: (args: DraggableSortRenderItemArgs) => React.ReactNode;
+};
+export type State = Record<string, never>;
+import React from "react";
 //# sourceMappingURL=index.d.ts.map

package/build/draggable-sort/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"/src/","sources":["draggable-sort/index.jsx"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"/src/","sources":["draggable-sort/index.jsx"],"names":[],"mappings":";;wCAac,OAAO,eAAe,EAAE,YAAY;kCACpC,OAAO,cAAc,EAAE,wBAAwB;gCAC/C;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC;;cAGtB,MAAM;YACN,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM;aACzB,iBAAiB;qBACjB,OAAO;;;oBAIP,0BAA0B;eAC1B,MAAM;OACN,MAAM;OACN,MAAM;;;WAIN,MAAM;UACN,MAAM;cACN,MAAM;;;cAIN,yBAAyB;;;eAIzB,MAAM;cACN,MAAM;kBACN,MAAM;UACN,MAAM;cACN,yBAAyB;YACzB,MAAM,GAAC,IAAI;gBACX,MAAM,GAAC,IAAI;;;cAIX,OAAO;UACP,MAAM;gBACN,mBAAmB;;;sBAKnB,OAAO,cAAc,EAAE,SAAS;wBAChC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;UACxB,MAAM,EAAE;cACR,MAAM;aACN,yBAAyB;iBACzB,OAAO;kBACP,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;oBACxB,CAAC,IAAI,EAAE,wBAAwB,KAAK,IAAI;sBACxC,CAAC,IAAI,EAAE,0BAA0B,KAAK,IAAI;kBAC1C,CAAC,IAAI,EAAE,4BAA4B,KAAK,IAAI;iBAC5C,CAAC,IAAI,EAAE,wBAAwB,KAAK,IAAI,GAAC,OAAO,CAAC,IAAI,CAAC;gBACtD,CAAC,IAAI,EAAE,2BAA2B,KAAK,KAAK,CAAC,SAAS;;oBAEtD,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;kBApEN,OAAO"}

package/build/draggable-sort/index.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable sort-imports */
 import { Animated, PanResponder } from "react-native";
 import { EventEmitter } from "eventemitter3";
@@ -10,7 +11,66 @@ import PropTypes from "prop-types";
 import memo from "set-state-compare/build/memo.js";
 import propTypesExact from "prop-types-exact";
 import useEventEmitter from "ya-use-event-emitter";
-export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
+/** @typedef {import("eventemitter3").EventEmitter} DraggableSortEventEmitter */
+/** @typedef {import("react-native").GestureResponderHandlers} DraggableTouchProps */
+/** @typedef {{x: number, y: number}} DraggablePosition */
+/**
+ * @typedef {object} DraggableSortAnimationArgs
+ * @property {number} duration
+ * @property {(value: number) => number} easing
+ * @property {DraggablePosition} toValue
+ * @property {boolean} useNativeDriver
+ */
+/**
+ * @typedef {object} DraggableSortOnItemMovedArgs
+ * @property {DraggableSortAnimationArgs} [animationArgs]
+ * @property {number} itemIndex
+ * @property {number} x
+ * @property {number} y
+ */
+/**
+ * @typedef {object} DraggableSortDragItemData
+ * @property {number} index
+ * @property {object} item
+ * @property {number} position
+ */
+/**
+ * @typedef {object} DraggableSortDragStartArgs
+ * @property {DraggableSortDragItemData} itemData
+ */
+/**
+ * @typedef {object} DraggableSortDragEndArgs
+ * @property {number} fromIndex
+ * @property {object} fromItem
+ * @property {number} fromPosition
+ * @property {object} item
+ * @property {DraggableSortDragItemData} itemData
+ * @property {object|null} toItem
+ * @property {number|null} toPosition
+ */
+/**
+ * @typedef {object} DraggableSortRenderItemArgs
+ * @property {boolean} isActive
+ * @property {object} item
+ * @property {DraggableTouchProps} touchProps
+ */
+/**
+ * @typedef {object} Props
+ * @property {import("react-native").ViewStyle} [activeItemStyle]
+ * @property {(item: object) => string} [cacheKeyExtractor]
+ * @property {object[]} data
+ * @property {object} [dataSet]
+ * @property {DraggableSortEventEmitter} [events]
+ * @property {boolean} [horizontal]
+ * @property {(item: object) => string} keyExtractor
+ * @property {(args: DraggableSortDragEndArgs) => void} [onDragItemEnd]
+ * @property {(args: DraggableSortDragStartArgs) => void} [onDragItemStart]
+ * @property {(args: DraggableSortOnItemMovedArgs) => void} [onItemMoved]
+ * @property {(args: DraggableSortDragEndArgs) => void|Promise<void>} onReordered
+ * @property {(args: DraggableSortRenderItemArgs) => React.ReactNode} renderItem
+ */
+/** @typedef {Record<string, never>} State */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class DraggableSort extends ShapeComponent {
     /** @type {import("./controller.js").default} */
     controller;
     /** @type {import("react-native").PanResponderInstance} */
@@ -25,7 +85,7 @@ export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
         data: PropTypes.array.isRequired,
         dataSet: PropTypes.object,
         events: PropTypes.instanceOf(EventEmitter),
-        horizontal: PropTypes.bool.isRequired,
+        horizontal: PropTypes.bool,
         keyExtractor: PropTypes.func.isRequired,
         onDragItemEnd: PropTypes.func,
         onDragItemStart: PropTypes.func,
@@ -66,11 +126,19 @@ export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
         }), [dataSet]);
         return (_jsx(Animated.View, { dataSet: actualDataSet, style: this.cache("rootViewStyle", { flexDirection: horizontal ? "row" : "column" }, [horizontal]), ...this.tt.panResponder.panHandlers, children: data.map((item, itemIndex) => (_jsx(DraggableSortItem, { activeItemStyle: this.p.activeItemStyle, cacheKey: cacheKeyExtractor ? cacheKeyExtractor(item) : undefined, controller: this.tt.controller, item: item, itemIndex: itemIndex, onItemMoved: this.props.onItemMoved, renderItem: renderItem }, keyExtractor(item)))) }));
     }
+    /**
+     * Forward drag-start notifications to the optional parent callback.
+     * @param {DraggableSortDragStartArgs} root0
+     */
     onDragItemStart = ({ itemData }) => {
         if (this.props.onDragItemStart) {
             this.p.onDragItemStart({ itemData });
         }
     };
+    /**
+     * Forward drag-end notifications and persist the reordered list when needed.
+     * @param {DraggableSortDragEndArgs} args
+     */
     onDragItemEnd = (args) => {
         if (args.toPosition !== null) {
             this.p.onReordered(args);
@@ -80,4 +148,4 @@ export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
         }
     };
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"/src/","sources":["draggable-sort/index.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable sort-imports */\nimport {Animated, PanResponder} from \"react-native\"\nimport {EventEmitter} from \"eventemitter3\"\nimport React, {useMemo} from \"react\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Controller from \"./controller.js\"\nimport DraggableSortItem from \"./item\"\nimport PropTypes from \"prop-types\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"ya-use-event-emitter\"\n\nexport default memo(shapeComponent(class DraggableSort extends ShapeComponent {\n  /** @type {import(\"./controller.js\").default} */\n  controller\n\n  /** @type {import(\"react-native\").PanResponderInstance} */\n  panResponder\n\n  static defaultProps = {\n    activeItemStyle: {backgroundColor: \"#fff\"},\n    horizontal: false\n  }\n\n  static propTypes = propTypesExact({\n    activeItemStyle: PropTypes.object,\n    cacheKeyExtractor: PropTypes.func,\n    data: PropTypes.array.isRequired,\n    dataSet: PropTypes.object,\n    events: PropTypes.instanceOf(EventEmitter),\n    horizontal: PropTypes.bool.isRequired,\n    keyExtractor: PropTypes.func.isRequired,\n    onDragItemEnd: PropTypes.func,\n    onDragItemStart: PropTypes.func,\n    onItemMoved: PropTypes.func,\n    onReordered: PropTypes.func.isRequired,\n    renderItem: PropTypes.func.isRequired\n  })\n\n  setup() {\n    const {data, keyExtractor} = this.p\n    const {events} = this.props\n\n    this.controller ||= new Controller({data, events, keyExtractor})\n    this.panResponder ||= PanResponder.create({\n      onStartShouldSetPanResponder: (e) => {\n        const initialDragPosition = {x: e.nativeEvent.locationX, y: e.nativeEvent.locationY}\n\n        this.controller.setInitialDragPosition(initialDragPosition)\n\n        if (this.controller.draggedItemData) {\n          return true\n        }\n      },\n      onPanResponderMove: (_e, gestate) => {\n        this.tt.controller.onMove({gestate})\n      },\n      onPanResponderRelease: (_e, _gestate) => {\n        if (this.controller.draggedItem) {\n          this.tt.controller.onDragEnd()\n        }\n      }\n    })\n\n    useEventEmitter(this.controller.getEvents(), \"onDragStart\", this.tt.onDragItemStart)\n    useEventEmitter(this.controller.getEvents(), \"onDragEnd\", this.tt.onDragItemEnd)\n  }\n\n  render() {\n    const {data, horizontal, keyExtractor, renderItem} = this.p\n    const {cacheKeyExtractor, dataSet} = this.props\n    const actualDataSet = useMemo(() => ({\n      component: \"draggable-sort\",\n      ...dataSet\n    }), [dataSet])\n\n    return (\n      <Animated.View\n        dataSet={actualDataSet}\n        style={this.cache(\"rootViewStyle\", {flexDirection: horizontal ? \"row\" : \"column\"}, [horizontal])}\n        {...this.tt.panResponder.panHandlers}\n      >\n        {data.map((item, itemIndex) => (\n          <DraggableSortItem\n            activeItemStyle={this.p.activeItemStyle}\n            cacheKey={cacheKeyExtractor ? cacheKeyExtractor(item) : undefined}\n            controller={this.tt.controller}\n            item={item}\n            itemIndex={itemIndex}\n            key={keyExtractor(item)}\n            onItemMoved={this.props.onItemMoved}\n            renderItem={renderItem}\n          />\n        ))}\n      </Animated.View>\n    )\n  }\n\n  onDragItemStart = ({itemData}) => {\n    if (this.props.onDragItemStart) {\n      this.p.onDragItemStart({itemData})\n    }\n  }\n\n  onDragItemEnd = (args) => {\n    if (args.toPosition !== null) {\n      this.p.onReordered(args)\n    }\n\n    if (this.props.onDragItemEnd) {\n      this.p.onDragItemEnd(args)\n    }\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"/src/","sources":["draggable-sort/index.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable sort-imports */\nimport {Animated, PanResponder} from \"react-native\"\nimport {EventEmitter} from \"eventemitter3\"\nimport React, {useMemo} from \"react\"\nimport {ShapeComponent, shapeComponent} from \"set-state-compare/build/shape-component.js\"\nimport Controller from \"./controller.js\"\nimport DraggableSortItem from \"./item\"\nimport PropTypes from \"prop-types\"\nimport memo from \"set-state-compare/build/memo.js\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"ya-use-event-emitter\"\n\n/** @typedef {import(\"eventemitter3\").EventEmitter} DraggableSortEventEmitter */\n/** @typedef {import(\"react-native\").GestureResponderHandlers} DraggableTouchProps */\n/** @typedef {{x: number, y: number}} DraggablePosition */\n/**\n * @typedef {object} DraggableSortAnimationArgs\n * @property {number} duration\n * @property {(value: number) => number} easing\n * @property {DraggablePosition} toValue\n * @property {boolean} useNativeDriver\n */\n/**\n * @typedef {object} DraggableSortOnItemMovedArgs\n * @property {DraggableSortAnimationArgs} [animationArgs]\n * @property {number} itemIndex\n * @property {number} x\n * @property {number} y\n */\n/**\n * @typedef {object} DraggableSortDragItemData\n * @property {number} index\n * @property {object} item\n * @property {number} position\n */\n/**\n * @typedef {object} DraggableSortDragStartArgs\n * @property {DraggableSortDragItemData} itemData\n */\n/**\n * @typedef {object} DraggableSortDragEndArgs\n * @property {number} fromIndex\n * @property {object} fromItem\n * @property {number} fromPosition\n * @property {object} item\n * @property {DraggableSortDragItemData} itemData\n * @property {object|null} toItem\n * @property {number|null} toPosition\n */\n/**\n * @typedef {object} DraggableSortRenderItemArgs\n * @property {boolean} isActive\n * @property {object} item\n * @property {DraggableTouchProps} touchProps\n */\n\n/**\n * @typedef {object} Props\n * @property {import(\"react-native\").ViewStyle} [activeItemStyle]\n * @property {(item: object) => string} [cacheKeyExtractor]\n * @property {object[]} data\n * @property {object} [dataSet]\n * @property {DraggableSortEventEmitter} [events]\n * @property {boolean} [horizontal]\n * @property {(item: object) => string} keyExtractor\n * @property {(args: DraggableSortDragEndArgs) => void} [onDragItemEnd]\n * @property {(args: DraggableSortDragStartArgs) => void} [onDragItemStart]\n * @property {(args: DraggableSortOnItemMovedArgs) => void} [onItemMoved]\n * @property {(args: DraggableSortDragEndArgs) => void|Promise<void>} onReordered\n * @property {(args: DraggableSortRenderItemArgs) => React.ReactNode} renderItem\n */\n/** @typedef {Record<string, never>} State */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class DraggableSort extends ShapeComponent {\n  /** @type {import(\"./controller.js\").default} */\n  controller\n\n  /** @type {import(\"react-native\").PanResponderInstance} */\n  panResponder\n\n  static defaultProps = {\n    activeItemStyle: {backgroundColor: \"#fff\"},\n    horizontal: false\n  }\n\n  static propTypes = propTypesExact({\n    activeItemStyle: PropTypes.object,\n    cacheKeyExtractor: PropTypes.func,\n    data: PropTypes.array.isRequired,\n    dataSet: PropTypes.object,\n    events: PropTypes.instanceOf(EventEmitter),\n    horizontal: PropTypes.bool,\n    keyExtractor: PropTypes.func.isRequired,\n    onDragItemEnd: PropTypes.func,\n    onDragItemStart: PropTypes.func,\n    onItemMoved: PropTypes.func,\n    onReordered: PropTypes.func.isRequired,\n    renderItem: PropTypes.func.isRequired\n  })\n\n  setup() {\n    const {data, keyExtractor} = this.p\n    const {events} = this.props\n\n    this.controller ||= new Controller({data, events, keyExtractor})\n    this.panResponder ||= PanResponder.create({\n      onStartShouldSetPanResponder: (e) => {\n        const initialDragPosition = {x: e.nativeEvent.locationX, y: e.nativeEvent.locationY}\n\n        this.controller.setInitialDragPosition(initialDragPosition)\n\n        if (this.controller.draggedItemData) {\n          return true\n        }\n      },\n      onPanResponderMove: (_e, gestate) => {\n        this.tt.controller.onMove({gestate})\n      },\n      onPanResponderRelease: (_e, _gestate) => {\n        if (this.controller.draggedItem) {\n          this.tt.controller.onDragEnd()\n        }\n      }\n    })\n\n    useEventEmitter(this.controller.getEvents(), \"onDragStart\", this.tt.onDragItemStart)\n    useEventEmitter(this.controller.getEvents(), \"onDragEnd\", this.tt.onDragItemEnd)\n  }\n\n  render() {\n    const {data, horizontal, keyExtractor, renderItem} = this.p\n    const {cacheKeyExtractor, dataSet} = this.props\n    const actualDataSet = useMemo(() => ({\n      component: \"draggable-sort\",\n      ...dataSet\n    }), [dataSet])\n\n    return (\n      <Animated.View\n        dataSet={actualDataSet}\n        style={this.cache(\"rootViewStyle\", {flexDirection: horizontal ? \"row\" : \"column\"}, [horizontal])}\n        {...this.tt.panResponder.panHandlers}\n      >\n        {data.map((item, itemIndex) => (\n          <DraggableSortItem\n            activeItemStyle={this.p.activeItemStyle}\n            cacheKey={cacheKeyExtractor ? cacheKeyExtractor(item) : undefined}\n            controller={this.tt.controller}\n            item={item}\n            itemIndex={itemIndex}\n            key={keyExtractor(item)}\n            onItemMoved={this.props.onItemMoved}\n            renderItem={renderItem}\n          />\n        ))}\n      </Animated.View>\n    )\n  }\n\n  /**\n   * Forward drag-start notifications to the optional parent callback.\n   * @param {DraggableSortDragStartArgs} root0\n   */\n  onDragItemStart = ({itemData}) => {\n    if (this.props.onDragItemStart) {\n      this.p.onDragItemStart({itemData})\n    }\n  }\n\n  /**\n   * Forward drag-end notifications and persist the reordered list when needed.\n   * @param {DraggableSortDragEndArgs} args\n   */\n  onDragItemEnd = (args) => {\n    if (args.toPosition !== null) {\n      this.p.onReordered(args)\n    }\n\n    if (this.props.onDragItemEnd) {\n      this.p.onDragItemEnd(args)\n    }\n  }\n}))\n"]}

package/build/draggable-sort/item.d.ts

@@ -1,3 +1,58 @@
-declare const _default: any;
+declare const _default: React.NamedExoticComponent<Record<string, any>>;
 export default _default;
+export type DraggableSortController = import("./controller.js").default;
+export type DraggableSortEventEmitter = import("eventemitter3").EventEmitter;
+export type DraggableTouchProps = import("react-native").GestureResponderHandlers;
+export type DraggableSortLayout = import("react-native").LayoutRectangle;
+export type DraggableSortGestureState = import("react-native").PanResponderGestureState;
+export type DraggablePosition = {
+    x: number;
+    y: number;
+};
+export type DraggableSortAnimationArgs = {
+    duration: number;
+    easing: (value: number) => number;
+    toValue: DraggablePosition;
+    useNativeDriver: boolean;
+};
+export type DraggableSortOnItemMovedArgs = {
+    animationArgs?: DraggableSortAnimationArgs;
+    itemIndex: number;
+    x: number;
+    y: number;
+};
+export type DraggableSortRenderItemArgs = {
+    isActive: boolean;
+    item: object;
+    touchProps: DraggableTouchProps;
+};
+export type DraggableSortItemData = {
+    index: number;
+    item: object;
+    position: number;
+};
+export type DraggableSortMoveEventArgs = {
+    gestate: DraggableSortGestureState;
+};
+export type DraggableSortMoveToPositionArgs = {
+    x: number;
+    y: number;
+};
+export type DraggableSortResetPositionArgs = {
+    callback?: () => void;
+};
+export type Props = {
+    activeItemStyle?: import("react-native").ViewStyle;
+    cacheKey?: string;
+    controller: DraggableSortController;
+    item: object;
+    itemIndex: number;
+    onItemMoved?: (args: DraggableSortOnItemMovedArgs) => void;
+    renderItem: (args: DraggableSortRenderItemArgs) => React.ReactNode;
+};
+export type State = {
+    active: boolean;
+    dragging: boolean;
+};
+import React from "react";
 //# sourceMappingURL=item.d.ts.map

package/build/draggable-sort/item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"/src/","sources":["draggable-sort/item.jsx"],"names":[],"mappings":""}
+{"version":3,"file":"item.d.ts","sourceRoot":"/src/","sources":["draggable-sort/item.jsx"],"names":[],"mappings":";;sCAWc,OAAO,iBAAiB,EAAE,OAAO;wCACjC,OAAO,eAAe,EAAE,YAAY;kCACpC,OAAO,cAAc,EAAE,wBAAwB;kCAC/C,OAAO,cAAc,EAAE,eAAe;wCACtC,OAAO,cAAc,EAAE,wBAAwB;gCAC/C;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC;;cAGtB,MAAM;YACN,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM;aACzB,iBAAiB;qBACjB,OAAO;;;oBAIP,0BAA0B;eAC1B,MAAM;OACN,MAAM;OACN,MAAM;;;cAIN,OAAO;UACP,MAAM;gBACN,mBAAmB;;;WAInB,MAAM;UACN,MAAM;cACN,MAAM;;;aAIN,yBAAyB;;;OAIzB,MAAM;OACN,MAAM;;;eAIN,MAAM,IAAI;;;sBAKV,OAAO,cAAc,EAAE,SAAS;eAChC,MAAM;gBACN,uBAAuB;UACvB,MAAM;eACN,MAAM;kBACN,CAAC,IAAI,EAAE,4BAA4B,KAAK,IAAI;gBAC5C,CAAC,IAAI,EAAE,2BAA2B,KAAK,KAAK,CAAC,SAAS;;;YAItD,OAAO;cACP,OAAO;;kBAlEQ,OAAO"}