@f1studio/form-spec 5.0.0-alpha.111 → 5.0.0-alpha.112

package/src/FormSpec.FS/FormSpec.ts

@@ -6,6 +6,7 @@ import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
 import { FSharpMap } from "@fable-org/fable-library-js/Map.js";
 import { FSharpSet } from "@fable-org/fable-library-js/Set.js";
 import { ofArray, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { IntegrationProvenance_$reflection, IntegrationProvenance } from "./Provenance.js";
 import { newGuid, tryParse } from "@fable-org/fable-library-js/Guid.js";
 import { item } from "@fable-org/fable-library-js/Array.js";
 import { split } from "@fable-org/fable-library-js/String.js";
@@ -996,6 +997,7 @@ export type Spec_FieldType_$union =
     | Spec_FieldType<20>
     | Spec_FieldType<21>
     | Spec_FieldType<22>
+    | Spec_FieldType<23>
 
 export type Spec_FieldType_$cases = {
     0: ["Text", [Spec_TextInfo]],
@@ -1020,7 +1022,8 @@ export type Spec_FieldType_$cases = {
     19: ["Matrix", [Spec_MatrixInfo]],
     20: ["Signature", [Spec_SignatureInfo]],
     21: ["Message", [Spec_MessageInfo]],
-    22: ["PluginField", [Spec_PluginFieldConfig]]
+    22: ["UnsupportedField", [Spec_UnsupportedFieldInfo]],
+    23: ["PluginField", [Spec_PluginFieldConfig]]
 }
 
 export function Spec_FieldType_Text(Item: Spec_TextInfo) {
@@ -1111,21 +1114,41 @@ export function Spec_FieldType_Message(Item: Spec_MessageInfo) {
     return new Spec_FieldType<21>(21, [Item]);
 }
 
-export function Spec_FieldType_PluginField(Item: Spec_PluginFieldConfig) {
+export function Spec_FieldType_UnsupportedField(Item: Spec_UnsupportedFieldInfo) {
     return new Spec_FieldType<22>(22, [Item]);
 }
 
+export function Spec_FieldType_PluginField(Item: Spec_PluginFieldConfig) {
+    return new Spec_FieldType<23>(23, [Item]);
+}
+
 export class Spec_FieldType<Tag extends keyof Spec_FieldType_$cases> extends Union<Tag, Spec_FieldType_$cases[Tag][0]> {
     constructor(readonly tag: Tag, readonly fields: Spec_FieldType_$cases[Tag][1]) {
         super();
     }
     cases() {
-        return ["Text", "TextArea", "Email", "Password", "Search", "Color", "Number", "Tel", "Date", "DateTimeLocal", "Time", "Checkbox", "Radio", "SingleChoice", "Dropdown", "MultiChoice", "CheckboxList", "TagList", "TextAutoComplete", "Matrix", "Signature", "Message", "PluginField"];
+        return ["Text", "TextArea", "Email", "Password", "Search", "Color", "Number", "Tel", "Date", "DateTimeLocal", "Time", "Checkbox", "Radio", "SingleChoice", "Dropdown", "MultiChoice", "CheckboxList", "TagList", "TextAutoComplete", "Matrix", "Signature", "Message", "UnsupportedField", "PluginField"];
     }
 }
 
 export function Spec_FieldType_$reflection(): TypeInfo {
-    return union_type("F1.Studio.Spec.FieldType", [], Spec_FieldType, () => [[["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_BooleanInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_MatrixInfo_$reflection()]], [["Item", Spec_SignatureInfo_$reflection()]], [["Item", Spec_MessageInfo_$reflection()]], [["Item", Spec_PluginFieldConfig_$reflection()]]]);
+    return union_type("F1.Studio.Spec.FieldType", [], Spec_FieldType, () => [[["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_TextInfo_$reflection()]], [["Item", Spec_BooleanInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_MultiChoiceInfo_$reflection()]], [["Item", Spec_SingleChoiceInfo_$reflection()]], [["Item", Spec_MatrixInfo_$reflection()]], [["Item", Spec_SignatureInfo_$reflection()]], [["Item", Spec_MessageInfo_$reflection()]], [["Item", Spec_UnsupportedFieldInfo_$reflection()]], [["Item", Spec_PluginFieldConfig_$reflection()]]]);
+}
+
+export class Spec_UnsupportedFieldInfo extends Record implements IEquatable<Spec_UnsupportedFieldInfo>, IComparable<Spec_UnsupportedFieldInfo> {
+    readonly CoreMRItemId: int32;
+    readonly Code: string;
+    readonly ItemTypeId: int32;
+    constructor(CoreMRItemId: int32, Code: string, ItemTypeId: int32) {
+        super();
+        this.CoreMRItemId = (CoreMRItemId | 0);
+        this.Code = Code;
+        this.ItemTypeId = (ItemTypeId | 0);
+    }
+}
+
+export function Spec_UnsupportedFieldInfo_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Spec.UnsupportedFieldInfo", [], Spec_UnsupportedFieldInfo, () => [["CoreMRItemId", int32_type], ["Code", string_type], ["ItemTypeId", int32_type]]);
 }
 
 export class Spec_FieldAnswerFlag extends Record implements IEquatable<Spec_FieldAnswerFlag>, IComparable<Spec_FieldAnswerFlag> {
@@ -1150,9 +1173,11 @@ export class Spec_FormField$1<FieldType> extends Record implements IEquatable<Sp
     readonly DependsOn: Option<Spec_DependsOn>;
     readonly IsOptional: boolean;
     readonly IsDeprecated: boolean;
+    readonly NeedsDocumentation: boolean;
+    readonly Documentation: Option<string>;
     readonly FieldType: FieldType;
     readonly Value: Option<Shared_FieldValue_$union>;
-    constructor(FieldOrder: int32, FieldKey: Shared_FieldKey, Label: string, Notes: Option<string>, DependsOn: Option<Spec_DependsOn>, IsOptional: boolean, IsDeprecated: boolean, FieldType: FieldType, Value: Option<Shared_FieldValue_$union>) {
+    constructor(FieldOrder: int32, FieldKey: Shared_FieldKey, Label: string, Notes: Option<string>, DependsOn: Option<Spec_DependsOn>, IsOptional: boolean, IsDeprecated: boolean, NeedsDocumentation: boolean, Documentation: Option<string>, FieldType: FieldType, Value: Option<Shared_FieldValue_$union>) {
         super();
         this.FieldOrder = (FieldOrder | 0);
         this.FieldKey = FieldKey;
@@ -1161,13 +1186,15 @@ export class Spec_FormField$1<FieldType> extends Record implements IEquatable<Sp
         this.DependsOn = DependsOn;
         this.IsOptional = IsOptional;
         this.IsDeprecated = IsDeprecated;
+        this.NeedsDocumentation = NeedsDocumentation;
+        this.Documentation = Documentation;
         this.FieldType = FieldType;
         this.Value = Value;
     }
 }
 
 export function Spec_FormField$1_$reflection(gen0: TypeInfo): TypeInfo {
-    return record_type("F1.Studio.Spec.FormField`1", [gen0], Spec_FormField$1, () => [["FieldOrder", int32_type], ["FieldKey", Shared_FieldKey_$reflection()], ["Label", string_type], ["Notes", option_type(string_type)], ["DependsOn", option_type(Spec_DependsOn_$reflection())], ["IsOptional", bool_type], ["IsDeprecated", bool_type], ["FieldType", gen0], ["Value", option_type(Shared_FieldValue_$reflection())]]);
+    return record_type("F1.Studio.Spec.FormField`1", [gen0], Spec_FormField$1, () => [["FieldOrder", int32_type], ["FieldKey", Shared_FieldKey_$reflection()], ["Label", string_type], ["Notes", option_type(string_type)], ["DependsOn", option_type(Spec_DependsOn_$reflection())], ["IsOptional", bool_type], ["IsDeprecated", bool_type], ["NeedsDocumentation", bool_type], ["Documentation", option_type(string_type)], ["FieldType", gen0], ["Value", option_type(Shared_FieldValue_$reflection())]]);
 }
 
 export class Spec_FormStep$1<FieldType> extends Record implements IEquatable<Spec_FormStep$1<FieldType>>, IComparable<Spec_FormStep$1<FieldType>> {
@@ -1362,7 +1389,9 @@ export class Spec_FormSpec$1<FieldType> extends Record implements IEquatable<Spe
     readonly ClinicalPathway: Option<ClinicalPathway_ClinicalPathwaySpec>;
     readonly Lifecycle: Spec_FormLifecycle_$union;
     readonly FilledMeta: Option<Spec_FilledMeta>;
-    constructor(Id: string, Code: Option<string>, Title: string, Abstract: string, Version: string, FormSpecVersion: string, Steps: FSharpList<Spec_FormStep$1<FieldType>>, CategoryTags: FSharpList<string>, Score: Option<Spec_Score>, AssociatedCodes: FSharpList<string>, RequiresReview: boolean, RequiresReviewAndApproval: boolean, ClinicalPathway: Option<ClinicalPathway_ClinicalPathwaySpec>, Lifecycle: Spec_FormLifecycle_$union, FilledMeta: Option<Spec_FilledMeta>) {
+    readonly CustomData: Option<FSharpMap<string, string>>;
+    readonly Provenance: Option<IntegrationProvenance>;
+    constructor(Id: string, Code: Option<string>, Title: string, Abstract: string, Version: string, FormSpecVersion: string, Steps: FSharpList<Spec_FormStep$1<FieldType>>, CategoryTags: FSharpList<string>, Score: Option<Spec_Score>, AssociatedCodes: FSharpList<string>, RequiresReview: boolean, RequiresReviewAndApproval: boolean, ClinicalPathway: Option<ClinicalPathway_ClinicalPathwaySpec>, Lifecycle: Spec_FormLifecycle_$union, FilledMeta: Option<Spec_FilledMeta>, CustomData: Option<FSharpMap<string, string>>, Provenance: Option<IntegrationProvenance>) {
         super();
         this.Id = Id;
         this.Code = Code;
@@ -1379,11 +1408,13 @@ export class Spec_FormSpec$1<FieldType> extends Record implements IEquatable<Spe
         this.ClinicalPathway = ClinicalPathway;
         this.Lifecycle = Lifecycle;
         this.FilledMeta = FilledMeta;
+        this.CustomData = CustomData;
+        this.Provenance = Provenance;
     }
 }
 
 export function Spec_FormSpec$1_$reflection(gen0: TypeInfo): TypeInfo {
-    return record_type("F1.Studio.Spec.FormSpec`1", [gen0], Spec_FormSpec$1, () => [["Id", class_type("System.Guid")], ["Code", option_type(string_type)], ["Title", string_type], ["Abstract", string_type], ["Version", string_type], ["FormSpecVersion", string_type], ["Steps", list_type(Spec_FormStep$1_$reflection(gen0))], ["CategoryTags", list_type(string_type)], ["Score", option_type(Spec_Score_$reflection())], ["AssociatedCodes", list_type(string_type)], ["RequiresReview", bool_type], ["RequiresReviewAndApproval", bool_type], ["ClinicalPathway", option_type(ClinicalPathway_ClinicalPathwaySpec_$reflection())], ["Lifecycle", Spec_FormLifecycle_$reflection()], ["FilledMeta", option_type(Spec_FilledMeta_$reflection())]]);
+    return record_type("F1.Studio.Spec.FormSpec`1", [gen0], Spec_FormSpec$1, () => [["Id", class_type("System.Guid")], ["Code", option_type(string_type)], ["Title", string_type], ["Abstract", string_type], ["Version", string_type], ["FormSpecVersion", string_type], ["Steps", list_type(Spec_FormStep$1_$reflection(gen0))], ["CategoryTags", list_type(string_type)], ["Score", option_type(Spec_Score_$reflection())], ["AssociatedCodes", list_type(string_type)], ["RequiresReview", bool_type], ["RequiresReviewAndApproval", bool_type], ["ClinicalPathway", option_type(ClinicalPathway_ClinicalPathwaySpec_$reflection())], ["Lifecycle", Spec_FormLifecycle_$reflection()], ["FilledMeta", option_type(Spec_FilledMeta_$reflection())], ["CustomData", option_type(class_type("Microsoft.FSharp.Collections.FSharpMap`2", [string_type, string_type]))], ["Provenance", option_type(IntegrationProvenance_$reflection())]]);
 }
 
 export function Spec_Evaluator__get_Key(x: Spec_Evaluator_$union): string {

package/src/FormSpec.FS/FormSpecHelpers.ts

@@ -1,17 +1,18 @@
-import { singleton, head, isEmpty, ofSeq, iterate, forAll, exists, FSharpList, empty, sortBy, mapIndexed, map } from "@fable-org/fable-library-js/List.js";
-import { float64, int32 } from "@fable-org/fable-library-js/Int32.js";
+import { singleton, head, isEmpty, ofSeq, iterate, forAll, exists, sumBy, collect, tryFind, FSharpList, empty, sortBy, mapIndexed, map } from "@fable-org/fable-library-js/List.js";
+import { tryParse as tryParse_1, float64, int32 } from "@fable-org/fable-library-js/Int32.js";
 import { getFieldDetails, FormSpecMetadata, FieldDetails$1 } from "./FormSpecValues.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, ClinicalPathway_ConstraintDefinition, ClinicalPathway_ConstraintType_$union, ClinicalPathway_TransitionDefinition, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_LogicalOp_$union, Shared_PluginPropertyKey, Shared_FieldOptionKey, Shared_ConditionValue_$union, ClinicalPathway_FieldEvaluator_$union, Shared_PluginDataProperty_$reflection, Shared_PluginDataProperty, Shared_MatrixItemKey, Shared_FieldAnswer, Shared_FieldValue_$union, Spec_FormSpec$1, Spec_FormLifecycle_Draft, Values_StepOrder, Spec_FormStep$1, Shared_FieldKey, Spec_FormField$1, Spec_FieldType_$union } from "./FormSpec.js";
+import { Shared_FieldValue_Single, Shared_FieldValue_PluginData, Shared_FieldValue_Matrix, Shared_FieldValue_Multiple, Shared_ConditionValue_Single, Shared_ConditionValue_PluginData, Shared_ConditionValue_Matrix, Shared_ConditionValue_Multiple, ClinicalPathway_ConstraintDefinition, ClinicalPathway_ConstraintType_$union, ClinicalPathway_TransitionDefinition, ClinicalPathway_ClinicalPathwaySpec, ClinicalPathway_TransitionCondition_$union, ClinicalPathway_LogicalOp_$union, Shared_MatrixAnswer, Shared_PluginPropertyKey, Shared_FieldOptionKey, Shared_ConditionValue_$union, ClinicalPathway_FieldEvaluator_$union, Shared_PluginDataProperty_$reflection, Shared_PluginDataProperty, Shared_MatrixItemKey, Shared_FieldAnswer, Shared_FieldValue_$union, Spec_FormSpec$1, Spec_FormLifecycle_Draft, Values_StepOrder, Spec_FormStep$1, Shared_FieldKey, Spec_FormField$1, Spec_FieldType_$union } from "./FormSpec.js";
 import { FSharpMap, toList } from "@fable-org/fable-library-js/Map.js";
-import { compare, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
+import { compare, int32ToString, equals, comparePrimitives } from "@fable-org/fable-library-js/Util.js";
 import { newGuid } from "@fable-org/fable-library-js/Guid.js";
-import { value as value_2, Option, bind } from "@fable-org/fable-library-js/Option.js";
-import { join } from "@fable-org/fable-library-js/String.js";
-import { map as map_1, toList as toList_1 } from "@fable-org/fable-library-js/Set.js";
+import { orElse, map as map_1, filter, defaultArg, value as value_2, Option, bind } from "@fable-org/fable-library-js/Option.js";
+import { isNullOrEmpty, join } from "@fable-org/fable-library-js/String.js";
+import { map as map_2, toList as toList_1 } from "@fable-org/fable-library-js/Set.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 { tryParse } from "@fable-org/fable-library-js/Double.js";
 import { FSharpRef } from "@fable-org/fable-library-js/Types.js";
+import { PluginValueRegistry_tryGet, IPluginValueConverter } from "./PluginInterface.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";
 
@@ -23,13 +24,13 @@ export function buildFormSpecFromResultStepsMap(details: FormSpecMetadata, steps
         const stepOrder: int32 = tupledArg_1[0].fields[0] | 0;
         return new Spec_FormStep$1(stepOrder, `Step ${stepOrder}`, mapIndexed<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>], Spec_FormField$1<Spec_FieldType_$union>>((i: int32, tupledArg_3: [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]): Spec_FormField$1<Spec_FieldType_$union> => {
             const fd_1: FieldDetails$1<Spec_FieldType_$union> = tupledArg_3[1];
-            return new Spec_FormField$1(i + 1, tupledArg_3[0], fd_1.Label, undefined, undefined, false, false, fd_1.FieldType, fd_1.FieldValue);
+            return new Spec_FormField$1(i + 1, tupledArg_3[0], fd_1.Label, undefined, undefined, false, false, false, undefined, fd_1.FieldType, fd_1.FieldValue);
         }, sortBy<[Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>], int32>((tupledArg_2: [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]): int32 => tupledArg_2[1].FieldOrder, toList<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>(tupledArg_1[1]), {
             Compare: comparePrimitives,
         })));
     }, sortBy<[Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>], int32>((tupledArg: [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]): int32 => tupledArg[0].fields[0], toList<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>(stepsMap), {
         Compare: comparePrimitives,
-    })), empty<string>(), details.MaxScore, empty<string>(), false, false, undefined, Spec_FormLifecycle_Draft(newGuid()), undefined);
+    })), empty<string>(), details.MaxScore, empty<string>(), false, false, undefined, Spec_FormLifecycle_Draft(newGuid()), undefined, undefined, undefined);
 }
 
 /**
@@ -112,6 +113,140 @@ export function fieldLessThan(fieldKey: Shared_FieldKey, threshold: float64, for
     }
 }
 
+/**
+ * Evaluate a field condition when actual value is already known (for plugin property conditions)
+ */
+export function evaluateFieldConditionByValue(actualValue: string, evaluator: ClinicalPathway_FieldEvaluator_$union, expectedValue: string): boolean {
+    switch (evaluator.tag) {
+        case /* Equals */ 0:
+            return actualValue.trim().toLocaleLowerCase() === expectedValue.trim().toLocaleLowerCase();
+        case /* NotEquals */ 1:
+            return actualValue.trim().toLocaleLowerCase() !== expectedValue.trim().toLocaleLowerCase();
+        case /* GreaterThan */ 5: {
+            let matchValue: [boolean, float64];
+            let outArg = 0;
+            matchValue = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg, (v: float64): void => {
+                outArg = v;
+            })), outArg] as [boolean, float64]);
+            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]);
+            let matchResult: int32;
+            if (matchValue[0]) {
+                if (matchValue_1[0]) {
+                    matchResult = 0;
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return matchValue[1] > matchValue_1[1];
+                default:
+                    return false;
+            }
+        }
+        case /* GreaterOrEqual */ 6: {
+            let matchValue_3: [boolean, float64];
+            let outArg_2 = 0;
+            matchValue_3 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_2, (v_2: float64): void => {
+                outArg_2 = v_2;
+            })), outArg_2] as [boolean, float64]);
+            let matchValue_4: [boolean, float64];
+            let outArg_3 = 0;
+            matchValue_4 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_3, (v_3: float64): void => {
+                outArg_3 = v_3;
+            })), outArg_3] as [boolean, float64]);
+            let matchResult_1: int32;
+            if (matchValue_3[0]) {
+                if (matchValue_4[0]) {
+                    matchResult_1 = 0;
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+            }
+            else {
+                matchResult_1 = 1;
+            }
+            switch (matchResult_1) {
+                case 0:
+                    return matchValue_3[1] >= matchValue_4[1];
+                default:
+                    return false;
+            }
+        }
+        case /* LessThan */ 7: {
+            let matchValue_6: [boolean, float64];
+            let outArg_4 = 0;
+            matchValue_6 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_4, (v_4: float64): void => {
+                outArg_4 = v_4;
+            })), outArg_4] as [boolean, float64]);
+            let matchValue_7: [boolean, float64];
+            let outArg_5 = 0;
+            matchValue_7 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_5, (v_5: float64): void => {
+                outArg_5 = v_5;
+            })), outArg_5] as [boolean, float64]);
+            let matchResult_2: int32;
+            if (matchValue_6[0]) {
+                if (matchValue_7[0]) {
+                    matchResult_2 = 0;
+                }
+                else {
+                    matchResult_2 = 1;
+                }
+            }
+            else {
+                matchResult_2 = 1;
+            }
+            switch (matchResult_2) {
+                case 0:
+                    return matchValue_6[1] < matchValue_7[1];
+                default:
+                    return false;
+            }
+        }
+        case /* LessOrEqual */ 8: {
+            let matchValue_9: [boolean, float64];
+            let outArg_6 = 0;
+            matchValue_9 = ([tryParse(actualValue, new FSharpRef<float64>((): float64 => outArg_6, (v_6: float64): void => {
+                outArg_6 = v_6;
+            })), outArg_6] as [boolean, float64]);
+            let matchValue_10: [boolean, float64];
+            let outArg_7 = 0;
+            matchValue_10 = ([tryParse(expectedValue, new FSharpRef<float64>((): float64 => outArg_7, (v_7: float64): void => {
+                outArg_7 = v_7;
+            })), outArg_7] as [boolean, float64]);
+            let matchResult_3: int32;
+            if (matchValue_9[0]) {
+                if (matchValue_10[0]) {
+                    matchResult_3 = 0;
+                }
+                else {
+                    matchResult_3 = 1;
+                }
+            }
+            else {
+                matchResult_3 = 1;
+            }
+            switch (matchResult_3) {
+                case 0:
+                    return matchValue_9[1] <= matchValue_10[1];
+                default:
+                    return false;
+            }
+        }
+        default:
+            return false;
+    }
+}
+
 /**
  * Evaluate a single field condition (string-based, for backward compatibility)
  */
@@ -215,7 +350,50 @@ export function evaluateCondition(formSpec: Spec_FormSpec$1<Spec_FieldType_$unio
             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_1<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<Shared_MatrixItemKey, string>(conditionValue_2.fields[0]))) : ((conditionValue_2.tag === /* PluginData */ 3) ? conditionValue_2.fields[0].Value : conditionValue_2.fields[0]));
-            return false;
+            return evaluateFieldConditionByValue(defaultArg(bind<FieldDetails$1<Spec_FieldType_$union>, string>((details: FieldDetails$1<Spec_FieldType_$union>): Option<string> => {
+                const pluginIdOpt: Option<string> = filter<string>((id: string): boolean => !isNullOrEmpty(id), map_1<Spec_FormField$1<Spec_FieldType_$union>, string>((f_1: Spec_FormField$1<Spec_FieldType_$union>): string => {
+                    const matchValue: Spec_FieldType_$union = f_1.FieldType;
+                    switch (matchValue.tag) {
+                        case /* PluginField */ 23:
+                            return matchValue.fields[0].PluginId;
+                        case /* Matrix */ 19:
+                            return "Fable.Form.Simple.Bulma.Fields.LikertField";
+                        default:
+                            return "";
+                    }
+                }, tryFind<Spec_FormField$1<Spec_FieldType_$union>>((f: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(f.FieldKey, fieldKey_2), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((s: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => s.Fields, formSpec.Steps))));
+                if (pluginIdOpt == null) {
+                    return undefined;
+                }
+                else {
+                    return bind<IPluginValueConverter, string>((converter: IPluginValueConverter): Option<string> => {
+                        let matchValue_1: Shared_FieldValue_$union, matrixValue: Shared_MatrixAnswer;
+                        return orElse(map_1<Shared_PluginDataProperty, string>((p: Shared_PluginDataProperty): string => p.Value, converter.GetPropertyByKey(propertyKey, details.FieldValue)), (matchValue_1 = details.FieldValue, (matchValue_1.tag === /* Matrix */ 2) ? ((matrixValue = matchValue_1.fields[0], bind<Shared_PluginDataProperty, string>((propMeta: Shared_PluginDataProperty): Option<string> => {
+                            if (propMeta.Name === "TotalScore") {
+                                return int32ToString(sumBy<[Shared_MatrixItemKey, string], int32>((tupledArg_3: [Shared_MatrixItemKey, string]): int32 => {
+                                    let matchValue_2: [boolean, int32];
+                                    let outArg = 0;
+                                    matchValue_2 = ([tryParse_1(tupledArg_3[1].trim(), 511, false, 32, new FSharpRef<int32>((): int32 => outArg, (v_7: int32): void => {
+                                        outArg = (v_7 | 0);
+                                    })), outArg] as [boolean, int32]);
+                                    if (matchValue_2[0]) {
+                                        return matchValue_2[1] | 0;
+                                    }
+                                    else {
+                                        return 0;
+                                    }
+                                }, toList<Shared_MatrixItemKey, string>(matrixValue.Values), {
+                                    GetZero: (): int32 => 0,
+                                    Add: (x: int32, y: int32): int32 => (x + y),
+                                }));
+                            }
+                            else {
+                                return undefined;
+                            }
+                        }, converter.GetPropertyMetadataByKey(propertyKey)))) : undefined));
+                    }, PluginValueRegistry_tryGet(value_2(pluginIdOpt)));
+                }
+            }, getFieldDetails(formSpec, fieldKey_2)), ""), evaluator_2, expectedValueStr_2);
         }
         case /* CompositeCondition */ 6: {
             const operator: ClinicalPathway_LogicalOp_$union = condition.fields[0];
@@ -357,7 +535,7 @@ export function validateGuidOnlyFormSpec(formSpec: Spec_FormSpec$1<Spec_FieldTyp
 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], {
+            return Shared_ConditionValue_Multiple(map_2<Shared_FieldAnswer, string>((a: Shared_FieldAnswer): string => a.Value, fieldValue.fields[0], {
                 Compare: comparePrimitives,
             }));
         case /* Matrix */ 2:
@@ -382,7 +560,7 @@ export function fieldValueToConditionValue(fieldValue: Shared_FieldValue_$union)
 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], {
+            return Shared_FieldValue_Multiple(map_2<string, Shared_FieldAnswer>((value_1: string): Shared_FieldAnswer => (new Shared_FieldAnswer(fieldKey, fieldLabel, value_1)), conditionValue.fields[0], {
                 Compare: compare,
             }));
         case /* Matrix */ 2:

package/src/FormSpec.FS/FormSpecValues.ts

@@ -52,6 +52,22 @@ export function FieldDetails$1_$reflection(gen0: TypeInfo): TypeInfo {
 function optionsFromField(field: Spec_FormField$1<Spec_FieldType_$union>): FSharpList<Shared_FieldOption> {
     const matchValue: Spec_FieldType_$union = field.FieldType;
     switch (matchValue.tag) {
+        case /* Checkbox */ 11:
+        case /* Email */ 2:
+        case /* Password */ 3:
+        case /* Search */ 4:
+        case /* Color */ 5:
+        case /* Number */ 6:
+        case /* Tel */ 7:
+        case /* Text */ 0:
+        case /* TextArea */ 1:
+        case /* Date */ 8:
+        case /* DateTimeLocal */ 9:
+        case /* Time */ 10:
+        case /* Message */ 21:
+        case /* Signature */ 20:
+        case /* PluginField */ 23:
+            return empty<Shared_FieldOption>();
         case /* CheckboxList */ 16:
             return matchValue.fields[0].Options;
         case /* MultiChoice */ 15:
@@ -69,7 +85,7 @@ function optionsFromField(field: Spec_FormField$1<Spec_FieldType_$union>): FShar
         case /* Matrix */ 19:
             return matchValue.fields[0].Options;
         default:
-            return empty<Shared_FieldOption>();
+            throw new Error("Match failure: F1.Studio.Spec.FieldType");
     }
 }
 
@@ -97,7 +113,30 @@ export function updateField<FieldType>(spec: Spec_FormSpec$1<FieldType>, fieldKe
         if (i_1 === stepIndex) {
             return new Spec_FormStep$1(step.StepOrder, step.StepLabel, map<Spec_FormField$1<FieldType>, Spec_FormField$1<FieldType>>((f: Spec_FormField$1<FieldType>): Spec_FormField$1<FieldType> => {
                 if (equals(f.FieldKey, fieldKey)) {
-                    return new Spec_FormField$1(f.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.FieldType, newValue);
+                    return new Spec_FormField$1(f.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.NeedsDocumentation, f.Documentation, f.FieldType, newValue);
+                }
+                else {
+                    return f;
+                }
+            }, step.Fields));
+        }
+        else {
+            return step;
+        }
+    }, spec.Steps), spec.CategoryTags, spec.Score, spec.AssociatedCodes, spec.RequiresReview, spec.RequiresReviewAndApproval, spec.ClinicalPathway, spec.Lifecycle, spec.FilledMeta, spec.CustomData, spec.Provenance);
+}
+
+/**
+ * Update a single field's Documentation. Returns new FormSpec.
+ * If stepIndex is None, searches for the field across all steps.
+ */
+export function updateFieldDocumentation<FieldType>(spec: Spec_FormSpec$1<FieldType>, fieldKey: Shared_FieldKey, newDoc: Option<string>, stepIndexOpt: Option<int32>): Spec_FormSpec$1<FieldType> {
+    const stepIndex: int32 = ((stepIndexOpt == null) ? defaultArg(findStepIndexForField<FieldType>(spec, fieldKey), 0) : value_1(stepIndexOpt)) | 0;
+    return new Spec_FormSpec$1(spec.Id, spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, mapIndexed<Spec_FormStep$1<FieldType>, Spec_FormStep$1<FieldType>>((i_1: int32, step: Spec_FormStep$1<FieldType>): Spec_FormStep$1<FieldType> => {
+        if (i_1 === stepIndex) {
+            return new Spec_FormStep$1(step.StepOrder, step.StepLabel, map<Spec_FormField$1<FieldType>, Spec_FormField$1<FieldType>>((f: Spec_FormField$1<FieldType>): Spec_FormField$1<FieldType> => {
+                if (equals(f.FieldKey, fieldKey)) {
+                    return new Spec_FormField$1(f.FieldOrder, f.FieldKey, f.Label, f.Notes, f.DependsOn, f.IsOptional, f.IsDeprecated, f.NeedsDocumentation, newDoc, f.FieldType, f.Value);
                 }
                 else {
                     return f;
@@ -107,7 +146,7 @@ export function updateField<FieldType>(spec: Spec_FormSpec$1<FieldType>, fieldKe
         else {
             return step;
         }
-    }, spec.Steps), spec.CategoryTags, spec.Score, spec.AssociatedCodes, spec.RequiresReview, spec.RequiresReviewAndApproval, spec.ClinicalPathway, spec.Lifecycle, spec.FilledMeta);
+    }, spec.Steps), spec.CategoryTags, spec.Score, spec.AssociatedCodes, spec.RequiresReview, spec.RequiresReviewAndApproval, spec.ClinicalPathway, spec.Lifecycle, spec.FilledMeta, spec.CustomData, spec.Provenance);
 }
 
 /**