@kaspernj/api-maker 1.0.2160 → 1.0.2161

package/build/draggable-sort/item.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+// @ts-check
 /* eslint-disable sort-imports */
 import { Animated, Easing, PanResponder } from "react-native";
 import { EventEmitter } from "eventemitter3";
@@ -8,22 +9,83 @@ 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 DraggableSortItem extends ShapeComponent {
+/** @typedef {import("./controller.js").default} DraggableSortController */
+/** @typedef {import("eventemitter3").EventEmitter} DraggableSortEventEmitter */
+/** @typedef {import("react-native").GestureResponderHandlers} DraggableTouchProps */
+/** @typedef {import("react-native").LayoutRectangle} DraggableSortLayout */
+/** @typedef {import("react-native").PanResponderGestureState} DraggableSortGestureState */
+/** @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} DraggableSortRenderItemArgs
+ * @property {boolean} isActive
+ * @property {object} item
+ * @property {DraggableTouchProps} touchProps
+ */
+/**
+ * @typedef {object} DraggableSortItemData
+ * @property {number} index
+ * @property {object} item
+ * @property {number} position
+ */
+/**
+ * @typedef {object} DraggableSortMoveEventArgs
+ * @property {DraggableSortGestureState} gestate
+ */
+/**
+ * @typedef {object} DraggableSortMoveToPositionArgs
+ * @property {number} x
+ * @property {number} y
+ */
+/**
+ * @typedef {object} DraggableSortResetPositionArgs
+ * @property {() => void} [callback]
+ */
+/**
+ * @typedef {object} Props
+ * @property {import("react-native").ViewStyle} [activeItemStyle]
+ * @property {string} [cacheKey]
+ * @property {DraggableSortController} controller
+ * @property {object} item
+ * @property {number} itemIndex
+ * @property {(args: DraggableSortOnItemMovedArgs) => void} [onItemMoved]
+ * @property {(args: DraggableSortRenderItemArgs) => React.ReactNode} renderItem
+ */
+/**
+ * @typedef {object} State
+ * @property {boolean} active
+ * @property {boolean} dragging
+ */
+export default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class DraggableSortItem extends ShapeComponent {
     static propTypes = propTypesExact({
         activeItemStyle: PropTypes.object,
         cacheKey: PropTypes.string,
         controller: PropTypes.object.isRequired,
-        item: PropTypes.any.isRequired,
+        item: PropTypes.object.isRequired,
         itemIndex: PropTypes.number.isRequired,
         onItemMoved: PropTypes.func,
         renderItem: PropTypes.func.isRequired
     });
-    /** @type {import("eventemitter3").EventEmitter} */
+    /** @type {DraggableSortEventEmitter} */
     events;
     /** @type {import("react-native").Animated.ValueXY} */
     position;
     /** @type {import("react-native").PanResponderInstance} */
     panResponder;
+    /** @type {DraggableSortLayout|null} */
     initialLayout = null;
     state = {
         active: false,
@@ -50,13 +112,14 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
         const { active } = this.s;
         const style = useMemo(() => {
             const baseTransform = this.tt.position.getTranslateTransform();
+            /** @type {import("react-native").ViewStyle} */
             const style = { transform: baseTransform };
             if (active) {
                 if (activeItemStyle) {
                     const { transform: activeTransform, ...restActiveStyle } = activeItemStyle;
                     if (activeTransform) {
-                        const normalizedActiveTransform = Array.isArray(activeTransform) ? activeTransform : [activeTransform];
-                        style.transform = /** @type {any} */ (baseTransform.concat(normalizedActiveTransform));
+                        const normalizedActiveTransform = /** @type {NonNullable<import("react-native").TransformsStyle["transform"]>} */ (Array.isArray(activeTransform) ? activeTransform : [activeTransform]);
+                        style.transform = /** @type {import("react-native").ViewStyle["transform"]} */ ([...baseTransform, ...normalizedActiveTransform]);
                     }
                     Object.assign(style, restActiveStyle);
                 }
@@ -67,6 +130,10 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
         }, [active, activeItemStyle]);
         return (_jsx(Animated.View, { dataSet: this.cache("draggableSortItemDataSet", { component: "draggable-sort/item" }), onLayout: this.tt.onLayout, style: style, children: renderItem({ isActive: active, item, touchProps: this.tt.panResponder.panHandlers }) }));
     }
+    /**
+     * Activate the dragged item after the controller announces drag start.
+     * @param {{itemData: DraggableSortItemData}} root0
+     */
     onDragStart = ({ itemData }) => {
         const newState = { dragging: true };
         if (itemData.index == this.p.itemIndex) {
@@ -76,6 +143,7 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
         this.setState(newState);
     };
     onDragEndAnimation = () => this.setState({ active: false, dragging: false });
+    /** @param {{nativeEvent: {layout: DraggableSortLayout}}} e */
     onLayout = (e) => {
         const { controller, item, itemIndex } = this.p;
         controller.onItemLayout({ events: this.tt.events, index: itemIndex, item, layout: e.nativeEvent.layout });
@@ -83,7 +151,13 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
             this.initialLayout = e.nativeEvent.layout;
         }
     };
+    /**
+     * Move the active item in sync with the current drag gesture.
+     * @param {DraggableSortMoveEventArgs} root0
+     */
     onMove = ({ gestate }) => {
+        if (!this.tt.initialLayout)
+            throw new Error("Expected initial layout before moving draggable item");
         const x = gestate.dx + this.tt.baseXAtStartedDragging - this.tt.initialLayout.x;
         const y = this.tt.initialLayout.y;
         this.tt.position.setValue({ x, y });
@@ -91,8 +165,15 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
             this.p.onItemMoved({ itemIndex: this.p.itemIndex, x, y });
         }
     };
+    /**
+     * Animate a non-dragged item into its new ordered position.
+     * @param {DraggableSortMoveToPositionArgs} root0
+     */
     onMoveToPosition = ({ x, y }) => {
+        if (!this.tt.initialLayout)
+            throw new Error("Expected initial layout before animating item position");
         const calculatedXFromStartingPosition = x - this.tt.initialLayout.x;
+        /** @type {DraggableSortAnimationArgs} */
         const animationArgs = {
             duration: 200,
             easing: Easing.inOut(Easing.linear),
@@ -119,8 +200,15 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
         }
     };
     getBaseX = () => this.p.controller.getItemDataForIndex(this.p.itemIndex).baseX;
+    /**
+     * Animate the dragged item back to its base position after drag end.
+     * @param {DraggableSortResetPositionArgs} [args]
+     */
     onResetPosition = (args) => {
+        if (!this.tt.initialLayout)
+            throw new Error("Expected initial layout before resetting item position");
         const baseX = this.getBaseX() - this.tt.initialLayout.x;
+        /** @type {DraggableSortAnimationArgs} */
         const animationArgs = {
             duration: 200,
             easing: Easing.inOut(Easing.linear),
@@ -149,4 +237,4 @@ export default memo(shapeComponent(class DraggableSortItem extends ShapeComponen
         }
     };
 }));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item.js","sourceRoot":"/src/","sources":["draggable-sort/item.jsx"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable sort-imports */\nimport {Animated, Easing, 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 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 DraggableSortItem extends ShapeComponent {\n  static propTypes = propTypesExact({\n    activeItemStyle: PropTypes.object,\n    cacheKey: PropTypes.string,\n    controller: PropTypes.object.isRequired,\n    item: PropTypes.any.isRequired,\n    itemIndex: PropTypes.number.isRequired,\n    onItemMoved: PropTypes.func,\n    renderItem: PropTypes.func.isRequired\n  })\n\n  /** @type {import(\"eventemitter3\").EventEmitter} */\n  events\n\n  /** @type {import(\"react-native\").Animated.ValueXY} */\n  position\n\n  /** @type {import(\"react-native\").PanResponderInstance} */\n  panResponder\n\n  initialLayout = null\n  state = {\n    active: false,\n    dragging: false\n  }\n\n  setup() {\n    this.events ||= new EventEmitter()\n    this.position ||= new Animated.ValueXY()\n    this.panResponder ||= PanResponder.create({\n      onStartShouldSetPanResponder: (_event) => {\n        this.setState({dragging: true})\n        this.p.controller.onDragStart({item: this.p.item, itemIndex: this.p.itemIndex})\n\n        return false\n      }\n    })\n\n    useEventEmitter(this.p.controller.getEvents(), \"onDragStart\", this.tt.onDragStart)\n    useEventEmitter(this.p.controller.getEvents(), \"onDragEndAnimation\", this.tt.onDragEndAnimation)\n    useEventEmitter(this.tt.events, \"move\", this.tt.onMove)\n    useEventEmitter(this.tt.events, \"moveToPosition\", this.tt.onMoveToPosition)\n    useEventEmitter(this.tt.events, \"resetPosition\", this.tt.onResetPosition)\n  }\n\n  render() {\n    const {activeItemStyle, item, renderItem} = this.p\n    const {active} = this.s\n    const style = useMemo(\n      () => {\n        const baseTransform = this.tt.position.getTranslateTransform()\n        const style = {transform: baseTransform}\n\n        if (active) {\n          if (activeItemStyle) {\n            const {transform: activeTransform, ...restActiveStyle} = activeItemStyle\n\n            if (activeTransform) {\n              const normalizedActiveTransform = Array.isArray(activeTransform) ? activeTransform : [activeTransform]\n\n              style.transform = /** @type {any} */ (baseTransform.concat(normalizedActiveTransform))\n            }\n\n            Object.assign(style, restActiveStyle)\n          }\n          style.elevation = 2\n          style.zIndex = 99999\n        }\n\n        return style\n      },\n      [active, activeItemStyle]\n    )\n\n    return (\n      <Animated.View dataSet={this.cache(\"draggableSortItemDataSet\", {component: \"draggable-sort/item\"})} onLayout={this.tt.onLayout} style={style}>\n        {renderItem({isActive: active, item, touchProps: this.tt.panResponder.panHandlers})}\n      </Animated.View>\n    )\n  }\n\n  onDragStart = ({itemData}) => {\n    const newState = {dragging: true}\n\n    if (itemData.index == this.p.itemIndex) {\n      newState.active = true\n      this.baseXAtStartedDragging = this.getBaseX()\n    }\n\n    this.setState(newState)\n  }\n\n  onDragEndAnimation = () => this.setState({active: false, dragging: false})\n\n  onLayout = (e) => {\n    const {controller, item, itemIndex} = this.p\n\n    controller.onItemLayout({events: this.tt.events, index: itemIndex, item, layout: e.nativeEvent.layout})\n\n    if (!this.tt.initialLayout) {\n      this.initialLayout = e.nativeEvent.layout\n    }\n  }\n\n  onMove = ({gestate}) => {\n    const x = gestate.dx + this.tt.baseXAtStartedDragging - this.tt.initialLayout.x\n    const y = this.tt.initialLayout.y\n\n    this.tt.position.setValue({x, y})\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({itemIndex: this.p.itemIndex, x, y})\n    }\n  }\n\n  onMoveToPosition = ({x, y}) => {\n    const calculatedXFromStartingPosition = x - this.tt.initialLayout.x\n    const animationArgs = {\n      duration: 200,\n      easing: Easing.inOut(Easing.linear),\n      toValue: {\n        x: calculatedXFromStartingPosition,\n        y\n      },\n      useNativeDriver: true\n    }\n    const animationEventArgs = {animationArgs, animationType: \"moveToPosition\", item: this.p.item}\n\n    this.p.controller.events.emit(\"onAnimationStart\", animationEventArgs)\n\n    Animated\n      .timing(this.tt.position, animationArgs)\n      .start(() => {\n        this.p.controller.events.emit(\"onAnimationEnd\", animationEventArgs)\n      })\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({\n        animationArgs,\n        itemIndex: this.p.itemIndex,\n        x: calculatedXFromStartingPosition,\n        y\n      })\n    }\n  }\n\n  getBaseX = () => this.p.controller.getItemDataForIndex(this.p.itemIndex).baseX\n\n  onResetPosition = (args) => {\n    const baseX = this.getBaseX() - this.tt.initialLayout.x\n    const animationArgs = {\n      duration: 200,\n      easing: Easing.inOut(Easing.linear),\n      toValue: {\n        x: baseX,\n        y: 0\n      },\n      useNativeDriver: true\n    }\n    const animationEventArgs = {animationArgs, animationType: \"resetPosition\", item: this.p.item}\n\n    this.p.controller.events.emit(\"onAnimationStart\", animationEventArgs)\n\n    Animated\n      .timing(this.tt.position, animationArgs)\n      .start(() => {\n        this.p.controller.events.emit(\"onAnimationEnd\", animationEventArgs)\n        if (args?.callback) args.callback()\n      })\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({\n        animationArgs,\n        itemIndex: this.p.itemIndex,\n        x: baseX,\n        y: 0\n      })\n    }\n  }\n}))\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"item.js","sourceRoot":"/src/","sources":["draggable-sort/item.jsx"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n/* eslint-disable sort-imports */\nimport {Animated, Easing, 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 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(\"./controller.js\").default} DraggableSortController */\n/** @typedef {import(\"eventemitter3\").EventEmitter} DraggableSortEventEmitter */\n/** @typedef {import(\"react-native\").GestureResponderHandlers} DraggableTouchProps */\n/** @typedef {import(\"react-native\").LayoutRectangle} DraggableSortLayout */\n/** @typedef {import(\"react-native\").PanResponderGestureState} DraggableSortGestureState */\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} DraggableSortRenderItemArgs\n * @property {boolean} isActive\n * @property {object} item\n * @property {DraggableTouchProps} touchProps\n */\n/**\n * @typedef {object} DraggableSortItemData\n * @property {number} index\n * @property {object} item\n * @property {number} position\n */\n/**\n * @typedef {object} DraggableSortMoveEventArgs\n * @property {DraggableSortGestureState} gestate\n */\n/**\n * @typedef {object} DraggableSortMoveToPositionArgs\n * @property {number} x\n * @property {number} y\n */\n/**\n * @typedef {object} DraggableSortResetPositionArgs\n * @property {() => void} [callback]\n */\n\n/**\n * @typedef {object} Props\n * @property {import(\"react-native\").ViewStyle} [activeItemStyle]\n * @property {string} [cacheKey]\n * @property {DraggableSortController} controller\n * @property {object} item\n * @property {number} itemIndex\n * @property {(args: DraggableSortOnItemMovedArgs) => void} [onItemMoved]\n * @property {(args: DraggableSortRenderItemArgs) => React.ReactNode} renderItem\n */\n/**\n * @typedef {object} State\n * @property {boolean} active\n * @property {boolean} dragging\n */\nexport default memo(shapeComponent(/** @augments {ShapeComponent<Props, State>} */ class DraggableSortItem extends ShapeComponent {\n  static propTypes = propTypesExact({\n    activeItemStyle: PropTypes.object,\n    cacheKey: PropTypes.string,\n    controller: PropTypes.object.isRequired,\n    item: PropTypes.object.isRequired,\n    itemIndex: PropTypes.number.isRequired,\n    onItemMoved: PropTypes.func,\n    renderItem: PropTypes.func.isRequired\n  })\n\n  /** @type {DraggableSortEventEmitter} */\n  events\n\n  /** @type {import(\"react-native\").Animated.ValueXY} */\n  position\n\n  /** @type {import(\"react-native\").PanResponderInstance} */\n  panResponder\n\n  /** @type {DraggableSortLayout|null} */\n  initialLayout = null\n  state = {\n    active: false,\n    dragging: false\n  }\n\n  setup() {\n    this.events ||= new EventEmitter()\n    this.position ||= new Animated.ValueXY()\n    this.panResponder ||= PanResponder.create({\n      onStartShouldSetPanResponder: (_event) => {\n        this.setState({dragging: true})\n        this.p.controller.onDragStart({item: this.p.item, itemIndex: this.p.itemIndex})\n\n        return false\n      }\n    })\n\n    useEventEmitter(this.p.controller.getEvents(), \"onDragStart\", this.tt.onDragStart)\n    useEventEmitter(this.p.controller.getEvents(), \"onDragEndAnimation\", this.tt.onDragEndAnimation)\n    useEventEmitter(this.tt.events, \"move\", this.tt.onMove)\n    useEventEmitter(this.tt.events, \"moveToPosition\", this.tt.onMoveToPosition)\n    useEventEmitter(this.tt.events, \"resetPosition\", this.tt.onResetPosition)\n  }\n\n  render() {\n    const {activeItemStyle, item, renderItem} = this.p\n    const {active} = this.s\n    const style = useMemo(\n      () => {\n        const baseTransform = this.tt.position.getTranslateTransform()\n\n        /** @type {import(\"react-native\").ViewStyle} */\n        const style = {transform: baseTransform}\n\n        if (active) {\n          if (activeItemStyle) {\n            const {transform: activeTransform, ...restActiveStyle} = activeItemStyle\n\n            if (activeTransform) {\n              const normalizedActiveTransform = /** @type {NonNullable<import(\"react-native\").TransformsStyle[\"transform\"]>} */ (\n                Array.isArray(activeTransform) ? activeTransform : [activeTransform]\n              )\n\n              style.transform = /** @type {import(\"react-native\").ViewStyle[\"transform\"]} */ ([...baseTransform, ...normalizedActiveTransform])\n            }\n\n            Object.assign(style, restActiveStyle)\n          }\n          style.elevation = 2\n          style.zIndex = 99999\n        }\n\n        return style\n      },\n      [active, activeItemStyle]\n    )\n\n    return (\n      <Animated.View dataSet={this.cache(\"draggableSortItemDataSet\", {component: \"draggable-sort/item\"})} onLayout={this.tt.onLayout} style={style}>\n        {renderItem({isActive: active, item, touchProps: this.tt.panResponder.panHandlers})}\n      </Animated.View>\n    )\n  }\n\n  /**\n   * Activate the dragged item after the controller announces drag start.\n   * @param {{itemData: DraggableSortItemData}} root0\n   */\n  onDragStart = ({itemData}) => {\n    const newState = {dragging: true}\n\n    if (itemData.index == this.p.itemIndex) {\n      newState.active = true\n      this.baseXAtStartedDragging = this.getBaseX()\n    }\n\n    this.setState(newState)\n  }\n\n  onDragEndAnimation = () => this.setState({active: false, dragging: false})\n\n  /** @param {{nativeEvent: {layout: DraggableSortLayout}}} e */\n  onLayout = (e) => {\n    const {controller, item, itemIndex} = this.p\n\n    controller.onItemLayout({events: this.tt.events, index: itemIndex, item, layout: e.nativeEvent.layout})\n\n    if (!this.tt.initialLayout) {\n      this.initialLayout = e.nativeEvent.layout\n    }\n  }\n\n  /**\n   * Move the active item in sync with the current drag gesture.\n   * @param {DraggableSortMoveEventArgs} root0\n   */\n  onMove = ({gestate}) => {\n    if (!this.tt.initialLayout) throw new Error(\"Expected initial layout before moving draggable item\")\n\n    const x = gestate.dx + this.tt.baseXAtStartedDragging - this.tt.initialLayout.x\n    const y = this.tt.initialLayout.y\n\n    this.tt.position.setValue({x, y})\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({itemIndex: this.p.itemIndex, x, y})\n    }\n  }\n\n  /**\n   * Animate a non-dragged item into its new ordered position.\n   * @param {DraggableSortMoveToPositionArgs} root0\n   */\n  onMoveToPosition = ({x, y}) => {\n    if (!this.tt.initialLayout) throw new Error(\"Expected initial layout before animating item position\")\n\n    const calculatedXFromStartingPosition = x - this.tt.initialLayout.x\n\n    /** @type {DraggableSortAnimationArgs} */\n    const animationArgs = {\n      duration: 200,\n      easing: Easing.inOut(Easing.linear),\n      toValue: {\n        x: calculatedXFromStartingPosition,\n        y\n      },\n      useNativeDriver: true\n    }\n    const animationEventArgs = {animationArgs, animationType: \"moveToPosition\", item: this.p.item}\n\n    this.p.controller.events.emit(\"onAnimationStart\", animationEventArgs)\n\n    Animated\n      .timing(this.tt.position, animationArgs)\n      .start(() => {\n        this.p.controller.events.emit(\"onAnimationEnd\", animationEventArgs)\n      })\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({\n        animationArgs,\n        itemIndex: this.p.itemIndex,\n        x: calculatedXFromStartingPosition,\n        y\n      })\n    }\n  }\n\n  getBaseX = () => this.p.controller.getItemDataForIndex(this.p.itemIndex).baseX\n\n  /**\n   * Animate the dragged item back to its base position after drag end.\n   * @param {DraggableSortResetPositionArgs} [args]\n   */\n  onResetPosition = (args) => {\n    if (!this.tt.initialLayout) throw new Error(\"Expected initial layout before resetting item position\")\n\n    const baseX = this.getBaseX() - this.tt.initialLayout.x\n\n    /** @type {DraggableSortAnimationArgs} */\n    const animationArgs = {\n      duration: 200,\n      easing: Easing.inOut(Easing.linear),\n      toValue: {\n        x: baseX,\n        y: 0\n      },\n      useNativeDriver: true\n    }\n    const animationEventArgs = {animationArgs, animationType: \"resetPosition\", item: this.p.item}\n\n    this.p.controller.events.emit(\"onAnimationStart\", animationEventArgs)\n\n    Animated\n      .timing(this.tt.position, animationArgs)\n      .start(() => {\n        this.p.controller.events.emit(\"onAnimationEnd\", animationEventArgs)\n        if (args?.callback) args.callback()\n      })\n\n    if (this.props.onItemMoved) {\n      this.p.onItemMoved({\n        animationArgs,\n        itemIndex: this.p.itemIndex,\n        x: baseX,\n        y: 0\n      })\n    }\n  }\n}))\n"]}

package/build/error-logger.d.ts

@@ -1,3 +1,10 @@
+/** @typedef {string | number | boolean | object | null | undefined} DebugOutput */
+/**
+ * @typedef {object} LoggedError
+ * @property {string} errorClass
+ * @property {string} message
+ * @property {Array<string> | null} backtrace
+ */
 /** Captures window errors with source-map support. */
 export default class ErrorLogger {
     debugging: boolean;
@@ -5,26 +12,35 @@ export default class ErrorLogger {
     errors: any[];
     isHandlingError: boolean;
     sourceMapsLoader: SourceMapsLoader;
-    /** debug. */
-    debug(...output: any[]): void;
-    /** enable. */
+    /**
+     * Logs diagnostic output when debug mode is enabled.
+     * @param {...DebugOutput} output
+     */
+    debug(...output: DebugOutput[]): void;
+    /** @returns {void} */
     enable(): void;
-    /** getErrors. */
-    getErrors: () => any[];
-    /** hasErrorOccurred. */
-    hasErrorOccurred: () => any;
-    /** isLoadingSourceMaps. */
-    isLoadingSourceMaps: () => any;
-    /** isWorkingOnError. */
-    isWorkingOnError: () => any;
-    /** connectOnError. */
+    /** @returns {Array<LoggedError>} */
+    getErrors: () => Array<LoggedError>;
+    /** @returns {boolean} */
+    hasErrorOccurred: () => boolean;
+    /** @returns {boolean} */
+    isLoadingSourceMaps: () => boolean;
+    /** @returns {boolean} */
+    isWorkingOnError: () => boolean;
+    /** Subscribes to global `error` events and records them once at a time. */
     connectOnError(): void;
-    /** connectUnhandledRejection. */
+    /** Subscribes to global unhandled promise rejections and records them once at a time. */
     connectUnhandledRejection(): void;
     onError(event: any): Promise<void>;
     onUnhandledRejection(event: any): Promise<void>;
-    /** testPromiseError. */
+    /** Raises a rejected promise to exercise the unhandled-rejection logger path. */
     testPromiseError(): Promise<any>;
 }
+export type DebugOutput = string | number | boolean | object | null | undefined;
+export type LoggedError = {
+    errorClass: string;
+    message: string;
+    backtrace: Array<string> | null;
+};
 import SourceMapsLoader from "./source-maps-loader.js";
 //# sourceMappingURL=error-logger.d.ts.map

package/build/error-logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-logger.d.ts","sourceRoot":"/src/","sources":["error-logger.js"],"names":[],"mappings":"AAGA,sDAAsD;AACtD;IAGI,mBAAsB;IACtB,uBAA0B;IAC1B,cAAgB;IAChB,yBAA4B;IAC5B,mCAA8C;IAWhD,aAAa;IACb,8BAEC;IAED,cAAc;IACd,eAIC;IAED,iBAAiB;IACjB,uBAA6B;IAE7B,wBAAwB;IACxB,4BAAoD;IAEpD,2BAA2B;IAC3B,+BAAiF;IAEjF,wBAAwB;IACxB,4BAAoF;IAEpF,sBAAsB;IACtB,uBAYC;IAED,iCAAiC;IACjC,kCAYC;IAED,mCAoBC;IAED,gDAkBC;IAED,wBAAwB;IACxB,iCAIC;CACF;6BA5H4B,yBAAyB"}
+{"version":3,"file":"error-logger.d.ts","sourceRoot":"/src/","sources":["error-logger.js"],"names":[],"mappings":"AAIA,mFAAmF;AACnF;;;;;GAKG;AAEH,sDAAsD;AACtD;IAGI,mBAAsB;IACtB,uBAA0B;IAC1B,cAAgB;IAChB,yBAA4B;IAC5B,mCAA8C;IAWhD;;;OAGG;IACH,iBAFc,WAAW,EAAA,QAIxB;IAED,sBAAsB;IACtB,UADc,IAAI,CAKjB;IAED,oCAAoC;IACpC,iBADc,KAAK,CAAC,WAAW,CAAC,CACH;IAE7B,yBAAyB;IACzB,wBADc,OAAO,CAC+B;IAEpD,yBAAyB;IACzB,2BADc,OAAO,CAC4D;IAEjF,yBAAyB;IACzB,wBADc,OAAO,CAC+D;IAEpF,2EAA2E;IAC3E,uBAYC;IAED,yFAAyF;IACzF,kCAYC;IAED,mCAoBC;IAED,gDAkBC;IAED,iFAAiF;IACjF,iCAIC;CACF;0BApIa,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS;;gBAGrD,MAAM;aACN,MAAM;eACN,KAAK,CAAC,MAAM,CAAC,GAAG,IAAI;;6BARL,yBAAyB"}

package/build/error-logger.js

@@ -1,8 +1,16 @@
+// @ts-check
 import SourceMapsLoader from "./source-maps-loader.js";
 import { digg } from "diggerize";
+/** @typedef {string | number | boolean | object | null | undefined} DebugOutput */
+/**
+ * @typedef {object} LoggedError
+ * @property {string} errorClass
+ * @property {string} message
+ * @property {Array<string> | null} backtrace
+ */
 /** Captures window errors with source-map support. */
 export default class ErrorLogger {
-    /** Constructor. */
+    /** Initializes error tracking state and prepares source-map loading for bundled scripts. */
     constructor() {
         this.debugging = false;
         this.errorOccurred = false;
@@ -17,26 +25,29 @@ export default class ErrorLogger {
             }
         });
     }
-    /** debug. */
+    /**
+     * Logs diagnostic output when debug mode is enabled.
+     * @param {...DebugOutput} output
+     */
     debug(...output) {
         if (this.debugging)
             console.error("ApiMaker ErrorLogger:", ...output);
     }
-    /** enable. */
+    /** @returns {void} */
     enable() {
         this.debug("Enable called");
         this.connectOnError();
         this.connectUnhandledRejection();
     }
-    /** getErrors. */
+    /** @returns {Array<LoggedError>} */
     getErrors = () => this.errors;
-    /** hasErrorOccurred. */
+    /** @returns {boolean} */
     hasErrorOccurred = () => digg(this, "errorOccurred");
-    /** isLoadingSourceMaps. */
+    /** @returns {boolean} */
     isLoadingSourceMaps = () => digg(this, "sourceMapsLoader", "isLoadingSourceMaps");
-    /** isWorkingOnError. */
+    /** @returns {boolean} */
     isWorkingOnError = () => digg(this, "isHandlingError") || this.isLoadingSourceMaps();
-    /** connectOnError. */
+    /** Subscribes to global `error` events and records them once at a time. */
     connectOnError() {
         window.addEventListener("error", (event) => {
             if (this.debugging)
@@ -50,7 +61,7 @@ export default class ErrorLogger {
             }
         });
     }
-    /** connectUnhandledRejection. */
+    /** Subscribes to global unhandled promise rejections and records them once at a time. */
     connectUnhandledRejection() {
         window.addEventListener("unhandledrejection", (event) => {
             if (this.debugging)
@@ -103,11 +114,11 @@ export default class ErrorLogger {
             });
         }
     }
-    /** testPromiseError. */
+    /** Raises a rejected promise to exercise the unhandled-rejection logger path. */
     testPromiseError() {
         return new Promise((_resolve) => {
             throw new Error("testPromiseError");
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-logger.js","sourceRoot":"/src/","sources":["error-logger.js"],"names":[],"mappings":"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","sourcesContent":["import SourceMapsLoader from \"./source-maps-loader.js\"\nimport {digg} from \"diggerize\"\n\n/** Captures window errors with source-map support. */\nexport default class ErrorLogger {\n  /** Constructor. */\n  constructor () {\n    this.debugging = false\n    this.errorOccurred = false\n    this.errors = []\n    this.isHandlingError = false\n    this.sourceMapsLoader = new SourceMapsLoader()\n    this.sourceMapsLoader.loadSourceMapsForScriptTags((script) => {\n      const src = script.getAttribute(\"src\")\n      const type = script.getAttribute(\"type\")\n\n      if (src && (src.includes(\"/packs/\") || src.includes(\"/packs-test/\")) && (type == \"text/javascript\" || !type)) {\n        return src\n      }\n    })\n  }\n\n  /** debug. */\n  debug(...output) {\n    if (this.debugging) console.error(\"ApiMaker ErrorLogger:\", ...output)\n  }\n\n  /** enable. */\n  enable () {\n    this.debug(\"Enable called\")\n    this.connectOnError()\n    this.connectUnhandledRejection()\n  }\n\n  /** getErrors. */\n  getErrors = () => this.errors\n\n  /** hasErrorOccurred. */\n  hasErrorOccurred = () => digg(this, \"errorOccurred\")\n\n  /** isLoadingSourceMaps. */\n  isLoadingSourceMaps = () => digg(this, \"sourceMapsLoader\", \"isLoadingSourceMaps\")\n\n  /** isWorkingOnError. */\n  isWorkingOnError = () => digg(this, \"isHandlingError\") || this.isLoadingSourceMaps()\n\n  /** connectOnError. */\n  connectOnError() {\n    window.addEventListener(\"error\", (event) => {\n      if (this.debugging) this.debug(\"Error:\", event.message)\n      this.errorOccurred = true\n\n      if (!this.isHandlingError) {\n        this.isHandlingError = true\n        this.onError(event).finally(() => {\n          this.isHandlingError = false\n        })\n      }\n    })\n  }\n\n  /** connectUnhandledRejection. */\n  connectUnhandledRejection() {\n    window.addEventListener(\"unhandledrejection\", (event) => {\n      if (this.debugging) this.debug(\"Unhandled rejection:\", event.reason.message)\n      this.errorOccurred = true\n\n      if (!this.isHandlingError) {\n        this.isHandlingError = true\n        this.onUnhandledRejection(event).finally(() => {\n          this.isHandlingError = false\n        })\n      }\n    })\n  }\n\n  async onError(event) {\n    this.errorOccurred = true\n\n    if (event.error) await this.sourceMapsLoader.loadSourceMaps(event.error)\n\n    if (event.error && event.error.stack) {\n      const backtrace = this.sourceMapsLoader.parseStackTrace(event.error.stack)\n\n      this.errors.push({\n        errorClass: event.error ? event.error.name : \"No error class\",\n        message: event.message || \"Unknown error\",\n        backtrace\n      })\n    } else {\n      this.errors.push({\n        errorClass: event.error ? event.error.name : \"No error class\",\n        message: event.message || \"Unknown error\",\n        backtrace: null\n      })\n    }\n  }\n\n  async onUnhandledRejection(event) {\n    if (event.reason) await this.sourceMapsLoader.loadSourceMaps(event.reason)\n\n    if (event.reason.stack) {\n      const backtrace = this.sourceMapsLoader.parseStackTrace(event.reason.stack)\n\n      this.errors.push({\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || \"Unhandled promise rejection\",\n        backtrace\n      })\n    } else {\n      this.errors.push({\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || \"Unhandled promise rejection\",\n        backtrace: null\n      })\n    }\n  }\n\n  /** testPromiseError. */\n  testPromiseError() {\n    return new Promise((_resolve) => {\n      throw new Error(\"testPromiseError\")\n    })\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-logger.js","sourceRoot":"/src/","sources":["error-logger.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport SourceMapsLoader from \"./source-maps-loader.js\"\nimport {digg} from \"diggerize\"\n\n/** @typedef {string | number | boolean | object | null | undefined} DebugOutput */\n/**\n * @typedef {object} LoggedError\n * @property {string} errorClass\n * @property {string} message\n * @property {Array<string> | null} backtrace\n */\n\n/** Captures window errors with source-map support. */\nexport default class ErrorLogger {\n  /** Initializes error tracking state and prepares source-map loading for bundled scripts. */\n  constructor () {\n    this.debugging = false\n    this.errorOccurred = false\n    this.errors = []\n    this.isHandlingError = false\n    this.sourceMapsLoader = new SourceMapsLoader()\n    this.sourceMapsLoader.loadSourceMapsForScriptTags((script) => {\n      const src = script.getAttribute(\"src\")\n      const type = script.getAttribute(\"type\")\n\n      if (src && (src.includes(\"/packs/\") || src.includes(\"/packs-test/\")) && (type == \"text/javascript\" || !type)) {\n        return src\n      }\n    })\n  }\n\n  /**\n   * Logs diagnostic output when debug mode is enabled.\n   * @param {...DebugOutput} output\n   */\n  debug(...output) {\n    if (this.debugging) console.error(\"ApiMaker ErrorLogger:\", ...output)\n  }\n\n  /** @returns {void} */\n  enable () {\n    this.debug(\"Enable called\")\n    this.connectOnError()\n    this.connectUnhandledRejection()\n  }\n\n  /** @returns {Array<LoggedError>} */\n  getErrors = () => this.errors\n\n  /** @returns {boolean} */\n  hasErrorOccurred = () => digg(this, \"errorOccurred\")\n\n  /** @returns {boolean} */\n  isLoadingSourceMaps = () => digg(this, \"sourceMapsLoader\", \"isLoadingSourceMaps\")\n\n  /** @returns {boolean} */\n  isWorkingOnError = () => digg(this, \"isHandlingError\") || this.isLoadingSourceMaps()\n\n  /** Subscribes to global `error` events and records them once at a time. */\n  connectOnError() {\n    window.addEventListener(\"error\", (event) => {\n      if (this.debugging) this.debug(\"Error:\", event.message)\n      this.errorOccurred = true\n\n      if (!this.isHandlingError) {\n        this.isHandlingError = true\n        this.onError(event).finally(() => {\n          this.isHandlingError = false\n        })\n      }\n    })\n  }\n\n  /** Subscribes to global unhandled promise rejections and records them once at a time. */\n  connectUnhandledRejection() {\n    window.addEventListener(\"unhandledrejection\", (event) => {\n      if (this.debugging) this.debug(\"Unhandled rejection:\", event.reason.message)\n      this.errorOccurred = true\n\n      if (!this.isHandlingError) {\n        this.isHandlingError = true\n        this.onUnhandledRejection(event).finally(() => {\n          this.isHandlingError = false\n        })\n      }\n    })\n  }\n\n  async onError(event) {\n    this.errorOccurred = true\n\n    if (event.error) await this.sourceMapsLoader.loadSourceMaps(event.error)\n\n    if (event.error && event.error.stack) {\n      const backtrace = this.sourceMapsLoader.parseStackTrace(event.error.stack)\n\n      this.errors.push({\n        errorClass: event.error ? event.error.name : \"No error class\",\n        message: event.message || \"Unknown error\",\n        backtrace\n      })\n    } else {\n      this.errors.push({\n        errorClass: event.error ? event.error.name : \"No error class\",\n        message: event.message || \"Unknown error\",\n        backtrace: null\n      })\n    }\n  }\n\n  async onUnhandledRejection(event) {\n    if (event.reason) await this.sourceMapsLoader.loadSourceMaps(event.reason)\n\n    if (event.reason.stack) {\n      const backtrace = this.sourceMapsLoader.parseStackTrace(event.reason.stack)\n\n      this.errors.push({\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || \"Unhandled promise rejection\",\n        backtrace\n      })\n    } else {\n      this.errors.push({\n        errorClass: \"UnhandledRejection\",\n        message: event.reason.message || \"Unhandled promise rejection\",\n        backtrace: null\n      })\n    }\n  }\n\n  /** Raises a rejected promise to exercise the unhandled-rejection logger path. */\n  testPromiseError() {\n    return new Promise((_resolve) => {\n      throw new Error(\"testPromiseError\")\n    })\n  }\n}\n"]}

package/build/event-connection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAKA;IACE;;MAEC;IAED,sBAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO"}
+{"version":3,"file":"event-connection.d.ts","sourceRoot":"/src/","sources":["event-connection.jsx"],"names":[],"mappings":"AAMA;IACE;;MAEC;IAED,sBAKE;;IAEF,0BAEC;IADC,wDAA8G;IAGhH,6BAIC;IAED,cAEC;IAED,6BAIC;CACF;kBAlCiB,OAAO"}

package/build/event-connection.js

@@ -1,3 +1,4 @@
+// @ts-check
 import ModelEvents from "./model-events.js";
 import PropTypes from "prop-types";
 import React from "react";
@@ -7,7 +8,7 @@ export default class ApiMakerEventConnection extends React.PureComponent {
         active: true
     };
     static propTypes = propTypesExact({
-        active: PropTypes.bool.isRequired,
+        active: PropTypes.bool,
         model: PropTypes.object.isRequired,
         event: PropTypes.string.isRequired,
         onCall: PropTypes.func.isRequired
@@ -29,4 +30,4 @@ export default class ApiMakerEventConnection extends React.PureComponent {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtY29ubmVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZXZlbnQtY29ubmVjdGlvbi5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxXQUFXLE1BQU0sbUJBQW1CLENBQUE7QUFDM0MsT0FBTyxTQUFTLE1BQU0sWUFBWSxDQUFBO0FBQ2xDLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQTtBQUN6QixPQUFPLGNBQWMsTUFBTSxrQkFBa0IsQ0FBQTtBQUU3QyxNQUFNLENBQUMsT0FBTyxPQUFPLHVCQUF3QixTQUFRLEtBQUssQ0FBQyxhQUFhO0lBQ3RFLE1BQU0sQ0FBQyxZQUFZLEdBQUc7UUFDcEIsTUFBTSxFQUFFLElBQUk7S0FDYixDQUFBO0lBRUQsTUFBTSxDQUFDLFNBQVMsR0FBRyxjQUFjLENBQUM7UUFDaEMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsVUFBVTtRQUNqQyxLQUFLLEVBQUUsU0FBUyxDQUFDLE1BQU0sQ0FBQyxVQUFVO1FBQ2xDLEtBQUssRUFBRSxTQUFTLENBQUMsTUFBTSxDQUFDLFVBQVU7UUFDbEMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxJQUFJLENBQUMsVUFBVTtLQUNsQyxDQUFDLENBQUE7SUFFRixpQkFBaUI7UUFDZixJQUFJLENBQUMsWUFBWSxHQUFHLFdBQVcsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEVBQUUsQ0FBQyxHQUFHLElBQUksRUFBRSxFQUFFLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUE7SUFDaEgsQ0FBQztJQUVELG9CQUFvQjtRQUNsQixJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQztZQUN0QixJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsRUFBRSxDQUFBO1FBQ2pDLENBQUM7SUFDSCxDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFBO0lBQ2IsQ0FBQztJQUVELE1BQU0sQ0FBRSxHQUFHLElBQUk7UUFDYixJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDdEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQTtRQUM1QixDQUFDO0lBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBNb2RlbEV2ZW50cyBmcm9tIFwiLi9tb2RlbC1ldmVudHMuanNcIlxuaW1wb3J0IFByb3BUeXBlcyBmcm9tIFwicHJvcC10eXBlc1wiXG5pbXBvcnQgUmVhY3QgZnJvbSBcInJlYWN0XCJcbmltcG9ydCBwcm9wVHlwZXNFeGFjdCBmcm9tIFwicHJvcC10eXBlcy1leGFjdFwiXG5cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyRXZlbnRDb25uZWN0aW9uIGV4dGVuZHMgUmVhY3QuUHVyZUNvbXBvbmVudCB7XG4gIHN0YXRpYyBkZWZhdWx0UHJvcHMgPSB7XG4gICAgYWN0aXZlOiB0cnVlXG4gIH1cblxuICBzdGF0aWMgcHJvcFR5cGVzID0gcHJvcFR5cGVzRXhhY3Qoe1xuICAgIGFjdGl2ZTogUHJvcFR5cGVzLmJvb2wuaXNSZXF1aXJlZCxcbiAgICBtb2RlbDogUHJvcFR5cGVzLm9iamVjdC5pc1JlcXVpcmVkLFxuICAgIGV2ZW50OiBQcm9wVHlwZXMuc3RyaW5nLmlzUmVxdWlyZWQsXG4gICAgb25DYWxsOiBQcm9wVHlwZXMuZnVuYy5pc1JlcXVpcmVkXG4gIH0pXG5cbiAgY29tcG9uZW50RGlkTW91bnQgKCkge1xuICAgIHRoaXMuc3Vic2NyaXB0aW9uID0gTW9kZWxFdmVudHMuY29ubmVjdCh0aGlzLnByb3BzLm1vZGVsLCB0aGlzLnByb3BzLmV2ZW50LCAoLi4uYXJncykgPT4gdGhpcy5vbkNhbGwoLi4uYXJncykpXG4gIH1cblxuICBjb21wb25lbnRXaWxsVW5tb3VudCAoKSB7XG4gICAgaWYgKHRoaXMuc3Vic2NyaXB0aW9uKSB7XG4gICAgICB0aGlzLnN1YnNjcmlwdGlvbi51bnN1YnNjcmliZSgpXG4gICAgfVxuICB9XG5cbiAgcmVuZGVyICgpIHtcbiAgICByZXR1cm4gbnVsbFxuICB9XG5cbiAgb25DYWxsICguLi5hcmdzKSB7XG4gICAgaWYgKHRoaXMucHJvcHMuYWN0aXZlKSB7XG4gICAgICB0aGlzLnByb3BzLm9uQ2FsbCguLi5hcmdzKVxuICAgIH1cbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/build/event-emitter-listener.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-emitter-listener.d.ts","sourceRoot":"/src/","sources":["event-emitter-listener.jsx"],"names":[],"mappings":";AAEA;;;;;SAQC"}
+{"version":3,"file":"event-emitter-listener.d.ts","sourceRoot":"/src/","sources":["event-emitter-listener.jsx"],"names":[],"mappings":";AAGA;;;;;SAQC"}

package/build/event-emitter-listener.js

@@ -1,3 +1,4 @@
+// @ts-check
 import useEventEmitter from "ya-use-event-emitter";
 const EventEmitterListener = ({ event, events, onCalled, ...restProps }) => {
     const restPropsKeys = Object.keys(restProps);
@@ -7,4 +8,4 @@ const EventEmitterListener = ({ event, events, onCalled, ...restProps }) => {
     useEventEmitter(events, event, onCalled);
 };
 export default EventEmitterListener;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtZW1pdHRlci1saXN0ZW5lci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZXZlbnQtZW1pdHRlci1saXN0ZW5lci5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxlQUFlLE1BQU0sc0JBQXNCLENBQUE7QUFFbEQsTUFBTSxvQkFBb0IsR0FBRyxDQUFDLEVBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsR0FBRyxTQUFTLEVBQUMsRUFBRSxFQUFFO0lBQ3ZFLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUE7SUFFNUMsSUFBSSxhQUFhLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQzdCLE1BQU0sSUFBSSxLQUFLLENBQUMscUJBQXFCLGFBQWEsRUFBRSxDQUFDLENBQUE7SUFDdkQsQ0FBQztJQUVELGVBQWUsQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFBO0FBQzFDLENBQUMsQ0FBQTtBQUVELGVBQWUsb0JBQW9CLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdXNlRXZlbnRFbWl0dGVyIGZyb20gXCJ5YS11c2UtZXZlbnQtZW1pdHRlclwiXG5cbmNvbnN0IEV2ZW50RW1pdHRlckxpc3RlbmVyID0gKHtldmVudCwgZXZlbnRzLCBvbkNhbGxlZCwgLi4ucmVzdFByb3BzfSkgPT4ge1xuICBjb25zdCByZXN0UHJvcHNLZXlzID0gT2JqZWN0LmtleXMocmVzdFByb3BzKVxuXG4gIGlmIChyZXN0UHJvcHNLZXlzLmxlbmd0aCA+IDApIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYFVuZXhwZWN0ZWQgcHJvcHM6ICR7cmVzdFByb3BzS2V5c31gKVxuICB9XG5cbiAgdXNlRXZlbnRFbWl0dGVyKGV2ZW50cywgZXZlbnQsIG9uQ2FsbGVkKVxufVxuXG5leHBvcnQgZGVmYXVsdCBFdmVudEVtaXR0ZXJMaXN0ZW5lclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtZW1pdHRlci1saXN0ZW5lci5qcyIsInNvdXJjZVJvb3QiOiIvc3JjLyIsInNvdXJjZXMiOlsiZXZlbnQtZW1pdHRlci1saXN0ZW5lci5qc3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sZUFBZSxNQUFNLHNCQUFzQixDQUFBO0FBRWxELE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxFQUFDLEtBQUssRUFBRSxNQUFNLEVBQUUsUUFBUSxFQUFFLEdBQUcsU0FBUyxFQUFDLEVBQUUsRUFBRTtJQUN2RSxNQUFNLGFBQWEsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFBO0lBRTVDLElBQUksYUFBYSxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztRQUM3QixNQUFNLElBQUksS0FBSyxDQUFDLHFCQUFxQixhQUFhLEVBQUUsQ0FBQyxDQUFBO0lBQ3ZELENBQUM7SUFFRCxlQUFlLENBQUMsTUFBTSxFQUFFLEtBQUssRUFBRSxRQUFRLENBQUMsQ0FBQTtBQUMxQyxDQUFDLENBQUE7QUFFRCxlQUFlLG9CQUFvQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5pbXBvcnQgdXNlRXZlbnRFbWl0dGVyIGZyb20gXCJ5YS11c2UtZXZlbnQtZW1pdHRlclwiXG5cbmNvbnN0IEV2ZW50RW1pdHRlckxpc3RlbmVyID0gKHtldmVudCwgZXZlbnRzLCBvbkNhbGxlZCwgLi4ucmVzdFByb3BzfSkgPT4ge1xuICBjb25zdCByZXN0UHJvcHNLZXlzID0gT2JqZWN0LmtleXMocmVzdFByb3BzKVxuXG4gIGlmIChyZXN0UHJvcHNLZXlzLmxlbmd0aCA+IDApIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYFVuZXhwZWN0ZWQgcHJvcHM6ICR7cmVzdFByb3BzS2V5c31gKVxuICB9XG5cbiAgdXNlRXZlbnRFbWl0dGVyKGV2ZW50cywgZXZlbnQsIG9uQ2FsbGVkKVxufVxuXG5leHBvcnQgZGVmYXVsdCBFdmVudEVtaXR0ZXJMaXN0ZW5lclxuIl19

package/build/event-model-class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAKA;IACE,sBAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO"}
+{"version":3,"file":"event-model-class.d.ts","sourceRoot":"/src/","sources":["event-model-class.jsx"],"names":[],"mappings":"AAMA;IACE,sBAIE;;IAEF,0BAEC;IAED,6BAIC;IAED,gBAEC;IADC,sDAA2G;IAG7G,cAEC;CACF;kBA3BiB,OAAO"}

package/build/event-model-class.js

@@ -1,3 +1,4 @@
+// @ts-check
 import ModelEvents from "./model-events.js";
 import PropTypes from "prop-types";
 import React from "react";
@@ -23,4 +24,4 @@ export default class ApiMakerEventModelClass extends React.PureComponent {
         return null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"/src/","sources":["events.js"],"names":[],"mappings":";AAEA,8CAA8C;AAC9C,yDAAiC;6BAHN,eAAe"}
+{"version":3,"file":"events.d.ts","sourceRoot":"/src/","sources":["events.js"],"names":[],"mappings":";AAGA,8CAA8C;AAC9C,yDAAiC;6BAHN,eAAe"}

package/build/events.js

@@ -1,5 +1,6 @@
+// @ts-check
 import { EventEmitter } from "eventemitter3";
 /** Shared event bus for API Maker modules. */
 const events = new EventEmitter();
 export default events;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJldmVudHMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGVBQWUsQ0FBQTtBQUUxQyw4Q0FBOEM7QUFDOUMsTUFBTSxNQUFNLEdBQUcsSUFBSSxZQUFZLEVBQUUsQ0FBQTtBQUVqQyxlQUFlLE1BQU0sQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RXZlbnRFbWl0dGVyfSBmcm9tIFwiZXZlbnRlbWl0dGVyM1wiXG5cbi8qKiBTaGFyZWQgZXZlbnQgYnVzIGZvciBBUEkgTWFrZXIgbW9kdWxlcy4gKi9cbmNvbnN0IGV2ZW50cyA9IG5ldyBFdmVudEVtaXR0ZXIoKVxuXG5leHBvcnQgZGVmYXVsdCBldmVudHNcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJldmVudHMuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxlQUFlLENBQUE7QUFFMUMsOENBQThDO0FBQzlDLE1BQU0sTUFBTSxHQUFHLElBQUksWUFBWSxFQUFFLENBQUE7QUFFakMsZUFBZSxNQUFNLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcbmltcG9ydCB7RXZlbnRFbWl0dGVyfSBmcm9tIFwiZXZlbnRlbWl0dGVyM1wiXG5cbi8qKiBTaGFyZWQgZXZlbnQgYnVzIGZvciBBUEkgTWFrZXIgbW9kdWxlcy4gKi9cbmNvbnN0IGV2ZW50cyA9IG5ldyBFdmVudEVtaXR0ZXIoKVxuXG5leHBvcnQgZGVmYXVsdCBldmVudHNcbiJdfQ==

package/build/form.d.ts

@@ -1,3 +1,26 @@
+export type Props = {
+    children?: React.ReactNode;
+    form?: FormInputs;
+    formObjectRef?: object;
+    formRef?: object;
+    htmlFormProps?: object;
+    onSubmit?: Function;
+    setForm?: Function;
+    useHtmlForm?: boolean;
+};
+export type State = Record<string, never>;
+/**
+ * @typedef {object} Props
+ * @property {React.ReactNode} [children]
+ * @property {FormInputs} [form]
+ * @property {object} [formObjectRef]
+ * @property {object} [formRef]
+ * @property {object} [htmlFormProps]
+ * @property {Function} [onSubmit]
+ * @property {Function} [setForm]
+ * @property {boolean} [useHtmlForm]
+ */
+/** @typedef {Record<string, never>} State */
 export const Form: React.NamedExoticComponent<Record<string, any>>;
 export const FormContext: React.Context<any>;
 export class FormInputs {

package/build/form.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"form.d.ts","sourceRoot":"/src/","sources":["form.jsx"],"names":[],"mappings":"AAgEA,mEA2DG;AAhHH,6CAAuC;AAGvC;IACE,wBAGC;IAFC,WAAgB;IAChB,cAA+B;IAGjC,eAWC;IAED,yBAEC;IAED,sCAIC;IAED,4BAIC;IAED,mFAMC;IAED,eAIC;CACF;AAlDD,+BAA6C;kBAXsB,OAAO"}
+{"version":3,"file":"form.d.ts","sourceRoot":"/src/","sources":["form.jsx"],"names":[],"mappings":";eAkEc,KAAK,CAAC,SAAS;WACf,UAAU;oBACV,MAAM;cACN,MAAM;oBACN,MAAM;;;kBAGN,OAAO;;oBAEP,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;AAXnC;;;;;;;;;;GAUG;AACH,6CAA6C;AAC7C,mEA2DG;AA5HH,6CAAuC;AAGvC;IACE,wBAGC;IAFC,WAAgB;IAChB,cAA+B;IAGjC,eAWC;IAED,yBAEC;IAED,sCAIC;IAED,4BAIC;IAED,mFAMC;IAED,eAIC;CACF;AAlDD,+BAA6C;kBAVsB,OAAO"}