@cornerstonejs/metadata 5.13.1 → 5.14.0

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

@@ -0,0 +1,150 @@
+import type { CompiledExpression, ExpressionRead, SchemaSite, TemplateSegment } from '../safeFunctions/index.js';
+import type { NaturalizedInstance, SeriesContext, SeriesFacts, SeriesFieldScope, SeriesFunction, SeriesFunctionDefinition } from './types.js';
+export type ContextValues = Readonly<Record<string, unknown>>;
+export type InstanceContextFunction = (instance: NaturalizedInstance, values: ContextValues) => unknown;
+export type ContextGroupEntry = {
+    function: string | SeriesFunction | SeriesFunctionDefinition;
+    args?: Record<string, unknown>;
+};
+export type ContextEntry = number | boolean | null | readonly unknown[] | string | {
+    attribute: string;
+    vr?: string;
+    vm?: string;
+} | {
+    template: string;
+} | ContextGroupEntry | InstanceContextFunction;
+export type DisplaySetContext = Readonly<Record<string, ContextEntry>>;
+export declare const DISPLAY_SET_CONTEXT_FACT = "displaySetContext";
+export declare const defaultMetadataContext: DisplaySetContext;
+export declare function isTagKeyword(name: string): boolean;
+type Scope = SeriesFieldScope;
+type GroupArgument = {
+    name: string;
+    fixed?: unknown;
+    evaluate?: CompiledExpression;
+    reads: ExpressionRead[];
+};
+type Definition = {
+    name: string;
+    ruleId?: string;
+    site: SchemaSite;
+    identity: string;
+    kind: 'fixed' | 'declaration' | 'expression' | 'template' | 'group' | 'code';
+    reads: ExpressionRead[];
+    value?: unknown;
+    attribute?: string;
+    vr?: string;
+    vm?: string;
+    evaluate?: CompiledExpression;
+    aliasOf?: string;
+    segments?: TemplateSegment[];
+    compute?: SeriesFunction;
+    fields?: Readonly<Record<string, Scope>>;
+    args?: GroupArgument[];
+    fn?: InstanceContextFunction;
+};
+type Dependency = {
+    kind: 'keyword';
+} | {
+    kind: 'attribute';
+} | {
+    kind: 'entry';
+    bound: Bound;
+} | {
+    kind: 'series';
+    inner: Dependency;
+} | {
+    kind: 'displaySet';
+    fields: Map<string, Dependency>;
+};
+type Extras = Readonly<Record<string, unknown>>;
+type Bound = {
+    key: string;
+    name: string;
+    scope: Scope;
+    group?: {
+        fields?: Readonly<Record<string, Scope>>;
+    };
+    deps: Map<string, Dependency>;
+    closure: ReadonlySet<string>;
+    ruleId?: string;
+    perDisplaySet: boolean;
+    layer?: ContextLayer;
+    definition?: Definition;
+    compute: (runtime: ContextRuntime, instance: NaturalizedInstance | undefined) => unknown;
+};
+export type ContextReader = (runtime: ContextRuntime, instance: NaturalizedInstance | undefined, extras?: Extras) => unknown;
+export declare function isFixedValue(raw: unknown, arrays?: boolean): boolean;
+export declare function withInstances(series: SeriesFacts, instances: readonly NaturalizedInstance[]): SeriesFacts;
+export declare class DisplaySetContextValues {
+    readonly instances: readonly NaturalizedInstance[];
+    readonly seriesInstances: readonly NaturalizedInstance[];
+    private readonly split?;
+    private readonly runtimes;
+    constructor(instances: readonly NaturalizedInstance[], seriesInstances?: readonly NaturalizedInstance[], split?: DisplaySetContextValues);
+    runtime(program: ContextProgram): ContextRuntime;
+}
+export declare function displaySetContextFor(series: SeriesFacts | undefined, instances: readonly NaturalizedInstance[]): DisplaySetContextValues;
+export declare class ContextRuntime {
+    readonly instances: readonly NaturalizedInstance[];
+    readonly seriesInstances: readonly NaturalizedInstance[];
+    private readonly split?;
+    private readonly seriesValues;
+    private readonly instanceValues;
+    private readonly views;
+    private readonly envs;
+    private readonly instanceEnvs;
+    private readonly inProgress;
+    constructor(instances: readonly NaturalizedInstance[], seriesInstances?: readonly NaturalizedInstance[], split?: ContextRuntime);
+    get seriesRuntime(): ContextRuntime;
+    value(bound: Bound, instance: NaturalizedInstance | undefined): unknown;
+    private compute;
+    groupView(bound: Bound, instance: NaturalizedInstance | undefined): unknown;
+    read(name: string, dependency: Dependency | undefined, instance: NaturalizedInstance | undefined, extras?: Extras): unknown;
+    env(bound: Pick<Bound, 'key' | 'deps' | 'layer' | 'definition'>, instance: NaturalizedInstance | undefined, extras?: Extras, fresh?: boolean): object;
+    envsOf(bound: Pick<Bound, 'key' | 'deps' | 'layer' | 'definition' | 'perDisplaySet'>, instances?: readonly NaturalizedInstance[], extras?: Extras): object[];
+}
+export declare class ContextLayer {
+    readonly program: ContextProgram;
+    readonly ruleId: string | undefined;
+    readonly local: ReadonlyMap<string, Definition>;
+    readonly memo: Map<Definition, Bound>;
+    private readonly dynamic;
+    constructor(program: ContextProgram, ruleId: string | undefined, local: ReadonlyMap<string, Definition>);
+    resolve(name: string, from?: Definition): Definition | undefined;
+    dynamicDependency(name: string, from?: Definition): Dependency | undefined;
+}
+export type ContextProgramOptions = {
+    seriesFunctions: Readonly<Record<string, SeriesFunction | SeriesFunctionDefinition>>;
+    site: SchemaSite;
+    deniedNames?: readonly string[];
+};
+export declare class ContextProgram {
+    readonly global: Map<string, Definition>;
+    private readonly bounds;
+    private readonly seriesFunctions;
+    private readonly empty;
+    private readonly denied;
+    private readonly deniedTags;
+    private fallbackLogged;
+    constructor(context: unknown, options: ContextProgramOptions);
+    readonly seriesHook: ({ instances, series }: SeriesContext) => SeriesFacts;
+    isDenied(name: string): boolean;
+    private parseExpression;
+    runtimeFrom(context: unknown, fallback: NaturalizedInstance | readonly NaturalizedInstance[]): ContextRuntime;
+    instanceValue(name: string, instance: NaturalizedInstance): unknown;
+    layer(ruleId: string, context: unknown, site: SchemaSite): ContextLayer;
+    readerAt(layer: ContextLayer, name: string, site: SchemaSite, options?: {
+        field?: string;
+        place?: string;
+    }): ContextReader;
+    attributeExpression(layer: ContextLayer, source: string, site: SchemaSite): (runtime: ContextRuntime, instances: readonly NaturalizedInstance[], extras: Extras) => unknown;
+    bind(definition: Definition, layer: ContextLayer, stack: Definition[]): Bound;
+    private dependencyOf;
+    private createBound;
+    private parseLayer;
+    private parseEntry;
+    private seriesFunctionOf;
+    private parseArguments;
+}
+export {};