@cornerstonejs/metadata 5.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Open Health Imaging Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,12 @@
+export declare enum CalibrationTypes {
+    NOT_APPLICABLE = "",
+    ERMF = "ERMF",
+    USER = "User",
+    PROJECTION = "Proj",
+    REGION = "Region",
+    ERROR = "Error",
+    UNCALIBRATED = "Uncalibrated",
+    CALIBRATED = "Calibrated",
+    UNKNOWN = "Unknown"
+}
+export default CalibrationTypes;

package/dist/esm/enums/CalibrationTypes.js

@@ -0,0 +1,13 @@
+export var CalibrationTypes;
+(function (CalibrationTypes) {
+    CalibrationTypes["NOT_APPLICABLE"] = "";
+    CalibrationTypes["ERMF"] = "ERMF";
+    CalibrationTypes["USER"] = "User";
+    CalibrationTypes["PROJECTION"] = "Proj";
+    CalibrationTypes["REGION"] = "Region";
+    CalibrationTypes["ERROR"] = "Error";
+    CalibrationTypes["UNCALIBRATED"] = "Uncalibrated";
+    CalibrationTypes["CALIBRATED"] = "Calibrated";
+    CalibrationTypes["UNKNOWN"] = "Unknown";
+})(CalibrationTypes || (CalibrationTypes = {}));
+export default CalibrationTypes;

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

@@ -0,0 +1,54 @@
+declare enum MetadataModules {
+    CALIBRATION = "calibrationModule",
+    CINE = "cineModule",
+    FRAME_OF_REFERENCE = "frameOfReferenceModule",
+    GENERAL_IMAGE = "generalImageModule",
+    GENERAL_SERIES = "generalSeriesModule",
+    GENERAL_STUDY = "generalStudyModule",
+    IMAGE_PIXEL = "imagePixelModule",
+    IMAGE_PLANE = "imagePlaneModule",
+    IMAGE_URL = "imageUrlModule",
+    MODALITY_LUT = "modalityLutModule",
+    MULTIFRAME = "multiframeModule",
+    NM_MULTIFRAME_GEOMETRY = "nmMultiframeGeometryModule",
+    OVERLAY_PLANE = "overlayPlaneModule",
+    PATIENT = "patientModule",
+    PATIENT_DEMOGRAPHIC = "patientDemographicModule",
+    PATIENT_STUDY = "patientStudyModule",
+    PET_IMAGE = "petImageModule",
+    PET_ISOTOPE = "petIsotopeModule",
+    PET_SERIES = "petSeriesModule",
+    SCALING = "scalingModule",
+    SOP_COMMON = "sopCommonModule",
+    ULTRASOUND_ENHANCED_REGION = "ultrasoundEnhancedRegionModule",
+    ECG = "ecgModule",
+    VOI_LUT = "voiLutModule",
+    TRANSFER_SYNTAX = "transferSyntax",
+    PLANE_ORIENTATION = "PlaneOrientation",
+    PLANE_POSITION = "PlanePosition",
+    PIXEL_MEASURES = "PixelMeasures",
+    XRAY_GEOMETRY = "XrayGeometry",
+    FRAME_PIXEL_DATA = "FramePixelData",
+    FRAME_MODULE = "frameModule",
+    URI_MODULE = "uriModule",
+    WADO_WEB_CLIENT = "wadoWebClient",
+    INSTANCE = "instance",
+    IMAGE_SOP_INSTANCE_REFERENCE = "ImageSopInstanceReference",
+    REFERENCED_SERIES_REFERENCE = "ReferencedSeriesReference",
+    PREDECESSOR_SEQUENCE = "PredecessorSequence",
+    STUDY_DATA = "StudyData",
+    SERIES_DATA = "SeriesData",
+    IMAGE_DATA = "ImageData",
+    RTSS_INSTANCE_DATA = "RtssInstanceData",
+    NEW_INSTANCE_DATA = "NewInstanceData",
+    RTSS_CONTOUR = "metaRTSSContour",
+    SEG_BIT = "metaSegBitmap",
+    SR_ANNOTATION = "metaSrAnnotation",
+    COMPRESSED_FRAME_DATA = "compressedFrameData",
+    BASE_IMAGE_ID = "baseImageId",
+    FRAME_IMAGE_IDS = "frameImageIds",
+    NATURALIZED = "naturalized"
+}
+export declare const ADD_MODULE_TYPE_SUFFIX = "Add";
+export declare function getAddModuleType(type: string): string;
+export default MetadataModules;

package/dist/esm/enums/MetadataModules.js

@@ -0,0 +1,57 @@
+var MetadataModules;
+(function (MetadataModules) {
+    MetadataModules["CALIBRATION"] = "calibrationModule";
+    MetadataModules["CINE"] = "cineModule";
+    MetadataModules["FRAME_OF_REFERENCE"] = "frameOfReferenceModule";
+    MetadataModules["GENERAL_IMAGE"] = "generalImageModule";
+    MetadataModules["GENERAL_SERIES"] = "generalSeriesModule";
+    MetadataModules["GENERAL_STUDY"] = "generalStudyModule";
+    MetadataModules["IMAGE_PIXEL"] = "imagePixelModule";
+    MetadataModules["IMAGE_PLANE"] = "imagePlaneModule";
+    MetadataModules["IMAGE_URL"] = "imageUrlModule";
+    MetadataModules["MODALITY_LUT"] = "modalityLutModule";
+    MetadataModules["MULTIFRAME"] = "multiframeModule";
+    MetadataModules["NM_MULTIFRAME_GEOMETRY"] = "nmMultiframeGeometryModule";
+    MetadataModules["OVERLAY_PLANE"] = "overlayPlaneModule";
+    MetadataModules["PATIENT"] = "patientModule";
+    MetadataModules["PATIENT_DEMOGRAPHIC"] = "patientDemographicModule";
+    MetadataModules["PATIENT_STUDY"] = "patientStudyModule";
+    MetadataModules["PET_IMAGE"] = "petImageModule";
+    MetadataModules["PET_ISOTOPE"] = "petIsotopeModule";
+    MetadataModules["PET_SERIES"] = "petSeriesModule";
+    MetadataModules["SCALING"] = "scalingModule";
+    MetadataModules["SOP_COMMON"] = "sopCommonModule";
+    MetadataModules["ULTRASOUND_ENHANCED_REGION"] = "ultrasoundEnhancedRegionModule";
+    MetadataModules["ECG"] = "ecgModule";
+    MetadataModules["VOI_LUT"] = "voiLutModule";
+    MetadataModules["TRANSFER_SYNTAX"] = "transferSyntax";
+    MetadataModules["PLANE_ORIENTATION"] = "PlaneOrientation";
+    MetadataModules["PLANE_POSITION"] = "PlanePosition";
+    MetadataModules["PIXEL_MEASURES"] = "PixelMeasures";
+    MetadataModules["XRAY_GEOMETRY"] = "XrayGeometry";
+    MetadataModules["FRAME_PIXEL_DATA"] = "FramePixelData";
+    MetadataModules["FRAME_MODULE"] = "frameModule";
+    MetadataModules["URI_MODULE"] = "uriModule";
+    MetadataModules["WADO_WEB_CLIENT"] = "wadoWebClient";
+    MetadataModules["INSTANCE"] = "instance";
+    MetadataModules["IMAGE_SOP_INSTANCE_REFERENCE"] = "ImageSopInstanceReference";
+    MetadataModules["REFERENCED_SERIES_REFERENCE"] = "ReferencedSeriesReference";
+    MetadataModules["PREDECESSOR_SEQUENCE"] = "PredecessorSequence";
+    MetadataModules["STUDY_DATA"] = "StudyData";
+    MetadataModules["SERIES_DATA"] = "SeriesData";
+    MetadataModules["IMAGE_DATA"] = "ImageData";
+    MetadataModules["RTSS_INSTANCE_DATA"] = "RtssInstanceData";
+    MetadataModules["NEW_INSTANCE_DATA"] = "NewInstanceData";
+    MetadataModules["RTSS_CONTOUR"] = "metaRTSSContour";
+    MetadataModules["SEG_BIT"] = "metaSegBitmap";
+    MetadataModules["SR_ANNOTATION"] = "metaSrAnnotation";
+    MetadataModules["COMPRESSED_FRAME_DATA"] = "compressedFrameData";
+    MetadataModules["BASE_IMAGE_ID"] = "baseImageId";
+    MetadataModules["FRAME_IMAGE_IDS"] = "frameImageIds";
+    MetadataModules["NATURALIZED"] = "naturalized";
+})(MetadataModules || (MetadataModules = {}));
+export const ADD_MODULE_TYPE_SUFFIX = 'Add';
+export function getAddModuleType(type) {
+    return `${type}${ADD_MODULE_TYPE_SUFFIX}`;
+}
+export default MetadataModules;

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

@@ -0,0 +1,4 @@
+import CalibrationTypes from './CalibrationTypes';
+import MetadataModules from './MetadataModules';
+export { getAddModuleType, ADD_MODULE_TYPE_SUFFIX } from './MetadataModules';
+export { CalibrationTypes, MetadataModules };

package/dist/esm/enums/index.js

@@ -0,0 +1,4 @@
+import CalibrationTypes from './CalibrationTypes';
+import MetadataModules from './MetadataModules';
+export { getAddModuleType, ADD_MODULE_TYPE_SUFFIX } from './MetadataModules';
+export { CalibrationTypes, MetadataModules };

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+import * as calculateSUV from '@cornerstonejs/calculate-suv';
+export * as Enums from './enums';
+export { version } from './version';
+export * as metaData from './metaData';
+export * as utilities from './utilities';
+export * as logging from './utilities/logging';
+export { registerDefaultProviders } from './registerDefaultProviders';
+export type * from './types';
+declare const calculateSUVScalingFactors: typeof calculateSUV.calculateSUVScalingFactors;
+export { calculateSUVScalingFactors };

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+import * as calculateSUV from '@cornerstonejs/calculate-suv';
+export * as Enums from './enums';
+export { version } from './version';
+export * as metaData from './metaData';
+export * as utilities from './utilities';
+export * as logging from './utilities/logging';
+export { registerDefaultProviders } from './registerDefaultProviders';
+const { calculateSUVScalingFactors } = calculateSUV;
+export { calculateSUVScalingFactors };

package/dist/esm/metaData.d.ts

@@ -0,0 +1,33 @@
+import type { MetadataModuleType } from './types';
+export type TypedProviderValue = {
+    provider: TypedProvider;
+    priority: number;
+    isDefault: boolean;
+    clear?: () => void;
+    clearQuery?: (query: string) => void;
+};
+export type TypedProvider = (next: TypedProviderBound, query: string, data?: any, options?: any) => unknown;
+export type TypedProviderBound = (query: string, data?: any, options?: any) => unknown;
+export declare function addProvider(provider: (type: string, ...query: string[]) => unknown, priority?: number): void;
+export interface TypedProviderOptions {
+    priority?: number;
+    requires?: string[];
+    isDefault?: boolean;
+    clear?: () => void;
+    clearQuery?: (query: string) => void;
+}
+export declare function addTypedProvider(type: string, provider: TypedProvider, options?: TypedProviderOptions): void;
+export declare function addAddProvider(type: string, provider: TypedProvider, options?: TypedProviderOptions): void;
+export declare function metadataModuleProvider(type: string, query: string, options: any): unknown;
+export declare function removeProvider(provider: (type: string, query: unknown) => unknown): void;
+export declare function removeAllProviders(): void;
+export declare function getMetaData(type: string, query: string, options?: any): any;
+export declare function getTyped<K extends keyof MetadataModuleType | string>(type: K, query: string, options?: unknown): (K extends keyof MetadataModuleType ? MetadataModuleType[K] : never) | undefined;
+export declare function addMetaData(type: string, query: string, options?: any): unknown;
+export declare function addTyped<K extends keyof MetadataModuleType | string>(type: K, query: string, options?: unknown): (K extends keyof MetadataModuleType ? MetadataModuleType[K] : never) | Promise<K extends keyof MetadataModuleType ? MetadataModuleType[K] : never> | undefined;
+export declare const clearQuery: (type: string, query?: string) => void;
+export declare const clear: (type: string) => void;
+export declare const get: (type: string, ...queries: string[]) => any;
+export declare function getNormalized(imageId: string, types: string[], metaDataProvider?: typeof getMetaData): {};
+export declare const toUpperCamelTag: (tag: string) => string;
+export declare const toLowerCamelTag: (tag: string) => string;

package/dist/esm/metaData.js

@@ -0,0 +1,181 @@
+import { getAddModuleType } from './enums';
+const providers = [];
+const typedProviderValueMap = new Map();
+const typedProviderMap = new Map();
+export function addProvider(provider, priority = 0) {
+    if (providers.some((p) => p.provider === provider)) {
+        return;
+    }
+    let i;
+    for (i = 0; i < providers.length; i++) {
+        if (providers[i].priority <= priority) {
+            break;
+        }
+    }
+    providers.splice(i, 0, {
+        priority,
+        provider,
+    });
+}
+const nullProvider = (_query, _data, options) => options?.defaultValue;
+function insertPriority(type, list, provider, options) {
+    const providerValue = { type, ...options, provider };
+    if (!list.find((it) => it.provider === provider)) {
+        let i;
+        const { priority = 0 } = options;
+        for (i = 0; i < list.length; i++) {
+            if (list[i].priority <= priority) {
+                break;
+            }
+        }
+        list.splice(i, 0, providerValue);
+    }
+    let currentProvider = nullProvider;
+    for (let i = list.length - 1; i >= 0; i--) {
+        const p = list[i].provider;
+        if (p) {
+            currentProvider = p.bind(null, currentProvider);
+        }
+    }
+    return currentProvider;
+}
+export function addTypedProvider(type, provider, options = { priority: 0, isDefault: true }) {
+    if (!provider) {
+        throw new Error(`addTypedProvider: cannot register undefined provider for type "${type}"`);
+    }
+    let list = typedProviderValueMap.get(type);
+    if (!list) {
+        list = new Array();
+        typedProviderValueMap.set(type, list);
+    }
+    if (list.find((it) => it.provider === provider)) {
+        return;
+    }
+    const newProvider = insertPriority(type, list, provider, options);
+    if (!newProvider) {
+        throw new Error(`newProvider is empty for ${type}`);
+    }
+    typedProviderMap.set(type, newProvider);
+}
+export function addAddProvider(type, provider, options = { priority: 0, isDefault: true }) {
+    addTypedProvider(getAddModuleType(type), provider, options);
+}
+export function metadataModuleProvider(type, query, options) {
+    const typedProvider = typedProviderMap.get(type);
+    if (!typedProvider) {
+        return;
+    }
+    return typedProvider(query, null, options);
+}
+export function removeProvider(provider) {
+    for (let i = 0; i < providers.length; i++) {
+        if (providers[i].provider === provider) {
+            providers.splice(i, 1);
+            break;
+        }
+    }
+}
+const TYPED_PROVIDER_BRIDGE_PRIORITY = -1000;
+export function removeAllProviders() {
+    while (providers.length > 0) {
+        providers.pop();
+    }
+    typedProviderValueMap.clear();
+    typedProviderMap.clear();
+}
+export function getMetaData(type, query, options) {
+    if (query === undefined) {
+        return;
+    }
+    for (let i = 0; i < providers.length; i++) {
+        const result = providers[i].provider(type, query, options);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+}
+export function getTyped(type, query, options) {
+    return getMetaData(type, query, options);
+}
+export function addMetaData(type, query, options) {
+    return getMetaData(getAddModuleType(type), query, options);
+}
+export function addTyped(type, query, options) {
+    const result = addMetaData(type, query, options);
+    return result;
+}
+export const clearQuery = (type, query) => {
+    const typesToClear = [type, getAddModuleType(type)];
+    for (const currentType of typesToClear) {
+        const typedProviders = typedProviderValueMap.get(currentType);
+        if (!typedProviders) {
+            continue;
+        }
+        for (const providerInfo of typedProviders) {
+            providerInfo?.clearQuery?.(query);
+        }
+    }
+};
+export const clear = (type) => {
+    const typesToClear = Array.from(new Set([type, getAddModuleType(type)]));
+    for (const currentType of typesToClear) {
+        const typedProviders = typedProviderValueMap.get(currentType);
+        if (!typedProviders) {
+            continue;
+        }
+        for (const providerInfo of typedProviders) {
+            providerInfo?.clear?.();
+        }
+    }
+};
+export const get = (type, ...queries) => queries.length === 1
+    ? getMetaData(type, queries[0])
+    : queries
+        .map((query) => query && getMetaData(type, query))
+        .find((it) => it !== undefined);
+export function getNormalized(imageId, types, metaDataProvider = getMetaData) {
+    const result = {};
+    for (const t of types) {
+        try {
+            const data = metaDataProvider(t, imageId);
+            if (data) {
+                const capitalizedData = {};
+                for (const key in data) {
+                    if (key in data) {
+                        const capitalizedKey = toUpperCamelTag(key);
+                        capitalizedData[capitalizedKey] = data[key];
+                    }
+                }
+                Object.assign(result, capitalizedData);
+            }
+        }
+        catch (error) {
+            console.error(`Error retrieving ${t} data:`, error);
+        }
+    }
+    return result;
+}
+export const toUpperCamelTag = (tag) => {
+    if (tag.startsWith('sop')) {
+        return `SOP${tag.substring(3)}`;
+    }
+    if (tag.startsWith('voi')) {
+        return `VOI${tag.substring(3)}`;
+    }
+    if (tag.endsWith('Id')) {
+        tag = `${tag.substring(0, tag.length - 2)}ID`;
+    }
+    return tag.charAt(0).toUpperCase() + tag.slice(1);
+};
+export const toLowerCamelTag = (tag) => {
+    if (tag.startsWith('SOP')) {
+        return `sop${tag.substring(3)}`;
+    }
+    if (tag.startsWith('VOI')) {
+        return `voi${tag.substring(3)}`;
+    }
+    if (tag.endsWith('ID') && !tag.endsWith('UID')) {
+        tag = `${tag.substring(0, tag.length - 2)}Id`;
+    }
+    return tag.charAt(0).toLowerCase() + tag.slice(1);
+};

package/dist/esm/registerDefaultProviders.d.ts

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

package/dist/esm/registerDefaultProviders.js

@@ -0,0 +1,38 @@
+import { addProvider, metadataModuleProvider } from './metaData';
+import calibratedPixelSpacingMetadataProvider from './utilities/calibratedPixelSpacingMetadataProvider';
+import { registerCacheProviders } from './utilities/metadataProvider/cacheData';
+import { registerUriModule } from './utilities/metadataProvider/uriModule';
+import { registerDataLookup } from './utilities/metadataProvider/dataLookup';
+import { registerInstanceFromListener } from './utilities/metadataProvider/instanceFromListener';
+import { registerCombineFrameProvider } from './utilities/metadataProvider/combineFrameInstance';
+import { clearTagModules, registerTagModules, } from './utilities/metadataProvider/tagModules';
+import { registerImagePlaneCalibrated } from './utilities/metadataProvider/imagePlaneCalibrated';
+import { registerCalibrationModule } from './utilities/metadataProvider/calibrationModule';
+import { registerPixelDataUpdate } from './utilities/metadataProvider/pixelDataUpdate';
+import { registerTransferSyntaxProvider } from './utilities/metadataProvider/transferSyntaxProvider';
+import { registerEcgFromInstanceProvider } from './utilities/metadataProvider/ecgFromInstance';
+import { registerCompressedFrameDataProvider } from './utilities/metadataProvider/compressedFrameData';
+import { registerScalingFromInstanceProvider } from './utilities/metadataProvider/scalingFromInstance';
+import { registerNaturalizedHandlers } from './utilities/metadataProvider/naturalizedHandlers';
+import { registerImageIdProviders } from './utilities/metadataProvider/imageIdsProviders';
+const TYPED_PROVIDER_BRIDGE_PRIORITY = -1000;
+export function registerDefaultProviders() {
+    addProvider(metadataModuleProvider, TYPED_PROVIDER_BRIDGE_PRIORITY);
+    addProvider(calibratedPixelSpacingMetadataProvider.get);
+    clearTagModules();
+    registerCacheProviders();
+    registerNaturalizedHandlers();
+    registerUriModule();
+    registerImageIdProviders();
+    registerDataLookup();
+    registerInstanceFromListener();
+    registerCombineFrameProvider();
+    registerTagModules();
+    registerEcgFromInstanceProvider();
+    registerImagePlaneCalibrated();
+    registerCalibrationModule();
+    registerPixelDataUpdate();
+    registerTransferSyntaxProvider();
+    registerCompressedFrameDataProvider();
+    registerScalingFromInstanceProvider();
+}

package/dist/esm/types/DicomStreamTypes.d.ts

@@ -0,0 +1,13 @@
+export interface IListenerInfo {
+    vr?: string;
+    vm?: number | string;
+    length?: number;
+    name?: string;
+}
+export type MetadataValueType = ArrayBuffer[] | ArrayBuffer | string | number | MetadataType;
+export interface MetadataType {
+    Value?: MetadataValueType[];
+    BulkDataURI?: string;
+    BulkDataUUID?: string;
+    vr: string;
+}

package/dist/esm/types/IImageCalibration.d.ts

@@ -0,0 +1,11 @@
+import type CalibrationTypes from '../enums/CalibrationTypes';
+export interface IImageCalibration {
+    rowPixelSpacing?: number;
+    columnPixelSpacing?: number;
+    scale?: number;
+    aspect?: number;
+    type: CalibrationTypes;
+    tooltip?: string;
+    sequenceOfUltrasoundRegions?: Record<string, unknown>[];
+}
+export type { IImageCalibration as default };

package/dist/esm/types/MetadataModuleTypes.d.ts

@@ -0,0 +1,100 @@
+export interface DicomDateObject {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface DicomTimeObject {
+    hours: number;
+    minutes?: number;
+    seconds?: number;
+    fractionalSeconds?: number;
+}
+export interface GeneralSeriesModuleMetadata {
+    modality: string;
+    seriesInstanceUID: string;
+    seriesNumber: number;
+    studyInstanceUID: string;
+    seriesDate: string;
+    seriesTime: string;
+}
+export interface PatientStudyModuleMetadata {
+    patientAge: number;
+    patientSize: number;
+    patientWeight: number;
+}
+export interface ImagePlaneModuleMetadata {
+    frameOfReferenceUID: string;
+    rows: number;
+    columns: number;
+    imageOrientationPatient: number[];
+    rowCosines: number[];
+    columnCosines: number[];
+    imagePositionPatient: number[];
+    sliceThickness?: number;
+    sliceLocation: number;
+    pixelSpacing: number[];
+    rowPixelSpacing: number | null;
+    columnPixelSpacing: number | null;
+    usingDefaultValues?: boolean;
+}
+export interface ImagePixelModuleMetadata {
+    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 SopCommonModuleMetadata {
+    sopClassUID: string;
+    sopInstanceUID: string;
+}
+export interface EcgModuleMetadata {
+    modality: string;
+    sopInstanceUID: string;
+    sopClassUID: string;
+    seriesDescription?: string;
+    seriesNumber?: number;
+    seriesDate?: string;
+    seriesTime?: string;
+    seriesInstanceUID: string;
+    studyInstanceUID: string;
+}
+export interface FrameMetadata extends SopCommonModuleMetadata {
+    frameNumber: number;
+    numberOfFrames: number;
+}
+export interface TransferSyntaxMetadata {
+    transferSyntaxUID: string;
+}
+export interface CompressedFrameDataMetadata {
+    transferSyntaxUid: string;
+    frameOfInterest: number;
+    frameNumber: number;
+    pixelData: ArrayBufferView | ArrayBufferView[];
+}
+export interface MetadataModuleType {
+    baseImageId: string;
+    frameImageIds: Set<string>;
+    generalSeriesModule: GeneralSeriesModuleMetadata;
+    patientStudyModule: PatientStudyModuleMetadata;
+    imagePlaneModule: ImagePlaneModuleMetadata;
+    imagePixelModule: ImagePixelModuleMetadata;
+    sopCommonModule: SopCommonModuleMetadata;
+    ecgModule: EcgModuleMetadata;
+    frameModule: FrameMetadata;
+    transferSyntax: TransferSyntaxMetadata;
+    compressedFrameData: CompressedFrameDataMetadata;
+}

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

@@ -0,0 +1,3 @@
+export type { IListenerInfo, MetadataType, MetadataValueType, } from './DicomStreamTypes';
+export type { IImageCalibration } from './IImageCalibration';
+export type { DicomDateObject, DicomTimeObject, GeneralSeriesModuleMetadata, PatientStudyModuleMetadata, ImagePlaneModuleMetadata, ImagePixelModuleMetadata, SopCommonModuleMetadata, EcgModuleMetadata, FrameMetadata, TransferSyntaxMetadata, CompressedFrameDataMetadata, MetadataModuleType, } from './MetadataModuleTypes';

package/dist/esm/utilities/Tags.d.ts

@@ -0,0 +1,25 @@
+import { USRegionChild, CLINICAL_TRIAL, RadiopharmaceuticalInfoModule } from './modules';
+export { USRegionChild, CLINICAL_TRIAL, RadiopharmaceuticalInfoModule };
+export interface TagEntry {
+    name: string;
+    lowerName: string;
+    xTag: string;
+    vm: number;
+    tag: string;
+    vr: string;
+    primaryGroup: string;
+    groups: string[];
+}
+export declare function createTagEntry(hexTag: string, ...groups: string[]): TagEntry;
+export declare function parseVm(vm: string | number | undefined): number | null;
+export declare function dictionaryLookup(hexTag: string): {
+    name: string;
+    vr: string;
+    vm: string;
+} | undefined;
+export declare function getTagCodeByName(name: string): string | undefined;
+export declare const mapModuleTags: Map<string, TagEntry[]>;
+export declare const mapTagInfo: Map<string, TagEntry>;
+export declare function addTag(name: string, value: TagEntry): void;
+export declare function resolveHexFromKeyword(keyword: string): string | undefined;
+export declare const Tags: Record<string, TagEntry>;