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

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRFormSpecValidator.ts

@@ -0,0 +1,490 @@
+import { toString, Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { defaultArg, value as value_3, map as map_1, Option } from "@fable-org/fable-library-js/Option.js";
+import { record_type, list_type, union_type, option_type, bool_type, string_type, int32_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { isEmpty, filter, empty as empty_1, singleton as singleton_1, ofSeq, choose, collect, map, sumBy, length, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { IDisposable, disposeSafe, IEnumerator, getEnumerator, compare, int32ToString, comparePrimitives, numberHash, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { HeadingItem, detectHeadings } from "./CorEMRSectioning.js";
+import { CoreMRTrigger, CoreMRFormData, CoreMRFormMetadata, CoreMRChoice, CoreMRItem } from "../../CorEMR/CoreMRTypes.js";
+import { ClinicalPathway_ClinicalPathwaySpec, Spec_Score, Spec_SingleChoiceInfo, Spec_MultiChoiceInfo, Spec_FormField$1, Shared_FieldKey, Spec_FormSpec$1, Spec_FieldType_$union, Spec_FormStep$1 } from "../../../FormSpec.js";
+import { tryFind, FSharpMap, ofList } from "@fable-org/fable-library-js/Map.js";
+import { List_groupBy } from "@fable-org/fable-library-js/Seq2.js";
+import { empty, singleton, append, delay, toList } from "@fable-org/fable-library-js/Seq.js";
+import { getElementTypeInfo } from "./CorEMRElementTypeMap.js";
+import { FSharpResult$2_$union, FSharpResult$2_Ok, FSharpResult$2_Error } from "@fable-org/fable-library-js/Result.js";
+
+export type ValidationError_$union = 
+    | ValidationError<0>
+    | ValidationError<1>
+    | ValidationError<2>
+    | ValidationError<3>
+    | ValidationError<4>
+    | ValidationError<5>
+    | ValidationError<6>
+    | ValidationError<7>
+    | ValidationError<8>
+    | ValidationError<9>
+    | ValidationError<10>
+    | ValidationError<11>
+    | ValidationError<12>
+    | ValidationError<13>
+    | ValidationError<14>
+    | ValidationError<15>
+    | ValidationError<16>
+
+export type ValidationError_$cases = {
+    0: ["ItemCountMismatch", [int32, int32]],
+    1: ["StepCountMismatch", [int32, int32]],
+    2: ["FieldCountMismatch", [string, int32, int32]],
+    3: ["MetadataMismatch", [string, string, string]],
+    4: ["MissingChoices", [int32, string]],
+    5: ["InvalidFieldType", [int32, string, string]],
+    6: ["HeadingNotConverted", [int32, string]],
+    7: ["MissingStep", [string]],
+    8: ["ChoiceCountMismatch", [int32, string, int32, int32]],
+    9: ["RequiredFieldMismatch", [int32, string, boolean, boolean]],
+    10: ["ScoreMismatch", [int32, Option<int32>]],
+    11: ["TagCountMismatch", [int32, int32]],
+    12: ["PathwayMissing", [int32]],
+    13: ["PathwayStateCountInvalid", [string, int32, int32]],
+    14: ["PathwayTransitionCountInvalid", [string, int32, int32]],
+    15: ["TriggerConditionCountMismatch", [int32, int32, int32]],
+    16: ["TriggerEventCountMismatch", [int32, int32, int32]]
+}
+
+export function ValidationError_ItemCountMismatch(expected: int32, actual: int32) {
+    return new ValidationError<0>(0, [expected, actual]);
+}
+
+export function ValidationError_StepCountMismatch(expected: int32, actual: int32) {
+    return new ValidationError<1>(1, [expected, actual]);
+}
+
+export function ValidationError_FieldCountMismatch(step: string, expected: int32, actual: int32) {
+    return new ValidationError<2>(2, [step, expected, actual]);
+}
+
+export function ValidationError_MetadataMismatch(field: string, expected: string, actual: string) {
+    return new ValidationError<3>(3, [field, expected, actual]);
+}
+
+export function ValidationError_MissingChoices(itemId: int32, itemLabel: string) {
+    return new ValidationError<4>(4, [itemId, itemLabel]);
+}
+
+export function ValidationError_InvalidFieldType(itemId: int32, itemType: string, reason: string) {
+    return new ValidationError<5>(5, [itemId, itemType, reason]);
+}
+
+export function ValidationError_HeadingNotConverted(itemId: int32, heading: string) {
+    return new ValidationError<6>(6, [itemId, heading]);
+}
+
+export function ValidationError_MissingStep(heading: string) {
+    return new ValidationError<7>(7, [heading]);
+}
+
+export function ValidationError_ChoiceCountMismatch(itemId: int32, itemLabel: string, expected: int32, actual: int32) {
+    return new ValidationError<8>(8, [itemId, itemLabel, expected, actual]);
+}
+
+export function ValidationError_RequiredFieldMismatch(itemId: int32, itemLabel: string, expected: boolean, actual: boolean) {
+    return new ValidationError<9>(9, [itemId, itemLabel, expected, actual]);
+}
+
+export function ValidationError_ScoreMismatch(expected: int32, actual: Option<int32>) {
+    return new ValidationError<10>(10, [expected, actual]);
+}
+
+export function ValidationError_TagCountMismatch(expected: int32, actual: int32) {
+    return new ValidationError<11>(11, [expected, actual]);
+}
+
+export function ValidationError_PathwayMissing(triggerCount: int32) {
+    return new ValidationError<12>(12, [triggerCount]);
+}
+
+export function ValidationError_PathwayStateCountInvalid(pathwayId: string, expected: int32, actual: int32) {
+    return new ValidationError<13>(13, [pathwayId, expected, actual]);
+}
+
+export function ValidationError_PathwayTransitionCountInvalid(pathwayId: string, expected: int32, actual: int32) {
+    return new ValidationError<14>(14, [pathwayId, expected, actual]);
+}
+
+export function ValidationError_TriggerConditionCountMismatch(triggerId: int32, expected: int32, actual: int32) {
+    return new ValidationError<15>(15, [triggerId, expected, actual]);
+}
+
+export function ValidationError_TriggerEventCountMismatch(triggerId: int32, expected: int32, actual: int32) {
+    return new ValidationError<16>(16, [triggerId, expected, actual]);
+}
+
+export class ValidationError<Tag extends keyof ValidationError_$cases> extends Union<Tag, ValidationError_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: ValidationError_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["ItemCountMismatch", "StepCountMismatch", "FieldCountMismatch", "MetadataMismatch", "MissingChoices", "InvalidFieldType", "HeadingNotConverted", "MissingStep", "ChoiceCountMismatch", "RequiredFieldMismatch", "ScoreMismatch", "TagCountMismatch", "PathwayMissing", "PathwayStateCountInvalid", "PathwayTransitionCountInvalid", "TriggerConditionCountMismatch", "TriggerEventCountMismatch"];
+    }
+}
+
+export function ValidationError_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.CorEMRFormSpecValidator.ValidationError", [], ValidationError, () => [[["expected", int32_type], ["actual", int32_type]], [["expected", int32_type], ["actual", int32_type]], [["step", string_type], ["expected", int32_type], ["actual", int32_type]], [["field", string_type], ["expected", string_type], ["actual", string_type]], [["itemId", int32_type], ["itemLabel", string_type]], [["itemId", int32_type], ["itemType", string_type], ["reason", string_type]], [["itemId", int32_type], ["heading", string_type]], [["heading", string_type]], [["itemId", int32_type], ["itemLabel", string_type], ["expected", int32_type], ["actual", int32_type]], [["itemId", int32_type], ["itemLabel", string_type], ["expected", bool_type], ["actual", bool_type]], [["expected", int32_type], ["actual", option_type(int32_type)]], [["expected", int32_type], ["actual", int32_type]], [["triggerCount", int32_type]], [["pathwayId", string_type], ["expected", int32_type], ["actual", int32_type]], [["pathwayId", string_type], ["expected", int32_type], ["actual", int32_type]], [["triggerId", int32_type], ["expected", int32_type], ["actual", int32_type]], [["triggerId", int32_type], ["expected", int32_type], ["actual", int32_type]]]);
+}
+
+export class ValidationResult extends Record implements IEquatable<ValidationResult>, IComparable<ValidationResult> {
+    readonly IsValid: boolean;
+    readonly Errors: FSharpList<ValidationError_$union>;
+    readonly Warnings: FSharpList<ValidationError_$union>;
+    readonly Summary: ValidationSummary;
+    constructor(IsValid: boolean, Errors: FSharpList<ValidationError_$union>, Warnings: FSharpList<ValidationError_$union>, Summary: ValidationSummary) {
+        super();
+        this.IsValid = IsValid;
+        this.Errors = Errors;
+        this.Warnings = Warnings;
+        this.Summary = Summary;
+    }
+}
+
+export function ValidationResult_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRFormSpecValidator.ValidationResult", [], ValidationResult, () => [["IsValid", bool_type], ["Errors", list_type(ValidationError_$reflection())], ["Warnings", list_type(ValidationError_$reflection())], ["Summary", ValidationSummary_$reflection()]]);
+}
+
+export class ValidationSummary extends Record implements IEquatable<ValidationSummary>, IComparable<ValidationSummary> {
+    readonly TotalItems: int32;
+    readonly ConvertedFields: int32;
+    readonly HeadingsDetected: int32;
+    readonly StepsCreated: int32;
+    readonly ChoicesProcessed: int32;
+    readonly TriggersFound: int32;
+    readonly TagsMapped: int32;
+    constructor(TotalItems: int32, ConvertedFields: int32, HeadingsDetected: int32, StepsCreated: int32, ChoicesProcessed: int32, TriggersFound: int32, TagsMapped: int32) {
+        super();
+        this.TotalItems = (TotalItems | 0);
+        this.ConvertedFields = (ConvertedFields | 0);
+        this.HeadingsDetected = (HeadingsDetected | 0);
+        this.StepsCreated = (StepsCreated | 0);
+        this.ChoicesProcessed = (ChoicesProcessed | 0);
+        this.TriggersFound = (TriggersFound | 0);
+        this.TagsMapped = (TagsMapped | 0);
+    }
+}
+
+export function ValidationSummary_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRFormSpecValidator.ValidationSummary", [], ValidationSummary, () => [["TotalItems", int32_type], ["ConvertedFields", int32_type], ["HeadingsDetected", int32_type], ["StepsCreated", int32_type], ["ChoicesProcessed", int32_type], ["TriggersFound", int32_type], ["TagsMapped", int32_type]]);
+}
+
+/**
+ * Count non-heading items in CoreMR
+ */
+export function FormSpecValidator_countNonHeadingItems(items: FSharpList<CoreMRItem>): int32 {
+    const headings: FSharpList<HeadingItem> = detectHeadings(items);
+    return (length(items) - length(headings)) | 0;
+}
+
+/**
+ * Count headings in CoreMR (should become steps)
+ */
+export function FormSpecValidator_countHeadings(items: FSharpList<CoreMRItem>): int32 {
+    return length(detectHeadings(items));
+}
+
+/**
+ * Count total fields in FormSpec
+ */
+export function FormSpecValidator_countTotalFields(steps: FSharpList<Spec_FormStep$1<Spec_FieldType_$union>>): int32 {
+    return sumBy<Spec_FormStep$1<Spec_FieldType_$union>, int32>((s: Spec_FormStep$1<Spec_FieldType_$union>): int32 => length(s.Fields), steps, {
+        GetZero: (): int32 => 0,
+        Add: (x: int32, y: int32): int32 => (x + y),
+    });
+}
+
+/**
+ * Get choices count per item
+ */
+export function FormSpecValidator_getChoicesPerItem(choices: FSharpList<CoreMRChoice>): FSharpMap<int32, int32> {
+    return ofList<int32, int32>(map<[int32, FSharpList<CoreMRChoice>], [int32, int32]>((tupledArg: [int32, FSharpList<CoreMRChoice>]): [int32, int32] => ([tupledArg[0], length(tupledArg[1])] as [int32, int32]), List_groupBy<CoreMRChoice, int32>((c: CoreMRChoice): int32 => c.ItemId, choices, {
+        Equals: (x: int32, y: int32): boolean => (x === y),
+        GetHashCode: numberHash,
+    })), {
+        Compare: comparePrimitives,
+    });
+}
+
+/**
+ * Calculate expected max score from CoreMR
+ */
+export function FormSpecValidator_calculateExpectedMaxScore(choices: FSharpList<CoreMRChoice>): int32 {
+    return sumBy<CoreMRChoice, int32>((c: CoreMRChoice): int32 => c.Score, choices, {
+        GetZero: (): int32 => 0,
+        Add: (x: int32, y: int32): int32 => (x + y),
+    });
+}
+
+/**
+ * Validate metadata mapping
+ */
+export function FormSpecValidator_validateMetadata(coreMR: CoreMRFormMetadata, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpList<ValidationError_$union> {
+    return toList<ValidationError_$union>(delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>((formSpec.Title !== coreMR.FormName) ? singleton<ValidationError_$union>(ValidationError_MetadataMismatch("title", coreMR.FormName, formSpec.Title)) : empty<ValidationError_$union>(), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>((formSpec.Version !== int32ToString(coreMR.VersionNumber)) ? singleton<ValidationError_$union>(ValidationError_MetadataMismatch("version", int32ToString(coreMR.VersionNumber), formSpec.Version)) : empty<ValidationError_$union>(), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => ((formSpec.RequiresReview !== coreMR.RequiresSignature) ? singleton<ValidationError_$union>(ValidationError_MetadataMismatch("requiresReview", toString(coreMR.RequiresSignature), toString(formSpec.RequiresReview))) : empty<ValidationError_$union>())))))));
+}
+
+/**
+ * Validate item/field counts
+ */
+export function FormSpecValidator_validateCounts(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpList<ValidationError_$union> {
+    const expectedFields: int32 = FormSpecValidator_countNonHeadingItems(coreMR.Items) | 0;
+    const actualFields: int32 = FormSpecValidator_countTotalFields(formSpec.Steps) | 0;
+    const expectedSteps: int32 = FormSpecValidator_countHeadings(coreMR.Items) | 0;
+    const actualSteps: int32 = length(formSpec.Steps) | 0;
+    return toList<ValidationError_$union>(delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>((expectedFields !== actualFields) ? singleton<ValidationError_$union>(ValidationError_ItemCountMismatch(expectedFields, actualFields)) : empty<ValidationError_$union>(), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => (((expectedSteps > 0) && (expectedSteps !== actualSteps)) ? singleton<ValidationError_$union>(ValidationError_StepCountMismatch(expectedSteps, actualSteps)) : empty<ValidationError_$union>())))));
+}
+
+/**
+ * Validate choices were mapped correctly
+ */
+export function FormSpecValidator_validateChoices(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpList<ValidationError_$union> {
+    const choicesPerItem: FSharpMap<int32, int32> = FormSpecValidator_getChoicesPerItem(coreMR.Choices);
+    const errors: ValidationError_$union[] = [];
+    const sequenceToFieldKey: FSharpMap<int32, Shared_FieldKey> = ofList<int32, Shared_FieldKey>(map<Spec_FormField$1<Spec_FieldType_$union>, [int32, Shared_FieldKey]>((f: Spec_FormField$1<Spec_FieldType_$union>): [int32, Shared_FieldKey] => ([f.FieldOrder, f.FieldKey] as [int32, Shared_FieldKey]), 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)), {
+        Compare: comparePrimitives,
+    });
+    const fieldKeyToItemId: FSharpMap<Shared_FieldKey, int32> = ofList<Shared_FieldKey, int32>(choose<CoreMRItem, [Shared_FieldKey, int32]>((item: CoreMRItem): Option<[Shared_FieldKey, int32]> => map_1<Shared_FieldKey, [Shared_FieldKey, int32]>((fieldKey: Shared_FieldKey): [Shared_FieldKey, int32] => ([fieldKey, item.ItemId] as [Shared_FieldKey, int32]), tryFind<int32, Shared_FieldKey>(item.Sequence, sequenceToFieldKey)), coreMR.Items), {
+        Compare: compare,
+    });
+    const itemsById: FSharpMap<int32, CoreMRItem> = ofList<int32, CoreMRItem>(map<CoreMRItem, [int32, CoreMRItem]>((i: CoreMRItem): [int32, CoreMRItem] => ([i.ItemId, i] as [int32, CoreMRItem]), coreMR.Items), {
+        Compare: comparePrimitives,
+    });
+    const enumerator: IEnumerator<Spec_FormStep$1<Spec_FieldType_$union>> = getEnumerator(formSpec.Steps);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const enumerator_1: IEnumerator<Spec_FormField$1<Spec_FieldType_$union>> = getEnumerator(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]().Fields);
+            try {
+                while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                    const field: Spec_FormField$1<Spec_FieldType_$union> = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const matchValue: Spec_FieldType_$union = field.FieldType;
+                    switch (matchValue.tag) {
+                        case /* MultiChoice */ 15: {
+                            const info: Spec_MultiChoiceInfo = matchValue.fields[0];
+                            const matchValue_1: Option<int32> = tryFind<Shared_FieldKey, int32>(field.FieldKey, fieldKeyToItemId);
+                            if (matchValue_1 == null) {
+                            }
+                            else {
+                                const itemId: int32 = value_3(matchValue_1) | 0;
+                                const matchValue_2: Option<CoreMRItem> = tryFind<int32, CoreMRItem>(itemId, itemsById);
+                                if (matchValue_2 == null) {
+                                }
+                                else {
+                                    const item_1: CoreMRItem = value_3(matchValue_2);
+                                    const expectedCount: int32 = defaultArg(tryFind<int32, int32>(itemId, choicesPerItem), 0) | 0;
+                                    const actualCount: int32 = length(info.Options) | 0;
+                                    if (!getElementTypeInfo(item_1.ItemTypeId).IsScaffold) {
+                                        if ((expectedCount > 0) && (expectedCount !== actualCount)) {
+                                            void (errors.push(ValidationError_ChoiceCountMismatch(itemId, item_1.Label, expectedCount, actualCount)));
+                                        }
+                                        else if (expectedCount === 0) {
+                                            void (errors.push(ValidationError_MissingChoices(itemId, item_1.Label)));
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                        case /* Dropdown */ 14: {
+                            const info_1: Spec_SingleChoiceInfo = matchValue.fields[0];
+                            const matchValue_3: Option<int32> = tryFind<Shared_FieldKey, int32>(field.FieldKey, fieldKeyToItemId);
+                            if (matchValue_3 == null) {
+                            }
+                            else {
+                                const itemId_1: int32 = value_3(matchValue_3) | 0;
+                                const matchValue_4: Option<CoreMRItem> = tryFind<int32, CoreMRItem>(itemId_1, itemsById);
+                                if (matchValue_4 == null) {
+                                }
+                                else {
+                                    const item_2: CoreMRItem = value_3(matchValue_4);
+                                    const expectedCount_1: int32 = defaultArg(tryFind<int32, int32>(itemId_1, choicesPerItem), 0) | 0;
+                                    const actualCount_1: int32 = length(info_1.Options) | 0;
+                                    if (!getElementTypeInfo(item_2.ItemTypeId).IsScaffold) {
+                                        if ((expectedCount_1 > 0) && (expectedCount_1 !== actualCount_1)) {
+                                            void (errors.push(ValidationError_ChoiceCountMismatch(itemId_1, item_2.Label, expectedCount_1, actualCount_1)));
+                                        }
+                                        else if (expectedCount_1 === 0) {
+                                            void (errors.push(ValidationError_MissingChoices(itemId_1, item_2.Label)));
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                        case /* CheckboxList */ 16: {
+                            const info_2: Spec_MultiChoiceInfo = matchValue.fields[0];
+                            const matchValue_5: Option<int32> = tryFind<Shared_FieldKey, int32>(field.FieldKey, fieldKeyToItemId);
+                            if (matchValue_5 == null) {
+                            }
+                            else {
+                                const itemId_2: int32 = value_3(matchValue_5) | 0;
+                                const matchValue_6: Option<CoreMRItem> = tryFind<int32, CoreMRItem>(itemId_2, itemsById);
+                                if (matchValue_6 == null) {
+                                }
+                                else {
+                                    const item_3: CoreMRItem = value_3(matchValue_6);
+                                    const expectedCount_2: int32 = defaultArg(tryFind<int32, int32>(itemId_2, choicesPerItem), 0) | 0;
+                                    const actualCount_2: int32 = length(info_2.Options) | 0;
+                                    if (!getElementTypeInfo(item_3.ItemTypeId).IsScaffold) {
+                                        if ((expectedCount_2 > 0) && (expectedCount_2 !== actualCount_2)) {
+                                            void (errors.push(ValidationError_ChoiceCountMismatch(itemId_2, item_3.Label, expectedCount_2, actualCount_2)));
+                                        }
+                                        else if (expectedCount_2 === 0) {
+                                            void (errors.push(ValidationError_MissingChoices(itemId_2, item_3.Label)));
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                        default:
+                            undefined;
+                    }
+                }
+            }
+            finally {
+                disposeSafe(enumerator_1 as IDisposable);
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator as IDisposable);
+    }
+    return ofSeq<ValidationError_$union>(errors);
+}
+
+/**
+ * Validate required fields mapping
+ */
+export function FormSpecValidator_validateRequiredFields(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpList<ValidationError_$union> {
+    const errors: ValidationError_$union[] = [];
+    const itemsByLabel: FSharpMap<string, CoreMRItem> = ofList<string, CoreMRItem>(map<CoreMRItem, [string, CoreMRItem]>((i: CoreMRItem): [string, CoreMRItem] => ([i.Label, i] as [string, CoreMRItem]), coreMR.Items), {
+        Compare: comparePrimitives,
+    });
+    const enumerator: IEnumerator<Spec_FormStep$1<Spec_FieldType_$union>> = getEnumerator(formSpec.Steps);
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const enumerator_1: IEnumerator<Spec_FormField$1<Spec_FieldType_$union>> = getEnumerator(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]().Fields);
+            try {
+                while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                    const field: Spec_FormField$1<Spec_FieldType_$union> = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const matchValue: Option<CoreMRItem> = tryFind<string, CoreMRItem>(field.Label, itemsByLabel);
+                    if (matchValue == null) {
+                    }
+                    else {
+                        const item: CoreMRItem = value_3(matchValue);
+                        const expectedOptional: boolean = !item.IsRequired;
+                        if (field.IsOptional !== expectedOptional) {
+                            void (errors.push(ValidationError_RequiredFieldMismatch(item.ItemId, item.Label, expectedOptional, field.IsOptional)));
+                        }
+                    }
+                }
+            }
+            finally {
+                disposeSafe(enumerator_1 as IDisposable);
+            }
+        }
+    }
+    finally {
+        disposeSafe(enumerator as IDisposable);
+    }
+    return ofSeq<ValidationError_$union>(errors);
+}
+
+/**
+ * Validate scoring calculation
+ */
+export function FormSpecValidator_validateScoring(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpList<ValidationError_$union> {
+    const expectedScore: int32 = FormSpecValidator_calculateExpectedMaxScore(coreMR.Choices) | 0;
+    if (expectedScore > 0) {
+        const matchValue: Option<Spec_Score> = formSpec.Score;
+        if (matchValue == null) {
+            return singleton_1(ValidationError_ScoreMismatch(expectedScore, undefined));
+        }
+        else {
+            const score: Spec_Score = value_3(matchValue);
+            if (score.MaxScore !== expectedScore) {
+                return singleton_1(ValidationError_ScoreMismatch(expectedScore, score.MaxScore));
+            }
+            else {
+                return empty_1<ValidationError_$union>();
+            }
+        }
+    }
+    else {
+        return empty_1<ValidationError_$union>();
+    }
+}
+
+/**
+ * Validate tags mapping
+ */
+export function FormSpecValidator_validateTags(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpList<ValidationError_$union> {
+    const expectedCount: int32 = length(coreMR.Tags) | 0;
+    const actualCount: int32 = length(formSpec.CategoryTags) | 0;
+    if (expectedCount !== actualCount) {
+        return singleton_1(ValidationError_TagCountMismatch(expectedCount, actualCount));
+    }
+    else {
+        return empty_1<ValidationError_$union>();
+    }
+}
+
+/**
+ * Create validation summary
+ */
+export function FormSpecValidator_createSummary(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): ValidationSummary {
+    return new ValidationSummary(length(coreMR.Items), FormSpecValidator_countTotalFields(formSpec.Steps), FormSpecValidator_countHeadings(coreMR.Items), length(formSpec.Steps), length(coreMR.Choices), length(coreMR.Triggers), length(formSpec.CategoryTags));
+}
+
+/**
+ * Validate pathway conversion from triggers (STUB - simplified for compilation)
+ */
+export function FormSpecValidator_validatePathways(triggers: FSharpList<CoreMRTrigger>, pathway: Option<ClinicalPathway_ClinicalPathwaySpec>): FSharpList<ValidationError_$union> {
+    const activeTriggers: FSharpList<CoreMRTrigger> = filter<CoreMRTrigger>((t: CoreMRTrigger): boolean => {
+        if (t.Active) {
+            return !isEmpty(t.Events);
+        }
+        else {
+            return false;
+        }
+    }, triggers);
+    let matchResult: int32;
+    if (pathway == null) {
+        if (length(activeTriggers) > 0) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return singleton_1(ValidationError_PathwayMissing(length(activeTriggers)));
+        default:
+            return empty_1<ValidationError_$union>();
+    }
+}
+
+/**
+ * Main validation function
+ */
+export function FormSpecValidator_validateConversion(coreMR: CoreMRFormData, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpResult$2_$union<ValidationResult, string> {
+    try {
+        const allErrors: FSharpList<ValidationError_$union> = toList<ValidationError_$union>(delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>(FormSpecValidator_validateMetadata(coreMR.Metadata, formSpec), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>(FormSpecValidator_validateCounts(coreMR, formSpec), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>(FormSpecValidator_validateChoices(coreMR, formSpec), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>(FormSpecValidator_validateRequiredFields(coreMR, formSpec), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>(FormSpecValidator_validateScoring(coreMR, formSpec), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => append<ValidationError_$union>(FormSpecValidator_validateTags(coreMR, formSpec), delay<ValidationError_$union>((): Iterable<ValidationError_$union> => FormSpecValidator_validatePathways(coreMR.Triggers, formSpec.ClinicalPathway)))))))))))))));
+        return FSharpResult$2_Ok<ValidationResult, string>(new ValidationResult(isEmpty(allErrors), allErrors, empty_1<ValidationError_$union>(), FormSpecValidator_createSummary(coreMR, formSpec)));
+    }
+    catch (ex: any) {
+        return FSharpResult$2_Error<ValidationResult, string>(`Validation failed: ${ex.message}`);
+    }
+}
+
+//# sourceMappingURL=CorEMRFormSpecValidator.ts.map

package/src/FormSpec.FS/Integrations/Adapters/CorEMR/CorEMRSectioning.ts

@@ -0,0 +1,87 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { comparePrimitives, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { list_type, option_type, record_type, string_type, int32_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+import { item as item_3, length, mapIndexed, append, head, singleton, isEmpty, map, sortBy, filter, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { CoreMRItem_$reflection, CoreMRItem } from "../../CorEMR/CoreMRTypes.js";
+
+export class HeadingItem extends Record implements IEquatable<HeadingItem>, IComparable<HeadingItem> {
+    readonly Sequence: int32;
+    readonly Label: string;
+    readonly ItemId: int32;
+    constructor(Sequence: int32, Label: string, ItemId: int32) {
+        super();
+        this.Sequence = (Sequence | 0);
+        this.Label = Label;
+        this.ItemId = (ItemId | 0);
+    }
+}
+
+export function HeadingItem_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSectioning.HeadingItem", [], HeadingItem, () => [["Sequence", int32_type], ["Label", string_type], ["ItemId", int32_type]]);
+}
+
+export class Section extends Record implements IEquatable<Section>, IComparable<Section> {
+    readonly Heading: Option<HeadingItem>;
+    readonly HeadingSequence: int32;
+    readonly HeadingLabel: string;
+    readonly Items: FSharpList<CoreMRItem>;
+    constructor(Heading: Option<HeadingItem>, HeadingSequence: int32, HeadingLabel: string, Items: FSharpList<CoreMRItem>) {
+        super();
+        this.Heading = Heading;
+        this.HeadingSequence = (HeadingSequence | 0);
+        this.HeadingLabel = HeadingLabel;
+        this.Items = Items;
+    }
+}
+
+export function Section_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.CorEMRSectioning.Section", [], Section, () => [["Heading", option_type(HeadingItem_$reflection())], ["HeadingSequence", int32_type], ["HeadingLabel", string_type], ["Items", list_type(CoreMRItem_$reflection())]]);
+}
+
+/**
+ * Items that are not headings (type 110). Use this instead of inline ItemTypeId <> 110.
+ */
+export function nonHeadingItems(items: FSharpList<CoreMRItem>): FSharpList<CoreMRItem> {
+    return filter<CoreMRItem>((item: CoreMRItem): boolean => (item.ItemTypeId !== 110), items);
+}
+
+/**
+ * Detect heading items (type 110) in item list
+ */
+export function detectHeadings(items: FSharpList<CoreMRItem>): FSharpList<HeadingItem> {
+    return sortBy<HeadingItem, int32>((h: HeadingItem): int32 => h.Sequence, map<CoreMRItem, HeadingItem>((item_1: CoreMRItem): HeadingItem => (new HeadingItem(item_1.Sequence, item_1.Label, item_1.ItemId)), filter<CoreMRItem>((item: CoreMRItem): boolean => (item.ItemTypeId === 110), items)), {
+        Compare: comparePrimitives,
+    });
+}
+
+/**
+ * Group items into sections based on heading positions.
+ * Preamble: items before first heading (HeadingLabel = "Form").
+ * Sections: one per heading, items between heading N and N+1.
+ */
+export function groupItemsByHeadings(headings: FSharpList<HeadingItem>, allItems: FSharpList<CoreMRItem>): FSharpList<Section> {
+    const nonHeading: FSharpList<CoreMRItem> = sortBy<CoreMRItem, int32>((item: CoreMRItem): int32 => item.Sequence, nonHeadingItems(allItems), {
+        Compare: comparePrimitives,
+    });
+    if (isEmpty(headings)) {
+        return singleton(new Section(undefined, 0, "Form", nonHeading));
+    }
+    else {
+        const firstHeading: HeadingItem = head(headings);
+        return append(singleton(new Section(undefined, 0, "Form", filter<CoreMRItem>((item_1: CoreMRItem): boolean => (item_1.Sequence < firstHeading.Sequence), nonHeading))), mapIndexed<HeadingItem, Section>((index: int32, heading: HeadingItem): Section => {
+            const nextHeadingSeq: int32 = ((index < (length(headings) - 1)) ? item_3(index + 1, headings).Sequence : 2147483647) | 0;
+            return new Section(heading, heading.Sequence, heading.Label, filter<CoreMRItem>((item_2: CoreMRItem): boolean => {
+                if (item_2.Sequence > heading.Sequence) {
+                    return item_2.Sequence < nextHeadingSeq;
+                }
+                else {
+                    return false;
+                }
+            }, nonHeading));
+        }, headings));
+    }
+}
+
+//# sourceMappingURL=CorEMRSectioning.ts.map