feat(actions): simplify action corner api through the toolbarService (#5033)

This commit is contained in:
Alireza authored and GitHub committed 2025-05-15 12:08:12 -04:00
1 parent f71b88e639
commit 7c15bb8901
246 files changed
+7930 -4270

No files matched your search

+5
View File
@@ -0,0 +1,5 @@
export * from './useToolbar';
export * from './types';
export * from './useViewportRef';
export * from './useViewportSize';
export * from './useViewportMousePosition';
+27
View File
@@ -0,0 +1,27 @@
export interface ToolbarButtonActions {
// Lock/Unlock actions
lockItem: (itemId: string, viewportId?: string) => void;
unlockItem: (itemId: string, viewportId?: string) => void;
toggleLock: (itemId: string, viewportId?: string) => void;
isItemLocked: (itemId: string, viewportId?: string) => boolean;
// Visibility actions
showItem: (itemId: string, viewportId?: string) => void;
hideItem: (itemId: string, viewportId?: string) => void;
toggleVisibility: (itemId: string, viewportId?: string) => void;
isItemVisible: (itemId: string, viewportId?: string) => boolean;
// Open/Close actions (for menus)
openItem: (itemId: string, viewportId?: string) => void;
closeItem: (itemId: string, viewportId?: string) => void;
closeAllItems: (viewportId?: string) => void;
isItemOpen: (itemId: string, viewportId?: string) => boolean;
// Evaluation
evaluateButtonForViewport: (itemId: string, viewportId?: string) => any;
}
export interface ToolbarHookReturn extends ToolbarButtonActions {
toolbarButtons: any[]; // The display representation of toolbar buttons
onInteraction: (args: any) => void;
}
@@ -1,6 +1,6 @@
import { useEffect, useState, useCallback } from 'react';
import { DisplaySet } from '../types';
import { useSystem } from '../';
/**
* Hook that listens for changes in the active viewport and its display sets.
* It returns the display sets associated with the active viewport.
@@ -8,7 +8,8 @@ import { DisplaySet } from '../types';
* @param servicesManager - Services manager instance
* @returns Array of display sets for the active viewport
*/
const useActiveViewportDisplaySets = ({ servicesManager }): DisplaySet[] => {
const useActiveViewportDisplaySets = (): DisplaySet[] => {
const { servicesManager } = useSystem();
const { displaySetService, viewportGridService } = servicesManager.services;
// Move this function outside useEffect and memoize it
const getDisplaySetsForViewport = useCallback(
+173 -7
View File
@@ -1,20 +1,26 @@
import { useCallback, useEffect, useState } from 'react';
import { useCallback, useEffect, useState, useMemo } from 'react';
import { useSystem } from '../contextProviders/SystemProvider';
import { ToolbarHookReturn } from './types';
export function useToolbar({ buttonSection = 'primary' }: withAppTypes) {
export function useToolbar({ buttonSection = 'primary' }: withAppTypes): ToolbarHookReturn {
const { commandsManager, servicesManager } = useSystem();
const { toolbarService, viewportGridService } = servicesManager.services;
const { EVENTS } = toolbarService;
// Store all buttons returned by the toolbar service
const [toolbarButtons, setToolbarButtons] = useState(
toolbarService.getButtonSection(buttonSection as string)
toolbarService.getButtonSection(buttonSection as string).filter(Boolean)
);
// Store state of open/closed menu items
// Note: We keep this in local state to avoid re-evaluating the toolbar on every interaction
const [openItemIds, setOpenItemIds] = useState<Record<string, boolean>>({});
// Callback function for handling toolbar interactions
const onInteraction = useCallback(
args => {
args.event?.stopPropagation?.();
const viewportId = viewportGridService.getActiveViewportId();
const viewportId = args.viewportId || viewportGridService.getActiveViewportId();
const refreshProps = { viewportId };
const buttonProps = toolbarService.getButtonProps(args.itemId);
@@ -58,15 +64,17 @@ export function useToolbar({ buttonSection = 'primary' }: withAppTypes) {
buttonProps.commands = allCommands;
}
toolbarService.recordInteraction({ ...args, ...buttonProps }, { refreshProps });
},
[toolbarService, viewportGridService, toolbarButtons]
[toolbarService, viewportGridService]
);
// Effect to handle toolbar modification events
useEffect(() => {
const handleToolbarModified = () => {
setToolbarButtons(toolbarService.getButtonSection(buttonSection as string)?.filter(Boolean));
const buttons = toolbarService.getButtonSection(buttonSection as string)?.filter(Boolean);
setToolbarButtons(buttons);
};
const subs = [EVENTS.TOOL_BAR_MODIFIED, EVENTS.TOOL_BAR_STATE_MODIFIED].map(event => {
@@ -96,5 +104,163 @@ export function useToolbar({ buttonSection = 'primary' }: withAppTypes) {
return () => subscriptions.forEach(sub => sub.unsubscribe());
}, [viewportGridService, toolbarService]);
return { toolbarButtons, onInteraction };
// Action API for toolbar buttons
const actions = useMemo(() => {
return {
// Lock/Unlock actions
lockItem: (itemId: string, viewportId?: string) => {
const targetViewportId = viewportId || viewportGridService.getActiveViewportId();
const button = toolbarService.getButton(itemId);
if (button) {
// Set isLocked flag in button metadata
button.props = {
...button.props,
isLocked: true,
};
// Re-evaluate the button
toolbarService.refreshToolbarState({ viewportId: targetViewportId, itemId });
}
},
unlockItem: (itemId: string, viewportId?: string) => {
const targetViewportId = viewportId || viewportGridService.getActiveViewportId();
const button = toolbarService.getButton(itemId);
if (button) {
// Set isLocked flag in button metadata
button.props = {
...button.props,
isLocked: false,
};
// Re-evaluate the button
toolbarService.refreshToolbarState({ viewportId: targetViewportId, itemId });
}
},
toggleLock: (itemId: string, viewportId?: string) => {
const targetViewportId = viewportId || viewportGridService.getActiveViewportId();
const button = toolbarService.getButton(itemId);
if (button) {
// Toggle isLocked flag in button metadata
button.props = {
...button.props,
isLocked: !button.props.isLocked,
};
// Re-evaluate the button
toolbarService.refreshToolbarState({ viewportId: targetViewportId, itemId });
}
},
isItemLocked: (itemId: string, viewportId?: string): boolean => {
const button = toolbarService.getButton(itemId);
return button?.props?.isLocked === true;
},
// Visibility actions - controlled by evaluator functions in toolbar items
showItem: (itemId: string, viewportId?: string) => {
const targetViewportId = viewportId || viewportGridService.getActiveViewportId();
const button = toolbarService.getButton(itemId);
if (button) {
// Set isVisible flag in button metadata
button.props = {
...button.props,
isVisible: true,
};
// Re-evaluate the button
toolbarService.refreshToolbarState({ viewportId: targetViewportId, itemId });
}
},
hideItem: (itemId: string, viewportId?: string) => {
const targetViewportId = viewportId || viewportGridService.getActiveViewportId();
const button = toolbarService.getButton(itemId);
if (button) {
// Set isVisible flag in button metadata
button.props = {
...button.props,
isVisible: false,
};
// Re-evaluate the button
toolbarService.refreshToolbarState({ viewportId: targetViewportId, itemId });
}
},
toggleVisibility: (itemId: string, viewportId?: string) => {
const targetViewportId = viewportId || viewportGridService.getActiveViewportId();
const button = toolbarService.getButton(itemId);
if (button) {
// Toggle isVisible flag in button metadata
button.props = {
...button.props,
isVisible: button.props.isVisible === false ? true : false,
};
// Re-evaluate the button
toolbarService.refreshToolbarState({ viewportId: targetViewportId, itemId });
}
},
isItemVisible: (itemId: string, viewportId?: string): boolean => {
const button = toolbarService.getButton(itemId);
// If isVisible is explicitly false, return false; otherwise return true
return button?.props?.isVisible !== false;
},
// Open/Close actions - managed in local state for performance
openItem: (itemId: string, viewportId?: string) => {
setOpenItemIds(prev => {
// Close all other items
const updated = {};
// Then set the current item to open
updated[itemId] = true;
return updated;
});
},
closeItem: (itemId: string, viewportId?: string) => {
setOpenItemIds(prev => ({
...prev,
[itemId]: false,
}));
},
closeAllItems: (viewportId?: string) => {
setOpenItemIds({});
},
isItemOpen: (itemId: string, viewportId?: string): boolean => {
return openItemIds[itemId] === true;
},
};
}, [viewportGridService, toolbarService, openItemIds]);
if (!toolbarButtons?.length) {
return {
toolbarButtons: [],
onInteraction,
...actions,
};
}
// filter out buttons that are disabled and have hideWhenDisabled set to true
const filteredToolbarButtons = toolbarButtons.filter(button => {
const props = button.componentProps;
return props.visible !== false;
});
return {
toolbarButtons: filteredToolbarButtons,
onInteraction,
...actions,
};
}
@@ -0,0 +1,67 @@
import { useState, useEffect } from 'react';
import { useViewportRef } from './useViewportRef';
import { useViewportSize } from './useViewportSize';
interface MousePosition {
x: number;
y: number;
isInViewport: boolean;
relativeY: number; // Position as percentage from top (0-1)
isInBottomPercentage: (percentage: number) => boolean;
}
function useViewportMousePosition(viewportId: string): MousePosition {
const viewportRef = useViewportRef(viewportId);
const { height, clientRect } = useViewportSize(viewportId);
const [mousePosition, setMousePosition] = useState<MousePosition>({
x: 0,
y: 0,
isInViewport: false,
relativeY: 0,
isInBottomPercentage: (percentage: number) => false,
});
useEffect(() => {
if (!viewportRef.current) {
return;
}
const handleMouseMove = (event: MouseEvent) => {
if (!clientRect) {
return;
}
// Get mouse position relative to viewport
const x = event.clientX - clientRect.left;
const y = event.clientY - clientRect.top;
const isInViewport = x >= 0 && x <= clientRect.width && y >= 0 && y <= clientRect.height;
const relativeY = Math.max(0, Math.min(1, y / height));
const isInBottomPercentage = (percentage: number) => {
return relativeY >= 1 - percentage / 100;
};
setMousePosition({
x,
y,
isInViewport,
relativeY,
isInBottomPercentage,
});
};
document.addEventListener('mousemove', handleMouseMove);
return () => {
document.removeEventListener('mousemove', handleMouseMove);
};
}, [viewportRef, height, clientRect]);
return mousePosition;
}
export default useViewportMousePosition;
export { useViewportMousePosition };
+58
View File
@@ -0,0 +1,58 @@
import React, { createContext, useContext, useRef } from 'react';
type ViewportRefsContextType = {
registerViewport: (viewportId: string, element: HTMLElement) => void;
unregisterViewport: (viewportId: string) => void;
getViewportElement: (viewportId: string) => HTMLElement | null;
viewportRefs: Map<string, HTMLElement>;
};
// comment
const ViewportRefsContext = createContext<ViewportRefsContextType | undefined>(undefined);
export const ViewportRefsProvider = ({ children }: { children: React.ReactNode }) => {
const viewportRefsRef = useRef<Map<string, HTMLElement>>(new Map());
const registerViewport = (viewportId: string, element: HTMLElement) => {
viewportRefsRef.current.set(viewportId, element);
};
const unregisterViewport = (viewportId: string) => {
viewportRefsRef.current.delete(viewportId);
};
const getViewportElement = (viewportId: string): HTMLElement | null => {
return viewportRefsRef.current.get(viewportId) || null;
};
const contextValue: ViewportRefsContextType = {
registerViewport,
unregisterViewport,
getViewportElement,
viewportRefs: viewportRefsRef.current,
};
return React.createElement(ViewportRefsContext.Provider, { value: contextValue }, children);
};
export const useViewportRefs = () => {
const context = useContext(ViewportRefsContext);
if (context === undefined) {
throw new Error('useViewportRefs must be used within a ViewportRefsProvider');
}
return context;
};
export const useViewportRef = (viewportId: string) => {
const { registerViewport, unregisterViewport, getViewportElement } = useViewportRefs();
const ref = {
current: getViewportElement(viewportId),
register: (element: HTMLElement) => registerViewport(viewportId, element),
unregister: () => unregisterViewport(viewportId),
};
return ref;
};
@@ -0,0 +1,97 @@
import { useEffect, useState, useCallback, useMemo } from 'react';
import { useViewportRef } from './';
interface ViewportSize {
width: number;
height: number;
offsetLeft: number;
offsetTop: number;
clientRect: DOMRect | null;
isVisible: boolean;
}
/**
* Hook that provides viewport size dimensions and monitors for changes
* @param viewportId - The ID of the viewport to monitor
* @returns ViewportSize object containing width, height, and visibility info
*/
function useViewportSize(viewportId: string): ViewportSize {
const viewportElementRef = useViewportRef(viewportId);
const [size, setSize] = useState<ViewportSize>({
width: 0,
height: 0,
offsetLeft: 0,
offsetTop: 0,
clientRect: null,
isVisible: false,
});
// Update viewport dimensions
const updateViewportSize = useCallback(() => {
if (!viewportElementRef?.current) {
return;
}
const element = viewportElementRef.current;
const clientRect = element.getBoundingClientRect();
const newWidth = clientRect.width;
const newHeight = clientRect.height;
const newOffsetLeft = element.offsetLeft;
const newOffsetTop = element.offsetTop;
const newIsVisible = newWidth > 0 && newHeight > 0;
setSize(prevSize => {
if (
prevSize.width === newWidth &&
prevSize.height === newHeight &&
prevSize.offsetLeft === newOffsetLeft &&
prevSize.offsetTop === newOffsetTop &&
prevSize.isVisible === newIsVisible
) {
return prevSize;
}
return {
width: newWidth,
height: newHeight,
offsetLeft: newOffsetLeft,
offsetTop: newOffsetTop,
clientRect,
isVisible: newIsVisible,
};
});
}, [viewportElementRef]);
useEffect(() => {
if (!viewportId || !viewportElementRef?.current) {
return;
}
updateViewportSize();
const resizeObserver = new ResizeObserver(() => {
updateViewportSize();
});
resizeObserver.observe(viewportElementRef.current);
window.addEventListener('resize', updateViewportSize);
return () => {
window.removeEventListener('resize', updateViewportSize);
if (viewportElementRef.current) {
resizeObserver.unobserve(viewportElementRef.current);
}
resizeObserver.disconnect();
};
}, [viewportId, viewportElementRef, updateViewportSize]);
const memoizedSize = useMemo(() => size, [size]);
return memoizedSize;
}
export default useViewportSize;
export { useViewportSize };