@rpg-engine/long-bow 0.7.72 → 0.7.73

package/src/components/Item/Inventory/context/ItemSlotDetailsContext.tsx

@@ -0,0 +1,130 @@
+import { IItem, ItemContainerType } from '@rpg-engine/shared';
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+} from 'react';
+import { generateContextMenu, IContextMenuItem } from '../itemContainerHelper';
+
+interface IPosition {
+  x: number;
+  y: number;
+}
+
+interface IItemSlotDetailsState {
+  item: IItem | null;
+  isTooltipVisible: boolean;
+  isTooltipMobileVisible: boolean;
+  isContextMenuVisible: boolean;
+  contextMenuPosition: IPosition;
+  contextActions: IContextMenuItem[];
+  clearContextActions: () => void;
+  clearDetailsState: () => void;
+}
+
+interface IItemSlotDetailsContext {
+  detailsState: IItemSlotDetailsState;
+  updateDetailsState: (newState: Partial<IItemSlotDetailsState>) => void;
+  clearDetailsState: () => void;
+  setContextActions: (
+    item: IItem | null,
+    containerType: string | null,
+    isDepotSystem: boolean
+  ) => void;
+  clearContextActions: () => void;
+}
+
+const initialDetailsState: IItemSlotDetailsState = {
+  item: null,
+  isTooltipVisible: false,
+  isTooltipMobileVisible: false,
+  isContextMenuVisible: false,
+  contextMenuPosition: { x: 0, y: 0 },
+  contextActions: [],
+  clearContextActions: () => {},
+  clearDetailsState: () => {},
+};
+
+const ItemSlotDetailsContext = createContext<IItemSlotDetailsContext>({
+  detailsState: initialDetailsState,
+  updateDetailsState: () => {},
+  clearDetailsState: () => {},
+  setContextActions: () => {},
+  clearContextActions: () => {},
+});
+
+export const useItemSlotDetails = (): IItemSlotDetailsContext =>
+  useContext(ItemSlotDetailsContext);
+
+interface IProps {
+  children: React.ReactNode;
+}
+
+export const ItemSlotDetailsProvider: React.FC<IProps> = ({ children }) => {
+  const [detailsState, setDetailsState] = useState<IItemSlotDetailsState>(
+    initialDetailsState
+  );
+
+  const updateDetailsState = useCallback(
+    (newState: Partial<IItemSlotDetailsState>): void => {
+      setDetailsState(prevState => ({
+        ...prevState,
+        ...newState,
+      }));
+    },
+    []
+  );
+
+  const clearDetailsState = useCallback(() => {
+    setDetailsState(initialDetailsState);
+  }, [setDetailsState]);
+
+  const setContextActions = useCallback(
+    (
+      item: IItem | null,
+      containerType: string | null,
+      isDepotSystem: boolean
+    ): void => {
+      if (item && containerType) {
+        const newContextActions = generateContextMenu(
+          item,
+          containerType as ItemContainerType,
+          isDepotSystem
+        );
+        updateDetailsState({ contextActions: newContextActions });
+      } else {
+        updateDetailsState({ contextActions: [] });
+      }
+    },
+    []
+  );
+
+  const clearContextActions = useCallback(() => {
+    updateDetailsState({ contextActions: [] });
+  }, [updateDetailsState]);
+
+  const contextValue = useMemo(
+    () => ({
+      detailsState,
+      updateDetailsState,
+      clearDetailsState,
+      setContextActions,
+      clearContextActions,
+    }),
+    [
+      detailsState,
+      updateDetailsState,
+      clearDetailsState,
+      setContextActions,
+      clearContextActions,
+    ]
+  );
+
+  return (
+    <ItemSlotDetailsContext.Provider value={contextValue}>
+      {children}
+    </ItemSlotDetailsContext.Provider>
+  );
+};

package/src/components/Item/Inventory/context/ItemSlotDraggingContext.tsx

@@ -0,0 +1,81 @@
+import { IItem } from '@rpg-engine/shared';
+import React, {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState,
+} from 'react';
+import { IPosition } from '../../../../types/eventTypes';
+
+interface IDraggingState {
+  item: IItem | null;
+  isDragging: boolean;
+  position: IPosition;
+  dropPosition: IPosition | null;
+  isFocused: boolean;
+  draggingDistance: number;
+}
+
+interface IDraggingContext {
+  draggingState: IDraggingState;
+  updateDraggingState: (newState: Partial<IDraggingState>) => void;
+  clearDraggingState: () => void;
+}
+
+const initialDraggingState: IDraggingState = {
+  item: null,
+  isDragging: false,
+  position: { x: 0, y: 0 },
+  dropPosition: null,
+  isFocused: false,
+  draggingDistance: 0,
+};
+
+const ItemSlotDraggingContext = createContext<IDraggingContext>({
+  draggingState: initialDraggingState,
+  updateDraggingState: () => {},
+  clearDraggingState: () => {},
+});
+
+export const useItemSlotDragging = (): IDraggingContext =>
+  useContext(ItemSlotDraggingContext);
+
+interface IProps {
+  children: React.ReactNode;
+}
+
+export const ItemSlotDraggingProvider: React.FC<IProps> = ({ children }) => {
+  const [draggingState, setDraggingState] = useState<IDraggingState>(
+    initialDraggingState
+  );
+
+  const updateDraggingState = useCallback(
+    (newState: Partial<IDraggingState>): void => {
+      setDraggingState(prevState => ({
+        ...prevState,
+        ...newState,
+      }));
+    },
+    []
+  );
+
+  const clearDraggingState = useCallback(() => {
+    setDraggingState(initialDraggingState);
+  }, []);
+
+  const contextValue = useMemo(
+    () => ({
+      draggingState,
+      updateDraggingState,
+      clearDraggingState,
+    }),
+    [draggingState, updateDraggingState, clearDraggingState]
+  );
+
+  return (
+    <ItemSlotDraggingContext.Provider value={contextValue}>
+      {children}
+    </ItemSlotDraggingContext.Provider>
+  );
+};

package/dist/components/Item/Inventory/context/DraggingContext.d.ts

@@ -1,11 +0,0 @@
-import { IItem } from '@rpg-engine/shared';
-import React from 'react';
-export declare const useDragging: () => {
-    item: IItem | null;
-    setDraggingItem: React.Dispatch<React.SetStateAction<IItem | null>>;
-};
-interface IProps {
-    children: React.ReactNode;
-}
-export declare const DraggingProvider: ({ children }: IProps) => JSX.Element;
-export {};

package/src/components/Item/Inventory/context/DraggingContext.tsx

@@ -1,26 +0,0 @@
-import { IItem } from '@rpg-engine/shared';
-import React, { createContext, useContext, useState } from 'react';
-
-const DraggingContext = createContext<{
-  item: IItem | null;
-  setDraggingItem: React.Dispatch<React.SetStateAction<IItem | null>>;
-}>({
-  item: null,
-  setDraggingItem: () => {},
-});
-
-export const useDragging = () => useContext(DraggingContext);
-
-interface IProps {
-  children: React.ReactNode;
-}
-
-export const DraggingProvider = ({ children }: IProps) => {
-  const [item, setDraggingItem] = useState<IItem | null>(null);
-
-  return (
-    <DraggingContext.Provider value={{ item, setDraggingItem }}>
-      {children}
-    </DraggingContext.Provider>
-  );
-};