@cornerstonejs/metadata 5.13.2 → 5.14.0

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

@@ -0,0 +1,198 @@
+const PUNCTUATORS = [
+    '===',
+    '!==',
+    '==',
+    '!=',
+    '<=',
+    '>=',
+    '&&',
+    '||',
+    '<',
+    '>',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '!',
+    '(',
+    ')',
+    '[',
+    ']',
+    ',',
+    '.',
+    '?',
+    ':',
+];
+const isIdentStart = (ch) => /[A-Za-z_$]/.test(ch);
+const isIdentPart = (ch) => /[A-Za-z0-9_$]/.test(ch);
+const isDigit = (ch) => ch >= '0' && ch <= '9';
+export class ExpressionSyntaxError extends Error {
+    constructor(message, expression) {
+        super(`${message} in expression: ${expression}`);
+        this.name = 'ExpressionSyntaxError';
+    }
+}
+function readEscape(source, index) {
+    const escaped = source[index];
+    const map = {
+        n: '\n',
+        t: '\t',
+        r: '\r',
+        '\\': '\\',
+        "'": "'",
+        '"': '"',
+        '`': '`',
+        $: '$',
+    };
+    return { ch: map[escaped] ?? escaped, next: index + 1 };
+}
+function readTemplate(source, start, expression) {
+    const parts = [];
+    let text = '';
+    let i = start;
+    while (i < source.length) {
+        const ch = source[i];
+        if (ch === '`') {
+            if (text) {
+                parts.push({ kind: 'text', text });
+            }
+            return { parts, next: i + 1 };
+        }
+        if (ch === '\\') {
+            const { ch: escaped, next } = readEscape(source, i + 1);
+            text += escaped;
+            i = next;
+            continue;
+        }
+        if (ch === '$' && source[i + 1] === '{') {
+            if (text) {
+                parts.push({ kind: 'text', text });
+                text = '';
+            }
+            let depth = 1;
+            let j = i + 2;
+            let exprSource = '';
+            while (j < source.length && depth > 0) {
+                const c = source[j];
+                if (c === '{') {
+                    depth++;
+                }
+                else if (c === '}') {
+                    depth--;
+                    if (depth === 0) {
+                        break;
+                    }
+                }
+                else if (c === "'" || c === '"') {
+                    const quote = c;
+                    exprSource += c;
+                    j++;
+                    while (j < source.length && source[j] !== quote) {
+                        if (source[j] === '\\') {
+                            exprSource += source[j];
+                            j++;
+                        }
+                        exprSource += source[j];
+                        j++;
+                    }
+                }
+                exprSource += source[j];
+                j++;
+            }
+            if (depth !== 0) {
+                throw new ExpressionSyntaxError('Unterminated template interpolation', expression);
+            }
+            parts.push({ kind: 'expr', source: exprSource });
+            i = j + 1;
+            continue;
+        }
+        text += ch;
+        i++;
+    }
+    throw new ExpressionSyntaxError('Unterminated template literal', expression);
+}
+export function tokenize(source, expression = source) {
+    const tokens = [];
+    let i = 0;
+    outer: while (i < source.length) {
+        const ch = source[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (isDigit(ch) || (ch === '.' && isDigit(source[i + 1]))) {
+            let j = i;
+            while (j < source.length && /[0-9.]/.test(source[j])) {
+                j++;
+            }
+            if (source[j] === 'e' || source[j] === 'E') {
+                let k = j + 1;
+                if (source[k] === '+' || source[k] === '-') {
+                    k++;
+                }
+                if (isDigit(source[k])) {
+                    k++;
+                    while (k < source.length && isDigit(source[k])) {
+                        k++;
+                    }
+                    j = k;
+                }
+            }
+            const raw = source.slice(i, j);
+            const value = Number(raw);
+            if (Number.isNaN(value)) {
+                throw new ExpressionSyntaxError(`Invalid number '${raw}'`, expression);
+            }
+            tokens.push({ kind: 'number', value });
+            i = j;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            let value = '';
+            let j = i + 1;
+            while (j < source.length && source[j] !== ch) {
+                if (source[j] === '\\') {
+                    const { ch: escaped, next } = readEscape(source, j + 1);
+                    value += escaped;
+                    j = next;
+                }
+                else {
+                    value += source[j];
+                    j++;
+                }
+            }
+            if (j >= source.length) {
+                throw new ExpressionSyntaxError('Unterminated string literal', expression);
+            }
+            tokens.push({ kind: 'string', value });
+            i = j + 1;
+            continue;
+        }
+        if (ch === '`') {
+            const { parts, next } = readTemplate(source, i + 1, expression);
+            tokens.push({ kind: 'template', parts });
+            i = next;
+            continue;
+        }
+        if (isIdentStart(ch)) {
+            let j = i + 1;
+            while (j < source.length && isIdentPart(source[j])) {
+                j++;
+            }
+            tokens.push({ kind: 'ident', name: source.slice(i, j) });
+            i = j;
+            continue;
+        }
+        for (const punct of PUNCTUATORS) {
+            if (source.startsWith(punct, i)) {
+                tokens.push({ kind: 'punct', value: punct });
+                i += punct.length;
+                continue outer;
+            }
+        }
+        throw new ExpressionSyntaxError(`Unexpected character '${ch}'`, expression);
+    }
+    tokens.push({ kind: 'end' });
+    return tokens;
+}

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

@@ -0,0 +1,5 @@
+export { compileCondition, compileConditionAt, compileExpressionAt, compileTemplate, compileValue, compileValueAt, createSite, hasNoValue, invalid, isAbsent, isEmpty, isTrue, compareFinite, looseEquals, parseTemplate, readNameAt, readOwnName, safeFunctionCompilers, type CompileOptions, type TemplateSegment, } from './compile.js';
+export { compileMatchTest, MATCH_HELPERS, MATCH_OPERATORS, type ValueTest, } from './matchTests.js';
+export { at, checkForm, compileKey, conditionShape, describeForm, describeShape, didYouMean, INSTANCE_EXPRESSION_SCOPE, invalidAt, isLeafKind, isUnsafeKey, MATCH_OPERATOR_NAMES, matchForm, matchTestShape, hasOwn, readOwn, RuleCompileError, safeFunctionSchema, selectForm, unrecognized, valueShape, type ExpressionScope, type NameReader, type NameReaderFunction, type Schema, type SchemaForm, type SchemaKey, type SchemaLeafKind, type SchemaShape, type SchemaSite, type ShapeCompiler, } from './schema.js';
+export { collectIdentifiers, collectReads, compileExpression, ExpressionSyntaxError, parseExpressionSource, tokenize, FORBIDDEN_PROPERTIES, type CompiledExpression, type CompileExpressionOptions, type ExpressionNode, type ExpressionRead, } from './expression/index.js';
+export type { CompiledPredicate, CompiledValue, InlinePredicate, InlineValue, RawCondition, RawMatchTest, RawScalar, RawValue, SafeFunctionSubject, } from './types.js';

package/dist/esm/safeFunctions/index.js

@@ -0,0 +1,4 @@
+export { compileCondition, compileConditionAt, compileExpressionAt, compileTemplate, compileValue, compileValueAt, createSite, hasNoValue, invalid, isAbsent, isEmpty, isTrue, compareFinite, looseEquals, parseTemplate, readNameAt, readOwnName, safeFunctionCompilers, } from './compile.js';
+export { compileMatchTest, MATCH_HELPERS, MATCH_OPERATORS, } from './matchTests.js';
+export { at, checkForm, compileKey, conditionShape, describeForm, describeShape, didYouMean, INSTANCE_EXPRESSION_SCOPE, invalidAt, isLeafKind, isUnsafeKey, MATCH_OPERATOR_NAMES, matchForm, matchTestShape, hasOwn, readOwn, RuleCompileError, safeFunctionSchema, selectForm, unrecognized, valueShape, } from './schema.js';
+export { collectIdentifiers, collectReads, compileExpression, ExpressionSyntaxError, parseExpressionSource, tokenize, FORBIDDEN_PROPERTIES, } from './expression/index.js';

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

@@ -0,0 +1,16 @@
+import type { SchemaSite } from './schema.js';
+export type ValueTest = (value: unknown, subject?: unknown, context?: unknown) => boolean;
+type Operator = {
+    readonly operand: string;
+    readonly accepts: (operand: unknown) => boolean;
+    readonly compile: (operand: unknown) => ValueTest;
+};
+export declare const MATCH_HELPERS: Readonly<{
+    includes: (value: unknown, operand: unknown) => boolean;
+    contains: (value: unknown, operand: unknown) => boolean;
+    startsWith: (value: unknown, operand: unknown) => boolean;
+    endsWith: (value: unknown, operand: unknown) => boolean;
+}>;
+export declare const MATCH_OPERATORS: Readonly<Record<string, Operator>>;
+export declare function compileMatchTest(test: unknown, site: SchemaSite): ValueTest;
+export {};

package/dist/esm/safeFunctions/matchTests.js

@@ -0,0 +1,203 @@
+import { asArray, toFiniteFirst } from '@cornerstonejs/utils';
+import { compareFinite, hasNoValue, looseEquals } from './values.js';
+import { invalidAt, matchForm, matchTestShape } from './schema.js';
+const isScalar = (value) => typeof value === 'string' ||
+    typeof value === 'boolean' ||
+    (typeof value === 'number' && Number.isFinite(value));
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isScalarOrScalars = (value) => isScalar(value) ||
+    (Array.isArray(value) && value.length > 0 && value.every(isScalar));
+const isTextOrTexts = (value) => typeof value === 'string' ||
+    (Array.isArray(value) &&
+        value.length > 0 &&
+        value.every((item) => typeof item === 'string'));
+const elementsOf = (value) => hasNoValue(value) ? [] : asArray(value).filter((item) => !hasNoValue(item));
+const textsOf = (value, ignoreCase = false) => elementsOf(value).map((item) => ignoreCase ? String(item).toLowerCase() : String(item));
+const needlesOf = (operand, ignoreCase = false) => asArray(operand).map((item) => ignoreCase ? String(item).toLowerCase() : String(item));
+function equalsTest(operand) {
+    return operand === null
+        ? (value) => hasNoValue(value)
+        : (value) => looseEquals(value, operand);
+}
+const SET_MIN_LENGTH = 9;
+const stringSets = new WeakMap();
+function stringSetOf(list) {
+    if (!Array.isArray(list) || list.length < SET_MIN_LENGTH) {
+        return null;
+    }
+    let set = stringSets.get(list);
+    if (set === undefined) {
+        set = list.every((element) => typeof element === 'string' && element)
+            ? new Set(list)
+            : null;
+        stringSets.set(list, set);
+    }
+    return set;
+}
+function someInList(items, list) {
+    const set = stringSetOf(list);
+    const elements = set ? list : elementsOf(list);
+    return items.some((item) => set && (typeof item === 'string' || typeof item === 'boolean')
+        ? set.has(String(item))
+        : elements.some((element) => looseEquals(item, element)));
+}
+function includesTest(operand) {
+    const wanted = [...asArray(operand)];
+    stringSetOf(wanted);
+    return (value) => someInList(elementsOf(value), wanted);
+}
+function textTest(ignoreCase, test) {
+    return (operand) => {
+        const needles = needlesOf(operand, ignoreCase);
+        return (value) => textsOf(value, ignoreCase).some((text) => needles.some((needle) => test(text, needle)));
+    };
+}
+const not = (compile) => (operand) => {
+    const test = compile(operand);
+    return (value, subject, context) => !test(value, subject, context);
+};
+function numberTest(test) {
+    const compare = compareFinite(test);
+    return (operand) => (value) => compare(value, operand);
+}
+const contains = textTest(false, (text, needle) => text.includes(needle));
+const containsI = textTest(true, (text, needle) => text.includes(needle));
+const startsWith = textTest(false, (text, needle) => text.startsWith(needle));
+const endsWith = textTest(false, (text, needle) => text.endsWith(needle));
+export const MATCH_HELPERS = Object.freeze({
+    includes: (value, operand) => someInList(elementsOf(operand), value),
+    contains: (value, operand) => contains(operand)(value),
+    startsWith: (value, operand) => startsWith(operand)(value),
+    endsWith: (value, operand) => endsWith(operand)(value),
+});
+export const MATCH_OPERATORS = Object.freeze({
+    equals: {
+        operand: 'a scalar, a non-empty array of scalars, or null',
+        accepts: (operand) => operand === null || isScalarOrScalars(operand),
+        compile: equalsTest,
+    },
+    doesNotEqual: {
+        operand: 'a scalar, a non-empty array of scalars, or null',
+        accepts: (operand) => operand === null || isScalarOrScalars(operand),
+        compile: not(equalsTest),
+    },
+    notNull: {
+        operand: 'a boolean',
+        accepts: (operand) => typeof operand === 'boolean',
+        compile: (operand) => operand ? (value) => !hasNoValue(value) : (value) => hasNoValue(value),
+    },
+    includes: {
+        operand: 'a scalar, or a non-empty array of scalars',
+        accepts: isScalarOrScalars,
+        compile: includesTest,
+    },
+    doesNotInclude: {
+        operand: 'a scalar, or a non-empty array of scalars',
+        accepts: isScalarOrScalars,
+        compile: not(includesTest),
+    },
+    greaterThan: {
+        operand: 'a finite number',
+        accepts: isFiniteNumber,
+        compile: numberTest((value, operand) => value > operand),
+    },
+    greaterThanOrEqual: {
+        operand: 'a finite number',
+        accepts: isFiniteNumber,
+        compile: numberTest((value, operand) => value >= operand),
+    },
+    lessThan: {
+        operand: 'a finite number',
+        accepts: isFiniteNumber,
+        compile: numberTest((value, operand) => value < operand),
+    },
+    lessThanOrEqual: {
+        operand: 'a finite number',
+        accepts: isFiniteNumber,
+        compile: numberTest((value, operand) => value <= operand),
+    },
+    range: {
+        operand: 'an array of two finite numbers',
+        accepts: (operand) => Array.isArray(operand) &&
+            operand.length === 2 &&
+            operand.every(isFiniteNumber),
+        compile: (operand) => {
+            const [a, b] = operand;
+            const low = Math.min(a, b);
+            const high = Math.max(a, b);
+            return (value) => {
+                const number = toFiniteFirst(value);
+                return number !== undefined && number >= low && number <= high;
+            };
+        },
+    },
+    contains: {
+        operand: 'a string, or a non-empty array of strings',
+        accepts: isTextOrTexts,
+        compile: contains,
+    },
+    containsI: {
+        operand: 'a string, or a non-empty array of strings',
+        accepts: isTextOrTexts,
+        compile: containsI,
+    },
+    doesNotContain: {
+        operand: 'a string, or a non-empty array of strings',
+        accepts: isTextOrTexts,
+        compile: not(contains),
+    },
+    doesNotContainI: {
+        operand: 'a string, or a non-empty array of strings',
+        accepts: isTextOrTexts,
+        compile: not(containsI),
+    },
+    containsAll: {
+        operand: 'a scalar, or a non-empty array of scalars',
+        accepts: isScalarOrScalars,
+        compile: (operand) => {
+            const wanted = asArray(operand);
+            return (value) => {
+                const elements = elementsOf(value);
+                return (elements.length > 0 &&
+                    wanted.every((element) => elements.some((item) => looseEquals(item, element))));
+            };
+        },
+    },
+    startsWith: {
+        operand: 'a string, or a non-empty array of strings',
+        accepts: isTextOrTexts,
+        compile: startsWith,
+    },
+    endsWith: {
+        operand: 'a string, or a non-empty array of strings',
+        accepts: isTextOrTexts,
+        compile: endsWith,
+    },
+});
+export function compileMatchTest(test, site) {
+    if (typeof test === 'function') {
+        return test;
+    }
+    if (test === null) {
+        return equalsTest(test);
+    }
+    if (isScalar(test)) {
+        return includesTest(test);
+    }
+    if (Array.isArray(test)) {
+        if (!test.length || !test.every(isScalar)) {
+            return invalidAt(site, 'an array test must hold one or more scalars', test);
+        }
+        return includesTest(test);
+    }
+    if (!test || typeof test !== 'object') {
+        return invalidAt(site, 'expected a scalar, an array of scalars, null, an object with one operator, or a function', test);
+    }
+    matchForm(matchTestShape, test, site);
+    const [name, operand] = Object.entries(test)[0];
+    const operator = MATCH_OPERATORS[name];
+    if (!operator.accepts(operand)) {
+        return invalidAt(site, `the operand of ${name} must be ${operator.operand}`, test);
+    }
+    return operator.compile(operand);
+}

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

@@ -0,0 +1,72 @@
+export type ExpressionScope = {
+    readonly params: readonly string[];
+    readonly implicitScope: string | false;
+};
+export type SchemaLeafKind = 'string' | 'number' | 'boolean' | 'true' | 'scalar' | 'literal' | 'priority' | 'expression';
+export type SchemaKey = {
+    readonly kind: string;
+    readonly list?: boolean;
+    readonly record?: boolean;
+    readonly optional?: boolean;
+    readonly oneOf?: readonly string[];
+    readonly keys?: Readonly<Record<string, SchemaKey>>;
+    readonly extraKeys?: Readonly<Record<string, SchemaKey>>;
+    readonly role?: 'operator' | 'modifier';
+    readonly with?: readonly string[];
+    readonly function?: boolean;
+    readonly call?: string;
+    readonly expression?: ExpressionScope;
+    readonly description?: string;
+};
+export type SchemaForm = {
+    readonly selectBy?: string;
+    readonly keys: Readonly<Record<string, SchemaKey>>;
+    readonly expression?: ExpressionScope;
+    readonly description?: string;
+};
+export type SchemaShape = {
+    readonly name: string;
+    readonly string?: 'expression' | 'attribute';
+    readonly function?: boolean;
+    readonly forms: Readonly<Record<string, SchemaForm>>;
+    readonly keyNoun?: string;
+};
+export type Schema = Readonly<Record<string, SchemaShape>>;
+export type NameReaderFunction = (subject: unknown, context?: unknown) => unknown;
+export type NameReader = (name: string, site: SchemaSite, field?: string) => NameReaderFunction;
+export type ShapeCompiler = (fragment: unknown, site: SchemaSite) => unknown;
+export type SchemaSite = {
+    readonly path: string;
+    readonly definition: string;
+    readonly schema: Schema;
+    readonly compilers: Readonly<Record<string, ShapeCompiler>>;
+    readonly readName?: NameReader;
+    readonly expression?: ExpressionScope;
+    readonly call?: string;
+    readonly extraKeys?: Readonly<Record<string, SchemaKey>>;
+};
+export declare const INSTANCE_EXPRESSION_SCOPE: ExpressionScope;
+export declare function hasOwn(object: unknown, key: string): boolean;
+export declare function readOwn(object: unknown, key: string): unknown;
+export declare function isUnsafeKey(key: string): boolean;
+export declare class RuleCompileError extends Error {
+    readonly definition: string;
+    readonly path: string;
+    constructor(definition: string, path: string, message: string);
+}
+export declare function invalidAt(site: Pick<SchemaSite, 'path' | 'definition'>, message: string, ...fragment: unknown[]): never;
+export declare function didYouMean(name: string, candidates: Iterable<string | undefined>): string;
+export declare function at(site: SchemaSite, key: string | number, spec?: SchemaKey): SchemaSite;
+export declare function isLeafKind(kind: string): kind is SchemaLeafKind;
+export declare function describeForm(form: SchemaForm, scope?: ExpressionScope): string;
+export declare function describeShape(shape: SchemaShape, site?: SchemaSite): string;
+export declare function unrecognized(shape: SchemaShape, fragment: unknown, site: SchemaSite): never;
+export declare function selectForm(shape: SchemaShape, fragment: unknown, site: SchemaSite): [string, SchemaForm];
+export declare function checkForm(form: SchemaForm, fragment: Record<string, unknown>, site: SchemaSite, keyNoun?: string): void;
+export declare function compileKey(spec: SchemaKey, value: unknown, site: SchemaSite): unknown;
+export declare function matchForm(shape: SchemaShape, fragment: unknown, site: SchemaSite): [string, SchemaForm];
+export declare const MATCH_OPERATOR_NAMES: readonly ["equals", "doesNotEqual", "notNull", "includes", "doesNotInclude", "greaterThan", "greaterThanOrEqual", "lessThan", "lessThanOrEqual", "range", "contains", "containsI", "doesNotContain", "doesNotContainI", "containsAll", "startsWith", "endsWith"];
+export declare const matchTestShape: SchemaShape;
+export declare const conditionShape: SchemaShape;
+export declare const valueShape: SchemaShape;
+export declare const safeFunctionSchema: Schema;