@cornerstonejs/metadata 5.13.1 → 5.14.0

package/dist/esm/safeFunctions/schema.js

@@ -0,0 +1,361 @@
+export const INSTANCE_EXPRESSION_SCOPE = Object.freeze({
+    params: Object.freeze(['instance', 'context']),
+    implicitScope: 'instance',
+});
+export function hasOwn(object, key) {
+    return (object != null &&
+        (typeof object === 'object' || typeof object === 'function') &&
+        Object.prototype.hasOwnProperty.call(object, key));
+}
+export function readOwn(object, key) {
+    return hasOwn(object, key)
+        ? object[key]
+        : undefined;
+}
+export function isUnsafeKey(key) {
+    return key === '__proto__';
+}
+function stringify(fragment) {
+    if (typeof fragment === 'function') {
+        return '<function>';
+    }
+    try {
+        return JSON.stringify(fragment) ?? String(fragment);
+    }
+    catch {
+        return String(fragment);
+    }
+}
+export class RuleCompileError extends Error {
+    constructor(definition, path, message) {
+        super(message);
+        this.definition = definition;
+        this.path = path;
+        this.name = 'RuleCompileError';
+    }
+}
+export function invalidAt(site, message, ...fragment) {
+    const where = site.path ? `${site.path}: ` : '';
+    const what = fragment.length ? `: ${stringify(fragment[0])}` : '';
+    throw new RuleCompileError(site.definition, site.path, `Invalid ${site.definition}: ${where}${message}${what}`);
+}
+export function didYouMean(name, candidates) {
+    const lower = name.toLowerCase();
+    for (const candidate of candidates) {
+        if (candidate && candidate !== name && candidate.toLowerCase() === lower) {
+            return `; did you mean '${candidate}'?`;
+        }
+    }
+    return '';
+}
+export function at(site, key, spec) {
+    const path = typeof key === 'number'
+        ? `${site.path}[${key}]`
+        : site.path
+            ? `${site.path}.${key}`
+            : key;
+    return {
+        ...site,
+        path,
+        extraKeys: undefined,
+        expression: spec?.expression ?? site.expression,
+        call: spec?.call ?? site.call,
+    };
+}
+const LEAF_KINDS = new Set([
+    'string',
+    'number',
+    'boolean',
+    'true',
+    'scalar',
+    'literal',
+    'priority',
+    'expression',
+]);
+export function isLeafKind(kind) {
+    return LEAF_KINDS.has(kind);
+}
+const LEAF_CHECKS = {
+    string: ['a string', (v) => typeof v === 'string'],
+    expression: ['an expression string', (v) => typeof v === 'string'],
+    number: [
+        'a finite number',
+        (v) => typeof v === 'number' && Number.isFinite(v),
+    ],
+    boolean: ['a boolean', (v) => typeof v === 'boolean'],
+    true: ['true', (v) => v === true],
+    scalar: [
+        'a string, a finite number or a boolean',
+        (v) => typeof v === 'string' ||
+            typeof v === 'boolean' ||
+            (typeof v === 'number' && Number.isFinite(v)),
+    ],
+    literal: ['any value', () => true],
+    priority: [
+        'a finite number, or null',
+        (v) => v === null || (typeof v === 'number' && Number.isFinite(v)),
+    ],
+};
+function checkLeaf(spec, value, site, label = 'value') {
+    const [expected, test] = LEAF_CHECKS[spec.kind];
+    if (!test(value)) {
+        invalidAt(site, `expected ${expected}`, value);
+    }
+    if (spec.oneOf && !spec.oneOf.includes(value)) {
+        invalidAt(site, `unknown ${label} ${stringify(value)}; allowed: ${spec.oneOf.join(', ')}`);
+    }
+}
+export function describeForm(form, scope) {
+    const names = [];
+    const operators = [];
+    for (const [key, spec] of Object.entries(form.keys)) {
+        if (spec.role === 'operator') {
+            operators.push(key);
+            continue;
+        }
+        if (key === '*') {
+            names.push('<any key>');
+            continue;
+        }
+        names.push(spec.optional || spec.role === 'modifier' ? `${key}?` : key);
+    }
+    if (operators.length) {
+        names.splice(1, 0, `<one of ${operators.join(' | ')}>`);
+    }
+    const text = `{ ${names.join(', ')} }`;
+    const expressionScope = form.expression ?? ('expression' in form.keys ? scope : undefined);
+    return expressionScope
+        ? `${text} called with (${expressionScope.params.join(', ')})`
+        : text;
+}
+export function describeShape(shape, site) {
+    const scope = site?.expression;
+    const parts = [];
+    if (shape.string === 'expression') {
+        parts.push(scope
+            ? `an expression string called with (${scope.params.join(', ')})`
+            : 'an expression string');
+    }
+    else if (shape.string === 'attribute') {
+        parts.push('a name (a DICOM keyword or a context name)');
+    }
+    for (const form of Object.values(shape.forms)) {
+        parts.push(describeForm(form, scope));
+    }
+    if (shape.function) {
+        parts.push(site?.call ? `a function ${site.call}` : 'a function');
+    }
+    if (parts.length === 1) {
+        return parts[0];
+    }
+    return `${parts.slice(0, -1).join(', ')}, or ${parts[parts.length - 1]}`;
+}
+export function unrecognized(shape, fragment, site) {
+    return invalidAt(site, `unrecognized ${shape.name}; expected ${describeShape(shape, site)}`, fragment);
+}
+export function selectForm(shape, fragment, site) {
+    if (fragment && typeof fragment === 'object' && !Array.isArray(fragment)) {
+        let fallback;
+        for (const entry of Object.entries(shape.forms)) {
+            const { selectBy } = entry[1];
+            if (selectBy === undefined) {
+                fallback ??= entry;
+            }
+            else if (Object.prototype.hasOwnProperty.call(fragment, selectBy)) {
+                return entry;
+            }
+        }
+        if (fallback) {
+            return fallback;
+        }
+    }
+    return unrecognized(shape, fragment, site);
+}
+export function checkForm(form, fragment, site, keyNoun = 'key') {
+    const allowed = {
+        ...form.keys,
+        ...site.extraKeys,
+    };
+    const wildcard = allowed['*'];
+    for (const key of Object.keys(fragment)) {
+        if (!Object.prototype.hasOwnProperty.call(allowed, key) && !wildcard) {
+            invalidAt(site, `unknown ${keyNoun} '${key}'${didYouMean(key, Object.keys(allowed))}; allowed: ${Object.keys(allowed).join(', ')}`);
+        }
+    }
+    const operators = [];
+    let hasOperatorKeys = false;
+    for (const [key, spec] of Object.entries(allowed)) {
+        if (key === '*') {
+            continue;
+        }
+        if (spec.role === 'operator') {
+            hasOperatorKeys = true;
+        }
+        const present = Object.prototype.hasOwnProperty.call(fragment, key) &&
+            fragment[key] !== undefined;
+        if (!present) {
+            if (!spec.optional && !spec.role) {
+                invalidAt(site, `missing ${keyNoun} '${key}'`, fragment);
+            }
+            continue;
+        }
+        if (spec.role === 'operator') {
+            operators.push(key);
+        }
+        if (isLeafKind(spec.kind)) {
+            const keySite = at(site, key, spec);
+            if (spec.list) {
+                const list = fragment[key];
+                if (!Array.isArray(list)) {
+                    invalidAt(keySite, 'expected an array', list);
+                }
+                list.forEach((entry, index) => checkLeaf(spec, entry, at(keySite, index), key));
+            }
+            else {
+                checkLeaf(spec, fragment[key], keySite, key);
+            }
+        }
+    }
+    if (hasOperatorKeys) {
+        const all = Object.entries(allowed)
+            .filter(([, spec]) => spec.role === 'operator')
+            .map(([key]) => key);
+        const subject = form.selectBy
+            ? `${form.selectBy} ${stringify(fragment[form.selectBy])}`
+            : 'this form';
+        if (!operators.length) {
+            invalidAt(site, `no operator for ${subject}; expected exactly one of: ${all.join(', ')}`, fragment);
+        }
+        if (operators.length > 1) {
+            invalidAt(site, `more than one operator for ${subject} (${operators.join(', ')}); expected exactly one of: ${all.join(', ')}`, fragment);
+        }
+    }
+    for (const [key, spec] of Object.entries(allowed)) {
+        if (spec.role === 'modifier' &&
+            fragment[key] !== undefined &&
+            spec.with &&
+            !spec.with.some((operator) => operators.includes(operator))) {
+            invalidAt(site, `'${key}' applies only with ${spec.with.join(', ')}`, fragment);
+        }
+    }
+}
+export function compileKey(spec, value, site) {
+    if (spec.function && typeof value === 'function') {
+        return value;
+    }
+    if (spec.list) {
+        if (!Array.isArray(value)) {
+            if (isLeafKind(spec.kind)) {
+                return invalidAt(site, 'expected an array', value);
+            }
+            const shape = site.schema[spec.kind];
+            const entries = shape ? describeShape(shape, site) : spec.kind;
+            return invalidAt(site, spec.function
+                ? `expected an array of (${entries}), or a function${site.call ? ` ${site.call}` : ''}`
+                : `expected an array of (${entries})`, value);
+        }
+        const entrySpec = { ...spec, list: false, function: false };
+        return value.map((entry, index) => compileKey(entrySpec, entry, at(site, index)));
+    }
+    if (isLeafKind(spec.kind)) {
+        checkLeaf(spec, value, site);
+        return value;
+    }
+    if (spec.kind === 'record') {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return invalidAt(site, 'expected an object', value);
+        }
+        const keys = spec.keys ?? {};
+        checkForm({ keys }, value, site);
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            if (isUnsafeKey(key)) {
+                return invalidAt(at(site, key), `the key "${key}" is not allowed`, value);
+            }
+            const entrySpec = Object.prototype.hasOwnProperty.call(keys, key)
+                ? keys[key]
+                : keys['*'];
+            result[key] = compileKey(entrySpec, entry, at(site, key, entrySpec));
+        }
+        return result;
+    }
+    const shape = site.schema[spec.kind];
+    const compiler = site.compilers[spec.kind];
+    if (!shape || !compiler) {
+        return invalidAt(site, `the schema has no compiler for '${spec.kind}'`);
+    }
+    if (shape.function && typeof value === 'function') {
+        return value;
+    }
+    return compiler(value, { ...site, extraKeys: spec.extraKeys });
+}
+export function matchForm(shape, fragment, site) {
+    const [name, form] = selectForm(shape, fragment, site);
+    checkForm(form, fragment, site, shape.keyNoun);
+    return [name, form];
+}
+export const MATCH_OPERATOR_NAMES = Object.freeze([
+    'equals',
+    'doesNotEqual',
+    'notNull',
+    'includes',
+    'doesNotInclude',
+    'greaterThan',
+    'greaterThanOrEqual',
+    'lessThan',
+    'lessThanOrEqual',
+    'range',
+    'contains',
+    'containsI',
+    'doesNotContain',
+    'doesNotContainI',
+    'containsAll',
+    'startsWith',
+    'endsWith',
+]);
+export const matchTestShape = {
+    name: 'test',
+    function: true,
+    keyNoun: 'operator',
+    forms: {
+        operator: {
+            keys: Object.fromEntries(MATCH_OPERATOR_NAMES.map((name) => [
+                name,
+                { kind: 'literal', role: 'operator' },
+            ])),
+            description: 'One operator and its operand.',
+        },
+    },
+};
+export const conditionShape = {
+    name: 'condition',
+    function: true,
+    forms: {
+        map: {
+            keys: { '*': { kind: 'matchTest' } },
+            description: 'A map of name to test. Every entry must hold. `{}` is true.',
+        },
+    },
+};
+export const valueShape = {
+    name: 'value',
+    string: 'attribute',
+    function: true,
+    forms: {
+        template: {
+            selectBy: 'template',
+            keys: { template: { kind: 'string' } },
+            description: 'A string with `{name}` placeholders.',
+        },
+        expression: {
+            selectBy: 'expression',
+            keys: { expression: { kind: 'expression' } },
+            description: 'An expression; the result is the value, not coerced.',
+        },
+    },
+};
+export const safeFunctionSchema = {
+    condition: conditionShape,
+    matchTest: matchTestShape,
+    value: valueShape,
+};

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

@@ -0,0 +1,47 @@
+export type SafeFunctionSubject = Record<string, unknown>;
+export type RawScalar = string | number | boolean;
+export type RawMatchTest = RawScalar | RawScalar[] | null | {
+    equals: RawScalar | RawScalar[] | null;
+} | {
+    doesNotEqual: RawScalar | RawScalar[] | null;
+} | {
+    notNull: boolean;
+} | {
+    includes: RawScalar | RawScalar[];
+} | {
+    doesNotInclude: RawScalar | RawScalar[];
+} | {
+    greaterThan: number;
+} | {
+    greaterThanOrEqual: number;
+} | {
+    lessThan: number;
+} | {
+    lessThanOrEqual: number;
+} | {
+    range: [number, number];
+} | {
+    contains: string | string[];
+} | {
+    containsI: string | string[];
+} | {
+    doesNotContain: string | string[];
+} | {
+    doesNotContainI: string | string[];
+} | {
+    containsAll: RawScalar | RawScalar[];
+} | {
+    startsWith: string | string[];
+} | {
+    endsWith: string | string[];
+} | ((value: unknown, subject?: unknown, context?: unknown) => boolean);
+export type RawCondition = Record<string, RawMatchTest> | InlinePredicate;
+export type InlinePredicate = (subject: any, context?: any) => boolean;
+export type InlineValue = (subject: any, context?: any) => unknown;
+export type RawValue = string | {
+    template: string;
+} | {
+    expression: string;
+} | InlineValue;
+export type CompiledPredicate<Subject = SafeFunctionSubject> = (subject: Subject, context?: unknown) => boolean;
+export type CompiledValue<Subject = SafeFunctionSubject> = (subject: Subject, context?: unknown) => unknown;

package/dist/esm/safeFunctions/values.d.ts

@@ -0,0 +1,6 @@
+export declare function isAbsent(value: unknown): boolean;
+export declare function isEmpty(value: unknown): boolean;
+export declare function hasNoValue(value: unknown): boolean;
+export declare function looseEquals(left: unknown, right: unknown): boolean;
+export declare function compareFinite(test: (a: number, b: number) => boolean): (left: unknown, right: unknown) => boolean;
+export declare function isTrue(value: unknown): boolean;

package/dist/esm/safeFunctions/values.js

@@ -0,0 +1,71 @@
+import { toFiniteFirst } from '@cornerstonejs/utils';
+export function isAbsent(value) {
+    return value === undefined;
+}
+export function isEmpty(value) {
+    return (value === null ||
+        value === '' ||
+        (Array.isArray(value) && value.every((item) => hasNoValue(item))));
+}
+export function hasNoValue(value) {
+    return isAbsent(value) || isEmpty(value);
+}
+export function looseEquals(left, right) {
+    if (hasNoValue(left) || hasNoValue(right)) {
+        return emptyKind(left) === emptyKind(right);
+    }
+    const leftArray = Array.isArray(left);
+    const rightArray = Array.isArray(right);
+    if (leftArray && rightArray) {
+        return (left.length === right.length &&
+            left.every((element, index) => scalarEquals(element, right[index])));
+    }
+    if (leftArray) {
+        return left.length === 1 && scalarEquals(left[0], right);
+    }
+    if (rightArray) {
+        return right.length === 1 && scalarEquals(left, right[0]);
+    }
+    return scalarEquals(left, right);
+}
+function scalarEquals(a, b) {
+    if (hasNoValue(a) || hasNoValue(b)) {
+        return emptyKind(a) === emptyKind(b);
+    }
+    if (a === b) {
+        return true;
+    }
+    if (typeof a === 'object' || typeof b === 'object') {
+        return false;
+    }
+    if (typeof a === 'number' || typeof b === 'number') {
+        const x = toFiniteFirst(a);
+        const y = toFiniteFirst(b);
+        if (x !== undefined && y !== undefined) {
+            return x === y;
+        }
+    }
+    return String(a) === String(b);
+}
+function emptyKind(value) {
+    if (isAbsent(value)) {
+        return 'absent';
+    }
+    if (value === null) {
+        return 'null';
+    }
+    if (value === '') {
+        return 'text';
+    }
+    return isEmpty(value) ? 'array' : undefined;
+}
+export function compareFinite(test) {
+    return (left, right) => {
+        const a = toFiniteFirst(left);
+        const b = toFiniteFirst(right);
+        return a !== undefined && b !== undefined && test(a, b);
+    };
+}
+export function isTrue(value) {
+    return !hasNoValue(value) && Boolean(value);
+}

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

@@ -22,4 +22,5 @@ export declare const mapModuleTags: Map<string, TagEntry[]>;
 export declare const mapTagInfo: Map<string, TagEntry>;
 export declare function addTag(name: string, value: TagEntry): void;
 export declare function resolveHexFromKeyword(keyword: string): string | undefined;
+export declare function keywordIgnoringCase(name: string): string | undefined;
 export declare const Tags: Record<string, TagEntry>;

package/dist/esm/utilities/Tags.js

@@ -82,12 +82,24 @@ export function addTag(name, value) {
     }
 }
 export function resolveHexFromKeyword(keyword) {
-    const entry = nameMap[keyword];
-    if (!entry) {
+    const entry = Object.prototype.hasOwnProperty.call(nameMap, keyword)
+        ? nameMap[keyword]
+        : undefined;
+    if (!entry?.tag) {
         return undefined;
     }
     return entry.tag.substring(1, 5) + entry.tag.substring(6, 10);
 }
+let keywordsByLowerCase;
+export function keywordIgnoringCase(name) {
+    if (!keywordsByLowerCase) {
+        keywordsByLowerCase = new Map();
+        for (const keyword of Object.keys(nameMap)) {
+            keywordsByLowerCase.set(keyword.toLowerCase(), keyword);
+        }
+    }
+    return keywordsByLowerCase.get(name.toLowerCase());
+}
 export const Tags = {};
 const tagGroups = new Map();
 for (const [moduleName, keywords] of moduleDefinitions) {

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

@@ -1,6 +1,6 @@
 export { getSingleBufferFromArray } from './bulkDataFromArray.js';
 export { definedAttributesOf } from './definedAttributesOf.js';
-export { toNumber, toFiniteNumber } from './toNumber.js';
+export { toNumber, toFiniteNumber, toFiniteFirst, toFiniteVector, } from './toNumber.js';
 export { default as toNumberDefault } from './toNumber.js';
 export { default as isVideoTransferSyntax, videoUIDs, } from './isVideoTransferSyntax.js';
 export { default as imageIdToURI } from './imageIdToURI.js';

package/dist/esm/utilities/index.js

@@ -1,6 +1,6 @@
 export { getSingleBufferFromArray } from './bulkDataFromArray.js';
 export { definedAttributesOf } from './definedAttributesOf.js';
-export { toNumber, toFiniteNumber } from './toNumber.js';
+export { toNumber, toFiniteNumber, toFiniteFirst, toFiniteVector, } from './toNumber.js';
 export { default as toNumberDefault } from './toNumber.js';
 export { default as isVideoTransferSyntax, videoUIDs, } from './isVideoTransferSyntax.js';
 export { default as imageIdToURI } from './imageIdToURI.js';

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

@@ -1,2 +1,2 @@
-export { toNumber, toFiniteNumber } from '@cornerstonejs/utils';
+export { toNumber, toFiniteNumber, toFiniteFirst, toFiniteVector, } from '@cornerstonejs/utils';
 export { toNumber as default } from '@cornerstonejs/utils';

package/dist/esm/utilities/toNumber.js

@@ -1,2 +1,2 @@
-export { toNumber, toFiniteNumber } from '@cornerstonejs/utils';
+export { toNumber, toFiniteNumber, toFiniteFirst, toFiniteVector, } from '@cornerstonejs/utils';
 export { toNumber as default } from '@cornerstonejs/utils';

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "5.13.1";
+export declare const version = "5.14.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '5.13.1';
+export const version = '5.14.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/metadata",
-  "version": "5.13.1",
+  "version": "5.14.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",
@@ -81,7 +81,7 @@
   },
   "dependencies": {
     "@cornerstonejs/calculate-suv": "1.0.3",
-    "@cornerstonejs/utils": "5.13.1",
+    "@cornerstonejs/utils": "5.14.0",
     "dcmjs": "0.52.0",
     "gl-matrix": "3.4.3"
   },

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

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

package/dist/esm/displayset/defaultDisplaySetSplitRules.js

@@ -1,93 +0,0 @@
-import { isEcgInstance } from './isEcgInstance.js';
-import { isImageInstance } from './isImageInstance.js';
-import { isVideoInstance } from './isVideoInstance.js';
-import { isWsiInstance } from './isWsiInstance.js';
-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/viewportTypes.d.ts

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