@cornerstonejs/tools 3.0.2 → 3.0.3

package/dist/esm/store/addTool.d.ts

@@ -0,0 +1,5 @@
+export declare function addTool(ToolClass: any): void;
+export declare function hasTool(ToolClass: any): boolean;
+export declare function hasToolByName(toolName: string): boolean;
+export declare function removeTool(ToolClass: any): void;
+export default addTool;

package/dist/esm/store/addTool.js

@@ -0,0 +1,31 @@
+import { state } from './state';
+export function addTool(ToolClass) {
+    const toolName = ToolClass.toolName;
+    const toolAlreadyAdded = state.tools[toolName] !== undefined;
+    if (!toolName) {
+        throw new Error(`No Tool Found for the ToolClass ${ToolClass.name}`);
+    }
+    state.tools[toolName] = {
+        toolClass: ToolClass,
+    };
+}
+export function hasTool(ToolClass) {
+    const toolName = ToolClass.toolName;
+    return !!(toolName && state.tools[toolName]);
+}
+export function hasToolByName(toolName) {
+    return !!(toolName && state.tools[toolName]);
+}
+export function removeTool(ToolClass) {
+    const toolName = ToolClass.toolName;
+    if (!toolName) {
+        throw new Error(`No tool found for: ${ToolClass.name}`);
+    }
+    if (!state.tools[toolName] !== undefined) {
+        delete state.tools[toolName];
+    }
+    else {
+        throw new Error(`${toolName} cannot be removed because it has not been added`);
+    }
+}
+export default addTool;

package/dist/esm/store/cancelActiveManipulations.d.ts

@@ -0,0 +1 @@
+export default function cancelActiveManipulations(element: HTMLDivElement): string | undefined;

package/dist/esm/store/cancelActiveManipulations.js

@@ -0,0 +1,16 @@
+import { ToolModes } from '../enums';
+import getToolsWithModesForElement from '../utilities/getToolsWithModesForElement';
+import filterToolsWithAnnotationsForElement from './filterToolsWithAnnotationsForElement';
+export default function cancelActiveManipulations(element) {
+    const tools = getToolsWithModesForElement(element, [
+        ToolModes.Active,
+        ToolModes.Passive,
+    ]);
+    const toolsWithData = filterToolsWithAnnotationsForElement(element, tools);
+    for (const { tool } of toolsWithData) {
+        const annotationUID = tool.cancel(element);
+        if (annotationUID) {
+            return annotationUID;
+        }
+    }
+}

package/dist/esm/store/filterMoveableAnnotationTools.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ToolAnnotationPair, ToolAnnotationsPair } from '../types/InternalToolTypes';
+export default function filterMoveableAnnotationTools(element: HTMLDivElement, ToolAndAnnotations: ToolAnnotationsPair[], canvasCoords: Types.Point2, interactionType?: string): ToolAnnotationPair[];

package/dist/esm/store/filterMoveableAnnotationTools.js

@@ -0,0 +1,20 @@
+export default function filterMoveableAnnotationTools(element, ToolAndAnnotations, canvasCoords, interactionType = 'mouse') {
+    const proximity = interactionType === 'touch' ? 36 : 6;
+    const moveableAnnotationTools = [];
+    ToolAndAnnotations.forEach(({ tool, annotations }) => {
+        for (const annotation of annotations) {
+            if (annotation.isLocked || !annotation.isVisible) {
+                continue;
+            }
+            const near = tool.isPointNearTool(element, annotation, canvasCoords, proximity, interactionType);
+            if (near) {
+                moveableAnnotationTools.push({
+                    tool,
+                    annotation,
+                });
+                break;
+            }
+        }
+    });
+    return moveableAnnotationTools;
+}

package/dist/esm/store/filterToolsWithAnnotationsForElement.d.ts

@@ -0,0 +1,3 @@
+import type { ToolAnnotationsPair } from '../types/InternalToolTypes';
+import type AnnotationTool from '../tools/base/AnnotationTool';
+export default function filterToolsWithAnnotationsForElement(element: HTMLDivElement, tools: AnnotationTool[]): ToolAnnotationsPair[];

package/dist/esm/store/filterToolsWithAnnotationsForElement.js

@@ -0,0 +1,22 @@
+import { getAnnotations } from '../stateManagement/annotation/annotationState';
+export default function filterToolsWithAnnotationsForElement(element, tools) {
+    const result = [];
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        if (!tool) {
+            console.warn('undefined tool in filterToolsWithAnnotationsForElement');
+            continue;
+        }
+        let annotations = getAnnotations(tool.constructor.toolName, element);
+        if (!annotations?.length) {
+            continue;
+        }
+        if (typeof tool.filterInteractableAnnotationsForElement === 'function') {
+            annotations = tool.filterInteractableAnnotationsForElement(element, annotations);
+        }
+        if (annotations?.length > 0) {
+            result.push({ tool, annotations });
+        }
+    }
+    return result;
+}

package/dist/esm/store/filterToolsWithMoveableHandles.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { ToolAnnotationsPair, ToolsWithMoveableHandles } from '../types/InternalToolTypes';
+export default function filterToolsWithMoveableHandles(element: HTMLDivElement, ToolAndAnnotations: ToolAnnotationsPair[], canvasCoords: Types.Point2, interactionType?: string): ToolsWithMoveableHandles[];

package/dist/esm/store/filterToolsWithMoveableHandles.js

@@ -0,0 +1,21 @@
+export default function filterToolsWithMoveableHandles(element, ToolAndAnnotations, canvasCoords, interactionType = 'mouse') {
+    const proximity = interactionType === 'touch' ? 36 : 6;
+    const toolsWithMoveableHandles = [];
+    ToolAndAnnotations.forEach(({ tool, annotations }) => {
+        for (const annotation of annotations) {
+            if (annotation.isLocked || !annotation.isVisible) {
+                continue;
+            }
+            const handle = tool.getHandleNearImagePoint(element, annotation, canvasCoords, proximity);
+            if (handle) {
+                toolsWithMoveableHandles.push({
+                    tool,
+                    annotation,
+                    handle,
+                });
+                break;
+            }
+        }
+    });
+    return toolsWithMoveableHandles;
+}

package/dist/esm/store/index.d.ts

@@ -0,0 +1,10 @@
+import { addTool, hasTool, removeTool } from './addTool';
+import addEnabledElement from './addEnabledElement';
+import removeEnabledElement from './removeEnabledElement';
+import cancelActiveManipulations from './cancelActiveManipulations';
+import state from './state';
+import Synchronizer from './SynchronizerManager/Synchronizer';
+import svgNodeCache from './svgNodeCache';
+import * as ToolGroupManager from './ToolGroupManager';
+import * as SynchronizerManager from './SynchronizerManager';
+export { addTool, hasTool, removeTool, addEnabledElement, removeEnabledElement, cancelActiveManipulations, svgNodeCache, ToolGroupManager, SynchronizerManager, Synchronizer, state, };

package/dist/esm/store/index.js

@@ -0,0 +1,10 @@
+import { addTool, hasTool, removeTool } from './addTool';
+import addEnabledElement from './addEnabledElement';
+import removeEnabledElement from './removeEnabledElement';
+import cancelActiveManipulations from './cancelActiveManipulations';
+import state from './state';
+import Synchronizer from './SynchronizerManager/Synchronizer';
+import svgNodeCache from './svgNodeCache';
+import * as ToolGroupManager from './ToolGroupManager';
+import * as SynchronizerManager from './SynchronizerManager';
+export { addTool, hasTool, removeTool, addEnabledElement, removeEnabledElement, cancelActiveManipulations, svgNodeCache, ToolGroupManager, SynchronizerManager, Synchronizer, state, };

package/dist/esm/store/removeEnabledElement.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function removeEnabledElement(elementDisabledEvt: Types.EventTypes.ElementDisabledEvent): void;
+export default removeEnabledElement;

package/dist/esm/store/removeEnabledElement.js

@@ -0,0 +1,85 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import { mouseEventListeners, wheelEventListener, touchEventListeners, keyEventListener, imageChangeEventListener, } from '../eventListeners';
+import { imageRenderedEventDispatcher, cameraModifiedEventDispatcher, mouseToolEventDispatcher, keyboardToolEventDispatcher, imageSpacingCalibratedEventDispatcher, touchToolEventDispatcher, cameraResetEventDispatcher, } from '../eventDispatchers';
+import filterToolsWithAnnotationsForElement from './filterToolsWithAnnotationsForElement';
+import { state } from './state';
+import getToolsWithModesForElement from '../utilities/getToolsWithModesForElement';
+import { ToolModes } from '../enums';
+import { removeAnnotation } from '../stateManagement';
+import getSynchronizersForViewport from './SynchronizerManager/getSynchronizersForViewport';
+import getToolGroupForViewport from './ToolGroupManager/getToolGroupForViewport';
+import { annotationRenderingEngine } from '../stateManagement/annotation/AnnotationRenderingEngine';
+const VIEWPORT_ELEMENT = 'viewport-element';
+function removeEnabledElement(elementDisabledEvt) {
+    const { element, viewportId } = elementDisabledEvt.detail;
+    _resetSvgNodeCache(element);
+    _removeSvgNode(element);
+    annotationRenderingEngine.removeViewportElement(viewportId, element);
+    mouseEventListeners.disable(element);
+    wheelEventListener.disable(element);
+    touchEventListeners.disable(element);
+    keyEventListener.disable(element);
+    imageChangeEventListener.disable(element);
+    imageRenderedEventDispatcher.disable(element);
+    cameraModifiedEventDispatcher.disable(element);
+    imageSpacingCalibratedEventDispatcher.disable(element);
+    cameraResetEventDispatcher.disable(element);
+    mouseToolEventDispatcher.disable(element);
+    keyboardToolEventDispatcher.disable(element);
+    touchToolEventDispatcher.disable(element);
+    _removeViewportFromSynchronizers(element);
+    _removeViewportFromToolGroup(element);
+    _removeEnabledElement(element);
+}
+const _removeViewportFromSynchronizers = (element) => {
+    const enabledElement = getEnabledElement(element);
+    if (!enabledElement) {
+        return;
+    }
+    const synchronizers = getSynchronizersForViewport(enabledElement.viewportId, enabledElement.renderingEngineId);
+    synchronizers.forEach((sync) => {
+        sync.remove(enabledElement);
+    });
+};
+const _removeViewportFromToolGroup = (element) => {
+    const enabledElement = getEnabledElement(element);
+    if (!enabledElement) {
+        return;
+    }
+    const { renderingEngineId, viewportId } = enabledElement;
+    const toolGroup = getToolGroupForViewport(viewportId, renderingEngineId);
+    if (toolGroup) {
+        toolGroup.removeViewports(renderingEngineId, viewportId);
+    }
+};
+const _removeAllToolsForElement = function (element) {
+    const tools = getToolsWithModesForElement(element, [
+        ToolModes.Active,
+        ToolModes.Passive,
+    ]);
+    const toolsWithData = filterToolsWithAnnotationsForElement(element, tools);
+    toolsWithData.forEach(({ annotations }) => {
+        annotations.forEach((annotation) => {
+            removeAnnotation(annotation.annotationUID);
+        });
+    });
+};
+function _resetSvgNodeCache(element) {
+    const { viewportUid: viewportId, renderingEngineUid: renderingEngineId } = element.dataset;
+    const elementHash = `${viewportId}:${renderingEngineId}`;
+    delete state.svgNodeCache[elementHash];
+}
+function _removeSvgNode(element) {
+    const internalViewportNode = element.querySelector(`div.${VIEWPORT_ELEMENT}`);
+    const svgLayer = internalViewportNode.querySelector('svg');
+    if (svgLayer) {
+        internalViewportNode.removeChild(svgLayer);
+    }
+}
+const _removeEnabledElement = function (element) {
+    const foundElementIndex = state.enabledElements.findIndex((el) => el === element);
+    if (foundElementIndex > -1) {
+        state.enabledElements.splice(foundElementIndex, 1);
+    }
+};
+export default removeEnabledElement;

package/dist/esm/store/state.d.ts

@@ -0,0 +1,18 @@
+import type { IToolGroup, IToolClassReference } from '../types';
+import type Synchronizer from './SynchronizerManager/Synchronizer';
+interface ICornerstoneTools3dState {
+    isInteractingWithTool: boolean;
+    isMultiPartToolActive: boolean;
+    tools: Record<string, {
+        toolClass: IToolClassReference;
+    }>;
+    toolGroups: Array<IToolGroup>;
+    synchronizers: Array<Synchronizer>;
+    svgNodeCache: Record<string, unknown>;
+    enabledElements: Array<unknown>;
+    handleRadius: number;
+}
+declare let state: ICornerstoneTools3dState;
+declare function resetCornerstoneToolsState(): void;
+export type { ICornerstoneTools3dState };
+export { resetCornerstoneToolsState, state, state as default };

package/dist/esm/store/state.js

@@ -0,0 +1,34 @@
+import svgNodeCache, { resetSvgNodeCache } from './svgNodeCache';
+const defaultState = {
+    isInteractingWithTool: false,
+    isMultiPartToolActive: false,
+    tools: {},
+    toolGroups: [],
+    synchronizers: [],
+    svgNodeCache: svgNodeCache,
+    enabledElements: [],
+    handleRadius: 6,
+};
+let state = {
+    isInteractingWithTool: false,
+    isMultiPartToolActive: false,
+    tools: {},
+    toolGroups: [],
+    synchronizers: [],
+    svgNodeCache: svgNodeCache,
+    enabledElements: [],
+    handleRadius: 6,
+};
+function resetCornerstoneToolsState() {
+    resetSvgNodeCache();
+    state = {
+        ...structuredClone({
+            ...defaultState,
+            svgNodeCache: {},
+        }),
+        svgNodeCache: {
+            ...defaultState.svgNodeCache,
+        },
+    };
+}
+export { resetCornerstoneToolsState, state, state as default };

package/dist/esm/store/svgNodeCache.d.ts

@@ -0,0 +1,3 @@
+declare let svgNodeCache: {};
+export declare function resetSvgNodeCache(): void;
+export default svgNodeCache;

package/dist/esm/store/svgNodeCache.js

@@ -0,0 +1,5 @@
+let svgNodeCache = {};
+export function resetSvgNodeCache() {
+    svgNodeCache = {};
+}
+export default svgNodeCache;

package/dist/esm/synchronizers/callbacks/areViewportsCoplanar.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function areViewportsCoplanar(viewport1: Types.IStackViewport | Types.IVolumeViewport, viewport2: Types.IStackViewport | Types.IVolumeViewport): boolean;

package/dist/esm/synchronizers/callbacks/areViewportsCoplanar.js

@@ -0,0 +1,7 @@
+import { vec3 } from 'gl-matrix';
+export default function areViewportsCoplanar(viewport1, viewport2) {
+    const { viewPlaneNormal: viewPlaneNormal1 } = viewport1.getCamera();
+    const { viewPlaneNormal: viewPlaneNormal2 } = viewport2.getCamera();
+    const dotProducts = vec3.dot(viewPlaneNormal1, viewPlaneNormal2);
+    return Math.abs(dotProducts) > 0.9;
+}

package/dist/esm/synchronizers/callbacks/cameraSyncCallback.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../../store';
+export default function cameraSyncCallback(synchronizerInstance: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, cameraModifiedEvent: CustomEvent): void;

package/dist/esm/synchronizers/callbacks/cameraSyncCallback.js

@@ -0,0 +1,11 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+export default function cameraSyncCallback(synchronizerInstance, sourceViewport, targetViewport, cameraModifiedEvent) {
+    const { camera } = cameraModifiedEvent.detail;
+    const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
+    if (!renderingEngine) {
+        throw new Error(`No RenderingEngine for Id: ${targetViewport.renderingEngineId}`);
+    }
+    const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
+    tViewport.setCamera(camera);
+    tViewport.render();
+}

package/dist/esm/synchronizers/callbacks/imageSliceSyncCallback.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../../store';
+export default function imageSliceSyncCallback(synchronizerInstance: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId): Promise<void>;

package/dist/esm/synchronizers/callbacks/imageSliceSyncCallback.js

@@ -0,0 +1,67 @@
+import { vec3, mat4 } from 'gl-matrix';
+import { getRenderingEngine, metaData, utilities, VolumeViewport, } from '@cornerstonejs/core';
+import areViewportsCoplanar from './areViewportsCoplanar';
+const getSpatialRegistration = (targetId, sourceId) => utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', targetId, sourceId);
+export default async function imageSliceSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
+    const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
+    if (!renderingEngine) {
+        throw new Error(`No RenderingEngine for Id: ${targetViewport.renderingEngineId}`);
+    }
+    const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
+    const options = synchronizerInstance.getOptions(targetViewport.viewportId);
+    if (options?.disabled) {
+        return;
+    }
+    const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
+    const imageId1 = sViewport.getCurrentImageId();
+    const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
+    const sourceImagePositionPatient = imagePlaneModule1.imagePositionPatient;
+    const targetImageIds = tViewport.getImageIds();
+    if (!areViewportsCoplanar(sViewport, tViewport)) {
+        return;
+    }
+    let registrationMatrixMat4 = getSpatialRegistration(targetViewport.viewportId, sourceViewport.viewportId);
+    if (!registrationMatrixMat4) {
+        const frameOfReferenceUID1 = sViewport.getFrameOfReferenceUID();
+        const frameOfReferenceUID2 = tViewport.getFrameOfReferenceUID();
+        if (frameOfReferenceUID1 === frameOfReferenceUID2 &&
+            options?.useInitialPosition !== false) {
+            registrationMatrixMat4 = mat4.identity(mat4.create());
+        }
+        else {
+            utilities.calculateViewportsSpatialRegistration(sViewport, tViewport);
+            registrationMatrixMat4 = getSpatialRegistration(targetViewport.viewportId, sourceViewport.viewportId);
+        }
+        if (!registrationMatrixMat4) {
+            return;
+        }
+    }
+    const targetImagePositionPatientWithRegistrationMatrix = vec3.transformMat4(vec3.create(), sourceImagePositionPatient, registrationMatrixMat4);
+    const closestImageIdIndex2 = _getClosestImageIdIndex(targetImagePositionPatientWithRegistrationMatrix, targetImageIds);
+    let imageIndexToSet = closestImageIdIndex2.index;
+    if (tViewport instanceof VolumeViewport) {
+        imageIndexToSet = targetImageIds.length - closestImageIdIndex2.index - 1;
+    }
+    if (closestImageIdIndex2.index !== -1 &&
+        tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index) {
+        await utilities.jumpToSlice(tViewport.element, {
+            imageIndex: imageIndexToSet,
+        });
+    }
+}
+function _getClosestImageIdIndex(targetPoint, imageIds) {
+    return imageIds.reduce((closestImageIdIndex, imageId, index) => {
+        const { imagePositionPatient } = metaData.get('imagePlaneModule', imageId);
+        const distance = vec3.distance(imagePositionPatient, targetPoint);
+        if (distance < closestImageIdIndex.distance) {
+            return {
+                distance,
+                index,
+            };
+        }
+        return closestImageIdIndex;
+    }, {
+        distance: Infinity,
+        index: -1,
+    });
+}

package/dist/esm/synchronizers/callbacks/presentationViewSyncCallback.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function presentationViewSyncCallback(_synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, _sourceEvent: any, options?: Types.ViewPresentationSelector): void;

package/dist/esm/synchronizers/callbacks/presentationViewSyncCallback.js

@@ -0,0 +1,12 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+export default function presentationViewSyncCallback(_synchronizerInstance, sourceViewport, targetViewport, _sourceEvent, options) {
+    const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
+    if (!renderingEngine) {
+        throw new Error(`No RenderingEngine for Id: ${targetViewport.renderingEngineId}`);
+    }
+    const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
+    const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
+    const presentationView = sViewport.getViewPresentation(options);
+    tViewport.setViewPresentation(presentationView);
+    tViewport.render();
+}

package/dist/esm/synchronizers/callbacks/slabThicknessSyncCallback.d.ts

@@ -0,0 +1,2 @@
+import type { Types } from '@cornerstonejs/core';
+export default function slabThicknessSyncCallback(_synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId): void;

package/dist/esm/synchronizers/callbacks/slabThicknessSyncCallback.js

@@ -0,0 +1,15 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+export default function slabThicknessSyncCallback(_synchronizerInstance, sourceViewport, targetViewport) {
+    const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
+    if (!renderingEngine) {
+        throw new Error(`No RenderingEngine for Id: ${targetViewport.renderingEngineId}`);
+    }
+    const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
+    const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
+    const slabThickness = sViewport.getSlabThickness?.();
+    if (!slabThickness) {
+        return;
+    }
+    tViewport.setSlabThickness?.(slabThickness);
+    tViewport.render();
+}

package/dist/esm/synchronizers/callbacks/voiSyncCallback.d.ts

@@ -0,0 +1,5 @@
+import type { Types } from '@cornerstonejs/core';
+export default function voiSyncCallback(synchronizerInstance: any, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId, modifiedEvent: Types.EventTypes.VoiModifiedEvent, options?: {
+    syncInvertState?: boolean;
+    syncColormap?: boolean;
+}): void;

package/dist/esm/synchronizers/callbacks/voiSyncCallback.js

@@ -0,0 +1,35 @@
+import { BaseVolumeViewport, getRenderingEngine, StackViewport, } from '@cornerstonejs/core';
+export default function voiSyncCallback(synchronizerInstance, sourceViewport, targetViewport, modifiedEvent, options) {
+    const eventDetail = modifiedEvent.detail;
+    const { volumeId, range, invertStateChanged, invert, colormap } = eventDetail;
+    const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
+    if (!renderingEngine) {
+        throw new Error(`Rendering Engine does not exist: ${targetViewport.renderingEngineId}`);
+    }
+    const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
+    const tProperties = {
+        voiRange: range,
+    };
+    if (options?.syncInvertState && invertStateChanged) {
+        tProperties.invert = invert;
+    }
+    if (options?.syncColormap && colormap) {
+        tProperties.colormap = colormap;
+    }
+    if (tViewport instanceof BaseVolumeViewport) {
+        const isFusion = tViewport._actors && tViewport._actors.size > 1;
+        if (isFusion) {
+            tViewport.setProperties(tProperties, volumeId);
+        }
+        else {
+            tViewport.setProperties(tProperties);
+        }
+    }
+    else if (tViewport instanceof StackViewport) {
+        tViewport.setProperties(tProperties);
+    }
+    else {
+        throw new Error('Viewport type not supported.');
+    }
+    tViewport.render();
+}

package/dist/esm/synchronizers/callbacks/zoomPanSyncCallback.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+import type { Synchronizer } from '../../store';
+export default function zoomPanSyncCallback(synchronizerInstance: Synchronizer, sourceViewport: Types.IViewportId, targetViewport: Types.IViewportId): void;

package/dist/esm/synchronizers/callbacks/zoomPanSyncCallback.js

@@ -0,0 +1,19 @@
+import { getRenderingEngine } from '@cornerstonejs/core';
+export default function zoomPanSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
+    const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
+    if (!renderingEngine) {
+        throw new Error(`No RenderingEngine for Id: ${targetViewport.renderingEngineId}`);
+    }
+    const options = synchronizerInstance.getOptions(targetViewport.viewportId);
+    const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
+    const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
+    if (options?.syncZoom !== false) {
+        const srcZoom = sViewport.getZoom();
+        tViewport.setZoom(srcZoom);
+    }
+    if (options?.syncPan !== false) {
+        const srcPan = sViewport.getPan();
+        tViewport.setPan(srcPan);
+    }
+    tViewport.render();
+}

package/dist/esm/synchronizers/index.d.ts

@@ -0,0 +1,8 @@
+import createCameraPositionSynchronizer from './synchronizers/createCameraPositionSynchronizer';
+import createPresentationViewSynchronizer from './synchronizers/createPresentationViewSynchronizer';
+import createVOISynchronizer from './synchronizers/createVOISynchronizer';
+import createZoomPanSynchronizer from './synchronizers/createZoomPanSynchronizer';
+import createImageSliceSynchronizer from './synchronizers/createImageSliceSynchronizer';
+import createSlabThicknessSynchronizer from './synchronizers/createSlabThicknessSynchronizer';
+declare const createStackImageSynchronizer: typeof createImageSliceSynchronizer;
+export { createCameraPositionSynchronizer, createPresentationViewSynchronizer, createVOISynchronizer, createZoomPanSynchronizer, createImageSliceSynchronizer, createStackImageSynchronizer, createSlabThicknessSynchronizer, };

package/dist/esm/synchronizers/index.js

@@ -0,0 +1,8 @@
+import createCameraPositionSynchronizer from './synchronizers/createCameraPositionSynchronizer';
+import createPresentationViewSynchronizer from './synchronizers/createPresentationViewSynchronizer';
+import createVOISynchronizer from './synchronizers/createVOISynchronizer';
+import createZoomPanSynchronizer from './synchronizers/createZoomPanSynchronizer';
+import createImageSliceSynchronizer from './synchronizers/createImageSliceSynchronizer';
+import createSlabThicknessSynchronizer from './synchronizers/createSlabThicknessSynchronizer';
+const createStackImageSynchronizer = createImageSliceSynchronizer;
+export { createCameraPositionSynchronizer, createPresentationViewSynchronizer, createVOISynchronizer, createZoomPanSynchronizer, createImageSliceSynchronizer, createStackImageSynchronizer, createSlabThicknessSynchronizer, };

package/dist/esm/synchronizers/synchronizers/createCameraPositionSynchronizer.d.ts

@@ -0,0 +1,2 @@
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+export default function createCameraPositionSynchronizer(synchronizerName: string): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createCameraPositionSynchronizer.js

@@ -0,0 +1,8 @@
+import { createSynchronizer } from '../../store/SynchronizerManager';
+import { Enums } from '@cornerstonejs/core';
+import cameraSyncCallback from '../callbacks/cameraSyncCallback';
+const { CAMERA_MODIFIED } = Enums.Events;
+export default function createCameraPositionSynchronizer(synchronizerName) {
+    const cameraPositionSynchronizer = createSynchronizer(synchronizerName, CAMERA_MODIFIED, cameraSyncCallback);
+    return cameraPositionSynchronizer;
+}

package/dist/esm/synchronizers/synchronizers/createImageSliceSynchronizer.d.ts

@@ -0,0 +1,2 @@
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+export default function createImageSliceSynchronizer(synchronizerName: string): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createImageSliceSynchronizer.js

@@ -0,0 +1,14 @@
+import { createSynchronizer } from '../../store/SynchronizerManager';
+import { Enums } from '@cornerstonejs/core';
+import imageSliceSyncCallback from '../callbacks/imageSliceSyncCallback';
+const { STACK_NEW_IMAGE, VOLUME_NEW_IMAGE } = Enums.Events;
+export default function createImageSliceSynchronizer(synchronizerName) {
+    const stackImageSynchronizer = createSynchronizer(synchronizerName, STACK_NEW_IMAGE, imageSliceSyncCallback, {
+        auxiliaryEvents: [
+            {
+                name: 'VOLUME_NEW_IMAGE',
+            },
+        ],
+    });
+    return stackImageSynchronizer;
+}

package/dist/esm/synchronizers/synchronizers/createPresentationViewSynchronizer.d.ts

@@ -0,0 +1,3 @@
+import { type Types } from '@cornerstonejs/core';
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+export default function createPresentationViewSynchronizer(synchronizerName: string, options?: Types.ViewPresentation): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createPresentationViewSynchronizer.js

@@ -0,0 +1,8 @@
+import { Enums } from '@cornerstonejs/core';
+import { createSynchronizer } from '../../store/SynchronizerManager';
+import presentationViewSyncCallback from '../callbacks/presentationViewSyncCallback';
+const { CAMERA_MODIFIED } = Enums.Events;
+export default function createPresentationViewSynchronizer(synchronizerName, options) {
+    const presentationView = createSynchronizer(synchronizerName, CAMERA_MODIFIED, presentationViewSyncCallback, { viewPresentation: options });
+    return presentationView;
+}

package/dist/esm/synchronizers/synchronizers/createSlabThicknessSynchronizer.d.ts

@@ -0,0 +1,2 @@
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+export default function createPresentationViewSynchronizer(synchronizerName: string): Synchronizer;

package/dist/esm/synchronizers/synchronizers/createSlabThicknessSynchronizer.js

@@ -0,0 +1,8 @@
+import { Enums } from '@cornerstonejs/core';
+import { createSynchronizer } from '../../store/SynchronizerManager';
+import slabThicknessSyncCallback from '../callbacks/slabThicknessSyncCallback';
+const { CAMERA_MODIFIED } = Enums.Events;
+export default function createPresentationViewSynchronizer(synchronizerName) {
+    const presentationView = createSynchronizer(synchronizerName, CAMERA_MODIFIED, slabThicknessSyncCallback);
+    return presentationView;
+}

package/dist/esm/synchronizers/synchronizers/createVOISynchronizer.d.ts

@@ -0,0 +1,7 @@
+import type Synchronizer from '../../store/SynchronizerManager/Synchronizer';
+type VOISynchronizerOptions = {
+    syncInvertState: boolean;
+    syncColormap: boolean;
+};
+export default function createVOISynchronizer(synchronizerName: string, options: VOISynchronizerOptions): Synchronizer;
+export {};