@cornerstonejs/metadata 5.13.2 → 5.15.0

package/dist/esm/safeFunctions/compile.test.js

@@ -0,0 +1,82 @@
+import { compileCondition, compileValue } from './compile.js';
+import { MATCH_HELPERS } from './matchTests.js';
+import { RuleCompileError } from './schema.js';
+describe('membership - the cached Set of a long list', () => {
+    const uids = [
+        ...Array.from({ length: 48 }, (_, i) => `1.2.840.10008.5.1.4.1.1.${i}`),
+        '7',
+        'true',
+    ];
+    const loopList = [...uids, -1];
+    const cases = [
+        ['1.2.840.10008.5.1.4.1.1.4', true],
+        ['9.9', false],
+        [7, true],
+        ['07', false],
+        [true, true],
+        [false, false],
+        ['', false],
+        [null, false],
+        [undefined, false],
+        [[], false],
+        [['x', '1.2.840.10008.5.1.4.1.1.5'], true],
+        [['x', 'y'], false],
+    ];
+    it('gives the result of the loop in matches and in the in operator', () => {
+        const viaSet = compileCondition({ X: uids });
+        const viaLoop = compileCondition({ X: loopList });
+        for (const [X, expected] of cases) {
+            expect([X, viaSet({ X }), viaLoop({ X })]).toEqual([
+                X,
+                expected,
+                expected,
+            ]);
+            expect([
+                X,
+                MATCH_HELPERS.includes(uids, X),
+                MATCH_HELPERS.includes(loopList, X),
+            ]).toEqual([X, expected, expected]);
+        }
+    });
+});
+const errorOf = (compile) => {
+    try {
+        compile();
+    }
+    catch (error) {
+        expect(error).toBeInstanceOf(RuleCompileError);
+        return error;
+    }
+    throw new Error('expected a compile error');
+};
+describe('compileCondition / compileValue - strict and stand-alone', () => {
+    it('names a stand-alone definition and its path in a message', () => {
+        const standAlone = errorOf(() => compileCondition({ Modality: { equal: 'CT' } }));
+        expect(standAlone.definition).toBe('safe function definition');
+        expect(standAlone.path).toBe('Modality');
+        expect(standAlone.message).toContain("'equal'");
+        const named = errorOf(() => compileCondition({ Rows: { greaterThan: 'x' } }, {
+            path: 'protocol.match',
+            definition: 'hanging protocol',
+        }));
+        expect(named.definition).toBe('hanging protocol');
+        expect(named.path).toBe('protocol.match.Rows');
+        expect(named.message).toMatch(/^Invalid hanging protocol: protocol\.match\.Rows: /);
+    });
+    it('passes an actual function through as is', () => {
+        const predicate = () => true;
+        const reader = () => 42;
+        expect(compileCondition(predicate)).toBe(predicate);
+        expect(compileValue(reader)).toBe(reader);
+        expect(compileCondition({ Rows: (value) => value === 2 })({ Rows: 2 })).toBe(true);
+    });
+    it('reads a name through the reader of the place', () => {
+        const readName = (name) => () => `${name}!`;
+        expect(compileValue('anything', { readName })({})).toBe('anything!');
+        expect(compileValue({ template: '<{a}>' }, { readName })({}, undefined)).toBe('<a!>');
+    });
+    it('reads own properties only by default', () => {
+        expect(compileValue('constructor')({})).toBeUndefined();
+        expect(compileCondition({ toString: null })({})).toBe(true);
+    });
+});

package/dist/esm/safeFunctions/expression/compiler.d.ts

@@ -0,0 +1,23 @@
+import type { ExpressionNode } from './parser.js';
+import { ExpressionSyntaxError } from './tokenizer.js';
+export type CompiledExpression = ((...args: unknown[]) => unknown) & {
+    expressionSource: string;
+};
+export type CompileExpressionOptions = {
+    params?: readonly string[];
+    implicitScope?: boolean | string;
+    receivers?: Readonly<Record<string, string>>;
+    unavailableReceivers?: Readonly<Record<string, string>>;
+};
+export declare function collectIdentifiers(node: ExpressionNode): string[];
+export type ExpressionRead = {
+    name: string;
+    field?: string;
+    inAggregate: boolean;
+    indexed?: boolean;
+};
+export declare function collectReads(node: ExpressionNode, options?: {
+    aggregates?: boolean;
+}): ExpressionRead[];
+export declare function compileExpression(source: string, options?: CompileExpressionOptions): CompiledExpression;
+export { ExpressionSyntaxError };

package/dist/esm/safeFunctions/expression/compiler.js

@@ -0,0 +1,481 @@
+import { DEFINED_LITERAL, FORBIDDEN_PROPERTIES, parseExpressionSource, } from './parser.js';
+import { ExpressionSyntaxError } from './tokenizer.js';
+import { asArrayFirst, toFiniteFirst } from '@cornerstonejs/utils';
+import { MATCH_HELPERS } from '../matchTests.js';
+import { RuleCompileError } from '../schema.js';
+import { compareFinite, hasNoValue, isAbsent, isEmpty, isTrue, looseEquals, } from '../values.js';
+function safeGet(object, key) {
+    if (object == null) {
+        return undefined;
+    }
+    if (typeof key !== 'string' && typeof key !== 'number') {
+        return undefined;
+    }
+    if (typeof key === 'string' && FORBIDDEN_PROPERTIES.has(key)) {
+        return undefined;
+    }
+    return object[key];
+}
+function numeric(operation) {
+    return (value) => {
+        const number = toFiniteFirst(value);
+        if (number === undefined) {
+            return undefined;
+        }
+        const result = operation(number);
+        return Number.isFinite(result) ? result : undefined;
+    };
+}
+function finiteValues(values) {
+    return values
+        .map((value) => toFiniteFirst(value))
+        .filter((value) => value !== undefined);
+}
+const HELPERS = {
+    includes: MATCH_HELPERS.includes,
+    contains: MATCH_HELPERS.contains,
+    startsWith: MATCH_HELPERS.startsWith,
+    endsWith: MATCH_HELPERS.endsWith,
+    lower: (value) => hasNoValue(value) ? undefined : String(asArrayFirst(value)).toLowerCase(),
+    abs: numeric(Math.abs),
+    min: (...values) => {
+        const numbers = finiteValues(values);
+        return numbers.length ? Math.min(...numbers) : undefined;
+    },
+    max: (...values) => {
+        const numbers = finiteValues(values);
+        return numbers.length ? Math.max(...numbers) : undefined;
+    },
+    round: numeric(Math.round),
+    floor: numeric(Math.floor),
+    ceil: numeric(Math.ceil),
+    Number: (value) => toFiniteFirst(value),
+    String: (value) => (hasNoValue(value) ? '' : String(value)),
+};
+const AGGREGATES = new Set(['min', 'max', 'sum', 'count']);
+function isAggregateCall(node) {
+    return node.receiver !== undefined;
+}
+function isBareAggregate(node) {
+    if (node.receiver !== undefined || !AGGREGATES.has(node.callee)) {
+        return false;
+    }
+    return node.callee === 'min' || node.callee === 'max'
+        ? node.args.length === 1
+        : true;
+}
+export function collectIdentifiers(node) {
+    return [...new Set(collectReads(node).map((read) => read.name))];
+}
+export function collectReads(node, options = {}) {
+    const reads = [];
+    const walk = (current, inAggregate) => {
+        switch (current.type) {
+            case 'literal':
+                return;
+            case 'identifier':
+                reads.push({ name: current.name, inAggregate });
+                return;
+            case 'member':
+                if (current.object.type === 'identifier') {
+                    reads.push({
+                        name: current.object.name,
+                        field: current.property,
+                        inAggregate,
+                    });
+                    return;
+                }
+                walk(current.object, inAggregate);
+                return;
+            case 'index':
+                if (current.object.type === 'identifier') {
+                    reads.push({
+                        name: current.object.name,
+                        indexed: true,
+                        inAggregate,
+                    });
+                }
+                else {
+                    walk(current.object, inAggregate);
+                }
+                walk(current.index, inAggregate);
+                return;
+            case 'call': {
+                const aggregate = inAggregate || (!!options.aggregates && isAggregateCall(current));
+                current.args.forEach((argument) => walk(argument, aggregate));
+                return;
+            }
+            case 'unary':
+                walk(current.argument, inAggregate);
+                return;
+            case 'binary':
+            case 'logical':
+                walk(current.left, inAggregate);
+                walk(current.right, inAggregate);
+                return;
+            case 'conditional':
+                walk(current.test, inAggregate);
+                walk(current.consequent, inAggregate);
+                walk(current.alternate, inAggregate);
+                return;
+            case 'array':
+                current.elements.forEach((element) => walk(element, inAggregate));
+                return;
+            case 'template':
+                current.parts.forEach((part) => {
+                    if (part.kind === 'expr') {
+                        walk(part.node, inAggregate);
+                    }
+                });
+                return;
+        }
+    };
+    walk(node, false);
+    return reads;
+}
+function assertOnlyParams(node, paramNames, context) {
+    const allowed = new Set(paramNames);
+    for (const read of collectReads(node, {
+        aggregates: !!context.receivers,
+    })) {
+        if (!read.inAggregate && !allowed.has(read.name)) {
+            throw new ExpressionSyntaxError(`'${read.name}' is not a parameter, and this expression has no ` +
+                `implicit scope; it can read only (${paramNames.join(', ')})`, context.expression);
+        }
+    }
+}
+function resolveIdentifier(name, scope) {
+    if (Object.prototype.hasOwnProperty.call(scope.params, name)) {
+        return scope.params[name];
+    }
+    for (let i = scope.implicit.length - 1; i >= 0; i--) {
+        const implicitScope = scope.implicit[i];
+        if (implicitScope != null &&
+            typeof implicitScope === 'object' &&
+            name in implicitScope) {
+            return safeGet(implicitScope, name);
+        }
+    }
+    return undefined;
+}
+const COMPARISONS = {
+    '<': compareFinite((a, b) => a < b),
+    '<=': compareFinite((a, b) => a <= b),
+    '>': compareFinite((a, b) => a > b),
+    '>=': compareFinite((a, b) => a >= b),
+};
+function arithmetic(operation) {
+    return (left, right) => {
+        const a = toFiniteFirst(left);
+        const b = toFiniteFirst(right);
+        if (a === undefined || b === undefined) {
+            return undefined;
+        }
+        const result = operation(a, b);
+        return Number.isFinite(result) ? result : undefined;
+    };
+}
+function plus(left, right) {
+    const first = asArrayFirst(left);
+    if (typeof first === 'string') {
+        return first + (hasNoValue(right) ? '' : String(asArrayFirst(right)));
+    }
+    if (hasNoValue(left) || hasNoValue(right)) {
+        return undefined;
+    }
+    const a = toFiniteFirst(left);
+    const b = toFiniteFirst(right);
+    if (a === undefined || b === undefined) {
+        throw new TypeError(`'+' adds numbers when the left side is not text, and ${JSON.stringify(a === undefined ? left : right)} is not a number; put the text first, or use a template`);
+    }
+    const result = a + b;
+    return Number.isFinite(result) ? result : undefined;
+}
+function isTextOperand(node) {
+    if (node.type === 'template') {
+        return true;
+    }
+    return (node.type === 'literal' &&
+        typeof node.value === 'string' &&
+        toFiniteFirst(node.value) === undefined);
+}
+const ARITHMETIC = {
+    '+': plus,
+    '-': arithmetic((a, b) => a - b),
+    '*': arithmetic((a, b) => a * b),
+    '/': arithmetic((a, b) => a / b),
+    '%': arithmetic((a, b) => a % b),
+};
+function missingValueTest(node) {
+    if (node.type === 'literal') {
+        if (node.value === DEFINED_LITERAL) {
+            return (value) => !hasNoValue(value);
+        }
+        if (isAbsent(node.value)) {
+            return isAbsent;
+        }
+        if (isEmpty(node.value)) {
+            return hasNoValue;
+        }
+    }
+    return undefined;
+}
+function rejectListArrayLiteral(node, context) {
+    for (const [side, other] of [
+        [node.left, node.right],
+        [node.right, node.left],
+    ]) {
+        if (side.type === 'array' && side.elements.length > 1) {
+            const name = other.type === 'identifier' ? other.name : 'X';
+            throw new ExpressionSyntaxError(`'${node.operator}' with an array of ${side.elements.length} values compares the whole value; to test that a value is one of a list, use ${node.operator === '!=' ? `!(${name} in [...])` : `${name} in [...]`} or includes(...), e.g. Modality in ['MR', 'CT']`, context.expression);
+        }
+    }
+}
+function rejectEmptyArrayLiteral(node, context) {
+    for (const side of [node.left, node.right]) {
+        if (side.type === 'array' && !side.elements.length) {
+            throw new ExpressionSyntaxError(`'${node.operator} []' accepts no value; give one or more values, or use '${node.operator} null' to test for no value`, context.expression);
+        }
+    }
+}
+function compileEquality(node, context) {
+    const negate = node.operator === '!=';
+    rejectEmptyArrayLiteral(node, context);
+    rejectListArrayLiteral(node, context);
+    const rightTest = missingValueTest(node.right);
+    const leftTest = missingValueTest(node.left);
+    if (rightTest || leftTest) {
+        const test = rightTest ?? leftTest;
+        const operand = compileNode(rightTest ? node.left : node.right, context);
+        return negate
+            ? (scope) => !test(operand(scope))
+            : (scope) => test(operand(scope));
+    }
+    const left = compileNode(node.left, context);
+    const right = compileNode(node.right, context);
+    return negate
+        ? (scope) => !looseEquals(left(scope), right(scope))
+        : (scope) => looseEquals(left(scope), right(scope));
+}
+function compileAggregate(node, context) {
+    const { callee } = node;
+    const over = context.receivers[node.receiver];
+    const element = node.args[0]
+        ? compileNode(node.args[0], { ...context, inAggregate: true })
+        : undefined;
+    return (scope) => {
+        const list = scope.params[over];
+        const items = Array.isArray(list) ? list : [];
+        if (!element) {
+            return items.length;
+        }
+        const values = items.map((item) => {
+            scope.implicit.push(item);
+            try {
+                return element(scope);
+            }
+            finally {
+                scope.implicit.pop();
+            }
+        });
+        if (callee === 'count') {
+            return values.filter((value) => !hasNoValue(value) && value !== false)
+                .length;
+        }
+        const numbers = finiteValues(values);
+        if (callee === 'sum') {
+            return numbers.reduce((total, value) => total + value, 0);
+        }
+        if (!numbers.length) {
+            return undefined;
+        }
+        return callee === 'min' ? Math.min(...numbers) : Math.max(...numbers);
+    };
+}
+function compileNode(node, context) {
+    const { expression } = context;
+    switch (node.type) {
+        case 'literal': {
+            const { value } = node;
+            if (value === DEFINED_LITERAL) {
+                throw new ExpressionSyntaxError("'defined' is a literal for '== defined' and '!= defined' only", expression);
+            }
+            return () => value;
+        }
+        case 'identifier': {
+            const { name } = node;
+            return (scope) => resolveIdentifier(name, scope);
+        }
+        case 'member': {
+            const object = compileNode(node.object, context);
+            const { property } = node;
+            return (scope) => safeGet(object(scope), property);
+        }
+        case 'index': {
+            const object = compileNode(node.object, context);
+            const index = compileNode(node.index, context);
+            return (scope) => safeGet(object(scope), index(scope));
+        }
+        case 'array': {
+            const elements = node.elements.map((element) => compileNode(element, context));
+            if (node.elements.every((element) => element.type === 'literal')) {
+                const folded = node.elements.map((element) => element.value);
+                return () => folded;
+            }
+            return (scope) => elements.map((element) => element(scope));
+        }
+        case 'template': {
+            const parts = node.parts.map((part) => part.kind === 'text' ? () => part.text : compileNode(part.node, context));
+            return (scope) => parts
+                .map((part) => {
+                const value = part(scope);
+                return hasNoValue(value) ? '' : String(value);
+            })
+                .join('');
+        }
+        case 'unary': {
+            const argument = compileNode(node.argument, context);
+            switch (node.operator) {
+                case '!':
+                    return (scope) => !isTrue(argument(scope));
+                case '-': {
+                    const negate = numeric((value) => -value);
+                    return (scope) => negate(argument(scope));
+                }
+                case '+':
+                    return (scope) => toFiniteFirst(argument(scope));
+            }
+            break;
+        }
+        case 'logical': {
+            const left = compileNode(node.left, context);
+            const right = compileNode(node.right, context);
+            return node.operator === '&&'
+                ? (scope) => isTrue(left(scope)) && isTrue(right(scope))
+                : (scope) => isTrue(left(scope)) || isTrue(right(scope));
+        }
+        case 'binary': {
+            if (node.operator === '==' || node.operator === '!=') {
+                return compileEquality(node, context);
+            }
+            if (node.operator === '===' || node.operator === '!==') {
+                throw new ExpressionSyntaxError(`'${node.operator}' is not allowed; use '${node.operator === '===' ? '==' : '!='}', the one equality of the rule language`, expression);
+            }
+            if (ARITHMETIC[node.operator] && node.operator !== '+') {
+                const text = [node.left, node.right].find(isTextOperand);
+                if (text) {
+                    throw new ExpressionSyntaxError(`'${node.operator}' works on numbers only, and ${text.type === 'template' ? 'a template literal' : `'${String(text.value)}'`} is not a number`, expression);
+                }
+            }
+            const left = compileNode(node.left, context);
+            const right = compileNode(node.right, context);
+            const comparison = COMPARISONS[node.operator];
+            if (comparison) {
+                return (scope) => comparison(left(scope), right(scope));
+            }
+            const operation = ARITHMETIC[node.operator];
+            if (operation) {
+                return (scope) => operation(left(scope), right(scope));
+            }
+            if (node.operator === 'in') {
+                return (scope) => MATCH_HELPERS.includes(right(scope), left(scope));
+            }
+            throw new ExpressionSyntaxError(`Unknown operator '${node.operator}'`, expression);
+        }
+        case 'conditional': {
+            const test = compileNode(node.test, context);
+            const consequent = compileNode(node.consequent, context);
+            const alternate = compileNode(node.alternate, context);
+            return (scope) => isTrue(test(scope)) ? consequent(scope) : alternate(scope);
+        }
+        case 'call': {
+            const { callee } = node;
+            if (isAggregateCall(node)) {
+                const { receiver } = node;
+                if (!Object.prototype.hasOwnProperty.call(context.receivers ?? {}, receiver)) {
+                    throw new ExpressionSyntaxError(context.unavailable?.[receiver] ??
+                        `${receiver}.instances.${callee}() is not available here`, expression);
+                }
+                if (context.inAggregate) {
+                    throw new ExpressionSyntaxError(`${receiver}.instances.${callee}() is not allowed inside the argument of another aggregate; put the inner aggregate in its own context entry, and read that name`, expression);
+                }
+                const arity = node.args.length;
+                if (callee === 'count' ? arity > 1 : arity !== 1) {
+                    throw new ExpressionSyntaxError(`${receiver}.instances.${callee}() takes ${callee === 'count' ? 'zero or one argument' : 'one argument'}`, expression);
+                }
+                return compileAggregate(node, context);
+            }
+            if (isBareAggregate(node)) {
+                const places = Object.keys(context.receivers ?? {}).map((receiver) => `${receiver}.instances.${callee}(...)`);
+                throw new ExpressionSyntaxError(places.length
+                    ? `${callee}(...) needs a receiver; use ${places.join(' or ')}`
+                    : `${callee}(...) is not available here: this place has no list of instances`, expression);
+            }
+            const helper = Object.prototype.hasOwnProperty.call(HELPERS, callee)
+                ? HELPERS[callee]
+                : undefined;
+            if (!helper) {
+                throw new ExpressionSyntaxError(`'${callee}' is not a whitelisted helper function`, expression);
+            }
+            const args = node.args.map((argument) => compileNode(argument, context));
+            return (scope) => helper(...args.map((argument) => argument(scope)));
+        }
+    }
+    throw new ExpressionSyntaxError('Unsupported expression node', expression);
+}
+export function compileExpression(source, options = {}) {
+    const paramNames = options.params ?? ['instance', 'context'];
+    const { implicitScope = true, receivers, unavailableReceivers } = options;
+    for (const [receiver, param] of Object.entries(receivers ?? {})) {
+        if (!paramNames.includes(param)) {
+            throw new ExpressionSyntaxError(`the list '${param}' of the receiver '${receiver}' is not one of the parameters (${paramNames.join(', ')})`, source);
+        }
+    }
+    let implicitIndex = -1;
+    if (implicitScope === true) {
+        implicitIndex = 0;
+    }
+    else if (typeof implicitScope === 'string') {
+        implicitIndex = paramNames.indexOf(implicitScope);
+        if (implicitIndex === -1) {
+            throw new ExpressionSyntaxError(`implicitScope '${implicitScope}' is not one of the parameters (${paramNames.join(', ')})`, source);
+        }
+    }
+    const context = {
+        expression: source,
+        receivers,
+        unavailable: unavailableReceivers,
+    };
+    const ast = parseExpressionSource(source);
+    if (implicitIndex === -1) {
+        assertOnlyParams(ast, paramNames, context);
+    }
+    const evaluator = compileNode(ast, context);
+    let warned = false;
+    const compiled = ((...args) => {
+        const params = Object.create(null);
+        paramNames.forEach((name, index) => {
+            params[name] = args[index];
+        });
+        const scope = {
+            params,
+            implicit: implicitIndex === -1 ? [] : [args[implicitIndex]],
+        };
+        try {
+            return evaluator(scope);
+        }
+        catch (error) {
+            if (error instanceof RuleCompileError) {
+                throw error;
+            }
+            if (!warned) {
+                warned = true;
+                console.warn(`Safe function expression failed at runtime: ${source}`, error);
+            }
+            return undefined;
+        }
+    });
+    compiled.expressionSource = source;
+    return compiled;
+}
+export { ExpressionSyntaxError };

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

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