@f1studio/form-spec 5.0.0-alpha.168 → 5.0.0-alpha.169

package/FormSpec.FS/Integrations/CorEMR/CoreMRPathwayMapper.js

@@ -0,0 +1,939 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get combineConditions () {
+        return combineConditions;
+    },
+    get convertAction () {
+        return convertAction;
+    },
+    get convertCondition () {
+        return convertCondition;
+    },
+    get convertFormTriggersToPathway () {
+        return convertFormTriggersToPathway;
+    },
+    get convertOperator () {
+        return convertOperator;
+    },
+    get convertTiming () {
+        return convertTiming;
+    },
+    get convertTriggerToPathway () {
+        return convertTriggerToPathway;
+    },
+    get generateActionLabel () {
+        return generateActionLabel;
+    },
+    get generateEvaluationLabel () {
+        return generateEvaluationLabel;
+    },
+    get liveTriggers () {
+        return liveTriggers;
+    },
+    get refusalFor () {
+        return refusalFor;
+    }
+});
+const _Helpers = require("../../Helpers.js");
+const _FormTemplate = require("../../../vye-os-contracts-fs/src/CoreMR/FormTemplate.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Int32 = require("@fable-org/fable-library-js/Int32.js");
+const _FormSpec = require("../../FormSpec.js");
+const _RegExp = require("@fable-org/fable-library-js/RegExp.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+const _Seq2 = require("@fable-org/fable-library-js/Seq2.js");
+const _Seq = require("@fable-org/fable-library-js/Seq.js");
+function stableGuid(name) {
+    return (0, _Helpers.Helpers_generateDeterministicGuidRaw)(`coremr:item_trigger:${name}`);
+}
+function comparisonWord(c) {
+    switch(c.tag){
+        case /* LessOrEqual */ 1:
+            return "less_equals";
+        case /* Equal */ 2:
+            return "equals";
+        case /* NotEqual */ 3:
+            return "not_equals";
+        case /* GreaterOrEqual */ 4:
+            return "greater_equals";
+        case /* Greater */ 5:
+            return "greater";
+        default:
+            return "less";
+    }
+}
+function textsOf(items, c) {
+    const chosen = (ids)=>{
+        const matchValue = (0, _List.tryFind)((i)=>(0, _Util.equals)(i.ItemId, c.SourceItem), items);
+        if (matchValue != null) {
+            const item = (0, _Option.value)(matchValue);
+            return (0, _List.choose)((_arg)=>{
+                const id = _arg.fields[0] | 0;
+                return (0, _Option.map)((ch_1)=>ch_1.Text, (0, _List.tryFind)((ch)=>ch.ChoiceId === id, item.Choices));
+            }, ids);
+        } else {
+            return (0, _List.empty)();
+        }
+    };
+    const matchValue_1 = c.Test;
+    switch(matchValue_1.tag){
+        case /* AllChosen */ 1:
+            return [
+                "all",
+                chosen(matchValue_1.fields[0])
+            ];
+        case /* NoneChosen */ 2:
+            return [
+                "none",
+                chosen(matchValue_1.fields[0])
+            ];
+        case /* VitalIs */ 3:
+            {
+                const threshold = matchValue_1.fields[2];
+                return [
+                    comparisonWord(matchValue_1.fields[1]),
+                    (0, _List.singleton)(threshold.toString())
+                ];
+            }
+        case /* BooleanIs */ 4:
+            return [
+                "equals",
+                (0, _List.singleton)(matchValue_1.fields[0] ? "true" : "false")
+            ];
+        case /* TextCompares */ 5:
+            {
+                const text = matchValue_1.fields[1];
+                return [
+                    comparisonWord(matchValue_1.fields[0]),
+                    (0, _List.singleton)(text)
+                ];
+            }
+        case /* UnmodelledCondition */ 6:
+            throw new Error(`CoreMRPathwayMapper: condition \`${matchValue_1.fields[0]} ${matchValue_1.fields[1]}\` is not modelled (${matchValue_1.fields[2]}) — \`refusalFor\` refuses it first`);
+        default:
+            return [
+                "any",
+                chosen(matchValue_1.fields[0])
+            ];
+    }
+}
+function convertOperator(test, values) {
+    const canonValues = (0, _List.map)(_Helpers.Helpers_canonicalizeFieldKey, values);
+    let matchResult, cmp;
+    switch(test.tag){
+        case /* AllChosen */ 1:
+            {
+                matchResult = 1;
+                break;
+            }
+        case /* NoneChosen */ 2:
+            {
+                matchResult = 2;
+                break;
+            }
+        case /* VitalIs */ 3:
+            {
+                matchResult = 3;
+                cmp = test.fields[1];
+                break;
+            }
+        case /* TextCompares */ 5:
+            {
+                matchResult = 3;
+                cmp = test.fields[0];
+                break;
+            }
+        case /* BooleanIs */ 4:
+            {
+                matchResult = 4;
+                break;
+            }
+        case /* UnmodelledCondition */ 6:
+            {
+                matchResult = 5;
+                break;
+            }
+        default:
+            matchResult = 0;
+    }
+    switch(matchResult){
+        case 0:
+            return (0, _FormSpec.ClinicalPathway_FieldEvaluator_InSet)(canonValues);
+        case 1:
+            return (0, _FormSpec.ClinicalPathway_FieldEvaluator_ContainsAll)(canonValues);
+        case 2:
+            return (0, _FormSpec.ClinicalPathway_FieldEvaluator_NotInSet)(canonValues);
+        case 3:
+            {
+                const _arg = cmp;
+                switch(_arg.tag){
+                    case /* NotEqual */ 3:
+                        return (0, _FormSpec.ClinicalPathway_FieldEvaluator_NotEquals)();
+                    case /* Greater */ 5:
+                        return (0, _FormSpec.ClinicalPathway_FieldEvaluator_GreaterThan)();
+                    case /* GreaterOrEqual */ 4:
+                        return (0, _FormSpec.ClinicalPathway_FieldEvaluator_GreaterOrEqual)();
+                    case /* Less */ 0:
+                        return (0, _FormSpec.ClinicalPathway_FieldEvaluator_LessThan)();
+                    case /* LessOrEqual */ 1:
+                        return (0, _FormSpec.ClinicalPathway_FieldEvaluator_LessOrEqual)();
+                    default:
+                        return (0, _FormSpec.ClinicalPathway_FieldEvaluator_Equals)();
+                }
+            }
+        case 4:
+            return (0, _FormSpec.ClinicalPathway_FieldEvaluator_Equals)();
+        default:
+            throw new Error(`CoreMRPathwayMapper: unmodelled condition \`${test.fields[0]} ${test.fields[1]}\` reached the mapper`);
+    }
+}
+function convertTiming(timing) {
+    switch(timing.tag){
+        case /* OnLock */ 1:
+            return (0, _FormSpec.ClinicalPathway_TriggerTiming_OnFormSubmit)();
+        case /* OnFirstOpen */ 2:
+            return (0, _FormSpec.ClinicalPathway_TriggerTiming_OnFormLoad)();
+        case /* UnrecognisedTiming */ 3:
+            throw new Error(`CoreMRPathwayMapper: event \`${timing.fields[0]}\` is not modelled — \`refusalFor\` refuses it first`);
+        default:
+            return (0, _FormSpec.ClinicalPathway_TriggerTiming_OnFormSave)();
+    }
+}
+function convertPriority(_arg) {
+    const p = _arg.fields[0] | 0;
+    switch(p){
+        case 1:
+            return (0, _FormSpec.ClinicalPathway_TaskPriority_High)();
+        case 2:
+            return (0, _FormSpec.ClinicalPathway_TaskPriority_Medium)();
+        case 3:
+            return (0, _FormSpec.ClinicalPathway_TaskPriority_Low)();
+        default:
+            return (0, _FormSpec.ClinicalPathway_TaskPriority_Stated)(p);
+    }
+}
+function parseDueDate(stated) {
+    const m = (0, _RegExp.match)(/^\+\s*(\d+)\s*(day|days|week|weeks)$/gu, stated.trim().toLowerCase());
+    const matchValue = stated.trim().toLowerCase();
+    switch(matchValue){
+        case "today":
+            return (0, _FormSpec.ClinicalPathway_DueDate_Today)();
+        case "tomorrow":
+            return (0, _FormSpec.ClinicalPathway_DueDate_Tomorrow)();
+        default:
+            if (m != null) {
+                const n = (0, _Int32.parse)(m[1] || "", 511, false, 32) | 0;
+                return (0, _FormSpec.ClinicalPathway_DueDate_DaysFromNow)((m[2] || "").startsWith("week") ? 7 * n : n);
+            } else {
+                return (0, _FormSpec.ClinicalPathway_DueDate_AsStated)(stated);
+            }
+    }
+}
+function requiredDue(what, stated) {
+    if (stated == null) {
+        throw new Error(`CoreMRPathwayMapper: ${what} states no date — none is invented`);
+    } else {
+        return parseDueDate((0, _Option.value)(stated));
+    }
+}
+function convertCondition(items, cond, itemFieldKeyMap) {
+    let fieldKey;
+    const matchValue = (0, _Option.bind)((item)=>(0, _Map.tryFind)(item, itemFieldKeyMap), cond.SourceItem);
+    if (matchValue == null) {
+        throw new Error((0, _String.toText)((0, _String.interpolate)("CoreMRPathwayMapper: condition on item %A%P() is not a field — `nonFieldRefusal` refuses it first", [
+            cond.SourceItem
+        ])));
+    } else {
+        fieldKey = (0, _Option.value)(matchValue);
+    }
+    const values = textsOf(items, cond)[1];
+    const evaluator = convertOperator(cond.Test, values);
+    const canonicalize = _Helpers.Helpers_canonicalizeFieldKey;
+    let condValue;
+    const matchValue_1 = cond.Test;
+    switch(matchValue_1.tag){
+        case /* AnyChosen */ 0:
+        case /* AllChosen */ 1:
+        case /* NoneChosen */ 2:
+            {
+                condValue = (0, _FormSpec.Shared_ConditionValue_Multiple)((0, _Set.ofList)((0, _List.map)(canonicalize, values), {
+                    Compare: _Util.comparePrimitives
+                }));
+                break;
+            }
+        default:
+            condValue = (0, _List.isEmpty)(values) ? (0, _FormSpec.Shared_ConditionValue_Single)("") : (0, _FormSpec.Shared_ConditionValue_Single)(canonicalize((0, _List.head)(values)));
+    }
+    const matchValue_2 = cond.Test;
+    let matchResult;
+    if (matchValue_2.tag === /* VitalIs */ 3) {
+        switch(matchValue_2.fields[0].tag){
+            case /* SystolicBP */ 0:
+                {
+                    matchResult = 0;
+                    break;
+                }
+            case /* DiastolicBP */ 1:
+                {
+                    matchResult = 1;
+                    break;
+                }
+            default:
+                matchResult = 2;
+        }
+    } else {
+        matchResult = 2;
+    }
+    switch(matchResult){
+        case 0:
+            return (0, _FormSpec.ClinicalPathway_TransitionCondition_PluginPropertyCondition)(fieldKey, new _FormSpec.Shared_PluginPropertyKey(stableGuid("bp_systolic")), evaluator, condValue);
+        case 1:
+            return (0, _FormSpec.ClinicalPathway_TransitionCondition_PluginPropertyCondition)(fieldKey, new _FormSpec.Shared_PluginPropertyKey(stableGuid("bp_diastolic")), evaluator, condValue);
+        default:
+            return (0, _FormSpec.ClinicalPathway_TransitionCondition_FieldCondition)(fieldKey, evaluator, condValue);
+    }
+}
+function combineConditions(items, conditions, itemFieldKeyMap) {
+    if (!(0, _List.isEmpty)(conditions)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(conditions))) {
+            return convertCondition(items, (0, _List.head)(conditions), itemFieldKeyMap);
+        } else {
+            const ops = (0, _List.map)((c)=>{
+                const matchValue = c.Join;
+                if (matchValue == null) {
+                    throw new Error("CoreMRPathwayMapper: a later condition states no join — the release cannot say how it combines");
+                } else {
+                    switch((0, _Option.value)(matchValue).tag){
+                        case /* Or */ 1:
+                            return (0, _FormSpec.ClinicalPathway_LogicalOp_Or)();
+                        case /* UnrecognisedJoin */ 2:
+                            {
+                                const j = (0, _Option.value)(matchValue).fields[0];
+                                throw new Error(`CoreMRPathwayMapper: join \`${j}\` is not modelled — \`refusalFor\` refuses it first`);
+                            }
+                        default:
+                            return (0, _FormSpec.ClinicalPathway_LogicalOp_And)();
+                    }
+                }
+            }, (0, _List.tail)(conditions));
+            const matchValue_1 = (0, _Seq2.List_distinct)(ops, {
+                Equals: _Util.equals,
+                GetHashCode: _Util.safeHash
+            });
+            let matchResult, op;
+            if (!(0, _List.isEmpty)(matchValue_1)) {
+                if ((0, _List.isEmpty)((0, _List.tail)(matchValue_1))) {
+                    matchResult = 0;
+                    op = (0, _List.head)(matchValue_1);
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return (0, _FormSpec.ClinicalPathway_TransitionCondition_CompositeCondition)(op, (0, _List.map)((c_1)=>convertCondition(items, c_1, itemFieldKeyMap), conditions));
+                default:
+                    {
+                        const list_3 = (0, _List.zip)(ops, (0, _List.tail)(conditions));
+                        return (0, _List.fold)((acc, tupledArg)=>(0, _FormSpec.ClinicalPathway_TransitionCondition_CompositeCondition)(tupledArg[0], (0, _List.ofArray)([
+                                acc,
+                                convertCondition(items, tupledArg[1], itemFieldKeyMap)
+                            ])), convertCondition(items, (0, _List.head)(conditions), itemFieldKeyMap), list_3);
+                    }
+            }
+        }
+    } else {
+        return (0, _FormSpec.ClinicalPathway_TransitionCondition_Always)();
+    }
+}
+function kindWord(a) {
+    switch(a.tag){
+        case /* Alert */ 2:
+            return "alert";
+        case /* Problem */ 3:
+            return "problem";
+        case /* Medset */ 4:
+            return "medset";
+        case /* StandingOrder */ 1:
+            if (a.fields[1].tag === /* Treatment */ 1) {
+                return "treatment";
+            } else {
+                return "recurring_task";
+            }
+        case /* ChangeGroups */ 5:
+            return "groups";
+        default:
+            return "task";
+    }
+}
+function nameOf(r) {
+    return (0, _Option.defaultArg)(r.Name, "");
+}
+function modelledActions(t) {
+    return (0, _List.map)((a)=>{
+        const matchValue = a.Read;
+        if (matchValue.tag === /* Unmodelled */ 1) {
+            throw new Error(`CoreMRPathwayMapper: action ${a.ActionId} (\`${matchValue.fields[0]}\`) is unmodelled (${matchValue.fields[1]}) — \`refusalFor\` refuses it first`);
+        } else {
+            return matchValue.fields[0];
+        }
+    }, t.Actions);
+}
+function standingOf(cadence) {
+    if (cadence.tag === /* Every */ 1) {
+        const until = cadence.fields[1];
+        return new _FormSpec.ClinicalPathway_StandingSchedule((0, _FormSpec.ClinicalPathway_Cadence_Every)(cadence.fields[0], until), parseDueDate(until));
+    } else {
+        const schedule = cadence.fields[0];
+        return new _FormSpec.ClinicalPathway_StandingSchedule((0, _FormSpec.ClinicalPathway_Cadence_OnSchedule)(schedule.Id, schedule.Name), (0, _Option.map)(parseDueDate, cadence.fields[1]));
+    }
+}
+function taskOf(task, standing) {
+    return (0, _FormSpec.ClinicalPathway_ActionInfo_Task)(new _FormSpec.ClinicalPathway_TaskAction(task.Category.Id, nameOf(task.Category), task.Description, convertPriority(task.Priority), requiredDue("a task", task.Due), undefined, standing));
+}
+function convertAction(action) {
+    switch(action.tag){
+        case /* OneOffTask */ 0:
+            {
+                const task = action.fields[0];
+                return taskOf(task, undefined);
+            }
+        case /* StandingOrder */ 1:
+            if (action.fields[1].tag === /* Treatment */ 1) {
+                const cadence_1 = action.fields[0];
+                const treatment = action.fields[1].fields[0];
+                return (0, _FormSpec.ClinicalPathway_ActionInfo_Treatment)(new _FormSpec.ClinicalPathway_TreatmentAction(treatment.Treatment.Id, treatment.Treatment.Name, (0, _Option.map)((r)=>r.Id, treatment.Provider), treatment.Instructions, parseDueDate(treatment.Start), standingOf(cadence_1), undefined, undefined, undefined));
+            } else {
+                const cadence = action.fields[0];
+                const task_1 = action.fields[1].fields[0];
+                return taskOf(task_1, standingOf(cadence));
+            }
+        case /* Medset */ 4:
+            {
+                const medset = action.fields[0];
+                return (0, _FormSpec.ClinicalPathway_ActionInfo_Medset)(new _FormSpec.ClinicalPathway_MedsetAction(medset.Medset.Id, nameOf(medset.Medset), (0, _Option.map)((r_1)=>r_1.Id, medset.Prescriber), (0, _Option.map)((r_2)=>r_2.Id, medset.Pharmacy), requiredDue("a medset", medset.Start)));
+            }
+        case /* Problem */ 3:
+            {
+                const problem = action.fields[0];
+                return (0, _FormSpec.ClinicalPathway_ActionInfo_Problem)(new _FormSpec.ClinicalPathway_ProblemAction(problem.Problem.Id, problem.Problem.Name, undefined, undefined, (0, _FormSpec.ClinicalPathway_ProblemStatus_Active)(), undefined, problem.Chronic, problem.Severity, problem.Inflammation));
+            }
+        case /* ChangeGroups */ 5:
+            {
+                const change = action.fields[0];
+                const patternInput = change.tag === /* RemoveFrom */ 1 ? [
+                    (0, _FormSpec.ClinicalPathway_GroupChange_RemoveFromGroups)(),
+                    change.fields[0]
+                ] : [
+                    (0, _FormSpec.ClinicalPathway_GroupChange_AddToGroups)(),
+                    change.fields[0]
+                ];
+                return (0, _FormSpec.ClinicalPathway_ActionInfo_ChangeGroups)(new _FormSpec.ClinicalPathway_GroupChangeAction(patternInput[0], (0, _List.map)((r_3)=>new _FormSpec.ClinicalPathway_GroupRef(r_3.Id, r_3.Name), (0, _FormTemplate.NonEmpty_toList)(patternInput[1]))));
+            }
+        default:
+            {
+                const category = action.fields[0];
+                const categoryName = nameOf(category);
+                return (0, _FormSpec.ClinicalPathway_ActionInfo_Alert)(new _FormSpec.ClinicalPathway_AlertAction(category.Id, categoryName, categoryName, undefined, undefined));
+            }
+    }
+}
+function generateEvaluationLabel(trigger, items) {
+    let item_1, item_2;
+    let fieldLabel;
+    const matchValue = trigger.Conditions;
+    if (!(0, _List.isEmpty)(matchValue)) {
+        const head = (0, _List.head)(matchValue);
+        const matchValue_1 = (0, _Option.bind)((id)=>(0, _List.tryFind)((i)=>i.ItemId === id, items), head.SourceItem);
+        if (matchValue_1 == null) {
+            throw new Error((0, _String.toText)((0, _String.interpolate)("CoreMRPathwayMapper: trigger %P() reads item %A%P(), not on this form — refused first", [
+                trigger.TriggerId,
+                head.SourceItem
+            ])));
+        } else {
+            fieldLabel = (0, _String.isNullOrEmpty)((0, _Option.value)(matchValue_1).Text) ? (item_1 = (0, _Option.value)(matchValue_1), "(no text)") : (item_2 = (0, _Option.value)(matchValue_1), item_2.Text.length > 50 ? (0, _String.substring)(item_2.Text, 0, 47) + "..." : item_2.Text);
+        }
+    } else {
+        throw new Error(`CoreMRPathwayMapper: trigger ${trigger.TriggerId} states no condition — \`liveTriggers\` keeps none such`);
+    }
+    const matchValue_2 = trigger.Conditions;
+    if (!(0, _List.isEmpty)(matchValue_2)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(matchValue_2))) {
+            const matchValue_3 = textsOf(items, (0, _List.head)(matchValue_2));
+            let matchResult, v, vals_2, vals_3, v_1, v_2, v_3, v_4, v_5, v_6, vals_4, op;
+            switch(matchValue_3[0]){
+                case "any":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 0;
+                                v = (0, _List.head)(matchValue_3[1]);
+                            } else if ((0, _List.length)(matchValue_3[1]) <= 3) {
+                                matchResult = 1;
+                                vals_2 = matchValue_3[1];
+                            } else {
+                                matchResult = 2;
+                                vals_3 = matchValue_3[1];
+                            }
+                        } else if ((0, _List.length)(matchValue_3[1]) <= 3) {
+                            matchResult = 1;
+                            vals_2 = matchValue_3[1];
+                        } else {
+                            matchResult = 2;
+                            vals_3 = matchValue_3[1];
+                        }
+                        break;
+                    }
+                case "equals":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 3;
+                                v_1 = (0, _List.head)(matchValue_3[1]);
+                            } else {
+                                matchResult = 10;
+                                op = matchValue_3[0];
+                            }
+                        } else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                        break;
+                    }
+                case "not_equals":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 4;
+                                v_2 = (0, _List.head)(matchValue_3[1]);
+                            } else {
+                                matchResult = 10;
+                                op = matchValue_3[0];
+                            }
+                        } else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                        break;
+                    }
+                case "greater_equals":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 5;
+                                v_3 = (0, _List.head)(matchValue_3[1]);
+                            } else {
+                                matchResult = 10;
+                                op = matchValue_3[0];
+                            }
+                        } else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                        break;
+                    }
+                case "greater":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 6;
+                                v_4 = (0, _List.head)(matchValue_3[1]);
+                            } else {
+                                matchResult = 10;
+                                op = matchValue_3[0];
+                            }
+                        } else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                        break;
+                    }
+                case "less_equals":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 7;
+                                v_5 = (0, _List.head)(matchValue_3[1]);
+                            } else {
+                                matchResult = 10;
+                                op = matchValue_3[0];
+                            }
+                        } else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                        break;
+                    }
+                case "less":
+                    {
+                        if (!(0, _List.isEmpty)(matchValue_3[1])) {
+                            if ((0, _List.isEmpty)((0, _List.tail)(matchValue_3[1]))) {
+                                matchResult = 8;
+                                v_6 = (0, _List.head)(matchValue_3[1]);
+                            } else {
+                                matchResult = 10;
+                                op = matchValue_3[0];
+                            }
+                        } else {
+                            matchResult = 10;
+                            op = matchValue_3[0];
+                        }
+                        break;
+                    }
+                case "all":
+                    {
+                        matchResult = 9;
+                        vals_4 = matchValue_3[1];
+                        break;
+                    }
+                default:
+                    {
+                        matchResult = 10;
+                        op = matchValue_3[0];
+                    }
+            }
+            switch(matchResult){
+                case 0:
+                    return `When ${fieldLabel} = ${v}`;
+                case 1:
+                    return `When ${fieldLabel} is ${(0, _String.join)(" or ", vals_2)}`;
+                case 2:
+                    return `When ${fieldLabel} is any of ${(0, _List.length)(vals_3)} values`;
+                case 3:
+                    return `When ${fieldLabel} = ${v_1}`;
+                case 4:
+                    return `When ${fieldLabel} ≠ ${v_2}`;
+                case 5:
+                    return `When ${fieldLabel} ≥ ${v_3}`;
+                case 6:
+                    return `When ${fieldLabel} > ${v_4}`;
+                case 7:
+                    return `When ${fieldLabel} ≤ ${v_5}`;
+                case 8:
+                    return `When ${fieldLabel} < ${v_6}`;
+                case 9:
+                    return `When ${fieldLabel} has all of: ${(0, _String.join)(", ", vals_4)}`;
+                default:
+                    return `When ${fieldLabel} ${op}`;
+            }
+        } else {
+            return `When ${fieldLabel} (${(0, _List.length)(matchValue_2)} conditions)`;
+        }
+    } else {
+        throw new Error(`CoreMRPathwayMapper: trigger ${trigger.TriggerId} states no condition`);
+    }
+}
+function generateActionLabel(trigger) {
+    let matchValue_1;
+    const matchValue = modelledActions(trigger);
+    if (!(0, _List.isEmpty)(matchValue)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(matchValue))) {
+            let matchResult, category, task, medset, task_1, other;
+            switch((0, _List.head)(matchValue).tag){
+                case /* Alert */ 2:
+                    {
+                        matchResult = 0;
+                        category = (0, _List.head)(matchValue).fields[0];
+                        break;
+                    }
+                case /* OneOffTask */ 0:
+                    {
+                        matchResult = 1;
+                        task = (0, _List.head)(matchValue).fields[0];
+                        break;
+                    }
+                case /* Medset */ 4:
+                    {
+                        matchResult = 2;
+                        medset = (0, _List.head)(matchValue).fields[0];
+                        break;
+                    }
+                case /* Problem */ 3:
+                    {
+                        matchResult = 3;
+                        break;
+                    }
+                case /* StandingOrder */ 1:
+                    {
+                        if ((0, _List.head)(matchValue).fields[1].tag === /* RecurringTask */ 0) {
+                            matchResult = 4;
+                            task_1 = (0, _List.head)(matchValue).fields[1].fields[0];
+                        } else {
+                            matchResult = 5;
+                            other = (0, _List.head)(matchValue);
+                        }
+                        break;
+                    }
+                default:
+                    {
+                        matchResult = 5;
+                        other = (0, _List.head)(matchValue);
+                    }
+            }
+            switch(matchResult){
+                case 0:
+                    return `Create Alert: ${nameOf(category)}`;
+                case 1:
+                    return `Create ${matchValue_1 = task.Priority, matchValue_1.fields[0] === 1 ? "High " : matchValue_1.fields[0] === 3 ? "Low " : ""}Task: ${nameOf(task.Category)}`;
+                case 2:
+                    return `Order Medset: ${nameOf(medset.Medset)}`;
+                case 3:
+                    return "Add to Problem List";
+                case 4:
+                    return `Schedule: ${nameOf(task_1.Category)}`;
+                default:
+                    return `Execute: ${kindWord(other)}`;
+            }
+        } else {
+            const joined = (0, _String.join)(", ", (0, _Seq2.List_distinct)((0, _List.map)(kindWord, matchValue), {
+                Equals: (x, y)=>x === y,
+                GetHashCode: _Util.stringHash
+            }));
+            return `Execute ${(0, _List.length)(matchValue)} actions: ${joined}`;
+        }
+    } else {
+        return "No actions";
+    }
+}
+function pathwayActions(t) {
+    let sourceItem;
+    const matchValue = t.Conditions;
+    if ((0, _List.isEmpty)(matchValue)) {
+        throw new Error(`CoreMRPathwayMapper: trigger ${t.TriggerId} states no condition — \`liveTriggers\` keeps none such`);
+    } else if ((0, _List.head)(matchValue).SourceItem == null) {
+        throw new Error(`CoreMRPathwayMapper: trigger ${t.TriggerId}'s head condition reads no item — \`refusalFor\` refuses it first`);
+    } else {
+        const item = (0, _Option.value)((0, _List.head)(matchValue).SourceItem) | 0;
+        sourceItem = item;
+    }
+    return (0, _List.map)((a)=>{
+        const matchValue_1 = a.Read;
+        if (matchValue_1.tag === /* Unmodelled */ 1) {
+            throw new Error(`CoreMRPathwayMapper: action ${a.ActionId} (\`${matchValue_1.fields[0]}\`) is unmodelled (${matchValue_1.fields[1]}) — \`refusalFor\` refuses it first`);
+        } else {
+            return new _FormSpec.ClinicalPathway_PathwayAction(convertAction(matchValue_1.fields[0]), (0, _FormSpec.ClinicalPathway_ActionOrigin_CoreMRTrigger)(new _FormSpec.ClinicalPathway_CoreMRTriggerRef(t.TriggerId, a.ActionId, sourceItem)));
+        }
+    }, t.Actions);
+}
+function actionStateType(t) {
+    const matchValue = pathwayActions(t);
+    if (!(0, _List.isEmpty)(matchValue)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(matchValue))) {
+            return (0, _FormSpec.ClinicalPathway_StateType_Action)((0, _List.head)(matchValue));
+        } else {
+            return (0, _FormSpec.ClinicalPathway_StateType_CompoundAction)(matchValue);
+        }
+    } else {
+        throw new Error(`CoreMRPathwayMapper: trigger ${t.TriggerId} states no action — \`liveTriggers\` keeps none such`);
+    }
+}
+function convertTriggerToPathway(importedAt, trigger, items, itemFieldKeyMap) {
+    const tid = trigger.TriggerId | 0;
+    const startKey = new _FormSpec.Shared_StateKey(stableGuid(`t${tid}_start`));
+    const evalKey = new _FormSpec.Shared_StateKey(stableGuid(`t${tid}_eval`));
+    const actionKey = new _FormSpec.Shared_StateKey(stableGuid(`t${tid}_action`));
+    const endKey = new _FormSpec.Shared_StateKey(stableGuid(`t${tid}_end`));
+    const evalLabel = generateEvaluationLabel(trigger, items);
+    const actionLabel = generateActionLabel(trigger);
+    const startState = new _FormSpec.ClinicalPathway_StateDefinition(startKey, "Start", 0, (0, _FormSpec.ClinicalPathway_StateType_Evaluation)(new _FormSpec.ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+    const evalState = new _FormSpec.ClinicalPathway_StateDefinition(evalKey, evalLabel, 1, (0, _FormSpec.ClinicalPathway_StateType_Evaluation)(new _FormSpec.ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+    const actionState = new _FormSpec.ClinicalPathway_StateDefinition(actionKey, actionLabel, 2, actionStateType(trigger), undefined);
+    const endState = new _FormSpec.ClinicalPathway_StateDefinition(endKey, "Complete", 3, (0, _FormSpec.ClinicalPathway_StateType_Terminal)(new _FormSpec.ClinicalPathway_TerminalInfo("Complete", "Trigger evaluation complete", undefined)), undefined);
+    const condition = combineConditions(items, trigger.Conditions, itemFieldKeyMap);
+    const transitions = (0, _List.ofArray)([
+        new _FormSpec.ClinicalPathway_TransitionDefinition(new _FormSpec.Shared_TransitionKey(stableGuid(`t${tid}_start_to_eval`)), startKey, evalKey, (0, _FormSpec.ClinicalPathway_TransitionCondition_Always)(), undefined),
+        new _FormSpec.ClinicalPathway_TransitionDefinition(new _FormSpec.Shared_TransitionKey(stableGuid(`t${tid}_eval_to_action`)), evalKey, actionKey, condition, 0),
+        new _FormSpec.ClinicalPathway_TransitionDefinition(new _FormSpec.Shared_TransitionKey(stableGuid(`t${tid}_action_to_end`)), actionKey, endKey, (0, _FormSpec.ClinicalPathway_TransitionCondition_Always)(), undefined)
+    ]);
+    return new _FormSpec.ClinicalPathway_ClinicalPathwaySpec(`item_trigger_${tid}`, `Trigger ${tid}: ${actionLabel}`, "1.0.0", "CoreMR Conduit - Item Trigger", (0, _FormSpec.ClinicalPathway_PathwayExecutionMode_TriggerBased)(new _FormSpec.ClinicalPathway_TriggerBasedConfig(convertTiming(trigger.Timing), true)), startKey, (0, _List.ofArray)([
+        startState,
+        evalState,
+        actionState,
+        endState
+    ]), transitions, (0, _List.empty)(), (0, _List.empty)(), importedAt, undefined, undefined, 1);
+}
+function liveTriggers(form, reads) {
+    switch(reads.tag){
+        case /* Stated */ 0:
+            {
+                const byId = (0, _List.sortBy)((t)=>t.TriggerId, reads.fields[0], {
+                    Compare: _Util.comparePrimitives
+                });
+                return (0, _List.filter)((t_3)=>{
+                    if (t_3.Enabled) {
+                        return !(0, _List.isEmpty)(t_3.Actions);
+                    } else {
+                        return false;
+                    }
+                }, (0, _Seq2.List_distinctBy)((t_2)=>t_2.TriggerId, (0, _List.collect)((item)=>(0, _List.filter)((t_1)=>(0, _List.exists)((c)=>(0, _Util.equals)(c.SourceItem, item.ItemId), t_1.Conditions), byId), form.Items), {
+                    Equals: (x_1, y_1)=>x_1 === y_1,
+                    GetHashCode: _Util.numberHash
+                }));
+            }
+        default:
+            return (0, _List.empty)();
+    }
+}
+function refusalFor(form, reads) {
+    let arg, arg_1;
+    const live = liveTriggers(form, reads);
+    const kinds = (0, _List.sort)((0, _Seq2.List_distinct)((0, _List.collect)((t)=>(0, _List.choose)((a)=>{
+            const matchValue = a.Read;
+            if (matchValue.tag === /* Modelled */ 0) {
+                return undefined;
+            } else {
+                const kind = matchValue.fields[0];
+                return kind.toLowerCase();
+            }
+        }, t.Actions), live), {
+        Equals: (x, y)=>x === y,
+        GetHashCode: _Util.stringHash
+    }), {
+        Compare: _Util.comparePrimitives
+    });
+    const conditions = (0, _List.sort)((0, _Seq2.List_distinct)((0, _List.append)(reads.tag === /* NotInRelease */ 1 ? (0, _List.empty)() : reads.tag === /* NotReadYet */ 2 ? (0, _List.empty)() : (0, _List.map)((t_3)=>`trigger ${t_3.TriggerId} reads no item`, (0, _List.filter)((t_2)=>(0, _List.exists)((c)=>c.SourceItem == null, t_2.Conditions), (0, _List.filter)((t_1)=>{
+        if (t_1.Enabled) {
+            return !(0, _List.isEmpty)(t_1.Actions);
+        } else {
+            return false;
+        }
+    }, reads.fields[0]))), (0, _List.collect)((t_4)=>(0, _Seq.toList)((0, _Seq.delay)(()=>(0, _Seq.append)((0, _Seq.collect)((c_1)=>{
+                let matchValue_1;
+                return (0, _Seq.append)((matchValue_1 = c_1.Test, matchValue_1.tag === /* UnmodelledCondition */ 6 ? (0, _Seq.singleton)(`${matchValue_1.fields[0]} ${matchValue_1.fields[1]}`) : (0, _Seq.empty)()), (0, _Seq.delay)(()=>{
+                    const matchValue_2 = c_1.Join;
+                    let matchResult, j;
+                    if (matchValue_2 != null) {
+                        if ((0, _Option.value)(matchValue_2).tag === /* UnrecognisedJoin */ 2) {
+                            matchResult = 0;
+                            j = (0, _Option.value)(matchValue_2).fields[0];
+                        } else {
+                            matchResult = 1;
+                        }
+                    } else {
+                        matchResult = 1;
+                    }
+                    switch(matchResult){
+                        case 0:
+                            return (0, _Seq.singleton)(`join ${j}`);
+                        default:
+                            {
+                                return (0, _Seq.empty)();
+                            }
+                    }
+                }));
+            }, t_4.Conditions), (0, _Seq.delay)(()=>{
+                const matchValue_3 = t_4.Timing;
+                if (matchValue_3.tag === /* UnrecognisedTiming */ 3) {
+                    return (0, _Seq.singleton)(`event ${matchValue_3.fields[0]}`);
+                } else {
+                    return (0, _Seq.empty)();
+                }
+            })))), live)), {
+        Equals: (x_2, y_2)=>x_2 === y_2,
+        GetHashCode: _Util.stringHash
+    }), {
+        Compare: _Util.comparePrimitives
+    });
+    if ((0, _List.isEmpty)(kinds)) {
+        if ((0, _List.isEmpty)(conditions)) {
+            return undefined;
+        } else {
+            return arg = (0, _String.join)(", ", conditions), (0, _String.toText)((0, _String.printf)("refused — its triggers state what the CoreMR trigger domain cannot evaluate yet: %s. Nothing is imported rather than a pathway that cannot be evaluated."))(arg);
+        }
+    } else {
+        return arg_1 = (0, _String.join)(", ", kinds), (0, _String.toText)((0, _String.printf)("refused — its triggers use action kinds the 5.5.0+10245 converter does not model faithfully yet: %s. Nothing is imported rather than a pathway with invented actions."))(arg_1);
+    }
+}
+function convertFormTriggersToPathway(importedAt, form, reads, itemFieldKeyMap) {
+    let arg;
+    const matchValue = refusalFor(form, reads);
+    if (matchValue == null) {} else {
+        throw new Error((0, _Option.value)(matchValue));
+    }
+    const nonField = (0, _Seq2.List_distinct)((0, _List.collect)((t)=>(0, _List.choose)((c)=>{
+            const matchValue_1 = c.SourceItem;
+            let matchResult, item_1;
+            if (matchValue_1 != null) {
+                if (!(0, _Map.FSharpMap__ContainsKey)(itemFieldKeyMap, (0, _Option.value)(matchValue_1))) {
+                    matchResult = 0;
+                    item_1 = (0, _Option.value)(matchValue_1);
+                } else {
+                    matchResult = 1;
+                }
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return `trigger ${t.TriggerId} reads item ${item_1}`;
+                default:
+                    return undefined;
+            }
+        }, t.Conditions), liveTriggers(form, reads)), {
+        Equals: (x, y)=>x === y,
+        GetHashCode: _Util.stringHash
+    });
+    if ((0, _List.isEmpty)(nonField)) {} else {
+        throw new Error((arg = (0, _String.join)(", ", nonField), (0, _String.toText)((0, _String.printf)("refused — its triggers read items that are not fields of this blueprint, so their branches could never fire: %s. Nothing is imported rather than a pathway with branches that can never fire."))(arg)));
+    }
+    const matchValue_2 = liveTriggers(form, reads);
+    if (!(0, _List.isEmpty)(matchValue_2)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(matchValue_2))) {
+            return convertTriggerToPathway(importedAt, (0, _List.head)(matchValue_2), form.Items, itemFieldKeyMap);
+        } else {
+            const pathwayId = `form_${form.FormId}_pathway`;
+            const startKey = new _FormSpec.Shared_StateKey(stableGuid(`${pathwayId}_start`));
+            let allStates = (0, _List.singleton)(new _FormSpec.ClinicalPathway_StateDefinition(startKey, "Start", 0, (0, _FormSpec.ClinicalPathway_StateType_Evaluation)(new _FormSpec.ClinicalPathway_EvaluationInfo("", undefined)), undefined));
+            let allTransitions = (0, _List.empty)();
+            const enumerator = (0, _Util.getEnumerator)((0, _List.indexed)(matchValue_2));
+            try {
+                while(enumerator["System.Collections.IEnumerator.MoveNext"]()){
+                    const forLoopVar = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const trigger = forLoopVar[1];
+                    const idx = forLoopVar[0] | 0;
+                    const tid = trigger.TriggerId | 0;
+                    const evalKey = new _FormSpec.Shared_StateKey(stableGuid(`${pathwayId}_eval_${tid}`));
+                    const actionKey = new _FormSpec.Shared_StateKey(stableGuid(`${pathwayId}_action_${tid}`));
+                    const endKey = new _FormSpec.Shared_StateKey(stableGuid(`${pathwayId}_end_${tid}`));
+                    const evalState = new _FormSpec.ClinicalPathway_StateDefinition(evalKey, generateEvaluationLabel(trigger, form.Items), idx * 3 + 1, (0, _FormSpec.ClinicalPathway_StateType_Evaluation)(new _FormSpec.ClinicalPathway_EvaluationInfo("", undefined)), undefined);
+                    const actionState = new _FormSpec.ClinicalPathway_StateDefinition(actionKey, generateActionLabel(trigger), idx * 3 + 2, actionStateType(trigger), undefined);
+                    const endState = new _FormSpec.ClinicalPathway_StateDefinition(endKey, "Complete", idx * 3 + 3, (0, _FormSpec.ClinicalPathway_StateType_Terminal)(new _FormSpec.ClinicalPathway_TerminalInfo("Complete", `Trigger ${tid} complete`, undefined)), undefined);
+                    const condition = combineConditions(form.Items, trigger.Conditions, itemFieldKeyMap);
+                    const transitions = (0, _List.ofArray)([
+                        new _FormSpec.ClinicalPathway_TransitionDefinition(new _FormSpec.Shared_TransitionKey(stableGuid(`${pathwayId}_start_to_eval_${tid}`)), startKey, evalKey, (0, _FormSpec.ClinicalPathway_TransitionCondition_Always)(), idx),
+                        new _FormSpec.ClinicalPathway_TransitionDefinition(new _FormSpec.Shared_TransitionKey(stableGuid(`${pathwayId}_eval_to_action_${tid}`)), evalKey, actionKey, condition, idx),
+                        new _FormSpec.ClinicalPathway_TransitionDefinition(new _FormSpec.Shared_TransitionKey(stableGuid(`${pathwayId}_action_to_end_${tid}`)), actionKey, endKey, (0, _FormSpec.ClinicalPathway_TransitionCondition_Always)(), undefined)
+                    ]);
+                    allStates = (0, _List.append)(allStates, (0, _List.ofArray)([
+                        evalState,
+                        actionState,
+                        endState
+                    ]));
+                    allTransitions = (0, _List.append)(allTransitions, transitions);
+                }
+            } finally{
+                (0, _Util.disposeSafe)(enumerator);
+            }
+            return new _FormSpec.ClinicalPathway_ClinicalPathwaySpec(pathwayId, `${form.Name} - Clinical Pathway`, "1.0.0", "CoreMR Conduit - Unified Item Triggers", (0, _FormSpec.ClinicalPathway_PathwayExecutionMode_MultiPathway)(new _FormSpec.ClinicalPathway_MultiPathwayConfig((0, _FormSpec.ClinicalPathway_CombinationStrategy_AllMatching)(), (0, _FormSpec.ClinicalPathway_ConflictResolution_CombineActions)(), undefined)), startKey, allStates, allTransitions, (0, _List.empty)(), (0, _List.empty)(), importedAt, undefined, undefined, 1);
+        }
+    } else {
+        return undefined;
+    }
+} //# sourceMappingURL=CoreMRPathwayMapper.ts.map
+
+//# sourceMappingURL=CoreMRPathwayMapper.js.map