@cornerstonejs/metadata 5.0.0

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

@@ -0,0 +1,39 @@
+interface CacheGetOptions {
+    noCache?: boolean;
+    reCache?: boolean;
+}
+export declare class CacheData {
+    protected static readonly mapCacheData: Map<string, Map<string, unknown>>;
+    protected static readonly secondaryTypesByBaseType: Map<string, Set<string>>;
+    protected static setCacheDataInternal(type: string, query: string, value: unknown): void;
+    protected static clearRelatedDerivedCache(type: string, query: string): void;
+    static registerSecondaryTypes(secondaryType: string, secondaryOf?: string | string[]): void;
+    static getCacheData(type: string, query: string): unknown;
+    static hasCacheData(type: string, query: string): boolean;
+    static clearCacheData(): void;
+    static clearTypedCacheData(type: string, query?: string): void;
+    static fromAsyncLookup<T>(type: string, query: string, lookup: () => T | Promise<T>, options?: CacheGetOptions): T | Promise<T> | undefined;
+    createTypeCacheProvider(type: string): (next: any, query: string, data: any, options: any) => any;
+    clearCacheData(): void;
+    clearTypedCacheData(type: string, query?: string): void;
+    getCacheData(type: string, query: string): unknown;
+    hasCacheData(type: string, query: string): boolean;
+    fromAsyncLookup<T>(type: string, query: string, lookup: () => T | Promise<T>, options?: CacheGetOptions): T | Promise<T>;
+}
+export declare class WritableCacheData extends CacheData {
+    static setCacheData(type: string, query: string, value: unknown): void;
+    setCacheData(type: string, query: string, value: unknown): void;
+}
+export declare const cacheData: CacheData;
+export declare function createTypeCacheProvider(type: string): (next: any, query: string, data: any, options: any) => any;
+export declare function createTypeWritableCacheProvider(type: string): (next: any, query: string, data: any, options: any) => any;
+export declare function clearCacheData(): void;
+export declare function clearTypedCacheData(type: string, query?: string): void;
+export declare function setCacheData(type: string, query: string, value: unknown): void;
+export declare function getCacheData(type: string, query: string): unknown;
+export declare function hasCacheData(type: string, query: string): boolean;
+export declare function fromAsyncLookup<T>(type: string, query: string, lookup: () => T | Promise<T>, options?: CacheGetOptions): T | Promise<T>;
+export declare function addCacheForType(type: string, options?: any): void;
+export declare function addWritableCacheForType(type: string, options?: any): void;
+export declare function registerCacheProviders(): void;
+export {};

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

@@ -0,0 +1,235 @@
+import { getAddModuleType, MetadataModules } from '../../enums';
+import { addAddProvider, addTypedProvider, clear, clearQuery, getMetaData, } from '../../metaData';
+import { BASE_IMAGE_ID, FRAME_IMAGE_IDS } from './imageIdsProviders';
+export class CacheData {
+    static setCacheDataInternal(type, query, value) {
+        let valueMap = this.mapCacheData.get(type);
+        if (!valueMap) {
+            valueMap = new Map();
+            this.mapCacheData.set(type, valueMap);
+        }
+        valueMap.set(query, value);
+        this.clearRelatedDerivedCache(type, query);
+    }
+    static clearRelatedDerivedCache(type, query) {
+        const derivedTypes = this.secondaryTypesByBaseType.get(type);
+        if (!derivedTypes?.size) {
+            return;
+        }
+        const frameImageIds = getMetaData(FRAME_IMAGE_IDS, query) ??
+            new Set([query]);
+        for (const frameImageId of frameImageIds) {
+            for (const derivedType of derivedTypes) {
+                const typeMap = this.mapCacheData.get(derivedType);
+                typeMap?.delete(frameImageId);
+            }
+        }
+    }
+    static registerSecondaryTypes(secondaryType, secondaryOf) {
+        if (!secondaryOf) {
+            return;
+        }
+        const baseTypes = Array.isArray(secondaryOf) ? secondaryOf : [secondaryOf];
+        for (const baseType of baseTypes) {
+            let secondaryTypes = this.secondaryTypesByBaseType.get(baseType);
+            if (!secondaryTypes) {
+                secondaryTypes = new Set();
+                this.secondaryTypesByBaseType.set(baseType, secondaryTypes);
+            }
+            secondaryTypes.add(secondaryType);
+        }
+    }
+    static getCacheData(type, query) {
+        return this.mapCacheData.get(type)?.get(query);
+    }
+    static hasCacheData(type, query) {
+        return this.mapCacheData.get(type)?.has(query) === true;
+    }
+    static clearCacheData() {
+        this.mapCacheData.clear();
+        this.secondaryTypesByBaseType.clear();
+        clear(FRAME_IMAGE_IDS);
+        clear(BASE_IMAGE_ID);
+    }
+    static clearTypedCacheData(type, query) {
+        const secondaryTypes = this.secondaryTypesByBaseType.get(type);
+        const valueMap = this.mapCacheData.get(type);
+        if (query) {
+            valueMap?.delete(query);
+            if (secondaryTypes?.size) {
+                for (const secondaryType of secondaryTypes) {
+                    this.mapCacheData.get(secondaryType)?.delete(query);
+                }
+            }
+            if (type === MetadataModules.NATURALIZED || secondaryTypes?.size) {
+                clearQuery(FRAME_IMAGE_IDS, query);
+                clearQuery(BASE_IMAGE_ID, query);
+            }
+            return;
+        }
+        valueMap?.clear();
+        if (secondaryTypes?.size) {
+            for (const secondaryType of secondaryTypes) {
+                this.mapCacheData.get(secondaryType)?.clear();
+            }
+        }
+        if (type === MetadataModules.NATURALIZED || secondaryTypes?.size) {
+            clear(FRAME_IMAGE_IDS);
+            clear(BASE_IMAGE_ID);
+        }
+    }
+    static fromAsyncLookup(type, query, lookup, options) {
+        if (options?.noCache !== true && options?.reCache !== true) {
+            const cachedValue = this.getCacheData(type, query);
+            if (cachedValue !== undefined) {
+                return cachedValue;
+            }
+        }
+        const lookupValue = lookup();
+        if (lookupValue === undefined) {
+            return undefined;
+        }
+        if (!(lookupValue instanceof Promise)) {
+            if (!options?.noCache) {
+                this.setCacheDataInternal(type, query, lookupValue);
+            }
+            return lookupValue;
+        }
+        return lookupValue.then((resolvedValue) => {
+            if (resolvedValue !== undefined && !options?.noCache) {
+                this.setCacheDataInternal(type, query, resolvedValue);
+            }
+            return resolvedValue;
+        });
+    }
+    createTypeCacheProvider(type) {
+        return createTypeCacheProvider(type);
+    }
+    clearCacheData() {
+        CacheData.clearCacheData();
+    }
+    clearTypedCacheData(type, query) {
+        CacheData.clearTypedCacheData(type, query);
+    }
+    getCacheData(type, query) {
+        return CacheData.getCacheData(type, query);
+    }
+    hasCacheData(type, query) {
+        return CacheData.hasCacheData(type, query);
+    }
+    fromAsyncLookup(type, query, lookup, options) {
+        return CacheData.fromAsyncLookup(type, query, lookup, options);
+    }
+}
+CacheData.mapCacheData = new Map();
+CacheData.secondaryTypesByBaseType = new Map();
+export class WritableCacheData extends CacheData {
+    static setCacheData(type, query, value) {
+        this.setCacheDataInternal(type, query, value);
+    }
+    setCacheData(type, query, value) {
+        WritableCacheData.setCacheData(type, query, value);
+    }
+}
+export const cacheData = new WritableCacheData();
+export function createTypeCacheProvider(type) {
+    return (next, query, data, options) => {
+        return CacheData.fromAsyncLookup(type, query, () => next(query, data, options), options);
+    };
+}
+export function createTypeWritableCacheProvider(type) {
+    const addType = getAddModuleType(type);
+    return (next, query, data, options) => {
+        const cachedValue = CacheData.getCacheData(type, query);
+        if (cachedValue !== undefined) {
+            console.warn(`Metadata add skipped for "${type}" at query "${query}" because cache already has a value.`);
+            return cachedValue;
+        }
+        const addCachedValue = CacheData.getCacheData(addType, query);
+        if (addCachedValue !== undefined) {
+            return addCachedValue;
+        }
+        const nextValue = next(query, data, options);
+        if (nextValue === undefined) {
+            return undefined;
+        }
+        if (!(nextValue instanceof Promise)) {
+            WritableCacheData.setCacheData(type, query, nextValue);
+            return nextValue;
+        }
+        const managedPromise = nextValue
+            .then((resolvedValue) => {
+            if (resolvedValue !== undefined) {
+                WritableCacheData.setCacheData(type, query, resolvedValue);
+            }
+            return resolvedValue;
+        })
+            .finally(() => {
+            CacheData.clearTypedCacheData(addType, query);
+        });
+        WritableCacheData.setCacheData(addType, query, managedPromise);
+        return managedPromise;
+    };
+}
+export function clearCacheData() {
+    CacheData.clearCacheData();
+}
+export function clearTypedCacheData(type, query) {
+    CacheData.clearTypedCacheData(type, query);
+}
+export function setCacheData(type, query, value) {
+    WritableCacheData.setCacheData(type, query, value);
+}
+export function getCacheData(type, query) {
+    return CacheData.getCacheData(type, query);
+}
+export function hasCacheData(type, query) {
+    return CacheData.hasCacheData(type, query);
+}
+export function fromAsyncLookup(type, query, lookup, options) {
+    return CacheData.fromAsyncLookup(type, query, lookup, options);
+}
+export function addCacheForType(type, options) {
+    const { secondaryOf, ...providerOptions } = (options ??
+        {});
+    CacheData.registerSecondaryTypes(type, secondaryOf);
+    addTypedProvider(type, createTypeCacheProvider(type), {
+        priority: 50_000,
+        clear: clearTypedCacheData.bind(null, type),
+        clearQuery: clearTypedCacheData.bind(null, type),
+        ...providerOptions,
+    });
+}
+export function addWritableCacheForType(type, options) {
+    const addType = getAddModuleType(type);
+    const { secondaryOf, ...providerOptions } = (options ??
+        {});
+    addCacheForType(type, { secondaryOf, ...providerOptions });
+    CacheData.registerSecondaryTypes(addType, type);
+    addAddProvider(type, createTypeWritableCacheProvider(type), {
+        priority: 50_000,
+        clear: clearTypedCacheData.bind(null, addType),
+        clearQuery: clearTypedCacheData.bind(null, addType),
+        ...providerOptions,
+    });
+}
+export function registerCacheProviders() {
+    addCacheForType(BASE_IMAGE_ID);
+    addCacheForType(FRAME_IMAGE_IDS);
+    addWritableCacheForType(MetadataModules.NATURALIZED);
+    addCacheForType(MetadataModules.INSTANCE, {
+        secondaryOf: MetadataModules.NATURALIZED,
+    });
+    addCacheForType(MetadataModules.URI_MODULE, {
+        secondaryOf: MetadataModules.NATURALIZED,
+    });
+    addCacheForType(MetadataModules.IMAGE_PLANE, {
+        secondaryOf: MetadataModules.NATURALIZED,
+    });
+    addCacheForType(MetadataModules.FRAME_MODULE, {
+        secondaryOf: MetadataModules.NATURALIZED,
+    });
+    addCacheForType(MetadataModules.GENERAL_IMAGE, {
+        secondaryOf: MetadataModules.NATURALIZED,
+    });
+}

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

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

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

@@ -0,0 +1,25 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider, toLowerCamelTag } from '../../metaData';
+export function calibrationModuleProvider(next, query, data, options) {
+    if (!data) {
+        return next(query, data, options);
+    }
+    if (!data.SequenceOfUltrasoundRegions?.length) {
+        return;
+    }
+    const { SequenceOfUltrasoundRegions } = data;
+    const sequenceOfUltrasoundRegions = [];
+    for (const sequenceItem of SequenceOfUltrasoundRegions) {
+        const newItem = {};
+        sequenceOfUltrasoundRegions.push(newItem);
+        for (const [key, value] of Object.entries(sequenceItem)) {
+            newItem[toLowerCamelTag(key)] = value;
+        }
+    }
+    return {
+        sequenceOfUltrasoundRegions,
+    };
+}
+export function registerCalibrationModule() {
+    addTypedProvider(MetadataModules.CALIBRATION, calibrationModuleProvider);
+}

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

@@ -0,0 +1,5 @@
+export declare const combineFrameInstance: (frame: any, instance: any) => any;
+export declare function createCombinedValue(parent: any, functionalGroups: any, key: any): any;
+export declare const combineFrameProvider: (next: any, query: any, instance: any, options: any) => any;
+export declare function registerCombineFrameProvider(): void;
+export default combineFrameInstance;

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

@@ -0,0 +1,158 @@
+import { vec3 } from 'gl-matrix';
+import { dicomSplit } from './dicomSplit';
+import { addTypedProvider, getMetaData } from '../../metaData';
+import { MetadataModules } from '../../enums';
+import { isEqual } from '../isEqual';
+export const combineFrameInstance = (frame, instance) => {
+    const { PerFrameFunctionalGroupsSequence, SharedFunctionalGroupsSequence, NumberOfFrames, ImageType, } = instance;
+    if (NumberOfFrames < 2) {
+        return instance;
+    }
+    instance.ImageType = dicomSplit(ImageType);
+    const frameNumber = Number.parseInt(frame || 1);
+    const hasDetectorButMissingSpatialInfo = instance.DetectorInformationSequence &&
+        (!instance.ImagePositionPatient || !instance.ImageOrientationPatient);
+    if ((PerFrameFunctionalGroupsSequence && SharedFunctionalGroupsSequence) ||
+        hasDetectorButMissingSpatialInfo) {
+        if (!instance.ImageOrientationPatient &&
+            instance.DetectorInformationSequence) {
+            instance.ImageOrientationPatient =
+                instance.DetectorInformationSequence[0].ImageOrientationPatient;
+        }
+        const rootImagePositionPatient = instance.ImagePositionPatient;
+        let detectorDerivedImagePositionPatient;
+        if (!instance.ImagePositionPatient &&
+            instance.DetectorInformationSequence) {
+            let imagePositionPatient = instance.DetectorInformationSequence[0].ImagePositionPatient;
+            let imageOrientationPatient = instance.ImageOrientationPatient;
+            imagePositionPatient = imagePositionPatient?.map((it) => Number(it));
+            imageOrientationPatient = imageOrientationPatient?.map((it) => Number(it));
+            const SpacingBetweenSlices = Number(instance.SpacingBetweenSlices);
+            if (imageOrientationPatient && SpacingBetweenSlices) {
+                const rowOrientation = vec3.fromValues(imageOrientationPatient[0], imageOrientationPatient[1], imageOrientationPatient[2]);
+                const colOrientation = vec3.fromValues(imageOrientationPatient[3], imageOrientationPatient[4], imageOrientationPatient[5]);
+                const normalVector = vec3.cross(vec3.create(), rowOrientation, colOrientation);
+                const position = vec3.scaleAndAdd(vec3.create(), imagePositionPatient, normalVector, SpacingBetweenSlices * (frameNumber - 1));
+                detectorDerivedImagePositionPatient = [
+                    position[0],
+                    position[1],
+                    position[2],
+                ];
+            }
+        }
+        if (!instance._parentInstance) {
+            Object.defineProperty(instance, '_parentInstance', {
+                value: { ...instance },
+            });
+        }
+        const sharedInstance = createCombinedValue(instance._parentInstance, SharedFunctionalGroupsSequence?.[0], '_shared');
+        const newInstance = createCombinedValue(sharedInstance, PerFrameFunctionalGroupsSequence?.[frameNumber - 1], frameNumber);
+        if (detectorDerivedImagePositionPatient) {
+            newInstance.ImagePositionPatient = detectorDerivedImagePositionPatient;
+        }
+        else if (!newInstance.ImagePositionPatient && rootImagePositionPatient) {
+            newInstance.ImagePositionPatient = rootImagePositionPatient;
+        }
+        else if (!newInstance.ImagePositionPatient) {
+            newInstance.ImagePositionPatient = [0, 0, frameNumber];
+        }
+        Object.defineProperty(newInstance, 'frameNumber', {
+            value: frameNumber,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+        return newInstance;
+    }
+    if (instance.GridFrameOffsetVector) {
+        if (!instance._parentInstance) {
+            Object.defineProperty(instance, '_parentInstance', {
+                value: { ...instance },
+            });
+        }
+        const sharedInstance = createCombinedValue(instance._parentInstance, SharedFunctionalGroupsSequence?.[0], '_shared');
+        const newInstance = createCombinedValue(sharedInstance, PerFrameFunctionalGroupsSequence?.[frameNumber - 1], frameNumber);
+        const origin = newInstance.ImagePositionPatient?.map(Number);
+        const orientation = newInstance.ImageOrientationPatient?.map(Number);
+        const offsets = instance.GridFrameOffsetVector;
+        const firstOffset = Number(offsets[0]);
+        const offset = Number(offsets[frameNumber - 1]);
+        if (origin && orientation && !Number.isNaN(offset)) {
+            const isIdentityAxialOrientation = isEqual(orientation[0], 1) &&
+                isEqual(orientation[1], 0) &&
+                isEqual(orientation[2], 0) &&
+                isEqual(orientation[3], 0) &&
+                isEqual(orientation[4], 1) &&
+                isEqual(orientation[5], 0);
+            const isRelativeOffsetForm = isEqual(firstOffset, 0);
+            const isAbsolutePatientZForm = isIdentityAxialOrientation && isEqual(firstOffset, origin[2]);
+            if (isAbsolutePatientZForm) {
+                newInstance.ImagePositionPatient = [origin[0], origin[1], offset];
+            }
+            else if (isRelativeOffsetForm) {
+                const row = vec3.fromValues(orientation[0], orientation[1], orientation[2]);
+                const col = vec3.fromValues(orientation[3], orientation[4], orientation[5]);
+                const normal = vec3.cross(vec3.create(), row, col);
+                const position = vec3.scaleAndAdd(vec3.create(), origin, normal, offset);
+                newInstance.ImagePositionPatient = [
+                    position[0],
+                    position[1],
+                    position[2],
+                ];
+            }
+        }
+        Object.defineProperty(newInstance, 'frameNumber', {
+            value: frameNumber,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+        return newInstance;
+    }
+    return instance;
+};
+export function createCombinedValue(parent, functionalGroups, key) {
+    if (parent[key]) {
+        return parent[key];
+    }
+    const newInstance = Object.create(parent);
+    Object.defineProperty(parent, key, {
+        value: newInstance,
+        writable: false,
+        enumerable: false,
+    });
+    if (!functionalGroups) {
+        return newInstance;
+    }
+    const shared = functionalGroups
+        ? Object.values(functionalGroups)
+            .filter(Boolean)
+            .map((it) => it[0])
+            .filter((it) => typeof it === 'object')
+        : [];
+    [...shared].forEach((item) => {
+        if (item.SOPInstanceUID) {
+            return;
+        }
+        Object.entries(item).forEach(([key, value]) => {
+            newInstance[key] = value;
+        });
+    });
+    return newInstance;
+}
+export const combineFrameProvider = (next, query, instance, options) => {
+    if (!instance) {
+        return next(query, instance, options);
+    }
+    if (!instance.NumberOfFrames) {
+        return instance;
+    }
+    const uriModule = getMetaData(MetadataModules.URI_MODULE, query, options?.frameModule);
+    const { frameNumber = 1 } = uriModule || {};
+    const combined = combineFrameInstance(frameNumber, instance);
+    return combined;
+};
+export function registerCombineFrameProvider() {
+    addTypedProvider(MetadataModules.INSTANCE, combineFrameProvider);
+}
+export default combineFrameInstance;

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

@@ -0,0 +1 @@
+export declare function registerCompressedFrameDataProvider(): void;

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

@@ -0,0 +1,133 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider } from '../../metaData';
+const PIXEL_DATA_KEYS = [
+    'PixelData',
+    'FramePixelData',
+    'FloatPixelData',
+    '7FE00010',
+    '7fe00010',
+    '7FE00008',
+    '7fe00008',
+];
+const PARAMAP_PIXEL_DATA_KEYS = ['FloatPixelData', '7FE00008', '7fe00008'];
+function getPixelDataFromNatural(natural) {
+    for (const key of PIXEL_DATA_KEYS) {
+        const val = natural[key];
+        if (val !== undefined &&
+            val !== null &&
+            Array.isArray(val) &&
+            val.length > 0) {
+            return val;
+        }
+    }
+    return undefined;
+}
+function getPixelDataKeyFromNatural(natural) {
+    for (const key of PIXEL_DATA_KEYS) {
+        const val = natural[key];
+        if (val !== undefined &&
+            val !== null &&
+            Array.isArray(val) &&
+            val.length > 0) {
+            return key;
+        }
+    }
+    return undefined;
+}
+function isParamapType(natural) {
+    const key = getPixelDataKeyFromNatural(natural);
+    return key !== undefined && PARAMAP_PIXEL_DATA_KEYS.includes(key);
+}
+function asView(buf) {
+    if (buf instanceof ArrayBuffer) {
+        return new Uint8Array(buf);
+    }
+    return buf;
+}
+function byteLength(buf) {
+    if (buf instanceof ArrayBuffer) {
+        return buf.byteLength;
+    }
+    return buf.byteLength;
+}
+function getFramePixelData(pixelDataTag, frameIndex) {
+    const frame = pixelDataTag[frameIndex];
+    if (frame === undefined || frame === null) {
+        return undefined;
+    }
+    if (Array.isArray(frame)) {
+        return frame.map(asView);
+    }
+    return asView(frame);
+}
+function getFramePixelDataFromSingleBuffer(pixelDataTag, frameIndex, numberOfFrames, natural) {
+    if (pixelDataTag.length !== 1 || !isParamapType(natural)) {
+        return undefined;
+    }
+    const buf = pixelDataTag[0];
+    if (buf === undefined || buf === null) {
+        return undefined;
+    }
+    const view = asView(buf);
+    const totalLength = byteLength(buf);
+    if (numberOfFrames <= 0 || totalLength % numberOfFrames !== 0) {
+        return undefined;
+    }
+    const frameSize = totalLength / numberOfFrames;
+    const offset = frameIndex * frameSize;
+    if (offset + frameSize > totalLength) {
+        return undefined;
+    }
+    console.warn('[compressedFrameData] Splitting single-buffer pixel data by numberOfFrames for paramap-type image; frameIndex=', frameIndex, ', numberOfFrames=', numberOfFrames, ', frameSize=', frameSize);
+    const u8 = view instanceof Uint8Array
+        ? view
+        : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+    return [u8.subarray(offset, offset + frameSize)];
+}
+function compressedFrameDataFromNatural(natural, frameIndex) {
+    if (!natural) {
+        return;
+    }
+    const pixelDataTag = getPixelDataFromNatural(natural);
+    if (!pixelDataTag) {
+        return;
+    }
+    const { TransferSyntaxUID: transferSyntaxUid } = natural;
+    if (!transferSyntaxUid) {
+        return;
+    }
+    const frameOfInterest = frameIndex ?? 0;
+    const frameNumber = frameOfInterest + 1;
+    const numberOfFrames = natural.NumberOfFrames != null ? Number(natural.NumberOfFrames) : 1;
+    let pixelData;
+    if (pixelDataTag.length === numberOfFrames) {
+        pixelData = getFramePixelData(pixelDataTag, frameOfInterest);
+    }
+    else {
+        pixelData = getFramePixelDataFromSingleBuffer(pixelDataTag, frameOfInterest, numberOfFrames, natural);
+        if (pixelData === undefined) {
+            pixelData = getFramePixelData(pixelDataTag, frameOfInterest);
+        }
+    }
+    if (pixelData === undefined) {
+        return;
+    }
+    return {
+        transferSyntaxUid,
+        frameOfInterest,
+        frameNumber,
+        pixelData,
+    };
+}
+const COMPRESSED_FRAME_DATA_TYPE = MetadataModules.COMPRESSED_FRAME_DATA;
+const compressedFrameDataProvider = (next, query, natural, options) => {
+    const frameIndex = options?.frameIndex ?? 0;
+    const value = compressedFrameDataFromNatural(natural, frameIndex);
+    if (value) {
+        return value;
+    }
+    return next(query, natural, options);
+};
+export function registerCompressedFrameDataProvider() {
+    addTypedProvider(COMPRESSED_FRAME_DATA_TYPE, compressedFrameDataProvider);
+}

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

@@ -0,0 +1,7 @@
+export declare function dataLookup(dataType: string): (next: any, query: any, data: any, options: any) => any;
+export declare const instanceLookup: (next: any, query: any, data: any, options: any) => any;
+export declare const naturalLookup: (next: any, query: any, data: any, options: any) => any;
+export declare const DATA_PRIORITY: {
+    priority: number;
+};
+export declare function registerDataLookup(): void;

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

@@ -0,0 +1,18 @@
+import { MetadataModules } from '../../enums';
+import { addTypedProvider, metadataModuleProvider } from '../../metaData';
+export function dataLookup(dataType) {
+    return (next, query, data, options) => {
+        data ||= metadataModuleProvider(dataType, query, options?.[dataType]);
+        return next(query, data, options);
+    };
+}
+export const instanceLookup = dataLookup(MetadataModules.INSTANCE);
+export const naturalLookup = dataLookup(MetadataModules.NATURALIZED);
+export const DATA_PRIORITY = { priority: 5000 };
+export function registerDataLookup() {
+    addTypedProvider(MetadataModules.INSTANCE, dataLookup(MetadataModules.NATURALIZED), DATA_PRIORITY);
+    addTypedProvider(MetadataModules.IMAGE_PLANE, instanceLookup, DATA_PRIORITY);
+    addTypedProvider(MetadataModules.CALIBRATION, instanceLookup, DATA_PRIORITY);
+    addTypedProvider(MetadataModules.COMPRESSED_FRAME_DATA, naturalLookup, DATA_PRIORITY);
+    addTypedProvider(MetadataModules.SCALING, naturalLookup, DATA_PRIORITY);
+}

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

@@ -0,0 +1 @@
+export declare function dicomSplit(value: any): any;

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

@@ -0,0 +1,5 @@
+export function dicomSplit(value) {
+    return ((Array.isArray(value) && value) ||
+        (typeof value === 'string' && value.split('\\')) ||
+        value);
+}

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

@@ -0,0 +1,18 @@
+export interface EcgModuleFull {
+    numberOfWaveformChannels: number;
+    numberOfWaveformSamples: number;
+    samplingFrequency: number;
+    waveformBitsAllocated: number;
+    waveformSampleInterpretation: string;
+    multiplexGroupLabel: string;
+    channelDefinitionSequence: Array<{
+        channelSourceSequence?: {
+            codeMeaning?: string;
+        };
+    }>;
+    waveformData: {
+        retrieveBulkData: () => Promise<Int16Array[]>;
+    };
+}
+export declare function buildEcgModuleFromInstance(instance: Record<string, unknown>, imageId?: string): EcgModuleFull | null;
+export declare function registerEcgFromInstanceProvider(): void;