feat(ShareDataSet): initial implementation

Author: floryst

src/core-ts/GeometryRepresentation.tsx

@@ -254,10 +254,8 @@ export default forwardRef(function GeometryRepresentation(
     }
   });
 
-  const representation = useMemo<IRepresentation<vtkActor, vtkMapper>>(
+  const representation = useMemo<IRepresentation>(
     () => ({
-      getActor,
-      getMapper,
       dataChanged: () => {
         view.requestRender();
       },
@@ -266,7 +264,7 @@ export default forwardRef(function GeometryRepresentation(
         representation.dataChanged();
       },
     }),
-    [view, getActor, getMapper]
+    [view]
   );
 
   useImperativeHandle(fwdRef, () => representation);

src/core-ts/ShareDataSet.tsx

@@ -0,0 +1,218 @@
+/**
+ * <ShareDataSetRoot>
+ *   <RegisterDataSet id="something">
+ *   </RegisterDataSet>
+ *   <Representation>
+ *     <UseDataSet id="something">
+ *   </Rep>
+ * </ShareDataSetRoot>
+ */
+
+import { vtkObject } from '@kitware/vtk.js/interfaces';
+import {
+  PropsWithChildren,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+} from 'react';
+import {
+  DataCallback,
+  IDownstream,
+  IRepresentation,
+  IShareDataset,
+} from '../types';
+import useUnmount from '../utils-ts/useUnmount';
+import {
+  DownstreamContext,
+  RepresentationContext,
+  ShareDataSetContext,
+  useDownstream,
+  useRepresentation,
+  useShareDataSet,
+} from './contexts';
+
+const DATA_AVAILABLE_EVENT = 'dataAvailable';
+const DATA_CHANGED_EVENT = 'dataChanged';
+
+interface DataEventDetails {
+  name: string;
+}
+
+export function ShareDataSetRoot(props: PropsWithChildren) {
+  const datasets = useRef<Map<string, unknown>>(new Map());
+  const eventTarget = useRef(new EventTarget());
+  // Used to notify UseDataSet components that register
+  // after the DATA_AVAILABLE_EVENT occurs.
+  const dataAvailable = useRef(new Set<string>());
+
+  useUnmount(() => {
+    datasets.current.clear();
+    dataAvailable.current.clear();
+  });
+
+  type RegistrarOptions = {
+    immediate: boolean | ((name: string) => boolean);
+  };
+
+  const createDataEventRegistrar = useCallback(
+    (event: string, options?: RegistrarOptions) => {
+      return function addListener(name: string, callback: DataCallback) {
+        const invoke = () => {
+          callback(datasets.current.get(name) ?? null);
+        };
+
+        const handler = (ev: Event) => {
+          if (!(ev instanceof CustomEvent<DataEventDetails>)) return;
+          if (name === ev.detail?.name) {
+            invoke();
+          }
+        };
+
+        let immediate = false;
+        if (typeof options?.immediate === 'boolean') {
+          immediate = options.immediate;
+        } else if (options?.immediate instanceof Function) {
+          immediate = options?.immediate(name);
+        }
+
+        if (immediate) {
+          invoke();
+        }
+
+        eventTarget.current.addEventListener(event, handler);
+        return () => {
+          eventTarget.current.removeEventListener(event, handler);
+        };
+      };
+    },
+    []
+  );
+
+  const share = useMemo<IShareDataset>(
+    () => ({
+      register(name: string, dataset: unknown) {
+        datasets.current.set(name, dataset);
+      },
+      unregister(name: string) {
+        datasets.current.delete(name);
+        dataAvailable.current.delete(name);
+      },
+
+      dispatchDataAvailable(name: string) {
+        dataAvailable.current.add(name);
+        eventTarget.current.dispatchEvent(
+          new CustomEvent<DataEventDetails>(DATA_AVAILABLE_EVENT, {
+            detail: { name },
+          })
+        );
+      },
+      dispatchDataChanged(name: string) {
+        eventTarget.current.dispatchEvent(
+          new CustomEvent<DataEventDetails>(DATA_CHANGED_EVENT, {
+            detail: { name },
+          })
+        );
+      },
+
+      onDataChanged: createDataEventRegistrar(DATA_CHANGED_EVENT),
+      onDataAvailable: createDataEventRegistrar(DATA_AVAILABLE_EVENT, {
+        immediate(name) {
+          return dataAvailable.current.has(name);
+        },
+      }),
+    }),
+    [createDataEventRegistrar]
+  );
+
+  return (
+    <ShareDataSetContext.Provider value={share}>
+      {props.children}
+    </ShareDataSetContext.Provider>
+  );
+}
+
+interface RegisterDataSetProps extends PropsWithChildren {
+  id: string;
+}
+
+export function RegisterDataSet(props: RegisterDataSetProps) {
+  const share = useShareDataSet();
+  const { id } = props;
+
+  // --- handle registrations --- //
+
+  useEffect(
+    () => () => {
+      share.unregister(id);
+    },
+    [id, share]
+  );
+
+  useUnmount(() => {
+    share.unregister(id);
+  });
+
+  // --- //
+
+  const api = useMemo<IDownstream>(
+    () => ({
+      setInputData(obj) {
+        share.register(id, obj);
+      },
+      setInputConnection(conn) {
+        api.setInputData(conn());
+      },
+    }),
+    [id, share]
+  );
+
+  const getAPI = useCallback(() => api, [api]);
+  const mockRepresentation = useMemo<IRepresentation>(
+    () => ({
+      dataChanged() {
+        share.dispatchDataChanged(id);
+      },
+      dataAvailable() {
+        share.dispatchDataAvailable(id);
+      },
+    }),
+    [id, share]
+  );
+
+  return (
+    <RepresentationContext.Provider value={mockRepresentation}>
+      <DownstreamContext.Provider value={getAPI}>
+        {props.children}
+      </DownstreamContext.Provider>
+    </RepresentationContext.Provider>
+  );
+}
+
+interface UseDataSetProps extends PropsWithChildren {
+  id: string;
+  port?: number;
+}
+
+export function UseDataSet(props: UseDataSetProps) {
+  const { id, port = 0 } = props;
+  const share = useShareDataSet();
+  // TODO if useDataSet is input to an algorithm, should representation be null?
+  const representation = useRepresentation();
+  const getDownstream = useDownstream();
+
+  useEffect(() => {
+    return share.onDataAvailable(id, (ds) => {
+      getDownstream().setInputData(ds as vtkObject, port);
+      representation.dataAvailable();
+    });
+  }, [id, port, representation, getDownstream, share]);
+
+  useEffect(() => {
+    return share.onDataChanged(id, () => {
+      representation.dataChanged();
+    });
+  }, [id, representation, share]);
+
+  return null;
+}

src/core-ts/contexts.ts

@@ -3,7 +3,13 @@ import vtkDataSetAttributes from '@kitware/vtk.js/Common/DataModel/DataSetAttrib
 import vtkFieldData from '@kitware/vtk.js/Common/DataModel/DataSetAttributes/FieldData';
 import { Nullable } from '@kitware/vtk.js/types';
 import { createContext, useContext } from 'react';
-import { IDataset, IDownstream, IRepresentation, IView } from '../types';
+import {
+  IDataset,
+  IDownstream,
+  IRepresentation,
+  IShareDataset,
+  IView,
+} from '../types';
 
 export const FieldDataContext =
   createContext<Nullable<() => vtkDataSetAttributes | vtkFieldData>>(null);
@@ -46,3 +52,11 @@ export function useDownstream() {
   if (!ds) throw new Error('No downstream context!');
   return ds;
 }
+
+export const ShareDataSetContext = createContext<Nullable<IShareDataset>>(null);
+
+export function useShareDataSet() {
+  const share = useContext(ShareDataSetContext);
+  if (!share) throw new Error('No ShareDataSet context!');
+  return share;
+}

src/index.ts

@@ -8,5 +8,10 @@ export { default as DataArray } from './core-ts/DataArray';
 export { default as GeometryRepresentation } from './core-ts/GeometryRepresentation';
 export { default as PointData } from './core-ts/PointData';
 export { default as PolyData } from './core-ts/PolyData';
+export {
+  RegisterDataSet,
+  ShareDataSetRoot,
+  UseDataSet,
+} from './core-ts/ShareDataSet';
 export { default as SliceRepresentation } from './core-ts/SliceRepresentation';
 export { default as View } from './core-ts/View';

src/types/index.ts

@@ -1,7 +1,5 @@
 import { vtkObject } from '@kitware/vtk.js/interfaces';
-import vtkAbstractMapper from '@kitware/vtk.js/Rendering/Core/AbstractMapper';
 import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
-import vtkProp from '@kitware/vtk.js/Rendering/Core/Prop';
 import vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 import vtkRenderWindow from '@kitware/vtk.js/Rendering/Core/RenderWindow';
 import vtkRenderWindowInteractor from '@kitware/vtk.js/Rendering/Core/RenderWindowInteractor';
@@ -46,14 +44,9 @@ export interface IView {
   resetCamera(boundsToUse?: Bounds): void;
 }
 
-export interface IRepresentation<
-  A extends vtkProp = vtkProp,
-  M extends vtkAbstractMapper = vtkAbstractMapper
-> {
+export interface IRepresentation {
   dataAvailable(): void;
   dataChanged(): void;
-  getActor(): A;
-  getMapper(): M;
 }
 
 // There is no sufficient type that overlaps classes like
@@ -67,3 +60,15 @@ export interface IDataset<T> {
   getDataSet(): T;
   modified(): void;
 }
+
+export type StopEventListener = () => void;
+export type DataCallback = <T>(ds: T | null) => void;
+
+export interface IShareDataset {
+  register(name: string, dataset: unknown): void;
+  unregister(name: string): void;
+  dispatchDataAvailable(name: string): void;
+  dispatchDataChanged(name: string): void;
+  onDataAvailable(name: string, callback: DataCallback): StopEventListener;
+  onDataChanged(name: string, callback: DataCallback): StopEventListener;
+}