@cornerstonejs/metadata 5.13.2 → 5.14.0

package/dist/esm/displayset/splitRuleSchema.js

@@ -0,0 +1,168 @@
+import { conditionShape, matchTestShape, valueShape } from '../safeFunctions/index.js';
+export const ATTRIBUTE_ONLY_NAMES = Object.freeze([
+    'splitNumber',
+    'sopClassUids',
+]);
+const ruleShape = {
+    name: 'rule',
+    keyNoun: 'field',
+    forms: {
+        rule: {
+            keys: {
+                id: {
+                    kind: 'string',
+                    optional: true,
+                    description: 'The rule id. Optional: the key of the rule in the rule set is the id. When present it must equal that key.',
+                },
+                groupId: {
+                    kind: 'string',
+                    optional: true,
+                    description: 'The group of rules this rule belongs to, for a reader that must recognize display sets from several related rules (for example every mammography rule). Defaults to the rule id.',
+                },
+                priority: {
+                    kind: 'priority',
+                    description: 'Evaluation order: ascending, first match wins. null excludes the rule.',
+                },
+                description: {
+                    kind: 'string',
+                    optional: true,
+                    description: 'Human-readable explanation. Not compiled.',
+                },
+                viewportTypes: {
+                    kind: 'string',
+                    list: true,
+                    optional: true,
+                    description: 'Viewport types for the host. CS3D copies them to the display set unchanged, and does not read them.',
+                },
+                handler: {
+                    kind: 'string',
+                    optional: true,
+                    description: 'The generic handler name of the display sets, e.g. segmentation. Any string; the host decides what an unknown name does.',
+                },
+                context: {
+                    kind: 'contextEntry',
+                    record: true,
+                    optional: true,
+                    description: 'Context entries for this rule only. An entry replaces the global entry of the same name, also inside the global entries that the rule reads, or defines a new name.',
+                },
+                matches: {
+                    kind: 'condition',
+                    optional: true,
+                    function: true,
+                    call: '(instance, context) => boolean',
+                    description: 'Which instances this rule claims: a map of name to test, and every entry must hold. Omit for a catch-all rule.',
+                },
+                groupBy: {
+                    kind: 'name',
+                    list: true,
+                    optional: true,
+                    call: '(instance, context) => value',
+                    description: 'Names (or functions) whose values must all be equal for two instances to form one group. Defaults to SeriesInstanceUID.',
+                },
+                sortBy: {
+                    kind: 'sortKey',
+                    list: true,
+                    optional: true,
+                    call: '(a, b, context) => number',
+                    description: 'The order of the instances in a display set: names in ascending order, named sort functions, or functions. A result of 0 or NaN is "no opinion": the next entry decides.',
+                },
+                attributes: {
+                    kind: 'attributeValue',
+                    record: true,
+                    optional: true,
+                    function: true,
+                    call: '(attributes, options) => Record<string, unknown>',
+                    description: 'Attributes of the produced display sets, keyed by attribute name.',
+                },
+            },
+        },
+    },
+};
+const contextEntryShape = {
+    name: 'context entry',
+    string: 'expression',
+    function: true,
+    forms: {
+        declaration: {
+            selectBy: 'attribute',
+            keys: {
+                attribute: { kind: 'string' },
+                vr: { kind: 'string', optional: true },
+                vm: { kind: 'string', optional: true },
+            },
+            description: 'Reads one attribute of the instance that the DICOM dictionary does not hold: a private tag as 8-digit hex, a vendor attribute, or a synthetic attribute such as imageId. vr and vm are recorded only.',
+        },
+        template: {
+            selectBy: 'template',
+            keys: { template: { kind: 'string' } },
+            description: 'Text: each {name} gives the value of a name or a path.',
+        },
+        group: {
+            selectBy: 'function',
+            keys: {
+                function: {
+                    kind: 'literal',
+                    description: 'The name of a series function (planeGeometry, timeClusters, or one of options.seriesFunctions), or in code a function.',
+                },
+                args: {
+                    kind: 'literal',
+                    optional: true,
+                    description: 'The arguments of the series function. Each value is a fixed value, or an expression with one value for the series.',
+                },
+            },
+            description: 'One call of a series function over the series. A rule reads a result field by path, e.g. timeClusters.start. In sortBy and attributes, displaySet.<name> runs it over the display set.',
+        },
+    },
+};
+const sortKeyShape = {
+    name: 'sort entry',
+    string: 'attribute',
+    function: true,
+    forms: {
+        sortFunction: {
+            selectBy: 'sortFunction',
+            keys: {
+                sortFunction: {
+                    kind: 'string',
+                    description: 'The name of a sort function in options.sortFunctions.',
+                },
+            },
+            description: 'A named sort function, called (a, b, context) => number.',
+        },
+    },
+};
+const attributeValueShape = {
+    ...valueShape,
+    name: 'attribute value',
+    forms: {
+        template: valueShape.forms.template,
+        expression: {
+            ...valueShape.forms.expression,
+            description: 'An expression over the display set: displaySet.instances.max(x) (and min, sum, count) runs over its instances, series.instances.max(x) over the series, and a DICOM keyword reads its first instance.',
+        },
+    },
+};
+const nameShape = {
+    name: 'name',
+    string: 'attribute',
+    function: true,
+    forms: {},
+};
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const entry of Object.values(value)) {
+            deepFreeze(entry);
+        }
+    }
+    return value;
+}
+export const splitRuleSchema = deepFreeze({
+    rule: ruleShape,
+    contextEntry: contextEntryShape,
+    condition: conditionShape,
+    matchTest: matchTestShape,
+    name: nameShape,
+    sortKey: sortKeyShape,
+    attributeValue: attributeValueShape,
+});

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

@@ -0,0 +1,12 @@
+import type { SplitRule, SplitRuleSet } from './types.js';
+export declare function validateSplitRuleSetEntry(id: string, entry: {
+    id?: string;
+    priority?: number | null;
+} | null | undefined): boolean;
+export declare function orderSplitRuleSetEntries<Entry extends {
+    id?: string;
+    priority?: number | null;
+}>(ruleSet: Record<string, Entry>): (Omit<Entry, 'priority'> & {
+    id: string;
+})[];
+export declare function resolveSplitRuleSet(ruleSet: SplitRuleSet): SplitRule[];

package/dist/esm/displayset/splitRuleSet.js

@@ -0,0 +1,47 @@
+import { isUnsafeKey } from '../safeFunctions/schema.js';
+function invalidEntry(id, message) {
+    throw new Error(`Invalid split rule set entry "${id}": ${message}`);
+}
+export function validateSplitRuleSetEntry(id, entry) {
+    if (isUnsafeKey(id)) {
+        invalidEntry(id, 'the id is not allowed; give the rule another id');
+    }
+    if (!entry || typeof entry !== 'object') {
+        invalidEntry(id, 'the entry must be an object');
+    }
+    if (entry.id !== undefined && entry.id !== id) {
+        invalidEntry(id, `the entry states id "${entry.id}", but its key is the id. Remove the id, or make it equal to the key.`);
+    }
+    const { priority } = entry;
+    if (priority === null) {
+        return false;
+    }
+    if (typeof priority !== 'number' || !Number.isFinite(priority)) {
+        invalidEntry(id, `priority must be a finite number, or null to exclude the rule; got ${JSON.stringify(priority)}`);
+    }
+    return true;
+}
+export function orderSplitRuleSetEntries(ruleSet) {
+    if (!ruleSet || typeof ruleSet !== 'object' || Array.isArray(ruleSet)) {
+        throw new Error(`A split rule set must be an object keyed by rule id: ${JSON.stringify(ruleSet)}`);
+    }
+    const included = [];
+    for (const [id, entry] of Object.entries(ruleSet)) {
+        if (validateSplitRuleSetEntry(id, entry)) {
+            included.push({ id, priority: entry.priority, entry });
+        }
+    }
+    included.sort((a, b) => {
+        if (a.priority !== b.priority) {
+            return a.priority - b.priority;
+        }
+        return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+    });
+    return included.map(({ id, entry }) => {
+        const { priority, ...rule } = entry;
+        return { ...rule, id };
+    });
+}
+export function resolveSplitRuleSet(ruleSet) {
+    return orderSplitRuleSetEntries(ruleSet);
+}

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

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

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

@@ -0,0 +1,119 @@
+import { describe, expect, it } from '@jest/globals';
+import { groupInstancesBySplitRules } from './groupInstancesBySplitRules.js';
+import { createDisplaySetSplitRules } from './displaySetRules.js';
+import { resolveSplitRuleSet, validateSplitRuleSetEntry } from './splitRuleSet.js';
+const ct = (imageId, InstanceNumber) => ({
+    imageId,
+    Modality: 'CT',
+    SeriesInstanceUID: 'series-1',
+    SOPInstanceUID: `sop-${imageId}`,
+    InstanceNumber,
+});
+describe('resolveSplitRuleSet', () => {
+    it('orders rules by ascending priority, and takes the id from the key', () => {
+        const rules = resolveSplitRuleSet({
+            late: { priority: 20000 },
+            defaultA: { priority: 1 },
+            early: { priority: -1 },
+            defaultB: { priority: 2 },
+        });
+        expect(rules.map((rule) => rule.id)).toEqual([
+            'early',
+            'defaultA',
+            'defaultB',
+            'late',
+        ]);
+        expect(rules.every((rule) => !('priority' in rule))).toBe(true);
+    });
+    it('orders equal priorities by id, whatever order the keys were inserted in', () => {
+        const forward = resolveSplitRuleSet({
+            b: { priority: 5 },
+            a: { priority: 5 },
+        });
+        const reverse = resolveSplitRuleSet({
+            a: { priority: 5 },
+            b: { priority: 5 },
+        });
+        expect(forward.map((rule) => rule.id)).toEqual(['a', 'b']);
+        expect(reverse.map((rule) => rule.id)).toEqual(['a', 'b']);
+    });
+    it('accepts an entry that states an id equal to its key', () => {
+        const rules = resolveSplitRuleSet({ same: { id: 'same', priority: 1 } });
+        expect(rules.map((rule) => rule.id)).toEqual(['same']);
+    });
+    it('rejects an array', () => {
+        expect(() => resolveSplitRuleSet([{ id: 'a' }])).toThrow(/must be an object keyed by rule id/);
+    });
+});
+describe('validateSplitRuleSetEntry', () => {
+    it('returns true for a numeric priority, and false for a null priority', () => {
+        expect(validateSplitRuleSetEntry('a', { priority: 0 })).toBe(true);
+        expect(validateSplitRuleSetEntry('a', { id: 'a', priority: -2.5 })).toBe(true);
+        expect(validateSplitRuleSetEntry('a', { priority: null })).toBe(false);
+    });
+    it('throws for an id that differs from the key', () => {
+        expect(() => validateSplitRuleSetEntry('a', { id: 'b', priority: 1 })).toThrow(/"a".*"b"/);
+    });
+    it('throws for a missing or non-numeric priority', () => {
+        for (const priority of [undefined, '1', Number.NaN, Infinity]) {
+            expect(() => validateSplitRuleSetEntry('a', { priority })).toThrow(/"a".*priority/);
+        }
+    });
+    it('throws for an entry that is not an object', () => {
+        expect(() => validateSplitRuleSetEntry('a', null)).toThrow(/"a".*must be an object/);
+    });
+});
+describe('groupInstancesBySplitRules with a rule set', () => {
+    it('gives one key for every naturalized form of a value', () => {
+        const keyOf = (EchoNumbers) => groupInstancesBySplitRules([{ ...ct('a', 1), EchoNumbers }], {
+            byEcho: { priority: 1, groupBy: ['SeriesInstanceUID', 'EchoNumbers'] },
+        })[0].splitKey;
+        expect(new Set([5, '5', [5], ['5']].map(keyOf)).size).toBe(1);
+        expect(new Set([undefined, null, '', []].map(keyOf)).size).toBe(1);
+        expect(keyOf('05')).not.toBe(keyOf(5));
+    });
+    it('evaluates the rules in priority order, first match wins', () => {
+        const ruleSet = {
+            everything: { priority: 1, groupBy: ['SeriesInstanceUID'] },
+            first: {
+                priority: -1,
+                matches: (instance) => instance.InstanceNumber === 1,
+                groupBy: ['SOPInstanceUID'],
+            },
+        };
+        const groups = groupInstancesBySplitRules([ct('a', 1), ct('b', 2), ct('c', 3)], ruleSet);
+        expect(groups.map((group) => [
+            group.matchedRule.id,
+            group.instances.map((i) => i.imageId),
+        ])).toEqual([
+            ['first', ['a']],
+            ['everything', ['b', 'c']],
+        ]);
+    });
+    it('lets a layer replace a rule by its key', () => {
+        const defaults = {
+            volume3d: { priority: 1, groupBy: ['SeriesInstanceUID'] },
+        };
+        const layered = {
+            ...defaults,
+            volume3d: { priority: -1, groupBy: ['SOPInstanceUID'] },
+        };
+        const groups = groupInstancesBySplitRules([ct('a', 1), ct('b', 2)], layered);
+        expect(groups).toHaveLength(2);
+        expect(groups.every((group) => group.matchedRule.id === 'volume3d')).toBe(true);
+    });
+});
+describe('createDisplaySetSplitRules with a rule set as data', () => {
+    it('compiles to a keyed rule set that resolves in priority order', () => {
+        const rules = createDisplaySetSplitRules({
+            catchAll: { priority: 2 },
+            ctRule: { priority: 1, matches: { Modality: 'CT' } },
+            off: { priority: null, matches: { Modality: 'MR' } },
+        });
+        expect(resolveSplitRuleSet(rules).map((rule) => rule.id)).toEqual([
+            'ctRule',
+            'catchAll',
+        ]);
+        expect(rules.ctRule.matches?.(ct('a', 1), { series: {} })).toBe(true);
+    });
+});

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

@@ -1,3 +1,4 @@
+import type { DisplaySetContextValues } from './displaySetContext.js';
 export type NaturalizedInstance = {
     imageId?: string;
     Modality?: string;
@@ -13,7 +14,7 @@ export type NaturalizedInstance = {
     AvailableTransferSyntaxUID?: string;
     [key: string]: unknown;
 };
-export type ViewportTypeHint = 'stack' | 'volume' | 'volume3d' | 'video' | 'wholeslide' | 'ecg' | string;
+export declare const DISPLAY_SET_HANDLER_NAMES: readonly ["image", "video", "wholeSlide", "ecg", "segmentation", "rtStructureSet", "parametricMap", "structuredReport", "encapsulatedDocument", "bulkAnnotation", "chart", "unsupported"];
 export type SeriesInfo = {
     NumberOfSeriesRelatedInstances: number;
     numberOfFrames: number;
@@ -25,35 +26,67 @@ export type SeriesInfo = {
 export type SeriesFacts = Record<string, unknown>;
 export type SeriesContext = {
     instances: NaturalizedInstance[];
+    series?: Readonly<SeriesFacts>;
+};
+export type SeriesFieldScope = 'series' | 'instance';
+export type SeriesFunction = (instances: NaturalizedInstance[], context: {
+    args: Readonly<Record<string, unknown>>;
+}) => unknown;
+export type SeriesFunctionDefinition = {
+    compute: SeriesFunction;
+    fields?: Readonly<Record<string, SeriesFieldScope>>;
 };
 export type RuleContext = {
     series: SeriesFacts;
+    displaySet?: DisplaySetContextValues;
 };
 export type SplitRuleCustomAttributesContext = {
     instance: NaturalizedInstance;
     isMultiFrame?: boolean;
     sopClassUids?: string[];
-    viewportTypes?: readonly ViewportTypeHint[];
     [key: string]: unknown;
 };
 export type SplitRuleOptions = {
     instances: NaturalizedInstance[];
     splitNumber?: number;
     descriptionName?: string;
+    series?: SeriesFacts;
 };
 export type SplitRule = {
-    id?: string;
-    viewportTypes?: readonly ViewportTypeHint[];
+    id: string;
+    groupId?: string;
+    handler?: string;
+    viewportTypes?: readonly string[];
     series?: (context: SeriesContext) => SeriesFacts;
     matches?: (instance: NaturalizedInstance, context: RuleContext) => boolean;
     groupBy?: (string | ((instance: NaturalizedInstance, context: RuleContext) => unknown))[];
+    compareInstances?: (a: NaturalizedInstance, b: NaturalizedInstance, context: RuleContext) => number;
     customAttributes?: (attributes: SplitRuleCustomAttributesContext, options: SplitRuleOptions) => Record<string, unknown>;
 };
+export type SplitRuleSetEntry = Omit<SplitRule, 'id'> & {
+    id?: string;
+    priority: number | null;
+};
+export type SplitRuleSet = Record<string, SplitRuleSetEntry>;
+export declare const DEFAULT_SPLIT_RULE_PRIORITY_LIMIT = 10000;
+export type InstanceOrderContext = {
+    matchedRule: SplitRule;
+    series: SeriesFacts;
+};
+export type SortInstances = (instances: NaturalizedInstance[], context: InstanceOrderContext) => NaturalizedInstance[];
+export type GroupInstancesOptions = {
+    sortInstances?: SortInstances;
+    compareInstances?: SplitRule['compareInstances'];
+};
 export type SplitContext = {
     getNaturalizedInstance: (imageId: string) => NaturalizedInstance | undefined;
 };
+export type OrderInstancesOptions = GroupInstancesOptions & {
+    series?: SeriesFacts;
+};
 export type InstanceGroup = {
     instances: NaturalizedInstance[];
     matchedRule: SplitRule;
+    series?: SeriesFacts;
     splitKey?: string;
 };

package/dist/esm/displayset/types.js

@@ -0,0 +1,15 @@
+export const DISPLAY_SET_HANDLER_NAMES = [
+    'image',
+    'video',
+    'wholeSlide',
+    'ecg',
+    'segmentation',
+    'rtStructureSet',
+    'parametricMap',
+    'structuredReport',
+    'encapsulatedDocument',
+    'bulkAnnotation',
+    'chart',
+    'unsupported',
+];
+export const DEFAULT_SPLIT_RULE_PRIORITY_LIMIT = 10000;

package/dist/esm/index.d.ts

@@ -4,8 +4,10 @@ export { version } from './version.js';
 export * as metaData from './metaData.js';
 export * as utilities from './utilities/index.js';
 export * as displaySet from './displayset/index.js';
-export type { IDisplaySet, BaseDisplaySetOptions, ImageStackDisplaySetOptions, ResolveInstancesOptions, SplitImageIdsBySplitRulesOptions, RegisterDisplaySetMetadataOptions, NaturalizedInstance, SeriesInfo, SeriesFacts, SeriesContext, RuleContext, SplitRule, SplitContext, SplitRuleOptions, SplitRuleCustomAttributesContext, InstanceGroup, ViewportTypeHint, } from './displayset/index.js';
-export { BaseDisplaySet, ImageStackDisplaySet, resolveInstances, buildSeriesInfo, groupInstancesBySplitRules, splitImageIdsBySplitRules, registerDisplaySetMetadata, registerDisplaySetProviders, defaultDisplaySetSplitRules, createDisplaySetFromGroup, isImageInstance, isVideoInstance, isEcgInstance, isWsiInstance, getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './displayset/index.js';
+export { collectIdentifiers, collectReads, compileCondition, compileExpression, compileTemplate, compileValue, ExpressionSyntaxError, hasNoValue, isAbsent, isEmpty, looseEquals, MATCH_OPERATOR_NAMES, parseExpressionSource, RuleCompileError, } from './safeFunctions/index.js';
+export type { CompiledExpression, CompileExpressionOptions, CompileOptions, CompiledPredicate, CompiledValue, ExpressionNode, ExpressionRead, ExpressionScope, InlinePredicate, InlineValue, NameReader, NameReaderFunction, RawMatchTest, RawScalar, RawValue, SafeFunctionSubject, SchemaSite, } from './safeFunctions/index.js';
+export type { IDisplaySet, BaseDisplaySetOptions, ImageStackDisplaySetOptions, ResolveInstancesOptions, SplitImageIdsBySplitRulesOptions, RegisterDisplaySetMetadataOptions, NaturalizedInstance, SeriesInfo, SeriesFacts, SeriesContext, SeriesFunction, SeriesFunctionDefinition, SeriesFieldScope, PlaneGeometry, TimeClusters, RuleContext, SplitRule, SplitContext, SplitRuleOptions, SplitRuleCustomAttributesContext, InstanceGroup, InstanceOrderContext, SortInstances, GroupInstancesOptions, SplitRuleSet, SplitRuleSetEntry, OrderInstancesOptions, ContextEntry, ContextGroupEntry, ContextValues, DisplaySetContext, InstanceContextFunction, InstanceHook, RawAttributeValue, RawCondition, RawName, RawSortKey, RawSplitRule, DisplaySetRules, CreateDisplaySetSplitRulesOptions, } from './displayset/index.js';
+export { BaseDisplaySet, ImageStackDisplaySet, resolveInstances, buildSeriesInfo, groupInstancesBySplitRules, splitImageIdsBySplitRules, registerDisplaySetMetadata, registerDisplaySetProviders, compiledDisplaySetRules, defaultDisplaySetSplitRules, orderInstancesForRule, resolveSplitRuleSet, compare, compareInstanceNumber, compareSOPInstanceUID, sortByInstanceNumber, instancesSortCriteria, sortInstancesCopy, displaySetRules, createDisplaySetSplitRules, defaultMetadataContext, setMetadataContext, getMetadataContext, getContextValue, imageSopClassUids, videoSopClassUids, videoTransferSyntaxUids, longVideoSopClassUids, longVideoMinFrames, ecgSopClassUids, wholeSlideSopClassUids, segmentationSopClassUids, rtStructureSetSopClassUids, parametricMapSopClassUids, structuredReportSopClassUids, encapsulatedDocumentSopClassUids, bulkAnnotationSopClassUids, chartSopClassUids, createDisplaySetFromGroup, isImageInstance, isVideoInstance, isEcgInstance, isWsiInstance, isReconstructableInstances, DEFAULT_SPLIT_RULE_PRIORITY_LIMIT, DISPLAY_SET_HANDLER_NAMES, } from './displayset/index.js';
 export type { CreateDisplaySetFromGroupOptions } from './displayset/index.js';
 export * as logging from './utilities/logging.js';
 export { registerDefaultProviders } from './registerDefaultProviders.js';

package/dist/esm/index.js

@@ -4,7 +4,8 @@ export { version } from './version.js';
 export * as metaData from './metaData.js';
 export * as utilities from './utilities/index.js';
 export * as displaySet from './displayset/index.js';
-export { BaseDisplaySet, ImageStackDisplaySet, resolveInstances, buildSeriesInfo, groupInstancesBySplitRules, splitImageIdsBySplitRules, registerDisplaySetMetadata, registerDisplaySetProviders, defaultDisplaySetSplitRules, createDisplaySetFromGroup, isImageInstance, isVideoInstance, isEcgInstance, isWsiInstance, getViewportTypesForRule, getPreferredViewportType, getViewportTypesForGroup, } from './displayset/index.js';
+export { collectIdentifiers, collectReads, compileCondition, compileExpression, compileTemplate, compileValue, ExpressionSyntaxError, hasNoValue, isAbsent, isEmpty, looseEquals, MATCH_OPERATOR_NAMES, parseExpressionSource, RuleCompileError, } from './safeFunctions/index.js';
+export { BaseDisplaySet, ImageStackDisplaySet, resolveInstances, buildSeriesInfo, groupInstancesBySplitRules, splitImageIdsBySplitRules, registerDisplaySetMetadata, registerDisplaySetProviders, compiledDisplaySetRules, defaultDisplaySetSplitRules, orderInstancesForRule, resolveSplitRuleSet, compare, compareInstanceNumber, compareSOPInstanceUID, sortByInstanceNumber, instancesSortCriteria, sortInstancesCopy, displaySetRules, createDisplaySetSplitRules, defaultMetadataContext, setMetadataContext, getMetadataContext, getContextValue, imageSopClassUids, videoSopClassUids, videoTransferSyntaxUids, longVideoSopClassUids, longVideoMinFrames, ecgSopClassUids, wholeSlideSopClassUids, segmentationSopClassUids, rtStructureSetSopClassUids, parametricMapSopClassUids, structuredReportSopClassUids, encapsulatedDocumentSopClassUids, bulkAnnotationSopClassUids, chartSopClassUids, createDisplaySetFromGroup, isImageInstance, isVideoInstance, isEcgInstance, isWsiInstance, isReconstructableInstances, DEFAULT_SPLIT_RULE_PRIORITY_LIMIT, DISPLAY_SET_HANDLER_NAMES, } from './displayset/index.js';
 export * as logging from './utilities/logging.js';
 export { registerDefaultProviders } from './registerDefaultProviders.js';
 const { calculateSUVScalingFactors } = calculateSUV;

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

@@ -0,0 +1,31 @@
+import type { ExpressionScope, NameReader, NameReaderFunction, Schema, SchemaSite, ShapeCompiler } from './schema.js';
+import type { CompiledPredicate, CompiledValue, RawCondition, RawValue, SafeFunctionSubject } from './types.js';
+export { compareFinite, hasNoValue, isAbsent, isEmpty, isTrue, looseEquals, } from './values.js';
+export type CompileOptions = {
+    path?: string;
+    definition?: string;
+    expression?: ExpressionScope;
+    call?: string;
+    readName?: NameReader;
+};
+export declare function invalid(message: string, fragment: unknown): never;
+export declare const readOwnName: NameReader;
+export declare const safeFunctionCompilers: Record<string, ShapeCompiler>;
+export declare function createSite(options?: CompileOptions, schema?: Schema, compilers?: Record<string, ShapeCompiler>): SchemaSite;
+export declare function readNameAt(name: string, site: SchemaSite, field?: string): NameReaderFunction;
+export declare function compileExpressionAt(source: string, site: SchemaSite, scope?: ExpressionScope & {
+    receivers?: Readonly<Record<string, string>>;
+    unavailableReceivers?: Readonly<Record<string, string>>;
+}): import("./expression/index.js").CompiledExpression;
+export declare function compileConditionAt<Subject extends SafeFunctionSubject>(condition: unknown, site: SchemaSite): CompiledPredicate<Subject>;
+export declare function compileCondition<Subject extends SafeFunctionSubject>(condition: RawCondition, options?: CompileOptions): CompiledPredicate<Subject>;
+export type TemplateSegment = {
+    literal: string;
+} | {
+    name: string;
+    field?: string;
+};
+export declare function parseTemplate(template: string, site?: Pick<SchemaSite, 'path' | 'definition'>): TemplateSegment[];
+export declare function compileTemplate<Subject extends SafeFunctionSubject>(template: string, site?: SchemaSite): CompiledValue<Subject>;
+export declare function compileValueAt<Subject extends SafeFunctionSubject>(value: unknown, site: SchemaSite): CompiledValue<Subject>;
+export declare function compileValue<Subject extends SafeFunctionSubject>(value: RawValue, options?: CompileOptions): CompiledValue<Subject>;

package/dist/esm/safeFunctions/compile.js

@@ -0,0 +1,142 @@
+import { compileExpression } from './expression/index.js';
+import { compileMatchTest } from './matchTests.js';
+import { at, conditionShape, INSTANCE_EXPRESSION_SCOPE, invalidAt, isUnsafeKey, matchForm, readOwn, safeFunctionSchema, unrecognized, valueShape, } from './schema.js';
+import { hasNoValue } from './values.js';
+export { compareFinite, hasNoValue, isAbsent, isEmpty, isTrue, looseEquals, } from './values.js';
+const DEFAULT_DEFINITION = 'safe function definition';
+export function invalid(message, fragment) {
+    return invalidAt({ path: '', definition: DEFAULT_DEFINITION }, message, fragment);
+}
+export const readOwnName = (name, _site, field) => field === undefined
+    ? (subject) => readOwn(subject, name)
+    : (subject) => readOwn(readOwn(subject, name), field);
+export const safeFunctionCompilers = {
+    condition: (fragment, site) => compileConditionAt(fragment, site),
+    matchTest: (fragment, site) => compileMatchTest(fragment, site),
+    value: (fragment, site) => compileValueAt(fragment, site),
+};
+export function createSite(options = {}, schema = safeFunctionSchema, compilers = safeFunctionCompilers) {
+    return {
+        path: options.path ?? '',
+        definition: options.definition ?? DEFAULT_DEFINITION,
+        schema,
+        compilers,
+        readName: options.readName ?? readOwnName,
+        expression: options.expression ?? INSTANCE_EXPRESSION_SCOPE,
+        call: options.call,
+    };
+}
+export function readNameAt(name, site, field) {
+    return (site.readName ?? readOwnName)(name, site, field);
+}
+export function compileExpressionAt(source, site, scope = site.expression ?? INSTANCE_EXPRESSION_SCOPE) {
+    try {
+        return compileExpression(source, {
+            params: scope.params,
+            implicitScope: scope.implicitScope,
+            receivers: scope.receivers,
+            unavailableReceivers: scope.unavailableReceivers,
+        });
+    }
+    catch (error) {
+        return invalidAt(site, error.message);
+    }
+}
+export function compileConditionAt(condition, site) {
+    if (typeof condition === 'function') {
+        return condition;
+    }
+    if (!condition || typeof condition !== 'object' || Array.isArray(condition)) {
+        return unrecognized(conditionShape, condition, site);
+    }
+    const entries = Object.entries(condition).map(([name, test]) => {
+        const entrySite = at(site, name);
+        if (isUnsafeKey(name)) {
+            invalidAt(entrySite, `the name "${name}" is not allowed`, condition);
+        }
+        return {
+            read: readNameAt(name, entrySite),
+            test: compileMatchTest(test, entrySite),
+        };
+    });
+    return (subject, context) => entries.every(({ read, test }) => test(read(subject, context), subject, context));
+}
+export function compileCondition(condition, options = {}) {
+    return compileConditionAt(condition, createSite(options));
+}
+export function parseTemplate(template, site = {
+    path: '',
+    definition: DEFAULT_DEFINITION,
+}) {
+    if (typeof template !== 'string') {
+        invalidAt(site, 'template must be a string', template);
+    }
+    const segments = [];
+    let literal = '';
+    for (let i = 0; i < template.length; i++) {
+        const char = template[i];
+        if (char === '\\' && (template[i + 1] === '{' || template[i + 1] === '}')) {
+            literal += template[i + 1];
+            i++;
+            continue;
+        }
+        if (char !== '{') {
+            literal += char;
+            continue;
+        }
+        const end = template.indexOf('}', i + 1);
+        if (end === -1) {
+            invalidAt(site, 'template has an unclosed "{"', template);
+        }
+        const placeholder = template.slice(i + 1, end).trim();
+        if (!placeholder) {
+            invalidAt(site, 'template has an empty "{}" placeholder', template);
+        }
+        const [name, field, ...rest] = placeholder.split('.');
+        if (!name || field === '' || rest.length) {
+            invalidAt(site, `template placeholder "{${placeholder}}" must be a name, or a name and one field`, template);
+        }
+        if (literal) {
+            segments.push({ literal });
+            literal = '';
+        }
+        segments.push(field === undefined ? { name } : { name, field });
+        i = end;
+    }
+    if (literal) {
+        segments.push({ literal });
+    }
+    return segments;
+}
+export function compileTemplate(template, site = createSite()) {
+    const parts = parseTemplate(template, site).map((segment) => 'literal' in segment
+        ? () => segment.literal
+        : readNameAt(segment.name, site, segment.field));
+    return (subject, context) => parts
+        .map((part) => {
+        const value = part(subject, context);
+        return hasNoValue(value) ? '' : String(value);
+    })
+        .join('');
+}
+export function compileValueAt(value, site) {
+    if (typeof value === 'function') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return readNameAt(value, site);
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return unrecognized(valueShape, value, site);
+    }
+    const [form] = matchForm(valueShape, value, site);
+    const fields = value;
+    if (form === 'template') {
+        return compileTemplate(fields.template, at(site, 'template'));
+    }
+    const evaluate = compileExpressionAt(fields.expression, at(site, 'expression'));
+    return (subject, context) => evaluate(subject, context);
+}
+export function compileValue(value, options = {}) {
+    return compileValueAt(value, createSite(options));
+}

package/dist/esm/safeFunctions/compile.test.d.ts

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