@f1studio/form-spec 5.0.0-alpha.101 → 5.0.0-alpha.103

package/src/FormSpecValues.ts

@@ -0,0 +1,158 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { map as map_1, value as value_1, defaultArg, bind, Option } from "@fable-org/fable-library-js/Option.js";
+import { Values_StepOrder, Shared_FieldValue_Single, Shared_FieldAnswer, Spec_FormSpec$1, Spec_FormStep$1, Spec_FormField$1, Spec_FieldType_$union, Shared_FieldOption_$reflection, Shared_FieldValue_$reflection, Shared_FieldKey_$reflection, Shared_FieldOption, Shared_FieldValue_$union, Shared_FieldKey, Spec_Score_$reflection, Spec_Score } from "./FormSpec.js";
+import { compare, equals, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { list_type, int32_type, record_type, option_type, string_type, class_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { findIndex, map, mapIndexed, exists, tryFindIndex, collect, tryFind, empty, FSharpList } from "@fable-org/fable-library-js/List.js";
+import { fold, FSharpMap, ofList } from "@fable-org/fable-library-js/Map.js";
+
+export class FormSpecMetadata extends Record implements IEquatable<FormSpecMetadata>, IComparable<FormSpecMetadata> {
+    readonly FormSpecId: string;
+    readonly FormSpecCode: Option<string>;
+    readonly FormSpecVersion: string;
+    readonly DynamicVersion: string;
+    readonly MaxScore: Option<Spec_Score>;
+    constructor(FormSpecId: string, FormSpecCode: Option<string>, FormSpecVersion: string, DynamicVersion: string, MaxScore: Option<Spec_Score>) {
+        super();
+        this.FormSpecId = FormSpecId;
+        this.FormSpecCode = FormSpecCode;
+        this.FormSpecVersion = FormSpecVersion;
+        this.DynamicVersion = DynamicVersion;
+        this.MaxScore = MaxScore;
+    }
+}
+
+export function FormSpecMetadata_$reflection(): TypeInfo {
+    return record_type("F1.Studio.FormSpecValues.FormSpecMetadata", [], FormSpecMetadata, () => [["FormSpecId", class_type("System.Guid")], ["FormSpecCode", option_type(string_type)], ["FormSpecVersion", string_type], ["DynamicVersion", string_type], ["MaxScore", option_type(Spec_Score_$reflection())]]);
+}
+
+export class FieldDetails$1<FieldType> extends Record implements IEquatable<FieldDetails$1<FieldType>>, IComparable<FieldDetails$1<FieldType>> {
+    readonly FieldOrder: int32;
+    readonly Key: Shared_FieldKey;
+    readonly Label: string;
+    readonly FieldValue: Shared_FieldValue_$union;
+    readonly FieldType: FieldType;
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(FieldOrder: int32, Key: Shared_FieldKey, Label: string, FieldValue: Shared_FieldValue_$union, FieldType: FieldType, Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.FieldOrder = (FieldOrder | 0);
+        this.Key = Key;
+        this.Label = Label;
+        this.FieldValue = FieldValue;
+        this.FieldType = FieldType;
+        this.Options = Options;
+    }
+}
+
+export function FieldDetails$1_$reflection(gen0: TypeInfo): TypeInfo {
+    return record_type("F1.Studio.FormSpecValues.FieldDetails`1", [gen0], FieldDetails$1, () => [["FieldOrder", int32_type], ["Key", Shared_FieldKey_$reflection()], ["Label", string_type], ["FieldValue", Shared_FieldValue_$reflection()], ["FieldType", gen0], ["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+function optionsFromField(field: Spec_FormField$1<Spec_FieldType_$union>): FSharpList<Shared_FieldOption> {
+    const matchValue: Spec_FieldType_$union = field.FieldType;
+    switch (matchValue.tag) {
+        case /* CheckboxList */ 16:
+            return matchValue.fields[0].Options;
+        case /* MultiChoice */ 15:
+            return matchValue.fields[0].Options;
+        case /* TagList */ 17:
+            return matchValue.fields[0].Options;
+        case /* Dropdown */ 14:
+            return matchValue.fields[0].Options;
+        case /* Radio */ 12:
+            return matchValue.fields[0].Options;
+        case /* SingleChoice */ 13:
+            return matchValue.fields[0].Options;
+        case /* TextAutoComplete */ 18:
+            return matchValue.fields[0].Options;
+        case /* Matrix */ 19:
+            return matchValue.fields[0].Options;
+        default:
+            return empty<Shared_FieldOption>();
+    }
+}
+
+/**
+ * Get field value by FieldKey (searches all steps)
+ */
+export function getFieldValue<FieldType>(spec: Spec_FormSpec$1<FieldType>, fieldKey: Shared_FieldKey): Option<Shared_FieldValue_$union> {
+    return bind<Spec_FormField$1<FieldType>, Shared_FieldValue_$union>((f_1: Spec_FormField$1<FieldType>): Option<Shared_FieldValue_$union> => f_1.Value, tryFind<Spec_FormField$1<FieldType>>((f: Spec_FormField$1<FieldType>): boolean => equals(f.FieldKey, fieldKey), collect<Spec_FormStep$1<FieldType>, Spec_FormField$1<FieldType>>((step: Spec_FormStep$1<FieldType>): FSharpList<Spec_FormField$1<FieldType>> => step.Fields, spec.Steps)));
+}
+
+/**
+ * Find the step index containing the given field
+ */
+export function findStepIndexForField<FieldType>(spec: Spec_FormSpec$1<FieldType>, fieldKey: Shared_FieldKey): Option<int32> {
+    return tryFindIndex<Spec_FormStep$1<FieldType>>((step: Spec_FormStep$1<FieldType>): boolean => exists<Spec_FormField$1<FieldType>>((f: Spec_FormField$1<FieldType>): boolean => equals(f.FieldKey, fieldKey), step.Fields), spec.Steps);
+}
+
+/**
+ * Update a single field's value. Returns new FormSpec.
+ * If stepIndex is None, searches for the field across all steps.
+ */
+export function updateField<FieldType>(spec: Spec_FormSpec$1<FieldType>, fieldKey: Shared_FieldKey, newValue: Shared_FieldValue_$union, 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.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);
+}
+
+/**
+ * Convert FormField to FieldDetails for rendering.
+ * Uses field.Value or creates empty default based on field type.
+ */
+export function fieldToDetails(field: Spec_FormField$1<Spec_FieldType_$union>): FieldDetails$1<Spec_FieldType_$union> {
+    let matchValue: Option<Shared_FieldValue_$union>;
+    return new FieldDetails$1(field.FieldOrder, field.FieldKey, field.Label, (matchValue = field.Value, (matchValue == null) ? Shared_FieldValue_Single(new Shared_FieldAnswer(field.FieldKey, field.Label, "")) : value_1(matchValue)), field.FieldType, optionsFromField(field));
+}
+
+/**
+ * Get FieldDetails for a field by FieldKey (for pathway/scoring)
+ */
+export function getFieldDetails(spec: Spec_FormSpec$1<Spec_FieldType_$union>, fieldKey: Shared_FieldKey): Option<FieldDetails$1<Spec_FieldType_$union>> {
+    return map_1<Spec_FormField$1<Spec_FieldType_$union>, FieldDetails$1<Spec_FieldType_$union>>(fieldToDetails, tryFind<Spec_FormField$1<Spec_FieldType_$union>>((f: Spec_FormField$1<Spec_FieldType_$union>): boolean => equals(f.FieldKey, fieldKey), collect<Spec_FormStep$1<Spec_FieldType_$union>, Spec_FormField$1<Spec_FieldType_$union>>((step: Spec_FormStep$1<Spec_FieldType_$union>): FSharpList<Spec_FormField$1<Spec_FieldType_$union>> => step.Fields, spec.Steps)));
+}
+
+/**
+ * Build ResultSteps Map from FormSpec (for TypeScript interop / backward compatibility).
+ */
+export function formSpecToResultStepsMap(spec: Spec_FormSpec$1<Spec_FieldType_$union>): FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>> {
+    return ofList<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>>(map<Spec_FormStep$1<Spec_FieldType_$union>, [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]>((step: Spec_FormStep$1<Spec_FieldType_$union>): [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>] => ([new Values_StepOrder(step.StepOrder), ofList<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>(map<Spec_FormField$1<Spec_FieldType_$union>, [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]>((f: Spec_FormField$1<Spec_FieldType_$union>): [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>] => ([f.FieldKey, fieldToDetails(f)] as [Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>]), step.Fields), {
+        Compare: compare,
+    })] as [Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<Spec_FieldType_$union>>]), spec.Steps), {
+        Compare: compare,
+    });
+}
+
+/**
+ * Build FormSpec with values from ResultSteps Map (for TypeScript interop).
+ */
+export function resultStepsMapToFormSpec<FieldType>(spec: Spec_FormSpec$1<FieldType>, resultSteps: FSharpMap<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<FieldType>>>): Spec_FormSpec$1<FieldType> {
+    return fold<Values_StepOrder, FSharpMap<Shared_FieldKey, FieldDetails$1<FieldType>>, Spec_FormSpec$1<FieldType>>((acc: Spec_FormSpec$1<FieldType>, _arg: Values_StepOrder, stepValues: FSharpMap<Shared_FieldKey, FieldDetails$1<FieldType>>): Spec_FormSpec$1<FieldType> => {
+        const stepOrder: int32 = _arg.fields[0] | 0;
+        const stepIndex: int32 = findIndex<Spec_FormStep$1<FieldType>>((s: Spec_FormStep$1<FieldType>): boolean => (s.StepOrder === stepOrder), spec.Steps) | 0;
+        return fold<Shared_FieldKey, FieldDetails$1<FieldType>, Spec_FormSpec$1<FieldType>>((s_1: Spec_FormSpec$1<FieldType>, _arg_1: Shared_FieldKey, fieldDetails: FieldDetails$1<FieldType>): Spec_FormSpec$1<FieldType> => updateField<FieldType>(s_1, fieldDetails.Key, fieldDetails.FieldValue, stepIndex), acc, stepValues);
+    }, spec, resultSteps);
+}
+
+/**
+ * Derive FormSpecMetadata from FormSpec (for TS interop / DynamicForm conversion).
+ */
+export function formSpecToMetadata<FieldType>(spec: Spec_FormSpec$1<FieldType>): FormSpecMetadata {
+    return new FormSpecMetadata(spec.Id, spec.Code, spec.FormSpecVersion, spec.FormSpecVersion, spec.Score);
+}
+
+//# sourceMappingURL=FormSpecValues.ts.map