@cornerstonejs/metadata 5.13.1 → 5.14.0

package/dist/esm/displayset/seriesFunctions.js

@@ -0,0 +1,327 @@
+import { vec3 } from 'gl-matrix';
+import { asArray, toFiniteFirst, toFiniteVector } from '@cornerstonejs/utils';
+import { readOwn } from '../safeFunctions/index.js';
+export function instanceKey(instance) {
+    const key = instance.SOPInstanceUID ?? instance.imageId;
+    return key === undefined ? undefined : String(key);
+}
+function byKey(a, b) {
+    const aKey = instanceKey(a) ?? '';
+    const bKey = instanceKey(b) ?? '';
+    return aKey < bKey ? -1 : aKey > bKey ? 1 : 0;
+}
+function numberArg(args, name, fallback) {
+    return toFiniteFirst(readOwn(args, name)) ?? fallback;
+}
+function readVector(instance, attribute, length) {
+    return toFiniteVector(readOwn(instance, attribute), length);
+}
+const round = (value, step) => Math.round(value / step) * step;
+function searchSorted(values, value, after = false) {
+    let low = 0;
+    let high = values.length;
+    while (low < high) {
+        const mid = (low + high) >> 1;
+        if (values[mid] < value || (after && values[mid] === value)) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return low;
+}
+function latticeAnchor(distinct, spacing, tolerance, offLattice) {
+    const EPSILON = 1e-6;
+    const n = distinct.length;
+    const countOf = (from, lo, hi, values) => {
+        let count = 0;
+        for (let i = lo; i < hi; i++) {
+            count += offLattice(from, values[i]) ? 0 : 1;
+        }
+        return count;
+    };
+    if (tolerance >= 0.5) {
+        return distinct[0];
+    }
+    let counts;
+    if (tolerance + EPSILON >= 0.5) {
+        counts = (index) => countOf(distinct[index], 0, n, distinct);
+    }
+    else {
+        const phaseOf = (d) => {
+            const steps = (d - distinct[0]) / spacing;
+            return steps - Math.floor(steps);
+        };
+        const order = distinct
+            .map((d) => [phaseOf(d), d])
+            .sort(([a], [b]) => a - b);
+        const phases = [];
+        const values = [];
+        for (const turn of [-1, 0, 1]) {
+            for (const [phase, d] of order) {
+                phases.push(phase + turn);
+                values.push(d);
+            }
+        }
+        counts = (index) => {
+            const from = distinct[index];
+            const phase = phaseOf(from);
+            const lo = searchSorted(phases, phase - tolerance - EPSILON);
+            const hi = searchSorted(phases, phase + tolerance + EPSILON, true);
+            const innerLo = searchSorted(phases, phase - tolerance + EPSILON);
+            const innerHi = searchSorted(phases, phase + tolerance - EPSILON, true);
+            if (innerLo >= innerHi) {
+                return countOf(from, lo, hi, values);
+            }
+            return (innerHi -
+                innerLo +
+                countOf(from, lo, innerLo, values) +
+                countOf(from, innerHi, hi, values));
+        };
+    }
+    let anchor = distinct[0];
+    let bestCount = -1;
+    for (let index = 0; index < n; index++) {
+        const count = counts(index);
+        if (count > bestCount) {
+            bestCount = count;
+            anchor = distinct[index];
+        }
+    }
+    return anchor;
+}
+export const planeGeometry = (instances, { args }) => {
+    const tolerance = numberArg(args, 'tolerance', 0.1);
+    const result = {
+        regularCount: 0,
+        irregularCount: 0,
+        positions: 0,
+        complete: false,
+        duplicates: false,
+        distance: {},
+        index: {},
+    };
+    const candidates = [];
+    for (const instance of [...instances].sort(byKey)) {
+        const key = instanceKey(instance);
+        const position = readVector(instance, 'ImagePositionPatient', 3);
+        const orientation = readVector(instance, 'ImageOrientationPatient', 6);
+        if (key === undefined || !position || !orientation) {
+            result.irregularCount++;
+            continue;
+        }
+        candidates.push({
+            key,
+            position,
+            orientation,
+            orientationKey: orientation.map((v) => round(v, 1e-3).toFixed(3)).join(),
+        });
+    }
+    const orientationCounts = new Map();
+    for (const { orientationKey } of candidates) {
+        orientationCounts.set(orientationKey, (orientationCounts.get(orientationKey) ?? 0) + 1);
+    }
+    const [dominant] = [...orientationCounts.entries()].sort(([aKey, aCount], [bKey, bCount]) => bCount - aCount || (aKey < bKey ? -1 : aKey > bKey ? 1 : 0));
+    if (!dominant) {
+        return result;
+    }
+    const inPlane = candidates.filter((c) => c.orientationKey === dominant[0]);
+    result.irregularCount += candidates.length - inPlane.length;
+    const [row0, row1, row2, col0, col1, col2] = inPlane[0].orientation;
+    const normal = vec3.cross(vec3.create(), vec3.fromValues(row0, row1, row2), vec3.fromValues(col0, col1, col2));
+    vec3.normalize(normal, normal);
+    result.normal = Array.from(normal);
+    const projected = inPlane.map((candidate) => ({
+        ...candidate,
+        d: vec3.dot(normal, candidate.position),
+    }));
+    const distinct = [];
+    for (const d of projected.map((p) => p.d).sort((a, b) => a - b)) {
+        if (!distinct.length || d - distinct[distinct.length - 1] >= 0.01) {
+            distinct.push(round(d, 1e-3));
+        }
+    }
+    const gapCounts = new Map();
+    for (let i = 1; i < distinct.length; i++) {
+        const gap = round(distinct[i] - distinct[i - 1], 0.01);
+        gapCounts.set(gap, (gapCounts.get(gap) ?? 0) + 1);
+    }
+    const [spacingEntry] = [...gapCounts.entries()].sort(([aGap, aCount], [bGap, bCount]) => bCount - aCount || aGap - bGap);
+    const spacing = spacingEntry?.[0];
+    if (!spacing) {
+        result.irregularCount += inPlane.length;
+        return result;
+    }
+    result.spacing = spacing;
+    const offLattice = (from, to) => {
+        const steps = (to - from) / spacing;
+        return Math.abs(steps - Math.round(steps)) > tolerance;
+    };
+    const anchor = latticeAnchor(distinct, spacing, tolerance, offLattice);
+    const regular = projected.filter(({ d }) => !offLattice(anchor, d));
+    result.irregularCount += projected.length - regular.length;
+    result.regularCount = regular.length;
+    const lowest = regular.reduce((low, c) => (c.d < low.d ? c : low));
+    result.origin = [...lowest.position];
+    const occupied = new Map();
+    for (const { key, d } of projected) {
+        result.distance[key] = d - lowest.d;
+    }
+    for (const { key, d } of regular) {
+        const index = Math.round((d - lowest.d) / spacing);
+        result.index[key] = index;
+        occupied.set(index, (occupied.get(index) ?? 0) + 1);
+    }
+    result.positions = occupied.size;
+    result.complete = Math.max(...occupied.keys()) === occupied.size - 1;
+    result.duplicates = [...occupied.values()].some((count) => count > 1);
+    return result;
+};
+export function dicomDateTimeToSeconds(date, time) {
+    const timeText = time == null ? '' : String(time).replace(/:/g, '').trim();
+    const dateText = date == null ? '' : String(date).replace(/-/g, '').trim();
+    const timeMatch = /^(\d{2})(\d{2})?(\d{2})?(\.\d+)?/.exec(timeText);
+    if (!timeMatch) {
+        return undefined;
+    }
+    const [, hh, mm = '0', ss = '0', fraction = ''] = timeMatch;
+    const timeOfDay = Number(hh) * 3600 + Number(mm) * 60 + Number(ss) + Number(`0${fraction}`);
+    const dateMatch = /^(\d{4})(\d{2})(\d{2})$/.exec(dateText);
+    if (!dateMatch) {
+        return timeOfDay;
+    }
+    const [, year, month, day] = dateMatch;
+    return (Date.UTC(Number(year), Number(month) - 1, Number(day)) / 1000 + timeOfDay);
+}
+function acquisitionSeconds(instance) {
+    const dateTime = readOwn(instance, 'AcquisitionDateTime');
+    if (dateTime != null && String(dateTime).length > 8) {
+        const text = String(dateTime);
+        return dicomDateTimeToSeconds(text.slice(0, 8), text.slice(8));
+    }
+    for (const [date, time] of [
+        ['AcquisitionDate', 'AcquisitionTime'],
+        ['ContentDate', 'ContentTime'],
+    ]) {
+        const seconds = dicomDateTimeToSeconds(readOwn(instance, date), readOwn(instance, time));
+        if (seconds !== undefined) {
+            return seconds;
+        }
+    }
+    return undefined;
+}
+export const timeClusters = (instances, { args }) => {
+    const maxGap = numberArg(args, 'maxGap', 30);
+    const result = {
+        time: {},
+        start: {},
+        clusters: 0,
+        untimedCount: 0,
+    };
+    const timed = [];
+    for (const instance of instances) {
+        const key = instanceKey(instance);
+        const seconds = acquisitionSeconds(instance);
+        if (key === undefined || seconds === undefined) {
+            result.untimedCount++;
+            continue;
+        }
+        timed.push({ key, seconds });
+        result.time[key] = seconds;
+    }
+    timed.sort((a, b) => a.seconds - b.seconds || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+    let start;
+    let previous;
+    for (const { key, seconds } of timed) {
+        if (previous === undefined || seconds - previous > maxGap) {
+            start = seconds;
+            result.clusters++;
+        }
+        result.start[key] = start;
+        previous = seconds;
+    }
+    result.first = timed[0]?.seconds;
+    return result;
+};
+function predecessorUids(instance) {
+    const uids = [];
+    const items = (value) => value == null ? [] : asArray(value);
+    for (const study of items(readOwn(instance, 'PredecessorDocumentsSequence'))) {
+        for (const series of items(readOwn(study, 'ReferencedSeriesSequence'))) {
+            for (const sop of items(readOwn(series, 'ReferencedSOPSequence'))) {
+                const uid = readOwn(sop, 'ReferencedSOPInstanceUID');
+                if (typeof uid === 'string' && uid) {
+                    uids.push(uid);
+                }
+            }
+        }
+    }
+    return uids;
+}
+export const revisionChains = (instances) => {
+    const keys = instances.map(instanceKey);
+    const indexOf = new Map();
+    keys.forEach((key, index) => key !== undefined && indexOf.set(key, index));
+    const predecessors = instances.map((instance, index) => predecessorUids(instance)
+        .map((uid) => indexOf.get(uid))
+        .filter((predecessor) => predecessor !== undefined &&
+        predecessor !== index &&
+        instances[predecessor].SeriesInstanceUID ===
+            instance.SeriesInstanceUID));
+    const named = new Set(predecessors.flat());
+    const chainOf = instances.map(() => undefined);
+    instances.forEach((_instance, end) => {
+        if (named.has(end)) {
+            return;
+        }
+        const stack = [end];
+        while (stack.length) {
+            const index = stack.pop();
+            if (chainOf[index] !== undefined) {
+                continue;
+            }
+            chainOf[index] = end;
+            stack.push(...predecessors[index]);
+        }
+    });
+    const result = { active: {} };
+    keys.forEach((key, index) => {
+        const activeKey = keys[chainOf[index] ?? index];
+        if (key !== undefined && activeKey !== undefined) {
+            result.active[key] = activeKey;
+        }
+    });
+    return result;
+};
+export const BUILT_IN_SERIES_FUNCTIONS = Object.freeze({
+    planeGeometry: Object.freeze({
+        compute: planeGeometry,
+        fields: Object.freeze({
+            normal: 'series',
+            origin: 'series',
+            spacing: 'series',
+            regularCount: 'series',
+            irregularCount: 'series',
+            positions: 'series',
+            complete: 'series',
+            duplicates: 'series',
+            distance: 'instance',
+            index: 'instance',
+        }),
+    }),
+    timeClusters: Object.freeze({
+        compute: timeClusters,
+        fields: Object.freeze({
+            time: 'instance',
+            start: 'instance',
+            first: 'series',
+            clusters: 'series',
+            untimedCount: 'series',
+        }),
+    }),
+    revisionChains: Object.freeze({
+        compute: revisionChains,
+        fields: Object.freeze({ active: 'instance' }),
+    }),
+});

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

@@ -0,0 +1,14 @@
+export declare const imageSopClassUids: readonly string[];
+export declare const videoSopClassUids: readonly string[];
+export declare const videoTransferSyntaxUids: readonly string[];
+export declare const longVideoSopClassUids: readonly string[];
+export declare const longVideoMinFrames = 90;
+export declare const ecgSopClassUids: readonly string[];
+export declare const wholeSlideSopClassUids: readonly string[];
+export declare const segmentationSopClassUids: readonly string[];
+export declare const rtStructureSetSopClassUids: readonly string[];
+export declare const parametricMapSopClassUids: readonly string[];
+export declare const structuredReportSopClassUids: readonly string[];
+export declare const encapsulatedDocumentSopClassUids: readonly string[];
+export declare const bulkAnnotationSopClassUids: readonly string[];
+export declare const chartSopClassUids: readonly string[];

package/dist/esm/displayset/sopClassUidLists.js

@@ -0,0 +1,100 @@
+import { videoUIDs } from '../utilities/isVideoTransferSyntax.js';
+const list = (uids) => uids;
+export const imageSopClassUids = list([
+    '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.1.2',
+    '1.2.840.10008.5.1.4.1.1.1.2.1',
+    '1.2.840.10008.5.1.4.1.1.1.3',
+    '1.2.840.10008.5.1.4.1.1.1.3.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.3.1',
+    '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.3',
+    '1.2.840.10008.5.1.4.1.1.4.4',
+    '1.2.840.10008.5.1.4.1.1.6.1',
+    '1.2.840.10008.5.1.4.1.1.6.2',
+    '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.14.1',
+    '1.2.840.10008.5.1.4.1.1.14.2',
+    '1.2.840.10008.5.1.4.1.1.20',
+    '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.77.1.5.1',
+    '1.2.840.10008.5.1.4.1.1.77.1.5.2',
+    '1.2.840.10008.5.1.4.1.1.77.1.5.4',
+    '1.2.840.10008.5.1.4.1.1.77.1.6',
+    '1.2.840.10008.5.1.4.1.1.82.1',
+    '1.2.840.10008.5.1.4.1.1.128',
+    '1.2.840.10008.5.1.4.1.1.128.1',
+    '1.2.840.10008.5.1.4.1.1.130',
+    '1.2.840.10008.5.1.4.1.1.481.1',
+    '1.2.840.10008.5.1.4.1.1.481.2',
+]);
+export const videoSopClassUids = list([
+    '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',
+    '1.2.840.10008.5.1.4.1.1.77.1.4.1',
+]);
+export const videoTransferSyntaxUids = list([...videoUIDs]);
+export const longVideoSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.7',
+    '1.2.840.10008.5.1.4.1.1.7.4',
+]);
+export const longVideoMinFrames = 90;
+export const ecgSopClassUids = list([
+    '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 const wholeSlideSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.77.1.6',
+]);
+export const segmentationSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.66.4',
+    '1.2.840.10008.5.1.4.1.1.66.7',
+]);
+export const rtStructureSetSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.481.3',
+]);
+export const parametricMapSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.30',
+]);
+export const structuredReportSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.88.11',
+    '1.2.840.10008.5.1.4.1.1.88.22',
+    '1.2.840.10008.5.1.4.1.1.88.33',
+    '1.2.840.10008.5.1.4.1.1.88.34',
+    '1.2.840.10008.5.1.4.1.1.88.67',
+]);
+export const encapsulatedDocumentSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.104.1',
+]);
+export const bulkAnnotationSopClassUids = list([
+    '1.2.840.10008.5.1.4.1.1.91.1',
+]);
+export const chartSopClassUids = list([]);

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

@@ -0,0 +1,10 @@
+import type { NaturalizedInstance, RuleContext } from './types.js';
+export declare function compare(a: unknown, b: unknown): number;
+export declare function compareSOPInstanceUID(a: NaturalizedInstance, b: NaturalizedInstance, _context?: RuleContext): number;
+export declare function compareInstanceNumber(a: NaturalizedInstance, b: NaturalizedInstance, _context?: RuleContext): number;
+export declare function sortByInstanceNumber(a: NaturalizedInstance, b: NaturalizedInstance, context?: RuleContext): number;
+export declare const instancesSortCriteria: {
+    default: typeof sortByInstanceNumber;
+    sortByInstanceNumber: typeof sortByInstanceNumber;
+};
+export declare function sortInstancesCopy<T extends NaturalizedInstance>(instances: readonly T[], criteria?: (a: NaturalizedInstance, b: NaturalizedInstance, context?: RuleContext) => number, context?: RuleContext): T[];

package/dist/esm/displayset/sortInstances.js

@@ -0,0 +1,33 @@
+import { toFiniteFirst } from '@cornerstonejs/utils';
+export function compare(a, b) {
+    if (a == b) {
+        return 0;
+    }
+    if (!a && b) {
+        return -1;
+    }
+    if (!b && a) {
+        return 1;
+    }
+    return a < b ? -1 : 1;
+}
+export function compareSOPInstanceUID(a, b, _context) {
+    return compare(String(a.SOPInstanceUID ?? a.imageId ?? ''), String(b.SOPInstanceUID ?? b.imageId ?? ''));
+}
+export function compareInstanceNumber(a, b, _context) {
+    const aNumber = toFiniteFirst(a.InstanceNumber);
+    const bNumber = toFiniteFirst(b.InstanceNumber);
+    return aNumber !== undefined && bNumber !== undefined
+        ? aNumber - bNumber
+        : Number(aNumber === undefined) - Number(bNumber === undefined);
+}
+export function sortByInstanceNumber(a, b, context) {
+    return (compareInstanceNumber(a, b, context) || compareSOPInstanceUID(a, b, context));
+}
+export const instancesSortCriteria = {
+    default: sortByInstanceNumber,
+    sortByInstanceNumber,
+};
+export function sortInstancesCopy(instances, criteria = instancesSortCriteria.default, context) {
+    return [...instances].sort((a, b) => criteria(a, b, context));
+}

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

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

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

@@ -0,0 +1,56 @@
+import { compareInstanceNumber, sortByInstanceNumber, sortInstancesCopy, } from './sortInstances.js';
+const uids = (instances) => instances.map((instance) => instance.SOPInstanceUID);
+describe('sortByInstanceNumber - the default instance order', () => {
+    const CASES = [
+        [
+            'orders by InstanceNumber, also a numeric string',
+            [
+                { SOPInstanceUID: 'c', InstanceNumber: 10 },
+                { SOPInstanceUID: 'a', InstanceNumber: 2 },
+                { SOPInstanceUID: 'b', InstanceNumber: '3' },
+            ],
+            ['a', 'b', 'c'],
+        ],
+        [
+            'puts an absent InstanceNumber after the numbered instances, not at 0',
+            [
+                { SOPInstanceUID: 'none' },
+                { SOPInstanceUID: 'one', InstanceNumber: 1 },
+                { SOPInstanceUID: 'zero', InstanceNumber: 0 },
+            ],
+            ['zero', 'one', 'none'],
+        ],
+        [
+            'orders equal numbers by SOPInstanceUID',
+            [
+                { SOPInstanceUID: '1.2.9', InstanceNumber: 1 },
+                { SOPInstanceUID: '1.2.3', InstanceNumber: 1 },
+            ],
+            ['1.2.3', '1.2.9'],
+        ],
+    ];
+    for (const [name, instances, expected] of CASES) {
+        it(`${name}, and returns a copy`, () => {
+            const input = [...instances];
+            expect(uids(sortInstancesCopy(input))).toEqual(expected);
+            expect(input).toEqual(instances);
+        });
+    }
+    it('passes context down a custom comparator chain', () => {
+        const context = { series: {} };
+        const seen = [];
+        const byNumberThenDescription = (a, b, ctx) => {
+            seen.push(ctx);
+            return (compareInstanceNumber(a, b, ctx) ||
+                String(b.SeriesDescription).localeCompare(String(a.SeriesDescription)) ||
+                sortByInstanceNumber(a, b, ctx));
+        };
+        const sorted = sortInstancesCopy([
+            { SOPInstanceUID: 'x', InstanceNumber: 1, SeriesDescription: 'A' },
+            { SOPInstanceUID: 'y', InstanceNumber: 1, SeriesDescription: 'B' },
+        ], byNumberThenDescription, context);
+        expect(uids(sorted)).toEqual(['y', 'x']);
+        expect(seen.length).toBeGreaterThan(0);
+        expect(seen.every((value) => value === context)).toBe(true);
+    });
+});

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

@@ -1,6 +1,6 @@
-import type { InstanceGroup, NaturalizedInstance, SplitContext, SplitRule } from './types.js';
-export type SplitImageIdsBySplitRulesOptions = SplitContext & {
-    splitRules: SplitRule[];
+import type { GroupInstancesOptions, InstanceGroup, NaturalizedInstance, SplitContext, SplitRuleSet } from './types.js';
+export type SplitImageIdsBySplitRulesOptions = SplitContext & GroupInstancesOptions & {
+    splitRules: SplitRuleSet;
     onMissingImageId?: (imageId: string) => void;
     onUnmatchedInstance?: (instance: NaturalizedInstance) => void;
 };

package/dist/esm/displayset/splitImageIdsBySplitRules.js

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

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

@@ -0,0 +1,11 @@
+import type { SchemaShape } from '../safeFunctions/index.js';
+export declare const ATTRIBUTE_ONLY_NAMES: readonly ["splitNumber", "sopClassUids"];
+export declare const splitRuleSchema: {
+    rule: SchemaShape;
+    contextEntry: SchemaShape;
+    condition: SchemaShape;
+    matchTest: SchemaShape;
+    name: SchemaShape;
+    sortKey: SchemaShape;
+    attributeValue: SchemaShape;
+};