@f1studio/form-spec 5.0.0-alpha.101

package/Designer.d.ts

@@ -0,0 +1,89 @@
+import { Record, Union } from "@fable-org/fable-library-js/Types.js";
+import { TypeInfo } from "@fable-org/fable-library-js/Reflection.js";
+import { int32 } from "@fable-org/fable-library-js/Int32.js";
+import { IComparable, IEquatable } from "@fable-org/fable-library-js/Util.js";
+import { FSharpResult$2_$union } from "@fable-org/fable-library-js/Result.js";
+import { FSharpList } from "@fable-org/fable-library-js/List.js";
+import { Spec_FormField$1, Spec_FormSpec$1, Shared_FieldOption, Shared_FieldValue_$union, Shared_FieldKey } from "./FormSpec.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 declare function FieldState_Idle(): FieldState<0>;
+export declare function FieldState_AddingDependantKeys(): FieldState<1>;
+export declare class FieldState<Tag extends keyof FieldState_$cases> extends Union<Tag, FieldState_$cases[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: FieldState_$cases[Tag][1];
+    constructor(tag: Tag, fields: FieldState_$cases[Tag][1]);
+    cases(): string[];
+}
+export declare function FieldState_$reflection(): TypeInfo;
+export declare 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);
+}
+export declare function ActiveField_$reflection(): TypeInfo;
+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 declare function CategoryTag_MentalHealth(): CategoryTag<0>;
+export declare function CategoryTag_IllicitDrugs(): CategoryTag<1>;
+export declare function CategoryTag_Alcohol(): CategoryTag<2>;
+export declare function CategoryTag_RiskScore(): CategoryTag<3>;
+export declare function CategoryTag_COPD(): CategoryTag<4>;
+export declare function CategoryTag_HRA(): CategoryTag<5>;
+export declare function CategoryTag_HeartDisease(): CategoryTag<6>;
+export declare function CategoryTag_GeneralWellness(): CategoryTag<7>;
+export declare function CategoryTag_KidneyDisease(): CategoryTag<8>;
+export declare function CategoryTag_Diabetes(): CategoryTag<9>;
+export declare function CategoryTag_Hospital(): CategoryTag<10>;
+export declare function CategoryTag_MedAdherance(): CategoryTag<11>;
+export declare class CategoryTag<Tag extends keyof CategoryTag_$cases> extends Union<Tag, CategoryTag_$cases[Tag][0]> {
+    readonly tag: Tag;
+    readonly fields: CategoryTag_$cases[Tag][1];
+    constructor(tag: Tag, fields: CategoryTag_$cases[Tag][1]);
+    cases(): string[];
+}
+export declare function CategoryTag_$reflection(): TypeInfo;
+export declare function CategoryTag__get_toString(x: CategoryTag_$union): string;
+export declare function CategoryTag_fromString_Z721C83C5(s: string): CategoryTag_$union;
+export declare function CategoryTag__get_toIcon(x: CategoryTag_$union): string;
+export declare function CategoryTag__get_toIndex(x: CategoryTag_$union): int32;
+export declare function CategoryTag_fromIndex_Z524259A4(categoryTagIndex: int32): CategoryTag_$union;
+export declare function CategoryTag_validate_Z524259A4(categoryTagIndex: int32): FSharpResult$2_$union<void, string>;
+export declare function categoryTagToString(c: CategoryTag_$union): string;
+export declare const availableCategoryTags: FSharpList<CategoryTag_$union>;
+export declare function CategoryTagModule_getList(): FSharpList<CategoryTag_$union>;
+export declare 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>);
+}
+export declare function FieldDetails_$reflection(): TypeInfo;
+export declare function Converters_fieldKeyToString(key: Shared_FieldKey): string;
+export declare function Converters_stringToFieldKey(s: string): Shared_FieldKey;
+export declare function Converters_tryStringToFieldKey(s: string): Option<Shared_FieldKey>;
+export declare function Converters_formSpecToLibrary<UserField>(spec: Spec_FormSpec$1<UserField>, categoryTags: FSharpList<CategoryTag_$union>): Spec_FormSpec$1<UserField>;
+export declare function Converters_formSpecFromLibrary<UserField>(spec: Spec_FormSpec$1<UserField>): [Spec_FormSpec$1<UserField>, FSharpList<CategoryTag_$union>];
+export declare function Converters_createFormField<UserField>(order: int32, label: string, fieldType: UserField): Spec_FormField$1<UserField>;
+export declare function Converters_fieldToDetails<UserField>(field: Spec_FormField$1<UserField>, value: Shared_FieldValue_$union, options: FSharpList<Shared_FieldOption>): FieldDetails;
+//# sourceMappingURL=Designer.d.ts.map

package/FormSpec.TS/Components/HelloComponent.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get HelloComponentProps () {
+        return HelloComponentProps;
+    },
+    get HelloComponentProps_$reflection () {
+        return HelloComponentProps_$reflection;
+    },
+    get getGreetingMessage () {
+        return getGreetingMessage;
+    },
+    get handleButtonClick () {
+        return handleButtonClick;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+class HelloComponentProps extends _Types.Record {
+    constructor(name, message, onButtonClick){
+        super();
+        this.name = name;
+        this.message = message;
+        this.onButtonClick = onButtonClick;
+    }
+}
+function HelloComponentProps_$reflection() {
+    return (0, _Reflection.record_type)("FormSpec.Components.HelloComponent.HelloComponentProps", [], HelloComponentProps, ()=>[
+            [
+                "name",
+                _Reflection.string_type
+            ],
+            [
+                "message",
+                (0, _Reflection.option_type)(_Reflection.string_type)
+            ],
+            [
+                "onButtonClick",
+                (0, _Reflection.option_type)((0, _Reflection.lambda_type)(_Reflection.string_type, _Reflection.unit_type))
+            ]
+        ]);
+}
+function getGreetingMessage(props) {
+    const matchValue = props.message;
+    if (matchValue == null) {
+        return (0, _String.toText)((0, _String.printf)("Hello from F#! Welcome, %s"))(props.name);
+    } else {
+        return (0, _Option.value)(matchValue);
+    }
+}
+function handleButtonClick(props) {
+    const matchValue = props.onButtonClick;
+    if (matchValue == null) {} else {
+        (0, _Option.value)(matchValue)(props.name);
+    }
+} //# sourceMappingURL=HelloComponent.ts.map
+
+//# sourceMappingURL=HelloComponent.js.map

package/FormSpec.TS/Components/HelloComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../FormSpec.TS/Components/HelloComponent.ts"],"names":["matchValue","props"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBcA,MAAAA,aAAAC,MAAAA,OAAAA;IAAA,IAAAD,cAAAA,MAAAA;QAEI,WAAA,cAAA,MAAQ,cAAA,EAAA,+BAA6BC,MAAAA,IAAAA;;kCADjCD;;;;IAKRA,MAAAA,aAAAC,MAAAA,aAAAA;IAAA,IAAAD,cAAAA,MAAAA;QACY,IAAA,aAAA,EAAAA,YAAQC,MAAAA,IAAAA"}

package/FormSpec.TS/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/FormSpec.TS/Designer.js

@@ -0,0 +1,526 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ActiveField () {
+        return ActiveField;
+    },
+    get ActiveField_$reflection () {
+        return ActiveField_$reflection;
+    },
+    get CategoryTag () {
+        return CategoryTag;
+    },
+    get CategoryTagModule_getList () {
+        return CategoryTagModule_getList;
+    },
+    get CategoryTag_$reflection () {
+        return CategoryTag_$reflection;
+    },
+    get CategoryTag_Alcohol () {
+        return CategoryTag_Alcohol;
+    },
+    get CategoryTag_COPD () {
+        return CategoryTag_COPD;
+    },
+    get CategoryTag_Diabetes () {
+        return CategoryTag_Diabetes;
+    },
+    get CategoryTag_GeneralWellness () {
+        return CategoryTag_GeneralWellness;
+    },
+    get CategoryTag_HRA () {
+        return CategoryTag_HRA;
+    },
+    get CategoryTag_HeartDisease () {
+        return CategoryTag_HeartDisease;
+    },
+    get CategoryTag_Hospital () {
+        return CategoryTag_Hospital;
+    },
+    get CategoryTag_IllicitDrugs () {
+        return CategoryTag_IllicitDrugs;
+    },
+    get CategoryTag_KidneyDisease () {
+        return CategoryTag_KidneyDisease;
+    },
+    get CategoryTag_MedAdherance () {
+        return CategoryTag_MedAdherance;
+    },
+    get CategoryTag_MentalHealth () {
+        return CategoryTag_MentalHealth;
+    },
+    get CategoryTag_RiskScore () {
+        return CategoryTag_RiskScore;
+    },
+    get CategoryTag__get_toIcon () {
+        return CategoryTag__get_toIcon;
+    },
+    get CategoryTag__get_toIndex () {
+        return CategoryTag__get_toIndex;
+    },
+    get CategoryTag__get_toString () {
+        return CategoryTag__get_toString;
+    },
+    get CategoryTag_fromIndex_Z524259A4 () {
+        return CategoryTag_fromIndex_Z524259A4;
+    },
+    get CategoryTag_fromString_Z721C83C5 () {
+        return CategoryTag_fromString_Z721C83C5;
+    },
+    get CategoryTag_validate_Z524259A4 () {
+        return CategoryTag_validate_Z524259A4;
+    },
+    get Converters_createFormField () {
+        return Converters_createFormField;
+    },
+    get Converters_fieldKeyToString () {
+        return Converters_fieldKeyToString;
+    },
+    get Converters_fieldToDetails () {
+        return Converters_fieldToDetails;
+    },
+    get Converters_formSpecFromLibrary () {
+        return Converters_formSpecFromLibrary;
+    },
+    get Converters_formSpecToLibrary () {
+        return Converters_formSpecToLibrary;
+    },
+    get Converters_stringToFieldKey () {
+        return Converters_stringToFieldKey;
+    },
+    get Converters_tryStringToFieldKey () {
+        return Converters_tryStringToFieldKey;
+    },
+    get FieldDetails () {
+        return FieldDetails;
+    },
+    get FieldDetails_$reflection () {
+        return FieldDetails_$reflection;
+    },
+    get FieldState () {
+        return FieldState;
+    },
+    get FieldState_$reflection () {
+        return FieldState_$reflection;
+    },
+    get FieldState_AddingDependantKeys () {
+        return FieldState_AddingDependantKeys;
+    },
+    get FieldState_Idle () {
+        return FieldState_Idle;
+    },
+    get availableCategoryTags () {
+        return availableCategoryTags;
+    },
+    get categoryTagToString () {
+        return categoryTagToString;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _String = require("@fable-org/fable-library-js/String.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _FormSpec = require("./FormSpec.js");
+const _Guid = require("@fable-org/fable-library-js/Guid.js");
+function FieldState_Idle() {
+    return new FieldState(0, []);
+}
+function FieldState_AddingDependantKeys() {
+    return new FieldState(1, []);
+}
+class FieldState extends _Types.Union {
+    cases() {
+        return [
+            "Idle",
+            "AddingDependantKeys"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function FieldState_$reflection() {
+    return (0, _Reflection.union_type)("F1.Studio.Designer.FieldState", [], FieldState, ()=>[
+            [],
+            []
+        ]);
+}
+class ActiveField extends _Types.Record {
+    constructor(FormStepNumber, FormFieldNumber, State){
+        super();
+        this.FormStepNumber = FormStepNumber | 0;
+        this.FormFieldNumber = FormFieldNumber | 0;
+        this.State = State;
+    }
+}
+function ActiveField_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.Designer.ActiveField", [], ActiveField, ()=>[
+            [
+                "FormStepNumber",
+                _Reflection.int32_type
+            ],
+            [
+                "FormFieldNumber",
+                _Reflection.int32_type
+            ],
+            [
+                "State",
+                FieldState_$reflection()
+            ]
+        ]);
+}
+function CategoryTag_MentalHealth() {
+    return new CategoryTag(0, []);
+}
+function CategoryTag_IllicitDrugs() {
+    return new CategoryTag(1, []);
+}
+function CategoryTag_Alcohol() {
+    return new CategoryTag(2, []);
+}
+function CategoryTag_RiskScore() {
+    return new CategoryTag(3, []);
+}
+function CategoryTag_COPD() {
+    return new CategoryTag(4, []);
+}
+function CategoryTag_HRA() {
+    return new CategoryTag(5, []);
+}
+function CategoryTag_HeartDisease() {
+    return new CategoryTag(6, []);
+}
+function CategoryTag_GeneralWellness() {
+    return new CategoryTag(7, []);
+}
+function CategoryTag_KidneyDisease() {
+    return new CategoryTag(8, []);
+}
+function CategoryTag_Diabetes() {
+    return new CategoryTag(9, []);
+}
+function CategoryTag_Hospital() {
+    return new CategoryTag(10, []);
+}
+function CategoryTag_MedAdherance() {
+    return new CategoryTag(11, []);
+}
+class CategoryTag extends _Types.Union {
+    cases() {
+        return [
+            "MentalHealth",
+            "IllicitDrugs",
+            "Alcohol",
+            "RiskScore",
+            "COPD",
+            "HRA",
+            "HeartDisease",
+            "GeneralWellness",
+            "KidneyDisease",
+            "Diabetes",
+            "Hospital",
+            "MedAdherance"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function CategoryTag_$reflection() {
+    return (0, _Reflection.union_type)("F1.Studio.Designer.CategoryTag", [], CategoryTag, ()=>[
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            [],
+            []
+        ]);
+}
+function CategoryTag__get_toString(x) {
+    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";
+    }
+}
+function CategoryTag_fromString_Z721C83C5(s) {
+    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 (0, _String.toFail)((0, _String.printf)("Unknown category tag: %s"))(s);
+    }
+}
+function CategoryTag__get_toIcon(x) {
+    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";
+    }
+}
+function CategoryTag__get_toIndex(x) {
+    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;
+    }
+}
+function CategoryTag_fromIndex_Z524259A4(categoryTagIndex) {
+    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`);
+    }
+}
+function CategoryTag_validate_Z524259A4(categoryTagIndex) {
+    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 (0, _Result.FSharpResult$2_Ok)(undefined);
+        default:
+            return (0, _Result.FSharpResult$2_Error)("Invalid value for Category Tag index");
+    }
+}
+function categoryTagToString(c) {
+    return CategoryTag__get_toString(c);
+}
+const availableCategoryTags = (0, _List.sort)((0, _List.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: _Util.compare
+});
+function CategoryTagModule_getList() {
+    return (0, _List.sort)((0, _List.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: _Util.compare
+    });
+}
+class FieldDetails extends _Types.Record {
+    constructor(FieldOrder, Key, Label, FieldValue, Options){
+        super();
+        this.FieldOrder = FieldOrder | 0;
+        this.Key = Key;
+        this.Label = Label;
+        this.FieldValue = FieldValue;
+        this.Options = Options;
+    }
+}
+function FieldDetails_$reflection() {
+    return (0, _Reflection.record_type)("F1.Studio.Designer.FieldDetails", [], FieldDetails, ()=>[
+            [
+                "FieldOrder",
+                _Reflection.int32_type
+            ],
+            [
+                "Key",
+                (0, _FormSpec.Shared_FieldKey_$reflection)()
+            ],
+            [
+                "Label",
+                _Reflection.string_type
+            ],
+            [
+                "FieldValue",
+                (0, _FormSpec.Shared_FieldValue_$reflection)()
+            ],
+            [
+                "Options",
+                (0, _Reflection.list_type)((0, _FormSpec.Shared_FieldOption_$reflection)())
+            ]
+        ]);
+}
+function Converters_fieldKeyToString(key) {
+    return key.fields[0];
+}
+function Converters_stringToFieldKey(s) {
+    return new _FormSpec.Shared_FieldKey((0, _Guid.parse)(s));
+}
+function Converters_tryStringToFieldKey(s) {
+    let matchValue;
+    let outArg = "00000000-0000-0000-0000-000000000000";
+    matchValue = [
+        (0, _Guid.tryParse)(s, new _Types.FSharpRef(()=>outArg, (v)=>{
+            outArg = v;
+        })),
+        outArg
+    ];
+    if (matchValue[0]) {
+        return new _FormSpec.Shared_FieldKey(matchValue[1]);
+    } else {
+        return undefined;
+    }
+}
+function Converters_formSpecToLibrary(spec, categoryTags) {
+    return new _FormSpec.Spec_FormSpec$1(spec.Id, spec.Code, spec.Title, spec.Abstract, spec.Version, spec.FormSpecVersion, spec.Steps, (0, _List.map)(CategoryTag__get_toString, categoryTags), spec.Score, spec.AssociatedCodes, spec.RequiresReview, spec.RequiresReviewAndApproval, spec.ClinicalPathway);
+}
+function Converters_formSpecFromLibrary(spec) {
+    return [
+        spec,
+        (0, _List.map)(CategoryTag_fromString_Z721C83C5, spec.CategoryTags)
+    ];
+}
+function Converters_createFormField(order, label, fieldType) {
+    return new _FormSpec.Spec_FormField$1(order, new _FormSpec.Shared_FieldKey((0, _Guid.newGuid)()), label, undefined, undefined, false, false, fieldType);
+}
+function Converters_fieldToDetails(field, value, options) {
+    return new FieldDetails(field.FieldOrder, field.FieldKey, field.Label, value, options);
+} //# sourceMappingURL=Designer.ts.map
+
+//# sourceMappingURL=Designer.js.map

package/FormSpec.TS/Designer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../FormSpec.TS/Designer.ts"],"names":["x","s","categoryTagIndex","toString","c","key","matchValue","outArg","spec","categoryTags","fromString","order","label","fieldType","field","value","options"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiCkBA,EAAAA,GAAAA;;mBAEY;;mBACL;;mBACE;;mBACL;;mBACD;;mBACS;;mBACG;;mBACF;;mBACL;;mBACA;;mBACI;;mBAXA;;;;WAcZC;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;;YAaC,WAAA,cAAA,MAAU,cAAA,EAAA,6BAA2BA;;;;WAGtCD,EAAAA,GAAAA;;mBAEY;;mBACL;;mBACE;;mBACL;;mBACD;;mBACS;;mBACG;;mBACF;;mBACL;;mBACA;;mBACI;;mBAXA;;;;WAcZA,EAAAA,GAAAA;;mBAEY;;mBACL;;mBACE;;mBACL;;mBACD;;mBACS;;mBACG;;mBACF;;mBACL;;mBACA;;mBACI;;mBAXA;;;;WAcZE;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;aAAA;;;YAaC,MAAA,IAAA,MAAS,GAAGA,iBAAAA,kCAAAA,CAAAA;;;;WAGbA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;aAAA;kDACkD;;qDAC3C;;;;WAGjBC,0BAAAC;;kCAIG,UAAA,MADH,aAAA,EAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;CAAA,GAAA;;;;eAMO,UAAA,MADH,aAAA,EAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;KAAA,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAyBIC,IAAAA,MAAAA,CAAAA,EAAAA;;;WAIJ,IAAA,yBAAA,CAAA,IAAA,WAAA,EAA2BJ;;;IAGrBK,IAAAA;IAAAC,IAAAA,SAAAA;IAAAD,aAAAA;QAAAA,IAAAA,cAAAA,EAAcL,GAAd,IAAA,gBAAA,CAAA,IAAAM,QAAAA,CAAAA;YAAAA,SAAAA;;QAAAA;KAAAA;IAAA,IAAAD,UAAAA,CAAAA,EAAAA,EAAAA;QACe,OAAA,IAAA,yBAAA,CAALA,UAAAA,CAAAA,EAAAA;;QACF,OAAA;;;;WAQd,IAAA,yBAAA,CAAAE,KAAAA,EAAAA,EAAAA,KAAAA,IAAAA,EAAAA,KAAAA,KAAAA,EAAAA,KAAAA,QAAAA,EAAAA,KAAAA,OAAAA,EAAAA,KAAAA,eAAAA,EAAAA,KAAAA,KAAAA,MACmC,SAAA,EAAmBL,2BAAnCM,eADnBD,KAAAA,KAAAA,EAAAA,KAAAA,eAAAA,EAAAA,KAAAA,cAAAA,EAAAA,KAAAA,yBAAAA,EAAAA,KAAAA,eAAAA;;;;QASAA;YADgC,SAAA,EAASE,kCAA9BF,KAAAA,YAAAA;KAAAA;;;WAUX,IAAA,0BAAA,CACiBG,OACF,IAAA,yBAAA,CAAA,IAAA,aAAA,MACHC,OACA,WACI,WACC,OACE,OACHC;;;WAUhB,IAAA,aACiBC,MAAAA,UAAAA,EACPA,MAAAA,QAAAA,EACEA,MAAAA,KAAAA,EACKC,OACHC"}