@cornerstonejs/core 4.22.13 → 5.0.0

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewportLegacyAdapter.js

@@ -0,0 +1,114 @@
+import { viewportProjection } from '../viewportProjection';
+import VideoViewport from './VideoViewport';
+class VideoViewportLegacyAdapter extends VideoViewport {
+    setDataIds(imageIds, options) {
+        const dataId = imageIds[0];
+        if (!dataId) {
+            return;
+        }
+        return this.setVideo(dataId, (options?.viewReference?.sliceIndex || 0) + 1);
+    }
+    async setVideo(imageId, frameNumber) {
+        await this.setDisplaySets({ displaySetId: imageId });
+        if (typeof frameNumber === 'number') {
+            this.setFrameNumber(frameNumber);
+        }
+        return this;
+    }
+    setProperties(props) {
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!dataId) {
+            return;
+        }
+        const dataPresentation = {};
+        const viewPresentation = {};
+        if (typeof props.loop === 'boolean') {
+            dataPresentation.loop = props.loop;
+        }
+        if (typeof props.muted === 'boolean') {
+            dataPresentation.muted = props.muted;
+        }
+        if (typeof props.playbackRate === 'number') {
+            dataPresentation.playbackRate = props.playbackRate;
+        }
+        if (props.pan) {
+            viewPresentation.pan = props.pan;
+        }
+        if (props.voiRange) {
+            dataPresentation.voiRange = props.voiRange;
+        }
+        if (props.invert !== undefined) {
+            dataPresentation.invert = props.invert;
+        }
+        if (Object.keys(dataPresentation).length) {
+            this.setDisplaySetPresentation(dataId, dataPresentation);
+        }
+        if (Object.keys(viewPresentation).length) {
+            this.setViewPresentation(viewPresentation);
+        }
+    }
+    getViewPresentation(selector) {
+        return viewportProjection.getPresentation(this, {
+            selector,
+        });
+    }
+    setViewPresentation(viewPres) {
+        if (!viewPres) {
+            return;
+        }
+        const nextViewState = viewportProjection.withPresentation(this, viewPres);
+        if (nextViewState) {
+            this.setViewState(nextViewState);
+        }
+    }
+    resetCamera() {
+        return this.resetViewState();
+    }
+    getProperties() {
+        const dataId = this.getFirstBinding()?.data.id;
+        const dataPresentation = dataId
+            ? this.getDisplaySetPresentation(dataId)
+            : undefined;
+        const viewPresentation = this.getViewPresentation();
+        return {
+            invert: dataPresentation?.invert,
+            loop: dataPresentation?.loop,
+            muted: dataPresentation?.muted,
+            pan: viewPresentation?.pan,
+            playbackRate: dataPresentation?.playbackRate,
+            voiRange: dataPresentation?.voiRange,
+        };
+    }
+    resetProperties() {
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, {
+            invert: false,
+            loop: true,
+            muted: true,
+            playbackRate: 1,
+            voiRange: undefined,
+        });
+        this.setViewPresentation({
+            pan: [0, 0],
+            zoom: 1,
+        });
+    }
+    setVOI(voiRange) {
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, { voiRange });
+    }
+    setAverageWhite(averageWhite) {
+        const dataId = this.getFirstBinding()?.data.id;
+        if (!dataId) {
+            return;
+        }
+        this.setDisplaySetPresentation(dataId, { averageWhite });
+    }
+}
+export default VideoViewportLegacyAdapter;

package/dist/esm/RenderingEngine/GenericViewport/Video/VideoViewportTypes.d.ts

@@ -0,0 +1,45 @@
+import type { BaseViewportRenderContext, BasePresentationProps, DataProvider, MountedRendering, RenderPathResolver } from '../ViewportArchitectureTypes';
+import type { ViewportCameraBase } from '../ViewportCameraTypes';
+import type { VideoImageMetadata } from '../../../utilities/VideoUtilities';
+import type { VOIRange } from '../../../types';
+export interface VideoStreamPayload {
+    renderedUrl: string;
+    fps: number;
+    numberOfFrames: number;
+    frameRange: [number, number];
+    durationSeconds?: number;
+    modality?: string;
+    metadata: VideoImageMetadata;
+}
+export interface VideoPresentationProps extends BasePresentationProps {
+}
+export interface VideoViewState extends ViewportCameraBase<[number, number]> {
+    currentTimeSeconds?: number;
+}
+export interface VideoProperties {
+    playbackRate?: number;
+    loop?: boolean;
+    muted?: boolean;
+    objectFit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+    voiRange?: VOIRange;
+    invert?: boolean;
+    averageWhite?: [number, number, number];
+}
+export type VideoDataPresentation = VideoPresentationProps & VideoProperties;
+export interface VideoViewportInput {
+    id: string;
+    element: HTMLDivElement;
+    renderingEngineId: string;
+    dataProvider?: DataProvider;
+    renderPathResolver?: RenderPathResolver;
+}
+export type VideoGenericViewportInput = VideoViewportInput;
+export interface VideoElementRenderContext extends BaseViewportRenderContext {
+    type: 'video';
+    element: HTMLDivElement;
+}
+export type VideoElementRendering = MountedRendering<{
+    renderMode: 'video2d';
+    element: HTMLVideoElement;
+    currentCamera?: VideoViewState;
+}>;

package/dist/esm/RenderingEngine/GenericViewport/Video/index.d.ts

@@ -0,0 +1,10 @@
+import { getVideoProjectionSnapshot } from './videoProjectionAdapter';
+export { DefaultVideoDataProvider } from './DefaultVideoDataProvider';
+export { createDefaultVideoRenderPaths, createVideoRenderPathResolver, } from './VideoRenderPathResolver';
+export declare const videoProjection: {
+    adapter: import("..").ViewportProjectionAdapter<import("./VideoViewportTypes").VideoViewState, import("../../../types").ViewPresentation, import("./VideoProjectionTypes").VideoProjectionSnapshot>;
+    getSnapshot: typeof getVideoProjectionSnapshot;
+};
+export type { VideoProjectionPresentation, VideoProjectionRequest, VideoProjectionSnapshot, } from './videoProjectionAdapter';
+export { default } from './VideoViewport';
+export type { VideoViewState, VideoDataPresentation, VideoPresentationProps, VideoProperties, VideoViewportInput, VideoGenericViewportInput, } from './VideoViewportTypes';

package/dist/esm/RenderingEngine/GenericViewport/Video/index.js

@@ -0,0 +1,8 @@
+import { getVideoProjectionSnapshot, videoProjectionAdapter, } from './videoProjectionAdapter';
+export { DefaultVideoDataProvider } from './DefaultVideoDataProvider';
+export { createDefaultVideoRenderPaths, createVideoRenderPathResolver, } from './VideoRenderPathResolver';
+export const videoProjection = {
+    adapter: videoProjectionAdapter,
+    getSnapshot: getVideoProjectionSnapshot,
+};
+export { default } from './VideoViewport';

package/dist/esm/RenderingEngine/GenericViewport/Video/videoProjectionAdapter.d.ts

@@ -0,0 +1,8 @@
+import type { ViewPresentation } from '../../../types';
+import type { ViewportProjectionAdapter } from '../ViewportProjectionTypes';
+import { getVideoProjectionSnapshot } from './videoProjectionSnapshot';
+import { type VideoProjectionSnapshot } from './VideoProjectionTypes';
+import type { VideoViewState } from './VideoViewportTypes';
+export { getVideoProjectionSnapshot };
+export type { VideoProjectionPresentation, VideoProjectionRequest, VideoProjectionSnapshot, } from './VideoProjectionTypes';
+export declare const videoProjectionAdapter: ViewportProjectionAdapter<VideoViewState, ViewPresentation, VideoProjectionSnapshot>;

package/dist/esm/RenderingEngine/GenericViewport/Video/videoProjectionAdapter.js

@@ -0,0 +1,12 @@
+import { ViewportType } from '../../../enums';
+import { getVideoProjectionPresentation, withVideoProjectionPresentation, } from './videoProjectionPresentation';
+import { getVideoProjectionSnapshot } from './videoProjectionSnapshot';
+import { VIDEO_PROJECTION_ID, } from './VideoProjectionTypes';
+export { getVideoProjectionSnapshot };
+export const videoProjectionAdapter = {
+    id: VIDEO_PROJECTION_ID,
+    viewportTypes: [ViewportType.VIDEO_NEXT],
+    getSnapshot: (request) => getVideoProjectionSnapshot(request),
+    getPresentation: (snapshot, selector) => getVideoProjectionPresentation(snapshot, selector),
+    withPresentation: (snapshot, presentation, options) => withVideoProjectionPresentation(snapshot, presentation, options),
+};

package/dist/esm/RenderingEngine/GenericViewport/Video/videoProjectionPresentation.d.ts

@@ -0,0 +1,7 @@
+import type { ViewPresentation } from '../../../types';
+import type { ViewPresentationSelector } from '../../../types/IViewport';
+import type { ProjectionWriteOptions } from '../ViewportProjectionTypes';
+import type { VideoProjectionSnapshot } from './VideoProjectionTypes';
+import type { VideoViewState } from './VideoViewportTypes';
+export declare function getVideoProjectionPresentation(snapshot: VideoProjectionSnapshot, selector: ViewPresentationSelector | undefined): ViewPresentation;
+export declare function withVideoProjectionPresentation(snapshot: VideoProjectionSnapshot, presentation: Partial<ViewPresentation>, options?: ProjectionWriteOptions): VideoViewState;

package/dist/esm/RenderingEngine/GenericViewport/Video/videoProjectionPresentation.js

@@ -0,0 +1,66 @@
+import { normalizeVideoViewState } from './videoViewportCamera';
+const DEFAULT_SELECTOR = {
+    rotation: true,
+    zoom: true,
+    pan: true,
+};
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+export function getVideoProjectionPresentation(snapshot, selector) {
+    const target = {};
+    const videoSelector = selector ?? DEFAULT_SELECTOR;
+    const zoom = snapshot.presentation.zoom ?? 1;
+    if (videoSelector.rotation) {
+        target.rotation = snapshot.presentation.rotation ?? 0;
+    }
+    if (videoSelector.zoom) {
+        target.zoom = zoom;
+    }
+    if (videoSelector.pan) {
+        const pan = snapshot.presentation.rawPan;
+        target.pan = [pan[0] / zoom, pan[1] / zoom];
+    }
+    return target;
+}
+export function withVideoProjectionPresentation(snapshot, presentation, options = {}) {
+    const viewState = snapshot.viewState ?? {};
+    const hasZoom = hasOwn(presentation, 'zoom');
+    const hasPan = hasOwn(presentation, 'pan');
+    const hasRotation = hasOwn(presentation, 'rotation');
+    const nextZoom = Math.max(presentation.zoom ?? snapshot.presentation.zoom ?? viewState.scale ?? 1, 0.001);
+    let resolvedView = snapshot.resolvedView;
+    let nextViewState = normalizeVideoViewState({
+        ...viewState,
+        ...(hasRotation ? { rotation: presentation.rotation ?? 0 } : {}),
+    });
+    if (hasZoom) {
+        if (resolvedView) {
+            resolvedView = resolvedView.withZoom(nextZoom, options.anchorCanvas);
+            nextViewState = normalizeVideoViewState({
+                ...resolvedView.state?.viewState,
+                ...(hasRotation ? { rotation: presentation.rotation ?? 0 } : {}),
+            });
+        }
+        else {
+            nextViewState = normalizeVideoViewState({
+                ...nextViewState,
+                scale: nextZoom,
+                scaleMode: 'fit',
+            });
+        }
+    }
+    if (hasPan && presentation.pan) {
+        const targetPan = [
+            presentation.pan[0] * nextZoom,
+            presentation.pan[1] * nextZoom,
+        ];
+        if (resolvedView) {
+            nextViewState = normalizeVideoViewState({
+                ...resolvedView.withPan(targetPan).state?.viewState,
+                ...(hasRotation ? { rotation: presentation.rotation ?? 0 } : {}),
+            });
+        }
+    }
+    return nextViewState;
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/videoProjectionSnapshot.d.ts

@@ -0,0 +1,2 @@
+import { type VideoProjectionRequest, type VideoProjectionSnapshot } from './VideoProjectionTypes';
+export declare function getVideoProjectionSnapshot(request: VideoProjectionRequest): VideoProjectionSnapshot | undefined;

package/dist/esm/RenderingEngine/GenericViewport/Video/videoProjectionSnapshot.js

@@ -0,0 +1,86 @@
+import { VIDEO_PROJECTION_ID, } from './VideoProjectionTypes';
+import { normalizeVideoViewState } from './videoViewportCamera';
+function clonePoint2(point) {
+    return [point[0], point[1]];
+}
+function getMediaPixelsPerCanvasPixel(resolvedView) {
+    const origin = resolvedView.canvasToWorld([0, 0]);
+    const next = resolvedView.canvasToWorld([1, 0]);
+    return Math.abs(next[0] - origin[0]) || 1;
+}
+function getScale(resolvedView, zoom) {
+    if (!resolvedView) {
+        return { kind: 'fit', value: zoom };
+    }
+    return {
+        kind: 'nativePixel',
+        pixelsPerCanvasPixel: getMediaPixelsPerCanvasPixel(resolvedView),
+    };
+}
+function getCenterCanvasPoint(canvasWidth, canvasHeight) {
+    return [canvasWidth / 2, canvasHeight / 2];
+}
+function getCenterMediaPoint(resolvedView, canvasPoint, viewState) {
+    if (resolvedView) {
+        const worldPoint = resolvedView.canvasToWorld(canvasPoint);
+        return [worldPoint[0], worldPoint[1]];
+    }
+    return viewState.anchorWorld ? clonePoint2(viewState.anchorWorld) : [0, 0];
+}
+export function getVideoProjectionSnapshot(request) {
+    const { viewport } = request;
+    const viewState = normalizeVideoViewState(request.viewState ?? viewport.getViewState?.() ?? {});
+    const resolvedView = request.resolvedView ?? viewport.getResolvedView?.();
+    const canvasWidth = request.canvasWidth ??
+        resolvedView?.state?.containerWidth ??
+        viewport.element?.clientWidth ??
+        1;
+    const canvasHeight = request.canvasHeight ??
+        resolvedView?.state?.containerHeight ??
+        viewport.element?.clientHeight ??
+        1;
+    const canvasPoint = getCenterCanvasPoint(canvasWidth, canvasHeight);
+    const mediaPoint = getCenterMediaPoint(resolvedView, canvasPoint, viewState);
+    const zoom = resolvedView?.zoom ?? Math.max(viewState.scale ?? 1, 0.001);
+    const rawPan = resolvedView?.pan ?? [0, 0];
+    const rendererCamera = resolvedView?.toICamera();
+    const frameOfReferenceUID = request.frameOfReferenceUID ??
+        resolvedView?.getFrameOfReferenceUID() ??
+        viewport.getFrameOfReferenceUID?.();
+    return {
+        kind: VIDEO_PROJECTION_ID,
+        adapterId: VIDEO_PROJECTION_ID,
+        canvasHeight,
+        canvasWidth,
+        dataId: request.dataId,
+        frameOfReferenceUID,
+        presentation: {
+            pan: clonePoint2(rawPan),
+            position: {
+                kind: 'mediaPoint',
+                mediaPoint,
+                canvasPoint,
+            },
+            rawPan: clonePoint2(rawPan),
+            rotation: resolvedView?.rotation ?? viewState.rotation ?? 0,
+            scale: getScale(resolvedView, zoom),
+            zoom,
+        },
+        rendererCamera,
+        resolvedView,
+        spaces: {
+            canvas: true,
+            image: false,
+            renderer: Boolean(rendererCamera),
+            world: Boolean(resolvedView),
+        },
+        transforms: resolvedView
+            ? {
+                canvasToWorld: (point) => resolvedView.canvasToWorld(point),
+                worldToCanvas: (point) => resolvedView.worldToCanvas(point),
+            }
+            : undefined,
+        viewState,
+        viewportType: viewport.type,
+    };
+}

package/dist/esm/RenderingEngine/GenericViewport/Video/videoViewportCamera.d.ts

@@ -0,0 +1,30 @@
+import type { ViewAnchor } from '../ViewportCameraTypes';
+import type { VideoViewState, VideoProperties } from './VideoViewportTypes';
+export interface VideoCanvasMapping {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    containerWidth: number;
+    containerHeight: number;
+    intrinsicWidth: number;
+    intrinsicHeight: number;
+    anchorWorld: [number, number];
+    anchorCanvas: ViewAnchor;
+    worldToCanvasRatio: number;
+}
+interface VideoCanvasMappingInput {
+    containerWidth: number;
+    containerHeight: number;
+    intrinsicWidth: number;
+    intrinsicHeight: number;
+    objectFit?: VideoProperties['objectFit'];
+}
+export declare function createDefaultVideoViewState(): VideoViewState;
+export declare function normalizeVideoViewState(camera: VideoViewState): VideoViewState;
+export declare function resolveVideoCanvasMapping(input: VideoCanvasMappingInput & {
+    camera?: VideoViewState;
+}): VideoCanvasMapping | undefined;
+export declare function getPanForVideoCanvasMapping(mapping: VideoCanvasMapping): [number, number];
+export declare function getAnchorWorldForPan(pan: [number, number], mapping: VideoCanvasMapping): [number, number];
+export {};

package/dist/esm/RenderingEngine/GenericViewport/Video/videoViewportCamera.js

@@ -0,0 +1,105 @@
+export function createDefaultVideoViewState() {
+    return {
+        currentTimeSeconds: 0,
+        anchorCanvas: [0.5, 0.5],
+        scale: 1,
+        scaleMode: 'fit',
+        rotation: 0,
+    };
+}
+export function normalizeVideoViewState(camera) {
+    return {
+        ...(camera.currentTimeSeconds !== undefined
+            ? { currentTimeSeconds: Math.max(0, camera.currentTimeSeconds) }
+            : {}),
+        anchorCanvas: cloneAnchorCanvas(camera.anchorCanvas ?? [0.5, 0.5]),
+        scale: Math.max(camera.scale ?? 1, 0.001),
+        scaleMode: 'fit',
+        rotation: camera.rotation ?? 0,
+        ...(camera.anchorWorld
+            ? {
+                anchorWorld: cloneAnchorWorld(camera.anchorWorld),
+            }
+            : {}),
+    };
+}
+export function resolveVideoCanvasMapping(input) {
+    const { containerWidth, containerHeight, intrinsicWidth, intrinsicHeight, objectFit = 'contain', camera, } = input;
+    if (!containerWidth ||
+        !containerHeight ||
+        !intrinsicWidth ||
+        !intrinsicHeight) {
+        return;
+    }
+    const containScale = Math.min(containerWidth / intrinsicWidth, containerHeight / intrinsicHeight);
+    const coverScale = Math.max(containerWidth / intrinsicWidth, containerHeight / intrinsicHeight);
+    let width = intrinsicWidth * containScale;
+    let height = intrinsicHeight * containScale;
+    switch (objectFit) {
+        case 'cover':
+            width = intrinsicWidth * coverScale;
+            height = intrinsicHeight * coverScale;
+            break;
+        case 'fill':
+            width = containerWidth;
+            height = containerHeight;
+            break;
+        case 'none':
+            width = intrinsicWidth;
+            height = intrinsicHeight;
+            break;
+        case 'scale-down': {
+            const scaleDown = Math.min(1, containScale);
+            width = intrinsicWidth * scaleDown;
+            height = intrinsicHeight * scaleDown;
+            break;
+        }
+        case 'contain':
+        default:
+            break;
+    }
+    const zoom = Math.max(camera?.scale ?? 1, 0.001);
+    width *= zoom;
+    height *= zoom;
+    const worldToCanvasRatio = width / intrinsicWidth;
+    const anchorCanvas = cloneAnchorCanvas(camera?.anchorCanvas ?? [0.5, 0.5]);
+    const anchorWorld = cloneAnchorWorld(camera?.anchorWorld) ??
+        [intrinsicWidth / 2, intrinsicHeight / 2];
+    const left = containerWidth * anchorCanvas[0] - anchorWorld[0] * worldToCanvasRatio;
+    const top = containerHeight * anchorCanvas[1] - anchorWorld[1] * worldToCanvasRatio;
+    return {
+        left,
+        top,
+        width,
+        height,
+        containerWidth,
+        containerHeight,
+        intrinsicWidth,
+        intrinsicHeight,
+        anchorWorld,
+        anchorCanvas,
+        worldToCanvasRatio,
+    };
+}
+export function getPanForVideoCanvasMapping(mapping) {
+    return [
+        mapping.left / mapping.worldToCanvasRatio,
+        mapping.top / mapping.worldToCanvasRatio,
+    ];
+}
+export function getAnchorWorldForPan(pan, mapping) {
+    return [
+        (mapping.containerWidth * mapping.anchorCanvas[0]) /
+            mapping.worldToCanvasRatio -
+            pan[0],
+        (mapping.containerHeight * mapping.anchorCanvas[1]) /
+            mapping.worldToCanvasRatio -
+            pan[1],
+    ];
+}
+function cloneAnchorWorld(anchorWorld) {
+    return anchorWorld ? [anchorWorld[0], anchorWorld[1]] : undefined;
+}
+function cloneAnchorCanvas(anchorCanvas) {
+    return [anchorCanvas[0], anchorCanvas[1]];
+}

package/dist/esm/RenderingEngine/GenericViewport/ViewportArchitectureTypes.d.ts

@@ -0,0 +1,126 @@
+import type { ActorEntry, ICamera, Point2, Point3 } from '../../types';
+import type { ReferenceCompatibleOptions, ViewReference, ViewReferenceSpecifier } from '../../types/IViewport';
+import type ViewportType from '../../enums/ViewportType';
+import type ResolvedViewportView from './ResolvedViewportView';
+export type ViewportId = string;
+export type DataId = string;
+export type KnownViewportRenderContext = 'planar' | 'video' | 'ecg' | 'wsi' | '3d';
+export type ExtensionViewportRenderContext = string & {};
+export type ViewportRenderContextType = KnownViewportRenderContext | ExtensionViewportRenderContext;
+export type LogicalDataType = 'image' | 'video' | 'ecg' | 'wsi' | 'geometry';
+export type BindingRole = 'source' | 'overlay';
+export type ViewportDataReference = {
+    kind: 'data';
+    dataId: string;
+} | {
+    kind: 'image';
+    imageId: string;
+} | {
+    kind: 'volume';
+    volumeId: string;
+} | {
+    kind: 'geometry';
+    geometryId: string;
+} | {
+    kind: 'segmentation';
+    segmentationId: string;
+    representationUID?: string;
+    labelmapId?: string;
+};
+export interface DataAddOptions {
+    renderMode: string;
+    role?: BindingRole;
+}
+export interface BasePresentationProps {
+    visible?: boolean;
+    opacity?: number;
+}
+export type LoadedData<TData extends object = object> = {
+    id: DataId;
+    type: LogicalDataType;
+} & TData;
+export type MountedRendering<TRendering extends {
+    renderMode: string;
+} = {
+    renderMode: string;
+}> = Omit<TRendering, 'id'>;
+export interface RenderPathAttachment<TPresentation = unknown> {
+    rendering: MountedRendering;
+    updateDataPresentation(props: TPresentation): void;
+    applyViewState(viewState: unknown): void;
+    getFrameOfReferenceUID(): string | undefined;
+    getActorEntry?(data: LoadedData): ActorEntry | undefined;
+    getImageData?(): unknown;
+    render?(): void;
+    resize?(): void;
+    removeData(): void;
+}
+export interface BaseViewportRenderContext {
+    viewportId: ViewportId;
+    renderingEngineId?: string;
+    type: ViewportRenderContextType;
+}
+export interface RenderPath<TContext extends BaseViewportRenderContext = BaseViewportRenderContext> {
+    addData(ctx: TContext, data: LoadedData, options: DataAddOptions): Promise<RenderPathAttachment>;
+}
+export interface RenderPathDefinition<TRootContext extends BaseViewportRenderContext = BaseViewportRenderContext, TAdapterContext extends BaseViewportRenderContext = TRootContext> {
+    id: string;
+    type: ViewportType;
+    matches(data: LoadedData, options: DataAddOptions): boolean;
+    createRenderPath(): RenderPath<TAdapterContext>;
+    selectContext?(rootContext: TRootContext): TAdapterContext;
+}
+export interface RenderPathResolver {
+    register<TRootContext extends BaseViewportRenderContext, TAdapterContext extends BaseViewportRenderContext>(path: RenderPathDefinition<TRootContext, TAdapterContext>): void;
+    resolve<TContext extends BaseViewportRenderContext>(type: ViewportType, data: LoadedData, options: DataAddOptions): RenderPathDefinition<TContext, BaseViewportRenderContext>;
+}
+export interface DataProvider<TData extends object = object, TOptions = unknown> {
+    load(dataId: DataId, options?: TOptions): Promise<LoadedData<TData>>;
+}
+export interface ViewportDataBinding<TPresentation = unknown> extends RenderPathAttachment<TPresentation> {
+    data: LoadedData;
+    role: BindingRole;
+}
+export interface ViewportController<TViewState = unknown, TDataPresentation = unknown> {
+    readonly id: ViewportId;
+    readonly type: ViewportType;
+    addDisplaySet(displaySetId: DataId, options: DataAddOptions): Promise<void>;
+    setDisplaySets(...entries: Array<{
+        displaySetId: DataId;
+        options?: unknown;
+    }>): Promise<void>;
+    removeData(dataId: DataId): void;
+    setViewState(viewState: Partial<TViewState>): void;
+    getViewState(): TViewState;
+    getResolvedView(): ResolvedViewportView<unknown, ICamera<unknown>> | undefined;
+    updateViewState(updater: Partial<TViewState> | ((viewState: TViewState) => Partial<TViewState> | void)): void;
+    resetViewState(options?: unknown): boolean;
+    setDisplaySetPresentation(props: Partial<TDataPresentation>): void;
+    setDisplaySetPresentation(displaySetId: DataId, props: Partial<TDataPresentation>): void;
+    getDisplaySetPresentation(dataId: DataId): TDataPresentation | undefined;
+    setViewReference(viewReference: ViewReference): void;
+    getViewReference(specifier?: ViewReferenceSpecifier): ViewReference;
+    getViewReferenceId(specifier?: ViewReferenceSpecifier): string;
+    isReferenceViewable(viewReference: ViewReference, options?: ReferenceCompatibleOptions): boolean;
+    render(): void;
+    setRendered(): void;
+}
+export interface ICanvasWorldViewport {
+    canvasToWorld(canvasPos: Point2): Point3;
+    worldToCanvas(worldPos: Point3): Point2;
+}
+export interface IZoomViewport {
+    getZoom(): number;
+    setZoom(zoom: number, canvasPoint?: Point2): void;
+}
+export interface IPanViewport {
+    getPan(): Point2;
+    setPan(pan: Point2): void;
+}
+export interface IFrameOfReferenceViewport {
+    getFrameOfReferenceUID(): string;
+}
+export declare function viewportHasCanvasWorldTransform(viewport: unknown): viewport is ICanvasWorldViewport;
+export declare function viewportHasZoom(viewport: unknown): viewport is IZoomViewport;
+export declare function viewportHasPan(viewport: unknown): viewport is IPanViewport;
+export declare function viewportHasFrameOfReferenceUID(viewport: unknown): viewport is IFrameOfReferenceViewport;

package/dist/esm/RenderingEngine/GenericViewport/ViewportArchitectureTypes.js

@@ -0,0 +1,20 @@
+export function viewportHasCanvasWorldTransform(viewport) {
+    return Boolean(viewport &&
+        typeof viewport.canvasToWorld === 'function' &&
+        typeof viewport.worldToCanvas === 'function');
+}
+export function viewportHasZoom(viewport) {
+    return Boolean(viewport &&
+        typeof viewport.getZoom === 'function' &&
+        typeof viewport.setZoom === 'function');
+}
+export function viewportHasPan(viewport) {
+    return Boolean(viewport &&
+        typeof viewport.getPan === 'function' &&
+        typeof viewport.setPan === 'function');
+}
+export function viewportHasFrameOfReferenceUID(viewport) {
+    return Boolean(viewport &&
+        typeof viewport.getFrameOfReferenceUID ===
+            'function');
+}

package/dist/esm/RenderingEngine/GenericViewport/ViewportCameraTypes.d.ts

@@ -0,0 +1,12 @@
+export type ViewAnchor = [number, number];
+export type CameraScale = number | [number, number];
+export type CameraScaleMode = 'fit' | 'fitAspect' | 'fitWidth' | 'fitHeight' | 'absolute';
+export interface CameraFrame<TAnchorWorld = unknown, TScale = number> {
+    anchorWorld?: TAnchorWorld;
+    anchorCanvas?: ViewAnchor;
+    scale?: TScale;
+    scaleMode?: CameraScaleMode;
+    rotation?: number;
+}
+export interface ViewportCameraBase<TAnchorWorld = unknown, TScale = number> extends CameraFrame<TAnchorWorld, TScale> {
+}