@rpg-engine/long-bow 0.1.66 → 0.1.67

package/dist/components/DraggableContainer.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { IPosition } from '../types/eventTypes';
 import { RPGUIContainerTypes } from './RPGUIContainer';
 export interface IDraggableContainerProps {
     children: React.ReactNode;
@@ -10,5 +11,7 @@ export interface IDraggableContainerProps {
     imgSrc?: string;
     imgWidth?: string;
     onCloseButton: () => void;
+    cancelDrag?: string;
+    onPositionChange?: (position: IPosition) => void;
 }
 export declare const DraggableContainer: React.FC<IDraggableContainerProps>;

package/dist/components/Item/Inventory/ItemContainer.d.ts

@@ -5,5 +5,9 @@ export interface IItemContainerProps {
     onClose: () => void;
     onMouseOver: (e: any, slotIndex: number, item: IItem | null) => void;
     onActionSelected: (payload: any) => void;
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
 }
 export declare const ItemContainer: React.FC<IItemContainerProps>;

package/dist/components/Item/Inventory/ItemSlot.d.ts

@@ -3,8 +3,9 @@ import React from 'react';
 interface IProps {
     slotIndex: number;
     item: IItem | null;
-    onMouseOver: (event: any, slotIndex: number, item: IItem | null) => void;
-    onActionContextMenu: (event: any, slotIndex: number) => void;
+    onMouseOver: (event: any, slotIndex: number, item: IItem | null, x: number, y: number) => void;
+    onClick: (item: IItem, posX: number, posY: number) => void;
+    onCancelContextMenu: () => void;
 }
 export declare const ItemSlot: React.FC<IProps>;
 export {};

package/dist/components/Item/Inventory/itemContainerHelper.d.ts

@@ -0,0 +1,7 @@
+import { ItemType } from '@rpg-engine/shared';
+interface IContextMenuItem {
+    id: string;
+    text: string;
+}
+export declare const handleContextMenuList: (itemType: ItemType) => IContextMenuItem[];
+export {};

package/dist/hooks/useOutsideAlerter.d.ts

@@ -0,0 +1 @@
+export declare function useOutsideClick(ref: any, id: string): void;

package/dist/long-bow.cjs.development.js

@@ -299,14 +299,23 @@ var DraggableContainer = function DraggableContainer(_ref) {
       title = _ref.title,
       imgSrc = _ref.imgSrc,
       _ref$imgWidth = _ref.imgWidth,
-      imgWidth = _ref$imgWidth === void 0 ? '20px' : _ref$imgWidth;
+      imgWidth = _ref$imgWidth === void 0 ? '20px' : _ref$imgWidth,
+      cancelDrag = _ref.cancelDrag,
+      onPositionChange = _ref.onPositionChange;
   return React__default.createElement(Draggable, {
-    handle: ".drag-handdler",
-    cancel: ".container-close"
+    cancel: ".container-close," + cancelDrag,
+    onDrag: function onDrag(_e, data) {
+      if (onPositionChange) {
+        onPositionChange({
+          x: data.x,
+          y: data.y
+        });
+      }
+    }
   }, React__default.createElement(Container$2, {
     width: width,
     height: height || 'auto',
-    className: "rpgui-container " + type + " " + className + " rpgui-draggable"
+    className: "rpgui-container " + type + " " + className
   }, React__default.createElement(TitleContainer, {
     className: "drag-handler"
   }, React__default.createElement(Title, null, imgSrc && React__default.createElement(Icon, {
@@ -393,6 +402,32 @@ var Dropdown = function Dropdown(_ref) {
   }));
 };
 
+function useOutsideClick(ref, id) {
+  React.useEffect(function () {
+    /**
+     * Alert if clicked on outside of element
+     */
+    function handleClickOutside(event) {
+      if (ref.current && !ref.current.contains(event.target)) {
+        var _event = new CustomEvent('clickOutside', {
+          detail: {
+            id: id
+          }
+        });
+
+        document.dispatchEvent(_event);
+      }
+    } // Bind the event listener
+
+
+    document.addEventListener('mousedown', handleClickOutside);
+    return function () {
+      // Unbind the event listener on clean up
+      document.removeEventListener('mousedown', handleClickOutside);
+    };
+  }, [ref]);
+}
+
 var ListMenu = function ListMenu(_ref) {
   var options = _ref.options,
       onSelected = _ref.onSelected,
@@ -445,12 +480,57 @@ var ItemCard = function ItemCard(_ref) {
 var Container$4 = /*#__PURE__*/styled.div.withConfig({
   displayName: "ItemCard__Container",
   componentId: "sc-170rits-0"
-})(["position:absolute;top:", "px;left:", "px;font-size:7px;color:white;"], function (props) {
+})(["position:absolute;top:", "px;left:", "px;font-size:0.5rem;color:white;background-color:black;border-radius:5px;padding:0.5rem;min-width:20px;opacity:0.5;"], function (props) {
   return props.y || 0;
 }, function (props) {
   return props.x || 0;
 });
 
+var handleContextMenuList = function handleContextMenuList(itemType) {
+  var generateContextList = function generateContextList(actionsByTypeList) {
+    var contextMenu = actionsByTypeList.map(function (action) {
+      return {
+        id: action,
+        text: action
+      };
+    });
+    return contextMenu;
+  };
+
+  var contextActionMenu = [];
+
+  switch (itemType) {
+    case shared.ItemType.Weapon:
+    case shared.ItemType.Armor:
+    case shared.ItemType.Accessory:
+    case shared.ItemType.Jewelry:
+    case shared.ItemType.Tool:
+      contextActionMenu = generateContextList(shared.ActionsByItemType.Equipment);
+      break;
+
+    case shared.ItemType.Consumable:
+      contextActionMenu = generateContextList(shared.ActionsByItemType.Consumable);
+      break;
+
+    case shared.ItemType.CraftMaterial:
+      contextActionMenu = generateContextList(shared.ActionsByItemType.CraftMaterial);
+      break;
+
+    case shared.ItemType.Other:
+    case shared.ItemType.Information:
+    case shared.ItemType.Quest:
+    case shared.ItemType.Container:
+      contextActionMenu = generateContextList(shared.ActionsByItemType.Other);
+      break;
+
+    default:
+      contextActionMenu = generateContextList(shared.ActionsByItemType.Other);
+      break;
+  }
+
+  return contextActionMenu;
+};
+
 var frames = {
 	"accessories/bandana.png": {
 		frame: {
@@ -2203,20 +2283,27 @@ var ItemSlot = function ItemSlot(_ref) {
   var slotIndex = _ref.slotIndex,
       item = _ref.item,
       _onMouseOver = _ref.onMouseOver,
-      onActionContextMenu = _ref.onActionContextMenu;
+      _onClick = _ref.onClick,
+      onCancelContextMenu = _ref.onCancelContextMenu;
 
-  var getLeftPostionValue = function getLeftPostionValue(quantity) {
+  var getLeftPositionValue = function getLeftPositionValue(quantity) {
     if (quantity > 0 && quantity < 10) return '2.5rem';else if (quantity > 9 && quantity < 100) return '2.0rem';else if (quantity > 99) return '1rem';
     return '2.5rem';
   };
 
   return React__default.createElement(Container$6, {
-    onContextMenu: function onContextMenu(event) {
-      onActionContextMenu(event, slotIndex);
-    },
     className: "rpgui-icon empty-slot",
     onMouseOver: function onMouseOver(event) {
-      return _onMouseOver(event, slotIndex, item);
+      return _onMouseOver(event, slotIndex, item, event.clientX, event.clientY);
+    },
+    onClick: function onClick(e) {
+      if (item) {
+        console.log(e);
+
+        _onClick(item, e.clientX, e.clientY);
+      } else {
+        onCancelContextMenu();
+      }
     }
   }, item && item.texturePath ? React__default.createElement(SpriteFromAtlas, {
     atlasIMG: img,
@@ -2224,7 +2311,7 @@ var ItemSlot = function ItemSlot(_ref) {
     spriteKey: item.texturePath,
     scale: 3
   }) : null, item && item.isStackable && item != null && item.stackQty ? React__default.createElement(ItemQty, {
-    left: getLeftPostionValue(item.stackQty)
+    left: getLeftPositionValue(item.stackQty)
   }, ' ', item.stackQty, ' ') : null);
 };
 var Container$6 = /*#__PURE__*/styled.div.withConfig({
@@ -2242,181 +2329,158 @@ var ItemContainer = function ItemContainer(_ref) {
   var itemContainer = _ref.itemContainer,
       onClose = _ref.onClose,
       onMouseOver = _ref.onMouseOver,
-      onActionSelected = _ref.onActionSelected;
+      onActionSelected = _ref.onActionSelected,
+      _ref$initialPosition = _ref.initialPosition,
+      initialPosition = _ref$initialPosition === void 0 ? {
+    x: 0,
+    y: 0
+  } : _ref$initialPosition;
+
+  // we use this draggable position to offset the menu position, after the container is dragged (otherwise, it bugs!)
+  var _useState = React.useState(initialPosition),
+      draggablePosition = _useState[0],
+      setDraggablePosition = _useState[1];
+
+  var draggableRef = React.useRef(null);
+  useOutsideClick(draggableRef, 'item-container');
+  React.useEffect(function () {
+    document.addEventListener('clickOutside', function (event) {
+      var e = event;
+
+      if (e.detail.id === 'item-container') {
+        clearContextMenu();
+        clearItemHoverDetail();
+      }
+    });
+    return function () {
+      document.removeEventListener('clickOutside', function (_e) {});
+    };
+  }, []);
+  var initX = initialPosition.x,
+      initY = initialPosition.y;
 
-  var _useState = React.useState({
+  var _useState2 = React.useState({
     visible: false,
-    posX: 0,
-    posY: 0,
+    posX: initX,
+    posY: initY,
     contextActions: [],
     slotItem: null
   }),
-      contextData = _useState[0],
-      setContextData = _useState[1];
+      contextData = _useState2[0],
+      setContextData = _useState2[1];
 
-  var _useState2 = React.useState({
+  var _useState3 = React.useState({
     visible: false,
-    posX: 0,
-    posY: 0,
+    posX: initX,
+    posY: initY,
     item: null
   }),
-      itemHoverDetail = _useState2[0];
-
-  var selectedSlotContext = null;
-
-  var handleContextMenuList = function handleContextMenuList(itemType) {
-    var generateContextList = function generateContextList(actionsByTypeList) {
-      var contextMenu = actionsByTypeList.map(function (action) {
-        return {
-          id: action,
-          text: action
-        };
-      });
-      return contextMenu;
-    };
-
-    var contextActionMenu = [];
-
-    switch (itemType) {
-      case shared.ItemType.Weapon:
-      case shared.ItemType.Armor:
-      case shared.ItemType.Accessory:
-      case shared.ItemType.Jewelry:
-      case shared.ItemType.Tool:
-        contextActionMenu = generateContextList(shared.ActionsByItemType.Equipment);
-        break;
-
-      case shared.ItemType.Consumable:
-        contextActionMenu = generateContextList(shared.ActionsByItemType.Consumable);
-        break;
-
-      case shared.ItemType.CraftMaterial:
-        contextActionMenu = generateContextList(shared.ActionsByItemType.CraftMaterial);
-        break;
-
-      case shared.ItemType.Other:
-      case shared.ItemType.Information:
-      case shared.ItemType.Quest:
-      case shared.ItemType.Container:
-        contextActionMenu = generateContextList(shared.ActionsByItemType.Other);
-        break;
-
-      default:
-        contextActionMenu = generateContextList(shared.ActionsByItemType.Other);
-        break;
-    }
-
-    return contextActionMenu;
+      itemHoverDetail = _useState3[0],
+      setItemHoverDetail = _useState3[1];
+
+  var clearContextMenu = function clearContextMenu() {
+    setContextData({
+      visible: false,
+      posX: 0,
+      posY: 0,
+      contextActions: [],
+      slotItem: null
+    });
   };
 
-  React.useEffect(function () {
-    var contextMenuEventHandler = function contextMenuEventHandler(event) {
-      event.preventDefault();
-
-      if (selectedSlotContext !== null) {
-        var _itemContainer$slots$, _itemContainer$slots;
-
-        var itemData = (_itemContainer$slots$ = (_itemContainer$slots = itemContainer.slots) == null ? void 0 : _itemContainer$slots[selectedSlotContext]) != null ? _itemContainer$slots$ : null;
-
-        if (itemData) {
-          // TODO: generate a menuActionList based on type and subType of the item.
-          var contextActionMenu = handleContextMenuList(itemData.type);
-          setContextData(_extends({}, contextData, {
-            visible: true,
-            posX: event.clientX,
-            posY: event.clientY,
-            slotItem: itemData,
-            contextActions: contextActionMenu
-          }));
-        } else {
-          // console.log("Empty Slot")
-          setContextData(_extends({}, contextData, {
-            visible: false,
-            posX: 0,
-            posY: 0,
-            slotIndex: null,
-            slotItem: null,
-            contextActions: []
-          }));
-        }
-      }
-    };
-
-    var offClickHandler = function offClickHandler(event) {
-      console.log(event);
-      setContextData(_extends({}, contextData, {
-        visible: false,
-        posX: 0,
-        posY: 0,
-        slotIndex: null,
-        slotItem: null
+  var handleOnMouseHover = function handleOnMouseHover(event, slotIndex, item, x, y) {
+    if (item) {
+      setItemHoverDetail(_extends({}, itemHoverDetail, {
+        visible: true,
+        item: item,
+        posX: x - draggablePosition.x,
+        posY: y - draggablePosition.y
       }));
-    };
-
-    document.addEventListener('contextmenu', contextMenuEventHandler);
-    document.addEventListener('click', offClickHandler);
-    return function () {
-      document.removeEventListener('contextmenu', contextMenuEventHandler);
-      document.removeEventListener('click', offClickHandler);
-    };
-  }, [contextData, selectedSlotContext]);
+      onMouseOver(event, slotIndex, item);
+    } else {
+      clearItemHoverDetail();
+    }
+  };
 
-  var onActionContextMenu = function onActionContextMenu(event, slotIndex) {
-    selectedSlotContext = slotIndex;
-    console.log(event); // setContextData({...contextData, slotItem: slotIndex})
+  var clearItemHoverDetail = function clearItemHoverDetail() {
+    setItemHoverDetail(_extends({}, itemHoverDetail, {
+      visible: false,
+      item: null
+    }));
   };
 
-  var handleOnMouseHover = function handleOnMouseHover(event, slotIndex, item) {
-    // TODO: Show a tip view with basic info about the item.
-    //  set a minimun hover period before show infos.
-    // setItemHoverDetail({...itemHoverDetail, visible: true, item: item, posX: event.clientX, posY: event.clientY})
-    onMouseOver(event, slotIndex, item);
+  var handleOnItemClick = function handleOnItemClick(item, posX, posY) {
+    var contextList = handleContextMenuList(item.type);
+    setContextData(_extends({}, contextData, {
+      visible: true,
+      posX: posX,
+      posY: posY,
+      slotItem: item,
+      contextActions: contextList
+    }));
+    clearItemHoverDetail();
   };
 
   var onSelected = function onSelected(selectedActionId) {
     var payloadData = {
       actionType: selectedActionId,
       item: contextData.slotItem
-    }; // TODO: create a function to validate the selection set the paylod data.
-
+    };
     onActionSelected(payloadData);
+    clearContextMenu();
   };
 
   var onRenderSlots = function onRenderSlots() {
     var slots = [];
 
     for (var i = 0; i < itemContainer.slotQty; i++) {
-      var _itemContainer$slots2;
+      var _itemContainer$slots;
 
       slots.push(React__default.createElement(ItemSlot, {
         key: i,
         slotIndex: i,
-        item: ((_itemContainer$slots2 = itemContainer.slots) == null ? void 0 : _itemContainer$slots2[i]) || null,
+        item: ((_itemContainer$slots = itemContainer.slots) == null ? void 0 : _itemContainer$slots[i]) || null,
         onMouseOver: handleOnMouseHover,
-        onActionContextMenu: onActionContextMenu
+        onClick: handleOnItemClick,
+        onCancelContextMenu: function onCancelContextMenu() {
+          clearContextMenu();
+        }
       }));
     }
 
     return slots;
   };
 
-  return React__default.createElement(DraggableContainer, {
+  return React__default.createElement("div", {
+    ref: draggableRef
+  }, React__default.createElement(DraggableContainer, {
     title: itemContainer.name || 'Container',
     type: exports.RPGUIContainerTypes.Framed,
     onCloseButton: function onCloseButton() {
       return onClose();
     },
-    width: "330px"
-  }, React__default.createElement(ItemsContainer, null, onRenderSlots()), contextData.visible ? React__default.createElement(ListMenu, {
-    x: contextData.posX,
-    y: contextData.posY,
+    width: "330px",
+    cancelDrag: ".item-container-body",
+    onPositionChange: function onPositionChange(_ref2) {
+      var x = _ref2.x,
+          y = _ref2.y;
+      setDraggablePosition({
+        x: x,
+        y: y
+      });
+    }
+  }, React__default.createElement(ItemsContainer, {
+    className: "item-container-body"
+  }, onRenderSlots()), contextData.visible ? React__default.createElement(ListMenu, {
+    x: contextData.posX - draggablePosition.x,
+    y: contextData.posY - draggablePosition.y,
     options: contextData.contextActions,
     onSelected: onSelected
   }) : null, itemHoverDetail.visible ? React__default.createElement(ItemCard, {
     item: itemHoverDetail.item,
     x: itemHoverDetail.posX,
     y: itemHoverDetail.posY
-  }) : null);
+  }) : null));
 };
 var ItemsContainer = /*#__PURE__*/styled.div.withConfig({
   displayName: "ItemContainer__ItemsContainer",