@medplum/core 2.0.14 → 2.0.15

package/dist/esm/fhirmapper/parse.mjs

@@ -1,16 +1,11 @@
-import { __classPrivateFieldGet } from '../node_modules/tslib/tslib.es6.mjs';
 import { SymbolAtom, FunctionAtom, LiteralAtom } from '../fhirpath/atoms.mjs';
 import { initFhirPathParserBuilder } from '../fhirpath/parse.mjs';
-import '../fhirlexer/parse.mjs';
-import '../fhirlexer/tokenize.mjs';
 import '../types.mjs';
 import '../utils.mjs';
 import { tokenize } from './tokenize.mjs';
 
-var _StructureMapParser_instances, _StructureMapParser_parseUses, _StructureMapParser_parseImport, _StructureMapParser_parseGroup, _StructureMapParser_parseParameters, _StructureMapParser_parseParameter, _StructureMapParser_parseRules, _StructureMapParser_parseRule, _StructureMapParser_parseRuleSources, _StructureMapParser_parseRuleSource, _StructureMapParser_parseRuleTargets, _StructureMapParser_parseRuleTarget, _StructureMapParser_parseRuleTargetTransform, _StructureMapParser_parseRuleTargetSymbol, _StructureMapParser_parseRuleTargetFunction, _StructureMapParser_parseRuleTargetLiteral, _StructureMapParser_parseRuleContext, _StructureMapParser_parseRuleDependents, _StructureMapParser_parseConceptMap;
 class StructureMapParser {
     constructor(parser) {
-        _StructureMapParser_instances.add(this);
         this.parser = parser;
         this.structureMap = { resourceType: 'StructureMap' };
     }
@@ -25,16 +20,16 @@ class StructureMapParser {
             const next = this.parser.peek()?.value;
             switch (next) {
                 case 'uses':
-                    __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseUses).call(this);
+                    this.parseUses();
                     break;
                 case 'imports':
-                    __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseImport).call(this);
+                    this.parseImport();
                     break;
                 case 'group':
-                    __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseGroup).call(this);
+                    this.parseGroup();
                     break;
                 case 'conceptmap':
-                    __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseConceptMap).call(this);
+                    this.parseConceptMap();
                     break;
                 default:
                     throw new Error(`Unexpected token: ${next}`);
@@ -42,263 +37,280 @@ class StructureMapParser {
         }
         return this.structureMap;
     }
-}
-_StructureMapParser_instances = new WeakSet(), _StructureMapParser_parseUses = function _StructureMapParser_parseUses() {
-    // 'uses' url structureAlias? 'as' modelMode
-    // uses "http://hl7.org/fhir/StructureDefinition/tutorial-left" as source
-    this.parser.consume('Symbol', 'uses');
-    const result = {};
-    result.url = this.parser.consume('String').value;
-    if (this.parser.peek()?.value === 'alias') {
-        this.parser.consume('Symbol', 'alias');
-        result.alias = this.parser.consume('Symbol').value;
-    }
-    this.parser.consume('Symbol', 'as');
-    result.mode = this.parser.consume().value;
-    if (!this.structureMap.structure) {
-        this.structureMap.structure = [];
-    }
-    this.structureMap.structure.push(result);
-}, _StructureMapParser_parseImport = function _StructureMapParser_parseImport() {
-    this.parser.consume('Symbol', 'imports');
-    if (!this.structureMap.import) {
-        this.structureMap.import = [];
-    }
-    this.structureMap.import.push(this.parser.consume('String').value);
-}, _StructureMapParser_parseGroup = function _StructureMapParser_parseGroup() {
-    // 'group' identifier parameters extends? typeMode? rules
-    // group tutorial(source src : TLeft, target tgt : TRight) {
-    const result = {};
-    this.parser.consume('Symbol', 'group');
-    result.name = this.parser.consume('Symbol').value;
-    result.input = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseParameters).call(this);
-    if (this.parser.peek()?.value === 'extends') {
-        this.parser.consume('Symbol', 'extends');
-        result.extends = this.parser.consume('Symbol').value;
-    }
-    if (this.parser.peek()?.value === '<<') {
-        this.parser.consume('<<');
-        result.typeMode = this.parser.consume().value;
-        if (this.parser.peek()?.value === '+') {
-            this.parser.consume('+');
-            result.typeMode = 'type-and-types';
-        }
-        this.parser.consume('>>');
+    parseUses() {
+        // 'uses' url structureAlias? 'as' modelMode
+        // uses "http://hl7.org/fhir/StructureDefinition/tutorial-left" as source
+        this.parser.consume('Symbol', 'uses');
+        const result = {};
+        result.url = this.parser.consume('String').value;
+        if (this.parser.peek()?.value === 'alias') {
+            this.parser.consume('Symbol', 'alias');
+            result.alias = this.parser.consume('Symbol').value;
+        }
+        this.parser.consume('Symbol', 'as');
+        result.mode = this.parser.consume().value;
+        if (!this.structureMap.structure) {
+            this.structureMap.structure = [];
+        }
+        this.structureMap.structure.push(result);
     }
-    else {
-        result.typeMode = 'none';
+    parseImport() {
+        this.parser.consume('Symbol', 'imports');
+        if (!this.structureMap.import) {
+            this.structureMap.import = [];
+        }
+        this.structureMap.import.push(this.parser.consume('String').value);
+    }
+    parseGroup() {
+        // 'group' identifier parameters extends? typeMode? rules
+        // group tutorial(source src : TLeft, target tgt : TRight) {
+        const result = {};
+        this.parser.consume('Symbol', 'group');
+        result.name = this.parser.consume('Symbol').value;
+        result.input = this.parseParameters();
+        if (this.parser.peek()?.value === 'extends') {
+            this.parser.consume('Symbol', 'extends');
+            result.extends = this.parser.consume('Symbol').value;
+        }
+        if (this.parser.peek()?.value === '<<') {
+            this.parser.consume('<<');
+            result.typeMode = this.parser.consume().value;
+            if (this.parser.peek()?.value === '+') {
+                this.parser.consume('+');
+                result.typeMode = 'type-and-types';
+            }
+            this.parser.consume('>>');
+        }
+        else {
+            result.typeMode = 'none';
+        }
+        result.rule = this.parseRules();
+        if (!this.structureMap.group) {
+            this.structureMap.group = [];
+        }
+        this.structureMap.group.push(result);
+    }
+    parseParameters() {
+        const parameters = [];
+        this.parser.consume('(');
+        while (this.parser.hasMore() && this.parser.peek()?.value !== ')') {
+            parameters.push(this.parseParameter());
+            if (this.parser.peek()?.value === ',') {
+                this.parser.consume(',');
+            }
+        }
+        this.parser.consume(')');
+        return parameters;
+    }
+    parseParameter() {
+        // inputMode identifier type?
+        // ':' identifier
+        // source src : TLeft
+        const result = {};
+        result.mode = this.parser.consume().value;
+        result.name = this.parser.consume('Symbol').value;
+        if (this.parser.peek()?.value === ':') {
+            this.parser.consume(':');
+            result.type = this.parser.consume('Symbol').value;
+        }
+        return result;
     }
-    result.rule = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRules).call(this);
-    if (!this.structureMap.group) {
-        this.structureMap.group = [];
+    parseRules() {
+        const rules = [];
+        this.parser.consume('{');
+        while (this.parser.hasMore() && this.parser.peek()?.value !== '}') {
+            rules.push(this.parseRule());
+        }
+        this.parser.consume('}');
+        return rules;
+    }
+    parseRule() {
+        const result = {
+            source: this.parseRuleSources(),
+        };
+        if (this.parser.peek()?.value === '->') {
+            this.parser.consume('->');
+            result.target = this.parseRuleTargets();
+        }
+        if (this.parser.peek()?.value === 'then') {
+            this.parser.consume('Symbol', 'then');
+            if (this.parser.peek()?.id === '{') {
+                result.rule = this.parseRules();
+            }
+            else {
+                result.dependent = this.parseRuleDependents();
+            }
+        }
+        if (this.parser.peek()?.id === 'String') {
+            result.name = this.parser.consume().value;
+        }
+        else {
+            result.name = result.source?.[0]?.element;
+        }
+        this.parser.consume(';');
+        return result;
     }
-    this.structureMap.group.push(result);
-}, _StructureMapParser_parseParameters = function _StructureMapParser_parseParameters() {
-    const parameters = [];
-    this.parser.consume('(');
-    while (this.parser.hasMore() && this.parser.peek()?.value !== ')') {
-        parameters.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseParameter).call(this));
-        if (this.parser.peek()?.value === ',') {
+    parseRuleSources() {
+        const sources = [this.parseRuleSource()];
+        while (this.parser.hasMore() && this.parser.peek()?.value === ',') {
             this.parser.consume(',');
+            sources.push(this.parseRuleSource());
         }
-    }
-    this.parser.consume(')');
-    return parameters;
-}, _StructureMapParser_parseParameter = function _StructureMapParser_parseParameter() {
-    // inputMode identifier type?
-    // ':' identifier
-    // source src : TLeft
-    const result = {};
-    result.mode = this.parser.consume().value;
-    result.name = this.parser.consume('Symbol').value;
-    if (this.parser.peek()?.value === ':') {
-        this.parser.consume(':');
-        result.type = this.parser.consume('Symbol').value;
-    }
-    return result;
-}, _StructureMapParser_parseRules = function _StructureMapParser_parseRules() {
-    const rules = [];
-    this.parser.consume('{');
-    while (this.parser.hasMore() && this.parser.peek()?.value !== '}') {
-        rules.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRule).call(this));
-    }
-    this.parser.consume('}');
-    return rules;
-}, _StructureMapParser_parseRule = function _StructureMapParser_parseRule() {
-    const result = {
-        source: __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleSources).call(this),
-    };
-    if (this.parser.peek()?.value === '->') {
-        this.parser.consume('->');
-        result.target = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargets).call(this);
-    }
-    if (this.parser.peek()?.value === 'then') {
-        this.parser.consume('Symbol', 'then');
-        if (this.parser.peek()?.id === '{') {
-            result.rule = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRules).call(this);
+        return sources;
+    }
+    parseRuleSource() {
+        const result = {};
+        const context = this.parseRuleContext();
+        if (context.includes('.')) {
+            const parts = context.split('.');
+            result.context = parts[0];
+            result.element = parts[1];
         }
         else {
-            result.dependent = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleDependents).call(this);
+            result.context = context;
         }
+        if (this.parser.hasMore() && this.parser.peek()?.value === ':') {
+            this.parser.consume(':');
+            result.type = this.parser.consume().value;
+        }
+        if (this.parser.hasMore() && this.parser.peek()?.value === 'default') {
+            this.parser.consume('default');
+            this.parser.consumeAndParse();
+        }
+        if (this.parser.peek()?.value === 'first' ||
+            this.parser.peek()?.value === 'not_first' ||
+            this.parser.peek()?.value === 'last' ||
+            this.parser.peek()?.value === 'not_last' ||
+            this.parser.peek()?.value === 'only_one') {
+            result.listMode = this.parser.consume().value;
+        }
+        if (this.parser.peek()?.value === 'as') {
+            this.parser.consume('Symbol', 'as');
+            result.variable = this.parser.consume().value;
+        }
+        if (this.parser.peek()?.value === 'where') {
+            this.parser.consume('Symbol', 'where');
+            const whereFhirPath = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
+            result.condition = whereFhirPath.toString();
+        }
+        if (this.parser.peek()?.value === 'check') {
+            this.parser.consume('Symbol', 'check');
+            const checkFhirPath = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
+            result.check = checkFhirPath.toString();
+        }
+        return result;
     }
-    if (this.parser.peek()?.id === 'String') {
-        result.name = this.parser.consume().value;
-    }
-    else {
-        result.name = result.source?.[0]?.element;
-    }
-    this.parser.consume(';');
-    return result;
-}, _StructureMapParser_parseRuleSources = function _StructureMapParser_parseRuleSources() {
-    const sources = [__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleSource).call(this)];
-    while (this.parser.hasMore() && this.parser.peek()?.value === ',') {
-        this.parser.consume(',');
-        sources.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleSource).call(this));
-    }
-    return sources;
-}, _StructureMapParser_parseRuleSource = function _StructureMapParser_parseRuleSource() {
-    const result = {};
-    const context = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleContext).call(this);
-    if (context.includes('.')) {
-        const parts = context.split('.');
-        result.context = parts[0];
-        result.element = parts[1];
-    }
-    else {
-        result.context = context;
-    }
-    if (this.parser.hasMore() && this.parser.peek()?.value === ':') {
-        this.parser.consume(':');
-        result.type = this.parser.consume().value;
-    }
-    if (this.parser.hasMore() && this.parser.peek()?.value === 'default') {
-        this.parser.consume('default');
-        this.parser.consumeAndParse();
-    }
-    if (this.parser.peek()?.value === 'first' ||
-        this.parser.peek()?.value === 'not_first' ||
-        this.parser.peek()?.value === 'last' ||
-        this.parser.peek()?.value === 'not_last' ||
-        this.parser.peek()?.value === 'only_one') {
-        result.listMode = this.parser.consume().value;
-    }
-    if (this.parser.peek()?.value === 'as') {
-        this.parser.consume('Symbol', 'as');
-        result.variable = this.parser.consume().value;
-    }
-    if (this.parser.peek()?.value === 'where') {
-        this.parser.consume('Symbol', 'where');
-        const whereFhirPath = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
-        result.condition = whereFhirPath.toString();
-    }
-    if (this.parser.peek()?.value === 'check') {
-        this.parser.consume('Symbol', 'check');
-        const checkFhirPath = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
-        result.check = checkFhirPath.toString();
-    }
-    return result;
-}, _StructureMapParser_parseRuleTargets = function _StructureMapParser_parseRuleTargets() {
-    const targets = [__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTarget).call(this)];
-    while (this.parser.hasMore() && this.parser.peek()?.value === ',') {
-        this.parser.consume(',');
-        targets.push(__classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTarget).call(this));
-    }
-    return targets;
-}, _StructureMapParser_parseRuleTarget = function _StructureMapParser_parseRuleTarget() {
-    const result = {};
-    const context = __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleContext).call(this);
-    if (context.includes('.')) {
-        const parts = context.split('.');
-        result.contextType = 'variable';
-        result.context = parts[0];
-        result.element = parts[1];
-    }
-    else {
-        result.context = context;
-    }
-    if (this.parser.peek()?.value === '=') {
-        this.parser.consume('=');
-        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetTransform).call(this, result);
-    }
-    if (this.parser.peek()?.value === 'as') {
-        this.parser.consume('Symbol', 'as');
-        result.variable = this.parser.consume().value;
-    }
-    if (this.parser.peek()?.value === 'first' ||
-        this.parser.peek()?.value === 'share' ||
-        this.parser.peek()?.value === 'last' ||
-        this.parser.peek()?.value === 'collate') {
-        result.listMode = [this.parser.consume().value];
-    }
-    return result;
-}, _StructureMapParser_parseRuleTargetTransform = function _StructureMapParser_parseRuleTargetTransform(result) {
-    result.transform = 'copy';
-    const transformFhirPath = this.parser.consumeAndParse(6 /* OperatorPrecedence.As */);
-    if (transformFhirPath instanceof SymbolAtom) {
-        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetSymbol).call(this, result, transformFhirPath);
-    }
-    else if (transformFhirPath instanceof FunctionAtom) {
-        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetFunction).call(this, result, transformFhirPath);
-    }
-    else if (transformFhirPath instanceof LiteralAtom) {
-        __classPrivateFieldGet(this, _StructureMapParser_instances, "m", _StructureMapParser_parseRuleTargetLiteral).call(this, result, transformFhirPath);
-    }
-    else {
-        throw new Error(`Unexpected FHIRPath: ${transformFhirPath}`);
+    parseRuleTargets() {
+        const targets = [this.parseRuleTarget()];
+        while (this.parser.hasMore() && this.parser.peek()?.value === ',') {
+            this.parser.consume(',');
+            targets.push(this.parseRuleTarget());
+        }
+        return targets;
+    }
+    parseRuleTarget() {
+        const result = {};
+        const context = this.parseRuleContext();
+        if (context.includes('.')) {
+            const parts = context.split('.');
+            result.contextType = 'variable';
+            result.context = parts[0];
+            result.element = parts[1];
+        }
+        else {
+            result.context = context;
+        }
+        if (this.parser.peek()?.value === '=') {
+            this.parser.consume('=');
+            this.parseRuleTargetTransform(result);
+        }
+        if (this.parser.peek()?.value === 'as') {
+            this.parser.consume('Symbol', 'as');
+            result.variable = this.parser.consume().value;
+        }
+        if (this.parser.peek()?.value === 'first' ||
+            this.parser.peek()?.value === 'share' ||
+            this.parser.peek()?.value === 'last' ||
+            this.parser.peek()?.value === 'collate') {
+            result.listMode = [this.parser.consume().value];
+        }
+        return result;
     }
-}, _StructureMapParser_parseRuleTargetSymbol = function _StructureMapParser_parseRuleTargetSymbol(result, literalAtom) {
-    result.parameter = [{ valueId: literalAtom.name }];
-}, _StructureMapParser_parseRuleTargetFunction = function _StructureMapParser_parseRuleTargetFunction(result, functionAtom) {
-    const functionName = functionAtom.name;
-    switch (functionName) {
-        case 'create':
-            result.parameter = [
-                {
-                    valueString: (functionAtom.args?.[0]).value.value,
-                },
-            ];
-            break;
-        case 'translate':
-            result.parameter = [{}];
-            break;
-        default:
-            throw new Error('Unknown target function: ' + functionName);
+    parseRuleTargetTransform(result) {
+        result.transform = 'copy';
+        const transformFhirPath = this.parser.consumeAndParse(6 /* OperatorPrecedence.As */);
+        if (transformFhirPath instanceof SymbolAtom) {
+            this.parseRuleTargetSymbol(result, transformFhirPath);
+        }
+        else if (transformFhirPath instanceof FunctionAtom) {
+            this.parseRuleTargetFunction(result, transformFhirPath);
+        }
+        else if (transformFhirPath instanceof LiteralAtom) {
+            this.parseRuleTargetLiteral(result, transformFhirPath);
+        }
+        else {
+            throw new Error(`Unexpected FHIRPath: ${transformFhirPath}`);
+        }
     }
-}, _StructureMapParser_parseRuleTargetLiteral = function _StructureMapParser_parseRuleTargetLiteral(result, literalAtom) {
-    switch (literalAtom.value.type) {
-        case 'boolean':
-            result.parameter = [{ valueBoolean: literalAtom.value.value }];
-            break;
-        case 'decimal':
-            result.parameter = [{ valueDecimal: literalAtom.value.value }];
-            break;
-        case 'string':
-            result.parameter = [{ valueString: literalAtom.value.value }];
-            break;
-        default:
-            throw new Error('Unknown target literal type: ' + literalAtom.value.type);
+    parseRuleTargetSymbol(result, literalAtom) {
+        result.parameter = [{ valueId: literalAtom.name }];
+    }
+    parseRuleTargetFunction(result, functionAtom) {
+        const functionName = functionAtom.name;
+        switch (functionName) {
+            case 'create':
+                result.parameter = [
+                    {
+                        valueString: (functionAtom.args?.[0]).value.value,
+                    },
+                ];
+                break;
+            case 'translate':
+                result.parameter = [{}];
+                break;
+            default:
+                throw new Error('Unknown target function: ' + functionName);
+        }
     }
-}, _StructureMapParser_parseRuleContext = function _StructureMapParser_parseRuleContext() {
-    let identifier = this.parser.consume().value;
-    while (this.parser.peek()?.value === '.') {
-        this.parser.consume('.');
-        identifier += '.' + this.parser.consume().value;
+    parseRuleTargetLiteral(result, literalAtom) {
+        switch (literalAtom.value.type) {
+            case 'boolean':
+                result.parameter = [{ valueBoolean: literalAtom.value.value }];
+                break;
+            case 'decimal':
+                result.parameter = [{ valueDecimal: literalAtom.value.value }];
+                break;
+            case 'string':
+                result.parameter = [{ valueString: literalAtom.value.value }];
+                break;
+            default:
+                throw new Error('Unknown target literal type: ' + literalAtom.value.type);
+        }
     }
-    return identifier;
-}, _StructureMapParser_parseRuleDependents = function _StructureMapParser_parseRuleDependents() {
-    const atom = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
-    return [
-        {
-            name: atom.name,
-            variable: atom.args.map((arg) => arg.name),
-        },
-    ];
-}, _StructureMapParser_parseConceptMap = function _StructureMapParser_parseConceptMap() {
-    while (this.parser.peek()?.value !== '}') {
-        this.parser.consume();
+    parseRuleContext() {
+        let identifier = this.parser.consume().value;
+        while (this.parser.peek()?.value === '.') {
+            this.parser.consume('.');
+            identifier += '.' + this.parser.consume().value;
+        }
+        return identifier;
+    }
+    parseRuleDependents() {
+        const atom = this.parser.consumeAndParse(100 /* OperatorPrecedence.Arrow */);
+        return [
+            {
+                name: atom.name,
+                variable: atom.args.map((arg) => arg.name),
+            },
+        ];
+    }
+    parseConceptMap() {
+        while (this.parser.peek()?.value !== '}') {
+            this.parser.consume();
+        }
+        this.parser.consume('}');
     }
-    this.parser.consume('}');
-};
+}
 const fhirPathParserBuilder = initFhirPathParserBuilder()
     .registerInfix('->', { precedence: 100 /* OperatorPrecedence.Arrow */ })
     .registerInfix(';', { precedence: 200 /* OperatorPrecedence.Semicolon */ });