@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

package/dist/esm/enums/MetadataModules.js

@@ -1,39 +1,2 @@
-var MetadataModules;
-(function (MetadataModules) {
-    MetadataModules["CALIBRATION"] = "calibrationModule";
-    MetadataModules["CINE"] = "cineModule";
-    MetadataModules["GENERAL_IMAGE"] = "generalImageModule";
-    MetadataModules["GENERAL_SERIES"] = "generalSeriesModule";
-    MetadataModules["GENERAL_STUDY"] = "generalStudyModule";
-    MetadataModules["IMAGE_PIXEL"] = "imagePixelModule";
-    MetadataModules["IMAGE_PLANE"] = "imagePlaneModule";
-    MetadataModules["IMAGE_URL"] = "imageUrlModule";
-    MetadataModules["MODALITY_LUT"] = "modalityLutModule";
-    MetadataModules["MULTIFRAME"] = "multiframeModule";
-    MetadataModules["NM_MULTIFRAME_GEOMETRY"] = "nmMultiframeGeometryModule";
-    MetadataModules["OVERLAY_PLANE"] = "overlayPlaneModule";
-    MetadataModules["PATIENT"] = "patientModule";
-    MetadataModules["PATIENT_STUDY"] = "patientStudyModule";
-    MetadataModules["PET_IMAGE"] = "petImageModule";
-    MetadataModules["PET_ISOTOPE"] = "petIsotopeModule";
-    MetadataModules["PET_SERIES"] = "petSeriesModule";
-    MetadataModules["SOP_COMMON"] = "sopCommonModule";
-    MetadataModules["ULTRASOUND_ENHANCED_REGION"] = "ultrasoundEnhancedRegionModule";
-    MetadataModules["ECG"] = "ecgModule";
-    MetadataModules["VOI_LUT"] = "voiLutModule";
-    MetadataModules["FRAME_MODULE"] = "frameModule";
-    MetadataModules["WADO_WEB_CLIENT"] = "wadoWebClient";
-    MetadataModules["INSTANCE"] = "instance";
-    MetadataModules["IMAGE_SOP_INSTANCE_REFERENCE"] = "ImageSopInstanceReference";
-    MetadataModules["REFERENCED_SERIES_REFERENCE"] = "ReferencedSeriesReference";
-    MetadataModules["PREDECESSOR_SEQUENCE"] = "PredecessorSequence";
-    MetadataModules["STUDY_DATA"] = "StudyData";
-    MetadataModules["SERIES_DATA"] = "SeriesData";
-    MetadataModules["IMAGE_DATA"] = "ImageData";
-    MetadataModules["RTSS_INSTANCE_DATA"] = "RtssInstanceData";
-    MetadataModules["NEW_INSTANCE_DATA"] = "NewInstanceData";
-    MetadataModules["RTSS_CONTOUR"] = "metaRTSSContour";
-    MetadataModules["SEG_BIT"] = "metaSegBitmap";
-    MetadataModules["SR_ANNOTATION"] = "metaSrAnnotation";
-})(MetadataModules || (MetadataModules = {}));
-export default MetadataModules;
+import { Enums } from '@cornerstonejs/metadata';
+export default Enums.MetadataModules;

package/dist/esm/enums/ViewportStatus.d.ts

@@ -2,6 +2,7 @@ declare enum ViewportStatus {
     NO_DATA = "noData",
     LOADING = "loading",
     PRE_RENDER = "preRender",
+    NEEDS_RENDER = "needsRender",
     RESIZE = "resize",
     RENDERED = "rendered"
 }

package/dist/esm/enums/ViewportStatus.js

@@ -3,6 +3,7 @@ var ViewportStatus;
     ViewportStatus["NO_DATA"] = "noData";
     ViewportStatus["LOADING"] = "loading";
     ViewportStatus["PRE_RENDER"] = "preRender";
+    ViewportStatus["NEEDS_RENDER"] = "needsRender";
     ViewportStatus["RESIZE"] = "resize";
     ViewportStatus["RENDERED"] = "rendered";
 })(ViewportStatus || (ViewportStatus = {}));

package/dist/esm/enums/ViewportType.d.ts

@@ -3,8 +3,13 @@ declare enum ViewportType {
     ORTHOGRAPHIC = "orthographic",
     PERSPECTIVE = "perspective",
     VOLUME_3D = "volume3d",
+    VOLUME_3D_NEXT = "volume3dNext",
+    PLANAR_NEXT = "planarNext",
     VIDEO = "video",
+    VIDEO_NEXT = "videoNext",
     WHOLE_SLIDE = "wholeSlide",
-    ECG = "ecg"
+    WHOLE_SLIDE_NEXT = "wholeSlideNext",
+    ECG = "ecg",
+    ECG_NEXT = "ecgNext"
 }
 export default ViewportType;

package/dist/esm/enums/ViewportType.js

@@ -4,8 +4,13 @@ var ViewportType;
     ViewportType["ORTHOGRAPHIC"] = "orthographic";
     ViewportType["PERSPECTIVE"] = "perspective";
     ViewportType["VOLUME_3D"] = "volume3d";
+    ViewportType["VOLUME_3D_NEXT"] = "volume3dNext";
+    ViewportType["PLANAR_NEXT"] = "planarNext";
     ViewportType["VIDEO"] = "video";
+    ViewportType["VIDEO_NEXT"] = "videoNext";
     ViewportType["WHOLE_SLIDE"] = "wholeSlide";
+    ViewportType["WHOLE_SLIDE_NEXT"] = "wholeSlideNext";
     ViewportType["ECG"] = "ecg";
+    ViewportType["ECG_NEXT"] = "ecgNext";
 })(ViewportType || (ViewportType = {}));
 export default ViewportType;

package/dist/esm/enums/ViewportTypes.d.ts

@@ -0,0 +1,5 @@
+import type { ViewportTypeConstants } from '../types/ViewportTypeRegistry';
+export type ViewportTypesMap = ViewportTypeConstants;
+declare const ViewportTypes: ViewportTypesMap;
+export declare function registerViewportTypesConstant<Name extends keyof ViewportTypeConstants>(name: Name, type: ViewportTypeConstants[Name]): void;
+export default ViewportTypes;

package/dist/esm/enums/ViewportTypes.js

@@ -0,0 +1,23 @@
+import ViewportType from './ViewportType';
+const builtInViewportTypes = {
+    STACK: ViewportType.STACK,
+    ORTHOGRAPHIC: ViewportType.ORTHOGRAPHIC,
+    PERSPECTIVE: ViewportType.PERSPECTIVE,
+    VOLUME_3D: ViewportType.VOLUME_3D,
+    VOLUME_3D_NEXT: ViewportType.VOLUME_3D_NEXT,
+    PLANAR_NEXT: ViewportType.PLANAR_NEXT,
+    VIDEO: ViewportType.VIDEO,
+    VIDEO_NEXT: ViewportType.VIDEO_NEXT,
+    WHOLE_SLIDE: ViewportType.WHOLE_SLIDE,
+    WHOLE_SLIDE_NEXT: ViewportType.WHOLE_SLIDE_NEXT,
+    ECG: ViewportType.ECG,
+    ECG_NEXT: ViewportType.ECG_NEXT,
+};
+const ViewportTypes = builtInViewportTypes;
+export function registerViewportTypesConstant(name, type) {
+    if (Object.prototype.hasOwnProperty.call(ViewportTypes, name)) {
+        throw new Error(`Viewport type constant "${String(name)}" already exists`);
+    }
+    ViewportTypes[name] = type;
+}
+export default ViewportTypes;

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

@@ -1,6 +1,7 @@
 import Events from './Events';
 import RequestType from './RequestType';
 import ViewportType from './ViewportType';
+import ViewportTypes, { type ViewportTypesMap } from './ViewportTypes';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
@@ -17,4 +18,4 @@ import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, type ViewportTypesMap, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/enums/index.js

@@ -1,6 +1,7 @@
 import Events from './Events';
 import RequestType from './RequestType';
 import ViewportType from './ViewportType';
+import ViewportTypes, {} from './ViewportTypes';
 import InterpolationType from './InterpolationType';
 import BlendModes from './BlendModes';
 import OrientationAxis from './OrientationAxis';
@@ -17,4 +18,4 @@ import MetadataModules from './MetadataModules';
 import { GenerateImageType } from './GenerateImageType';
 import VoxelManagerEnum from './VoxelManagerEnum';
 import RenderingEngineModeEnum from './RenderingEngineModeEnum';
-export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };
+export { Events, BlendModes, CalibrationTypes, InterpolationType, RequestType, ViewportType, ViewportTypes, OrientationAxis, GeometryType, ContourType, MeshType, VOILUTFunctionType, DynamicOperatorType, ViewportStatus, VideoEnums, MetadataModules, ImageQualityStatus, VoxelManagerEnum, GenerateImageType, RenderingEngineModeEnum, };

package/dist/esm/getEnabledElement.js

@@ -1,4 +1,5 @@
 import getRenderingEngine, { getRenderingEngines, } from './RenderingEngine/getRenderingEngine';
+import { viewportHasFrameOfReferenceUID } from './RenderingEngine/GenericViewport/ViewportArchitectureTypes';
 export default function getEnabledElement(element) {
     if (!element) {
         return;
@@ -18,7 +19,9 @@ export function getEnabledElementByIds(viewportId, renderingEngineId) {
     if (!viewport) {
         return;
     }
-    const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+    const FrameOfReferenceUID = viewportHasFrameOfReferenceUID(viewport)
+        ? viewport.getFrameOfReferenceUID()
+        : undefined;
     return {
         viewport,
         renderingEngine,

package/dist/esm/index.d.ts

@@ -12,6 +12,18 @@ import StackViewport from './RenderingEngine/StackViewport';
 import VideoViewport from './RenderingEngine/VideoViewport';
 import WSIViewport from './RenderingEngine/WSIViewport';
 import ECGViewport from './RenderingEngine/ECGViewport';
+import { defaultRenderPathResolver, DefaultRenderPathResolver, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, GenericViewport, ViewportProjectionService, viewportProjection } from './RenderingEngine/GenericViewport';
+import ECGGenericViewport, { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection } from './RenderingEngine/GenericViewport/ECG';
+import VideoGenericViewport, { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection } from './RenderingEngine/GenericViewport/Video';
+import PlanarViewport, { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection } from './RenderingEngine/GenericViewport/Planar';
+import GenericVolumeViewport3D, { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection } from './RenderingEngine/GenericViewport/Volume3D';
+import WSIGenericViewport, { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection } from './RenderingEngine/GenericViewport/WSI';
+export type { BuiltInViewportProjectionByKind, BuiltInViewportProjectionByType, BuiltInViewportProjectionKind, BuiltInViewportProjectionType, ProjectionPresentationForKind, ProjectionPresentationForViewport, ProjectionPresentationForViewportType, ProjectionPosition, ProjectionPresentation, ProjectionRequest, ProjectionScale, ProjectionSnapshotForKind, ProjectionSnapshotForViewport, ProjectionSnapshotForViewportType, ProjectionSnapshot, ProjectionSpaces, ProjectionTransforms, ProjectionViewStateForKind, ProjectionViewStateForViewport, ProjectionViewStateForViewportType, ProjectionWriteOptions, ViewportDataReference, ViewportProjectionAdapter, } from './RenderingEngine/GenericViewport';
+export type { ECGProjectionPresentation, ECGProjectionRequest, ECGProjectionSnapshot, ECGViewState, } from './RenderingEngine/GenericViewport/ECG';
+export type { VideoProjectionPresentation, VideoProjectionRequest, VideoProjectionSnapshot, VideoViewState, } from './RenderingEngine/GenericViewport/Video';
+export type { PlanarResolvedICamera, PlanarSliceBasis, PlanarDisplayArea, PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, PlanarViewPresentation, PlanarViewPresentationSelector, PlanarViewState, } from './RenderingEngine/GenericViewport/Planar';
+export type { WSIProjectionPresentation, WSIProjectionRequest, WSIProjectionSnapshot, WSIViewState, } from './RenderingEngine/GenericViewport/WSI';
+export type { Volume3DCamera, Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot, } from './RenderingEngine/GenericViewport/Volume3D';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { version } from './version';
@@ -22,7 +34,7 @@ import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization } from './init';
+import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
@@ -31,13 +43,72 @@ import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import { decimatedVolumeLoader } from './loaders/decimatedVolumeLoader';
 import type * as Types from './types';
 import type { IRetrieveConfiguration, IImagesLoader, RetrieveOptions, RetrieveStage, ImageLoadListener } from './types';
+import { ActorRenderMode } from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
+import { convertColorArrayToRgbString } from './utilities/convertColorArrayToRgbString';
 import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
-import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports } from './RenderingEngine/helpers';
+import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix } from './RenderingEngine/helpers';
+import { registerViewportType, isRegisteredViewportType } from './RenderingEngine/helpers/viewportTypeToViewportClass';
+export type { ViewportType, ViewportTypeConstants, ViewportTypeRegistry, } from './types/ViewportTypeRegistry';
+export type { ViewportTypesMap } from './enums/ViewportTypes';
 export * from './loaders/decimatedVolumeLoader';
+declare const renderingEngineExportsV2: {
+    GenericViewport: typeof GenericViewport;
+    DefaultRenderPathResolver: typeof DefaultRenderPathResolver;
+    defaultRenderPathResolver: DefaultRenderPathResolver;
+    ECGGenericViewport: typeof ECGGenericViewport;
+    createDefaultECGRenderPaths: typeof createDefaultECGRenderPaths;
+    createECGRenderPathResolver: typeof createECGRenderPathResolver;
+    DefaultECGDataProvider: typeof DefaultECGDataProvider;
+    ecgProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").ECGViewState, Types.ViewPresentation, import(".").ECGProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/ECG/ecgProjectionSnapshot").getECGProjectionSnapshot;
+    };
+    VideoGenericViewport: typeof VideoGenericViewport;
+    createDefaultVideoRenderPaths: typeof createDefaultVideoRenderPaths;
+    createVideoRenderPathResolver: typeof createVideoRenderPathResolver;
+    DefaultVideoDataProvider: typeof DefaultVideoDataProvider;
+    videoProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").VideoViewState, Types.ViewPresentation, import(".").VideoProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/Video/videoProjectionSnapshot").getVideoProjectionSnapshot;
+    };
+    PlanarViewport: typeof PlanarViewport;
+    createDefaultPlanarRenderPaths: typeof createDefaultPlanarRenderPaths;
+    createPlanarRenderPathResolver: typeof createPlanarRenderPathResolver;
+    DefaultPlanarDataProvider: typeof DefaultPlanarDataProvider;
+    planarProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").PlanarViewState, import(".").PlanarViewPresentation, import(".").PlanarProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionSnapshot;
+        getZoom: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionZoom;
+        getScale: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionScale;
+        getPan: typeof import("./RenderingEngine/GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionPan;
+        resolveICamera: typeof import("./RenderingEngine/GenericViewport/Planar/planarRenderCamera").resolvePlanarICamera;
+        derivePresentation: typeof import("./RenderingEngine/GenericViewport/Planar/planarRenderCamera").derivePlanarPresentation;
+        applyToRenderer: typeof import("./RenderingEngine/GenericViewport/Planar/planarRenderCamera").applyPlanarICameraToRenderer;
+        createImageSliceBasis: typeof import("./RenderingEngine/GenericViewport/Planar/planarSliceBasis").createPlanarImageSliceBasis;
+        createVolumeSliceBasis: typeof import("./RenderingEngine/GenericViewport/Planar/planarSliceBasis").createPlanarVolumeSliceBasis;
+    };
+    VolumeViewport3D: typeof GenericVolumeViewport3D;
+    createDefaultVolume3DRenderPaths: typeof createDefaultVolume3DRenderPaths;
+    createVolume3DRenderPathResolver: typeof createVolume3DRenderPathResolver;
+    DefaultVolume3DDataProvider: typeof DefaultVolume3DDataProvider;
+    volume3DProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").Volume3DCamera, import(".").Volume3DProjectionPresentation, import(".").Volume3DProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/Volume3D/volume3DProjectionSnapshot").getVolume3DProjectionSnapshot;
+    };
+    WSIGenericViewport: typeof WSIGenericViewport;
+    createDefaultWSIRenderPaths: typeof createDefaultWSIRenderPaths;
+    createWSIRenderPathResolver: typeof createWSIRenderPathResolver;
+    DefaultWSIDataProvider: typeof DefaultWSIDataProvider;
+    wsiProjection: {
+        adapter: import(".").ViewportProjectionAdapter<import(".").WSIViewState, Types.ViewPresentation, import(".").WSIProjectionSnapshot>;
+        getSnapshot: typeof import("./RenderingEngine/GenericViewport/WSI/wsiProjectionSnapshot").getWSIProjectionSnapshot;
+    };
+};
+declare const LegacyVolumeViewport3D: typeof VolumeViewport3D;
 export type { Types, IRetrieveConfiguration, RetrieveOptions, RetrieveStage, ImageLoadListener, IImagesLoader, };
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/index.js

@@ -12,6 +12,12 @@ import StackViewport from './RenderingEngine/StackViewport';
 import VideoViewport from './RenderingEngine/VideoViewport';
 import WSIViewport from './RenderingEngine/WSIViewport';
 import ECGViewport from './RenderingEngine/ECGViewport';
+import { defaultRenderPathResolver, DefaultRenderPathResolver, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, GenericViewport, ViewportProjectionService, viewportProjection, } from './RenderingEngine/GenericViewport';
+import ECGGenericViewport, { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, } from './RenderingEngine/GenericViewport/ECG';
+import VideoGenericViewport, { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, } from './RenderingEngine/GenericViewport/Video';
+import PlanarViewport, { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, } from './RenderingEngine/GenericViewport/Planar';
+import GenericVolumeViewport3D, { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, } from './RenderingEngine/GenericViewport/Volume3D';
+import WSIGenericViewport, { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, } from './RenderingEngine/GenericViewport/WSI';
 import Viewport from './RenderingEngine/Viewport';
 import eventTarget from './eventTarget';
 import { version } from './version';
@@ -22,19 +28,53 @@ import imageRetrievalPoolManager from './requestPool/imageRetrievalPoolManager';
 import imageLoadPoolManager from './requestPool/imageLoadPoolManager';
 import getEnabledElement, { getEnabledElementByIds, getEnabledElementByViewportId, getEnabledElements, } from './getEnabledElement';
 import * as metaData from './metaData';
-import { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, } from './init';
+import { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, } from './init';
 import Settings from './Settings';
 import * as volumeLoader from './loaders/volumeLoader';
 import * as imageLoader from './loaders/imageLoader';
 import * as geometryLoader from './loaders/geometryLoader';
 import ProgressiveRetrieveImages from './loaders/ProgressiveRetrieveImages';
 import { decimatedVolumeLoader } from './loaders/decimatedVolumeLoader';
+import { ActorRenderMode } from './types';
 import * as utilities from './utilities';
 import { registerImageLoader } from './loaders/imageLoader';
 import triggerEvent from './utilities/triggerEvent';
+import { convertColorArrayToRgbString } from './utilities/convertColorArrayToRgbString';
 import { cornerstoneStreamingImageVolumeLoader } from './loaders/cornerstoneStreamingImageVolumeLoader';
 import { cornerstoneStreamingDynamicImageVolumeLoader } from './loaders/cornerstoneStreamingDynamicImageVolumeLoader';
 import { cornerstoneMeshLoader } from './loaders/cornerstoneMeshLoader';
-import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, } from './RenderingEngine/helpers';
+import { setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, getProjectionScaleMatrix, } from './RenderingEngine/helpers';
+import { registerViewportType, isRegisteredViewportType, } from './RenderingEngine/helpers/viewportTypeToViewportClass';
 export * from './loaders/decimatedVolumeLoader';
-export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, VolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };
+const renderingEngineExportsV2 = {
+    GenericViewport,
+    DefaultRenderPathResolver,
+    defaultRenderPathResolver,
+    ECGGenericViewport,
+    createDefaultECGRenderPaths,
+    createECGRenderPathResolver,
+    DefaultECGDataProvider,
+    ecgProjection,
+    VideoGenericViewport,
+    createDefaultVideoRenderPaths,
+    createVideoRenderPathResolver,
+    DefaultVideoDataProvider,
+    videoProjection,
+    PlanarViewport,
+    createDefaultPlanarRenderPaths,
+    createPlanarRenderPathResolver,
+    DefaultPlanarDataProvider,
+    planarProjection,
+    VolumeViewport3D: GenericVolumeViewport3D,
+    createDefaultVolume3DRenderPaths,
+    createVolume3DRenderPathResolver,
+    DefaultVolume3DDataProvider,
+    volume3DProjection,
+    WSIGenericViewport,
+    createDefaultWSIRenderPaths,
+    createWSIRenderPathResolver,
+    DefaultWSIDataProvider,
+    wsiProjection,
+};
+const LegacyVolumeViewport3D = VolumeViewport3D;
+export { init, isCornerstoneInitialized, peerImport, resetInitialization, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, Enums, CONSTANTS, Events as EVENTS, Settings, BaseVolumeViewport, VolumeViewport, LegacyVolumeViewport3D, VolumeViewport3D, GenericVolumeViewport3D, Viewport, StackViewport, VideoViewport, WSIViewport, ECGViewport, ECGGenericViewport, GenericViewport, ViewportProjectionService, viewportProjection, viewportHasCanvasWorldTransform, viewportHasFrameOfReferenceUID, viewportHasPan, viewportHasZoom, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, ImageVolume, Surface, getRenderingEngine, getRenderingEngines, getEnabledElement, getEnabledElementByIds, getEnabledElements, getEnabledElementByViewportId, createVolumeActor, createVolumeMapper, cache, eventTarget, triggerEvent, convertColorArrayToRgbString, imageLoader, registerImageLoader, volumeLoader, metaData, utilities, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, DefaultRenderPathResolver, defaultRenderPathResolver, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, getProjectionScaleMatrix, registerViewportType, isRegisteredViewportType, imageLoadPoolManager as requestPoolManager, imageRetrievalPoolManager, imageLoadPoolManager, getShouldUseCPURendering, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getUseGenericViewport, geometryLoader, cornerstoneMeshLoader, ProgressiveRetrieveImages, decimatedVolumeLoader, ActorRenderMode, cornerstoneStreamingImageVolumeLoader, cornerstoneStreamingDynamicImageVolumeLoader, StreamingDynamicImageVolume, StreamingImageVolume, convertMapperToNotSharedMapper, version, };

package/dist/esm/init.d.ts

@@ -7,10 +7,11 @@ declare function setPreferSizeOverAccuracy(status: boolean): void;
 declare function canRenderFloatTextures(): boolean;
 declare function resetUseCPURendering(): void;
 declare function getShouldUseCPURendering(): boolean;
+declare function getUseGenericViewport(): boolean;
 declare function isCornerstoneInitialized(): boolean;
 declare function resetInitialization(): void;
 declare function getConfiguration(): Cornerstone3DConfig;
 declare function setConfiguration(c: Cornerstone3DConfig): void;
 declare function getWebWorkerManager(): CentralizedWebWorkerManager;
 declare function peerImport(moduleId: string): Promise<any>;
-export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };
+export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/init.js

@@ -14,6 +14,16 @@ const defaultConfig = {
         strictZSpacingForVolumeViewport: true,
         renderingEngineMode: RenderingEngineModeEnum.ContextPool,
         webGlContextCount: 7,
+        planar: {
+            cpuThresholds: {
+                image: 64 * 1024 * 1024,
+                volume: 64 * 1024 * 1024,
+            },
+            cpuVolume: {
+                useViewportSamplingForLinear: true,
+                volumeModifiedThrottleMs: 5000,
+            },
+        },
         volumeRendering: {
             sampleDistanceMultiplier: 1,
         },
@@ -113,6 +123,9 @@ function resetUseCPURendering() {
 function getShouldUseCPURendering() {
     return config.rendering.useCPURendering;
 }
+function getUseGenericViewport() {
+    return config.rendering.useGenericViewport === true;
+}
 function isCornerstoneInitialized() {
     return csRenderInitialized;
 }
@@ -142,4 +155,4 @@ function getWebWorkerManager() {
 async function peerImport(moduleId) {
     return config.peerImport(moduleId);
 }
-export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };
+export { init, getShouldUseCPURendering, getUseGenericViewport, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/loaders/ProgressiveRetrieveImages.js

@@ -12,16 +12,6 @@ import eventTarget from '../eventTarget';
 import { fillNearbyFrames } from './fillNearbyFrames';
 export { sequentialRetrieveStages, interleavedRetrieveStages, singleRetrieveStages, };
 export class ProgressiveRetrieveImages {
-    static { this.createProgressive = createProgressive; }
-    static { this.interleavedRetrieveStages = {
-        stages: interleavedRetrieveStages,
-    }; }
-    static { this.singleRetrieveStages = {
-        stages: singleRetrieveStages,
-    }; }
-    static { this.sequentialRetrieveStages = {
-        stages: sequentialRetrieveStages,
-    }; }
     constructor(imageRetrieveConfiguration) {
         this.stages = imageRetrieveConfiguration.stages || singleRetrieveStages;
         this.retrieveOptions = imageRetrieveConfiguration.retrieveOptions || {};
@@ -31,6 +21,16 @@ export class ProgressiveRetrieveImages {
         return instance.loadImages();
     }
 }
+ProgressiveRetrieveImages.createProgressive = createProgressive;
+ProgressiveRetrieveImages.interleavedRetrieveStages = {
+    stages: interleavedRetrieveStages,
+};
+ProgressiveRetrieveImages.singleRetrieveStages = {
+    stages: singleRetrieveStages,
+};
+ProgressiveRetrieveImages.sequentialRetrieveStages = {
+    stages: sequentialRetrieveStages,
+};
 class ProgressiveRetrieveImagesInstance {
     constructor(configuration, imageIds, listener) {
         this.outstandingRequests = 0;
@@ -85,7 +85,7 @@ class ProgressiveRetrieveImagesInstance {
         }, errorCallback)
             .finally(() => {
             if (!complete && next) {
-                cache.setPartialImage(imageId);
+                cache.setPartialImage(imageId, undefined, true);
                 this.addRequest(next, options.streamingData);
             }
             else {

package/dist/esm/loaders/cornerstoneMeshLoader.js

@@ -1,7 +1,7 @@
 import { createMesh } from './utils/mesh/createMesh';
 import { Events } from '../enums';
 import eventTarget from '../eventTarget';
-import { triggerEvent } from '../utilities';
+import triggerEvent from '../utilities/triggerEvent';
 function fetchArrayBuffer({ url, signal, onload, loaderOptions, }) {
     return new Promise(async (resolve, reject) => {
         const xhr = new XMLHttpRequest();

package/dist/esm/loaders/imageLoader.d.ts

@@ -1,10 +1,11 @@
-import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray } from '../types';
+import type { IImage, ImageLoaderFn, Point2, Point3, Mat3, PixelDataTypedArrayString, PixelDataTypedArray, RetrieveOptions } from '../types';
 import VoxelManagerEnum from '../enums/VoxelManagerEnum';
 export interface ImageLoaderOptions {
     priority: number;
     requestType: string;
     additionalDetails?: Record<string, unknown>;
     ignoreCache?: boolean;
+    retrieveOptions?: RetrieveOptions;
 }
 interface LocalImageOptions {
     frameOfReferenceUID?: string;

package/dist/esm/loaders/imageLoader.js

@@ -1,5 +1,7 @@
 import cache from '../cache/cache';
 import Events from '../enums/Events';
+import MetadataModules from '../enums/MetadataModules';
+import { ImageQualityStatus } from '../enums';
 import eventTarget from '../eventTarget';
 import genericMetadataProvider from '../utilities/genericMetadataProvider';
 import { getBufferConfiguration } from '../utilities/getBufferConfiguration';
@@ -11,12 +13,25 @@ import * as metaData from '../metaData';
 import VoxelManagerEnum from '../enums/VoxelManagerEnum';
 const imageLoaders = {};
 let unknownImageLoader;
+function getRequestedImageQualityStatus(options) {
+    return (options.retrieveOptions?.imageQualityStatus ??
+        ImageQualityStatus.FULL_RESOLUTION);
+}
 function loadImageFromImageLoader(imageId, options) {
-    const cachedImageLoadObject = cache.getImageLoadObject(imageId);
+    const cachedImageLoadObject = !options.ignoreCache && cache.getImageLoadObject(imageId);
     if (cachedImageLoadObject) {
         handleImageLoadPromise(cachedImageLoadObject.promise, imageId);
         return cachedImageLoadObject;
     }
+    const cachedImage = !options.ignoreCache &&
+        cache.getImage(imageId, getRequestedImageQualityStatus(options));
+    if (cachedImage) {
+        const imageLoadObject = {
+            promise: Promise.resolve(cachedImage),
+        };
+        handleImageLoadPromise(imageLoadObject.promise, imageId);
+        return imageLoadObject;
+    }
     const scheme = imageId.split(':')[0];
     const loader = imageLoaders[scheme] || unknownImageLoader;
     if (!loader) {
@@ -87,30 +102,30 @@ export function createAndCacheDerivedImage(referencedImageId, options = {}) {
         options.imageId = `derived:${uuidv4()}`;
     }
     const { imageId, skipCreateBuffer, onCacheAdd, voxelRepresentation } = options;
-    const imagePlaneModule = metaData.get('imagePlaneModule', referencedImageId);
+    const imagePlaneModule = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
     const length = imagePlaneModule.rows * imagePlaneModule.columns;
     const { TypedArrayConstructor } = getBufferConfiguration(options.targetBuffer?.type, length);
     const imageScalarData = new TypedArrayConstructor(skipCreateBuffer ? 1 : length);
     const derivedImageId = imageId;
-    const referencedImagePlaneMetadata = metaData.get('imagePlaneModule', referencedImageId);
+    const referencedImagePlaneMetadata = metaData.get(MetadataModules.IMAGE_PLANE, referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
-        type: 'imagePlaneModule',
+        type: MetadataModules.IMAGE_PLANE,
         metadata: referencedImagePlaneMetadata,
     });
-    const referencedImageGeneralSeriesMetadata = metaData.get('generalSeriesModule', referencedImageId);
+    const referencedImageGeneralSeriesMetadata = metaData.get(MetadataModules.GENERAL_SERIES, referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
-        type: 'generalSeriesModule',
+        type: MetadataModules.GENERAL_SERIES,
         metadata: referencedImageGeneralSeriesMetadata,
     });
     genericMetadataProvider.add(derivedImageId, {
-        type: 'generalImageModule',
+        type: MetadataModules.GENERAL_IMAGE,
         metadata: {
             instanceNumber: options.instanceNumber,
         },
     });
-    const imagePixelModule = metaData.get('imagePixelModule', referencedImageId);
+    const imagePixelModule = metaData.get(MetadataModules.IMAGE_PIXEL, referencedImageId);
     genericMetadataProvider.add(derivedImageId, {
-        type: 'imagePixelModule',
+        type: MetadataModules.IMAGE_PIXEL,
         metadata: {
             ...imagePixelModule,
             bitsAllocated: 8,
@@ -242,7 +257,7 @@ export function createAndCacheLocalImage(imageId, options) {
         imagePlaneModule,
         imagePixelModule,
     };
-    ['imagePlaneModule', 'imagePixelModule'].forEach((type) => {
+    [MetadataModules.IMAGE_PLANE, MetadataModules.IMAGE_PIXEL].forEach((type) => {
         genericMetadataProvider.add(imageId, {
             type,
             metadata: metadata[type] || {},

package/dist/esm/loaders/volumeLoader.js

@@ -4,6 +4,7 @@ import cache from '../cache/cache';
 import Events from '../enums/Events';
 import eventTarget from '../eventTarget';
 import triggerEvent from '../utilities/triggerEvent';
+import { deepClone } from '../utilities/deepClone';
 import uuidv4 from '../utilities/uuidv4';
 import VoxelManager from '../utilities/VoxelManager';
 import { createAndCacheLocalImage, createAndCacheDerivedImages, } from './imageLoader';
@@ -82,7 +83,7 @@ export function createAndCacheDerivedVolume(referencedVolumeId, options) {
     const derivedVolume = new ImageVolume({
         volumeId,
         dataType,
-        metadata: structuredClone(metadata),
+        metadata: deepClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
@@ -129,7 +130,7 @@ export function createAndCacheVolumeFromImagesSync(volumeId, imageIds) {
     const derivedVolume = new ImageVolume({
         volumeId,
         dataType: volumeProps.dataType,
-        metadata: structuredClone(volumeProps.metadata),
+        metadata: deepClone(volumeProps.metadata),
         dimensions: volumeProps.dimensions,
         spacing: volumeProps.spacing,
         origin: volumeProps.origin,
@@ -142,7 +143,7 @@ export function createAndCacheVolumeFromImagesSync(volumeId, imageIds) {
     return derivedVolume;
 }
 export function createLocalVolume(volumeId, options = {}) {
-    const { metadata, dimensions, spacing, origin, direction, scalarData, targetBuffer, preventCache = false, } = options;
+    const { metadata, dimensions, spacing, origin, direction, scalarData, referencedImageIds, referencedVolumeId, targetBuffer, preventCache = false, } = options;
     const cachedVolume = cache.getVolume(volumeId);
     if (cachedVolume) {
         return cachedVolume;
@@ -182,19 +183,22 @@ export function createLocalVolume(volumeId, options = {}) {
             spacing: [spacing[0], spacing[1]],
             origin,
             direction,
+            referencedImageId: referencedImageIds?.[i],
             targetBuffer: { type: dataType },
         });
         derivedImages.push(derivedImage);
     }
     const imageVolume = new ImageVolume({
         volumeId,
-        metadata: structuredClone(metadata),
+        metadata: deepClone(metadata),
         dimensions: [dimensions[0], dimensions[1], dimensions[2]],
         spacing,
         origin,
         direction,
         imageIds,
         dataType,
+        referencedVolumeId,
+        referencedImageIds,
     });
     const voxelManager = VoxelManager.createImageVolumeVoxelManager({
         imageIds,

package/dist/esm/metaData.d.ts

@@ -1,8 +1,2 @@
-export declare function addProvider(provider: (type: string, ...query: string[]) => unknown, priority?: number): void;
-export declare function removeProvider(provider: (type: string, query: unknown) => unknown): void;
-export declare function removeAllProviders(): void;
-declare function getMetaData(type: string, ...queries: any[]): any;
-export declare function getNormalized(imageId: string, types: string[], metaDataProvider?: typeof getMetaData): {};
-export declare const toUpperCamelTag: (tag: string) => string;
-export declare const toLowerCamelTag: (tag: string) => string;
-export { getMetaData as get };
+import { metaData } from '@cornerstonejs/metadata';
+export declare const addProvider: typeof metaData.addProvider, removeProvider: typeof metaData.removeProvider, removeAllProviders: typeof metaData.removeAllProviders, getMetaData: typeof metaData.getMetaData, getTyped: typeof metaData.getTyped, get: (type: string, ...queries: string[]) => any, getNormalized: typeof metaData.getNormalized, toUpperCamelTag: (tag: string) => string, toLowerCamelTag: (tag: string) => string;