@f1studio/form-spec 5.0.0-alpha.101

package/src/FormSpec.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/FormSpec.fs"],"names":["x","str","index","a","formStatusString","matchValue","outArg"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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","file":null,"sourcesContent":null,"sourceRoot":null}

package/src/FormSpecHelpers.ts

@@ -0,0 +1,374 @@
+import { value as value_2, Option, bind } from "@fable-org/fable-library-js/Option.js";
+import { Shared_FieldValue_Single, Shared_FieldValue_PluginData, Shared_FieldValue_Matrix, Shared_MatrixAnswer, Shared_FieldValue_Multiple, Shared_ConditionValue_Single, Shared_ConditionValue_PluginData, Shared_ConditionValue_Matrix, Shared_ConditionValue_Multiple, Spec_FormSpec$1, ClinicalPathway_ConstraintDefinition, ClinicalPathway_ConstraintType_$union, ClinicalPathway_TransitionDefinition, ClinicalPathway_ClinicalPathwaySpec, Spec_FormStep$1, Spec_FormField$1, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_LogicalOp_$union, Shared_PluginPropertyKey, Shared_FieldOptionKey, Shared_ConditionValue_$union, ClinicalPathway_FieldEvaluator_$union, Values_DynamicFormResultData$1, Values_StepOrder, Shared_FieldKey, Spec_FieldType_$union, Values_FieldDetails$1, Shared_PluginDataProperty_$reflection, Shared_PluginDataProperty, Shared_MatrixItemKey, Shared_FieldAnswer, Shared_FieldValue_$union } from "./FormSpec.js";
+import { join } from "@fable-org/fable-library-js/String.js";
+import { singleton, head, isEmpty, ofSeq, iterate, forAll, exists, FSharpList, map } from "@fable-org/fable-library-js/List.js";
+import { map as map_1, toList } from "@fable-org/fable-library-js/Set.js";
+import { iterate as iterate_1, FSharpMap, tryFind, toList as toList_1 } from "@fable-org/fable-library-js/Map.js";
+import { Auto_generateBoxedEncoder_437914C6, toString } from "./fable_modules/Thoth.Json.10.4.1/Encode.fs.js";
+import { list_type } from "@fable-org/fable-library-js/Reflection.js";
+import { int32, float64 } from "@fable-org/fable-library-js/Int32.js";
+import { tryParse } from "@fable-org/fable-library-js/Double.js";
+import { FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { FSharpResult$2_$union, FSharpResult$2_Error, FSharpResult$2_Ok } from "@fable-org/fable-library-js/Result.js";
+import { addRangeInPlace } from "@fable-org/fable-library-js/Array.js";
+import { compare, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+
+/**
+ * Extract a field value as a string from form data
+ */
+export function getFieldValue(fieldKey: Shared_FieldKey, formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): Option<string> {
+    return bind<Values_FieldDetails$1<Spec_FieldType_$union>, string>((fieldDetails: Values_FieldDetails$1<Spec_FieldType_$union>): Option<string> => {
+        const matchValue: Shared_FieldValue_$union = fieldDetails.FieldValue;
+        switch (matchValue.tag) {
+            case /* Multiple */ 1:
+                return join(",", map<Shared_FieldAnswer, string>((a: Shared_FieldAnswer): string => a.Value, toList<Shared_FieldAnswer>(matchValue.fields[0])));
+            case /* Matrix */ 2:
+                return join(",", map<[Shared_MatrixItemKey, string], string>((tuple: [Shared_MatrixItemKey, string]): string => tuple[1], toList_1<Shared_MatrixItemKey, string>(matchValue.fields[0].Values)));
+            case /* PluginData */ 3: {
+                const pluginData: FSharpList<Shared_PluginDataProperty> = matchValue.fields[0];
+                return toString(0, Auto_generateBoxedEncoder_437914C6(list_type(Shared_PluginDataProperty_$reflection()), undefined, undefined, undefined)(pluginData));
+            }
+            default:
+                return matchValue.fields[0].Value;
+        }
+    }, bind<FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>, Values_FieldDetails$1<Spec_FieldType_$union>>((stepValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): Option<Values_FieldDetails$1<Spec_FieldType_$union>> => tryFind<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>(fieldKey, stepValues), tryFind<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>(new Values_StepOrder(1), formData.ResultSteps)));
+}
+
+/**
+ * Check if a field has a specific value
+ */
+export function fieldHasValue(fieldKey: Shared_FieldKey, expectedValue: string, formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): boolean {
+    const matchValue: Option<string> = getFieldValue(fieldKey, formData);
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        return value_2(matchValue) === expectedValue;
+    }
+}
+
+/**
+ * Check if a field value is greater than a threshold
+ */
+export function fieldGreaterThan(fieldKey: Shared_FieldKey, threshold: float64, formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): boolean {
+    const matchValue: Option<string> = getFieldValue(fieldKey, formData);
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        let matchValue_1: [boolean, float64];
+        let outArg = 0;
+        matchValue_1 = ([tryParse(value_2(matchValue), new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+            outArg = v;
+        })), outArg] as [boolean, float64]);
+        if (matchValue_1[0]) {
+            return matchValue_1[1] > threshold;
+        }
+        else {
+            return false;
+        }
+    }
+}
+
+/**
+ * Check if a field value is less than a threshold
+ */
+export function fieldLessThan(fieldKey: Shared_FieldKey, threshold: float64, formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): boolean {
+    const matchValue: Option<string> = getFieldValue(fieldKey, formData);
+    if (matchValue == null) {
+        return false;
+    }
+    else {
+        let matchValue_1: [boolean, float64];
+        let outArg = 0;
+        matchValue_1 = ([tryParse(value_2(matchValue), new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+            outArg = v;
+        })), outArg] as [boolean, float64]);
+        if (matchValue_1[0]) {
+            return matchValue_1[1] < threshold;
+        }
+        else {
+            return false;
+        }
+    }
+}
+
+/**
+ * Evaluate a single field condition (string-based, for backward compatibility)
+ */
+export function evaluateFieldCondition(fieldKey: Shared_FieldKey, evaluator: ClinicalPathway_FieldEvaluator_$union, expectedValue: string, formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): boolean {
+    switch (evaluator.tag) {
+        case /* Equals */ 0:
+            return fieldHasValue(fieldKey, expectedValue, formData);
+        case /* NotEquals */ 1:
+            return !fieldHasValue(fieldKey, expectedValue, formData);
+        case /* GreaterThan */ 5: {
+            let matchValue: [boolean, float64];
+            let outArg = 0;
+            matchValue = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+                outArg = v;
+            })), outArg] as [boolean, float64]);
+            if (matchValue[0]) {
+                return fieldGreaterThan(fieldKey, matchValue[1], formData);
+            }
+            else {
+                return false;
+            }
+        }
+        case /* LessThan */ 7: {
+            let matchValue_1: [boolean, float64];
+            let outArg_1 = 0;
+            matchValue_1 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_1, (v_1: float64): void => {
+                outArg_1 = v_1;
+            })), outArg_1] as [boolean, float64]);
+            if (matchValue_1[0]) {
+                return fieldLessThan(fieldKey, matchValue_1[1], formData);
+            }
+            else {
+                return false;
+            }
+        }
+        case /* GreaterOrEqual */ 6: {
+            let matchValue_2: [boolean, float64];
+            let outArg_2 = 0;
+            matchValue_2 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_2, (v_2: float64): void => {
+                outArg_2 = v_2;
+            })), outArg_2] as [boolean, float64]);
+            if (matchValue_2[0]) {
+                if (fieldGreaterThan(fieldKey, matchValue_2[1], formData)) {
+                    return true;
+                }
+                else {
+                    return fieldHasValue(fieldKey, expectedValue, formData);
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        case /* LessOrEqual */ 8: {
+            let matchValue_3: [boolean, float64];
+            let outArg_3 = 0;
+            matchValue_3 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_3, (v_3: float64): void => {
+                outArg_3 = v_3;
+            })), outArg_3] as [boolean, float64]);
+            if (matchValue_3[0]) {
+                if (fieldLessThan(fieldKey, matchValue_3[1], formData)) {
+                    return true;
+                }
+                else {
+                    return fieldHasValue(fieldKey, expectedValue, formData);
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        default:
+            return false;
+    }
+}
+
+/**
+ * Recursively evaluate a transition condition
+ */
+export function evaluateCondition(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>, condition: ClinicalPathway_TransitionCondition_$union): boolean {
+    switch (condition.tag) {
+        case /* FieldCondition */ 0: {
+            const conditionValue: Shared_ConditionValue_$union = condition.fields[2];
+            return evaluateFieldCondition(condition.fields[0], condition.fields[1], (conditionValue.tag === /* Multiple */ 1) ? join(",", toList<string>(conditionValue.fields[0])) : ((conditionValue.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg: [Shared_MatrixItemKey, string]): string => tupledArg[1], toList_1<Shared_MatrixItemKey, string>(conditionValue.fields[0]))) : ((conditionValue.tag === /* PluginData */ 3) ? conditionValue.fields[0].Value : conditionValue.fields[0])), formData);
+        }
+        case /* FieldOptionCondition */ 1: {
+            const optionKey: Shared_FieldOptionKey = condition.fields[2];
+            const fieldKey_1: Shared_FieldKey = condition.fields[0];
+            const fieldItemKey: Option<Shared_MatrixItemKey> = condition.fields[1];
+            const evaluator_1: ClinicalPathway_FieldEvaluator_$union = condition.fields[3];
+            const conditionValue_1: Shared_ConditionValue_$union = condition.fields[4];
+            return evaluateFieldCondition((fieldItemKey == null) ? fieldKey_1 : (new Shared_FieldKey(value_2(fieldItemKey).fields[0])), evaluator_1, (conditionValue_1.tag === /* Multiple */ 1) ? join(",", toList<string>(conditionValue_1.fields[0])) : ((conditionValue_1.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg_1: [Shared_MatrixItemKey, string]): string => tupledArg_1[1], toList_1<Shared_MatrixItemKey, string>(conditionValue_1.fields[0]))) : ((conditionValue_1.tag === /* PluginData */ 3) ? conditionValue_1.fields[0].Value : conditionValue_1.fields[0])), formData);
+        }
+        case /* PluginPropertyCondition */ 2: {
+            const propertyKey: Shared_PluginPropertyKey = condition.fields[1];
+            const fieldKey_2: Shared_FieldKey = condition.fields[0];
+            const evaluator_2: ClinicalPathway_FieldEvaluator_$union = condition.fields[2];
+            const conditionValue_2: Shared_ConditionValue_$union = condition.fields[3];
+            const expectedValueStr_2: string = (conditionValue_2.tag === /* Multiple */ 1) ? join(",", toList<string>(conditionValue_2.fields[0])) : ((conditionValue_2.tag === /* Matrix */ 2) ? join(",", map<[Shared_MatrixItemKey, string], string>((tupledArg_2: [Shared_MatrixItemKey, string]): string => tupledArg_2[1], toList_1<Shared_MatrixItemKey, string>(conditionValue_2.fields[0]))) : ((conditionValue_2.tag === /* PluginData */ 3) ? conditionValue_2.fields[0].Value : conditionValue_2.fields[0]));
+            return false;
+        }
+        case /* CompositeCondition */ 4: {
+            const operator: ClinicalPathway_LogicalOp_$union = condition.fields[0];
+            const conditions: FSharpList<ClinicalPathway_TransitionCondition_$union> = condition.fields[1];
+            switch (operator.tag) {
+                case /* Or */ 1:
+                    return exists<ClinicalPathway_TransitionCondition_$union>((condition_2: ClinicalPathway_TransitionCondition_$union): boolean => evaluateCondition(formData, condition_2), conditions);
+                case /* Not */ 2:
+                    throw new Error("Not operator should not be used directly with CompositeCondition");
+                default:
+                    return forAll<ClinicalPathway_TransitionCondition_$union>((condition_1: ClinicalPathway_TransitionCondition_$union): boolean => evaluateCondition(formData, condition_1), conditions);
+            }
+        }
+        case /* StateCondition */ 3:
+            return true;
+        case /* TestResultCondition */ 5:
+            return true;
+        default:
+            return true;
+    }
+}
+
+/**
+ * Validate that a FormSpec only uses GUID field keys
+ */
+export function validateFormSpecFieldKeys(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpResult$2_$union<void, FSharpList<string>> {
+    const errors: string[] = [];
+    iterate<Spec_FormStep$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): void => {
+        iterate<Spec_FormField$1<Spec_FieldType_$union>>((field: Spec_FormField$1<Spec_FieldType_$union>): void => {
+            if (field.FieldKey.fields[0] === "00000000-0000-0000-0000-000000000000") {
+                void (errors.push(`Field '${field.Label}' has empty GUID field key`));
+            }
+        }, step.Fields);
+    }, formSpec.Steps);
+    const matchValue: Option<ClinicalPathway_ClinicalPathwaySpec> = formSpec.ClinicalPathway;
+    if (matchValue == null) {
+    }
+    else {
+        const pathway: ClinicalPathway_ClinicalPathwaySpec = value_2(matchValue);
+        pathway.States;
+        iterate<ClinicalPathway_TransitionDefinition>((transition: ClinicalPathway_TransitionDefinition): void => {
+            const validateCondition = (condition: ClinicalPathway_TransitionCondition_$union): void => {
+                switch (condition.tag) {
+                    case /* FieldCondition */ 0: {
+                        if (condition.fields[0].fields[0] === "00000000-0000-0000-0000-000000000000") {
+                            void (errors.push(`Transition '${transition.TransitionKey}' has empty GUID field key in condition`));
+                        }
+                        break;
+                    }
+                    case /* PluginPropertyCondition */ 2: {
+                        const propGuid: string = condition.fields[1].fields[0];
+                        if (condition.fields[0].fields[0] === "00000000-0000-0000-0000-000000000000") {
+                            void (errors.push(`Transition '${transition.TransitionKey}' has empty GUID field key in plugin property condition`));
+                        }
+                        if (propGuid === "00000000-0000-0000-0000-000000000000") {
+                            void (errors.push(`Transition '${transition.TransitionKey}' has empty GUID property key in plugin property condition`));
+                        }
+                        break;
+                    }
+                    case /* CompositeCondition */ 4: {
+                        iterate<ClinicalPathway_TransitionCondition_$union>(validateCondition, condition.fields[1]);
+                        break;
+                    }
+                    default:
+                        undefined;
+                }
+            };
+            validateCondition(transition.Condition);
+        }, pathway.Transitions);
+        iterate<ClinicalPathway_ConstraintDefinition>((constraintDef: ClinicalPathway_ConstraintDefinition): void => {
+            const matchValue_1: ClinicalPathway_ConstraintType_$union = constraintDef.ConstraintType;
+            if (matchValue_1.tag === /* RequiredField */ 3) {
+                if (matchValue_1.fields[0].fields[0] === "00000000-0000-0000-0000-000000000000") {
+                    void (errors.push(`Constraint '${constraintDef.ConstraintKey}' has empty GUID field key`));
+                }
+            }
+        }, pathway.Constraints);
+    }
+    if (errors.length === 0) {
+        return FSharpResult$2_Ok<void, FSharpList<string>>(undefined);
+    }
+    else {
+        return FSharpResult$2_Error<void, FSharpList<string>>(ofSeq<string>(errors));
+    }
+}
+
+/**
+ * Validate that form data only contains GUID field keys
+ */
+export function validateFormDataFieldKeys(formData: Values_DynamicFormResultData$1<Spec_FieldType_$union>): FSharpResult$2_$union<void, FSharpList<string>> {
+    const errors: string[] = [];
+    iterate_1<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>((stepOrder: Values_StepOrder, stepValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>): void => {
+        iterate_1<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>((fieldKey: Shared_FieldKey, _arg: Values_FieldDetails$1<Spec_FieldType_$union>): void => {
+            if (fieldKey.fields[0] === "00000000-0000-0000-0000-000000000000") {
+                void (errors.push(`Step ${stepOrder} contains field with empty GUID`));
+            }
+        }, stepValues);
+    }, formData.ResultSteps);
+    if (errors.length === 0) {
+        return FSharpResult$2_Ok<void, FSharpList<string>>(undefined);
+    }
+    else {
+        return FSharpResult$2_Error<void, FSharpList<string>>(ofSeq<string>(errors));
+    }
+}
+
+/**
+ * Comprehensive validation that ensures FormSpec only works with GUID keys
+ */
+export function validateGuidOnlyFormSpec(formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, formData: Option<Values_DynamicFormResultData$1<Spec_FieldType_$union>>): FSharpResult$2_$union<void, FSharpList<string>> {
+    const errors: string[] = [];
+    const matchValue: FSharpResult$2_$union<void, FSharpList<string>> = validateFormSpecFieldKeys(formSpec);
+    if (matchValue.tag === /* Ok */ 0) {
+    }
+    else {
+        addRangeInPlace(matchValue.fields[0], errors);
+    }
+    if (formData == null) {
+    }
+    else {
+        const matchValue_1: FSharpResult$2_$union<void, FSharpList<string>> = validateFormDataFieldKeys(value_2(formData));
+        if (matchValue_1.tag === /* Ok */ 0) {
+        }
+        else {
+            addRangeInPlace(matchValue_1.fields[0], errors);
+        }
+    }
+    if (errors.length === 0) {
+        return FSharpResult$2_Ok<void, FSharpList<string>>(undefined);
+    }
+    else {
+        return FSharpResult$2_Error<void, FSharpList<string>>(ofSeq<string>(errors));
+    }
+}
+
+/**
+ * Convert FieldValue to ConditionValue (extracts just the values, no FieldAnswer wrapper)
+ */
+export function fieldValueToConditionValue(fieldValue: Shared_FieldValue_$union): Shared_ConditionValue_$union {
+    switch (fieldValue.tag) {
+        case /* Multiple */ 1:
+            return Shared_ConditionValue_Multiple(map_1<Shared_FieldAnswer, string>((a: Shared_FieldAnswer): string => a.Value, fieldValue.fields[0], {
+                Compare: comparePrimitives,
+            }));
+        case /* Matrix */ 2:
+            return Shared_ConditionValue_Matrix(fieldValue.fields[0].Values);
+        case /* PluginData */ 3: {
+            const pluginDataList: FSharpList<Shared_PluginDataProperty> = fieldValue.fields[0];
+            if (!isEmpty(pluginDataList)) {
+                return Shared_ConditionValue_PluginData(head(pluginDataList));
+            }
+            else {
+                throw new Error("Empty plugin data list cannot be converted to ConditionValue");
+            }
+        }
+        default:
+            return Shared_ConditionValue_Single(fieldValue.fields[0].Value);
+    }
+}
+
+/**
+ * Convert ConditionValue to FieldValue (for evaluation - needs fieldKey for FieldAnswer)
+ */
+export function conditionValueToFieldValue(conditionValue: Shared_ConditionValue_$union, fieldKey: Shared_FieldKey, fieldLabel: string): Shared_FieldValue_$union {
+    switch (conditionValue.tag) {
+        case /* Multiple */ 1:
+            return Shared_FieldValue_Multiple(map_1<string, Shared_FieldAnswer>((value_1: string): Shared_FieldAnswer => (new Shared_FieldAnswer(fieldKey, fieldLabel, value_1)), conditionValue.fields[0], {
+                Compare: compare,
+            }));
+        case /* Matrix */ 2:
+            return Shared_FieldValue_Matrix(new Shared_MatrixAnswer(fieldKey, fieldLabel, conditionValue.fields[0]));
+        case /* PluginData */ 3:
+            return Shared_FieldValue_PluginData(singleton(conditionValue.fields[0]));
+        default:
+            return Shared_FieldValue_Single(new Shared_FieldAnswer(fieldKey, fieldLabel, conditionValue.fields[0]));
+    }
+}
+
+//# sourceMappingURL=FormSpecHelpers.ts.map

package/src/FormSpecHelpers.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/FormSpecHelpers.fs","./fable_modules/Thoth.Json.10.4.1/Encode.fs"],"names":["matchValue","fieldDetails","a","tuple","pluginData","fieldKey","stepValues","formData","getFieldValue","expectedValue","outArg","threshold","evaluator","fieldHasValue","fieldGreaterThan","fieldLessThan","condition","conditionValue","evaluateFieldCondition","tupledArg","optionKey","fieldItemKey","propertyKey","expectedValueStr","operator","conditions","evaluateCondition","errors","field","step","formSpec","pathway","validateCondition","transition","propGuid","constraintDef","stepOrder","validateFormSpecFieldKeys","validateFormDataFieldKeys","fieldValue","pluginDataList","fieldLabel","value"],"mappings":";;;;;;;;;;;;;;;;;;;WAeO;AACOA,qDAAA,AAAAC;gBAAAD;;AAMC,uBAAA,KAAc,KADd,mEAAmB,AAAAE,SADnB,2BADH,AAAAF;;AAUG,uBAAA,KAAc,KADd,\u002BFAAS,AAAAG,UADT,uCADH,AAAAH;;AAK2BI,0EAE3B,AAAAJ;AC0uBiB,uBAAA,SD1uBqB,GC0uBtC,AAzBA,wHDjtByCI;;;AAhBH,uBAAA,AAAL,AAAAJ;;OALtC,6QACe,uEAAAK,UAAdC,aAFD,oGAAa,qBAAU,IAD1B,AAAAC;;;;;;;AA4BMP,uCAAA,AAAAQ,cAAcH,UAASE;AAAvB,QAAA,AAAAP;eAEI;;;AADM,eAAA,QAAAA,gBAAQS;;;;;;;;AAKlBT,uCAAA,AAAAQ,cAAcH,UAASE;AAAvB,QAAA,AAAAP;eAKI;;;AAHAA;AAAAU;AAAAV,yBAAA,iBAAAA,aAAA,sCAAAU;AAAAA;aAAAA;AAAA,YAAA,AAAAV;AACS,mBAAA,AAAAA,kBAAMW;;;mBACP;;;;;;;;;AAKZX,uCAAA,AAAAQ,cAAcH,UAASE;AAAvB,QAAA,AAAAP;eAKI;;;AAHAA;AAAAU;AAAAV,yBAAA,iBAAAA,aAAA,sCAAAU;AAAAA;aAAAA;AAAA,YAAA,AAAAV;AACS,mBAAA,AAAAA,kBAAMW;;;mBACP;;;;;;;;;YASZC;;AAEF,mBAAA,AAAAC,cAAcR,UAASI,eAAcF;;AAErC,mBAAA,CAAK,AAAAM,cAAcR,UAASI,eAAcF;;AAEpCP;AAAAU;AAAAV,2BAAA,SAAgBS,eAAhB,sCAAAC;AAAAA;iBAAAA;AAAA,gBAAA,AAAAV;AACe,uBAAA,AAAAc,iBAAiBT,UAAjB,AAAAL,eAAoCO;;;uBAC3C;;;;AAERP;AAAAU;AAAAV,6BAAA,SAAgBS,eAAhB,sCAAAC;AAAAA;iBAAAA;AAAA,gBAAA,AAAAV;AACe,uBAAA,AAAAe,cAAcV,UAAd,AAAAL,iBAAiCO;;;uBACxC;;;;AAERP;AAAAU;AAAAV,6BAAA,SAAgBS,eAAhB,sCAAAC;AAAAA;iBAAAA;AAAA,gBAAA,AAAAV;AAEF,oBAAA,AAAAc,iBAAiBT,UAAjB,AAAAL,iBAAoCO;2BAApC;;;AACA,2BAAA,AAAAM,cAAcR,UAASI,eAAcF;;;;uBAC3B;;;;AAERP;AAAAU;AAAAV,6BAAA,SAAgBS,eAAhB,sCAAAC;AAAAA;iBAAAA;AAAA,gBAAA,AAAAV;AAEF,oBAAA,AAAAe,cAAcV,UAAd,AAAAL,iBAAiCO;2BAAjC;;;AACA,2BAAA,AAAAM,cAAcR,UAASI,eAAcF;;;;uBAC3B;;;;mBACX;;;;;;;;YAIDS;;AAEiCC,iEAE/B,AAAAD;AAMJ,mBAAA,AAAAE,uBANI,AAAAF,qBAAA,AAAAA,qBACM,CAAA,AAAAC,2CAEqD,KAAc,KAA5B,eAAN,AAAAA,8BAFjC,CAAA,AAAAA,yCAGiF,KAAc,KAA5C,mGAAe,AAAAE,cAA7B,uCAAN,AAAAF,\u002BBAH/B,CAAA,AAAAA,6CAI\u002BC,AAAAA,iCAHjB,AAAAA,4BAImBV;;;AACfa,qDAGxC,AAAAJ;AAHgBX,gDAGhB,AAAAW;AAH0BK,\u002BDAG1B,AAAAL;AAHmDJ,uEAGnD,AAAAI;AAH8DC,mEAG9D,AAAAD;AAiBJ,mBAAA,AAAAE,uBAhBU,CAAA,AAAAG,wBAMFhB,cAFA,oBADI,QAAAgB,2BAaqBT,aAPvB,CAAA,AAAAK,6CAEqD,KAAc,KAA5B,eAAN,AAAAA,gCAFjC,CAAA,AAAAA,2CAGiF,KAAc,KAA5C,qGAAe,AAAAE,gBAA7B,uCAAN,AAAAF,iCAH/B,CAAA,AAAAA,\u002BCAI\u002BC,AAAAA,mCAHjB,AAAAA,8BAMoBV;;;AAC3Be,0DAE7B,AAAAN;AAFmBX,gDAEnB,AAAAW;AAF0CJ,uEAE1C,AAAAI;AAFqDC,mEAErD,AAAAD;AAAAO,\u002BCACM,CAAA,AAAAN,6CAEqD,KAAc,KAA5B,eAAN,AAAAA,gCAFjC,CAAA,AAAAA,2CAGiF,KAAc,KAA5C,qGAAe,AAAAE,gBAA7B,uCAAN,AAAAF,iCAH/B,CAAA,AAAAA,\u002BCAI\u002BC,AAAAA,mCAHjB,AAAAA;mBAMxC;;;AACkBO,\u002BDACZ,AAAAR;AADsBS,uFACtB,AAAAT;oBAAAQ;;AAEgB,2BAAA,yHAAa,AAAAE,kBAAAnB,UAAAS,cAA3BS;;AACC,oCAAS;;AAFK,2BAAA,yHAAa,AAAAC,kBAAAnB,UAAAS,cAA3BS;;;;mBAGc;;mBACK;;mBAhDpB;;;;;;;;AA0FRE;AAID;AAEI;AAGC,gBAAG,AADC,AAAwC,AAAAC;AAExC,sBAAAD,YAAW,UAAU,AAAAC;;WAL7B,AAAAC;OAFJ,AAAAC;AAcM9B,oEAAA,AAAA8B;AAAA,QAAA,AAAA9B;;;AACC\u002BB,qEAGH/B;AAAA,AAAA\u002BB;AAIG;AACSC;wBACEhB;;AAGF,4BAAG,AADC,AAAAA;AAEA,kCAAAW,YAAW,eAAe,AAAAM;;;;;AAGUC,iDAApC,AADA,AAAAlB;AAEJ,4BAAG,AAFC,AAAAA;AAGA,kCAAAW,YAAW,eAAe,AAAAM;;AAC9B,4BAAG,AAAAC;AACC,kCAAAP,YAAW,eAAe,AAAAM;;;;;AAEhB,4EAAUD,mBAAxB,AAAAhB;;;;AACG;;;AACX,AAAAgB,8BAAkB,AAAAC;WAlBtB,AAAAF;AAuBG;AACO/B,wEAAA,AAAAmC;AAAA,gBAAA,AAAAnC;AAGF,oBAAG,AADC,AAAAA;AAEA,0BAAA2B,YAAW,eAAe,AAAAQ;;;WANtC,AAAAJ;;AAWJ,QAAG,AAAAJ,kBAAe;2DACZ;;;8DAEc,cAAVA;;;;;;;;AAINA;AAGD;AAEI;AAEC,gBAAG,AADC,AAAAtB;AAEA,sBAAAsB,YAAW,QAAQS;;WAJ3B9B;OAFJ,AAAAC;AAUA,QAAG,AAAAoB,kBAAe;2DACZ;;;8DAEc,cAAVA;;;;;;;;AAINA;AAGE3B,wEAAA,AAAAqC,0BAA0BP;AAA1B,QAAA,AAAA9B;;;AACoB,wBAAA,AAAAA,sBAAA2B;;AAIpB,QAAA,AAAApB;;;AAEIP,8EAAA,AAAAsC,kCAAA/B;AAAA,YAAA,AAAAP;;;AACgB,4BAAA,AAAAA,wBAAA2B;;;AAI1B,QAAG,AAAAA,kBAAe;2DACZ;;;8DAEc,cAAVA;;;;;;;;YAQJY;;kDAIsB,qEAAkB,AAAArC,SAAtC,AAAAqC;;;;gDAGyB,AAA7B,AAAAA;;AAC2BC,0EAGrB,AAAAD;AAAA,gBAAA,CAAA,QAAAC;wDAEkB,KAAAA;;;AADhB,gCAAS;;;;gDAVY,AAA7B,AAAAD;;;;;;;;YAeEtB;;8CAQ\u002BC,4EAC7C,uBACeZ,UACGoC,YACNC,WAJZ,AAAAzB;;;;4CASsB,wBACXZ,UACGoC,YAFlB,AAAAxB;;gDAM6B,UAA7B,AAAAA;;4CArB0B,uBACXZ,UACGoC,YAFlB,AAAAxB","file":null,"sourcesContent":null,"sourceRoot":null}