@cornerstonejs/metadata 5.0.16 → 5.1.0

package/dist/esm/displayset/BaseDisplaySet.d.ts

@@ -0,0 +1,18 @@
+import type { IDisplaySet } from './IDisplaySet';
+import type { NaturalizedInstance, ViewportTypeHint } from './types';
+export type BaseDisplaySetOptions = {
+    displaySetId: string;
+    viewportTypes?: readonly ViewportTypeHint[];
+    instances?: NaturalizedInstance[];
+    imageIds?: Iterable<string>;
+    underlyingImageIds?: Iterable<string>;
+};
+export declare class BaseDisplaySet implements IDisplaySet {
+    displaySetId: string;
+    viewportTypes: readonly ViewportTypeHint[];
+    preferredViewportType: ViewportTypeHint;
+    readonly instances: readonly NaturalizedInstance[];
+    readonly imageIds: readonly string[];
+    readonly underlyingImageIds: readonly string[];
+    constructor(options: BaseDisplaySetOptions);
+}

package/dist/esm/displayset/BaseDisplaySet.js

@@ -0,0 +1,13 @@
+import { getPreferredViewportType } from './viewportTypes';
+export class BaseDisplaySet {
+    constructor(options) {
+        this.displaySetId = options.displaySetId;
+        this.viewportTypes = options.viewportTypes?.length
+            ? [...options.viewportTypes]
+            : ['stack'];
+        this.preferredViewportType = getPreferredViewportType(this.viewportTypes);
+        this.instances = [...(options.instances ?? [])];
+        this.imageIds = [...(options.imageIds ?? [])];
+        this.underlyingImageIds = [...(options.underlyingImageIds ?? [])];
+    }
+}

package/dist/esm/displayset/IDisplaySet.d.ts

@@ -0,0 +1,13 @@
+import type { NaturalizedInstance, ViewportTypeHint } from './types';
+export interface IDisplaySet {
+    displaySetId: string;
+    viewportTypes: readonly ViewportTypeHint[];
+    preferredViewportType: ViewportTypeHint;
+    instances: readonly NaturalizedInstance[];
+    imageIds: readonly string[];
+    underlyingImageIds: readonly string[];
+    isMultiFrame?: boolean;
+    isClip?: boolean;
+    numImageFrames?: number;
+    splitNumber?: number;
+}

package/dist/esm/displayset/ImageStackDisplaySet.d.ts

@@ -0,0 +1,20 @@
+import { BaseDisplaySet, type BaseDisplaySetOptions } from './BaseDisplaySet';
+import type { NaturalizedInstance, ViewportTypeHint } from './types';
+export type ImageStackDisplaySetOptions = Omit<BaseDisplaySetOptions, 'imageIds' | 'underlyingImageIds'> & {
+    instances?: NaturalizedInstance[];
+    imageIds?: Iterable<string>;
+    underlyingImageIds?: Iterable<string>;
+};
+export declare class ImageStackDisplaySet extends BaseDisplaySet {
+    isMultiFrame: boolean;
+    constructor(options: ImageStackDisplaySetOptions);
+    static fromInstances(instances: NaturalizedInstance[], options?: {
+        displaySetId?: string;
+        viewportTypes?: readonly ViewportTypeHint[];
+        imageIds?: Iterable<string>;
+    }): ImageStackDisplaySet;
+    static fromImageIds(imageIds: string[], getNaturalizedInstance: (imageId: string) => NaturalizedInstance | undefined, options?: {
+        displaySetId?: string;
+        viewportTypes?: readonly ViewportTypeHint[];
+    }): ImageStackDisplaySet;
+}

package/dist/esm/displayset/ImageStackDisplaySet.js

@@ -0,0 +1,57 @@
+import { BaseDisplaySet } from './BaseDisplaySet';
+function collectUnderlyingImageIds(instances) {
+    const ids = [];
+    for (const instance of instances) {
+        if (instance.imageId) {
+            ids.push(instance.imageId);
+        }
+    }
+    return ids;
+}
+function collectImageIds(instances, underlyingImageIds) {
+    const imageIds = [];
+    for (const instance of instances) {
+        if (instance.imageId) {
+            imageIds.push(instance.imageId);
+        }
+    }
+    if (imageIds.length === 0) {
+        return [...underlyingImageIds];
+    }
+    return imageIds;
+}
+export class ImageStackDisplaySet extends BaseDisplaySet {
+    constructor(options) {
+        const instances = options.instances ?? [];
+        const underlyingImageIds = options.underlyingImageIds ?? collectUnderlyingImageIds(instances);
+        const underlyingList = [...underlyingImageIds];
+        const imageIds = options.imageIds ?? collectImageIds(instances, underlyingList);
+        super({
+            ...options,
+            instances,
+            imageIds,
+            underlyingImageIds: underlyingList,
+        });
+        this.isMultiFrame = instances.some((instance) => Number(instance.NumberOfFrames) > 1);
+    }
+    static fromInstances(instances, options) {
+        const displaySetId = options?.displaySetId ??
+            instances[0]?.SeriesInstanceUID ??
+            `display-set-${instances[0]?.imageId ?? 'unknown'}`;
+        return new ImageStackDisplaySet({
+            displaySetId,
+            viewportTypes: options?.viewportTypes ?? ['stack', 'volume', 'volume3d'],
+            instances,
+            imageIds: options?.imageIds,
+        });
+    }
+    static fromImageIds(imageIds, getNaturalizedInstance, options) {
+        const instances = imageIds
+            .map((imageId) => getNaturalizedInstance(imageId))
+            .filter((instance) => instance !== undefined);
+        return ImageStackDisplaySet.fromInstances(instances, {
+            ...options,
+            imageIds,
+        });
+    }
+}

package/dist/esm/displayset/buildSeriesInfo.d.ts

@@ -0,0 +1,2 @@
+import type { NaturalizedInstance, SeriesInfo } from './types';
+export declare function buildSeriesInfo(instances: NaturalizedInstance[]): SeriesInfo;

package/dist/esm/displayset/buildSeriesInfo.js

@@ -0,0 +1,27 @@
+export function buildSeriesInfo(instances) {
+    const NumberOfSeriesRelatedInstances = instances.length;
+    let numberOfFrames = 0;
+    let numberOfNonImageObjects = 0;
+    let numberOfSOPInstanceUIDsPerSeries = 0;
+    for (const instance of instances) {
+        if (instance.NumberOfFrames) {
+            numberOfFrames += Number(instance.NumberOfFrames);
+        }
+        else if (instance.Rows) {
+            numberOfFrames += 1;
+        }
+        else {
+            numberOfNonImageObjects += 1;
+        }
+        if (instance.SOPInstanceUID) {
+            numberOfSOPInstanceUIDsPerSeries += 1;
+        }
+    }
+    return {
+        NumberOfSeriesRelatedInstances,
+        numberOfFrames,
+        numImageFrames: numberOfFrames,
+        numberOfNonImageObjects,
+        numberOfSOPInstanceUIDsPerSeries,
+    };
+}

package/dist/esm/displayset/createDisplaySetFromGroup.d.ts

@@ -0,0 +1,9 @@
+import type { IDisplaySet } from './IDisplaySet';
+import type { InstanceGroup } from './types';
+export type CreateDisplaySetFromGroupOptions = {
+    displaySetId?: string;
+    imageIds?: Iterable<string>;
+    splitNumber?: number;
+    descriptionName?: string;
+};
+export declare function createDisplaySetFromGroup(group: InstanceGroup, options?: CreateDisplaySetFromGroupOptions): IDisplaySet;

package/dist/esm/displayset/createDisplaySetFromGroup.js

@@ -0,0 +1,86 @@
+import { BaseDisplaySet } from './BaseDisplaySet';
+import { ImageStackDisplaySet } from './ImageStackDisplaySet';
+import { isEcgInstance } from './isEcgInstance';
+import { isVideoInstance } from './isVideoInstance';
+import { isWsiInstance } from './isWsiInstance';
+import { getPreferredViewportType, getViewportTypesForGroup, } from './viewportTypes';
+const RESERVED_ATTRIBUTE_KEYS = new Set([
+    'imageIds',
+    'underlyingImageIds',
+    'instances',
+    'displaySetId',
+]);
+function isAssignable(target, key) {
+    let obj = target;
+    while (obj) {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        if (descriptor) {
+            if (descriptor.get || descriptor.set) {
+                return typeof descriptor.set === 'function';
+            }
+            return descriptor.writable !== false;
+        }
+        obj = Object.getPrototypeOf(obj);
+    }
+    return true;
+}
+function applyCustomAttributes(displaySet, group, viewportTypes, options) {
+    const { instances, matchedRule } = group;
+    const first = instances[0];
+    if (!matchedRule.customAttributes || !first) {
+        return;
+    }
+    const sopClassUids = [
+        ...new Set(instances.map((i) => i.SOPClassUID).filter(Boolean)),
+    ];
+    const isMultiFrame = Number(first.NumberOfFrames) > 1;
+    const attributes = matchedRule.customAttributes({ instance: first, isMultiFrame, sopClassUids, viewportTypes }, {
+        instances,
+        splitNumber: options.splitNumber,
+        descriptionName: options.descriptionName,
+    });
+    if (!attributes) {
+        return;
+    }
+    for (const [key, value] of Object.entries(attributes)) {
+        if (RESERVED_ATTRIBUTE_KEYS.has(key)) {
+            continue;
+        }
+        if (isAssignable(displaySet, key)) {
+            displaySet[key] = value;
+        }
+    }
+    displaySet.preferredViewportType = getPreferredViewportType(displaySet.viewportTypes);
+}
+export function createDisplaySetFromGroup(group, options = {}) {
+    const viewportTypes = getViewportTypesForGroup(group);
+    const { instances } = group;
+    const baseDisplaySetId = instances[0]?.SeriesInstanceUID ??
+        `display-set-${instances[0]?.imageId ?? 'unknown'}`;
+    const displaySetId = options.displaySetId ??
+        (options.splitNumber
+            ? `${baseDisplaySetId}:${options.splitNumber}`
+            : baseDisplaySetId);
+    const first = instances[0];
+    let displaySet;
+    if (first &&
+        (isVideoInstance(first) || isEcgInstance(first) || isWsiInstance(first))) {
+        const imageIds = instances.map((i) => i.imageId).filter(Boolean);
+        displaySet = new BaseDisplaySet({
+            displaySetId,
+            viewportTypes,
+            instances,
+            imageIds: options.imageIds ?? imageIds,
+            underlyingImageIds: imageIds,
+        });
+    }
+    else {
+        displaySet = ImageStackDisplaySet.fromInstances(instances, {
+            displaySetId,
+            viewportTypes,
+            imageIds: options.imageIds,
+        });
+    }
+    applyCustomAttributes(displaySet, group, viewportTypes, options);
+    return displaySet;
+}

package/dist/esm/displayset/defaultDisplaySetSplitRules.d.ts

@@ -0,0 +1,2 @@
+import type { SplitRule } from './types';
+export declare const defaultDisplaySetSplitRules: SplitRule[];

package/dist/esm/displayset/defaultDisplaySetSplitRules.js

@@ -0,0 +1,93 @@
+import { isEcgInstance } from './isEcgInstance';
+import { isImageInstance } from './isImageInstance';
+import { isVideoInstance } from './isVideoInstance';
+import { isWsiInstance } from './isWsiInstance';
+const VOLUME_MODALITIES = new Set(['CT', 'MR', 'PT', 'NM']);
+export const defaultDisplaySetSplitRules = [
+    {
+        id: 'video',
+        viewportTypes: ['video'],
+        matches: (instance) => isVideoInstance(instance),
+        groupBy: ['SOPInstanceUID'],
+    },
+    {
+        id: 'ecg',
+        viewportTypes: ['ecg'],
+        matches: (instance) => isEcgInstance(instance),
+        groupBy: ['SOPInstanceUID'],
+    },
+    {
+        id: 'wholeslide',
+        viewportTypes: ['wholeslide'],
+        matches: (instance) => isWsiInstance(instance),
+        groupBy: ['SeriesInstanceUID'],
+    },
+    {
+        id: 'singleImageModality',
+        viewportTypes: ['stack'],
+        matches: (instance) => ['CR', 'DX', 'MG'].includes(instance.Modality ?? '') &&
+            isImageInstance(instance) &&
+            !!instance.Rows,
+        groupBy: [
+            'SeriesInstanceUID',
+            (instance) => `rows=${Math.round(Number(instance.Rows) / 64)}&cols=${Math.round(Number(instance.Columns) / 64)}`,
+        ],
+    },
+    {
+        id: 'multiFrame',
+        viewportTypes: ['stack'],
+        series: ({ instances }) => {
+            const first = instances[0];
+            return {
+                isMultiFrame: Number(first?.NumberOfFrames) > 1 &&
+                    first?.SliceLocation !== undefined,
+            };
+        },
+        matches: (instance, { series }) => !!series.isMultiFrame && isImageInstance(instance) && !!instance.Rows,
+        groupBy: ['SeriesInstanceUID', 'InstanceNumber'],
+        customAttributes: ({ isMultiFrame }, options) => {
+            const numberOfFrames = options.instances[0]?.NumberOfFrames;
+            return {
+                isClip: true,
+                numImageFrames: numberOfFrames === undefined ? undefined : Number(numberOfFrames),
+                splitNumber: options.splitNumber,
+                isMultiFrame,
+            };
+        },
+    },
+    {
+        id: 'mixedDimensionalityBValue',
+        viewportTypes: ['volume', 'volume3d', 'stack'],
+        series: ({ instances }) => {
+            const [instance] = instances;
+            if (!instance || instance.Modality !== 'MR') {
+                return { mixedBValue: false };
+            }
+            const hasBValue = instances.some((i) => i.DiffusionBValue !== undefined);
+            const missingBValue = instances.some((i) => i.DiffusionBValue === undefined);
+            return { mixedBValue: hasBValue && missingBValue };
+        },
+        matches: (instance, { series }) => !!series.mixedBValue && isImageInstance(instance) && !!instance.Rows,
+        groupBy: [
+            'SeriesInstanceUID',
+            (instance) => instance.DiffusionBValue === undefined,
+        ],
+    },
+    {
+        id: 'volume3d',
+        viewportTypes: ['volume', 'volume3d', 'stack'],
+        series: ({ instances }) => {
+            const modality = instances[0]?.Modality;
+            return {
+                supportsVolume3d: !!modality && VOLUME_MODALITIES.has(modality) && instances.length > 1,
+            };
+        },
+        matches: (instance, { series }) => !!series.supportsVolume3d && isImageInstance(instance) && !!instance.Rows,
+        groupBy: ['SeriesInstanceUID'],
+    },
+    {
+        id: 'defaultImageRule',
+        viewportTypes: ['stack', 'volume', 'volume3d'],
+        matches: (instance) => isImageInstance(instance) && !!instance.Rows,
+    },
+];

package/dist/esm/displayset/displaySetProvider.d.ts

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

package/dist/esm/displayset/displaySetProvider.js

@@ -0,0 +1,16 @@
+import { MetadataModules } from '../enums';
+import { addAddProvider } from '../metaData';
+import { addWritableCacheForType } from '../utilities/metadataProvider/cacheData';
+function displaySetAddProvider(next, query, _data, options) {
+    const displaySet = options?.displaySet;
+    if (displaySet) {
+        return displaySet;
+    }
+    return next(query, _data, options);
+}
+export function registerDisplaySetProviders() {
+    addWritableCacheForType(MetadataModules.DISPLAY_SET);
+    addAddProvider(MetadataModules.DISPLAY_SET, displaySetAddProvider, {
+        priority: 40_000,
+    });
+}

package/dist/esm/displayset/displayset.test.d.ts

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

package/dist/esm/displayset/displayset.test.js

@@ -0,0 +1,357 @@
+import { describe, expect, it } from '@jest/globals';
+import { buildSeriesInfo } from './buildSeriesInfo';
+import { createDisplaySetFromGroup } from './createDisplaySetFromGroup';
+import { defaultDisplaySetSplitRules } from './defaultDisplaySetSplitRules';
+import { groupInstancesBySplitRules } from './groupInstancesBySplitRules';
+import { ImageStackDisplaySet } from './ImageStackDisplaySet';
+import { isVideoInstance } from './isVideoInstance';
+import { resolveInstances } from './resolveInstances';
+import { splitImageIdsBySplitRules } from './splitImageIdsBySplitRules';
+import { getPreferredViewportType } from './viewportTypes';
+describe('displayset split utilities', () => {
+    const instances = [
+        {
+            imageId: 'wadors:1',
+            Modality: 'CT',
+            SOPClassUID: '1.2.840.10008.5.1.4.1.1.2',
+            Rows: 512,
+            Columns: 512,
+            SeriesInstanceUID: '1.2.3',
+            InstanceNumber: 1,
+        },
+        {
+            imageId: 'wadors:2',
+            Modality: 'CT',
+            SOPClassUID: '1.2.840.10008.5.1.4.1.1.2',
+            Rows: 512,
+            Columns: 512,
+            SeriesInstanceUID: '1.2.3',
+            InstanceNumber: 2,
+        },
+    ];
+    const getNaturalizedInstance = (imageId) => instances.find((instance) => instance.imageId === imageId);
+    it('resolveInstances preserves order and skips missing ids', () => {
+        const resolved = resolveInstances(['wadors:2', 'wadors:missing', 'wadors:1'], getNaturalizedInstance);
+        expect(resolved.map((i) => i.imageId)).toEqual(['wadors:2', 'wadors:1']);
+    });
+    it('default rules group multi-slice CT as volume (MPR) preferred', () => {
+        const groups = splitImageIdsBySplitRules(instances.map((i) => i.imageId), {
+            getNaturalizedInstance: (id) => instances.find((i) => i.imageId === id),
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups).toHaveLength(1);
+        expect(groups[0].matchedRule.id).toBe('volume3d');
+        const displaySet = createDisplaySetFromGroup(groups[0]);
+        expect(displaySet.viewportTypes[0]).toBe('volume');
+        expect(displaySet.viewportTypes).toContain('volume3d');
+        expect(displaySet.preferredViewportType).toBe('volume');
+    });
+    it('video rule uses video viewportTypes', () => {
+        const videoInstance = {
+            imageId: 'wadors:video',
+            SOPClassUID: '1.2.840.10008.5.1.4.1.1.77.1.4.1',
+            Modality: 'US',
+        };
+        const groups = splitImageIdsBySplitRules(['wadors:video'], {
+            getNaturalizedInstance: () => videoInstance,
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups[0].matchedRule.id).toBe('video');
+        const displaySet = createDisplaySetFromGroup(groups[0]);
+        expect(displaySet.viewportTypes).toEqual(['video']);
+        expect(getPreferredViewportType(displaySet.viewportTypes)).toBe('video');
+        expect(displaySet.instances[0]?.imageId).toBe('wadors:video');
+    });
+    it('ecg rule uses ecg viewportTypes', () => {
+        const ecgInstance = {
+            imageId: 'wadors:ecg',
+            SOPClassUID: '1.2.840.10008.5.1.4.1.1.9.1.1',
+            Modality: 'ECG',
+        };
+        const groups = splitImageIdsBySplitRules(['wadors:ecg'], {
+            getNaturalizedInstance: () => ecgInstance,
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups[0].matchedRule.id).toBe('ecg');
+        expect(createDisplaySetFromGroup(groups[0]).viewportTypes[0]).toBe('ecg');
+    });
+    it('splits MR mixed B-value series', () => {
+        const mrInstances = [
+            {
+                imageId: 'wadors:a',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 'series-mr',
+                DiffusionBValue: 800,
+            },
+            {
+                imageId: 'wadors:b',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 'series-mr',
+            },
+        ];
+        const groups = splitImageIdsBySplitRules(mrInstances.map((i) => i.imageId), {
+            getNaturalizedInstance: (id) => mrInstances.find((i) => i.imageId === id),
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups).toHaveLength(2);
+    });
+    it('ImageStackDisplaySet exposes underlying and frame ids', () => {
+        const displaySet = ImageStackDisplaySet.fromInstances(instances, {
+            displaySetId: 'uid-1',
+            viewportTypes: ['stack', 'volume', 'volume3d'],
+        });
+        expect(displaySet.underlyingImageIds.length).toBe(2);
+        expect(displaySet.viewportTypes[0]).toBe('stack');
+        expect(displaySet.preferredViewportType).toBe('stack');
+    });
+    it('groups by default image rule into a single group', () => {
+        const singleInstance = [instances[0]];
+        const rules = [
+            {
+                id: 'defaultImageRule',
+                viewportTypes: ['stack'],
+                matches: (instance) => instance.SOPClassUID === '1.2.840.10008.5.1.4.1.1.2' &&
+                    !!instance.Rows,
+            },
+        ];
+        const groups = groupInstancesBySplitRules(singleInstance, rules);
+        expect(groups).toHaveLength(1);
+        expect(groups[0].instances).toHaveLength(1);
+    });
+    it('spreads matched-rule customAttributes flat onto the display set', () => {
+        const multiFrameInstances = [
+            {
+                imageId: 'wadors:mf',
+                Modality: 'XA',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.12.1',
+                Rows: 512,
+                NumberOfFrames: 30,
+                SliceLocation: 0,
+                SeriesInstanceUID: 'series-mf',
+                InstanceNumber: 1,
+            },
+        ];
+        const groups = splitImageIdsBySplitRules(['wadors:mf'], {
+            getNaturalizedInstance: () => multiFrameInstances[0],
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups[0].matchedRule.id).toBe('multiFrame');
+        const displaySet = createDisplaySetFromGroup(groups[0], { splitNumber: 2 });
+        expect(displaySet.isClip).toBe(true);
+        expect(displaySet.numImageFrames).toBe(30);
+        expect(displaySet.splitNumber).toBe(2);
+        expect(displaySet.viewportTypes).toEqual(['stack']);
+    });
+    it('coerces a string NumberOfFrames to a numeric numImageFrames', () => {
+        const multiFrameInstances = [
+            {
+                imageId: 'wadors:mf-str',
+                Modality: 'XA',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.12.1',
+                Rows: 512,
+                NumberOfFrames: '30',
+                SliceLocation: 0,
+                SeriesInstanceUID: 'series-mf-str',
+                InstanceNumber: 1,
+            },
+        ];
+        const groups = splitImageIdsBySplitRules(['wadors:mf-str'], {
+            getNaturalizedInstance: () => multiFrameInstances[0],
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups[0].matchedRule.id).toBe('multiFrame');
+        const displaySet = createDisplaySetFromGroup(groups[0]);
+        expect(displaySet.numImageFrames).toBe(30);
+        expect(typeof displaySet.numImageFrames).toBe('number');
+    });
+    it('classifies an MPEG2 transfer syntax instance as video', () => {
+        const mpeg2Instance = {
+            imageId: 'wadors:mpeg2',
+            SOPClassUID: '1.2.840.10008.5.1.4.1.1.7',
+            TransferSyntaxUID: '1.2.840.10008.1.2.4.100',
+            Modality: 'OT',
+        };
+        expect(isVideoInstance(mpeg2Instance)).toBe(true);
+    });
+    it('buildSeriesInfo and grouping are safe on an empty instance list', () => {
+        expect(() => buildSeriesInfo([])).not.toThrow();
+        const seriesInfo = buildSeriesInfo([]);
+        expect(seriesInfo.NumberOfSeriesRelatedInstances).toBe(0);
+        expect(groupInstancesBySplitRules([], defaultDisplaySetSplitRules)).toEqual([]);
+    });
+    it('does not let customAttributes clobber resolved data fields', () => {
+        const stackInstances = [
+            {
+                imageId: 'wadors:reserved',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.2',
+                Rows: 512,
+                SeriesInstanceUID: 'series-reserved',
+                InstanceNumber: 1,
+            },
+        ];
+        const group = {
+            instances: stackInstances,
+            matchedRule: {
+                id: 'reserved-clobber',
+                viewportTypes: ['stack'],
+                customAttributes: () => ({
+                    imageIds: ['evil-frame'],
+                    underlyingImageIds: ['evil-underlying'],
+                    instances: [],
+                    displaySetId: 'evil-uid',
+                    customFlag: true,
+                }),
+            },
+        };
+        const displaySet = createDisplaySetFromGroup(group, {
+            displaySetId: 'good-uid',
+        });
+        expect(displaySet.imageIds).toEqual(['wadors:reserved']);
+        expect(displaySet.underlyingImageIds).toEqual(['wadors:reserved']);
+        expect(displaySet.instances).toHaveLength(1);
+        expect(displaySet.displaySetId).toBe('good-uid');
+        expect(displaySet.customFlag).toBe(true);
+    });
+    it('derives unique displaySetIds for splits of one series', () => {
+        const seriesUID = 'series-split';
+        const makeGroup = (imageId) => ({
+            instances: [
+                {
+                    imageId,
+                    SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                    Rows: 256,
+                    SeriesInstanceUID: seriesUID,
+                },
+            ],
+            matchedRule: { id: 'split', viewportTypes: ['stack'] },
+        });
+        const ds0 = createDisplaySetFromGroup(makeGroup('wadors:s0'), {
+            splitNumber: 0,
+        });
+        const ds1 = createDisplaySetFromGroup(makeGroup('wadors:s1'), {
+            splitNumber: 1,
+        });
+        expect(ds0.displaySetId).toBe(seriesUID);
+        expect(ds1.displaySetId).toBe(`${seriesUID}:1`);
+        expect(ds0.displaySetId).not.toBe(ds1.displaySetId);
+    });
+    it('namespaces buckets by rule so identical split keys do not merge', () => {
+        const insts = [
+            { imageId: 'a', Modality: 'XA' },
+            { imageId: 'b', Modality: 'NM' },
+        ];
+        const rules = [
+            {
+                id: 'ruleA',
+                matches: (i) => i.Modality === 'XA',
+                groupBy: [() => 'same'],
+            },
+            {
+                id: 'ruleB',
+                matches: (i) => i.Modality === 'NM',
+                groupBy: [() => 'same'],
+            },
+        ];
+        const groups = groupInstancesBySplitRules(insts, rules);
+        expect(groups).toHaveLength(2);
+        expect(new Set(groups.map((g) => g.matchedRule.id))).toEqual(new Set(['ruleA', 'ruleB']));
+    });
+    it('returns groups in a deterministic order regardless of input order', () => {
+        const mr = [
+            {
+                imageId: 'a',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 's',
+                DiffusionBValue: 800,
+            },
+            {
+                imageId: 'b',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 's',
+            },
+        ];
+        const options = {
+            getNaturalizedInstance: (id) => mr.find((i) => i.imageId === id),
+            splitRules: defaultDisplaySetSplitRules,
+        };
+        const forward = splitImageIdsBySplitRules(['a', 'b'], options);
+        const reverse = splitImageIdsBySplitRules(['b', 'a'], options);
+        expect(forward.map((g) => g.splitKey)).toEqual(reverse.map((g) => g.splitKey));
+    });
+    it('series hook splits a mixed-b-value DWI series into two display sets', () => {
+        const mixed = [
+            {
+                imageId: 'b800',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 'dwi',
+                DiffusionBValue: 800,
+            },
+            {
+                imageId: 'noB',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 'dwi',
+            },
+        ];
+        const groups = splitImageIdsBySplitRules(['b800', 'noB'], {
+            getNaturalizedInstance: (id) => mixed.find((i) => i.imageId === id),
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups).toHaveLength(2);
+        expect(groups.every((g) => g.matchedRule.id === 'mixedDimensionalityBValue')).toBe(true);
+    });
+    it('series hook leaves a non-mixed DWI series as one volume display set', () => {
+        const allBValue = [
+            {
+                imageId: 'b0',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 'dwi-uniform',
+                DiffusionBValue: 0,
+            },
+            {
+                imageId: 'b1000',
+                Modality: 'MR',
+                SOPClassUID: '1.2.840.10008.5.1.4.1.1.4',
+                Rows: 256,
+                SeriesInstanceUID: 'dwi-uniform',
+                DiffusionBValue: 1000,
+            },
+        ];
+        const groups = splitImageIdsBySplitRules(['b0', 'b1000'], {
+            getNaturalizedInstance: (id) => allBValue.find((i) => i.imageId === id),
+            splitRules: defaultDisplaySetSplitRules,
+        });
+        expect(groups).toHaveLength(1);
+        expect(groups[0].matchedRule.id).toBe('volume3d');
+    });
+    it('reports instances that match no rule via onUnmatched', () => {
+        const insts = [
+            { imageId: 'a', Modality: 'CT' },
+            { imageId: 'b', Modality: 'SR' },
+        ];
+        const rules = [
+            {
+                id: 'ct',
+                matches: (i) => i.Modality === 'CT',
+                groupBy: ['imageId'],
+            },
+        ];
+        const unmatched = [];
+        const groups = groupInstancesBySplitRules(insts, rules, (i) => unmatched.push(i.imageId));
+        expect(unmatched).toEqual(['b']);
+        expect(groups).toHaveLength(1);
+    });
+});

package/dist/esm/displayset/groupInstancesBySplitRules.d.ts

@@ -0,0 +1,2 @@
+import type { InstanceGroup, NaturalizedInstance, SplitRule } from './types';
+export declare function groupInstancesBySplitRules(instances: NaturalizedInstance[], splitRules: SplitRule[], onUnmatched?: (instance: NaturalizedInstance) => void): InstanceGroup[];

package/dist/esm/displayset/groupInstancesBySplitRules.js

@@ -0,0 +1,37 @@
+function buildSplitKey(instance, context, splitRule, ruleDiscriminator) {
+    const groupBy = splitRule.groupBy ?? ['SeriesInstanceUID'];
+    const parts = groupBy.map((key) => typeof key === 'function' ? key(instance, context) : instance[key]);
+    return JSON.stringify([ruleDiscriminator, ...parts]);
+}
+export function groupInstancesBySplitRules(instances, splitRules, onUnmatched) {
+    if (!instances.length) {
+        return [];
+    }
+    const ruleContexts = splitRules.map((rule) => ({
+        series: rule.series?.({ instances }) ?? {},
+    }));
+    const instancesMap = new Map();
+    for (const instance of instances) {
+        let matched = false;
+        for (let ruleIndex = 0; ruleIndex < splitRules.length; ruleIndex++) {
+            const splitRule = splitRules[ruleIndex];
+            const context = ruleContexts[ruleIndex];
+            if (splitRule.matches && !splitRule.matches(instance, context)) {
+                continue;
+            }
+            matched = true;
+            const key = buildSplitKey(instance, context, splitRule, `${ruleIndex}:${splitRule.id ?? ''}`);
+            let group = instancesMap.get(key);
+            if (!group) {
+                group = { instances: [], matchedRule: splitRule, splitKey: key };
+                instancesMap.set(key, group);
+            }
+            group.instances.push(instance);
+            break;
+        }
+        if (!matched) {
+            onUnmatched?.(instance);
+        }
+    }
+    return Array.from(instancesMap.values()).sort((a, b) => (a.splitKey ?? '').localeCompare(b.splitKey ?? ''));
+}

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

@@ -0,0 +1,22 @@
+export type { IDisplaySet } from './IDisplaySet';
+export { BaseDisplaySet } from './BaseDisplaySet';
+export type { BaseDisplaySetOptions } from './BaseDisplaySet';
+export { ImageStackDisplaySet } from './ImageStackDisplaySet';
+export type { ImageStackDisplaySetOptions } from './ImageStackDisplaySet';
+export { resolveInstances } from './resolveInstances';
+export type { ResolveInstancesOptions } from './resolveInstances';
+export { buildSeriesInfo } from './buildSeriesInfo';
+export { groupInstancesBySplitRules } from './groupInstancesBySplitRules';
+export { splitImageIdsBySplitRules } from './splitImageIdsBySplitRules';
+export type { SplitImageIdsBySplitRulesOptions } from './splitImageIdsBySplitRules';
+export { registerDisplaySetMetadata, type RegisterDisplaySetMetadataOptions, } from './registerDisplaySetMetadata';
+export { registerDisplaySetProviders } from './displaySetProvider';
+export { defaultDisplaySetSplitRules } from './defaultDisplaySetSplitRules';
+export { createDisplaySetFromGroup } from './createDisplaySetFromGroup';
+export type { CreateDisplaySetFromGroupOptions } from './createDisplaySetFromGroup';
+export { isImageInstance } from './isImageInstance';
+export { isVideoInstance } from './isVideoInstance';
+export { isEcgInstance } from './isEcgInstance';
+export { isWsiInstance } from './isWsiInstance';
+export { getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './viewportTypes';
+export type { NaturalizedInstance, SeriesInfo, SeriesFacts, SeriesContext, RuleContext, SplitRule, SplitContext, SplitRuleOptions, SplitRuleCustomAttributesContext, InstanceGroup, ViewportTypeHint, } from './types';

package/dist/esm/displayset/index.js

@@ -0,0 +1,15 @@
+export { BaseDisplaySet } from './BaseDisplaySet';
+export { ImageStackDisplaySet } from './ImageStackDisplaySet';
+export { resolveInstances } from './resolveInstances';
+export { buildSeriesInfo } from './buildSeriesInfo';
+export { groupInstancesBySplitRules } from './groupInstancesBySplitRules';
+export { splitImageIdsBySplitRules } from './splitImageIdsBySplitRules';
+export { registerDisplaySetMetadata, } from './registerDisplaySetMetadata';
+export { registerDisplaySetProviders } from './displaySetProvider';
+export { defaultDisplaySetSplitRules } from './defaultDisplaySetSplitRules';
+export { createDisplaySetFromGroup } from './createDisplaySetFromGroup';
+export { isImageInstance } from './isImageInstance';
+export { isVideoInstance } from './isVideoInstance';
+export { isEcgInstance } from './isEcgInstance';
+export { isWsiInstance } from './isWsiInstance';
+export { getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './viewportTypes';

package/dist/esm/displayset/isEcgInstance.d.ts

@@ -0,0 +1,2 @@
+import type { NaturalizedInstance } from './types';
+export declare function isEcgInstance(instance: NaturalizedInstance): boolean;

package/dist/esm/displayset/isEcgInstance.js

@@ -0,0 +1,10 @@
+const ECG_SOP_CLASS_UIDS = new Set([
+    '1.2.840.10008.5.1.4.1.1.9.1.1',
+    '1.2.840.10008.5.1.4.1.1.9.1.2',
+    '1.2.840.10008.5.1.4.1.1.9.1.3',
+    '1.2.840.10008.5.1.4.1.1.9.2.1',
+    '1.2.840.10008.5.1.4.1.1.9.3.1',
+]);
+export function isEcgInstance(instance) {
+    return ECG_SOP_CLASS_UIDS.has(instance.SOPClassUID ?? '');
+}

package/dist/esm/displayset/isImageInstance.d.ts

@@ -0,0 +1,2 @@
+import type { NaturalizedInstance } from './types';
+export declare function isImageInstance(instance: NaturalizedInstance): boolean;

package/dist/esm/displayset/isImageInstance.js

@@ -0,0 +1,45 @@
+const IMAGE_STORAGE_SOP_CLASS_UIDS = new Set([
+    '1.2.840.10008.5.1.4.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.2',
+    '1.2.840.10008.5.1.4.1.1.2.1',
+    '1.2.840.10008.5.1.4.1.1.2.2',
+    '1.2.840.10008.5.1.4.1.1.4',
+    '1.2.840.10008.5.1.4.1.1.4.1',
+    '1.2.840.10008.5.1.4.1.1.4.2',
+    '1.2.840.10008.5.1.4.1.1.4.3',
+    '1.2.840.10008.5.1.4.1.1.4.4',
+    '1.2.840.10008.5.1.4.1.1.7',
+    '1.2.840.10008.5.1.4.1.1.7.1',
+    '1.2.840.10008.5.1.4.1.1.7.2',
+    '1.2.840.10008.5.1.4.1.1.7.3',
+    '1.2.840.10008.5.1.4.1.1.7.4',
+    '1.2.840.10008.5.1.4.1.1.12.1',
+    '1.2.840.10008.5.1.4.1.1.12.1.1',
+    '1.2.840.10008.5.1.4.1.1.12.2',
+    '1.2.840.10008.5.1.4.1.1.12.2.1',
+    '1.2.840.10008.5.1.4.1.1.13.1.1',
+    '1.2.840.10008.5.1.4.1.1.13.1.2',
+    '1.2.840.10008.5.1.4.1.1.13.1.3',
+    '1.2.840.10008.5.1.4.1.1.13.1.4',
+    '1.2.840.10008.5.1.4.1.1.13.1.5',
+    '1.2.840.10008.5.1.4.1.1.13.1.6',
+    '1.2.840.10008.5.1.4.1.1.128',
+    '1.2.840.10008.5.1.4.1.1.77.1.1',
+    '1.2.840.10008.5.1.4.1.1.77.1.1.1',
+    '1.2.840.10008.5.1.4.1.1.77.1.2',
+    '1.2.840.10008.5.1.4.1.1.77.1.2.1',
+    '1.2.840.10008.5.1.4.1.1.77.1.3',
+    '1.2.840.10008.5.1.4.1.1.77.1.4',
+    '1.2.840.10008.5.1.4.1.1.77.1.4.1',
+    '1.2.840.10008.5.1.4.1.1.128.1',
+    '1.2.840.10008.5.1.4.1.1.128.2',
+    '1.2.840.10008.5.1.4.1.1.128.3',
+    '1.2.840.10008.5.1.4.1.1.128.4',
+    '1.2.840.10008.5.1.4.1.1.128.5',
+    '1.2.840.10008.5.1.4.1.1.77.1.6',
+]);
+export function isImageInstance(instance) {
+    return IMAGE_STORAGE_SOP_CLASS_UIDS.has(instance.SOPClassUID ?? '');
+}

package/dist/esm/displayset/isVideoInstance.d.ts

@@ -0,0 +1,2 @@
+import type { NaturalizedInstance } from './types';
+export declare function isVideoInstance(instance: NaturalizedInstance): boolean;

package/dist/esm/displayset/isVideoInstance.js

@@ -0,0 +1,31 @@
+import { videoUIDs } from '../utilities/isVideoTransferSyntax';
+const VIDEO_SOP_CLASS_UIDS = new Set([
+    '1.2.840.10008.5.1.4.1.1.77.1.2.1',
+    '1.2.840.10008.5.1.4.1.1.77.1.4.1',
+    '1.2.840.10008.5.1.4.1.1.77.1.1.1',
+]);
+const SECONDARY_CAPTURE_SOP_CLASS_UIDS = new Set([
+    '1.2.840.10008.5.1.4.1.1.7',
+    '1.2.840.10008.5.1.4.1.1.7.4',
+]);
+function getTransferSyntaxUids(instance) {
+    const tsuid = instance.AvailableTransferSyntaxUID ||
+        instance.TransferSyntaxUID ||
+        instance['00083002'];
+    return (Array.isArray(tsuid) ? tsuid : [tsuid]).filter((value) => typeof value === 'string' && value.length > 0);
+}
+export function isVideoInstance(instance) {
+    const tsuids = getTransferSyntaxUids(instance);
+    if (tsuids.some((tsuid) => videoUIDs.has(tsuid))) {
+        return true;
+    }
+    if (instance.SOPClassUID === '1.2.840.10008.5.1.4.1.1.77.1.4.1') {
+        return true;
+    }
+    if (VIDEO_SOP_CLASS_UIDS.has(instance.SOPClassUID ?? '')) {
+        return true;
+    }
+    const numberOfFrames = Number(instance.NumberOfFrames) || 0;
+    return (SECONDARY_CAPTURE_SOP_CLASS_UIDS.has(instance.SOPClassUID ?? '') &&
+        numberOfFrames >= 90);
+}

package/dist/esm/displayset/isWsiInstance.d.ts

@@ -0,0 +1,2 @@
+import type { NaturalizedInstance } from './types';
+export declare function isWsiInstance(instance: NaturalizedInstance): boolean;

package/dist/esm/displayset/isWsiInstance.js

@@ -0,0 +1,7 @@
+const WSI_SOP_CLASS_UIDS = new Set(['1.2.840.10008.5.1.4.1.1.77.1.6']);
+export function isWsiInstance(instance) {
+    if (WSI_SOP_CLASS_UIDS.has(instance.SOPClassUID ?? '')) {
+        return true;
+    }
+    return instance.Modality === 'SM';
+}

package/dist/esm/displayset/registerDisplaySetMetadata.d.ts

@@ -0,0 +1,5 @@
+import type { IDisplaySet } from './IDisplaySet';
+export type RegisterDisplaySetMetadataOptions = {
+    includeImageIds?: boolean;
+};
+export declare function registerDisplaySetMetadata(imageIds: string[], displaySet: IDisplaySet, options?: RegisterDisplaySetMetadataOptions): void;

package/dist/esm/displayset/registerDisplaySetMetadata.js

@@ -0,0 +1,19 @@
+import { MetadataModules } from '../enums';
+import { addTyped } from '../metaData';
+export function registerDisplaySetMetadata(imageIds, displaySet, options = {}) {
+    const idsToRegister = new Set(imageIds);
+    if (options.includeImageIds) {
+        for (const frameId of displaySet.imageIds) {
+            idsToRegister.add(frameId);
+        }
+    }
+    for (const underlyingId of displaySet.underlyingImageIds) {
+        idsToRegister.add(underlyingId);
+    }
+    for (const imageId of idsToRegister) {
+        if (!imageId) {
+            continue;
+        }
+        addTyped(MetadataModules.DISPLAY_SET, imageId, { displaySet });
+    }
+}

package/dist/esm/displayset/resolveInstances.d.ts

@@ -0,0 +1,6 @@
+import type { NaturalizedInstance } from './types';
+export type ResolveInstancesOptions = {
+    skipMissing?: boolean;
+    onMissing?: (imageId: string) => void;
+};
+export declare function resolveInstances(imageIds: string[], getNaturalizedInstance: (imageId: string) => NaturalizedInstance | undefined, options?: ResolveInstancesOptions): NaturalizedInstance[];

package/dist/esm/displayset/resolveInstances.js

@@ -0,0 +1,16 @@
+export function resolveInstances(imageIds, getNaturalizedInstance, options = {}) {
+    const { skipMissing = true, onMissing } = options;
+    const instances = [];
+    for (const imageId of imageIds) {
+        const instance = getNaturalizedInstance(imageId);
+        if (!instance) {
+            if (!skipMissing) {
+                throw new Error(`No naturalized instance for imageId: ${imageId}`);
+            }
+            onMissing?.(imageId);
+            continue;
+        }
+        instances.push(instance);
+    }
+    return instances;
+}

package/dist/esm/displayset/splitImageIdsBySplitRules.d.ts

@@ -0,0 +1,7 @@
+import type { InstanceGroup, NaturalizedInstance, SplitContext, SplitRule } from './types';
+export type SplitImageIdsBySplitRulesOptions = SplitContext & {
+    splitRules: SplitRule[];
+    onMissingImageId?: (imageId: string) => void;
+    onUnmatchedInstance?: (instance: NaturalizedInstance) => void;
+};
+export declare function splitImageIdsBySplitRules(imageIds: string[], options: SplitImageIdsBySplitRulesOptions): InstanceGroup[];

package/dist/esm/displayset/splitImageIdsBySplitRules.js

@@ -0,0 +1,12 @@
+import { groupInstancesBySplitRules } from './groupInstancesBySplitRules';
+import { resolveInstances } from './resolveInstances';
+export function splitImageIdsBySplitRules(imageIds, options) {
+    const { getNaturalizedInstance, splitRules, onMissingImageId, onUnmatchedInstance, } = options;
+    const instances = resolveInstances(imageIds, getNaturalizedInstance, {
+        onMissing: onMissingImageId,
+    });
+    if (!instances.length) {
+        return [];
+    }
+    return groupInstancesBySplitRules(instances, splitRules, onUnmatchedInstance);
+}

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

@@ -0,0 +1,59 @@
+export type NaturalizedInstance = {
+    imageId?: string;
+    Modality?: string;
+    SOPClassUID?: string;
+    Rows?: number;
+    Columns?: number;
+    NumberOfFrames?: number;
+    SliceLocation?: number;
+    SeriesInstanceUID?: string;
+    InstanceNumber?: number;
+    DiffusionBValue?: number;
+    TransferSyntaxUID?: string;
+    AvailableTransferSyntaxUID?: string;
+    [key: string]: unknown;
+};
+export type ViewportTypeHint = 'stack' | 'volume' | 'volume3d' | 'video' | 'wholeslide' | 'ecg' | string;
+export type SeriesInfo = {
+    NumberOfSeriesRelatedInstances: number;
+    numberOfFrames: number;
+    numImageFrames: number;
+    numberOfNonImageObjects: number;
+    numberOfSOPInstanceUIDsPerSeries: number;
+    [key: string]: unknown;
+};
+export type SeriesFacts = Record<string, unknown>;
+export type SeriesContext = {
+    instances: NaturalizedInstance[];
+};
+export type RuleContext = {
+    series: SeriesFacts;
+};
+export type SplitRuleCustomAttributesContext = {
+    instance: NaturalizedInstance;
+    isMultiFrame?: boolean;
+    sopClassUids?: string[];
+    viewportTypes?: readonly ViewportTypeHint[];
+    [key: string]: unknown;
+};
+export type SplitRuleOptions = {
+    instances: NaturalizedInstance[];
+    splitNumber?: number;
+    descriptionName?: string;
+};
+export type SplitRule = {
+    id?: string;
+    viewportTypes?: readonly ViewportTypeHint[];
+    series?: (context: SeriesContext) => SeriesFacts;
+    matches?: (instance: NaturalizedInstance, context: RuleContext) => boolean;
+    groupBy?: (string | ((instance: NaturalizedInstance, context: RuleContext) => unknown))[];
+    customAttributes?: (attributes: SplitRuleCustomAttributesContext, options: SplitRuleOptions) => Record<string, unknown>;
+};
+export type SplitContext = {
+    getNaturalizedInstance: (imageId: string) => NaturalizedInstance | undefined;
+};
+export type InstanceGroup = {
+    instances: NaturalizedInstance[];
+    matchedRule: SplitRule;
+    splitKey?: string;
+};

package/dist/esm/displayset/viewportTypes.d.ts

@@ -0,0 +1,4 @@
+import type { InstanceGroup, SplitRule, ViewportTypeHint } from './types';
+export declare function getViewportTypesForRule(rule: SplitRule): readonly ViewportTypeHint[];
+export declare function getPreferredViewportType(viewportTypes: readonly ViewportTypeHint[]): ViewportTypeHint;
+export declare function getViewportTypesForGroup(group: InstanceGroup): readonly ViewportTypeHint[];

package/dist/esm/displayset/viewportTypes.js

@@ -0,0 +1,13 @@
+const DEFAULT_VIEWPORT_TYPES = ['stack'];
+export function getViewportTypesForRule(rule) {
+    if (rule.viewportTypes?.length) {
+        return rule.viewportTypes;
+    }
+    return DEFAULT_VIEWPORT_TYPES;
+}
+export function getPreferredViewportType(viewportTypes) {
+    return viewportTypes[0] ?? 'stack';
+}
+export function getViewportTypesForGroup(group) {
+    return getViewportTypesForRule(group.matchedRule);
+}

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

@@ -47,7 +47,8 @@ declare enum MetadataModules {
     COMPRESSED_FRAME_DATA = "compressedFrameData",
     BASE_IMAGE_ID = "baseImageId",
     FRAME_IMAGE_IDS = "frameImageIds",
-    NATURALIZED = "naturalized"
+    NATURALIZED = "naturalized",
+    DISPLAY_SET = "displaySetModule"
 }
 export declare const ADD_MODULE_TYPE_SUFFIX = "Add";
 export declare function getAddModuleType(type: string): string;

package/dist/esm/enums/MetadataModules.js

@@ -49,6 +49,7 @@ var MetadataModules;
     MetadataModules["BASE_IMAGE_ID"] = "baseImageId";
     MetadataModules["FRAME_IMAGE_IDS"] = "frameImageIds";
     MetadataModules["NATURALIZED"] = "naturalized";
+    MetadataModules["DISPLAY_SET"] = "displaySetModule";
 })(MetadataModules || (MetadataModules = {}));
 export const ADD_MODULE_TYPE_SUFFIX = 'Add';
 export function getAddModuleType(type) {

package/dist/esm/index.d.ts

@@ -3,6 +3,10 @@ export * as Enums from './enums';
 export { version } from './version';
 export * as metaData from './metaData';
 export * as utilities from './utilities';
+export * as displaySet from './displayset';
+export type { IDisplaySet, BaseDisplaySetOptions, ImageStackDisplaySetOptions, ResolveInstancesOptions, SplitImageIdsBySplitRulesOptions, RegisterDisplaySetMetadataOptions, NaturalizedInstance, SeriesInfo, SeriesFacts, SeriesContext, RuleContext, SplitRule, SplitContext, SplitRuleOptions, SplitRuleCustomAttributesContext, InstanceGroup, ViewportTypeHint, } from './displayset';
+export { BaseDisplaySet, ImageStackDisplaySet, resolveInstances, buildSeriesInfo, groupInstancesBySplitRules, splitImageIdsBySplitRules, registerDisplaySetMetadata, registerDisplaySetProviders, defaultDisplaySetSplitRules, createDisplaySetFromGroup, isImageInstance, isVideoInstance, isEcgInstance, isWsiInstance, getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './displayset';
+export type { CreateDisplaySetFromGroupOptions } from './displayset';
 export * as logging from './utilities/logging';
 export { registerDefaultProviders } from './registerDefaultProviders';
 export type * from './types';

package/dist/esm/index.js

@@ -3,6 +3,8 @@ export * as Enums from './enums';
 export { version } from './version';
 export * as metaData from './metaData';
 export * as utilities from './utilities';
+export * as displaySet from './displayset';
+export { BaseDisplaySet, ImageStackDisplaySet, resolveInstances, buildSeriesInfo, groupInstancesBySplitRules, splitImageIdsBySplitRules, registerDisplaySetMetadata, registerDisplaySetProviders, defaultDisplaySetSplitRules, createDisplaySetFromGroup, isImageInstance, isVideoInstance, isEcgInstance, isWsiInstance, getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './displayset';
 export * as logging from './utilities/logging';
 export { registerDefaultProviders } from './registerDefaultProviders';
 const { calculateSUVScalingFactors } = calculateSUV;

package/dist/esm/registerDefaultProviders.js

@@ -15,6 +15,7 @@ import { registerCompressedFrameDataProvider } from './utilities/metadataProvide
 import { registerScalingFromInstanceProvider } from './utilities/metadataProvider/scalingFromInstance';
 import { registerNaturalizedHandlers } from './utilities/metadataProvider/naturalizedHandlers';
 import { registerImageIdProviders } from './utilities/metadataProvider/imageIdsProviders';
+import { registerDisplaySetProviders } from './displayset/displaySetProvider';
 const TYPED_PROVIDER_BRIDGE_PRIORITY = -1000;
 export function registerDefaultProviders() {
     addProvider(metadataModuleProvider, TYPED_PROVIDER_BRIDGE_PRIORITY);
@@ -24,6 +25,7 @@ export function registerDefaultProviders() {
     registerNaturalizedHandlers();
     registerUriModule();
     registerImageIdProviders();
+    registerDisplaySetProviders();
     registerDataLookup();
     registerInstanceFromListener();
     registerCombineFrameProvider();

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

@@ -1,3 +1,4 @@
+import type { IDisplaySet } from '../displayset/IDisplaySet';
 export interface DicomDateObject {
     year: number;
     month: number;
@@ -97,4 +98,5 @@ export interface MetadataModuleType {
     frameModule: FrameMetadata;
     transferSyntax: TransferSyntaxMetadata;
     compressedFrameData: CompressedFrameDataMetadata;
+    displaySetModule: IDisplaySet;
 }

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

@@ -13,3 +13,4 @@ export * as DicomStream from './dicomStream';
 export * from './logging';
 export * from './metadataProvider';
 export * as typedMetadataProviders from './metadataProvider';
+export * from '../displayset';

package/dist/esm/utilities/index.js

@@ -13,3 +13,4 @@ export * as DicomStream from './dicomStream';
 export * from './logging';
 export * from './metadataProvider';
 export * as typedMetadataProviders from './metadataProvider';
+export * from '../displayset';

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.0.16";
+export declare const version = "5.1.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.0.16';
+export const version = '5.1.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/metadata",
-  "version": "5.0.16",
+  "version": "5.1.0",
   "description": "Cornerstone3D Metadata Foundation - Provider chain, DICOM stream parsing, tag modules, and series splitting",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -80,7 +80,7 @@
   },
   "dependencies": {
     "@cornerstonejs/calculate-suv": "1.0.3",
-    "@cornerstonejs/utils": "5.0.16",
+    "@cornerstonejs/utils": "5.1.0",
     "dcmjs": "0.50.1",
     "gl-matrix": "3.4.3"
   },
@@ -95,5 +95,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "902d3aeef74489bbdd2b1f525823effbf2bbfeb9"
+  "gitHead": "f86b3b590f646412726bfb8bbea8e6724f36cbf1"
 }