@cornerstonejs/metadata 5.0.0

package/dist/esm/utilities/metadataProvider/ecgFromInstance.js

@@ -0,0 +1,228 @@
+import { addTypedProvider } from '../../metaData';
+import { MetadataModules } from '../../enums';
+function base64ToUint8Array(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+function convertBuffer(dataSrc, numberOfChannels, numberOfSamples, bits, type) {
+    const data = new Uint8Array(dataSrc);
+    if (bits === 16 && type === 'SS') {
+        const ret = [];
+        const bytesPerSample = 2;
+        const totalBytes = bytesPerSample * numberOfChannels * numberOfSamples;
+        const length = Math.min(data.length, totalBytes);
+        for (let channel = 0; channel < numberOfChannels; channel++) {
+            const buffer = new Int16Array(numberOfSamples);
+            ret.push(buffer);
+            let sampleI = 0;
+            for (let sample = 2 * channel; sample < length; sample += 2 * numberOfChannels) {
+                const highByte = data[sample + 1];
+                const lowByte = data[sample];
+                const sign = highByte & 0x80;
+                buffer[sampleI++] = sign
+                    ? 0xffff0000 | (highByte << 8) | lowByte
+                    : (highByte << 8) | lowByte;
+            }
+        }
+        return ret;
+    }
+    return [];
+}
+function multipartDecode(response) {
+    const message = new Uint8Array(response);
+    const separator = new TextEncoder().encode('\r\n\r\n');
+    let offset = 0;
+    const maxHeader = 1000;
+    let headerEnd = -1;
+    for (let i = 0; i < Math.min(message.length - separator.length, offset + maxHeader); i++) {
+        let found = true;
+        for (let j = 0; j < separator.length; j++) {
+            if (message[i + j] !== separator[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            headerEnd = i;
+            break;
+        }
+    }
+    if (headerEnd === -1)
+        return [response];
+    const headerStr = new TextDecoder().decode(message.slice(0, headerEnd));
+    const boundaryMatch = headerStr.match(/boundary=([^\s;]+)/i);
+    const boundary = boundaryMatch
+        ? new TextEncoder().encode(`--${boundaryMatch[1].replace(/"/g, '').trim()}`)
+        : null;
+    if (!boundary)
+        return [response];
+    const dataStart = headerEnd + separator.length;
+    const components = [];
+    let idx = message.indexOf(boundary[0], dataStart);
+    while (idx !== -1) {
+        const nextSep = message.indexOf(separator[0], idx);
+        if (nextSep === -1)
+            break;
+        const partStart = nextSep + separator.length;
+        const nextBound = message.indexOf(boundary[0], partStart);
+        const partEnd = nextBound === -1 ? message.length : nextBound - 2;
+        if (partEnd > partStart) {
+            components.push(response.slice(partStart, partEnd));
+        }
+        if (nextBound === -1)
+            break;
+        idx = message.indexOf(boundary[0], nextBound + boundary.length);
+    }
+    return components.length > 0 ? components : [response];
+}
+function parseWadoRsImageId(imageId) {
+    const uri = imageId.replace(/^wadors:/i, '');
+    const studiesIndex = uri.indexOf('/studies/');
+    if (studiesIndex === -1)
+        return {};
+    const wadoRsRoot = uri.substring(0, studiesIndex);
+    const afterStudies = uri.substring(studiesIndex + 9);
+    const nextSlash = afterStudies.indexOf('/');
+    const studyUID = nextSlash !== -1 ? afterStudies.substring(0, nextSlash) : afterStudies;
+    return { wadoRsRoot, studyUID };
+}
+function toArray(seq) {
+    if (!seq)
+        return [];
+    if (Array.isArray(seq))
+        return seq;
+    if (typeof seq.length === 'number') {
+        return Array.from(seq);
+    }
+    return [seq];
+}
+export function buildEcgModuleFromInstance(instance, imageId) {
+    const raw = instance.WaveformSequence;
+    const groups = toArray(raw);
+    if (!groups.length)
+        return null;
+    const group = groups[0];
+    const numberOfChannels = group.NumberOfWaveformChannels ?? 0;
+    const numberOfSamples = group.NumberOfWaveformSamples ?? 0;
+    const samplingFrequency = group.SamplingFrequency ?? 1;
+    const bitsAllocated = group.WaveformBitsAllocated ?? 16;
+    const sampleInterpretation = group.WaveformSampleInterpretation ?? 'SS';
+    const multiplexGroupLabel = group.MultiplexGroupLabel ?? '';
+    const channelDefSeq = toArray(group.ChannelDefinitionSequence);
+    const channelDefinitionSequence = channelDefSeq.map((ch) => {
+        const srcSeqArr = toArray(ch.ChannelSourceSequence);
+        const srcSeq = srcSeqArr[0];
+        const codeMeaning = srcSeq?.CodeMeaning ?? '';
+        return {
+            channelSourceSequence: { codeMeaning },
+        };
+    });
+    let waveformDataRaw = (group.WaveformData ?? group.waveformData);
+    if (waveformDataRaw &&
+        typeof waveformDataRaw.length === 'number' &&
+        waveformDataRaw.length > 0) {
+        waveformDataRaw = waveformDataRaw[0];
+    }
+    const waveformData = waveformDataRaw ?? {};
+    const { wadoRsRoot = undefined, studyUID = undefined } = imageId
+        ? parseWadoRsImageId(imageId)
+        : {};
+    const retrieveBulkData = async () => {
+        const wd = waveformData;
+        if (wd instanceof ArrayBuffer ||
+            (typeof ArrayBuffer !== 'undefined' &&
+                ArrayBuffer.isView &&
+                ArrayBuffer.isView(wd))) {
+            return convertBuffer(wd, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        if (waveformData.Value)
+            return waveformData.Value;
+        if (waveformData.InlineBinary) {
+            const raw = base64ToUint8Array(waveformData.InlineBinary);
+            return convertBuffer(raw, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        if (typeof waveformData.retrieveBulkData === 'function') {
+            return waveformData.retrieveBulkData();
+        }
+        if (waveformData.BulkDataURI) {
+            let url = waveformData.BulkDataURI;
+            if (url.indexOf(':') === -1 && wadoRsRoot) {
+                url = studyUID
+                    ? `${wadoRsRoot}/studies/${studyUID}/${url}`
+                    : `${wadoRsRoot}/${url}`;
+            }
+            const response = await fetch(url);
+            const buffer = await response.arrayBuffer();
+            const contentType = response.headers.get('content-type') || '';
+            const decoded = contentType.includes('multipart')
+                ? multipartDecode(buffer)[0]
+                : buffer;
+            return convertBuffer(decoded, numberOfChannels, numberOfSamples, bitsAllocated, sampleInterpretation);
+        }
+        console.warn('[ecgFromInstance] No waveform data source found. group keys:', Object.keys(group), 'waveformData keys:', Object.keys(waveformData));
+        throw new Error('[ecgFromInstance] No waveform data source found');
+    };
+    return {
+        numberOfWaveformChannels: numberOfChannels,
+        numberOfWaveformSamples: numberOfSamples,
+        samplingFrequency,
+        waveformBitsAllocated: bitsAllocated,
+        waveformSampleInterpretation: sampleInterpretation,
+        multiplexGroupLabel,
+        channelDefinitionSequence,
+        waveformData: { retrieveBulkData },
+    };
+}
+const ECG_FROM_INSTANCE_PRIORITY = 4_000;
+const ecgFromInstanceProvider = (next, query, data, options) => {
+    const instance = data;
+    const hasWaveform = instance && instance.WaveformSequence;
+    if (!hasWaveform) {
+        return next(query, data, options);
+    }
+    const result = buildEcgModuleFromInstance(instance, query);
+    return result ?? next(query, data, options);
+};
+const ECG_AMPLITUDE_INDEX_SIZE = 65536;
+const ECG_AMPLITUDE_OFFSET = 32768;
+const ecgCalibrationProvider = (next, query, data, options) => {
+    const instance = data;
+    const raw = instance?.WaveformSequence;
+    const groups = toArray(raw);
+    if (!groups.length)
+        return next(query, data, options);
+    const group = groups[0];
+    const numberOfWaveformSamples = group.NumberOfWaveformSamples ?? 0;
+    const samplingFrequency = group.SamplingFrequency ?? 1;
+    const physicalDeltaX = 1 / (samplingFrequency || 1);
+    const physicalDeltaY = 0.001;
+    return {
+        sequenceOfUltrasoundRegions: [
+            {
+                regionLocationMinX0: 0,
+                regionLocationMaxX1: numberOfWaveformSamples,
+                regionLocationMinY0: 0,
+                regionLocationMaxY1: ECG_AMPLITUDE_INDEX_SIZE - 1,
+                referencePixelX0: 0,
+                referencePixelY0: ECG_AMPLITUDE_OFFSET,
+                physicalDeltaX,
+                physicalDeltaY,
+                physicalUnitsXDirection: 4,
+                physicalUnitsYDirection: -1,
+                regionDataType: 1,
+            },
+        ],
+    };
+};
+export function registerEcgFromInstanceProvider() {
+    addTypedProvider(MetadataModules.ECG, ecgFromInstanceProvider, {
+        priority: ECG_FROM_INSTANCE_PRIORITY,
+    });
+    addTypedProvider(MetadataModules.CALIBRATION, ecgCalibrationProvider, {
+        priority: ECG_FROM_INSTANCE_PRIORITY,
+    });
+}

package/dist/esm/utilities/metadataProvider/ecgModule.d.ts

@@ -0,0 +1 @@
+export type { EcgModuleMetadata } from '../../types';

package/dist/esm/utilities/metadataProvider/imageIdsProviders.d.ts

@@ -0,0 +1,11 @@
+import { MetadataModules } from '../../enums';
+import { type TypedProvider } from '../../metaData';
+export declare const FRAME_IMAGE_IDS = MetadataModules.FRAME_IMAGE_IDS;
+export declare const BASE_IMAGE_ID = MetadataModules.BASE_IMAGE_ID;
+export type ImageIdTransformPlugin = TypedProvider;
+export declare function generateFrameImageIdsFromNaturalized(baseImageId: string, naturalized: Record<string, unknown> | null | undefined): Set<string> | undefined;
+export declare function registerFrameImageIdsProvider(provider: ImageIdTransformPlugin, priority?: number): void;
+export declare function baseImageIdQueryFilter(next: any, query: string, data: any, options: any): any;
+export declare function registerImageIdTransformFilter(filter: (imageId: string, frameImageIds: Set<string>) => Iterable<string> | void, priority?: number): void;
+export declare function registerImageIdProviders(): void;
+export declare function bulkUpdateImageIds(imageIds: Iterable<string>, updater: (imageId: string) => void): Set<string>;

package/dist/esm/utilities/metadataProvider/imageIdsProviders.js

@@ -0,0 +1,117 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider, getTyped, metadataModuleProvider, } from '../../metaData';
+import { getNaturalizedNumber, getNaturalizedString, } from '../getNaturalizedField';
+export const FRAME_IMAGE_IDS = MetadataModules.FRAME_IMAGE_IDS;
+export const BASE_IMAGE_ID = MetadataModules.BASE_IMAGE_ID;
+const BASE_IMAGE_ID_PATH_FILTER_PRIORITY = 9_000;
+const BASE_IMAGE_ID_QUERY_FILTER_PRIORITY = 8_000;
+const DEFAULT_FRAME_IMAGE_IDS_PRIORITY = 9_000;
+function defaultBaseImageIdProvider(_next, imageId) {
+    return imageId;
+}
+function framePathToBaseFilter(next, imageId, data, options) {
+    const baseImageId = next(imageId, data, options) ?? imageId;
+    return baseImageId.replace(/\/frames\/\d+(?=(\?|#|$))/i, '');
+}
+function frameQueryToBaseFilter(next, imageId, data, options) {
+    const baseImageId = next(imageId, data, options) ?? imageId;
+    return baseImageId
+        .replace(/([?&])frame=\d+(&?)/i, (_match, separator, hasTrailingAmp) => {
+        if (separator === '?' && hasTrailingAmp) {
+            return '?';
+        }
+        return '';
+    })
+        .replace(/\?$/, '')
+        .replace(/\?&/, '?')
+        .replace(/&&+/g, '&');
+}
+function hasPhotometricInterpretation(naturalized) {
+    return !!getNaturalizedString(naturalized, 'PhotometricInterpretation');
+}
+function addFrameQueryParameter(imageId, frameNumber) {
+    const separator = imageId.includes('?') ? '&' : '?';
+    return `${imageId}${separator}frame=${frameNumber}`;
+}
+function addDicomwebFramePath(imageId, frameNumber) {
+    const instancesMatch = /\/instances\/[^/]+/i.exec(imageId);
+    if (!instancesMatch) {
+        return;
+    }
+    const insertIndex = instancesMatch.index + instancesMatch[0].length;
+    return `${imageId.slice(0, insertIndex)}/frames/${frameNumber}${imageId.slice(insertIndex)}`;
+}
+export function generateFrameImageIdsFromNaturalized(baseImageId, naturalized) {
+    if (!naturalized) {
+        return;
+    }
+    if (!hasPhotometricInterpretation(naturalized)) {
+        return new Set([baseImageId]);
+    }
+    const frameImageIds = new Set();
+    const numberOfFrames = Math.floor(getNaturalizedNumber(naturalized, 'NumberOfFrames', 1));
+    if (!Number.isFinite(numberOfFrames) || numberOfFrames < 1) {
+        return;
+    }
+    for (let frameNumber = 1; frameNumber <= numberOfFrames; frameNumber++) {
+        const framePath = addDicomwebFramePath(baseImageId, frameNumber);
+        if (framePath) {
+            frameImageIds.add(framePath);
+            continue;
+        }
+        frameImageIds.add(addFrameQueryParameter(baseImageId, frameNumber));
+    }
+    return frameImageIds;
+}
+function defaultFrameImageIdsProvider(next, imageId, data, options) {
+    const naturalized = metadataModuleProvider(MetadataModules.NATURALIZED, imageId, options);
+    return (generateFrameImageIdsFromNaturalized(imageId, naturalized) ||
+        next(imageId, data, options));
+}
+export function registerFrameImageIdsProvider(provider, priority = 0) {
+    addTypedProvider(FRAME_IMAGE_IDS, provider, { priority });
+}
+export function baseImageIdQueryFilter(next, query, data, options) {
+    const baseImageId = getTyped(MetadataModules.BASE_IMAGE_ID, query, options);
+    return next(baseImageId, data, options);
+}
+export function registerImageIdTransformFilter(filter, priority = 0) {
+    const provider = (next, imageId, data, options) => {
+        const frameImageIds = next(imageId, data, options) ??
+            new Set([imageId]);
+        const produced = filter(imageId, frameImageIds);
+        if (produced) {
+            for (const transformedImageId of produced) {
+                frameImageIds.add(transformedImageId);
+            }
+        }
+        return frameImageIds;
+    };
+    registerFrameImageIdsProvider(provider, priority);
+}
+export function registerImageIdProviders() {
+    addTypedProvider(BASE_IMAGE_ID, defaultBaseImageIdProvider, { priority: 0 });
+    addTypedProvider(BASE_IMAGE_ID, framePathToBaseFilter, {
+        priority: BASE_IMAGE_ID_PATH_FILTER_PRIORITY,
+    });
+    addTypedProvider(BASE_IMAGE_ID, frameQueryToBaseFilter, {
+        priority: BASE_IMAGE_ID_QUERY_FILTER_PRIORITY,
+    });
+    addTypedProvider(FRAME_IMAGE_IDS, defaultFrameImageIdsProvider, {
+        priority: DEFAULT_FRAME_IMAGE_IDS_PRIORITY,
+    });
+}
+export function bulkUpdateImageIds(imageIds, updater) {
+    const updatedImageIds = new Set();
+    for (const imageId of imageIds) {
+        const frameImageIds = getTyped(MetadataModules.FRAME_IMAGE_IDS, imageId);
+        if (!frameImageIds) {
+            continue;
+        }
+        for (const frameImageId of frameImageIds) {
+            updater(frameImageId);
+            updatedImageIds.add(frameImageId);
+        }
+    }
+    return updatedImageIds;
+}

package/dist/esm/utilities/metadataProvider/imagePlaneCalibrated.d.ts

@@ -0,0 +1,4 @@
+import type { ImagePlaneModuleMetadata } from '../../types';
+export declare const getImagePlaneCalibrated: (next: any, imageId: string, instance: any, options: any) => ImagePlaneModuleMetadata;
+export declare function registerImagePlaneCalibrated(): void;
+export default getImagePlaneCalibrated;

package/dist/esm/utilities/metadataProvider/imagePlaneCalibrated.js

@@ -0,0 +1,89 @@
+import { MetadataModules } from '../../enums';
+import { toFiniteNumber } from '../toNumber';
+import { getNaturalizedNumber } from '../getNaturalizedField';
+import calibratedPixelSpacingMetadataProvider from '../calibratedPixelSpacingMetadataProvider';
+import getPixelSpacingInformation from '../getPixelSpacingInformation';
+import { addTypedProvider } from '../../metaData';
+export const getImagePlaneCalibrated = (next, imageId, instance, options) => {
+    if (!instance) {
+        return next(imageId, instance, options);
+    }
+    const { ImageOrientationPatient, ImagePositionPatient } = instance;
+    const { PixelSpacing, type } = getPixelSpacingInformation(instance);
+    let rowPixelSpacing;
+    let columnPixelSpacing;
+    let rowCosines;
+    let columnCosines;
+    let usingDefaultValues = false;
+    let isDefaultValueSetForRowCosine = false;
+    let isDefaultValueSetForColumnCosine = false;
+    let imageOrientationPatient;
+    if (PixelSpacing) {
+        [rowPixelSpacing, columnPixelSpacing] = PixelSpacing;
+        const calibratedPixelSpacing = calibratedPixelSpacingMetadataProvider.get('calibratedPixelSpacing', imageId);
+        if (!calibratedPixelSpacing) {
+            calibratedPixelSpacingMetadataProvider.add(imageId, {
+                rowPixelSpacing: parseFloat(PixelSpacing[0]),
+                columnPixelSpacing: parseFloat(PixelSpacing[1]),
+                type,
+            });
+        }
+    }
+    else {
+        rowPixelSpacing = columnPixelSpacing = 1;
+        usingDefaultValues = true;
+    }
+    if (ImageOrientationPatient) {
+        imageOrientationPatient = toFiniteNumber(ImageOrientationPatient) || [1, 0, 0, 0, 1, 0];
+        rowCosines = imageOrientationPatient.slice(0, 3);
+        columnCosines = imageOrientationPatient.slice(3, 6);
+    }
+    else {
+        rowCosines = [1, 0, 0];
+        columnCosines = [0, 1, 0];
+        imageOrientationPatient = [1, 0, 0, 0, 1, 0];
+        usingDefaultValues = true;
+        isDefaultValueSetForRowCosine = true;
+        isDefaultValueSetForColumnCosine = true;
+    }
+    const imagePositionPatient = toFiniteNumber(ImagePositionPatient) || [0, 0, 0];
+    if (!ImagePositionPatient) {
+        usingDefaultValues = true;
+    }
+    const rowPixelSpacingNumber = toFiniteNumber(rowPixelSpacing) ?? null;
+    const columnPixelSpacingNumber = toFiniteNumber(columnPixelSpacing) ?? null;
+    const pixelSpacing = rowPixelSpacingNumber !== null && columnPixelSpacingNumber !== null
+        ? [rowPixelSpacingNumber, columnPixelSpacingNumber]
+        : Array.isArray(PixelSpacing)
+            ? PixelSpacing.map((value) => Number(value)).filter(Number.isFinite)
+            : [];
+    const result = {
+        frameOfReferenceUID: instance.FrameOfReferenceUID,
+        rows: getNaturalizedNumber(instance, 'Rows', 0),
+        columns: getNaturalizedNumber(instance, 'Columns', 0),
+        imageOrientationPatient,
+        rowCosines,
+        columnCosines,
+        imagePositionPatient,
+        sliceLocation: getNaturalizedNumber(instance, 'SliceLocation', 0),
+        pixelSpacing,
+        rowPixelSpacing: rowPixelSpacingNumber,
+        sliceThickness: getNaturalizedNumber(instance, 'SliceThickness'),
+        spacingBetweenSlices: getNaturalizedNumber(instance, 'SpacingBetweenSlices'),
+        columnPixelSpacing: columnPixelSpacingNumber,
+    };
+    Object.defineProperty(result, 'usingDefaultValues', {
+        value: usingDefaultValues,
+    });
+    Object.defineProperty(result, 'isDefaultValueSetForRowCosine', {
+        value: isDefaultValueSetForRowCosine,
+    });
+    Object.defineProperty(result, 'isDefaultValueSetForColumnCosine', {
+        value: isDefaultValueSetForColumnCosine,
+    });
+    return result;
+};
+export function registerImagePlaneCalibrated() {
+    addTypedProvider(MetadataModules.IMAGE_PLANE, getImagePlaneCalibrated);
+}
+export default getImagePlaneCalibrated;

package/dist/esm/utilities/metadataProvider/index.d.ts

@@ -0,0 +1,18 @@
+export { dicomSplit } from './dicomSplit';
+export * from './imagePlaneCalibrated';
+export * from './cacheData';
+export * from './imageIdsProviders';
+export * from './dataLookup';
+export * from './naturalizedHandlers';
+export * from './tagModules';
+export * from './instanceFromListener';
+export * from './calibrationModule';
+export * from './combineFrameInstance';
+export * from './uriModule';
+export * from './pixelDataUpdate';
+export * from './transferSyntaxProvider';
+export * from './addDicomPart10Instance';
+export type { CompressedFrameDataMetadata } from '../../types';
+export * from './ecgModule';
+export * from './ecgFromInstance';
+export * from './scalingFromInstance';

package/dist/esm/utilities/metadataProvider/index.js

@@ -0,0 +1,17 @@
+export { dicomSplit } from './dicomSplit';
+export * from './imagePlaneCalibrated';
+export * from './cacheData';
+export * from './imageIdsProviders';
+export * from './dataLookup';
+export * from './naturalizedHandlers';
+export * from './tagModules';
+export * from './instanceFromListener';
+export * from './calibrationModule';
+export * from './combineFrameInstance';
+export * from './uriModule';
+export * from './pixelDataUpdate';
+export * from './transferSyntaxProvider';
+export * from './addDicomPart10Instance';
+export * from './ecgModule';
+export * from './ecgFromInstance';
+export * from './scalingFromInstance';

package/dist/esm/utilities/metadataProvider/instanceFromListener.d.ts

@@ -0,0 +1,2 @@
+export declare const instanceOrigToInstanceProvider: (next: any, query: any, data: any, options: any) => any;
+export declare function registerInstanceFromListener(): void;

package/dist/esm/utilities/metadataProvider/instanceFromListener.js

@@ -0,0 +1,9 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider, metadataModuleProvider } from '../../metaData';
+export const instanceOrigToInstanceProvider = (next, query, data, options) => {
+    return (metadataModuleProvider(MetadataModules.NATURALIZED, query, options) ||
+        next(query, data, options));
+};
+export function registerInstanceFromListener() {
+    addTypedProvider(MetadataModules.INSTANCE, instanceOrigToInstanceProvider);
+}

package/dist/esm/utilities/metadataProvider/makeArrayLike.d.ts

@@ -0,0 +1 @@
+export declare function makeArrayLike(obj: any): any;

package/dist/esm/utilities/metadataProvider/makeArrayLike.js

@@ -0,0 +1,25 @@
+export function makeArrayLike(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (typeof obj !== 'object' || Array.isArray(obj)) {
+        return obj;
+    }
+    Object.defineProperty(obj, 'length', {
+        value: 1,
+        configurable: true,
+    });
+    Object.defineProperty(obj, 0, {
+        value: obj,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+    });
+    Object.defineProperty(obj, Symbol.iterator, {
+        value: function* () {
+            yield this;
+        },
+        configurable: true,
+    });
+    return obj;
+}

package/dist/esm/utilities/metadataProvider/naturalizedHandlers.d.ts

@@ -0,0 +1,5 @@
+type Part10Input = ArrayBuffer | Uint8Array | (() => ArrayBuffer | Uint8Array | Promise<ArrayBuffer | Uint8Array>);
+export declare function naturalizeDicomwebMetadata(metadata: Record<string, unknown>): any;
+export declare function naturalizePart10Buffer(part10: Part10Input): Promise<any>;
+export declare function registerNaturalizedHandlers(): void;
+export {};

package/dist/esm/utilities/metadataProvider/naturalizedHandlers.js

@@ -0,0 +1,67 @@
+import dcmjs from 'dcmjs';
+import { MetadataModules } from '../../enums';
+import { addAddProvider, addTypedProvider } from '../../metaData';
+import { MetaDataIterator, NaturalTagListener } from '../dicomStream';
+import { baseImageIdQueryFilter } from './imageIdsProviders';
+const { AsyncDicomReader } = dcmjs.async;
+const NATURAL_BASE_IMAGE_ID_FILTER_PRIORITY = 60_000;
+const NATURALIZED_ADD_HANDLER_PRIORITY = 30_000;
+function toArrayBuffer(part10Value) {
+    if (part10Value instanceof ArrayBuffer) {
+        return part10Value;
+    }
+    return part10Value.buffer.slice(part10Value.byteOffset, part10Value.byteOffset + part10Value.byteLength);
+}
+async function resolvePart10Input(part10) {
+    const resolvedValue = typeof part10 === 'function' ? await part10() : part10;
+    if (!(resolvedValue instanceof ArrayBuffer) &&
+        !(resolvedValue instanceof Uint8Array)) {
+        throw new Error('part10 must resolve to ArrayBuffer or Uint8Array');
+    }
+    return toArrayBuffer(resolvedValue);
+}
+export function naturalizeDicomwebMetadata(metadata) {
+    const iterator = new MetaDataIterator(metadata);
+    const listener = NaturalTagListener.createMetadataListener();
+    listener.startObject();
+    iterator.syncIterator(listener);
+    return listener.pop();
+}
+export async function naturalizePart10Buffer(part10) {
+    const arrayBuffer = await resolvePart10Input(part10);
+    const reader = new AsyncDicomReader();
+    const listener = NaturalTagListener.createMetadataListener();
+    reader.stream.addBuffer(arrayBuffer);
+    reader.stream.setComplete();
+    await reader.readFile({ listener });
+    const naturalized = reader.dict;
+    const transferSyntaxUid = reader.syntax;
+    if (transferSyntaxUid) {
+        naturalized.TransferSyntaxUID = Array.isArray(transferSyntaxUid)
+            ? transferSyntaxUid[0]
+            : transferSyntaxUid;
+    }
+    return naturalized;
+}
+function naturalizedAddProvider(next, query, data, options) {
+    const dicomwebJson = options?.dicomwebJson ?? options?.metadata;
+    if (dicomwebJson && typeof dicomwebJson === 'object') {
+        return naturalizeDicomwebMetadata(dicomwebJson);
+    }
+    const part10Buffer = options?.part10Buffer ?? options?.part10;
+    if (part10Buffer) {
+        return naturalizePart10Buffer(part10Buffer);
+    }
+    return next(query, data, options);
+}
+export function registerNaturalizedHandlers() {
+    addTypedProvider(MetadataModules.NATURALIZED, baseImageIdQueryFilter, {
+        priority: NATURAL_BASE_IMAGE_ID_FILTER_PRIORITY,
+    });
+    addAddProvider(MetadataModules.NATURALIZED, baseImageIdQueryFilter, {
+        priority: NATURAL_BASE_IMAGE_ID_FILTER_PRIORITY,
+    });
+    addAddProvider(MetadataModules.NATURALIZED, naturalizedAddProvider, {
+        priority: NATURALIZED_ADD_HANDLER_PRIORITY,
+    });
+}

package/dist/esm/utilities/metadataProvider/pixelDataUpdate.d.ts

@@ -0,0 +1,2 @@
+export declare function pixelDataUpdate(next: any, query: any, data: any, options: any): any;
+export declare function registerPixelDataUpdate(): void;