@cornerstonejs/metadata 5.13.1 → 5.14.0

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

@@ -1,2 +1,8 @@
-import type { InstanceGroup, NaturalizedInstance, SplitRule } from './types.js';
-export declare function groupInstancesBySplitRules(instances: NaturalizedInstance[], splitRules: SplitRule[], onUnmatched?: (instance: NaturalizedInstance) => void): InstanceGroup[];
+import type { GroupInstancesOptions, InstanceGroup, NaturalizedInstance, OrderInstancesOptions, SeriesFacts, SplitRule, SplitRuleSet } from './types.js';
+export declare function computeSeriesFacts(instances: NaturalizedInstance[], rules: readonly SplitRule[]): SeriesFacts;
+type Comparator = NonNullable<SplitRule['compareInstances']>;
+export declare function chainComparators(comparators: Comparator[]): Comparator;
+export declare function orderInstancesForRule(instances: NaturalizedInstance[], splitRule: SplitRule, options?: OrderInstancesOptions): NaturalizedInstance[];
+export declare function normalizeSplitKeyPart(value: unknown): unknown;
+export declare function groupInstancesBySplitRules(instances: NaturalizedInstance[], ruleSet: SplitRuleSet, onUnmatched?: (instance: NaturalizedInstance) => void, options?: GroupInstancesOptions): InstanceGroup[];
+export {};

package/dist/esm/displayset/groupInstancesBySplitRules.js

@@ -1,37 +1,194 @@
-function buildSplitKey(instance, context, splitRule, ruleDiscriminator) {
+import { resolveSplitRuleSet } from './splitRuleSet.js';
+import { displaySetContextFor, withInstances } from './displaySetContext.js';
+import { sortInstancesCopy } from './sortInstances.js';
+import { hasNoValue, isUnsafeKey } from '../safeFunctions/index.js';
+export function computeSeriesFacts(instances, rules) {
+    const facts = {};
+    for (const rule of rules) {
+        if (!rule.series) {
+            continue;
+        }
+        const computed = rule.series({ instances, series: facts }) ?? {};
+        for (const [name, value] of Object.entries(computed)) {
+            if (!isUnsafeKey(name) &&
+                !Object.prototype.hasOwnProperty.call(facts, name)) {
+                facts[name] = value;
+            }
+        }
+    }
+    return facts;
+}
+export function chainComparators(comparators) {
+    if (comparators.length === 1) {
+        return comparators[0];
+    }
+    return (a, b, context) => {
+        for (const comparator of comparators) {
+            const order = comparator(a, b, context);
+            if (Number.isFinite(order) && order !== 0) {
+                return order;
+            }
+        }
+        return 0;
+    };
+}
+function buildInstanceOrderer(splitRule, context, options) {
+    const comparators = [
+        splitRule.compareInstances,
+        options.compareInstances,
+    ].filter((comparator) => typeof comparator === 'function');
+    const baseSort = options.sortInstances;
+    const orderContext = {
+        matchedRule: splitRule,
+        series: context.series,
+    };
+    return (instances) => {
+        let ordered = sortInstancesCopy(instances);
+        if (baseSort) {
+            ordered = [...baseSort(ordered, orderContext)];
+        }
+        if (comparators.length) {
+            const compare = chainComparators(comparators);
+            const sortContext = {
+                ...context,
+                displaySet: displaySetContextFor(context.series, ordered),
+            };
+            ordered.sort((a, b) => compare(a, b, sortContext));
+        }
+        return ordered;
+    };
+}
+export function orderInstancesForRule(instances, splitRule, options = {}) {
+    const context = {
+        series: options.series
+            ? withInstances(options.series, instances)
+            : computeSeriesFacts(sortInstancesCopy(instances), [splitRule]),
+    };
+    return buildInstanceOrderer(splitRule, context, options)(instances);
+}
+function isDigitAt(value, index) {
+    const code = value.charCodeAt(index);
+    return code >= 0x30 && code <= 0x39;
+}
+function digitRunEnd(value, start) {
+    let end = start;
+    while (end < value.length && isDigitAt(value, end)) {
+        end += 1;
+    }
+    return end;
+}
+function compareDigitRuns(a, b) {
+    const aValue = a.replace(/^0+/, '');
+    const bValue = b.replace(/^0+/, '');
+    if (aValue.length !== bValue.length) {
+        return aValue.length - bValue.length;
+    }
+    if (aValue !== bValue) {
+        return aValue < bValue ? -1 : 1;
+    }
+    return a.length - b.length;
+}
+function compareSplitKeys(a, b) {
+    let aIndex = 0;
+    let bIndex = 0;
+    while (aIndex < a.length && bIndex < b.length) {
+        if (isDigitAt(a, aIndex) && isDigitAt(b, bIndex)) {
+            const aEnd = digitRunEnd(a, aIndex);
+            const bEnd = digitRunEnd(b, bIndex);
+            const byDigits = compareDigitRuns(a.slice(aIndex, aEnd), b.slice(bIndex, bEnd));
+            if (byDigits !== 0) {
+                return byDigits;
+            }
+            aIndex = aEnd;
+            bIndex = bEnd;
+            continue;
+        }
+        const aCode = a.charCodeAt(aIndex);
+        const bCode = b.charCodeAt(bIndex);
+        if (aCode !== bCode) {
+            return aCode - bCode;
+        }
+        aIndex += 1;
+        bIndex += 1;
+    }
+    return a.length - aIndex - (b.length - bIndex);
+}
+export function normalizeSplitKeyPart(value) {
+    if (hasNoValue(value)) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        const parts = value.map(normalizeSplitKeyPart);
+        return parts.length === 1 ? parts[0] : parts;
+    }
+    if (typeof value === 'string') {
+        const number = Number(value);
+        return Number.isFinite(number) && String(number) === value ? number : value;
+    }
+    return value;
+}
+function buildGroupByParts(instance, context, splitRule) {
     const groupBy = splitRule.groupBy ?? ['SeriesInstanceUID'];
-    const parts = groupBy.map((key) => typeof key === 'function' ? key(instance, context) : instance[key]);
-    return JSON.stringify([ruleDiscriminator, ...parts]);
+    return groupBy.map((key) => normalizeSplitKeyPart(typeof key === 'function' ? key(instance, context) : instance[key]));
+}
+function buildSplitKey(ruleDiscriminator, baseKeyParts) {
+    return JSON.stringify([ruleDiscriminator, ...baseKeyParts]);
 }
-export function groupInstancesBySplitRules(instances, splitRules, onUnmatched) {
+export function groupInstancesBySplitRules(instances, ruleSet, onUnmatched, options = {}) {
+    const splitRules = resolveSplitRuleSet(ruleSet);
     if (!instances.length) {
         return [];
     }
-    const ruleContexts = splitRules.map((rule) => ({
-        series: rule.series?.({ instances }) ?? {},
-    }));
-    const instancesMap = new Map();
-    for (const instance of instances) {
+    const sorted = sortInstancesCopy(instances);
+    const context = {
+        series: computeSeriesFacts(sorted, splitRules),
+    };
+    const claimedByRule = splitRules.map(() => []);
+    for (const instance of sorted) {
         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;
             }
+            claimedByRule[ruleIndex].push(instance);
             matched = true;
-            const key = buildSplitKey(instance, context, splitRule, `${ruleIndex}:${splitRule.id ?? ''}`);
+            break;
+        }
+        if (!matched) {
+            onUnmatched?.(instance);
+        }
+    }
+    const ruleOrderers = splitRules.map((rule) => buildInstanceOrderer(rule, context, options));
+    const instancesMap = new Map();
+    const groupRuleIndex = new Map();
+    for (let ruleIndex = 0; ruleIndex < splitRules.length; ruleIndex++) {
+        const splitRule = splitRules[ruleIndex];
+        for (const instance of claimedByRule[ruleIndex]) {
+            const key = buildSplitKey(splitRule.id, buildGroupByParts(instance, context, splitRule));
             let group = instancesMap.get(key);
             if (!group) {
-                group = { instances: [], matchedRule: splitRule, splitKey: key };
+                group = {
+                    instances: [],
+                    matchedRule: splitRule,
+                    series: context.series,
+                    splitKey: key,
+                };
                 instancesMap.set(key, group);
+                groupRuleIndex.set(key, ruleIndex);
             }
             group.instances.push(instance);
-            break;
-        }
-        if (!matched) {
-            onUnmatched?.(instance);
         }
     }
-    return Array.from(instancesMap.values()).sort((a, b) => (a.splitKey ?? '').localeCompare(b.splitKey ?? ''));
+    const groups = Array.from(instancesMap.values());
+    for (const group of groups) {
+        const ruleIndex = groupRuleIndex.get(group.splitKey ?? '') ?? 0;
+        group.instances = ruleOrderers[ruleIndex](group.instances);
+    }
+    return groups.sort((a, b) => {
+        const aKey = a.splitKey ?? '';
+        const bKey = b.splitKey ?? '';
+        const ruleOrder = (groupRuleIndex.get(aKey) ?? 0) - (groupRuleIndex.get(bKey) ?? 0);
+        return ruleOrder !== 0 ? ruleOrder : compareSplitKeys(aKey, bKey);
+    });
 }

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

@@ -6,17 +6,27 @@ export type { ImageStackDisplaySetOptions } from './ImageStackDisplaySet.js';
 export { resolveInstances } from './resolveInstances.js';
 export type { ResolveInstancesOptions } from './resolveInstances.js';
 export { buildSeriesInfo } from './buildSeriesInfo.js';
-export { groupInstancesBySplitRules } from './groupInstancesBySplitRules.js';
+export { groupInstancesBySplitRules, orderInstancesForRule, } from './groupInstancesBySplitRules.js';
+export type { PlaneGeometry, TimeClusters } from './seriesFunctions.js';
+export { resolveSplitRuleSet } from './splitRuleSet.js';
+export { compare, compareInstanceNumber, compareSOPInstanceUID, sortByInstanceNumber, instancesSortCriteria, sortInstancesCopy, } from './sortInstances.js';
 export { splitImageIdsBySplitRules } from './splitImageIdsBySplitRules.js';
 export type { SplitImageIdsBySplitRulesOptions } from './splitImageIdsBySplitRules.js';
 export { registerDisplaySetMetadata, type RegisterDisplaySetMetadataOptions, } from './registerDisplaySetMetadata.js';
 export { registerDisplaySetProviders } from './displaySetProvider.js';
-export { defaultDisplaySetSplitRules } from './defaultDisplaySetSplitRules.js';
+export { compiledDisplaySetRules, defaultDisplaySetSplitRules, } from './compiledDisplaySetRules.js';
+export { displaySetRules, createDisplaySetSplitRules } from './displaySetRules.js';
+export { defaultMetadataContext } from './displaySetContext.js';
+export { setMetadataContext, getMetadataContext, getContextValue, } from './metadataContext.js';
+export { imageSopClassUids, videoSopClassUids, videoTransferSyntaxUids, longVideoSopClassUids, longVideoMinFrames, ecgSopClassUids, wholeSlideSopClassUids, segmentationSopClassUids, rtStructureSetSopClassUids, parametricMapSopClassUids, structuredReportSopClassUids, encapsulatedDocumentSopClassUids, bulkAnnotationSopClassUids, chartSopClassUids, } from './sopClassUidLists.js';
+export type { ContextEntry, ContextGroupEntry, ContextValues, DisplaySetContext, InstanceContextFunction, } from './displaySetContext.js';
+export type { InstanceHook, RawAttributeValue, RawCondition, RawMatchTest, RawName, RawSortKey, RawSplitRule, DisplaySetRules, CreateDisplaySetSplitRulesOptions, } from './displaySetRulesTypes.js';
 export { createDisplaySetFromGroup } from './createDisplaySetFromGroup.js';
 export type { CreateDisplaySetFromGroupOptions } from './createDisplaySetFromGroup.js';
 export { isImageInstance } from './isImageInstance.js';
 export { isVideoInstance } from './isVideoInstance.js';
 export { isEcgInstance } from './isEcgInstance.js';
 export { isWsiInstance } from './isWsiInstance.js';
-export { getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './viewportTypes.js';
-export type { NaturalizedInstance, SeriesInfo, SeriesFacts, SeriesContext, RuleContext, SplitRule, SplitContext, SplitRuleOptions, SplitRuleCustomAttributesContext, InstanceGroup, ViewportTypeHint, } from './types.js';
+export { isReconstructableInstances } from './isReconstructableInstances.js';
+export { DEFAULT_SPLIT_RULE_PRIORITY_LIMIT, DISPLAY_SET_HANDLER_NAMES, } from './types.js';
+export type { NaturalizedInstance, SeriesInfo, SeriesFacts, SeriesContext, SeriesFunction, SeriesFunctionDefinition, SeriesFieldScope, RuleContext, SplitRule, SplitContext, SplitRuleOptions, SplitRuleCustomAttributesContext, InstanceGroup, InstanceOrderContext, SortInstances, GroupInstancesOptions, SplitRuleSet, SplitRuleSetEntry, OrderInstancesOptions, } from './types.js';

package/dist/esm/displayset/index.js

@@ -2,14 +2,21 @@ export { BaseDisplaySet } from './BaseDisplaySet.js';
 export { ImageStackDisplaySet } from './ImageStackDisplaySet.js';
 export { resolveInstances } from './resolveInstances.js';
 export { buildSeriesInfo } from './buildSeriesInfo.js';
-export { groupInstancesBySplitRules } from './groupInstancesBySplitRules.js';
+export { groupInstancesBySplitRules, orderInstancesForRule, } from './groupInstancesBySplitRules.js';
+export { resolveSplitRuleSet } from './splitRuleSet.js';
+export { compare, compareInstanceNumber, compareSOPInstanceUID, sortByInstanceNumber, instancesSortCriteria, sortInstancesCopy, } from './sortInstances.js';
 export { splitImageIdsBySplitRules } from './splitImageIdsBySplitRules.js';
 export { registerDisplaySetMetadata, } from './registerDisplaySetMetadata.js';
 export { registerDisplaySetProviders } from './displaySetProvider.js';
-export { defaultDisplaySetSplitRules } from './defaultDisplaySetSplitRules.js';
+export { compiledDisplaySetRules, defaultDisplaySetSplitRules, } from './compiledDisplaySetRules.js';
+export { displaySetRules, createDisplaySetSplitRules } from './displaySetRules.js';
+export { defaultMetadataContext } from './displaySetContext.js';
+export { setMetadataContext, getMetadataContext, getContextValue, } from './metadataContext.js';
+export { imageSopClassUids, videoSopClassUids, videoTransferSyntaxUids, longVideoSopClassUids, longVideoMinFrames, ecgSopClassUids, wholeSlideSopClassUids, segmentationSopClassUids, rtStructureSetSopClassUids, parametricMapSopClassUids, structuredReportSopClassUids, encapsulatedDocumentSopClassUids, bulkAnnotationSopClassUids, chartSopClassUids, } from './sopClassUidLists.js';
 export { createDisplaySetFromGroup } from './createDisplaySetFromGroup.js';
 export { isImageInstance } from './isImageInstance.js';
 export { isVideoInstance } from './isVideoInstance.js';
 export { isEcgInstance } from './isEcgInstance.js';
 export { isWsiInstance } from './isWsiInstance.js';
-export { getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './viewportTypes.js';
+export { isReconstructableInstances } from './isReconstructableInstances.js';
+export { DEFAULT_SPLIT_RULE_PRIORITY_LIMIT, DISPLAY_SET_HANDLER_NAMES, } from './types.js';

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

@@ -1,2 +1,3 @@
+import type { DisplaySetContext } from './displaySetContext.js';
 import type { NaturalizedInstance } from './types.js';
-export declare function isEcgInstance(instance: NaturalizedInstance): boolean;
+export declare function isEcgInstance(instance: NaturalizedInstance, context?: DisplaySetContext): boolean;

package/dist/esm/displayset/isEcgInstance.js

@@ -1,10 +1,5 @@
-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 ?? '');
+import { isTrue } from '../safeFunctions/values.js';
+import { getContextValue } from './metadataContext.js';
+export function isEcgInstance(instance, context) {
+    return isTrue(getContextValue('isEcg', instance, context));
 }

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

@@ -1,2 +1,3 @@
+import type { DisplaySetContext } from './displaySetContext.js';
 import type { NaturalizedInstance } from './types.js';
-export declare function isImageInstance(instance: NaturalizedInstance): boolean;
+export declare function isImageInstance(instance: NaturalizedInstance, context?: DisplaySetContext): boolean;

package/dist/esm/displayset/isImageInstance.js

@@ -1,45 +1,5 @@
-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 ?? '');
+import { isTrue } from '../safeFunctions/values.js';
+import { getContextValue } from './metadataContext.js';
+export function isImageInstance(instance, context) {
+    return isTrue(getContextValue('isImage', instance, context));
 }

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

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

package/dist/esm/displayset/isReconstructableInstances.js

@@ -0,0 +1,91 @@
+import { asArrayFirst, toFiniteFirst, toFiniteVector, } from '@cornerstonejs/utils';
+import { readOwn } from '../safeFunctions/index.js';
+import { planeGeometry } from './seriesFunctions.js';
+const SPACING_TOLERANCE = 0.2;
+const item = (value) => asArrayFirst(value);
+function vectorAt(source, path, field, length) {
+    let current = source;
+    for (const sequence of path) {
+        current = item(readOwn(current, sequence));
+    }
+    return toFiniteVector(readOwn(current, field), length);
+}
+function geometryOf(positions, orientation) {
+    return planeGeometry(positions.map((ImagePositionPatient, index) => ({
+        SOPInstanceUID: String(index),
+        ImagePositionPatient,
+        ImageOrientationPatient: orientation,
+    })), { args: { tolerance: SPACING_TOLERANCE } });
+}
+function isSingleFrameVolume(instances) {
+    if (instances.length < 2) {
+        return false;
+    }
+    const [first] = instances;
+    const same = (name) => (instance) => toFiniteFirst(readOwn(instance, name)) ===
+        toFiniteFirst(readOwn(first, name));
+    if (!instances.every(same('Rows')) ||
+        !instances.every(same('Columns')) ||
+        !instances.every(same('SamplesPerPixel'))) {
+        return false;
+    }
+    const geometry = planeGeometry([...instances], {
+        args: { tolerance: SPACING_TOLERANCE },
+    });
+    return (geometry.irregularCount === 0 &&
+        geometry.positions >= 2 &&
+        !geometry.duplicates);
+}
+function framePositions(instance) {
+    const perFrame = asArrayFromSequence(readOwn(instance, 'PerFrameFunctionalGroupsSequence')).map((group) => vectorAt(group, ['PlanePositionSequence'], 'ImagePositionPatient', 3));
+    if (perFrame.filter(Boolean).length >= 2) {
+        return perFrame;
+    }
+    const shared = vectorAt(instance, ['SharedFunctionalGroupsSequence', 'PlanePositionSequence'], 'ImagePositionPatient', 3);
+    const count = toFiniteFirst(instance.NumberOfFrames, perFrame.length);
+    return shared ? new Array(count).fill(shared) : [];
+}
+function asArrayFromSequence(value) {
+    return Array.isArray(value) ? value : value == null ? [] : [value];
+}
+function isMultiFrameVolume(instance) {
+    const perFrame0 = item(readOwn(instance, 'PerFrameFunctionalGroupsSequence'));
+    const shared = item(readOwn(instance, 'SharedFunctionalGroupsSequence'));
+    const detector = item(readOwn(instance, 'DetectorInformationSequence'));
+    const hasPixelMeasures = readOwn(perFrame0, 'PixelMeasuresSequence') != null ||
+        readOwn(shared, 'PixelMeasuresSequence') != null ||
+        (instance.PixelSpacing != null &&
+            (instance.SliceThickness != null ||
+                instance.SpacingBetweenFrames != null));
+    const orientation = toFiniteVector(instance.ImageOrientationPatient, 6) ??
+        vectorAt(shared, ['PlaneOrientationSequence'], 'ImageOrientationPatient', 6) ??
+        vectorAt(perFrame0, ['PlaneOrientationSequence'], 'ImageOrientationPatient', 6) ??
+        toFiniteVector(readOwn(detector, 'ImageOrientationPatient'), 6);
+    const hasPosition = readOwn(perFrame0, 'PlanePositionSequence') != null ||
+        readOwn(perFrame0, 'CTPositionSequence') != null ||
+        instance.ImagePositionPatient != null ||
+        readOwn(detector, 'ImagePositionPatient') != null;
+    if (!hasPixelMeasures || !orientation || !hasPosition) {
+        return false;
+    }
+    if (String(instance.Modality ?? '').includes('NM')) {
+        const subType = asArrayFromSequence(instance.ImageType)[2];
+        if (subType !== 'RECON TOMO' && subType !== 'RECON GATED TOMO') {
+            return false;
+        }
+    }
+    const positions = framePositions(instance);
+    if (positions.filter(Boolean).length < 2) {
+        return true;
+    }
+    return geometryOf(positions, orientation).positions >= 2;
+}
+export function isReconstructableInstances(instances) {
+    const defined = instances.filter(Boolean);
+    if (!defined.length) {
+        return false;
+    }
+    return toFiniteFirst(defined[0].NumberOfFrames, 0) > 1
+        ? isMultiFrameVolume(defined[0])
+        : isSingleFrameVolume(defined);
+}

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

@@ -1,2 +1,3 @@
+import type { DisplaySetContext } from './displaySetContext.js';
 import type { NaturalizedInstance } from './types.js';
-export declare function isVideoInstance(instance: NaturalizedInstance): boolean;
+export declare function isVideoInstance(instance: NaturalizedInstance, context?: DisplaySetContext): boolean;

package/dist/esm/displayset/isVideoInstance.js

@@ -1,31 +1,5 @@
-import { videoUIDs } from '../utilities/isVideoTransferSyntax.js';
-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);
+import { isTrue } from '../safeFunctions/values.js';
+import { getContextValue } from './metadataContext.js';
+export function isVideoInstance(instance, context) {
+    return isTrue(getContextValue('isVideo', instance, context));
 }

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

@@ -1,2 +1,3 @@
+import type { DisplaySetContext } from './displaySetContext.js';
 import type { NaturalizedInstance } from './types.js';
-export declare function isWsiInstance(instance: NaturalizedInstance): boolean;
+export declare function isWsiInstance(instance: NaturalizedInstance, context?: DisplaySetContext): boolean;

package/dist/esm/displayset/isWsiInstance.js

@@ -1,7 +1,5 @@
-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';
+import { isTrue } from '../safeFunctions/values.js';
+import { getContextValue } from './metadataContext.js';
+export function isWsiInstance(instance, context) {
+    return isTrue(getContextValue('isWsi', instance, context));
 }

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

@@ -0,0 +1,13 @@
+import { ContextProgram } from './displaySetContext.js';
+import type { DisplaySetContext } from './displaySetContext.js';
+import type { NaturalizedInstance, SeriesFunction, SeriesFunctionDefinition } from './types.js';
+export declare function setMetadataContext(context?: DisplaySetContext): void;
+export declare function getMetadataContext(): DisplaySetContext;
+export type CompileMetadataContextOptions = {
+    seriesFunctions?: Readonly<Record<string, SeriesFunction | SeriesFunctionDefinition>>;
+    deniedNames?: readonly string[];
+    definition?: string;
+};
+export declare function compileMetadataContext(context: DisplaySetContext | undefined, options?: CompileMetadataContextOptions): ContextProgram;
+export declare function getMetadataContextProgram(context: DisplaySetContext | undefined, options?: CompileMetadataContextOptions): ContextProgram;
+export declare function getContextValue(name: string, instance: NaturalizedInstance, context?: DisplaySetContext): unknown;

package/dist/esm/displayset/metadataContext.js

@@ -0,0 +1,42 @@
+import { createSite, safeFunctionCompilers } from '../safeFunctions/index.js';
+import { ContextProgram, defaultMetadataContext } from './displaySetContext.js';
+import { BUILT_IN_SERIES_FUNCTIONS } from './seriesFunctions.js';
+import { splitRuleSchema } from './splitRuleSchema.js';
+let activeContext = defaultMetadataContext;
+export function setMetadataContext(context) {
+    activeContext = context ?? defaultMetadataContext;
+}
+export function getMetadataContext() {
+    return activeContext;
+}
+const programs = new WeakMap();
+export function compileMetadataContext(context, options = {}) {
+    const program = new ContextProgram({ ...defaultMetadataContext, ...context }, {
+        seriesFunctions: {
+            ...BUILT_IN_SERIES_FUNCTIONS,
+            ...options.seriesFunctions,
+        },
+        deniedNames: options.deniedNames,
+        site: createSite({
+            definition: options.definition ?? 'metadata context',
+            path: 'context',
+        }, splitRuleSchema, safeFunctionCompilers),
+    });
+    if (!options.seriesFunctions && !options.deniedNames) {
+        programs.set(context ?? defaultMetadataContext, program);
+    }
+    return program;
+}
+export function getMetadataContextProgram(context, options = {}) {
+    const shareable = !options.seriesFunctions && !options.deniedNames;
+    const cached = shareable
+        ? programs.get(context ?? defaultMetadataContext)
+        : undefined;
+    return cached ?? compileMetadataContext(context, options);
+}
+function programOf(context) {
+    return getMetadataContextProgram(context);
+}
+export function getContextValue(name, instance, context) {
+    return programOf(context ?? activeContext).instanceValue(name, instance);
+}

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

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

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

@@ -0,0 +1,62 @@
+import { defaultMetadataContext } from './displaySetContext.js';
+import { isImageInstance } from './isImageInstance.js';
+import { isVideoInstance } from './isVideoInstance.js';
+import { getContextValue, getMetadataContext, setMetadataContext, } from './metadataContext.js';
+import { imageSopClassUids } from './sopClassUidLists.js';
+const NEW_UID = '1.2.3.4';
+const CT = '1.2.840.10008.5.1.4.1.1.2';
+const extended = {
+    ...defaultMetadataContext,
+    imageSopClassUids: [...imageSopClassUids, NEW_UID],
+};
+describe('the active metadata context', () => {
+    afterEach(() => setMetadataContext(undefined));
+    const CASES = [
+        ['the default context', () => undefined, undefined, true, false],
+        [
+            'an active context with one more UID',
+            () => setMetadataContext(extended),
+            undefined,
+            true,
+            true,
+        ],
+        ['an explicit context argument', () => undefined, extended, true, true],
+        [
+            'the default again after setMetadataContext(undefined)',
+            () => {
+                setMetadataContext(extended);
+                setMetadataContext(undefined);
+            },
+            undefined,
+            true,
+            false,
+        ],
+    ];
+    for (const [name, setup, context, ct, added] of CASES) {
+        it(`gives isImageInstance the lists of ${name}`, () => {
+            setup();
+            expect([
+                isImageInstance({ SOPClassUID: CT }, context),
+                isImageInstance({ SOPClassUID: NEW_UID }, context),
+            ]).toEqual([ct, added]);
+        });
+    }
+    it('returns the default context, and the context that a host sets', () => {
+        expect(getMetadataContext()).toBe(defaultMetadataContext);
+        setMetadataContext(extended);
+        expect(getMetadataContext()).toBe(extended);
+    });
+    it('applies a customized isVideo expression to isVideoInstance', () => {
+        const subject = { SOPClassUID: CT, Modality: 'XC' };
+        expect(isVideoInstance(subject)).toBe(false);
+        setMetadataContext({
+            ...defaultMetadataContext,
+            isVideo: "Modality == 'XC'",
+        });
+        expect(isVideoInstance(subject)).toBe(true);
+    });
+    it('reads any instance-scope name, and rejects a series-scope name', () => {
+        expect(getContextValue('isMultiFrame', { NumberOfFrames: 3 })).toBe(true);
+        expect(() => getContextValue('seriesInstanceCount', {})).toThrow(/series scope/);
+    });
+});

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

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