@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/Helpers.js

@@ -0,0 +1,732 @@
+"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 Converters_fieldKeyToString () {
+        return Converters_fieldKeyToString;
+    },
+    get Converters_stringToFieldKey () {
+        return Converters_stringToFieldKey;
+    },
+    get Helpers_FieldFinders_findFormFieldInFormByLabelString () {
+        return Helpers_FieldFinders_findFormFieldInFormByLabelString;
+    },
+    get Helpers_FieldFinders_findFormFieldInStepByLabelString () {
+        return Helpers_FieldFinders_findFormFieldInStepByLabelString;
+    },
+    get Helpers_FieldFinders_findUniqueFormFieldInFormByLabelString () {
+        return Helpers_FieldFinders_findUniqueFormFieldInFormByLabelString;
+    },
+    get Helpers_FieldFinders_findUniqueFormFieldInStepByLabelString () {
+        return Helpers_FieldFinders_findUniqueFormFieldInStepByLabelString;
+    },
+    get Helpers_FieldFinders_getAllFieldNames () {
+        return Helpers_FieldFinders_getAllFieldNames;
+    },
+    get Helpers_FieldFinders_getAllStepNames () {
+        return Helpers_FieldFinders_getAllStepNames;
+    },
+    get Helpers_FieldFinders_tryFindFieldByKey () {
+        return Helpers_FieldFinders_tryFindFieldByKey;
+    },
+    get Helpers_FieldFinders_tryFindFieldInSpec () {
+        return Helpers_FieldFinders_tryFindFieldInSpec;
+    },
+    get Helpers_FieldFinders_tryFindFormStepByStepNumber () {
+        return Helpers_FieldFinders_tryFindFormStepByStepNumber;
+    },
+    get Helpers_FieldTypeUtils_fieldTypesMatchByCaseName () {
+        return Helpers_FieldTypeUtils_fieldTypesMatchByCaseName;
+    },
+    get Helpers_FieldTypeUtils_getFieldTypeName () {
+        return Helpers_FieldTypeUtils_getFieldTypeName;
+    },
+    get Helpers_FormSpecMutators_addFormFieldToStep () {
+        return Helpers_FormSpecMutators_addFormFieldToStep;
+    },
+    get Helpers_FormSpecMutators_insertFormFieldToStepAt () {
+        return Helpers_FormSpecMutators_insertFormFieldToStepAt;
+    },
+    get Helpers_FormSpecMutators_moveFieldByKeyToPositionInFormStepSpec () {
+        return Helpers_FormSpecMutators_moveFieldByKeyToPositionInFormStepSpec;
+    },
+    get Helpers_FormSpecMutators_moveFormFieldDownInFormSpec () {
+        return Helpers_FormSpecMutators_moveFormFieldDownInFormSpec;
+    },
+    get Helpers_FormSpecMutators_moveFormFieldUpInFormSpec () {
+        return Helpers_FormSpecMutators_moveFormFieldUpInFormSpec;
+    },
+    get Helpers_FormSpecMutators_moveFormStepDownInFormSpec () {
+        return Helpers_FormSpecMutators_moveFormStepDownInFormSpec;
+    },
+    get Helpers_FormSpecMutators_moveFormStepUpInFormSpec () {
+        return Helpers_FormSpecMutators_moveFormStepUpInFormSpec;
+    },
+    get Helpers_FormSpecMutators_removeFormFieldFromFormSpec () {
+        return Helpers_FormSpecMutators_removeFormFieldFromFormSpec;
+    },
+    get Helpers_FormSpecMutators_removeFormStepFromFormSpec () {
+        return Helpers_FormSpecMutators_removeFormStepFromFormSpec;
+    },
+    get Helpers_FormSpecMutators_updateFormFieldInFormSpecStep () {
+        return Helpers_FormSpecMutators_updateFormFieldInFormSpecStep;
+    },
+    get Helpers_FormSpecMutators_updateFormStepInFormSpec () {
+        return Helpers_FormSpecMutators_updateFormStepInFormSpec;
+    },
+    get Helpers_FormSpecTransformers_flattenSpecSteps () {
+        return Helpers_FormSpecTransformers_flattenSpecSteps;
+    },
+    get Helpers_FormSpecValidators_allStepsHaveFields () {
+        return Helpers_FormSpecValidators_allStepsHaveFields;
+    },
+    get Helpers_FormSpecValidators_hasClinicalPathway () {
+        return Helpers_FormSpecValidators_hasClinicalPathway;
+    },
+    get Helpers_canonicalizeFieldKey () {
+        return Helpers_canonicalizeFieldKey;
+    },
+    get Helpers_findAndUpdateFormField () {
+        return Helpers_findAndUpdateFormField;
+    },
+    get Helpers_findAndUpdateFormFieldInAnyStep () {
+        return Helpers_findAndUpdateFormFieldInAnyStep;
+    },
+    get Helpers_generateDeterministicGuid () {
+        return Helpers_generateDeterministicGuid;
+    },
+    get Helpers_optionsFromSpecField () {
+        return Helpers_optionsFromSpecField;
+    },
+    get Helpers_readManyValue () {
+        return Helpers_readManyValue;
+    },
+    get Helpers_readValue () {
+        return Helpers_readValue;
+    },
+    get Helpers_specFieldOptionsToValueOptions () {
+        return Helpers_specFieldOptionsToValueOptions;
+    },
+    get Helpers_updateFormFieldValue () {
+        return Helpers_updateFormFieldValue;
+    },
+    get Helpers_updateFormValuesWithField () {
+        return Helpers_updateFormValuesWithField;
+    },
+    get Helpers_updateManyFunc () {
+        return Helpers_updateManyFunc;
+    },
+    get Helpers_updateSingleFunc () {
+        return Helpers_updateSingleFunc;
+    }
+});
+const _FormSpec = require("./FormSpec.js");
+const _Guid = require("@fable-org/fable-library-js/Guid.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+const _RegExp = require("@fable-org/fable-library-js/RegExp.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Array = require("@fable-org/fable-library-js/Array.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _Seq2 = require("@fable-org/fable-library-js/Seq2.js");
+const _Seq = require("@fable-org/fable-library-js/Seq.js");
+const _Map = require("@fable-org/fable-library-js/Map.js");
+const _Set = require("@fable-org/fable-library-js/Set.js");
+function Converters_fieldKeyToString(key) {
+    return key.fields[0];
+}
+function Converters_stringToFieldKey(s) {
+    return new _FormSpec.Shared_FieldKey((0, _Guid.parse)(s));
+}
+function Helpers_canonicalizeFieldKey(input) {
+    if ((0, _String.isNullOrWhiteSpace)(input)) {
+        return "field_unknown";
+    } else {
+        const s_5 = (0, _String.trim)((0, _RegExp.replace)((0, _RegExp.replace)((0, _RegExp.replace)((0, _String.trimEnd)(input.toLowerCase().trim(), ":"), "[\\s\\-]+", "_"), "[^a-z0-9_]", ""), "_+", "_"), "_");
+        if ((0, _String.isNullOrEmpty)(s_5)) {
+            return "field_unknown";
+        } else {
+            return s_5;
+        }
+    }
+}
+function Helpers_generateDeterministicGuid(fieldName) {
+    const hash = (0, _Util.stringHash)(Helpers_canonicalizeFieldKey(fieldName)) | 0;
+    const bytes = (0, _Array.fill)(new Array(16), 0, 16, 0);
+    for(let i = 0; i <= 3; i++){
+        (0, _Array.setItem)(bytes, i, hash >> i * 8 & 0xFF);
+        (0, _Array.setItem)(bytes, i + 4, hash >> 1 >> i * 8 & 0xFF);
+        (0, _Array.setItem)(bytes, i + 8, hash >> 2 >> i * 8 & 0xFF);
+        (0, _Array.setItem)(bytes, i + 12, hash >> 3 >> i * 8 & 0xFF);
+    }
+    (0, _Array.setItem)(bytes, 6, (0, _Array.item)(6, bytes) & 15 | 64);
+    (0, _Array.setItem)(bytes, 8, (0, _Array.item)(8, bytes) & 63 | 128);
+    return (0, _Guid.arrayToGuid)(bytes);
+}
+function Helpers_FieldFinders_findFormFieldInStepByLabelString(label, stepNumber, formSpec) {
+    return (0, _Option.defaultArg)((0, _Option.map)((step_1)=>(0, _List.map)((field_1)=>[
+                step_1,
+                field_1
+            ], (0, _List.filter)((field)=>field.Label === label, step_1.Fields)), (0, _List.tryFind)((step)=>step.StepOrder === stepNumber, formSpec.Steps)), (0, _List.empty)());
+}
+function Helpers_FieldFinders_findFormFieldInFormByLabelString(label, formSpec) {
+    return (0, _List.collect)((step)=>(0, _List.map)((field_1)=>[
+                step,
+                field_1
+            ], (0, _List.filter)((field)=>field.Label === label, step.Fields)), formSpec.Steps);
+}
+function Helpers_FieldFinders_findUniqueFormFieldInStepByLabelString(label, stepNumber, formSpec) {
+    const fields = Helpers_FieldFinders_findFormFieldInStepByLabelString(label, stepNumber, formSpec);
+    if (!(0, _List.isEmpty)(fields)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(fields))) {
+            return (0, _Result.FSharpResult$2_Ok)((0, _List.head)(fields));
+        } else {
+            return (0, _Result.FSharpResult$2_Error)(`Multiple fields found with label '${label}' in step ${stepNumber}`);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)(`No field found with label '${label}' in step ${stepNumber}`);
+    }
+}
+function Helpers_FieldFinders_findUniqueFormFieldInFormByLabelString(label, formSpec) {
+    const fields = Helpers_FieldFinders_findFormFieldInFormByLabelString(label, formSpec);
+    if (!(0, _List.isEmpty)(fields)) {
+        if ((0, _List.isEmpty)((0, _List.tail)(fields))) {
+            return (0, _Result.FSharpResult$2_Ok)((0, _List.head)(fields));
+        } else {
+            return (0, _Result.FSharpResult$2_Error)(`Multiple fields found with label '${label}' across all steps`);
+        }
+    } else {
+        return (0, _Result.FSharpResult$2_Error)(`No field found with label '${label}' in any step`);
+    }
+}
+function Helpers_FieldFinders_tryFindFieldByKey(fieldKey, formSpec) {
+    return (0, _List.tryFind)((field)=>(0, _Util.equals)(field.FieldKey, fieldKey), (0, _List.collect)((step)=>step.Fields, formSpec.Steps));
+}
+function Helpers_FieldFinders_tryFindFormStepByStepNumber(stepNumber, formSpec) {
+    return (0, _List.tryFind)((step)=>step.StepOrder === stepNumber, formSpec.Steps);
+}
+function Helpers_FieldFinders_tryFindFieldInSpec(fieldNumber, stepNumber, formSpec) {
+    const stepOpt = (0, _List.tryFind)((step)=>step.StepOrder === stepNumber, formSpec.Steps);
+    if (stepOpt != null) {
+        const fieldOpt = (0, _List.tryFind)((field)=>field.FieldOrder === fieldNumber, (0, _Option.value)(stepOpt).Fields);
+        if (fieldOpt != null) {
+            return (0, _Option.value)(fieldOpt);
+        } else {
+            return undefined;
+        }
+    } else {
+        return undefined;
+    }
+}
+function Helpers_FieldFinders_getAllFieldNames(formSpec) {
+    return (0, _Seq2.List_distinct)((0, _List.map)((field)=>field.Label, (0, _List.collect)((step)=>step.Fields, formSpec.Steps)), {
+        Equals: (x, y)=>x === y,
+        GetHashCode: _Util.stringHash
+    });
+}
+function Helpers_FieldFinders_getAllStepNames(formSpec) {
+    return (0, _List.map)((step)=>`Step ${step.StepOrder}`, formSpec.Steps);
+}
+function Helpers_FieldTypeUtils_getFieldTypeName(fieldType) {
+    if (fieldType instanceof _FormSpec.Spec_FieldType) {
+        const ft = fieldType;
+        switch(ft.tag){
+            case /* TextArea */ 1:
+                return "TextArea";
+            case /* Email */ 2:
+                return "Email";
+            case /* Password */ 3:
+                return "Password";
+            case /* Search */ 4:
+                return "Search";
+            case /* Color */ 5:
+                return "Color";
+            case /* Number */ 6:
+                return "Number";
+            case /* Tel */ 7:
+                return "Tel";
+            case /* Date */ 8:
+                return "Date";
+            case /* DateTimeLocal */ 9:
+                return "DateTimeLocal";
+            case /* Time */ 10:
+                return "Time";
+            case /* Checkbox */ 11:
+                return "Checkbox";
+            case /* Radio */ 12:
+                return "Radio";
+            case /* SingleChoice */ 13:
+                return "SingleChoice";
+            case /* Dropdown */ 14:
+                return "Dropdown";
+            case /* MultiChoice */ 15:
+                return "MultiChoice";
+            case /* CheckboxList */ 16:
+                return "CheckboxList";
+            case /* TagList */ 17:
+                return "TagList";
+            case /* TextAutoComplete */ 18:
+                return "TextAutoComplete";
+            case /* Matrix */ 19:
+                return "Matrix";
+            case /* Signature */ 20:
+                return "Signature";
+            case /* Message */ 21:
+                return "Message";
+            case /* PluginField */ 22:
+                return `PluginField(${ft.fields[0].PluginId})`;
+            default:
+                return "Text";
+        }
+    } else {
+        return "Unknown";
+    }
+}
+function Helpers_FieldTypeUtils_fieldTypesMatchByCaseName(fieldType1, fieldType2) {
+    let matchResult, ft1, ft2;
+    if (fieldType1 instanceof _FormSpec.Spec_FieldType) {
+        if (fieldType2 instanceof _FormSpec.Spec_FieldType) {
+            matchResult = 0;
+            ft1 = fieldType1;
+            ft2 = fieldType2;
+        } else {
+            matchResult = 1;
+        }
+    } else {
+        matchResult = 1;
+    }
+    switch(matchResult){
+        case 0:
+            {
+                let matchResult_1;
+                switch(ft1.tag){
+                    case /* Message */ 21:
+                        {
+                            if (ft2.tag === /* Message */ 21) {
+                                matchResult_1 = 0;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* Matrix */ 19:
+                        {
+                            if (ft2.tag === /* Matrix */ 19) {
+                                matchResult_1 = 1;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* SingleChoice */ 13:
+                        {
+                            if (ft2.tag === /* SingleChoice */ 13) {
+                                matchResult_1 = 2;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* MultiChoice */ 15:
+                        {
+                            if (ft2.tag === /* MultiChoice */ 15) {
+                                matchResult_1 = 3;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* Radio */ 12:
+                        {
+                            if (ft2.tag === /* Radio */ 12) {
+                                matchResult_1 = 4;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* Dropdown */ 14:
+                        {
+                            if (ft2.tag === /* Dropdown */ 14) {
+                                matchResult_1 = 5;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* Checkbox */ 11:
+                        {
+                            if (ft2.tag === /* Checkbox */ 11) {
+                                matchResult_1 = 6;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* CheckboxList */ 16:
+                        {
+                            if (ft2.tag === /* CheckboxList */ 16) {
+                                matchResult_1 = 7;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* TagList */ 17:
+                        {
+                            if (ft2.tag === /* TagList */ 17) {
+                                matchResult_1 = 8;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    case /* TextAutoComplete */ 18:
+                        {
+                            if (ft2.tag === /* TextAutoComplete */ 18) {
+                                matchResult_1 = 9;
+                            } else {
+                                matchResult_1 = 10;
+                            }
+                            break;
+                        }
+                    default:
+                        matchResult_1 = 10;
+                }
+                switch(matchResult_1){
+                    case 0:
+                        return true;
+                    case 1:
+                        return true;
+                    case 2:
+                        return true;
+                    case 3:
+                        return true;
+                    case 4:
+                        return true;
+                    case 5:
+                        return true;
+                    case 6:
+                        return true;
+                    case 7:
+                        return true;
+                    case 8:
+                        return true;
+                    case 9:
+                        return true;
+                    default:
+                        return false;
+                }
+            }
+        default:
+            return false;
+    }
+}
+function Helpers_FormSpecMutators_updateFormFieldInFormSpecStep(inField, formStep, formSpec) {
+    const outStep = new _FormSpec.Spec_FormStep$1(formStep.StepOrder, formStep.StepLabel, (0, _List.map)((f)=>{
+        if ((0, _Util.equals)(f.FieldKey, inField.FieldKey)) {
+            return inField;
+        } else {
+            return f;
+        }
+    }, formStep.Fields));
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+        if (s.StepOrder === formStep.StepOrder) {
+            return outStep;
+        } else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_updateFormStepInFormSpec(formStep, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+        if (s.StepOrder === formStep.StepOrder) {
+            return formStep;
+        } else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_addFormFieldToStep(formStep, formSpec, formField) {
+    const outStep = new _FormSpec.Spec_FormStep$1(formStep.StepOrder, formStep.StepLabel, (0, _List.append)(formStep.Fields, (0, _List.singleton)(formField)));
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+        if (s.StepOrder === formStep.StepOrder) {
+            return outStep;
+        } else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_removeFormFieldFromFormSpec(formStepOrder, formField, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+        if (s.StepOrder === formStepOrder) {
+            return new _FormSpec.Spec_FormStep$1(s.StepOrder, s.StepLabel, (0, _List.mapIndexed)((i, f_1)=>new _FormSpec.Spec_FormField$1(i + 1, f_1.FieldKey, f_1.Label, f_1.Notes, f_1.DependsOn, f_1.IsOptional, f_1.IsDeprecated, f_1.FieldType), (0, _List.filter)((f)=>f.FieldOrder !== formField.FieldOrder, s.Fields)));
+        } else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_insertFormFieldToStepAt(formStep, newPositionFieldOrder, fieldKey) {
+    return (0, _List.mapIndexed)((index_1, f_1)=>new _FormSpec.Spec_FormField$1(index_1 + 1, f_1.FieldKey, f_1.Label, f_1.Notes, f_1.DependsOn, f_1.IsOptional, f_1.IsDeprecated, f_1.FieldType), (0, _List.insertAt)(newPositionFieldOrder - 1, (0, _List.find)((f)=>(0, _Util.equals)(f.FieldKey, fieldKey), formStep.Fields), formStep.Fields));
+}
+function Helpers_FormSpecMutators_moveFormFieldUpInFormSpec(formStepOrder, formField, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+        if (s.StepOrder === formStepOrder) {
+            return new _FormSpec.Spec_FormStep$1(s.StepOrder, s.StepLabel, (0, _List.mapIndexed)((index, f_2)=>new _FormSpec.Spec_FormField$1(index + 1, f_2.FieldKey, f_2.Label, f_2.Notes, f_2.DependsOn, f_2.IsOptional, f_2.IsDeprecated, f_2.FieldType), (0, _List.sortBy)((f_1)=>f_1.FieldOrder, (0, _List.map)((f)=>{
+                if (f.FieldOrder === formField.FieldOrder) {
+                    return new _FormSpec.Spec_FormField$1(formField.FieldOrder - 1, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                } else if (f.FieldOrder === formField.FieldOrder - 1) {
+                    return new _FormSpec.Spec_FormField$1(formField.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                } else {
+                    return f;
+                }
+            }, s.Fields), {
+                Compare: _Util.comparePrimitives
+            })));
+        } else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_moveFormFieldDownInFormSpec(formStepOrder, formField, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+        if (s.StepOrder === formStepOrder) {
+            return new _FormSpec.Spec_FormStep$1(s.StepOrder, s.StepLabel, (0, _List.mapIndexed)((index, f_2)=>new _FormSpec.Spec_FormField$1(index + 1, f_2.FieldKey, f_2.Label, f_2.Notes, f_2.DependsOn, f_2.IsOptional, f_2.IsDeprecated, f_2.FieldType), (0, _List.sortBy)((f_1)=>f_1.FieldOrder, (0, _List.map)((f)=>{
+                if (f.FieldOrder === formField.FieldOrder) {
+                    return new _FormSpec.Spec_FormField$1(formField.FieldOrder + 1, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                } else if (f.FieldOrder === formField.FieldOrder + 1) {
+                    return new _FormSpec.Spec_FormField$1(formField.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType);
+                } else {
+                    return f;
+                }
+            }, s.Fields), {
+                Compare: _Util.comparePrimitives
+            })));
+        } else {
+            return s;
+        }
+    }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_moveFieldByKeyToPositionInFormStepSpec(fieldKey, newPositionFieldOrder, formStepOrder, formSpec) {
+    const formStep = Helpers_FieldFinders_tryFindFormStepByStepNumber(formStepOrder, formSpec);
+    if (formStep != null) {
+        const formStep_1 = (0, _Option.value)(formStep);
+        return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.map)((s)=>{
+            if (s.StepOrder === formStep_1.StepOrder) {
+                return new _FormSpec.Spec_FormStep$1(s.StepOrder, s.StepLabel, (0, _List.mapIndexed)((index_1, f_1)=>new _FormSpec.Spec_FormField$1(index_1 + 1, f_1.FieldKey, f_1.Label, f_1.Notes, f_1.DependsOn, f_1.IsOptional, f_1.IsDeprecated, f_1.FieldType), (0, _Seq2.List_distinct)((0, _List.insertAt)(newPositionFieldOrder - 1, (0, _List.find)((f)=>(0, _Util.equals)(f.FieldKey, fieldKey), s.Fields), s.Fields), {
+                    Equals: _Util.equals,
+                    GetHashCode: _Util.safeHash
+                })));
+            } else {
+                return s;
+            }
+        }, formSpec.Steps), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+    } else {
+        return formSpec;
+    }
+}
+function Helpers_FormSpecMutators_moveFormStepUpInFormSpec(formStepOrder, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.mapIndexed)((i, s_1)=>new _FormSpec.Spec_FormStep$1(i + 1, s_1.StepLabel, s_1.Fields), (0, _List.sortBy)((s)=>s.StepOrder, (0, _List.map)((innerStep)=>{
+        if (innerStep.StepOrder === formStepOrder - 1) {
+            return new _FormSpec.Spec_FormStep$1(formStepOrder + 1, innerStep.StepLabel, innerStep.Fields);
+        } else if (innerStep.StepOrder === formStepOrder) {
+            return new _FormSpec.Spec_FormStep$1(formStepOrder - 1, innerStep.StepLabel, innerStep.Fields);
+        } else {
+            return innerStep;
+        }
+    }, formSpec.Steps), {
+        Compare: _Util.comparePrimitives
+    })), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_moveFormStepDownInFormSpec(formStepOrder, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.mapIndexed)((i, s_1)=>new _FormSpec.Spec_FormStep$1(i + 1, s_1.StepLabel, s_1.Fields), (0, _List.sortBy)((s)=>s.StepOrder, (0, _List.map)((innerStep)=>{
+        if (innerStep.StepOrder === formStepOrder + 1) {
+            return new _FormSpec.Spec_FormStep$1(formStepOrder - 1, innerStep.StepLabel, innerStep.Fields);
+        } else if (innerStep.StepOrder === formStepOrder) {
+            return new _FormSpec.Spec_FormStep$1(formStepOrder + 1, innerStep.StepLabel, innerStep.Fields);
+        } else {
+            return innerStep;
+        }
+    }, formSpec.Steps), {
+        Compare: _Util.comparePrimitives
+    })), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecMutators_removeFormStepFromFormSpec(formStepOrder, formSpec) {
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.mapIndexed)((i, s_1)=>new _FormSpec.Spec_FormStep$1(i + 1, s_1.StepLabel, s_1.Fields), (0, _List.filter)((s)=>s.StepOrder !== formStepOrder, formSpec.Steps)), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecTransformers_flattenSpecSteps(formSpec) {
+    const flatten = (steps_mut, acc_mut)=>{
+        flatten: while(true){
+            const steps = steps_mut, acc = acc_mut;
+            if (!(0, _List.isEmpty)(steps)) {
+                const step = (0, _List.head)(steps);
+                steps_mut = (0, _List.tail)(steps);
+                acc_mut = (0, _List.append)(acc, (0, _List.map)((field)=>new _FormSpec.Spec_FormField$1(step.StepOrder * 1000 + field.FieldOrder, field.FieldKey, field.Label, field.Notes, field.DependsOn, field.IsOptional, field.IsDeprecated, field.FieldType), step.Fields));
+                continue flatten;
+            } else {
+                return acc;
+            }
+            break;
+        }
+    };
+    return new _FormSpec.Spec_FormSpec$1(formSpec.Id, formSpec.Code, formSpec.Title, formSpec.Abstract, formSpec.Version, formSpec.FormSpecVersion, (0, _List.singleton)(new _FormSpec.Spec_FormStep$1(1, "Complete Form", flatten(formSpec.Steps, (0, _List.empty)()))), formSpec.CategoryTags, formSpec.Score, formSpec.AssociatedCodes, formSpec.RequiresReview, formSpec.RequiresReviewAndApproval, formSpec.ClinicalPathway);
+}
+function Helpers_FormSpecValidators_allStepsHaveFields(formSpec) {
+    return (0, _List.forAll)((step)=>!(0, _List.isEmpty)(step.Fields), formSpec.Steps);
+}
+function Helpers_FormSpecValidators_hasClinicalPathway(formSpec) {
+    return formSpec.ClinicalPathway != null;
+}
+function Helpers_specFieldOptionsToValueOptions(options) {
+    return (0, _List.map)((o)=>new _FormSpec.Shared_FieldOption(o.Description, o.Value, o.OptionKey), options);
+}
+function Helpers_optionsFromSpecField(field) {
+    const matchValue = field.FieldType;
+    switch(matchValue.tag){
+        case /* PluginField */ 22:
+            return (0, _List.empty)();
+        case /* CheckboxList */ 16:
+            return matchValue.fields[0].Options;
+        case /* MultiChoice */ 15:
+            return matchValue.fields[0].Options;
+        case /* TagList */ 17:
+            return matchValue.fields[0].Options;
+        case /* Dropdown */ 14:
+            return matchValue.fields[0].Options;
+        case /* Radio */ 12:
+            return matchValue.fields[0].Options;
+        case /* SingleChoice */ 13:
+            return matchValue.fields[0].Options;
+        case /* TextAutoComplete */ 18:
+            return matchValue.fields[0].Options;
+        case /* Matrix */ 19:
+            return matchValue.fields[0].Options;
+        default:
+            return (0, _List.empty)();
+    }
+}
+function Helpers_readValue(field, values) {
+    const matchValue = (0, _Seq.tryFind)((k)=>(0, _Util.equals)(k, field.FieldKey), (0, _Seq.map)((tuple)=>tuple[0], (0, _Map.toSeq)(values)));
+    if (matchValue != null) {
+        const matchValue_1 = (0, _Map.FSharpMap__get_Item)(values, (0, _Option.value)(matchValue)).FieldValue;
+        if (matchValue_1.tag === /* Single */ 0) {
+            return matchValue_1.fields[0].Value;
+        } else {
+            return "";
+        }
+    } else {
+        return "";
+    }
+}
+function Helpers_readManyValue(fieldKey, values) {
+    const matchValue = (0, _Seq.tryFind)((k)=>(0, _Util.equals)(k, fieldKey), (0, _Seq.map)((tuple)=>tuple[0], (0, _Map.toSeq)(values)));
+    if (matchValue != null) {
+        const matchValue_1 = (0, _Map.FSharpMap__get_Item)(values, (0, _Option.value)(matchValue)).FieldValue;
+        if (matchValue_1.tag === /* Multiple */ 1) {
+            return (0, _Set.map)((v_1)=>v_1.Value, matchValue_1.fields[0], {
+                Compare: _Util.comparePrimitives
+            });
+        } else {
+            return (0, _Set.empty)({
+                Compare: _Util.comparePrimitives
+            });
+        }
+    } else {
+        return (0, _Set.empty)({
+            Compare: _Util.comparePrimitives
+        });
+    }
+}
+function Helpers_updateSingleFunc(formatter, specField, newValue, values) {
+    let Value, matchValue;
+    const fieldOptions = Helpers_optionsFromSpecField(specField);
+    const newFieldDetails = new _FormSpec.Values_FieldDetails$1(specField.FieldOrder, specField.FieldKey, specField.Label, (0, _FormSpec.Shared_FieldValue_Single)((Value = formatter(newValue), new _FormSpec.Shared_FieldAnswer(specField.FieldKey, (matchValue = (0, _List.tryFind)((o)=>o.Value === newValue, fieldOptions), matchValue == null ? newValue : (0, _Option.value)(matchValue).Description), Value))), specField.FieldType, Helpers_specFieldOptionsToValueOptions(fieldOptions));
+    const matchValue_1 = (0, _Seq.tryFind)((k)=>(0, _Util.equals)(k, newFieldDetails.Key), (0, _Seq.map)((tuple)=>tuple[0], (0, _Map.toSeq)(values)));
+    if (matchValue_1 != null) {
+        const key = (0, _Option.value)(matchValue_1);
+        const f = (0, _Map.FSharpMap__Remove)(values, key);
+        return (0, _Map.FSharpMap__Add)(values, key, newFieldDetails);
+    } else {
+        return (0, _Map.FSharpMap__Add)(values, newFieldDetails.Key, newFieldDetails);
+    }
+}
+function Helpers_updateManyFunc(formatter, specField, newValue, values) {
+    const newFieldDetails = new _FormSpec.Values_FieldDetails$1(specField.FieldOrder, specField.FieldKey, specField.Label, (0, _FormSpec.Shared_FieldValue_Multiple)((0, _Set.map)((v)=>{
+        let matchValue;
+        const Value = formatter(v);
+        return new _FormSpec.Shared_FieldAnswer(specField.FieldKey, (matchValue = (0, _List.tryFind)((o)=>o.Value === v, Helpers_optionsFromSpecField(specField)), matchValue == null ? v : (0, _Option.value)(matchValue).Description), Value);
+    }, newValue, {
+        Compare: _Util.compare
+    })), specField.FieldType, Helpers_specFieldOptionsToValueOptions(Helpers_optionsFromSpecField(specField)));
+    const matchValue_1 = (0, _Seq.tryFind)((k)=>(0, _Util.equals)(k, newFieldDetails.Key), (0, _Seq.map)((tuple)=>tuple[0], (0, _Map.toSeq)(values)));
+    if (matchValue_1 != null) {
+        const key = (0, _Option.value)(matchValue_1);
+        return (0, _Map.FSharpMap__Add)((0, _Map.FSharpMap__Remove)(values, newFieldDetails.Key), newFieldDetails.Key, newFieldDetails);
+    } else {
+        return (0, _Map.FSharpMap__Add)(values, newFieldDetails.Key, newFieldDetails);
+    }
+}
+function Helpers_updateFormFieldValue(field, newValue, values) {
+    const newFieldDetails = new _FormSpec.Values_FieldDetails$1(field.FieldOrder, field.FieldKey, field.Label, (()=>{
+        throw new Error("updateFormFieldValue: Field type handling not implemented.");
+    })(), field.FieldType, Helpers_specFieldOptionsToValueOptions(Helpers_optionsFromSpecField(field)));
+    const matchValue_1 = (0, _Seq.tryFind)((k)=>(0, _Util.equals)(k, newFieldDetails.Key), (0, _Seq.map)((tuple)=>tuple[0], (0, _Map.toSeq)(values)));
+    if (matchValue_1 != null) {
+        const key = (0, _Option.value)(matchValue_1);
+        return (0, _Map.FSharpMap__Add)((0, _Map.FSharpMap__Remove)(values, key), key, newFieldDetails);
+    } else {
+        return (0, _Map.FSharpMap__Add)(values, newFieldDetails.Key, newFieldDetails);
+    }
+}
+function Helpers_updateFormValuesWithField(fieldKeyAndValue_, fieldKeyAndValue__1, form, getSteps, setSteps) {
+    let patternInput;
+    const fieldKeyAndValue = [
+        fieldKeyAndValue_,
+        fieldKeyAndValue__1
+    ];
+    let stepOrderResult;
+    const filteredFormSteps = (0, _Map.filter)((_arg, fieldValues)=>(0, _Map.FSharpMap__ContainsKey)(fieldValues, fieldKeyAndValue[0]), getSteps(form));
+    stepOrderResult = (0, _Map.FSharpMap__get_IsEmpty)(filteredFormSteps) ? (0, _Result.FSharpResult$2_Error)("No fields found") : (0, _Map.FSharpMap__get_Count)(filteredFormSteps) > 1 ? (0, _Result.FSharpResult$2_Error)("More than one field found") : (0, _Result.FSharpResult$2_Ok)((0, _List.head)((0, _Map.toList)(filteredFormSteps))[0]);
+    if (stepOrderResult.tag === /* Ok */ 0) {
+        const stepOrd = stepOrderResult.fields[0];
+        const foundStepValues = (0, _Map.toList)((0, _Map.FSharpMap__get_Item)(getSteps(form), stepOrd));
+        const foundField = (0, _List.tryFindIndex)((tupledArg_1)=>(0, _Util.equals)(tupledArg_1[0], fieldKeyAndValue[0]), foundStepValues);
+        const dynamicStepValues = (0, _Map.ofList)((0, _List.append)((0, _List.singleton)(fieldKeyAndValue), foundField == null ? foundStepValues : (patternInput = (0, _List.splitAt)((0, _Option.value)(foundField), foundStepValues), (0, _List.append)(patternInput[0], (0, _List.tail)(patternInput[1])))), {
+            Compare: _Util.compare
+        });
+        return setSteps((0, _Map.FSharpMap__Change)(getSteps(form), stepOrd, (_arg_3)=>dynamicStepValues), form);
+    } else {
+        (0, _String.toConsole)(`ERROR updating value: ${stepOrderResult.fields[0]}`);
+        return form;
+    }
+}
+function Helpers_findAndUpdateFormField(label, stepNumber, newValue, formSpec, form, getSteps, setSteps) {
+    return (0, _Result.Result_Map)((tupledArg)=>{
+        const field = tupledArg[1];
+        const fieldKeyAndValue = [
+            field.FieldKey,
+            (0, _Map.FSharpMap__get_Item)(Helpers_updateFormFieldValue(field, newValue, (0, _Map.FSharpMap__get_Item)(getSteps(form), new _FormSpec.Values_StepOrder(tupledArg[0].StepOrder))), field.FieldKey)
+        ];
+        return Helpers_updateFormValuesWithField(fieldKeyAndValue[0], fieldKeyAndValue[1], form, getSteps, setSteps);
+    }, Helpers_FieldFinders_findUniqueFormFieldInStepByLabelString(label, stepNumber, formSpec));
+}
+function Helpers_findAndUpdateFormFieldInAnyStep(label, newValue, formSpec, form, getSteps, setSteps) {
+    return (0, _Result.Result_Map)((tupledArg)=>{
+        const field = tupledArg[1];
+        const fieldKeyAndValue = [
+            field.FieldKey,
+            (0, _Map.FSharpMap__get_Item)(Helpers_updateFormFieldValue(field, newValue, (0, _Map.FSharpMap__get_Item)(getSteps(form), new _FormSpec.Values_StepOrder(tupledArg[0].StepOrder))), field.FieldKey)
+        ];
+        return Helpers_updateFormValuesWithField(fieldKeyAndValue[0], fieldKeyAndValue[1], form, getSteps, setSteps);
+    }, Helpers_FieldFinders_findUniqueFormFieldInFormByLabelString(label, formSpec));
+} //# sourceMappingURL=Helpers.ts.map
+
+//# sourceMappingURL=Helpers.js.map