higlass 2.2.3 → 2.3.0

package/app/scripts/utils/react-dom-compat.js

@@ -0,0 +1,100 @@
+// @ts-nocheck
+import ReactDOM from 'react-dom';
+
+/**
+ * Compatibility layer for ReactDOM.render / createRoot APIs.
+ *
+ * - React 18+: uses `createRoot` from `react-dom/client`
+ * - React 16/17: falls back to legacy `ReactDOM.render`
+ *
+ * This allows HiGlass to support React 16–19 as peer dependencies.
+ */
+
+/** @type {WeakMap<HTMLElement, { unmount: () => void }>} */
+const containerRoots = new WeakMap();
+
+/** @type {((container: HTMLElement) => import('react-dom/client').Root) | null} */
+let _createRoot = null;
+
+/** @type {boolean} */
+let _resolved = false;
+
+// Check synchronously first (UMD builds expose createRoot on ReactDOM)
+if (typeof ReactDOM.createRoot === 'function') {
+  _createRoot = ReactDOM.createRoot;
+  _resolved = true;
+}
+
+// Attempt dynamic import for ESM builds (react-dom/client is a separate entry point).
+// The module specifier is built via concatenation so that bundlers (Vite, Rollup)
+// do not try to statically resolve it — it may not exist in React 16/17.
+/** @type {string} */
+const _clientModuleId = 'react-dom' + '/client';
+/** @type {Promise<void>} */
+const _clientPromise = _resolved
+  ? Promise.resolve()
+  : import(/* @vite-ignore */ /* webpackIgnore: true */ _clientModuleId)
+      .then((mod) => {
+        if (typeof mod.createRoot === 'function') {
+          _createRoot = mod.createRoot;
+        }
+      })
+      .catch(() => {
+        // React 16/17: react-dom/client doesn't exist, use legacy API
+      })
+      .finally(() => {
+        _resolved = true;
+      });
+
+/**
+ * Wait for the createRoot detection to complete.
+ * Call this before the first `renderToContainer` in async contexts.
+ * @returns {Promise<void>}
+ */
+export async function ensureReady() {
+  if (!_resolved) await _clientPromise;
+}
+
+/**
+ * Render a React element into a container, using `createRoot` if available.
+ *
+ * @param {HTMLElement} container
+ * @param {React.ReactNode} element
+ * @returns {{ unmount: () => void }}
+ */
+export function renderToContainer(container, element) {
+  if (_createRoot) {
+    const root = _createRoot(container);
+    root.render(element);
+    const handle = { unmount: () => root.unmount() };
+    containerRoots.set(container, handle);
+    return handle;
+  }
+  // Legacy fallback (React 16/17)
+  ReactDOM.render(element, container);
+  const handle = {
+    unmount: () => ReactDOM.unmountComponentAtNode(container),
+  };
+  containerRoots.set(container, handle);
+  return handle;
+}
+
+/**
+ * Unmount a React tree from a container.
+ *
+ * Looks up the handle from `renderToContainer`, or falls back to the legacy
+ * `ReactDOM.unmountComponentAtNode` (for trees mounted outside the compat layer,
+ * e.g. by Enzyme in tests).
+ *
+ * @param {HTMLElement} container
+ * @returns {void}
+ */
+export function unmountFromContainer(container) {
+  const handle = containerRoots.get(container);
+  if (handle) {
+    handle.unmount();
+    containerRoots.delete(container);
+  } else if (typeof ReactDOM.unmountComponentAtNode === 'function') {
+    ReactDOM.unmountComponentAtNode(container);
+  }
+}

package/app/styles/HiGlass.scss

@@ -12,5 +12,6 @@
 
   .react-resizable-handle {
     z-index: 1;
+    opacity: 1;
   }
 }

package/dist/app/scripts/Autocomplete.d.ts

@@ -8,6 +8,8 @@ declare class Autocomplete extends React.Component<any, any, any> {
         menuWidth: number;
         isOpen: boolean;
     };
+    itemRefs: {};
+    menuRef: any;
     keyDownHandlers: {
         ArrowDown(event: any): void;
         ArrowUp(event: any): void;
@@ -35,7 +37,7 @@ declare class Autocomplete extends React.Component<any, any, any> {
     selectItemFromMouse(item: any): void;
     setIgnoreBlur(ignore: any): void;
     renderMenu(): React.FunctionComponentElement<{
-        ref: string;
+        ref: (el: any) => void;
     }> | null;
     handleInputBlur(): void;
     handleInputFocus(): void;

package/dist/app/scripts/ContextMenuContainer.d.ts

@@ -19,7 +19,6 @@ declare class ContextMenuContainer extends React.Component<any, any, any> {
     handleMouseLeave(): void;
     handleOtherMouseEnter(): void;
     updateOrientation(): void;
-    divDom: Element | Text | null | undefined;
     render(): React.JSX.Element;
     div: HTMLDivElement | null | undefined;
 }

package/dist/app/scripts/ContextMenuItem.d.ts

@@ -2,32 +2,26 @@ export default ContextMenuItem;
 export type ContextMenuItemProps = {
     className?: string | undefined;
     onClick: (evt: React.MouseEvent) => void;
-    onMouseEnter: (evt: React.MouseEvent) => void;
-    onMouseLeave: (evt: React.MouseEvent) => void;
+    onMouseEnter?: ((evt: React.MouseEvent) => void) | undefined;
+    onMouseLeave?: ((evt: React.MouseEvent) => void) | undefined;
 };
 /**
  * @typedef ContextMenuItemProps
  * @prop {string} [className]
  * @prop {(evt: React.MouseEvent) => void} onClick
- * @prop {(evt: React.MouseEvent) => void} onMouseEnter
- * @prop {(evt: React.MouseEvent) => void} onMouseLeave
+ * @prop {(evt: React.MouseEvent) => void} [onMouseEnter]
+ * @prop {(evt: React.MouseEvent) => void} [onMouseLeave]
  */
 /**
  * @param {React.PropsWithChildren<ContextMenuItemProps>} props
  */
-declare function ContextMenuItem(props: React.PropsWithChildren<ContextMenuItemProps>): React.JSX.Element;
+declare function ContextMenuItem({ onMouseEnter, onMouseLeave, onClick, className, children, }: React.PropsWithChildren<ContextMenuItemProps>): React.JSX.Element;
 declare namespace ContextMenuItem {
-    namespace defaultProps {
-        function onMouseEnter(): undefined;
-        function onMouseLeave(): undefined;
-    }
     namespace propTypes {
-        export let children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
-        export let onClick: PropTypes.Validator<(...args: any[]) => any>;
-        let onMouseEnter_1: PropTypes.Requireable<(...args: any[]) => any>;
-        export { onMouseEnter_1 as onMouseEnter };
-        let onMouseLeave_1: PropTypes.Requireable<(...args: any[]) => any>;
-        export { onMouseLeave_1 as onMouseLeave };
+        let children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        let onClick: PropTypes.Validator<(...args: any[]) => any>;
+        let onMouseEnter: PropTypes.Requireable<(...args: any[]) => any>;
+        let onMouseLeave: PropTypes.Requireable<(...args: any[]) => any>;
     }
 }
 import React from 'react';

package/dist/app/scripts/HiGlassComponent.d.ts

@@ -58,7 +58,6 @@ declare class HiGlassComponent extends React.Component<any, any, any> {
     pluginTracks: {};
     pluginDataFetchers: any;
     state: {
-        currentBreakpoint: string;
         width: number;
         height: number;
         rowHeight: number;
@@ -223,7 +222,6 @@ declare class HiGlassComponent extends React.Component<any, any, any> {
     animateOnGlobalEvent({ sourceUid }?: {}): void;
     measureSize(): void;
     updateAfterResize(): void;
-    onBreakpointChange(breakpoint: any): void;
     handleOverlayMouseEnter(uid: any): void;
     handleOverlayMouseLeave(): void;
     /**
@@ -731,7 +729,6 @@ declare class HiGlassComponent extends React.Component<any, any, any> {
     render(): React.JSX.Element;
     tiledAreasDivs: {} | undefined;
     tiledAreas: React.JSX.Element | React.JSX.Element[] | undefined;
-    gridLayout: any;
     canvasElement: HTMLCanvasElement | null | undefined;
     scrollContainer: HTMLDivElement | null | undefined;
     divDrawingSurface: HTMLDivElement | null | undefined;

package/dist/app/scripts/HorizontalItem.d.ts

@@ -1,3 +1,3 @@
 export default HorizontalItem;
-declare const HorizontalItem: React.ComponentClass<any, any>;
+declare function HorizontalItem(props: any): React.JSX.Element;
 import React from 'react';

package/dist/app/scripts/ListWrapper.d.ts

@@ -8,21 +8,16 @@ declare class ListWrapper extends React.Component<any, any, any> {
         isSorting: boolean;
     };
     UNSAFE_componentWillReceiveProps(nextProps: any): void;
-    onSortStart({ node, index, collection }: {
-        node: any;
+    onSortStart({ index }: {
         index: any;
-        collection: any;
-    }, e: any): void;
+    }): void;
     sortingIndex: any;
-    sortStartTop: any;
-    sortStartLeft: any;
     onSortMove(): void;
     onSortEnd({ oldIndex, newIndex }: {
         oldIndex: any;
         newIndex: any;
     }): void;
     render(): React.JSX.Element;
-    ref: any;
 }
 declare namespace ListWrapper {
     namespace propTypes {

package/dist/app/scripts/PopupMenu.d.ts

@@ -1,18 +1,16 @@
 export default PopupMenu;
 declare class PopupMenu extends React.Component<any, any, any> {
     constructor(props: any);
+    popup: HTMLDivElement | null;
     clickHandlerBound: (event: any) => void;
     contextMenuHandlerBound: (event: any) => void;
     resizeHandlerBound: () => void;
     componentDidMount(): void;
-    popup: HTMLDivElement | undefined;
-    componentDidUpdate(): void;
     componentWillUnmount(): void;
-    _renderLayer(): void;
     clickHandler(event: any): void;
     contextMenuHandler(event: any): void;
     resizeHandler(): void;
-    render(): React.JSX.Element;
+    render(): React.ReactPortal | null;
 }
 declare namespace PopupMenu {
     namespace defaultProps {

package/dist/app/scripts/SortableList.d.ts

@@ -1,5 +1,5 @@
 export default SortableList;
-declare const SortableList: React.ComponentClass<{
+declare function SortableList({ className, items, itemClass, itemControlAlignLeft, sortingIndex, useDragHandle, sortableHandlers, height, width, onCloseTrack, onCollapseTrack, onExpandTrack, onCloseTrackMenuOpened, onConfigTrackMenuOpened, onAddSeries, handleConfigTrack, editable, itemReactClass, handleResizeTrack, resizeHandles, onSortEnd, onSortStart, onSortMove, axis, }: {
     className: any;
     items: any;
     itemClass: any;
@@ -20,5 +20,9 @@ declare const SortableList: React.ComponentClass<{
     itemReactClass: any;
     handleResizeTrack: any;
     resizeHandles: any;
-} & import("react-sortable-hoc").SortableContainerProps, any>;
+    onSortEnd: any;
+    onSortStart: any;
+    onSortMove: any;
+    axis: any;
+}): React.JSX.Element;
 import React from 'react';

package/dist/app/scripts/VerticalItem.d.ts

@@ -1,3 +1,3 @@
 export default VerticalItem;
-declare const VerticalItem: React.ComponentClass<any, any>;
+declare function VerticalItem(props: any): React.JSX.Element;
 import React from 'react';

package/dist/app/scripts/utils/react-dom-compat.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Wait for the createRoot detection to complete.
+ * Call this before the first `renderToContainer` in async contexts.
+ * @returns {Promise<void>}
+ */
+export function ensureReady(): Promise<void>;
+/**
+ * Render a React element into a container, using `createRoot` if available.
+ *
+ * @param {HTMLElement} container
+ * @param {React.ReactNode} element
+ * @returns {{ unmount: () => void }}
+ */
+export function renderToContainer(container: HTMLElement, element: React.ReactNode): {
+    unmount: () => void;
+};
+/**
+ * Unmount a React tree from a container.
+ *
+ * Looks up the handle from `renderToContainer`, or falls back to the legacy
+ * `ReactDOM.unmountComponentAtNode` (for trees mounted outside the compat layer,
+ * e.g. by Enzyme in tests).
+ *
+ * @param {HTMLElement} container
+ * @returns {void}
+ */
+export function unmountFromContainer(container: HTMLElement): void;