@cornerstonejs/dicom-image-loader 2.0.0-beta.20 → 2.0.0-beta.21

package/dist/esm/src/imageLoader/wadouri/metaData/metaDataProvider.js

@@ -11,6 +11,7 @@ import multiframeDataset from '../retrieveMultiframeDataset';
 import { getImageTypeSubItemFromDataset, extractOrientationFromDataset, extractPositionFromDataset, extractSpacingFromDataset, extractSliceThicknessFromDataset, } from './extractPositioningFromDataset';
 import isNMReconstructable from '../../isNMReconstructable';
 import { getInstanceModule, instanceModuleNames, } from '../../getInstanceModule';
+import { getUSEnhancedRegions } from './USHelpers';
 function metaDataProvider(type, imageId) {
     const { MetadataModules } = external.cornerstone.Enums;
     const { dicomParser } = external;
@@ -203,6 +204,18 @@ function metaDataProvider(type, imageId) {
             actualFrameDuration: dataSet.intString(dataSet.string('x00181242')),
         };
     }
+    if (type === MetadataModules.ULTRASOUND_ENHANCED_REGION) {
+        return getUSEnhancedRegions(dataSet);
+    }
+    if (type === MetadataModules.CALIBRATION) {
+        const modality = dataSet.string('x00080060');
+        if (modality === 'US') {
+            const enhancedRegion = getUSEnhancedRegions(dataSet);
+            return {
+                sequenceOfUltrasoundRegions: enhancedRegion,
+            };
+        }
+    }
     if (type === 'instance') {
         return getInstanceModule(imageId, metaDataProvider, instanceModuleNames);
     }

package/dist/esm/src/imageLoader/wadouri/register.d.ts

@@ -1,2 +1,2 @@
-import * as cornerstoneImport from '@cornerstonejs/core';
+import type * as cornerstoneImport from '@cornerstonejs/core';
 export default function (cornerstone: typeof cornerstoneImport): void;

package/dist/esm/src/imageLoader/wadouri/retrieveMultiframeDataset.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="dicom-parser" />
 declare function _get(uri: any): {
     dataSet: import("dicom-parser").DataSet;
     cacheCount: number;

package/dist/esm/src/imageLoader/wadouri/unpackBinaryFrame.d.ts

@@ -1,3 +1,3 @@
-import { ByteArray } from 'dicom-parser';
+import type { ByteArray } from 'dicom-parser';
 declare function unpackBinaryFrame(byteArray: ByteArray, frameOffset: number, pixelsPerFrame: number): Uint8Array;
 export default unpackBinaryFrame;

package/dist/esm/src/shared/decoders/decodeBigEndian.d.ts

@@ -1,4 +1,4 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame } from '../../types';
-declare function decodeBigEndian(imageFrame: ImageFrame, pixelData: ByteArray): Promise<ImageFrame>;
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core/src';
+declare function decodeBigEndian(imageFrame: Types.IImageFrame, pixelData: ByteArray): Promise<Types.IImageFrame>;
 export default decodeBigEndian;

package/dist/esm/src/shared/decoders/decodeHTJ2K.d.ts

@@ -1,5 +1,5 @@
-import { ByteArray } from 'dicom-parser';
-import { LoaderDecodeOptions } from '../../types';
+import type { ByteArray } from 'dicom-parser';
+import type { LoaderDecodeOptions } from '../../types';
 export declare function initialize(decodeConfig?: LoaderDecodeOptions): Promise<void>;
 declare function decodeAsync(compressedImageFrame: ByteArray, imageInfo: any): Promise<any>;
 export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEG2000.d.ts

@@ -1,4 +1,5 @@
-import { ImageFrame, WebWorkerDecodeConfig } from '../../types';
+import type { Types } from '@cornerstonejs/core/src';
+import type { WebWorkerDecodeConfig } from '../../types';
 export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
-declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<ImageFrame>;
+declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<Types.IImageFrame>;
 export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-js.d.ts

@@ -1,5 +1,6 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame, WebWorkerDecodeConfig } from '../../types';
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core/src';
+import type { WebWorkerDecodeConfig } from '../../types';
 export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
-declare function decodeJPEGBaseline12BitAsync(imageFrame: ImageFrame, pixelData: ByteArray): Promise<ImageFrame>;
+declare function decodeJPEGBaseline12BitAsync(imageFrame: Types.IImageFrame, pixelData: ByteArray): Promise<Types.IImageFrame>;
 export default decodeJPEGBaseline12BitAsync;

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-wasm-not-yet-working.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/src/shared/decoders/decodeJPEGBaseline12Bit-wasm-not-yet-working.js

@@ -1 +1 @@
-"use strict";
+export {};

package/dist/esm/src/shared/decoders/decodeJPEGBaseline8Bit.d.ts

@@ -1,3 +1,3 @@
-import { ImageFrame } from '../../types';
-declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<ImageFrame>;
+import type { Types } from '@cornerstonejs/core/src';
+declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<Types.IImageFrame>;
 export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGLS.d.ts

@@ -1,4 +1,5 @@
-import { ImageFrame, WebWorkerDecodeConfig } from '../../types';
+import type { WebWorkerDecodeConfig } from '../../types';
+import type { Types } from '@cornerstonejs/core/src';
 export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
-declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<ImageFrame>;
+declare function decodeAsync(compressedImageFrame: any, imageInfo: any): Promise<Types.IImageFrame>;
 export default decodeAsync;

package/dist/esm/src/shared/decoders/decodeJPEGLossless.d.ts

@@ -1,5 +1,6 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame, WebWorkerDecodeConfig } from '../../types';
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core/src';
+import type { WebWorkerDecodeConfig } from '../../types';
 export declare function initialize(decodeConfig?: WebWorkerDecodeConfig): Promise<void>;
-declare function decodeJPEGLossless(imageFrame: ImageFrame, pixelData: ByteArray): Promise<ImageFrame>;
+declare function decodeJPEGLossless(imageFrame: Types.IImageFrame, pixelData: ByteArray): Promise<Types.IImageFrame>;
 export default decodeJPEGLossless;

package/dist/esm/src/shared/decoders/decodeLittleEndian.d.ts

@@ -1,4 +1,4 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame } from '../../types';
-declare function decodeLittleEndian(imageFrame: ImageFrame, pixelData: ByteArray): Promise<ImageFrame>;
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+declare function decodeLittleEndian(imageFrame: Types.IImageFrame, pixelData: ByteArray): Promise<Types.IImageFrame>;
 export default decodeLittleEndian;

package/dist/esm/src/shared/decoders/decodeRLE.d.ts

@@ -1,4 +1,4 @@
-import { ByteArray } from 'dicom-parser';
-import { ImageFrame } from '../../types';
-declare function decodeRLE(imageFrame: ImageFrame, pixelData: ByteArray): Promise<ImageFrame>;
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+declare function decodeRLE(imageFrame: Types.IImageFrame, pixelData: ByteArray): Promise<Types.IImageFrame>;
 export default decodeRLE;

package/dist/esm/src/shared/getMinMax.d.ts

@@ -1,5 +1,5 @@
-import { PixelDataTypedArray } from '../types';
-declare function getMinMax(storedPixelData: PixelDataTypedArray): {
+import type { Types } from '@cornerstonejs/core';
+declare function getMinMax(storedPixelData: Types.PixelDataTypedArray): {
     min: number;
     max: number;
 };

package/dist/esm/src/shared/getPixelDataTypeFromMinMax.d.ts

@@ -1,2 +1,2 @@
-import { PixelDataTypedArray } from '../types';
-export default function getPixelDataTypeFromMinMax(min: number, max: number): PixelDataTypedArray;
+import type { Types } from '@cornerstonejs/core';
+export default function getPixelDataTypeFromMinMax(min: number, max: number): Types.PixelDataTypedArray;

package/dist/esm/src/shared/scaling/scaleArray.d.ts

@@ -1,2 +1,2 @@
-import { PixelDataTypedArray } from '../../types';
-export default function scaleArray(array: PixelDataTypedArray, scalingParameters: any): boolean;
+import type { Types } from '@cornerstonejs/core';
+export default function scaleArray(array: Types.PixelDataTypedArray, scalingParameters: any): boolean;

package/dist/esm/src/types/DICOMLoaderDataSetWithFetchMore.d.ts

@@ -1,4 +1,4 @@
-import { DataSet } from 'dicom-parser';
+import type { DataSet } from 'dicom-parser';
 export interface DICOMLoaderDataSetWithFetchMore extends DataSet {
     fetchMore?: (fetchOptions: {
         uri: string;

package/dist/esm/src/types/DICOMLoaderIImage.d.ts

@@ -1,13 +1,12 @@
-import { Types } from '@cornerstonejs/core';
-import { ByteArray, DataSet } from 'dicom-parser';
-import ImageFrame from './ImageFrame';
+import type { Types } from '@cornerstonejs/core';
+import type { ByteArray, DataSet } from 'dicom-parser';
 export interface DICOMLoaderIImage extends Types.IImage {
     decodeTimeInMS: number;
     floatPixelData?: ByteArray | Float32Array;
     loadTimeInMS?: number;
     totalTimeInMS?: number;
     data?: DataSet;
-    imageFrame?: ImageFrame;
+    imageFrame?: Types.IImageFrame;
     voiLUTFunction: string | undefined;
     transferSyntaxUID?: string;
 }

package/dist/esm/src/types/DICOMLoaderImageOptions.d.ts

@@ -1,24 +1,21 @@
-import { Types } from '@cornerstonejs/core';
-import { LoadRequestFunction } from './LoadRequestFunction';
-import { StreamingData } from '../imageLoader/wadors/loadImage';
+import type { Types } from '@cornerstonejs/core';
+import type { LoadRequestFunction } from './LoadRequestFunction';
+import type { StreamingData } from '../imageLoader/wadors/loadImage';
 export interface DICOMLoaderImageOptions {
     useRGBA?: boolean;
-    useNativeDataType?: boolean;
     allowFloatRendering?: boolean;
-    skipCreateImage?: boolean;
     preScale?: {
         enabled: boolean;
         scalingParameters?: Types.ScalingParameters;
     };
     targetBuffer?: {
-        type: 'Uint8Array' | 'Uint16Array' | 'Int16Array' | 'Float32Array';
+        type: Types.PixelDataTypedArrayString;
         arrayBuffer: ArrayBufferLike;
         length: number;
         offset: number;
         rows?: number;
         columns?: number;
     };
-    isSharedArrayBuffer?: boolean;
     loader?: LoadRequestFunction;
     decodeLevel?: number;
     retrieveOptions?: Types.RetrieveOptions;

package/dist/esm/src/types/LoadRequestFunction.d.ts

@@ -1 +1 @@
-export type LoadRequestFunction = (url: string, imageId: string, ...args: any[]) => Promise<ArrayBuffer>;
+export type LoadRequestFunction = (url: string, imageId: string, ...args: unknown[]) => Promise<ArrayBuffer>;

package/dist/esm/src/types/LoaderDecodeOptions.d.ts

@@ -1,4 +1,2 @@
 export interface LoaderDecodeOptions {
-    convertFloatPixelDataToInt?: boolean;
-    use16BitDataType?: boolean;
 }

package/dist/esm/src/types/LoaderOptions.d.ts

@@ -1,17 +1,17 @@
-import { LoaderDecodeOptions } from './LoaderDecodeOptions';
-import { LoaderXhrRequestError, LoaderXhrRequestParams } from './XHRRequest';
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
+import type { LoaderXhrRequestError, LoaderXhrRequestParams } from './XHRRequest';
 export interface LoaderOptions {
-    cornerstone?: any;
-    dicomParser?: any;
+    cornerstone?: unknown;
+    dicomParser?: unknown;
     maxWebWorkers?: number;
     open?: (xhr: XMLHttpRequest, url: string, defaultHeaders: Record<string, string>, params: LoaderXhrRequestParams) => void;
     beforeSend?: (xhr: XMLHttpRequest, imageId: string, defaultHeaders: Record<string, string>, params: LoaderXhrRequestParams) => Record<string, string> | void;
     beforeProcessing?: (xhr: XMLHttpRequest) => Promise<ArrayBuffer>;
-    imageCreated?: (...args: any[]) => void;
-    onloadstart?: (event: ProgressEvent<EventTarget>, params: any) => void;
-    onloadend?: (event: ProgressEvent<EventTarget>, params: any) => void;
-    onreadystatechange?: (event: Event, params: any) => void;
-    onprogress?: (event: ProgressEvent<EventTarget>, params: any) => void;
+    imageCreated?: (imageObject: unknown) => void;
+    onloadstart?: (event: ProgressEvent<EventTarget>, params: unknown) => void;
+    onloadend?: (event: ProgressEvent<EventTarget>, params: unknown) => void;
+    onreadystatechange?: (event: Event, params: unknown) => void;
+    onprogress?: (event: ProgressEvent<EventTarget>, params: unknown) => void;
     errorInterceptor?: (error: LoaderXhrRequestError) => void;
     strict?: boolean;
     decodeConfig?: LoaderDecodeOptions;

package/dist/esm/src/types/WebWorkerTypes.d.ts

@@ -1,7 +1,7 @@
-import { ByteArray } from 'dicom-parser';
-import ImageFrame from './ImageFrame';
-import { LoaderOptions } from './LoaderOptions';
-import { LoaderDecodeOptions } from './LoaderDecodeOptions';
+import type { ByteArray } from 'dicom-parser';
+import type { Types } from '@cornerstonejs/core';
+import type { LoaderOptions } from './LoaderOptions';
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
 export interface WebWorkerOptions {
     maxWebWorkers?: number;
     startWebWorkersOnDemand?: boolean;
@@ -15,7 +15,7 @@ export interface WebWorkerDecodeConfig {
 export interface WebWorkerTaskOptions {
     decodeTask: WebWorkerDecodeConfig;
 }
-export interface WebWorkerDeferredObject<T = any> {
+export interface WebWorkerDeferredObject<T = unknown> {
     resolve: (arg: T | PromiseLike<T>) => void;
     reject: (err: any) => void;
 }
@@ -32,7 +32,7 @@ export interface WorkerTask {
     transferList: Transferable[];
 }
 export interface WebWorkerDecodeTaskData {
-    imageFrame: ImageFrame;
+    imageFrame: Types.IImageFrame;
     transferSyntax: string;
     pixelData: ByteArray;
     options: LoaderOptions;
@@ -59,6 +59,6 @@ export interface WebWorkerResponse {
     taskType: WorkerTaskTypes;
     status: 'failed' | 'success';
     workerIndex: number;
-    data?: ImageFrame;
-    result: string | ImageFrame;
+    data?: Types.IImageFrame;
+    result: string | Types.IImageFrame;
 }

package/dist/esm/src/types/XHRRequest.d.ts

@@ -1,13 +1,13 @@
 export interface LoaderXhrRequestError extends Error {
     request: XMLHttpRequest;
-    response: any;
+    response: unknown;
     status: number;
 }
 export interface LoaderXhrRequestParams {
     url?: string;
     deferred?: {
         resolve: (value: ArrayBuffer | PromiseLike<ArrayBuffer>) => void;
-        reject: (reason?: any) => void;
+        reject: (reason: any) => void;
     };
     imageId?: string;
 }

package/dist/esm/src/types/index.d.ts

@@ -1,14 +1,11 @@
-import ImageFrame from './ImageFrame';
-import PixelDataTypedArray from './PixelDataTypedArray';
-import { LoaderXhrRequestError, LoaderXhrRequestParams, LoaderXhrRequestPromise } from './XHRRequest';
-import { WADORSMetaData, WADORSMetaDataElement } from './WADORSMetaData';
-import { LoaderOptions } from './LoaderOptions';
-import { LoaderDecodeOptions } from './LoaderDecodeOptions';
-import { DICOMLoaderIImage } from './DICOMLoaderIImage';
-import { DICOMLoaderImageOptions } from './DICOMLoaderImageOptions';
-import { LutType } from './LutType';
-import { LoadRequestFunction } from './LoadRequestFunction';
-import { DICOMLoaderDataSetWithFetchMore } from './DICOMLoaderDataSetWithFetchMore';
-import { MetaDataTypes, MetadataGeneralSeriesModule, MetadataImagePixelModule, MetadataImagePlaneModule, MetadataPatientStudyModule, MetadataSopCommonModule, MetadataTransferSyntax, DicomDateObject, DicomTimeObject } from './MetadataModules';
-import { WebWorkerOptions, WebWorkerDecodeConfig, WebWorkerTaskOptions, WorkerTaskTypes, WorkerTask, WebWorkerDecodeTaskData, WebWorkerDecodeData, WebWorkerLoadData, WebWorkerInitializeData, WebWorkerData, WebWorkerResponse, WebWorkerDeferredObject } from './WebWorkerTypes';
-export { ImageFrame, LoaderDecodeOptions, LoaderOptions, WADORSMetaData, WADORSMetaDataElement, LoaderXhrRequestError, LoaderXhrRequestParams, LoaderXhrRequestPromise, DICOMLoaderIImage, DICOMLoaderImageOptions, MetaDataTypes, MetadataGeneralSeriesModule, MetadataImagePixelModule, MetadataImagePlaneModule, MetadataPatientStudyModule, MetadataSopCommonModule, MetadataTransferSyntax, DicomDateObject, DicomTimeObject, LutType, WebWorkerOptions, WebWorkerDecodeConfig, WebWorkerTaskOptions, WorkerTaskTypes, WorkerTask, WebWorkerDecodeTaskData, WebWorkerDecodeData, WebWorkerLoadData, WebWorkerInitializeData, WebWorkerData, WebWorkerResponse, WebWorkerDeferredObject, LoadRequestFunction, DICOMLoaderDataSetWithFetchMore, PixelDataTypedArray, };
+import type { LoaderXhrRequestError, LoaderXhrRequestParams, LoaderXhrRequestPromise } from './XHRRequest';
+import type { WADORSMetaData, WADORSMetaDataElement } from './WADORSMetaData';
+import type { LoaderOptions } from './LoaderOptions';
+import type { LoaderDecodeOptions } from './LoaderDecodeOptions';
+import type { DICOMLoaderIImage } from './DICOMLoaderIImage';
+import type { DICOMLoaderImageOptions } from './DICOMLoaderImageOptions';
+import type { LutType } from './LutType';
+import type { LoadRequestFunction } from './LoadRequestFunction';
+import type { DICOMLoaderDataSetWithFetchMore } from './DICOMLoaderDataSetWithFetchMore';
+import type { WebWorkerOptions, WebWorkerDecodeConfig, WebWorkerTaskOptions, WorkerTaskTypes, WorkerTask, WebWorkerDecodeTaskData, WebWorkerDecodeData, WebWorkerLoadData, WebWorkerInitializeData, WebWorkerData, WebWorkerResponse, WebWorkerDeferredObject } from './WebWorkerTypes';
+export type { LoaderDecodeOptions, LoaderOptions, WADORSMetaData, WADORSMetaDataElement, LoaderXhrRequestError, LoaderXhrRequestParams, LoaderXhrRequestPromise, DICOMLoaderIImage, DICOMLoaderImageOptions, LutType, WebWorkerOptions, WebWorkerDecodeConfig, WebWorkerTaskOptions, WorkerTaskTypes, WorkerTask, WebWorkerDecodeTaskData, WebWorkerDecodeData, WebWorkerLoadData, WebWorkerInitializeData, WebWorkerData, WebWorkerResponse, WebWorkerDeferredObject, LoadRequestFunction, DICOMLoaderDataSetWithFetchMore, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/dicom-image-loader",
-  "version": "2.0.0-beta.20",
+  "version": "2.0.0-beta.21",
   "description": "Cornerstone Image Loader for DICOM WADO-URI and WADO-RS and Local file",
   "keywords": [
     "DICOM",
@@ -40,17 +40,18 @@
     "build:umd:dynamic": "cross-env NODE_ENV=production webpack --config .webpack/webpack-dynamic-import.js",
     "build:umd:bundle": "cross-env NODE_ENV=production webpack --config .webpack/webpack-bundle.js",
     "build:all": "yarn run build:umd:dynamic & yarn run build:umd:bundle && yarn run build:esm",
+    "build:update-api": "echo 'not implemented yet'",
     "copy-dts": "echo 'not implemented yet'",
     "clean": "shx rm -rf dist",
     "clean:deep": "yarn run clean && shx rm -rf node_modules",
     "api-check": "echo 'not implemented yet'",
-    "build:update-api": "echo 'not implemented yet'",
     "cm": "npx git-cz",
     "clean:dist": "shx rm -rf dist",
     "clean:docs": "shx rm -rf documentation",
     "clean:coverage": "shx rm -rf coverage",
     "doc": "npm run doc:generate && opn documentation/index.html",
     "doc:generate": "npm run clean:docs && jsdoc -c .jsdocrc",
+    "dev": "tsc --project ./tsconfig.esm.json --watch",
     "eslint": "eslint -c .eslintrc.js src",
     "eslint-quiet": "eslint -c .eslintrc.js --quiet src",
     "eslint-fix": "eslint -c .eslintrc.js --fix src",
@@ -64,7 +65,6 @@
     "test:firefox": "karma start config/karma/karma-firefox.js",
     "test:watch": "karma start config/karma/karma-watch.js",
     "watch": "npm run clean && shx mkdir dist && npm run webpack:watch",
-    "dev": "npm run webpack:dev",
     "webpack:dev": "webpack serve --progress --config .webpack/webpack-dev.js",
     "webpack:dynamic-import": "webpack --progress --config .webpack/webpack-dynamic-import",
     "webpack:bundle": "webpack --progress --config .webpack/webpack-bundle",
@@ -83,11 +83,6 @@
     "pako": "^2.0.4",
     "uuid": "^9.0.0"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged"
-    }
-  },
   "lint-staged": {
     "src/**/*.{js,jsx,json,css}": [
       "eslint --fix",
@@ -100,5 +95,5 @@
       "path": "./node_modules/cz-conventional-changelog"
     }
   },
-  "gitHead": "7606aa14c5a072bc63b24d82cbe347eb80cf5c6a"
+  "gitHead": "de2d08d4edbae4ca48831cc44a57737717b10b22"
 }

package/dist/esm/src/shared/calculateMinMax.d.ts

@@ -1,2 +0,0 @@
-import { ImageFrame } from '../types';
-export default function calculateMinMax(imageFrame: ImageFrame, strict?: boolean): void;

package/dist/esm/src/shared/calculateMinMax.js

@@ -1,24 +0,0 @@
-import getMinMax from './getMinMax';
-export default function calculateMinMax(imageFrame, strict = true) {
-    const minMax = imageFrame.minAfterScale !== undefined ||
-        imageFrame.maxAfterScale !== undefined
-        ? { min: imageFrame.minAfterScale, max: imageFrame.maxAfterScale }
-        : getMinMax(imageFrame.pixelData);
-    const mustAssign = !(isNumber(imageFrame.smallestPixelValue) &&
-        isNumber(imageFrame.largestPixelValue));
-    if (strict === true && !mustAssign) {
-        if (imageFrame.smallestPixelValue !== minMax.min) {
-            console.warn('Image smallestPixelValue tag is incorrect. Rendering performance will suffer considerably.');
-        }
-        if (imageFrame.largestPixelValue !== minMax.max) {
-            console.warn('Image largestPixelValue tag is incorrect. Rendering performance will suffer considerably.');
-        }
-    }
-    else {
-        imageFrame.smallestPixelValue = minMax.min;
-        imageFrame.largestPixelValue = minMax.max;
-    }
-}
-function isNumber(numValue) {
-    return typeof numValue === 'number';
-}

package/dist/esm/src/shared/calculateMinMax_test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/shared/calculateMinMax_test.js

@@ -1,38 +0,0 @@
-import { expect } from 'chai';
-import calculateMinMax from './calculateMinMax';
-describe('#calculateMinMax', () => {
-    let imageFrame = {};
-    beforeEach(() => {
-        imageFrame = {
-            smallestPixelValue: -1,
-            largestPixelValue: 10,
-            pixelData: [7, 3, 9, 6, 8, 1, 4, 5, 2],
-        };
-    });
-    it('should update the smallest and largest pixel values if strict is false', () => {
-        const strict = false;
-        calculateMinMax(imageFrame, strict);
-        expect(imageFrame.smallestPixelValue).to.be.equal(1);
-        expect(imageFrame.largestPixelValue).to.be.equal(9);
-    });
-    it('should not update the smallest and largest pixel values if strict is true', () => {
-        const strict = true;
-        calculateMinMax(imageFrame, strict);
-        expect(imageFrame.smallestPixelValue).to.be.equal(-1);
-        expect(imageFrame.largestPixelValue).to.be.equal(10);
-    });
-    it('should update the smallest and largest pixel values regardless of strict value', () => {
-        let strict = false;
-        imageFrame.smallestPixelValue = undefined;
-        imageFrame.largestPixelValue = undefined;
-        calculateMinMax(imageFrame, strict);
-        expect(imageFrame.smallestPixelValue).to.be.equal(1);
-        expect(imageFrame.largestPixelValue).to.be.equal(9);
-        strict = true;
-        imageFrame.smallestPixelValue = undefined;
-        imageFrame.largestPixelValue = undefined;
-        calculateMinMax(imageFrame, strict);
-        expect(imageFrame.smallestPixelValue).to.be.equal(1);
-        expect(imageFrame.largestPixelValue).to.be.equal(9);
-    });
-});

package/dist/esm/src/types/ImageFrame.d.ts

@@ -1,43 +0,0 @@
-import { Enums } from '@cornerstonejs/core';
-import PixelDataTypedArray from './PixelDataTypedArray';
-interface ImageFrame {
-    samplesPerPixel: number;
-    photometricInterpretation: string;
-    planarConfiguration: number;
-    rows: number;
-    columns: number;
-    bitsAllocated: number;
-    bitsStored: number;
-    pixelRepresentation: number;
-    smallestPixelValue: number;
-    largestPixelValue: number;
-    redPaletteColorLookupTableDescriptor: number[];
-    greenPaletteColorLookupTableDescriptor: number[];
-    bluePaletteColorLookupTableDescriptor: number[];
-    redPaletteColorLookupTableData: number[];
-    greenPaletteColorLookupTableData: number[];
-    bluePaletteColorLookupTableData: number[];
-    pixelData: PixelDataTypedArray;
-    imageData?: ImageData;
-    pixelDataLength?: number;
-    preScale?: {
-        enabled: boolean;
-        scaled: boolean;
-        scalingParameters?: {
-            intercept?: number;
-            slope?: number;
-            rescaleSlope?: number;
-            rescaleIntercept?: number;
-            modality?: string;
-            suvbw?: number;
-        };
-    };
-    minAfterScale?: number;
-    maxAfterScale?: number;
-    imageId: string;
-    decodeTimeInMS?: number;
-    loadTimeInMS?: number;
-    imageQualityStatus?: Enums.ImageQualityStatus;
-    decodeLevel?: any;
-}
-export default ImageFrame;

package/dist/esm/src/types/ImageFrame.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/types/MetadataModules.d.ts

@@ -1,66 +0,0 @@
-export type MetaDataTypes = 'generalSeriesModule' | 'patientStudyModule' | 'imagePlaneModule' | 'imagePixelModule' | 'transferSyntax' | 'sopCommonModule' | string;
-export interface DicomDateObject {
-    year: number;
-    month: number;
-    day: number;
-}
-export interface DicomTimeObject {
-    hours: number;
-    minutes?: number;
-    seconds?: number;
-    fractionalSeconds?: number;
-}
-export interface MetadataGeneralSeriesModule {
-    modality: string;
-    seriesInstanceUID: string;
-    seriesNumber: number;
-    studyInstanceUID: string;
-    seriesDate: DicomDateObject;
-    seriesTime: DicomTimeObject;
-}
-export interface MetadataPatientStudyModule {
-    patientAge: number;
-    patientSize: number;
-    patientWeight: number;
-}
-export interface MetadataImagePlaneModule {
-    frameOfReferenceUID: string;
-    rows: string;
-    columns: string;
-    imageOrientationPatient: number[];
-    rowCosines: number[];
-    columnCosines: number[];
-    imagePositionPatient: number[];
-    sliceThickness: string;
-    sliceLocation: string;
-    pixelSpacing: number[];
-    rowPixelSpacing: number | null;
-    columnPixelSpacing: number | null;
-}
-export interface MetadataImagePixelModule {
-    samplesPerPixel: number;
-    photometricInterpretation: string;
-    rows: number;
-    columns: number;
-    bitsAllocated: number;
-    bitsStored: number;
-    highBit: number;
-    pixelRepresentation: number;
-    planarConfiguration: number;
-    pixelAspectRatio: string;
-    redPaletteColorLookupTableDescriptor: number[];
-    greenPaletteColorLookupTableDescriptor: number[];
-    bluePaletteColorLookupTableDescriptor: number[];
-    redPaletteColorLookupTableData: number[];
-    greenPaletteColorLookupTableData: number[];
-    bluePaletteColorLookupTableData: number[];
-    smallestPixelValue?: number;
-    largestPixelValue?: number;
-}
-export interface MetadataSopCommonModule {
-    sopClassUID: string;
-    sopInstanceUID: string;
-}
-export interface MetadataTransferSyntax {
-    transferSyntaxUID: string;
-}

package/dist/esm/src/types/MetadataModules.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/src/types/PixelDataTypedArray.d.ts

@@ -1,2 +0,0 @@
-type PixelDataTypedArray = Float32Array | Int16Array | Uint16Array | Uint8Array | Int8Array | Uint8ClampedArray;
-export default PixelDataTypedArray;

package/dist/esm/src/types/PixelDataTypedArray.js

@@ -1 +0,0 @@
-export {};