@f1studio/form-spec 5.0.0-alpha.123 → 5.0.0-alpha.125

package/src/FormSpec.FS/Integrations/CorEMR/TemplateDecodeTypes.ts

@@ -0,0 +1,246 @@
+import { Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { list_type, record_type, option_type, string_type, int32_type, union_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { value, Option } from "@fable-org/fable-library-js/Option.js";
+import { equals, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { isEmpty, take, iterate, filter, length, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { join, printf, toText } from "@fable-org/fable-library-js/String.js";
+
+export type DecodeIssueSeverity_$union = 
+    | DecodeIssueSeverity<0>
+    | DecodeIssueSeverity<1>
+
+export type DecodeIssueSeverity_$cases = {
+    0: ["Error", []],
+    1: ["Warning", []]
+}
+
+export function DecodeIssueSeverity_Error() {
+    return new DecodeIssueSeverity<0>(0, []);
+}
+
+export function DecodeIssueSeverity_Warning() {
+    return new DecodeIssueSeverity<1>(1, []);
+}
+
+export class DecodeIssueSeverity<Tag extends keyof DecodeIssueSeverity_$cases> extends Union<Tag, DecodeIssueSeverity_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: DecodeIssueSeverity_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Error", "Warning"];
+    }
+}
+
+export function DecodeIssueSeverity_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.TemplateDecodeTypes.DecodeIssueSeverity", [], DecodeIssueSeverity, () => [[], []]);
+}
+
+export type DecodeIssuePath_$union = 
+    | DecodeIssuePath<0>
+    | DecodeIssuePath<1>
+    | DecodeIssuePath<2>
+    | DecodeIssuePath<3>
+
+export type DecodeIssuePath_$cases = {
+    0: ["PayloadLevel", []],
+    1: ["FormLevel", [int32, string]],
+    2: ["ItemLevel", [int32, string, int32, string]],
+    3: ["ChoiceLevel", [int32, string, int32, string, int32, Option<string>]]
+}
+
+export function DecodeIssuePath_PayloadLevel() {
+    return new DecodeIssuePath<0>(0, []);
+}
+
+export function DecodeIssuePath_FormLevel(formId: int32, formName: string) {
+    return new DecodeIssuePath<1>(1, [formId, formName]);
+}
+
+export function DecodeIssuePath_ItemLevel(formId: int32, formName: string, itemId: int32, itemText: string) {
+    return new DecodeIssuePath<2>(2, [formId, formName, itemId, itemText]);
+}
+
+export function DecodeIssuePath_ChoiceLevel(formId: int32, formName: string, itemId: int32, itemText: string, choiceIndex: int32, choiceText: Option<string>) {
+    return new DecodeIssuePath<3>(3, [formId, formName, itemId, itemText, choiceIndex, choiceText]);
+}
+
+export class DecodeIssuePath<Tag extends keyof DecodeIssuePath_$cases> extends Union<Tag, DecodeIssuePath_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: DecodeIssuePath_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["PayloadLevel", "FormLevel", "ItemLevel", "ChoiceLevel"];
+    }
+}
+
+export function DecodeIssuePath_$reflection(): TypeInfo {
+    return union_type("FormSpec.Integrations.CorEMR.TemplateDecodeTypes.DecodeIssuePath", [], DecodeIssuePath, () => [[], [["formId", int32_type], ["formName", string_type]], [["formId", int32_type], ["formName", string_type], ["itemId", int32_type], ["itemText", string_type]], [["formId", int32_type], ["formName", string_type], ["itemId", int32_type], ["itemText", string_type], ["choiceIndex", int32_type], ["choiceText", option_type(string_type)]]]);
+}
+
+export class DecodeIssue extends Record implements IEquatable<DecodeIssue>, IComparable<DecodeIssue> {
+    readonly Path: DecodeIssuePath_$union;
+    readonly Severity: DecodeIssueSeverity_$union;
+    readonly Field: string;
+    readonly Expected: string;
+    readonly Got: string;
+    readonly Message: string;
+    constructor(Path: DecodeIssuePath_$union, Severity: DecodeIssueSeverity_$union, Field: string, Expected: string, Got: string, Message: string) {
+        super();
+        this.Path = Path;
+        this.Severity = Severity;
+        this.Field = Field;
+        this.Expected = Expected;
+        this.Got = Got;
+        this.Message = Message;
+    }
+}
+
+export function DecodeIssue_$reflection(): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateDecodeTypes.DecodeIssue", [], DecodeIssue, () => [["Path", DecodeIssuePath_$reflection()], ["Severity", DecodeIssueSeverity_$reflection()], ["Field", string_type], ["Expected", string_type], ["Got", string_type], ["Message", string_type]]);
+}
+
+export class DecodeBatchResult$1<T> extends Record implements IEquatable<DecodeBatchResult$1<T>>, IComparable<DecodeBatchResult$1<T>> {
+    readonly Succeeded: FSharpList<T>;
+    readonly Issues: FSharpList<DecodeIssue>;
+    readonly SkippedTemplates: int32;
+    readonly SkippedItems: int32;
+    readonly SkippedChoices: int32;
+    readonly TotalTemplates: int32;
+    readonly TotalItems: int32;
+    readonly TotalChoices: int32;
+    constructor(Succeeded: FSharpList<T>, Issues: FSharpList<DecodeIssue>, SkippedTemplates: int32, SkippedItems: int32, SkippedChoices: int32, TotalTemplates: int32, TotalItems: int32, TotalChoices: int32) {
+        super();
+        this.Succeeded = Succeeded;
+        this.Issues = Issues;
+        this.SkippedTemplates = (SkippedTemplates | 0);
+        this.SkippedItems = (SkippedItems | 0);
+        this.SkippedChoices = (SkippedChoices | 0);
+        this.TotalTemplates = (TotalTemplates | 0);
+        this.TotalItems = (TotalItems | 0);
+        this.TotalChoices = (TotalChoices | 0);
+    }
+}
+
+export function DecodeBatchResult$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("FormSpec.Integrations.CorEMR.TemplateDecodeTypes.DecodeBatchResult`1", [gen0], DecodeBatchResult$1, () => [["Succeeded", list_type(gen0)], ["Issues", list_type(DecodeIssue_$reflection())], ["SkippedTemplates", int32_type], ["SkippedItems", int32_type], ["SkippedChoices", int32_type], ["TotalTemplates", int32_type], ["TotalItems", int32_type], ["TotalChoices", int32_type]]);
+}
+
+function formatPath(path: DecodeIssuePath_$union): string {
+    switch (path.tag) {
+        case /* FormLevel */ 1: {
+            const formName: string = path.fields[1];
+            const formId: int32 = path.fields[0] | 0;
+            return toText(printf("Form \'%s\' (FormId: %d)"))(formName)(formId);
+        }
+        case /* ItemLevel */ 2: {
+            const itemText: string = path.fields[3];
+            const itemId: int32 = path.fields[2] | 0;
+            const formName_1: string = path.fields[1];
+            const formId_1: int32 = path.fields[0] | 0;
+            return toText(printf("Form \'%s\' (FormId: %d): Item #%d \'%s\'"))(formName_1)(formId_1)(itemId)(itemText);
+        }
+        case /* ChoiceLevel */ 3: {
+            const itemText_1: string = path.fields[3];
+            const itemId_1: int32 = path.fields[2] | 0;
+            const formName_2: string = path.fields[1];
+            const formId_2: int32 = path.fields[0] | 0;
+            const choiceText: Option<string> = path.fields[5];
+            const choiceIndex: int32 = path.fields[4] | 0;
+            let choicePart: string;
+            if (choiceText == null) {
+                choicePart = toText(printf("Choice #%d"))(choiceIndex);
+            }
+            else {
+                const t: string = value(choiceText);
+                choicePart = toText(printf("Choice #%d (text: \'%s\')"))(choiceIndex)(t);
+            }
+            return toText(printf("Form \'%s\' (FormId: %d): Item #%d \'%s\' — %s"))(formName_2)(formId_2)(itemId_1)(itemText_1)(choicePart);
+        }
+        default:
+            return "payload";
+    }
+}
+
+/**
+ * Format a single DecodeIssue for display.
+ */
+export function formatIssue(issue: DecodeIssue): string {
+    const pathStr: string = formatPath(issue.Path);
+    return toText(printf("%s — Field \'%s\': expected %s, got %s"))(pathStr)(issue.Field)(issue.Expected)(issue.Got);
+}
+
+/**
+ * Human-readable summary for DecodeBatchResult (partial success).
+ */
+export function formatSummary<T>(result: DecodeBatchResult$1<T>): string {
+    let arg_4: int32, arg_7: int32;
+    const lines: string[] = [];
+    const successCount: int32 = length(result.Succeeded) | 0;
+    void (lines.push(toText(printf("Decoded %d/%d templates successfully."))(successCount)(result.TotalTemplates)));
+    if (result.SkippedTemplates > 0) {
+        const templateIssues: FSharpList<DecodeIssue> = filter<DecodeIssue>((i: DecodeIssue): boolean => {
+            const matchValue: DecodeIssuePath_$union = i.Path;
+            switch (matchValue.tag) {
+                case /* ItemLevel */ 2:
+                case /* ChoiceLevel */ 3:
+                    return false;
+                default:
+                    return true;
+            }
+        }, result.Issues);
+        void (lines.push(""));
+        void (lines.push(toText(printf("%d templates skipped:"))(result.SkippedTemplates)));
+        iterate<DecodeIssue>((i_1: DecodeIssue): void => {
+            let arg_3: string;
+            void (lines.push((arg_3 = formatIssue(i_1), toText(printf("  %s"))(arg_3))));
+        }, take<DecodeIssue>(10, templateIssues));
+        if (length(templateIssues) > 10) {
+            void (lines.push((arg_4 = ((length(templateIssues) - 10) | 0), toText(printf("  ... and %d more"))(arg_4))));
+        }
+    }
+    if (result.SkippedChoices > 0) {
+        const choiceIssues: FSharpList<DecodeIssue> = filter<DecodeIssue>((i_2: DecodeIssue): boolean => {
+            if (i_2.Path.tag === /* ChoiceLevel */ 3) {
+                return equals(i_2.Severity, DecodeIssueSeverity_Warning());
+            }
+            else {
+                return false;
+            }
+        }, result.Issues);
+        void (lines.push(""));
+        void (lines.push(toText(printf("%d choices skipped across successful templates (non-fatal warnings):"))(result.SkippedChoices)));
+        iterate<DecodeIssue>((i_3: DecodeIssue): void => {
+            let arg_6: string;
+            void (lines.push((arg_6 = formatIssue(i_3), toText(printf("  %s"))(arg_6))));
+        }, take<DecodeIssue>(5, choiceIssues));
+        if (length(choiceIssues) > 5) {
+            void (lines.push((arg_7 = ((length(choiceIssues) - 5) | 0), toText(printf("  ... and %d more"))(arg_7))));
+        }
+    }
+    return join("\n", lines);
+}
+
+/**
+ * Human-readable summary for DecodeIssue list (hard failure, no partial success).
+ */
+export function formatDecodeErrors(issues: FSharpList<DecodeIssue>): string {
+    let arg: int32, arg_2: int32;
+    if (isEmpty(issues)) {
+        return "Decode failed (no details)";
+    }
+    else {
+        const lines: string[] = [];
+        void (lines.push((arg = (length(issues) | 0), toText(printf("Decode failed: %d issue(s)"))(arg))));
+        iterate<DecodeIssue>((i: DecodeIssue): void => {
+            let arg_1: string;
+            void (lines.push((arg_1 = formatIssue(i), toText(printf("  %s"))(arg_1))));
+        }, take<DecodeIssue>(10, issues));
+        if (length(issues) > 10) {
+            void (lines.push((arg_2 = ((length(issues) - 10) | 0), toText(printf("  ... and %d more"))(arg_2))));
+        }
+        return join("\n", lines);
+    }
+}
+
+//# sourceMappingURL=TemplateDecodeTypes.ts.map