@f1studio/form-spec 5.0.0-alpha.101

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@f1studio/form-spec",
+  "version": "5.0.0-alpha.101",
+  "description": "F1 Core - Form specification and types",
+  "main": "./FormSpec.TS/Interop/FormSpec.Api.Option.js",
+  "types": "./Interop/FormSpec.Api.Option.d.ts",
+  "exports": {
+    ".": {
+      "types": "./Interop/FormSpec.Api.Option.d.ts",
+      "default": "./FormSpec.TS/Interop/FormSpec.Api.Option.js"
+    },
+    "./Values": {
+      "types": "./Interop/FormSpec.Values.Api.Option.d.ts",
+      "default": "./FormSpec.TS/Interop/FormSpec.Values.Api.Option.js"
+    },
+    "./Helpers": {
+      "types": "./Interop/FormSpec.Api.Helpers.d.ts",
+      "default": "./FormSpec.TS/Interop/FormSpec.Api.Helpers.js"
+    }
+  },
+  "files": [
+    "FormSpec.TS/**/*",
+    "src/**/*",
+    "README.md",
+    "README.TS.md",
+    "LICENSE",
+    "*.d.ts",
+    "Interop/**/*"
+  ],
+  "dependencies": {
+    "@fable-org/fable-library-js": "1.11.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/f1-studio/f1-monorepo.git"
+  },
+  "author": "LuisFX",
+  "license": "MIT"
+}

package/src/Components/HelloComponent.ts

@@ -0,0 +1,48 @@
+import { Record } from "@fable-org/fable-library-js/Types.js";
+import { value, Option } from "@fable-org/fable-library-js/Option.js";
+import { record_type, lambda_type, unit_type, option_type, string_type, TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { printf, toText } from "@fable-org/fable-library-js/String.js";
+
+export class HelloComponentProps extends Record {
+    readonly name: string;
+    readonly message: Option<string>;
+    readonly onButtonClick: Option<((arg0: string) => void)>;
+    constructor(name: string, message: Option<string>, onButtonClick: Option<((arg0: string) => void)>) {
+        super();
+        this.name = name;
+        this.message = message;
+        this.onButtonClick = onButtonClick;
+    }
+}
+
+export function HelloComponentProps_$reflection(): TypeInfo {
+    return record_type("FormSpec.Components.HelloComponent.HelloComponentProps", [], HelloComponentProps, () => [["name", string_type], ["message", option_type(string_type)], ["onButtonClick", option_type(lambda_type(string_type, unit_type))]]);
+}
+
+/**
+ * Generate greeting message from props
+ * This pure F# function will be compiled to TypeScript
+ */
+export function getGreetingMessage(props: HelloComponentProps): string {
+    const matchValue: Option<string> = props.message;
+    if (matchValue == null) {
+        return toText(printf("Hello from F#! Welcome, %s"))(props.name);
+    }
+    else {
+        return value(matchValue);
+    }
+}
+
+/**
+ * Handle button click
+ */
+export function handleButtonClick(props: HelloComponentProps): void {
+    const matchValue: Option<((arg0: string) => void)> = props.onButtonClick;
+    if (matchValue == null) {
+    }
+    else {
+        value(matchValue)(props.name);
+    }
+}
+
+//# sourceMappingURL=HelloComponent.ts.map

package/src/Components/HelloComponent.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../FormSpec.FS/Components/HelloComponent.fs"],"names":["matchValue","props"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAgBcA,uCAAA,AAAAC;AAAA,QAAA,AAAAD;AAEI,eAAA,OAAQ,OAAA,\u002BBAA6B,AAAAC;;;qBADjCD;;;;;;;;AAKRA,yDAAA,AAAAC;AAAA,QAAA,AAAAD;;;AACY,cAAAA,YAAQ,AAAAC","file":null,"sourcesContent":null,"sourceRoot":null}

package/src/Designer.ts

@@ -0,0 +1,389 @@
+import { FSharpRef, Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { list_type, string_type, record_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 { compare, IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { printf, toFail } from "@fable-org/fable-library-js/String.js";
+import { FSharpResult$2_$union, FSharpResult$2_Error, FSharpResult$2_Ok } from "@fable-org/fable-library-js/Result.js";
+import { map, FSharpList, ofArray, sort } from "@fable-org/fable-library-js/List.js";
+import { Spec_FormField$1, Spec_FormSpec$1, Shared_FieldOption_$reflection, Shared_FieldValue_$reflection, Shared_FieldKey_$reflection, Shared_FieldOption, Shared_FieldValue_$union, Shared_FieldKey } from "./FormSpec.js";
+import { newGuid, tryParse, parse } from "@fable-org/fable-library-js/Guid.js";
+import { Option } from "@fable-org/fable-library-js/Option.js";
+
+export type FieldState_$union = 
+    | FieldState<0>
+    | FieldState<1>
+
+export type FieldState_$cases = {
+    0: ["Idle", []],
+    1: ["AddingDependantKeys", []]
+}
+
+export function FieldState_Idle() {
+    return new FieldState<0>(0, []);
+}
+
+export function FieldState_AddingDependantKeys() {
+    return new FieldState<1>(1, []);
+}
+
+export class FieldState<Tag extends keyof FieldState_$cases> extends Union<Tag, FieldState_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: FieldState_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["Idle", "AddingDependantKeys"];
+    }
+}
+
+export function FieldState_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Designer.FieldState", [], FieldState, () => [[], []]);
+}
+
+export class ActiveField extends Record implements IEquatable<ActiveField>, IComparable<ActiveField> {
+    readonly FormStepNumber: int32;
+    readonly FormFieldNumber: int32;
+    readonly State: FieldState_$union;
+    constructor(FormStepNumber: int32, FormFieldNumber: int32, State: FieldState_$union) {
+        super();
+        this.FormStepNumber = (FormStepNumber | 0);
+        this.FormFieldNumber = (FormFieldNumber | 0);
+        this.State = State;
+    }
+}
+
+export function ActiveField_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Designer.ActiveField", [], ActiveField, () => [["FormStepNumber", int32_type], ["FormFieldNumber", int32_type], ["State", FieldState_$reflection()]]);
+}
+
+export type CategoryTag_$union = 
+    | CategoryTag<0>
+    | CategoryTag<1>
+    | CategoryTag<2>
+    | CategoryTag<3>
+    | CategoryTag<4>
+    | CategoryTag<5>
+    | CategoryTag<6>
+    | CategoryTag<7>
+    | CategoryTag<8>
+    | CategoryTag<9>
+    | CategoryTag<10>
+    | CategoryTag<11>
+
+export type CategoryTag_$cases = {
+    0: ["MentalHealth", []],
+    1: ["IllicitDrugs", []],
+    2: ["Alcohol", []],
+    3: ["RiskScore", []],
+    4: ["COPD", []],
+    5: ["HRA", []],
+    6: ["HeartDisease", []],
+    7: ["GeneralWellness", []],
+    8: ["KidneyDisease", []],
+    9: ["Diabetes", []],
+    10: ["Hospital", []],
+    11: ["MedAdherance", []]
+}
+
+export function CategoryTag_MentalHealth() {
+    return new CategoryTag<0>(0, []);
+}
+
+export function CategoryTag_IllicitDrugs() {
+    return new CategoryTag<1>(1, []);
+}
+
+export function CategoryTag_Alcohol() {
+    return new CategoryTag<2>(2, []);
+}
+
+export function CategoryTag_RiskScore() {
+    return new CategoryTag<3>(3, []);
+}
+
+export function CategoryTag_COPD() {
+    return new CategoryTag<4>(4, []);
+}
+
+export function CategoryTag_HRA() {
+    return new CategoryTag<5>(5, []);
+}
+
+export function CategoryTag_HeartDisease() {
+    return new CategoryTag<6>(6, []);
+}
+
+export function CategoryTag_GeneralWellness() {
+    return new CategoryTag<7>(7, []);
+}
+
+export function CategoryTag_KidneyDisease() {
+    return new CategoryTag<8>(8, []);
+}
+
+export function CategoryTag_Diabetes() {
+    return new CategoryTag<9>(9, []);
+}
+
+export function CategoryTag_Hospital() {
+    return new CategoryTag<10>(10, []);
+}
+
+export function CategoryTag_MedAdherance() {
+    return new CategoryTag<11>(11, []);
+}
+
+export class CategoryTag<Tag extends keyof CategoryTag_$cases> extends Union<Tag, CategoryTag_$cases[Tag][0]> {
+    constructor(readonly tag: Tag, readonly fields: CategoryTag_$cases[Tag][1]) {
+        super();
+    }
+    cases() {
+        return ["MentalHealth", "IllicitDrugs", "Alcohol", "RiskScore", "COPD", "HRA", "HeartDisease", "GeneralWellness", "KidneyDisease", "Diabetes", "Hospital", "MedAdherance"];
+    }
+}
+
+export function CategoryTag_$reflection(): TypeInfo {
+    return union_type("F1.Studio.Designer.CategoryTag", [], CategoryTag, () => [[], [], [], [], [], [], [], [], [], [], [], []]);
+}
+
+export function CategoryTag__get_toString(x: CategoryTag_$union): string {
+    switch (x.tag) {
+        case /* IllicitDrugs */ 1:
+            return "Illicit Drugs";
+        case /* Alcohol */ 2:
+            return "Alcohol";
+        case /* RiskScore */ 3:
+            return "Risk Score";
+        case /* COPD */ 4:
+            return "COPD";
+        case /* HRA */ 5:
+            return "HRA";
+        case /* HeartDisease */ 6:
+            return "Heart Disease";
+        case /* GeneralWellness */ 7:
+            return "General Wellness";
+        case /* KidneyDisease */ 8:
+            return "Kidney Disease";
+        case /* Diabetes */ 9:
+            return "Diabetes";
+        case /* Hospital */ 10:
+            return "Hospital";
+        case /* MedAdherance */ 11:
+            return "Med Adherance";
+        default:
+            return "Mental Health";
+    }
+}
+
+export function CategoryTag_fromString_Z721C83C5(s: string): CategoryTag_$union {
+    switch (s) {
+        case "Mental Health":
+            return CategoryTag_MentalHealth();
+        case "Illicit Drugs":
+            return CategoryTag_IllicitDrugs();
+        case "Alcohol":
+            return CategoryTag_Alcohol();
+        case "Risk Score":
+            return CategoryTag_RiskScore();
+        case "COPD":
+            return CategoryTag_COPD();
+        case "HRA":
+            return CategoryTag_HRA();
+        case "Heart Disease":
+            return CategoryTag_HeartDisease();
+        case "General Wellness":
+            return CategoryTag_GeneralWellness();
+        case "Kidney Disease":
+            return CategoryTag_KidneyDisease();
+        case "Diabetes":
+            return CategoryTag_Diabetes();
+        case "Hospital":
+            return CategoryTag_Hospital();
+        case "Med Adherance":
+            return CategoryTag_MedAdherance();
+        default:
+            return toFail(printf("Unknown category tag: %s"))(s);
+    }
+}
+
+export function CategoryTag__get_toIcon(x: CategoryTag_$union): string {
+    switch (x.tag) {
+        case /* IllicitDrugs */ 1:
+            return "/images/pills.svg";
+        case /* Alcohol */ 2:
+            return "/images/alcohol.svg";
+        case /* RiskScore */ 3:
+            return "/images/speedometer.svg";
+        case /* COPD */ 4:
+            return "/images/lungs.svg";
+        case /* HRA */ 5:
+            return "/images/assessment.svg";
+        case /* HeartDisease */ 6:
+            return "/images/heart.svg";
+        case /* GeneralWellness */ 7:
+            return "/images/healthcare.svg";
+        case /* KidneyDisease */ 8:
+            return "/images/kidney.svg";
+        case /* Diabetes */ 9:
+            return "/images/insulin-pen.svg";
+        case /* Hospital */ 10:
+            return "/images/medical-kit.svg";
+        case /* MedAdherance */ 11:
+            return "/images/tablet.svg";
+        default:
+            return "/images/brain2.svg";
+    }
+}
+
+export function CategoryTag__get_toIndex(x: CategoryTag_$union): int32 {
+    switch (x.tag) {
+        case /* IllicitDrugs */ 1:
+            return 1;
+        case /* Alcohol */ 2:
+            return 2;
+        case /* RiskScore */ 3:
+            return 3;
+        case /* COPD */ 4:
+            return 4;
+        case /* HRA */ 5:
+            return 5;
+        case /* HeartDisease */ 6:
+            return 6;
+        case /* GeneralWellness */ 7:
+            return 7;
+        case /* KidneyDisease */ 8:
+            return 8;
+        case /* Diabetes */ 9:
+            return 9;
+        case /* Hospital */ 10:
+            return 10;
+        case /* MedAdherance */ 11:
+            return 11;
+        default:
+            return 0;
+    }
+}
+
+export function CategoryTag_fromIndex_Z524259A4(categoryTagIndex: int32): CategoryTag_$union {
+    switch (categoryTagIndex) {
+        case 0:
+            return CategoryTag_MentalHealth();
+        case 1:
+            return CategoryTag_IllicitDrugs();
+        case 2:
+            return CategoryTag_Alcohol();
+        case 3:
+            return CategoryTag_RiskScore();
+        case 4:
+            return CategoryTag_COPD();
+        case 5:
+            return CategoryTag_HRA();
+        case 6:
+            return CategoryTag_HeartDisease();
+        case 7:
+            return CategoryTag_GeneralWellness();
+        case 8:
+            return CategoryTag_KidneyDisease();
+        case 9:
+            return CategoryTag_Diabetes();
+        case 10:
+            return CategoryTag_Hospital();
+        case 11:
+            return CategoryTag_MedAdherance();
+        default:
+            throw new Error(`${categoryTagIndex} is not a valid Category Tag index`);
+    }
+}
+
+export function CategoryTag_validate_Z524259A4(categoryTagIndex: int32): FSharpResult$2_$union<void, string> {
+    switch (categoryTagIndex) {
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+        case 9:
+        case 10:
+        case 11:
+            return FSharpResult$2_Ok<void, string>(undefined);
+        default:
+            return FSharpResult$2_Error<void, string>("Invalid value for Category Tag index");
+    }
+}
+
+export function categoryTagToString(c: CategoryTag_$union): string {
+    return CategoryTag__get_toString(c);
+}
+
+export const availableCategoryTags: FSharpList<CategoryTag_$union> = sort<CategoryTag_$union>(ofArray([CategoryTag_MentalHealth(), CategoryTag_IllicitDrugs(), CategoryTag_Alcohol(), CategoryTag_RiskScore(), CategoryTag_COPD(), CategoryTag_HRA(), CategoryTag_HeartDisease(), CategoryTag_GeneralWellness(), CategoryTag_KidneyDisease(), CategoryTag_Diabetes(), CategoryTag_Hospital(), CategoryTag_MedAdherance()]), {
+    Compare: compare,
+});
+
+export function CategoryTagModule_getList(): FSharpList<CategoryTag_$union> {
+    return sort<CategoryTag_$union>(ofArray([CategoryTag_MentalHealth(), CategoryTag_IllicitDrugs(), CategoryTag_Alcohol(), CategoryTag_RiskScore(), CategoryTag_COPD(), CategoryTag_HRA(), CategoryTag_HeartDisease(), CategoryTag_GeneralWellness(), CategoryTag_KidneyDisease(), CategoryTag_Diabetes(), CategoryTag_Hospital(), CategoryTag_MedAdherance()]), {
+        Compare: compare,
+    });
+}
+
+export class FieldDetails extends Record implements IEquatable<FieldDetails>, IComparable<FieldDetails> {
+    readonly FieldOrder: int32;
+    readonly Key: Shared_FieldKey;
+    readonly Label: string;
+    readonly FieldValue: Shared_FieldValue_$union;
+    readonly Options: FSharpList<Shared_FieldOption>;
+    constructor(FieldOrder: int32, Key: Shared_FieldKey, Label: string, FieldValue: Shared_FieldValue_$union, Options: FSharpList<Shared_FieldOption>) {
+        super();
+        this.FieldOrder = (FieldOrder | 0);
+        this.Key = Key;
+        this.Label = Label;
+        this.FieldValue = FieldValue;
+        this.Options = Options;
+    }
+}
+
+export function FieldDetails_$reflection(): TypeInfo {
+    return record_type("F1.Studio.Designer.FieldDetails", [], FieldDetails, () => [["FieldOrder", int32_type], ["Key", Shared_FieldKey_$reflection()], ["Label", string_type], ["FieldValue", Shared_FieldValue_$reflection()], ["Options", list_type(Shared_FieldOption_$reflection())]]);
+}
+
+export function Converters_fieldKeyToString(key: Shared_FieldKey): string {
+    return key.fields[0];
+}
+
+export function Converters_stringToFieldKey(s: string): Shared_FieldKey {
+    return new Shared_FieldKey(parse(s));
+}
+
+export function Converters_tryStringToFieldKey(s: string): Option<Shared_FieldKey> {
+    let matchValue: [boolean, string];
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = ([tryParse(s, new FSharpRef<string>((): string => outArg, (v: string): void => {
+        outArg = v;
+    })), outArg] as [boolean, string]);
+    if (matchValue[0]) {
+        return new Shared_FieldKey(matchValue[1]);
+    }
+    else {
+        return undefined;
+    }
+}
+
+export function Converters_formSpecToLibrary<UserField>(spec: Spec_FormSpec$1<UserField>, categoryTags: FSharpList<CategoryTag_$union>): Spec_FormSpec$1<UserField> {
+    return new Spec_FormSpec$1(spec.Id, spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, spec.Steps, map<CategoryTag_$union, string>(CategoryTag__get_toString, categoryTags), spec.Score, spec.AssociatedCodes, spec.RequiresReview, spec.RequiresReviewAndApproval, spec.ClinicalPathway);
+}
+
+export function Converters_formSpecFromLibrary<UserField>(spec: Spec_FormSpec$1<UserField>): [Spec_FormSpec$1<UserField>, FSharpList<CategoryTag_$union>] {
+    return [spec, map<string, CategoryTag_$union>(CategoryTag_fromString_Z721C83C5, spec.CategoryTags)] as [Spec_FormSpec$1<UserField>, FSharpList<CategoryTag_$union>];
+}
+
+export function Converters_createFormField<UserField>(order: int32, label: string, fieldType: UserField): Spec_FormField$1<UserField> {
+    return new Spec_FormField$1(order, new Shared_FieldKey(newGuid()), label, undefined, undefined, false, false, fieldType);
+}
+
+export function Converters_fieldToDetails<UserField>(field: Spec_FormField$1<UserField>, value: Shared_FieldValue_$union, options: FSharpList<Shared_FieldOption>): FieldDetails {
+    return new FieldDetails(field.FieldOrder, field.FieldKey, field.Label, value, options);
+}
+
+//# sourceMappingURL=Designer.ts.map

package/src/Designer.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../FormSpec.FS/Designer.fs"],"names":["x","s","categoryTagIndex","toString","c","key","matchValue","outArg","spec","categoryTags","fromString","order","label","fieldType","field","value","options"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAiCkBA;;mBAEY;;mBACL;;mBACE;;mBACL;;mBACD;;mBACS;;mBACG;;mBACF;;mBACL;;mBACA;;mBACI;;mBAXA;;;;;YAcZC;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;;AAaC,mBAAA,OAAU,OAAA,6BAA2BA;;;;;YAGtCD;;mBAEY;;mBACL;;mBACE;;mBACL;;mBACD;;mBACS;;mBACG;;mBACF;;mBACL;;mBACA;;mBACI;;mBAXA;;;;;YAcZA;;mBAEY;;mBACL;;mBACE;;mBACL;;mBACD;;mBACS;;mBACG;;mBACF;;mBACL;;mBACA;;mBACI;;mBAXA;;;;;YAcZE;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;;AAaC,4BAAS,GAAGA;;;;;YAGbA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;mDACkD;;sDAC3C;;;;;WAGjB,AAAAC,0BAAAC;;;qEAIG,yBADH;;;;;WAMO,yBADH;;;;;;;;;;;;;;;;;;;;;;;;;;WAyBI,AAAAC;;;;WAIJ,0BAA2BJ;;;;AAGrBK;AAAAC;AAAAD,4BAAcL,GAAd,oCAAAM;AAAAA;SAAAA;AAAA,QAAA,AAAAD;AACe,eAAA,oBAAL,AAAAA;;;AACF,eAAA;;;;;WAQd,oBAAA,AAAAE,SAAA,AAAAA,WAAA,AAAAA,YAAA,AAAAA,eAAA,AAAAA,cAAA,AAAAA,sBAAA,AAAAA,YACmC,gCAAmBL,2BAAnCM,eADnB,AAAAD,YAAA,AAAAA,sBAAA,AAAAA,qBAAA,AAAAA,gCAAA,AAAAA;;;;YASAA,MADgC,gCAASE,kCAA9B,AAAAF;;;;WAUX,qBACiBG,OACF,gCACHC,OACA,WACI,WACC,OACE,OACHC;;;;WAUhB,iBACiB,AAAAC,kBACP,AAAAA,gBACE,AAAAA,aACKC,OACHC","file":null,"sourcesContent":null,"sourceRoot":null}