@kaspernj/api-maker 1.0.446 → 1.0.448

package/build/draggable-sort/controller.js

@@ -0,0 +1,136 @@
+import { digg } from "diggerize";
+import EventEmitter from "events";
+export default class DraggableSortController {
+  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.itemData[itemIndex] = {
+        index: itemIndex,
+        item: data[itemIndex],
+        position: itemIndex
+      };
+    }
+  }
+  getEvents = () => this.events;
+  getItemDataForItem = item => this.getItemDataForIndex(this.data.indexOf(item));
+  getItemDataForKey = key => this.itemData.find(itemDataI => digg(itemDataI, "key") == key);
+  getItemDataForIndex = index => digg(this, "itemData", index);
+  onDragStart = ({
+    item,
+    itemIndex
+  }) => {
+    if (item) {
+      this.draggedItem = item;
+      this.draggedItemData = this.getItemDataForIndex(itemIndex);
+      this.draggedItemIndex = itemIndex;
+      this.draggedItemPosition = this.draggedItemData.position;
+      this.events.emit("onDragStart", {
+        item,
+        itemData: this.draggedItemData
+      });
+    }
+  };
+  onDragEnd = () => {
+    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;
+    const callbackArgs = {
+      item: itemData.item,
+      itemData,
+      fromIndex,
+      fromItem,
+      fromPosition,
+      toItem,
+      toPosition
+    };
+    this.draggedItemData.events.emit("resetPosition", {
+      callback: () => {
+        this.events.emit("onDragEndAnimation", callbackArgs);
+      }
+    });
+    this.draggedItem = null;
+    this.draggedItemData = null;
+    this.draggedItemNewPosition = null;
+    this.draggedOverItem = null;
+    this.draggedOverItemData = null;
+    this.events.emit("onDragEnd", callbackArgs);
+  };
+  onItemLayout = ({
+    events,
+    index,
+    item,
+    layout
+  }) => {
+    if (!(index in this.itemData)) throw new Error(`Item not found for index ${index}`);
+    const itemData = this.itemData[index];
+    itemData.layout = layout;
+    if (!itemData.initialLayout) {
+      itemData.baseX = layout.x;
+      itemData.events = events;
+      itemData.initialLayout = layout;
+      itemData.key = this.keyExtractor(item);
+    }
+  };
+  onMove = ({
+    gestate
+  }) => {
+    // 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);
+      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) {
+        this.draggedOverItem = itemData.item;
+        this.draggedOverItemData = itemData;
+        const positionOfDraggedItem = this.currentOrder.indexOf(this.draggedItemData.item);
+        const positionOfOverItem = this.currentOrder.indexOf(this.draggedOverItemData.item);
+        this.currentOrder[positionOfDraggedItem] = this.draggedOverItemData.item;
+        this.currentOrder[positionOfOverItem] = this.draggedItemData.item;
+        this.draggedItemData.position = positionOfOverItem;
+        this.draggedOverItemData.position = positionOfDraggedItem;
+        this.updatePositionOfItems();
+        this.draggedItemNewPosition = positionOfOverItem;
+      }
+    }
+  };
+  setInitialDragPosition = initialDragPosition => {
+    this.initialDragPosition = initialDragPosition;
+  };
+  updatePositionOfItems() {
+    let currentPosition = 0;
+    for (const item of this.currentOrder) {
+      const itemData = this.getItemDataForItem(item);
+      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", {
+          x: currentPosition,
+          y: 0
+        });
+      }
+      itemData.baseX = currentPosition;
+      currentPosition += digg(itemData, "layout", "width");
+    }
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digg","EventEmitter","DraggableSortController","constructor","data","events","keyExtractor","currentOrder","draggedItem","draggedItemData","draggedItemNewPosition","draggedOverItem","draggedOverItemData","itemData","itemIndex","index","item","position","getEvents","getItemDataForItem","getItemDataForIndex","indexOf","getItemDataForKey","key","find","itemDataI","onDragStart","draggedItemIndex","draggedItemPosition","emit","onDragEnd","fromIndex","fromPosition","toPosition","fromItem","toItem","callbackArgs","callback","onItemLayout","layout","Error","initialLayout","baseX","x","onMove","gestate","moveX","dx","initialDragPosition","smallestWidth","width","positionOfDraggedItem","positionOfOverItem","updatePositionOfItems","setInitialDragPosition","currentPosition","y"],"sources":["../../src/draggable-sort/controller.js"],"sourcesContent":["import {digg} from \"diggerize\"\nimport EventEmitter from \"events\"\n\nexport default class DraggableSortController {\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 = () => this.events\n  getItemDataForItem = (item) => this.getItemDataForIndex(this.data.indexOf(item))\n  getItemDataForKey = (key) => this.itemData.find((itemDataI) => digg(itemDataI, \"key\") == key)\n  getItemDataForIndex = (index) => digg(this, \"itemData\", index)\n\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    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 = ({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 = ({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 = (initialDragPosition) => {\n    this.initialDragPosition = initialDragPosition\n  }\n\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\")) { // 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"],"mappings":"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","ignoreList":[]}

package/build/draggable-sort/index.js

@@ -0,0 +1,114 @@
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
+import { useMemo } from "react";
+import { Animated, PanResponder } from "react-native";
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import Controller from "./controller";
+import DraggableSortItem from "./item";
+import EventEmitter from "events";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import useEventEmitter from "../use-event-emitter";
+export default memo(shapeComponent(class DraggableSort extends ShapeComponent {
+  static defaultProps = {
+    horizontal: false
+  };
+  static propTypes = propTypesExact({
+    cacheKeyExtractor: PropTypes.func,
+    data: PropTypes.array.isRequired,
+    dataSet: PropTypes.object,
+    events: PropTypes.instanceOf(EventEmitter),
+    horizontal: PropTypes.bool.isRequired,
+    keyExtractor: PropTypes.func.isRequired,
+    onDragItemEnd: PropTypes.func,
+    onDragItemStart: PropTypes.func,
+    onItemMoved: PropTypes.func,
+    onReordered: PropTypes.func.isRequired,
+    renderItem: PropTypes.func.isRequired
+  });
+  setup() {
+    const {
+      data,
+      keyExtractor
+    } = this.p;
+    const {
+      events
+    } = this.props;
+    this.controller = useMemo(() => new Controller({
+      data,
+      events,
+      keyExtractor
+    }), []);
+    this.panResponder = useMemo(() => PanResponder.create({
+      onStartShouldSetPanResponder: e => {
+        const initialDragPosition = {
+          x: e.nativeEvent.locationX,
+          y: e.nativeEvent.locationY
+        };
+        this.controller.setInitialDragPosition(initialDragPosition);
+        if (this.controller.draggedItemData) {
+          return true;
+        }
+      },
+      onPanResponderMove: (e, gestate) => {
+        this.tt.controller.onMove({
+          gestate
+        });
+      },
+      onPanResponderRelease: (e, gestate) => {
+        if (this.controller.draggedItem) {
+          this.tt.controller.onDragEnd();
+        }
+      }
+    }), []);
+    useEventEmitter(this.controller.getEvents(), "onDragStart", this.tt.onDragItemStart);
+    useEventEmitter(this.controller.getEvents(), "onDragEnd", this.tt.onDragItemEnd);
+  }
+  render() {
+    const {
+      data,
+      horizontal,
+      keyExtractor,
+      renderItem
+    } = this.p;
+    const {
+      cacheKeyExtractor,
+      dataSet
+    } = this.props;
+    const actualDataSet = useMemo(() => Object.assign({
+      component: "draggable-sort"
+    }, dataSet), [dataSet]);
+    return /*#__PURE__*/React.createElement(Animated.View, _extends({
+      dataSet: actualDataSet,
+      style: {
+        flexDirection: horizontal ? "row" : "column"
+      }
+    }, this.tt.panResponder.panHandlers), data.map((item, itemIndex) => /*#__PURE__*/React.createElement(DraggableSortItem, {
+      cacheKey: cacheKeyExtractor ? cacheKeyExtractor(item) : undefined,
+      controller: this.tt.controller,
+      item: item,
+      itemIndex: itemIndex,
+      key: keyExtractor(item),
+      onItemMoved: this.props.onItemMoved,
+      renderItem: renderItem
+    })));
+  }
+  onDragItemStart = ({
+    itemData
+  }) => {
+    if (this.props.onDragItemStart) {
+      this.p.onDragItemStart({
+        itemData
+      });
+    }
+  };
+  onDragItemEnd = args => {
+    if (args.toPosition !== null) {
+      this.p.onReordered(args);
+    }
+    if (this.props.onDragItemEnd) {
+      this.p.onDragItemEnd(args);
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useMemo","Animated","PanResponder","shapeComponent","ShapeComponent","Controller","DraggableSortItem","EventEmitter","memo","PropTypes","propTypesExact","useEventEmitter","DraggableSort","defaultProps","horizontal","propTypes","cacheKeyExtractor","func","data","array","isRequired","dataSet","object","events","instanceOf","bool","keyExtractor","onDragItemEnd","onDragItemStart","onItemMoved","onReordered","renderItem","setup","p","props","controller","panResponder","create","onStartShouldSetPanResponder","e","initialDragPosition","x","nativeEvent","locationX","y","locationY","setInitialDragPosition","draggedItemData","onPanResponderMove","gestate","tt","onMove","onPanResponderRelease","draggedItem","onDragEnd","getEvents","render","actualDataSet","Object","assign","component","React","createElement","View","_extends","style","flexDirection","panHandlers","map","item","itemIndex","cacheKey","undefined","key","itemData","args","toPosition"],"sources":["../../src/draggable-sort/index.jsx"],"sourcesContent":["import {useMemo} from \"react\"\nimport {Animated, PanResponder} from \"react-native\"\nimport {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport Controller from \"./controller\"\nimport DraggableSortItem from \"./item\"\nimport EventEmitter from \"events\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"../use-event-emitter\"\n\nexport default memo(shapeComponent(class DraggableSort extends ShapeComponent {\n  static defaultProps = {\n    horizontal: false\n  }\n\n  static propTypes = propTypesExact({\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 = useMemo(() => new Controller({data, events, keyExtractor}), [])\n    this.panResponder = useMemo(\n      () => 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    )\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      () => Object.assign(\n        {\n          component: \"draggable-sort\"\n        },\n        dataSet\n      ),\n      [dataSet]\n    )\n\n    return (\n      <Animated.View dataSet={actualDataSet} style={{flexDirection: horizontal ? \"row\" : \"column\"}} {...this.tt.panResponder.panHandlers}>\n        {data.map((item, itemIndex) =>\n          <DraggableSortItem\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"],"mappings":"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","ignoreList":[]}

package/build/draggable-sort/item.js

@@ -0,0 +1,188 @@
+import { useMemo } from "react";
+import { Animated, Easing, PanResponder } from "react-native";
+import { shapeComponent, ShapeComponent } from "set-state-compare/src/shape-component";
+import EventEmitter from "events";
+import memo from "set-state-compare/src/memo";
+import PropTypes from "prop-types";
+import propTypesExact from "prop-types-exact";
+import useEventEmitter from "../use-event-emitter";
+export default memo(shapeComponent(class DraggableSortItem extends ShapeComponent {
+  static propTypes = propTypesExact({
+    cacheKey: PropTypes.string,
+    controller: PropTypes.object.isRequired,
+    item: PropTypes.any.isRequired,
+    itemIndex: PropTypes.number.isRequired,
+    onItemMoved: PropTypes.func,
+    renderItem: PropTypes.func.isRequired
+  });
+  initialLayout = null;
+  setup() {
+    this.useStates({
+      active: false,
+      dragging: false
+    });
+    this.events = useMemo(() => new EventEmitter(), []);
+    this.position = useMemo(() => new Animated.ValueXY(), []);
+    this.panResponder = useMemo(() => PanResponder.create({
+      onStartShouldSetPanResponder: e => {
+        this.setState({
+          dragging: true
+        });
+        this.p.controller.onDragStart({
+          item: this.p.item,
+          itemIndex: this.p.itemIndex
+        });
+        return false;
+      }
+    }), []);
+    useEventEmitter(this.p.controller.getEvents(), "onDragStart", this.tt.onDragStart);
+    useEventEmitter(this.p.controller.getEvents(), "onDragEndAnimation", this.tt.onDragEndAnimation);
+    useEventEmitter(this.tt.events, "move", this.tt.onMove);
+    useEventEmitter(this.tt.events, "moveToPosition", this.tt.onMoveToPosition);
+    useEventEmitter(this.tt.events, "resetPosition", this.tt.onResetPosition);
+  }
+  render() {
+    const {
+      item,
+      renderItem
+    } = this.p;
+    const {
+      active
+    } = this.s;
+    const style = useMemo(() => {
+      const style = {
+        transform: this.tt.position.getTranslateTransform()
+      };
+      if (active) {
+        style.backgroundColor = "#fff";
+        style.elevation = 2;
+        style.zIndex = 99999;
+      }
+      return style;
+    }, [active]);
+    return /*#__PURE__*/React.createElement(Animated.View, {
+      dataSet: {
+        component: "draggable-sort/item"
+      },
+      onLayout: this.tt.onLayout,
+      style: style
+    }, renderItem({
+      isActive: active,
+      item,
+      touchProps: this.tt.panResponder.panHandlers
+    }));
+  }
+  onDragStart = ({
+    itemData
+  }) => {
+    const newState = {
+      dragging: true
+    };
+    if (itemData.index == this.p.itemIndex) {
+      newState.active = true;
+      this.baseXAtStartedDragging = this.getBaseX();
+    }
+    this.setState(newState);
+  };
+  onDragEndAnimation = () => this.setState({
+    active: false,
+    dragging: false
+  });
+  onLayout = e => {
+    const {
+      controller,
+      item,
+      itemIndex
+    } = this.p;
+    controller.onItemLayout({
+      events: this.tt.events,
+      index: itemIndex,
+      item,
+      layout: e.nativeEvent.layout
+    });
+    if (!this.tt.initialLayout) {
+      this.initialLayout = e.nativeEvent.layout;
+    }
+  };
+  onMove = ({
+    gestate
+  }) => {
+    const x = gestate.dx + this.tt.baseXAtStartedDragging - this.tt.initialLayout.x;
+    const y = this.tt.initialLayout.y;
+    this.tt.position.setValue({
+      x,
+      y
+    });
+    if (this.props.onItemMoved) {
+      this.p.onItemMoved({
+        itemIndex: this.p.itemIndex,
+        x,
+        y
+      });
+    }
+  };
+  onMoveToPosition = ({
+    x,
+    y
+  }) => {
+    const calculatedXFromStartingPosition = x - this.tt.initialLayout.x;
+    const animationArgs = {
+      duration: 200,
+      easing: Easing.inOut(Easing.linear),
+      toValue: {
+        x: calculatedXFromStartingPosition,
+        y
+      },
+      useNativeDriver: true
+    };
+    const animationEventArgs = {
+      animationArgs,
+      animationType: "moveToPosition",
+      item: this.p.item
+    };
+    this.p.controller.events.emit("onAnimationStart", animationEventArgs);
+    Animated.timing(this.tt.position, animationArgs).start(() => {
+      this.p.controller.events.emit("onAnimationEnd", animationEventArgs);
+    });
+    if (this.props.onItemMoved) {
+      this.p.onItemMoved({
+        animationArgs,
+        itemIndex: this.p.itemIndex,
+        x: calculatedXFromStartingPosition,
+        y
+      });
+    }
+  };
+  getBaseX = () => this.p.controller.getItemDataForIndex(this.p.itemIndex).baseX;
+  onResetPosition = args => {
+    const baseX = this.getBaseX() - this.tt.initialLayout.x;
+    const animationArgs = {
+      duration: 200,
+      easing: Easing.inOut(Easing.linear),
+      toValue: {
+        x: baseX,
+        y: 0
+      },
+      useNativeDriver: true
+    };
+    const animationEventArgs = {
+      animationArgs,
+      animationType: "resetPosition",
+      item: this.p.item
+    };
+    this.p.controller.events.emit("onAnimationStart", animationEventArgs);
+    Animated.timing(this.tt.position, animationArgs).start(() => {
+      this.p.controller.events.emit("onAnimationEnd", animationEventArgs);
+      if (args?.callback) args.callback();
+    });
+    if (this.props.onItemMoved) {
+      this.p.onItemMoved({
+        animationArgs,
+        itemIndex: this.p.itemIndex,
+        x: baseX,
+        y: 0
+      });
+    }
+  };
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["useMemo","Animated","Easing","PanResponder","shapeComponent","ShapeComponent","EventEmitter","memo","PropTypes","propTypesExact","useEventEmitter","DraggableSortItem","propTypes","cacheKey","string","controller","object","isRequired","item","any","itemIndex","number","onItemMoved","func","renderItem","initialLayout","setup","useStates","active","dragging","events","position","ValueXY","panResponder","create","onStartShouldSetPanResponder","e","setState","p","onDragStart","getEvents","tt","onDragEndAnimation","onMove","onMoveToPosition","onResetPosition","render","s","style","transform","getTranslateTransform","backgroundColor","elevation","zIndex","React","createElement","View","dataSet","component","onLayout","isActive","touchProps","panHandlers","itemData","newState","index","baseXAtStartedDragging","getBaseX","onItemLayout","layout","nativeEvent","gestate","x","dx","y","setValue","props","calculatedXFromStartingPosition","animationArgs","duration","easing","inOut","linear","toValue","useNativeDriver","animationEventArgs","animationType","emit","timing","start","getItemDataForIndex","baseX","args","callback"],"sources":["../../src/draggable-sort/item.jsx"],"sourcesContent":["import {useMemo} from \"react\"\nimport {Animated, Easing, PanResponder} from \"react-native\"\nimport {shapeComponent, ShapeComponent} from \"set-state-compare/src/shape-component\"\nimport EventEmitter from \"events\"\nimport memo from \"set-state-compare/src/memo\"\nimport PropTypes from \"prop-types\"\nimport propTypesExact from \"prop-types-exact\"\nimport useEventEmitter from \"../use-event-emitter\"\n\nexport default memo(shapeComponent(class DraggableSortItem extends ShapeComponent {\n  static propTypes = propTypesExact({\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  initialLayout = null\n\n  setup() {\n    this.useStates({\n      active: false,\n      dragging: false\n    })\n\n    this.events = useMemo(() => new EventEmitter(), [])\n    this.position = useMemo(() => new Animated.ValueXY(), [])\n    this.panResponder = useMemo(\n      () => PanResponder.create({\n        onStartShouldSetPanResponder: (e, ) => {\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    )\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 {item, renderItem} = this.p\n    const {active} = this.s\n    const style = useMemo(\n      () => {\n        const style = {\n          transform: this.tt.position.getTranslateTransform()\n        }\n\n        if (active) {\n          style.backgroundColor = \"#fff\"\n          style.elevation = 2\n          style.zIndex = 99999\n        }\n\n        return style\n      },\n      [active]\n    )\n\n    return (\n      <Animated.View dataSet={{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"],"mappings":"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","ignoreList":[]}

package/build/error-logger.js

@@ -0,0 +1,101 @@
+import { digg } from "diggerize";
+import SourceMapsLoader from "./source-maps-loader";
+export default class ErrorLogger {
+  constructor() {
+    this.debugging = false;
+    this.errorOccurred = false;
+    this.errors = [];
+    this.isHandlingError = false;
+    this.sourceMapsLoader = new SourceMapsLoader();
+    this.sourceMapsLoader.loadSourceMapsForScriptTags(script => {
+      const src = script.getAttribute("src");
+      const type = script.getAttribute("type");
+      if (src && (src.includes("/packs/") || src.includes("/packs-test/")) && (type == "text/javascript" || !type)) {
+        return src;
+      }
+    });
+  }
+  debug(...output) {
+    if (this.debugging) console.error(`ApiMaker ErrorLogger:`, ...output);
+  }
+  enable() {
+    this.debug("Enable called");
+    this.connectOnError();
+    this.connectUnhandledRejection();
+  }
+  getErrors = () => this.errors;
+  hasErrorOccurred() {
+    return digg(this, "errorOccurred");
+  }
+  isLoadingSourceMaps() {
+    return digg(this, "sourceMapsLoader", "isLoadingSourceMaps");
+  }
+  isWorkingOnError() {
+    return digg(this, "isHandlingError") || this.isLoadingSourceMaps();
+  }
+  connectOnError() {
+    window.addEventListener("error", event => {
+      if (this.debugging) this.debug(`Error:`, event.message);
+      this.errorOccurred = true;
+      if (!this.isHandlingError) {
+        this.isHandlingError = true;
+        this.onError(event).finally(() => {
+          this.isHandlingError = false;
+        });
+      }
+    });
+  }
+  connectUnhandledRejection() {
+    window.addEventListener("unhandledrejection", event => {
+      if (this.debugging) this.debug(`Unhandled rejection:`, event.reason.message);
+      this.errorOccurred = true;
+      if (!this.isHandlingError) {
+        this.isHandlingError = true;
+        this.onUnhandledRejection(event).finally(() => {
+          this.isHandlingError = false;
+        });
+      }
+    });
+  }
+  async onError(event) {
+    this.errorOccurred = true;
+    await this.sourceMapsLoader.loadSourceMaps(event.error);
+    if (event.error && event.error.stack) {
+      const backtrace = this.sourceMapsLoader.parseStackTrace(event.error.stack);
+      this.errors.push({
+        errorClass: event.error ? event.error.name : "No error class",
+        message: event.message || "Unknown error",
+        backtrace
+      });
+    } else {
+      this.errors.push({
+        errorClass: event.error ? event.error.name : "No error class",
+        message: event.message || "Unknown error",
+        backtrace: null
+      });
+    }
+  }
+  async onUnhandledRejection(event) {
+    await this.sourceMapsLoader.loadSourceMaps(event.reason);
+    if (event.reason.stack) {
+      const backtrace = this.sourceMapsLoader.parseStackTrace(event.reason.stack);
+      this.errors.push({
+        errorClass: "UnhandledRejection",
+        message: event.reason.message || "Unhandled promise rejection",
+        backtrace
+      });
+    } else {
+      this.errors.push({
+        errorClass: "UnhandledRejection",
+        message: event.reason.message || "Unhandled promise rejection",
+        backtrace: null
+      });
+    }
+  }
+  testPromiseError() {
+    return new Promise(_resolve => {
+      throw new Error("testPromiseError");
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["digg","SourceMapsLoader","ErrorLogger","constructor","debugging","errorOccurred","errors","isHandlingError","sourceMapsLoader","loadSourceMapsForScriptTags","script","src","getAttribute","type","includes","debug","output","console","error","enable","connectOnError","connectUnhandledRejection","getErrors","hasErrorOccurred","isLoadingSourceMaps","isWorkingOnError","window","addEventListener","event","message","onError","finally","reason","onUnhandledRejection","loadSourceMaps","stack","backtrace","parseStackTrace","push","errorClass","name","testPromiseError","Promise","_resolve","Error"],"sources":["../src/error-logger.js"],"sourcesContent":["import {digg} from \"diggerize\"\nimport SourceMapsLoader from \"./source-maps-loader\"\n\nexport default class ErrorLogger {\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(...output) {\n    if (this.debugging) console.error(`ApiMaker ErrorLogger:`, ...output)\n  }\n\n  enable () {\n    this.debug(\"Enable called\")\n    this.connectOnError()\n    this.connectUnhandledRejection()\n  }\n\n  getErrors = () => this.errors\n\n  hasErrorOccurred() {\n    return digg(this, \"errorOccurred\")\n  }\n\n  isLoadingSourceMaps() {\n    return digg(this, \"sourceMapsLoader\", \"isLoadingSourceMaps\")\n  }\n\n  isWorkingOnError() {\n    return digg(this, \"isHandlingError\") || this.isLoadingSourceMaps()\n  }\n\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    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    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    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    return new Promise((_resolve) => {\n      throw new Error(\"testPromiseError\")\n    })\n  }\n}\n"],"mappings":"AAAA,SAAQA,IAAI,QAAO,WAAW;AAC9B,OAAOC,gBAAgB,MAAM,sBAAsB;AAEnD,eAAe,MAAMC,WAAW,CAAC;EAC/BC,WAAWA,CAAA,EAAI;IACb,IAAI,CAACC,SAAS,GAAG,KAAK;IACtB,IAAI,CAACC,aAAa,GAAG,KAAK;IAC1B,IAAI,CAACC,MAAM,GAAG,EAAE;IAChB,IAAI,CAACC,eAAe,GAAG,KAAK;IAC5B,IAAI,CAACC,gBAAgB,GAAG,IAAIP,gBAAgB,CAAC,CAAC;IAC9C,IAAI,CAACO,gBAAgB,CAACC,2BAA2B,CAAEC,MAAM,IAAK;MAC5D,MAAMC,GAAG,GAAGD,MAAM,CAACE,YAAY,CAAC,KAAK,CAAC;MACtC,MAAMC,IAAI,GAAGH,MAAM,CAACE,YAAY,CAAC,MAAM,CAAC;MAExC,IAAID,GAAG,KAAKA,GAAG,CAACG,QAAQ,CAAC,SAAS,CAAC,IAAIH,GAAG,CAACG,QAAQ,CAAC,cAAc,CAAC,CAAC,KAAKD,IAAI,IAAI,iBAAiB,IAAI,CAACA,IAAI,CAAC,EAAE;QAC5G,OAAOF,GAAG;MACZ;IACF,CAAC,CAAC;EACJ;EAEAI,KAAKA,CAAC,GAAGC,MAAM,EAAE;IACf,IAAI,IAAI,CAACZ,SAAS,EAAEa,OAAO,CAACC,KAAK,CAAC,uBAAuB,EAAE,GAAGF,MAAM,CAAC;EACvE;EAEAG,MAAMA,CAAA,EAAI;IACR,IAAI,CAACJ,KAAK,CAAC,eAAe,CAAC;IAC3B,IAAI,CAACK,cAAc,CAAC,CAAC;IACrB,IAAI,CAACC,yBAAyB,CAAC,CAAC;EAClC;EAEAC,SAAS,GAAGA,CAAA,KAAM,IAAI,CAAChB,MAAM;EAE7BiB,gBAAgBA,CAAA,EAAG;IACjB,OAAOvB,IAAI,CAAC,IAAI,EAAE,eAAe,CAAC;EACpC;EAEAwB,mBAAmBA,CAAA,EAAG;IACpB,OAAOxB,IAAI,CAAC,IAAI,EAAE,kBAAkB,EAAE,qBAAqB,CAAC;EAC9D;EAEAyB,gBAAgBA,CAAA,EAAG;IACjB,OAAOzB,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC,IAAI,IAAI,CAACwB,mBAAmB,CAAC,CAAC;EACpE;EAEAJ,cAAcA,CAAA,EAAI;IAChBM,MAAM,CAACC,gBAAgB,CAAC,OAAO,EAAGC,KAAK,IAAK;MAC1C,IAAI,IAAI,CAACxB,SAAS,EAAE,IAAI,CAACW,KAAK,CAAC,QAAQ,EAAEa,KAAK,CAACC,OAAO,CAAC;MACvD,IAAI,CAACxB,aAAa,GAAG,IAAI;MAEzB,IAAI,CAAC,IAAI,CAACE,eAAe,EAAE;QACzB,IAAI,CAACA,eAAe,GAAG,IAAI;QAC3B,IAAI,CAACuB,OAAO,CAACF,KAAK,CAAC,CAACG,OAAO,CAAC,MAAM;UAChC,IAAI,CAACxB,eAAe,GAAG,KAAK;QAC9B,CAAC,CAAC;MACJ;IACF,CAAC,CAAC;EACJ;EAEAc,yBAAyBA,CAAA,EAAI;IAC3BK,MAAM,CAACC,gBAAgB,CAAC,oBAAoB,EAAGC,KAAK,IAAK;MACvD,IAAI,IAAI,CAACxB,SAAS,EAAE,IAAI,CAACW,KAAK,CAAC,sBAAsB,EAAEa,KAAK,CAACI,MAAM,CAACH,OAAO,CAAC;MAC5E,IAAI,CAACxB,aAAa,GAAG,IAAI;MAEzB,IAAI,CAAC,IAAI,CAACE,eAAe,EAAE;QACzB,IAAI,CAACA,eAAe,GAAG,IAAI;QAC3B,IAAI,CAAC0B,oBAAoB,CAACL,KAAK,CAAC,CAACG,OAAO,CAAC,MAAM;UAC7C,IAAI,CAACxB,eAAe,GAAG,KAAK;QAC9B,CAAC,CAAC;MACJ;IACF,CAAC,CAAC;EACJ;EAEA,MAAMuB,OAAOA,CAAEF,KAAK,EAAE;IACpB,IAAI,CAACvB,aAAa,GAAG,IAAI;IACzB,MAAM,IAAI,CAACG,gBAAgB,CAAC0B,cAAc,CAACN,KAAK,CAACV,KAAK,CAAC;IAEvD,IAAIU,KAAK,CAACV,KAAK,IAAIU,KAAK,CAACV,KAAK,CAACiB,KAAK,EAAE;MACpC,MAAMC,SAAS,GAAG,IAAI,CAAC5B,gBAAgB,CAAC6B,eAAe,CAACT,KAAK,CAACV,KAAK,CAACiB,KAAK,CAAC;MAE1E,IAAI,CAAC7B,MAAM,CAACgC,IAAI,CAAC;QACfC,UAAU,EAAEX,KAAK,CAACV,KAAK,GAAGU,KAAK,CAACV,KAAK,CAACsB,IAAI,GAAG,gBAAgB;QAC7DX,OAAO,EAAED,KAAK,CAACC,OAAO,IAAI,eAAe;QACzCO;MACF,CAAC,CAAC;IACJ,CAAC,MAAM;MACL,IAAI,CAAC9B,MAAM,CAACgC,IAAI,CAAC;QACfC,UAAU,EAAEX,KAAK,CAACV,KAAK,GAAGU,KAAK,CAACV,KAAK,CAACsB,IAAI,GAAG,gBAAgB;QAC7DX,OAAO,EAAED,KAAK,CAACC,OAAO,IAAI,eAAe;QACzCO,SAAS,EAAE;MACb,CAAC,CAAC;IACJ;EACF;EAEA,MAAMH,oBAAoBA,CAAEL,KAAK,EAAE;IACjC,MAAM,IAAI,CAACpB,gBAAgB,CAAC0B,cAAc,CAACN,KAAK,CAACI,MAAM,CAAC;IAExD,IAAIJ,KAAK,CAACI,MAAM,CAACG,KAAK,EAAE;MACtB,MAAMC,SAAS,GAAG,IAAI,CAAC5B,gBAAgB,CAAC6B,eAAe,CAACT,KAAK,CAACI,MAAM,CAACG,KAAK,CAAC;MAE3E,IAAI,CAAC7B,MAAM,CAACgC,IAAI,CAAC;QACfC,UAAU,EAAE,oBAAoB;QAChCV,OAAO,EAAED,KAAK,CAACI,MAAM,CAACH,OAAO,IAAI,6BAA6B;QAC9DO;MACF,CAAC,CAAC;IACJ,CAAC,MAAM;MACL,IAAI,CAAC9B,MAAM,CAACgC,IAAI,CAAC;QACfC,UAAU,EAAE,oBAAoB;QAChCV,OAAO,EAAED,KAAK,CAACI,MAAM,CAACH,OAAO,IAAI,6BAA6B;QAC9DO,SAAS,EAAE;MACb,CAAC,CAAC;IACJ;EACF;EAEAK,gBAAgBA,CAAA,EAAI;IAClB,OAAO,IAAIC,OAAO,CAAEC,QAAQ,IAAK;MAC/B,MAAM,IAAIC,KAAK,CAAC,kBAAkB,CAAC;IACrC,CAAC,CAAC;EACJ;AACF","ignoreList":[]}

package/build/error-messages.js

@@ -0,0 +1,13 @@
+import { digg } from "diggerize";
+const errorMessages = args => {
+  if (typeof args.response == "object") {
+    return digg(args, "response", "errors").map(error => {
+      if (typeof error == "string") {
+        return error;
+      }
+      return digg(error, "message");
+    });
+  }
+};
+export default errorMessages;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJkaWdnIiwiZXJyb3JNZXNzYWdlcyIsImFyZ3MiLCJyZXNwb25zZSIsIm1hcCIsImVycm9yIl0sInNvdXJjZXMiOlsiLi4vc3JjL2Vycm9yLW1lc3NhZ2VzLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7ZGlnZ30gZnJvbSBcImRpZ2dlcml6ZVwiXG5cbmNvbnN0IGVycm9yTWVzc2FnZXMgPSAoYXJncykgPT4ge1xuICBpZiAodHlwZW9mIGFyZ3MucmVzcG9uc2UgPT0gXCJvYmplY3RcIikge1xuICAgIHJldHVybiBkaWdnKGFyZ3MsIFwicmVzcG9uc2VcIiwgXCJlcnJvcnNcIikubWFwKChlcnJvcikgPT4ge1xuICAgICAgaWYgKHR5cGVvZiBlcnJvciA9PSBcInN0cmluZ1wiKSB7XG4gICAgICAgIHJldHVybiBlcnJvclxuICAgICAgfVxuXG4gICAgICByZXR1cm4gZGlnZyhlcnJvciwgXCJtZXNzYWdlXCIpXG4gICAgfSlcbiAgfVxufVxuXG5leHBvcnQgZGVmYXVsdCBlcnJvck1lc3NhZ2VzXG4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVFBLElBQUksUUFBTyxXQUFXO0FBRTlCLE1BQU1DLGFBQWEsR0FBSUMsSUFBSSxJQUFLO0VBQzlCLElBQUksT0FBT0EsSUFBSSxDQUFDQyxRQUFRLElBQUksUUFBUSxFQUFFO0lBQ3BDLE9BQU9ILElBQUksQ0FBQ0UsSUFBSSxFQUFFLFVBQVUsRUFBRSxRQUFRLENBQUMsQ0FBQ0UsR0FBRyxDQUFFQyxLQUFLLElBQUs7TUFDckQsSUFBSSxPQUFPQSxLQUFLLElBQUksUUFBUSxFQUFFO1FBQzVCLE9BQU9BLEtBQUs7TUFDZDtNQUVBLE9BQU9MLElBQUksQ0FBQ0ssS0FBSyxFQUFFLFNBQVMsQ0FBQztJQUMvQixDQUFDLENBQUM7RUFDSjtBQUNGLENBQUM7QUFFRCxlQUFlSixhQUFhIiwiaWdub3JlTGlzdCI6W119