@f1studio/form-spec 5.0.0-alpha.101

package/src/Renderers/FormSpecMarkdownRenderer.ts

@@ -0,0 +1,874 @@
+import { printf, toText, isNullOrWhiteSpace, join, replicate } from "@fable-org/fable-library-js/String.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { value as value_4, Option, map, defaultArg } from "@fable-org/fable-library-js/Option.js";
+import { Values_FieldDetails$1, Shared_FieldKey, Values_StepOrder, Spec_FormStep$1, Spec_FormSpec$1, ClinicalPathway_ClinicalPathwaySpec, Spec_MatrixInfo, Shared_MatrixItemKey, Shared_MatrixAnswer, Spec_FormField$1, Shared_FieldValue_$union, Spec_FieldType_$union, Spec_MultiChoiceInfo, Spec_SingleChoiceInfo, Shared_PluginDataProperty, Shared_FieldAnswer, Shared_FieldOption } from "../FormSpec.js";
+import { partition, isEmpty, FSharpList, map as map_1, choose, tryFind } from "@fable-org/fable-library-js/List.js";
+import { FSharpSet, toList } from "@fable-org/fable-library-js/Set.js";
+import { singleton, append, delay, toList as toList_1 } from "@fable-org/fable-library-js/Seq.js";
+import { compare, IDisposable, disposeSafe, IEnumerator, getEnumerator } from "@fable-org/fable-library-js/Util.js";
+import { FSharpMap, empty, FSharpMap__TryFind } from "@fable-org/fable-library-js/Map.js";
+import { pathwaySpecToGraph } from "./PathwayRenderers.js";
+import { MermaidRenderer_$ctor_Z1FBCCD16 } from "./MermaidRenderer.js";
+
+function generateHeadingLevel(level: int32): string {
+    return replicate(level, "#");
+}
+
+function formatFieldValue(fieldType: Spec_FieldType_$union, fieldValue: Shared_FieldValue_$union, field: Spec_FormField$1<Spec_FieldType_$union>): string {
+    let matchResult: int32, answer: Shared_FieldAnswer, answer_1: Shared_FieldAnswer, answer_2: Shared_FieldAnswer, answer_3: Shared_FieldAnswer, answer_4: Shared_FieldAnswer, answer_5: Shared_FieldAnswer, answer_6: Shared_FieldAnswer, answer_7: Shared_FieldAnswer, answer_8: Shared_FieldAnswer, answer_9: Shared_FieldAnswer, answer_10: Shared_FieldAnswer, answer_11: Shared_FieldAnswer, answer_12: Shared_FieldAnswer, info: Spec_SingleChoiceInfo, answer_13: Shared_FieldAnswer, info_1: Spec_SingleChoiceInfo, answer_14: Shared_FieldAnswer, info_2: Spec_SingleChoiceInfo, answer_15: Shared_FieldAnswer, info_3: Spec_SingleChoiceInfo, answers: FSharpSet<Shared_FieldAnswer>, info_4: Spec_MultiChoiceInfo, answers_1: FSharpSet<Shared_FieldAnswer>, info_5: Spec_MultiChoiceInfo, answers_2: FSharpSet<Shared_FieldAnswer>, info_6: Spec_MultiChoiceInfo, answer_19: Shared_FieldAnswer, answer_20: Shared_FieldAnswer, answer_21: Shared_FieldAnswer, pluginData: FSharpList<Shared_PluginDataProperty>;
+    switch (fieldType.tag) {
+        case /* TextArea */ 1: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 1;
+                    answer_1 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Email */ 2: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 2;
+                    answer_2 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Password */ 3: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 3;
+                    answer_3 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Search */ 4: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 4;
+                    answer_4 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Color */ 5: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 5;
+                    answer_5 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Number */ 6: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 6;
+                    answer_6 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Tel */ 7: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 7;
+                    answer_7 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Date */ 8: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 8;
+                    answer_8 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* DateTimeLocal */ 9: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 9;
+                    answer_9 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Time */ 10: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 10;
+                    answer_10 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Checkbox */ 11: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 11;
+                    answer_11 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* SingleChoice */ 13: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 12;
+                    answer_12 = fieldValue.fields[0];
+                    info = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Radio */ 12: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 13;
+                    answer_13 = fieldValue.fields[0];
+                    info_1 = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Dropdown */ 14: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 14;
+                    answer_14 = fieldValue.fields[0];
+                    info_2 = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* TextAutoComplete */ 18: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 15;
+                    answer_15 = fieldValue.fields[0];
+                    info_3 = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* MultiChoice */ 15: {
+            switch (fieldValue.tag) {
+                case /* Single */ 0: {
+                    matchResult = 24;
+                    answer_21 = fieldValue.fields[0];
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 16;
+                    answers = fieldValue.fields[0];
+                    info_4 = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* CheckboxList */ 16: {
+            switch (fieldValue.tag) {
+                case /* Single */ 0: {
+                    matchResult = 24;
+                    answer_21 = fieldValue.fields[0];
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 17;
+                    answers_1 = fieldValue.fields[0];
+                    info_5 = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* TagList */ 17: {
+            switch (fieldValue.tag) {
+                case /* Single */ 0: {
+                    matchResult = 24;
+                    answer_21 = fieldValue.fields[0];
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 18;
+                    answers_2 = fieldValue.fields[0];
+                    info_6 = fieldType.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Signature */ 20: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 19;
+                    answer_19 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Message */ 21: {
+            matchResult = 20;
+            break;
+        }
+        case /* PluginField */ 22: {
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 21;
+                    answer_20 = fieldValue.fields[0];
+                }
+            }
+            break;
+        }
+        case /* Matrix */ 19: {
+            matchResult = 22;
+            break;
+        }
+        default:
+            switch (fieldValue.tag) {
+                case /* Multiple */ 1: {
+                    matchResult = 23;
+                    break;
+                }
+                case /* Matrix */ 2: {
+                    matchResult = 25;
+                    break;
+                }
+                case /* PluginData */ 3: {
+                    matchResult = 26;
+                    pluginData = fieldValue.fields[0];
+                    break;
+                }
+                default: {
+                    matchResult = 0;
+                    answer = fieldValue.fields[0];
+                }
+            }
+    }
+    switch (matchResult) {
+        case 0:
+            return answer!.Value;
+        case 1:
+            return answer_1!.Value;
+        case 2:
+            return answer_2!.Value;
+        case 3:
+            return "***";
+        case 4:
+            return answer_4!.Value;
+        case 5:
+            return answer_5!.Value;
+        case 6:
+            return answer_6!.Value;
+        case 7:
+            return answer_7!.Value;
+        case 8:
+            return answer_8!.Value;
+        case 9:
+            return answer_9!.Value;
+        case 10:
+            return answer_10!.Value;
+        case 11: {
+            const matchValue_1: string = answer_11!.Value.toLowerCase();
+            switch (matchValue_1) {
+                case "true":
+                case "yes":
+                case "1":
+                    return "Yes";
+                default:
+                    return "No";
+            }
+        }
+        case 12:
+            return defaultArg(map<Shared_FieldOption, string>((opt_1: Shared_FieldOption): string => opt_1.Description, tryFind<Shared_FieldOption>((opt: Shared_FieldOption): boolean => (opt.Value === answer_12!.Value), info!.Options)), answer_12!.Value);
+        case 13:
+            return defaultArg(map<Shared_FieldOption, string>((opt_3: Shared_FieldOption): string => opt_3.Description, tryFind<Shared_FieldOption>((opt_2: Shared_FieldOption): boolean => (opt_2.Value === answer_13!.Value), info_1!.Options)), answer_13!.Value);
+        case 14:
+            return defaultArg(map<Shared_FieldOption, string>((opt_5: Shared_FieldOption): string => opt_5.Description, tryFind<Shared_FieldOption>((opt_4: Shared_FieldOption): boolean => (opt_4.Value === answer_14!.Value), info_2!.Options)), answer_14!.Value);
+        case 15:
+            return defaultArg(map<Shared_FieldOption, string>((opt_7: Shared_FieldOption): string => opt_7.Description, tryFind<Shared_FieldOption>((opt_6: Shared_FieldOption): boolean => (opt_6.Value === answer_15!.Value), info_3!.Options)), answer_15!.Value);
+        case 16:
+            return join(", ", choose<Shared_FieldAnswer, string>((answer_16: Shared_FieldAnswer): Option<string> => map<Shared_FieldOption, string>((opt_9: Shared_FieldOption): string => opt_9.Description, tryFind<Shared_FieldOption>((opt_8: Shared_FieldOption): boolean => (opt_8.Value === answer_16.Value), info_4!.Options)), toList<Shared_FieldAnswer>(answers!)));
+        case 17:
+            return join(", ", choose<Shared_FieldAnswer, string>((answer_17: Shared_FieldAnswer): Option<string> => map<Shared_FieldOption, string>((opt_11: Shared_FieldOption): string => opt_11.Description, tryFind<Shared_FieldOption>((opt_10: Shared_FieldOption): boolean => (opt_10.Value === answer_17.Value), info_5!.Options)), toList<Shared_FieldAnswer>(answers_1!)));
+        case 18:
+            return join(", ", choose<Shared_FieldAnswer, string>((answer_18: Shared_FieldAnswer): Option<string> => map<Shared_FieldOption, string>((opt_13: Shared_FieldOption): string => opt_13.Description, tryFind<Shared_FieldOption>((opt_12: Shared_FieldOption): boolean => (opt_12.Value === answer_18.Value), info_6!.Options)), toList<Shared_FieldAnswer>(answers_2!)));
+        case 19:
+            if (!isNullOrWhiteSpace(answer_19!.Value)) {
+                return "*Signature provided*";
+            }
+            else {
+                return "*No signature*";
+            }
+        case 20:
+            return "";
+        case 21:
+            return answer_20!.Value;
+        case 22:
+            return "";
+        case 23:
+            return "*Type mismatch: Expected single value*";
+        case 24:
+            return answer_21!.Value;
+        case 25:
+            return "";
+        default:
+            return join(", ", map_1<Shared_PluginDataProperty, string>((prop: Shared_PluginDataProperty): string => {
+                const matchValue_2: Option<string> = prop.DisplayName;
+                if (matchValue_2 == null) {
+                    return toText(printf("%s: %s"))(prop.Name)(prop.Value);
+                }
+                else {
+                    const displayName: string = value_4(matchValue_2);
+                    return toText(printf("%s: %s"))(displayName)(prop.Value);
+                }
+            }, pluginData!));
+    }
+}
+
+function formatMatrixFieldAsTable(fieldLabel: string, matrixInfo: Spec_MatrixInfo, matrixAnswer: Option<Shared_MatrixAnswer>): string {
+    let arg_3: string, arg_4: string, arg_6: string, sv_1: string, arg_5: string;
+    const items: FSharpList<Shared_FieldOption> = matrixInfo.Items;
+    const options: FSharpList<Shared_FieldOption> = matrixInfo.Options;
+    if (isEmpty(items) ? true : isEmpty(options)) {
+        return "";
+    }
+    else {
+        const lines: string[] = [];
+        void (lines.push(toText(printf("#### %s"))(fieldLabel)));
+        void (lines.push(""));
+        const headerCells: FSharpList<string> = toList_1<string>(delay<string>((): Iterable<string> => append<string>(singleton<string>("Symptom"), delay<string>((): Iterable<string> => map_1<Shared_FieldOption, string>((opt: Shared_FieldOption): string => toText(printf("%s (%s)"))(opt.Description)(opt.Value), options)))));
+        void (lines.push((arg_3 = join(" | ", headerCells), toText(printf("| %s |"))(arg_3))));
+        const separators: FSharpList<string> = toList_1<string>(delay<string>((): Iterable<string> => append<string>(singleton<string>("---"), delay<string>((): Iterable<string> => map_1<Shared_FieldOption, string>((_arg: Shared_FieldOption): string => "---", options)))));
+        void (lines.push((arg_4 = join(" | ", separators), toText(printf("| %s |"))(arg_4))));
+        if (matrixAnswer == null) {
+            const enumerator_2: IEnumerator<Shared_FieldOption> = getEnumerator(items);
+            try {
+                while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+                    const item_1: Shared_FieldOption = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const rowCells_1: FSharpList<string> = toList_1<string>(delay<string>((): Iterable<string> => append<string>(singleton<string>(item_1.Description), delay<string>((): Iterable<string> => map_1<Shared_FieldOption, string>((_arg_1: Shared_FieldOption): string => "", options)))));
+                    void (lines.push((arg_6 = join(" | ", rowCells_1), toText(printf("| %s |"))(arg_6))));
+                }
+            }
+            finally {
+                disposeSafe(enumerator_2 as IDisposable);
+            }
+        }
+        else {
+            const answer: Shared_MatrixAnswer = value_4(matrixAnswer);
+            const enumerator: IEnumerator<Shared_FieldOption> = getEnumerator(items);
+            try {
+                while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                    const item: Shared_FieldOption = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                    const selectedValue: Option<string> = FSharpMap__TryFind(answer.Values, new Shared_MatrixItemKey(item.OptionKey.fields[0]));
+                    const rowCells: string[] = [];
+                    void (rowCells.push(item.Description));
+                    const enumerator_1: IEnumerator<Shared_FieldOption> = getEnumerator(options);
+                    try {
+                        while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                            const option: Shared_FieldOption = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                            if ((selectedValue != null) && ((value_4(selectedValue) === option.Value) && ((sv_1 = value_4(selectedValue), true)))) {
+                                void (rowCells.push("✔️"));
+                            }
+                            else {
+                                void (rowCells.push(""));
+                            }
+                        }
+                    }
+                    finally {
+                        disposeSafe(enumerator_1 as IDisposable);
+                    }
+                    void (lines.push((arg_5 = join(" | ", rowCells), toText(printf("| %s |"))(arg_5))));
+                }
+            }
+            finally {
+                disposeSafe(enumerator as IDisposable);
+            }
+        }
+        void (lines.push(""));
+        return join("\n", lines);
+    }
+}
+
+function getFieldTypeName(fieldType: Spec_FieldType_$union): string {
+    switch (fieldType.tag) {
+        case /* TextArea */ 1:
+            return "TextArea";
+        case /* Email */ 2:
+            return "Email";
+        case /* Password */ 3:
+            return "Password";
+        case /* Search */ 4:
+            return "Search";
+        case /* Color */ 5:
+            return "Color";
+        case /* Number */ 6:
+            return "Number";
+        case /* Tel */ 7:
+            return "Tel";
+        case /* Date */ 8:
+            return "Date";
+        case /* DateTimeLocal */ 9:
+            return "DateTimeLocal";
+        case /* Time */ 10:
+            return "Time";
+        case /* Checkbox */ 11:
+            return "Checkbox";
+        case /* SingleChoice */ 13:
+            return "SingleChoice";
+        case /* Radio */ 12:
+            return "Radio";
+        case /* Dropdown */ 14:
+            return "Dropdown";
+        case /* TextAutoComplete */ 18:
+            return "TextAutoComplete";
+        case /* MultiChoice */ 15:
+            return "MultiChoice";
+        case /* CheckboxList */ 16:
+            return "CheckboxList";
+        case /* TagList */ 17:
+            return "TagList";
+        case /* Signature */ 20:
+            return "Signature";
+        case /* Message */ 21:
+            return "Message";
+        case /* Matrix */ 19:
+            return "Matrix";
+        case /* PluginField */ 22:
+            return "PluginField";
+        default:
+            return "Text";
+    }
+}
+
+function generatePathwayMermaid(pathway: ClinicalPathway_ClinicalPathwaySpec, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>): string {
+    return pathwaySpecToGraph<void, void, string>(MermaidRenderer_$ctor_Z1FBCCD16(true), pathway, formSpec);
+}
+
+/**
+ * Renders a FormSpec to markdown format with configurable heading levels and optional pathway diagrams.
+ * Uses well-typed Spec.FieldType and Values.FieldValue throughout - NO boxing/unboxing.
+ */
+export function renderFormSpecToMarkdown(startHeading: int32, withPathway: boolean, formSpec: Spec_FormSpec$1<Spec_FieldType_$union>, formValues: Option<FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>>>): string {
+    let matchValue_4: Option<Values_FieldDetails$1<Spec_FieldType_$union>>, matchValue_5: Shared_FieldValue_$union;
+    const lines: string[] = [];
+    const titleHeading: string = generateHeadingLevel(startHeading);
+    void (lines.push(`${titleHeading} ${formSpec.Title}`));
+    void (lines.push(""));
+    const matchValue: Option<string> = formSpec.Code;
+    if (matchValue == null) {
+    }
+    else {
+        const code: string = value_4(matchValue);
+        void (lines.push(`**Code:** ${code}`));
+    }
+    void (lines.push(`**Version:** ${formSpec.Version}`));
+    void (lines.push(""));
+    if (!isNullOrWhiteSpace(formSpec.Abstract)) {
+        void (lines.push(formSpec.Abstract));
+        void (lines.push(""));
+    }
+    if (!isEmpty(formSpec.CategoryTags)) {
+        const categoryHeading: string = generateHeadingLevel(startHeading + 1);
+        void (lines.push(`${categoryHeading} Categories`));
+        void (lines.push(""));
+        const enumerator: IEnumerator<string> = getEnumerator(formSpec.CategoryTags);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const tag: string = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                void (lines.push(`- ${tag}`));
+            }
+        }
+        finally {
+            disposeSafe(enumerator as IDisposable);
+        }
+        void (lines.push(""));
+    }
+    if (!isEmpty(formSpec.AssociatedCodes)) {
+        const codesHeading: string = generateHeadingLevel(startHeading + 1);
+        void (lines.push(`${codesHeading} Associated Codes`));
+        void (lines.push(""));
+        const enumerator_1: IEnumerator<string> = getEnumerator(formSpec.AssociatedCodes);
+        try {
+            while (enumerator_1["System.Collections.IEnumerator.MoveNext"]()) {
+                const code_1: string = enumerator_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                void (lines.push(`- \`${code_1}\``));
+            }
+        }
+        finally {
+            disposeSafe(enumerator_1 as IDisposable);
+        }
+        void (lines.push(""));
+    }
+    const stepHeading: string = generateHeadingLevel(startHeading + 1);
+    const enumerator_2: IEnumerator<Spec_FormStep$1<Spec_FieldType_$union>> = getEnumerator(formSpec.Steps);
+    try {
+        while (enumerator_2["System.Collections.IEnumerator.MoveNext"]()) {
+            const step: Spec_FormStep$1<Spec_FieldType_$union> = enumerator_2["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            const stepLabel: string = isNullOrWhiteSpace(step.StepLabel) ? (`Step ${step.StepOrder}`) : step.StepLabel;
+            void (lines.push(`${stepHeading} ${stepLabel}`));
+            void (lines.push(""));
+            const patternInput: [FSharpList<Spec_FormField$1<Spec_FieldType_$union>>, FSharpList<Spec_FormField$1<Spec_FieldType_$union>>] = partition<Spec_FormField$1<Spec_FieldType_$union>>((field: Spec_FormField$1<Spec_FieldType_$union>): boolean => {
+                if (field.FieldType.tag === /* Matrix */ 19) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }, step.Fields);
+            const regularFields: FSharpList<Spec_FormField$1<Spec_FieldType_$union>> = patternInput[1];
+            const matrixFields: FSharpList<Spec_FormField$1<Spec_FieldType_$union>> = patternInput[0];
+            if (formValues == null) {
+                if (!isEmpty(regularFields)) {
+                    void (lines.push("**Fields:**"));
+                    const enumerator_5: IEnumerator<Spec_FormField$1<Spec_FieldType_$union>> = getEnumerator(regularFields);
+                    try {
+                        while (enumerator_5["System.Collections.IEnumerator.MoveNext"]()) {
+                            const field_3: Spec_FormField$1<Spec_FieldType_$union> = enumerator_5["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                            const fieldTypeName: string = getFieldTypeName(field_3.FieldType);
+                            const requiredText: string = field_3.IsOptional ? "" : " *(required)*";
+                            void (lines.push(toText(printf("- %s%s [%s]"))(field_3.Label)(requiredText)(fieldTypeName)));
+                        }
+                    }
+                    finally {
+                        disposeSafe(enumerator_5 as IDisposable);
+                    }
+                    void (lines.push(""));
+                }
+                const enumerator_6: IEnumerator<Spec_FormField$1<Spec_FieldType_$union>> = getEnumerator(matrixFields);
+                try {
+                    while (enumerator_6["System.Collections.IEnumerator.MoveNext"]()) {
+                        const field_4: Spec_FormField$1<Spec_FieldType_$union> = enumerator_6["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                        const fieldTypeName_1: string = getFieldTypeName(field_4.FieldType);
+                        const requiredText_1: string = field_4.IsOptional ? "" : " *(required)*";
+                        void (lines.push(toText(printf("- %s%s [%s]"))(field_4.Label)(requiredText_1)(fieldTypeName_1)));
+                    }
+                }
+                finally {
+                    disposeSafe(enumerator_6 as IDisposable);
+                }
+            }
+            else {
+                const stepValues: FSharpMap<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>> = defaultArg(FSharpMap__TryFind(value_4(formValues), new Values_StepOrder(step.StepOrder)), empty<Shared_FieldKey, Values_FieldDetails$1<Spec_FieldType_$union>>({
+                    Compare: compare,
+                }));
+                const enumerator_3: IEnumerator<Spec_FormField$1<Spec_FieldType_$union>> = getEnumerator(regularFields);
+                try {
+                    while (enumerator_3["System.Collections.IEnumerator.MoveNext"]()) {
+                        const field_1: Spec_FormField$1<Spec_FieldType_$union> = enumerator_3["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                        const matchValue_2: Option<Values_FieldDetails$1<Spec_FieldType_$union>> = FSharpMap__TryFind(stepValues, field_1.FieldKey);
+                        if (matchValue_2 == null) {
+                            void (lines.push(toText(printf("- **%s**: *No response provided*"))(field_1.Label)));
+                        }
+                        else {
+                            const formattedValue: string = formatFieldValue(field_1.FieldType, value_4(matchValue_2).FieldValue, field_1);
+                            if (!isNullOrWhiteSpace(formattedValue)) {
+                                void (lines.push(toText(printf("- **%s**: %s"))(field_1.Label)(formattedValue)));
+                            }
+                        }
+                    }
+                }
+                finally {
+                    disposeSafe(enumerator_3 as IDisposable);
+                }
+                const enumerator_4: IEnumerator<Spec_FormField$1<Spec_FieldType_$union>> = getEnumerator(matrixFields);
+                try {
+                    while (enumerator_4["System.Collections.IEnumerator.MoveNext"]()) {
+                        const field_2: Spec_FormField$1<Spec_FieldType_$union> = enumerator_4["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                        const matchValue_3: Spec_FieldType_$union = field_2.FieldType;
+                        if (matchValue_3.tag === /* Matrix */ 19) {
+                            const tableMarkdown: string = formatMatrixFieldAsTable(field_2.Label, matchValue_3.fields[0], (matchValue_4 = FSharpMap__TryFind(stepValues, field_2.FieldKey), (matchValue_4 == null) ? undefined : ((matchValue_5 = value_4(matchValue_4).FieldValue, (matchValue_5.tag === /* Single */ 0) ? undefined : ((matchValue_5.tag === /* Multiple */ 1) ? undefined : ((matchValue_5.tag === /* PluginData */ 3) ? undefined : matchValue_5.fields[0]))))));
+                            if (!isNullOrWhiteSpace(tableMarkdown)) {
+                                void (lines.push(""));
+                                void (lines.push(tableMarkdown));
+                            }
+                        }
+                    }
+                }
+                finally {
+                    disposeSafe(enumerator_4 as IDisposable);
+                }
+            }
+            void (lines.push(""));
+        }
+    }
+    finally {
+        disposeSafe(enumerator_2 as IDisposable);
+    }
+    if (withPathway) {
+        const matchValue_6: Option<ClinicalPathway_ClinicalPathwaySpec> = formSpec.ClinicalPathway;
+        if (matchValue_6 == null) {
+        }
+        else {
+            const pathway: ClinicalPathway_ClinicalPathwaySpec = value_4(matchValue_6);
+            const pathwayHeading: string = generateHeadingLevel(startHeading + 1);
+            void (lines.push(`${pathwayHeading} Clinical Pathway`));
+            void (lines.push(""));
+            const mermaid: string = generatePathwayMermaid(pathway, formSpec);
+            void (lines.push(mermaid));
+            void (lines.push(""));
+        }
+    }
+    const reviewHeading: string = generateHeadingLevel(startHeading + 1);
+    void (lines.push(`${reviewHeading} Review Requirements`));
+    void (lines.push(""));
+    const requiresReviewText: string = formSpec.RequiresReview ? "Yes" : "No";
+    const requiresReviewAndApprovalText: string = formSpec.RequiresReviewAndApproval ? "Yes" : "No";
+    void (lines.push(toText(printf("- **Requires Review:** %s"))(requiresReviewText)));
+    void (lines.push(toText(printf("- **Requires Review and Approval:** %s"))(requiresReviewAndApprovalText)));
+    void (lines.push(""));
+    return join("\n", lines);
+}
+
+//# sourceMappingURL=FormSpecMarkdownRenderer.ts.map