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

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

@@ -0,0 +1,94 @@
+import { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR } from './colorSpaceConverters/index';
+import { default as wadouri } from './wadouri/index';
+import { default as wadors } from './wadors/index';
+import { default as configure } from './configure';
+import { default as convertColorSpace } from './convertColorSpace';
+import { default as createImage } from './createImage';
+import { default as decodeJPEGBaseline8BitColor } from './decodeJPEGBaseline8BitColor';
+import { default as getImageFrame } from './getImageFrame';
+import { default as getMinMax } from '../shared/getMinMax';
+import { default as isColorImage } from '../shared/isColorImage';
+import { default as isJPEGBaseline8BitColor } from './isJPEGBaseline8BitColor';
+import { default as getPixelData } from './wadors/getPixelData';
+import { internal } from './internal/index';
+import { default as external } from '../externalModules';
+declare const cornerstoneDICOMImageLoader: {
+    convertRGBColorByPixel: typeof convertRGBColorByPixel;
+    convertRGBColorByPlane: typeof convertRGBColorByPlane;
+    convertYBRFullByPixel: typeof convertYBRFullByPixel;
+    convertYBRFullByPlane: typeof convertYBRFullByPlane;
+    convertPALETTECOLOR: typeof convertPALETTECOLOR;
+    wadouri: {
+        metaData: {
+            getImagePixelModule: typeof import("./wadouri/metaData").getImagePixelModule;
+            getLUTs: typeof import("./wadouri/metaData").getLUTs;
+            getModalityLUTOutputPixelRepresentation: typeof import("./wadouri/metaData").getModalityLUTOutputPixelRepresentation;
+            getNumberValues: typeof import("./wadouri/metaData").getNumberValues;
+            metaDataProvider: typeof import("./wadouri/metaData").metaDataProvider;
+        };
+        dataSetCacheManager: {
+            isLoaded: (uri: string) => boolean;
+            load: (uri: string, loadRequest: import("../types").LoadRequestFunction, imageId: string) => import("./wadouri/dataSetCacheManager").CornerstoneWadoLoaderCachedPromise;
+            unload: (uri: string) => void;
+            getInfo: typeof import("./wadouri/dataSetCacheManager").getInfo;
+            purge: () => void;
+            get: (uri: string) => import("dicom-parser").DataSet;
+            update: (uri: string, dataSet: import("dicom-parser").DataSet) => void;
+        };
+        fileManager: {
+            add: (file: Blob) => string;
+            get: (index: number) => Blob;
+            remove: (index: number) => void;
+            purge: () => void;
+        };
+        getEncapsulatedImageFrame: typeof import("./wadouri/getEncapsulatedImageFrame").default;
+        getUncompressedImageFrame: typeof import("./wadouri/getUncompressedImageFrame").default;
+        loadFileRequest: typeof import("./wadouri/loadFileRequest").default;
+        loadImageFromPromise: typeof import("./wadouri/loadImage").loadImageFromPromise;
+        getLoaderForScheme: typeof import("./wadouri/loadImage").getLoaderForScheme;
+        loadImage: typeof import("./wadouri/loadImage").loadImage;
+        parseImageId: typeof import("./wadouri/parseImageId").default;
+        unpackBinaryFrame: typeof import("./wadouri/unpackBinaryFrame").default;
+        register: typeof import("./wadouri/register").default;
+    };
+    wadors: {
+        metaData: {
+            getNumberString: typeof import("./wadors/metaData").getNumberString;
+            getNumberValue: typeof import("./wadors/metaData").getNumberValue;
+            getNumberValues: typeof import("./wadors/metaData").getNumberValues;
+            getValue: typeof import("./wadors/metaData").getValue;
+            metaDataProvider: typeof import("./wadors/metaData").metaDataProvider;
+        };
+        findIndexOfString: typeof import("./wadors/findIndexOfString").default;
+        getPixelData: typeof getPixelData;
+        loadImage: typeof import("./wadors/loadImage").default;
+        metaDataManager: {
+            add: (imageId: string, metadata: import("../types").WADORSMetaData) => void;
+            get: (imageId: string) => import("../types").WADORSMetaData;
+            remove: (imageId: any) => void;
+            purge: () => void;
+        };
+        register: typeof import("./wadors/register").default;
+    };
+    configure: typeof configure;
+    convertColorSpace: typeof convertColorSpace;
+    createImage: typeof createImage;
+    decodeJPEGBaseline8BitColor: typeof decodeJPEGBaseline8BitColor;
+    getImageFrame: typeof getImageFrame;
+    getPixelData: typeof getPixelData;
+    getMinMax: typeof getMinMax;
+    isColorImage: typeof isColorImage;
+    isJPEGBaseline8BitColor: typeof isJPEGBaseline8BitColor;
+    internal: {
+        xhrRequest: typeof import("./internal/xhrRequest").default;
+        streamRequest: typeof import("./internal/streamRequest").default;
+        setOptions: typeof import("./internal/options").setOptions;
+        getOptions: typeof import("./internal/options").getOptions;
+    };
+    external: {
+        cornerstone: any;
+        dicomParser: any;
+    };
+};
+export { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR, wadouri, wadors, configure, convertColorSpace, createImage, decodeJPEGBaseline8BitColor, getImageFrame, getPixelData, getMinMax, isColorImage, isJPEGBaseline8BitColor, internal, external, };
+export default cornerstoneDICOMImageLoader;

package/dist/esm/src/imageLoader/index.js

@@ -0,0 +1,36 @@
+import { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR, } from './colorSpaceConverters/index';
+import { default as wadouri } from './wadouri/index';
+import { default as wadors } from './wadors/index';
+import { default as configure } from './configure';
+import { default as convertColorSpace } from './convertColorSpace';
+import { default as createImage } from './createImage';
+import { default as decodeJPEGBaseline8BitColor } from './decodeJPEGBaseline8BitColor';
+import { default as getImageFrame } from './getImageFrame';
+import { default as getMinMax } from '../shared/getMinMax';
+import { default as isColorImage } from '../shared/isColorImage';
+import { default as isJPEGBaseline8BitColor } from './isJPEGBaseline8BitColor';
+import { default as getPixelData } from './wadors/getPixelData';
+import { internal } from './internal/index';
+import { default as external } from '../externalModules';
+const cornerstoneDICOMImageLoader = {
+    convertRGBColorByPixel,
+    convertRGBColorByPlane,
+    convertYBRFullByPixel,
+    convertYBRFullByPlane,
+    convertPALETTECOLOR,
+    wadouri,
+    wadors,
+    configure,
+    convertColorSpace,
+    createImage,
+    decodeJPEGBaseline8BitColor,
+    getImageFrame,
+    getPixelData,
+    getMinMax,
+    isColorImage,
+    isJPEGBaseline8BitColor,
+    internal,
+    external,
+};
+export { convertRGBColorByPixel, convertRGBColorByPlane, convertYBRFullByPixel, convertYBRFullByPlane, convertPALETTECOLOR, wadouri, wadors, configure, convertColorSpace, createImage, decodeJPEGBaseline8BitColor, getImageFrame, getPixelData, getMinMax, isColorImage, isJPEGBaseline8BitColor, internal, external, };
+export default cornerstoneDICOMImageLoader;

package/dist/esm/src/imageLoader/internal/index.d.ts

@@ -0,0 +1,10 @@
+import { default as xhrRequest } from './xhrRequest';
+import { default as streamRequest } from './streamRequest';
+import { setOptions, getOptions } from './options';
+declare const internal: {
+    xhrRequest: typeof xhrRequest;
+    streamRequest: typeof streamRequest;
+    setOptions: typeof setOptions;
+    getOptions: typeof getOptions;
+};
+export { setOptions, getOptions, xhrRequest, internal, streamRequest };

package/dist/esm/src/imageLoader/internal/index.js

@@ -0,0 +1,10 @@
+import { default as xhrRequest } from './xhrRequest';
+import { default as streamRequest } from './streamRequest';
+import { setOptions, getOptions } from './options';
+const internal = {
+    xhrRequest,
+    streamRequest,
+    setOptions,
+    getOptions,
+};
+export { setOptions, getOptions, xhrRequest, internal, streamRequest };

package/dist/esm/src/imageLoader/internal/options.d.ts

@@ -0,0 +1,3 @@
+import type { LoaderOptions } from '../../types';
+export declare function setOptions(newOptions: LoaderOptions): void;
+export declare function getOptions(): LoaderOptions;

package/dist/esm/src/imageLoader/internal/options.js

@@ -0,0 +1,19 @@
+let options = {
+    open(xhr, url) {
+        xhr.open('get', url, true);
+    },
+    beforeSend() {
+    },
+    beforeProcessing(xhr) {
+        return Promise.resolve(xhr.response);
+    },
+    imageCreated() {
+    },
+    strict: false,
+};
+export function setOptions(newOptions) {
+    options = Object.assign(options, newOptions);
+}
+export function getOptions() {
+    return options;
+}

package/dist/esm/src/imageLoader/internal/rangeRequest.d.ts

@@ -0,0 +1,9 @@
+import type { Enums } from '@cornerstonejs/core';
+import type { LoaderXhrRequestPromise } from '../../types';
+import type { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';
+export default function rangeRequest(url: string, imageId: string, defaultHeaders?: Record<string, string>, options?: CornerstoneWadoRsLoaderOptions): LoaderXhrRequestPromise<{
+    contentType: string;
+    pixelData: Uint8Array;
+    imageQualityStatus: Enums.ImageQualityStatus;
+    percentComplete: number;
+}>;

package/dist/esm/src/imageLoader/internal/rangeRequest.js

@@ -0,0 +1,121 @@
+import { getOptions } from './options';
+import metaDataManager from '../wadors/metaDataManager';
+import extractMultipart from '../wadors/extractMultipart';
+import { getImageQualityStatus } from '../wadors/getImageQualityStatus';
+export default function rangeRequest(url, imageId, defaultHeaders = {}, options = {}) {
+    const globalOptions = getOptions();
+    const { retrieveOptions = {}, streamingData } = options;
+    const chunkSize = streamingData.chunkSize ||
+        getValue(imageId, retrieveOptions, 'chunkSize') ||
+        65536;
+    const errorInterceptor = (err) => {
+        if (typeof globalOptions.errorInterceptor === 'function') {
+            const error = new Error('request failed');
+            globalOptions.errorInterceptor(error);
+        }
+        else {
+            console.warn('rangeRequest:Caught', err);
+        }
+    };
+    const promise = new Promise(async (resolve, reject) => {
+        const headers = Object.assign({}, defaultHeaders);
+        Object.keys(headers).forEach(function (key) {
+            if (headers[key] === null || headers[key] === undefined) {
+                delete headers[key];
+            }
+        });
+        try {
+            if (!streamingData.encodedData) {
+                streamingData.chunkSize = chunkSize;
+                streamingData.rangesFetched = 0;
+            }
+            const byteRange = getByteRange(streamingData, retrieveOptions);
+            const { encodedData, responseHeaders } = await fetchRangeAndAppend(url, headers, byteRange, streamingData);
+            const contentType = responseHeaders.get('content-type');
+            const { totalBytes } = streamingData;
+            const doneAllBytes = totalBytes === encodedData.byteLength;
+            const extract = extractMultipart(contentType, encodedData, {
+                isPartial: true,
+            });
+            const imageQualityStatus = getImageQualityStatus(retrieveOptions, doneAllBytes || extract.extractDone);
+            resolve({
+                ...extract,
+                imageQualityStatus,
+                percentComplete: extract.extractDone
+                    ? 100
+                    : (chunkSize * 100) / totalBytes,
+            });
+        }
+        catch (err) {
+            errorInterceptor(err);
+            console.error(err);
+            reject(err);
+        }
+    });
+    return promise;
+}
+async function fetchRangeAndAppend(url, headers, range, streamingData) {
+    if (range) {
+        headers = Object.assign(headers, {
+            Range: `bytes=${range[0]}-${range[1]}`,
+        });
+    }
+    let { encodedData } = streamingData;
+    if (range[1] && encodedData?.byteLength > range[1]) {
+        return streamingData;
+    }
+    const response = await fetch(url, {
+        headers,
+        signal: undefined,
+    });
+    const responseArrayBuffer = await response.arrayBuffer();
+    const responseTypedArray = new Uint8Array(responseArrayBuffer);
+    const { status } = response;
+    let newByteArray;
+    if (encodedData) {
+        newByteArray = new Uint8Array(encodedData.length + responseTypedArray.length);
+        newByteArray.set(encodedData, 0);
+        newByteArray.set(responseTypedArray, encodedData.length);
+        streamingData.rangesFetched = 1;
+    }
+    else {
+        newByteArray = new Uint8Array(responseTypedArray.length);
+        newByteArray.set(responseTypedArray, 0);
+        streamingData.rangesFetched++;
+    }
+    streamingData.encodedData = encodedData = newByteArray;
+    streamingData.responseHeaders = response.headers;
+    const contentRange = response.headers.get('Content-Range');
+    if (contentRange) {
+        streamingData.totalBytes = Number(contentRange.split('/')[1]);
+    }
+    else if (status !== 206 || !range) {
+        streamingData.totalBytes = encodedData?.byteLength;
+    }
+    else if (range[1] === '' || encodedData?.length < range[1]) {
+        streamingData.totalBytes = encodedData.byteLength;
+    }
+    else {
+        streamingData.totalBytes = Number.MAX_SAFE_INTEGER;
+    }
+    return streamingData;
+}
+function getValue(imageId, src, attr) {
+    const value = src[attr];
+    if (typeof value !== 'function') {
+        return value;
+    }
+    const metaData = metaDataManager.get(imageId);
+    return value(metaData, imageId);
+}
+function getByteRange(streamingData, retrieveOptions) {
+    const { totalBytes, encodedData, chunkSize = 65536 } = streamingData;
+    const { rangeIndex = 0 } = retrieveOptions;
+    if (rangeIndex === -1 && (!totalBytes || !encodedData)) {
+        return [0, ''];
+    }
+    if (rangeIndex === -1 || encodedData?.byteLength > totalBytes - chunkSize) {
+        return [encodedData?.byteLength || 0, ''];
+    }
+    return [encodedData?.byteLength || 0, chunkSize * (rangeIndex + 1) - 1];
+}

package/dist/esm/src/imageLoader/internal/streamRequest.d.ts

@@ -0,0 +1,2 @@
+import type { CornerstoneWadoRsLoaderOptions } from '../wadors/loadImage';
+export default function streamRequest(url: string, imageId: string, defaultHeaders?: Record<string, string>, options?: CornerstoneWadoRsLoaderOptions): import("packages/core/dist/esm/utilities/ProgressiveIterator").PromiseIterator<unknown>;

package/dist/esm/src/imageLoader/internal/streamRequest.js

@@ -0,0 +1,92 @@
+import { utilities } from '@cornerstonejs/core';
+import { getOptions } from './options';
+import extractMultipart from '../wadors/extractMultipart';
+import { getImageQualityStatus } from '../wadors/getImageQualityStatus';
+const { ProgressiveIterator } = utilities;
+export default function streamRequest(url, imageId, defaultHeaders = {}, options = {}) {
+    const globalOptions = getOptions();
+    const { retrieveOptions = {}, streamingData = {}, } = options;
+    const minChunkSize = retrieveOptions.chunkSize || 128 * 1024;
+    const errorInterceptor = (err) => {
+        if (typeof globalOptions.errorInterceptor === 'function') {
+            const error = new Error('request failed');
+            globalOptions.errorInterceptor(error);
+        }
+    };
+    const loadIterator = new ProgressiveIterator('streamRequest');
+    loadIterator.generate(async (iterator, reject) => {
+        const headers = Object.assign({}, defaultHeaders);
+        Object.keys(headers).forEach(function (key) {
+            if (headers[key] === null) {
+                headers[key] = undefined;
+            }
+            if (key === 'Accept' && url.indexOf('accept=') !== -1) {
+                headers[key] = undefined;
+            }
+        });
+        try {
+            const response = await fetch(url, {
+                headers: defaultHeaders,
+                signal: undefined,
+            });
+            if (response.status !== 200) {
+                throw new Error(`Couldn't retrieve ${url} got status ${response.status}`);
+            }
+            const responseReader = response.body.getReader();
+            const responseHeaders = response.headers;
+            const contentType = responseHeaders.get('content-type');
+            const totalBytes = Number(responseHeaders.get('Content-Length'));
+            let readDone = false;
+            let encodedData = streamingData.encodedData;
+            let lastSize = streamingData.lastSize || 0;
+            streamingData.isPartial = true;
+            while (!readDone) {
+                const { done, value } = await responseReader.read();
+                encodedData = appendChunk(encodedData, value);
+                if (!encodedData) {
+                    if (readDone) {
+                        throw new Error(`Done but no image frame available ${imageId}`);
+                    }
+                    continue;
+                }
+                readDone = done || encodedData.byteLength === totalBytes;
+                if (!readDone && encodedData.length < lastSize + minChunkSize) {
+                    continue;
+                }
+                lastSize = encodedData.length;
+                streamingData.isPartial = !done;
+                const extracted = extractMultipart(contentType, encodedData, streamingData);
+                const imageQualityStatus = getImageQualityStatus(retrieveOptions, readDone);
+                const detail = {
+                    url,
+                    imageId,
+                    ...extracted,
+                    percentComplete: done
+                        ? 100
+                        : (extracted.pixelData?.length * 100) / totalBytes,
+                    imageQualityStatus,
+                    done: readDone,
+                };
+                iterator.add(detail, readDone);
+            }
+        }
+        catch (err) {
+            errorInterceptor(err);
+            console.error(err);
+            reject(err);
+        }
+    });
+    return loadIterator.getNextPromise();
+}
+function appendChunk(existing, chunk) {
+    if (!existing) {
+        return chunk;
+    }
+    if (!chunk) {
+        return existing;
+    }
+    const newDataArray = new Uint8Array(existing.length + chunk.length);
+    newDataArray.set(existing, 0);
+    newDataArray.set(chunk, existing.length);
+    return newDataArray;
+}

package/dist/esm/src/imageLoader/internal/xhrRequest.d.ts

@@ -0,0 +1,3 @@
+import type { LoaderXhrRequestParams, LoaderXhrRequestPromise } from '../../types';
+declare function xhrRequest(url: string, imageId: string, defaultHeaders?: Record<string, string>, params?: LoaderXhrRequestParams): LoaderXhrRequestPromise<ArrayBuffer>;
+export default xhrRequest;

package/dist/esm/src/imageLoader/internal/xhrRequest.js

@@ -0,0 +1,102 @@
+import external from '../../externalModules';
+import { getOptions } from './options';
+function xhrRequest(url, imageId, defaultHeaders = {}, params = {}) {
+    const { cornerstone } = external;
+    const options = getOptions();
+    const errorInterceptor = (xhr) => {
+        if (typeof options.errorInterceptor === 'function') {
+            const error = new Error('request failed');
+            error.request = xhr;
+            error.response = xhr.response;
+            error.status = xhr.status;
+            options.errorInterceptor(error);
+        }
+    };
+    const xhr = new XMLHttpRequest();
+    const promise = new Promise((resolve, reject) => {
+        options.open(xhr, url, defaultHeaders, params);
+        const beforeSendHeaders = options.beforeSend(xhr, imageId, defaultHeaders, params);
+        xhr.responseType = 'arraybuffer';
+        const headers = Object.assign({}, defaultHeaders, beforeSendHeaders);
+        Object.keys(headers).forEach(function (key) {
+            if (headers[key] === null) {
+                return;
+            }
+            if (key === 'Accept' && url.indexOf('accept=') !== -1) {
+                return;
+            }
+            xhr.setRequestHeader(key, headers[key]);
+        });
+        params.deferred = {
+            resolve,
+            reject,
+        };
+        params.url = url;
+        params.imageId = imageId;
+        xhr.onloadstart = function (event) {
+            if (options.onloadstart) {
+                options.onloadstart(event, params);
+            }
+            const eventData = {
+                url,
+                imageId,
+            };
+            cornerstone.triggerEvent(cornerstone.events, 'cornerstoneimageloadstart', eventData);
+        };
+        xhr.onloadend = function (event) {
+            if (options.onloadend) {
+                options.onloadend(event, params);
+            }
+            const eventData = {
+                url,
+                imageId,
+            };
+            cornerstone.triggerEvent(cornerstone.events, 'cornerstoneimageloadend', eventData);
+        };
+        xhr.onreadystatechange = function (event) {
+            if (options.onreadystatechange) {
+                options.onreadystatechange(event, params);
+                return;
+            }
+            if (xhr.readyState === 4) {
+                if (xhr.status === 200 || xhr.status === 206) {
+                    options
+                        .beforeProcessing(xhr)
+                        .then(resolve)
+                        .catch(() => {
+                        errorInterceptor(xhr);
+                        reject(xhr);
+                    });
+                }
+                else {
+                    errorInterceptor(xhr);
+                    reject(xhr);
+                }
+            }
+        };
+        xhr.onprogress = function (oProgress) {
+            const loaded = oProgress.loaded;
+            let total;
+            let percentComplete;
+            if (oProgress.lengthComputable) {
+                total = oProgress.total;
+                percentComplete = Math.round((loaded / total) * 100);
+            }
+            if (options.onprogress) {
+                options.onprogress(oProgress, params);
+            }
+        };
+        xhr.onerror = function () {
+            errorInterceptor(xhr);
+            reject(xhr);
+        };
+        xhr.onabort = function () {
+            errorInterceptor(xhr);
+            reject(xhr);
+        };
+        xhr.send();
+    });
+    promise.xhr = xhr;
+    return promise;
+}
+export default xhrRequest;

package/dist/esm/src/imageLoader/isColorConversionRequired.d.ts

@@ -0,0 +1 @@
+export default function isColorConversionRequired(imageFrame: any): boolean;

package/dist/esm/src/imageLoader/isColorConversionRequired.js

@@ -0,0 +1,22 @@
+export default function isColorConversionRequired(imageFrame) {
+    if (imageFrame === undefined) {
+        return false;
+    }
+    const { rows, columns, photometricInterpretation, pixelDataLength } = imageFrame;
+    if (pixelDataLength === 4 * columns * rows) {
+        return false;
+    }
+    if (photometricInterpretation.endsWith('420')) {
+        return (pixelDataLength ===
+            (3 * Math.ceil(columns / 2) + Math.floor(columns / 2)) * rows);
+    }
+    else if (photometricInterpretation.endsWith('422')) {
+        return (pixelDataLength ===
+            (3 * Math.ceil(columns / 2) + Math.floor(columns / 2)) *
+                Math.ceil(rows / 2) +
+                Math.floor(rows / 2) * columns);
+    }
+    else {
+        return photometricInterpretation !== 'RGB';
+    }
+}

package/dist/esm/src/imageLoader/isJPEGBaseline8BitColor.d.ts

@@ -0,0 +1,3 @@
+import type { Types } from '@cornerstonejs/core';
+declare function isJPEGBaseline8BitColor(imageFrame: Types.IImageFrame, transferSyntax: string): boolean;
+export default isJPEGBaseline8BitColor;

package/dist/esm/src/imageLoader/isJPEGBaseline8BitColor.js

@@ -0,0 +1,9 @@
+function isJPEGBaseline8BitColor(imageFrame, transferSyntax) {
+    transferSyntax = transferSyntax || imageFrame.transferSyntax;
+    if (imageFrame.bitsAllocated === 8 &&
+        transferSyntax === '1.2.840.10008.1.2.4.50' &&
+        (imageFrame.samplesPerPixel === 3 || imageFrame.samplesPerPixel === 4)) {
+        return true;
+    }
+}
+export default isJPEGBaseline8BitColor;

package/dist/esm/src/imageLoader/isNMReconstructable.d.ts

@@ -0,0 +1 @@
+export default function isNMReconstructable(imageSubType: any): boolean;

package/dist/esm/src/imageLoader/isNMReconstructable.js

@@ -0,0 +1,3 @@
+export default function isNMReconstructable(imageSubType) {
+    return imageSubType === 'RECON TOMO' || imageSubType === 'RECON GATED TOMO';
+}

package/dist/esm/src/imageLoader/registerLoaders.d.ts

@@ -0,0 +1,2 @@
+declare function registerLoaders(cornerstone: any): void;
+export default registerLoaders;

package/dist/esm/src/imageLoader/registerLoaders.js

@@ -0,0 +1,7 @@
+import wadors from './wadors/index';
+import wadouri from './wadouri/index';
+function registerLoaders(cornerstone) {
+    wadors.register(cornerstone);
+    wadouri.register(cornerstone);
+}
+export default registerLoaders;

package/dist/esm/src/imageLoader/wadors/combineFrameInstance.d.ts

@@ -0,0 +1,12 @@
+declare function getFrameInformation(PerFrameFunctionalGroupsSequence: any, SharedFunctionalGroupsSequence: any, frameNumber: any): {
+    shared: any[];
+    perFrame: any[];
+};
+declare function getMultiframeInformation(metaData: any): {
+    PerFrameFunctionalGroupsSequence: any;
+    SharedFunctionalGroupsSequence: any;
+    NumberOfFrames: any;
+    rest: any;
+};
+declare function combineFrameInstance(frameNumber: any, instance: any): any;
+export { combineFrameInstance, getMultiframeInformation, getFrameInformation };

package/dist/esm/src/imageLoader/wadors/combineFrameInstance.js

@@ -0,0 +1,44 @@
+import getTagValue from './getTagValue';
+function getFrameInformation(PerFrameFunctionalGroupsSequence, SharedFunctionalGroupsSequence, frameNumber) {
+    const shared = (SharedFunctionalGroupsSequence
+        ? Object.values(SharedFunctionalGroupsSequence[0])
+        : [])
+        .map((it) => it[0])
+        .filter((it) => it !== undefined && typeof it === 'object');
+    const perFrame = (PerFrameFunctionalGroupsSequence
+        ? Object.values(PerFrameFunctionalGroupsSequence[frameNumber - 1])
+        : [])
+        .map((it) => it.Value[0])
+        .filter((it) => it !== undefined && typeof it === 'object');
+    return {
+        shared,
+        perFrame,
+    };
+}
+function getMultiframeInformation(metaData) {
+    let { 52009230: PerFrameFunctionalGroupsSequence, 52009229: SharedFunctionalGroupsSequence, '00280008': NumberOfFrames, ...rest } = metaData;
+    PerFrameFunctionalGroupsSequence = getTagValue(PerFrameFunctionalGroupsSequence, false);
+    SharedFunctionalGroupsSequence = getTagValue(SharedFunctionalGroupsSequence, false);
+    NumberOfFrames = getTagValue(NumberOfFrames);
+    return {
+        PerFrameFunctionalGroupsSequence,
+        SharedFunctionalGroupsSequence,
+        NumberOfFrames,
+        rest,
+    };
+}
+function combineFrameInstance(frameNumber, instance) {
+    const { PerFrameFunctionalGroupsSequence, SharedFunctionalGroupsSequence, NumberOfFrames, rest, } = getMultiframeInformation(instance);
+    if (PerFrameFunctionalGroupsSequence || NumberOfFrames > 1) {
+        const { shared, perFrame } = getFrameInformation(PerFrameFunctionalGroupsSequence, SharedFunctionalGroupsSequence, frameNumber);
+        const newInstance = Object.assign(instance, { frameNumber });
+        [...shared, ...perFrame].forEach((item) => {
+            Object.entries(item).forEach(([key, value]) => {
+                newInstance[key] = value;
+            });
+        });
+        return Object.assign(rest, { '00280008': NumberOfFrames }, newInstance);
+    }
+    return instance;
+}
+export { combineFrameInstance, getMultiframeInformation, getFrameInformation };

package/dist/esm/src/imageLoader/wadors/extractMultipart.d.ts

@@ -0,0 +1,23 @@
+import { Enums } from '@cornerstonejs/core';
+export default function extractMultipart(contentType: string, imageFrameAsArrayBuffer: any, options?: any): {
+    contentType: string;
+    imageQualityStatus: Enums.ImageQualityStatus;
+    pixelData: Uint8Array;
+    extractDone?: undefined;
+    tokenIndex?: undefined;
+    responseHeaders?: undefined;
+    boundary?: undefined;
+    multipartContentType?: undefined;
+} | {
+    contentType: any;
+    extractDone: boolean;
+    tokenIndex: any;
+    responseHeaders: any;
+    boundary: any;
+    multipartContentType: any;
+    pixelData: any;
+    imageQualityStatus?: undefined;
+};
+export declare function findBoundary(header: string[]): string;
+export declare function findContentType(header: string[]): string;
+export declare function uint8ArrayToString(data: any, offset: any, length: any): string;