@f1studio/form-spec 5.0.0-alpha.107 → 5.0.0-alpha.109

package/FormSpec.TS/fable_modules/Fable.Form.Simple.Bulma.5.0.1/Form.fs.js

@@ -0,0 +1,263 @@
+"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 MapValuesConfig$2 () {
+        return MapValuesConfig$2;
+    },
+    get MapValuesConfig$2_$reflection () {
+        return MapValuesConfig$2_$reflection;
+    },
+    get View_asHtml () {
+        return View_asHtml;
+    },
+    get andThen () {
+        return andThen;
+    },
+    get append () {
+        return append;
+    },
+    get checkboxField () {
+        return checkboxField;
+    },
+    get colorField () {
+        return colorField;
+    },
+    get dateField () {
+        return dateField;
+    },
+    get dateTimeLocalField () {
+        return dateTimeLocalField;
+    },
+    get disable () {
+        return disable;
+    },
+    get disableIf () {
+        return disableIf;
+    },
+    get emailField () {
+        return emailField;
+    },
+    get fileField () {
+        return fileField;
+    },
+    get group () {
+        return group;
+    },
+    get list () {
+        return list;
+    },
+    get mapValues () {
+        return mapValues;
+    },
+    get meta () {
+        return meta;
+    },
+    get numberField () {
+        return numberField;
+    },
+    get optional () {
+        return optional;
+    },
+    get passwordField () {
+        return passwordField;
+    },
+    get radioField () {
+        return radioField;
+    },
+    get readOnly () {
+        return readOnly;
+    },
+    get readOnlyIf () {
+        return readOnlyIf;
+    },
+    get searchField () {
+        return searchField;
+    },
+    get section () {
+        return section;
+    },
+    get selectField () {
+        return selectField;
+    },
+    get succeed () {
+        return succeed;
+    },
+    get telField () {
+        return telField;
+    },
+    get textField () {
+        return textField;
+    },
+    get textareaField () {
+        return textareaField;
+    },
+    get timeField () {
+        return timeField;
+    }
+});
+const _Formfs = require("../Fable.Form.Simple.5.0.1/Form.fs.js");
+const _HtmlViewfs = require("./Html.View.fs.js");
+const _Basefs = require("../Fable.Form.3.0.0/Base.fs.js");
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _TextFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/TextField.fs.js");
+const _TextFieldfs1 = require("./TextField.fs.js");
+const _ColorFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/ColorField.fs.js");
+const _ColorFieldfs1 = require("./ColorField.fs.js");
+const _DateFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/DateField.fs.js");
+const _DateFieldfs1 = require("./DateField.fs.js");
+const _DateTimeLocalFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/DateTimeLocalField.fs.js");
+const _DateTimeLocalFieldfs1 = require("./DateTimeLocalField.fs.js");
+const _EmailFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/EmailField.fs.js");
+const _EmailFieldfs1 = require("./EmailField.fs.js");
+const _NumberFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/NumberField.fs.js");
+const _NumberFieldfs1 = require("./NumberField.fs.js");
+const _PasswordFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/PasswordField.fs.js");
+const _PasswordFieldfs1 = require("./PasswordField.fs.js");
+const _SearchFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/SearchField.fs.js");
+const _SearchFieldfs1 = require("./SearchField.fs.js");
+const _TelFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/TelField.fs.js");
+const _TelFieldfs1 = require("./TelField.fs.js");
+const _TimeFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/TimeField.fs.js");
+const _TimeFieldfs1 = require("./TimeField.fs.js");
+const _TextareaFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/TextareaField.fs.js");
+const _TextareaFieldfs1 = require("./TextareaField.fs.js");
+const _CheckboxFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/CheckboxField.fs.js");
+const _CheckboxFieldfs1 = require("./CheckboxField.fs.js");
+const _RadioFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/RadioField.fs.js");
+const _RadioFieldfs1 = require("./RadioField.fs.js");
+const _SelectFieldfs = require("../Fable.Form.Simple.Fields.Html.1.0.1/SelectField.fs.js");
+const _SelectFieldfs1 = require("./SelectField.fs.js");
+const _FileFieldfs = require("./FileField.fs.js");
+const _FormListfs = require("./FormList.fs.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Sectionfs = require("./Section.fs.js");
+const _Groupfs = require("./Group.fs.js");
+function View_asHtml(config) {
+    return (form)=>(model)=>(0, _Formfs.custom)(config, _HtmlViewfs.form, _HtmlViewfs.renderField, form, model);
+}
+function succeed(output) {
+    return (0, _Basefs.succeed)(output);
+}
+function append(newForm, currentForm) {
+    return (0, _Basefs.append)(newForm, currentForm);
+}
+function disable(form) {
+    return (0, _Basefs.disable)(form);
+}
+function disableIf(condition, form) {
+    return (0, _Basefs.disableIf)(condition, form);
+}
+function readOnly(form) {
+    return (0, _Basefs.readOnly)(form);
+}
+function readOnlyIf(condition, form) {
+    return (0, _Basefs.readOnlyIf)(condition, form);
+}
+function andThen(child, parent) {
+    return (0, _Basefs.andThen)(child, parent);
+}
+function optional(form) {
+    return (0, _Basefs.optional)(form);
+}
+function meta(fn) {
+    return (0, _Basefs.meta)(fn);
+}
+class MapValuesConfig$2 extends _Types.Record {
+    constructor(Value, Update){
+        super();
+        this.Value = Value;
+        this.Update = Update;
+    }
+}
+function MapValuesConfig$2_$reflection(gen0, gen1) {
+    return (0, _Reflection.record_type)("Fable.Form.Simple.Bulma.Form.MapValuesConfig`2", [
+        gen0,
+        gen1
+    ], MapValuesConfig$2, ()=>[
+            [
+                "Value",
+                (0, _Reflection.lambda_type)(gen0, gen1)
+            ],
+            [
+                "Update",
+                (0, _Reflection.lambda_type)(gen1, (0, _Reflection.lambda_type)(gen0, gen0))
+            ]
+        ]);
+}
+function mapValues(_arg, form) {
+    return (0, _Basefs.meta)((values)=>(0, _Basefs.mapField)((field)=>field.MapFieldValues((oldValues)=>_arg.Update(oldValues, values)), (0, _Basefs.mapValues)(_arg.Value, form)));
+}
+function textField(config) {
+    return (0, _TextFieldfs.TextFieldModule_form)()(_TextFieldfs1.Field$1_$ctor_Z22C30168)(config);
+}
+function colorField(config) {
+    return (0, _ColorFieldfs.ColorFieldModule_form)()(_ColorFieldfs1.Field$1_$ctor_4ED23FD8)(config);
+}
+function dateField(config) {
+    return (0, _DateFieldfs.DateFieldModule_form)()(_DateFieldfs1.Field$1_$ctor_76CAA1F1)(config);
+}
+function dateTimeLocalField(config) {
+    return (0, _DateTimeLocalFieldfs.DateTimeLocalFieldModule_form)()(_DateTimeLocalFieldfs1.Field$1_$ctor_Z39D1F697)(config);
+}
+function emailField(config) {
+    return (0, _EmailFieldfs.EmailFieldModule_form)()(_EmailFieldfs1.Field$1_$ctor_Z6F9EDC17)(config);
+}
+function numberField(config) {
+    return (0, _NumberFieldfs.NumberFieldModule_form)()(_NumberFieldfs1.Field$1_$ctor_23C55586)(config);
+}
+function passwordField(config) {
+    return (0, _PasswordFieldfs.PasswordFieldModule_form)()(_PasswordFieldfs1.Field$1_$ctor_6904D35A)(config);
+}
+function searchField(config) {
+    return (0, _SearchFieldfs.SearchFieldModule_form)()(_SearchFieldfs1.Field$1_$ctor_ZD275)(config);
+}
+function telField(config) {
+    return (0, _TelFieldfs.TelFieldModule_form)()(_TelFieldfs1.Field$1_$ctor_Z19AC91C8)(config);
+}
+function timeField(config) {
+    return (0, _TimeFieldfs.TimeFieldModule_form)()(_TimeFieldfs1.Field$1_$ctor_1236A5B0)(config);
+}
+function textareaField(config) {
+    return (0, _TextareaFieldfs.TextareaFieldModule_form)()(_TextareaFieldfs1.Field$1_$ctor_3B5F9EAF)(config);
+}
+function checkboxField(config) {
+    return (0, _CheckboxFieldfs.CheckboxFieldModule_form)()(_CheckboxFieldfs1.Field$1_$ctor_Z43378559)(config);
+}
+function radioField(config) {
+    return (0, _RadioFieldfs.RadioFieldModule_form)()(_RadioFieldfs1.Field$1_$ctor_Z1E665B32)(config);
+}
+function selectField(config) {
+    return (0, _SelectFieldfs.SelectFieldModule_form)()(_SelectFieldfs1.Field$1_$ctor_Z6B5A6752)(config);
+}
+function fileField(config) {
+    return (0, _FileFieldfs.form)()(_FileFieldfs.Field$1_$ctor_Z332CAE39)(config);
+}
+function list(config, elementForIndex) {
+    return (0, _FormListfs.FormListModule_form)(_FormListfs.FormListModule_Field$4_$ctor_Z396DFD9E, config, (elementState)=>{
+        const filledElement = (0, _Basefs.fill)(elementForIndex(new _FormListfs.FormListModule_ElementContext(elementState.FieldIdPrefix, elementState.Index)), elementState.ElementValues);
+        return new _Basefs.FilledForm$2((0, _List.map)((filledField)=>new _Basefs.FilledField$1(filledField.State.MapFieldValues((oldValues)=>elementState.Update(oldValues, elementState.Values)), filledField.Error, filledField.IsDisabled, filledField.IsReadOnly), filledElement.Fields), filledElement.Result, filledElement.IsEmpty);
+    });
+}
+function section(title, form) {
+    return (0, _Basefs.custom)((values)=>{
+        const res = (0, _Basefs.fill)(form, values);
+        return new _Basefs.CustomField$2((0, _Sectionfs.Field$1_$ctor_33A98869)(title, res.Fields), res.Result, res.IsEmpty);
+    });
+}
+function group(form) {
+    return (0, _Basefs.custom)((values)=>{
+        const res = (0, _Basefs.fill)(form, values);
+        return new _Basefs.CustomField$2((0, _Groupfs.Field$1_$ctor_79FA8BF2)(res.Fields), res.Result, res.IsEmpty);
+    });
+} //# sourceMappingURL=Form.fs.ts.map
+
+//# sourceMappingURL=Form.fs.js.map

package/FormSpec.TS/fable_modules/Fable.Form.Simple.Bulma.5.0.1/Form.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.Simple.Bulma.5.0.1/Form.fs.ts"],"names":["config","form","model","output","newForm","currentForm","condition","child","parent","fn","field","_arg1","oldValues","values","filledElement","elementForIndex","elementState","filledField","res","title"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAiBY,cAAA,EAAAA,QAAAA,gBAAAA,EAAAA,uBAAAA,EAAAC,MAAAC;;;eAciD,eAAA,EAAaC;;;eAuClE,cAAA,EAAYC,SAAQC;;;eAWpB,eAAA,EAAaJ;;;eAWb,iBAAA,EAAeK,WAAUL;;;eASgC,gBAAA,EAAcA;;;eAWvE,kBAAA,EAAgBK,WAAUL;;;eA8E1B,eAAA,EAAaM,OAAMC;;;eAoCnB,gBAAA,EAAcP;;;eA0Cd,YAAA,EAAUQ;;;;;;;;;;;;;;;;;;;;;;;;;eAgCV,YAAA,EAAA,CAAA,aAGO,gBAAA,EAAA,CAAA,QAGCC,MAAAA,cAAAA,CAAAA,CAAAA,YAdPC,KAAAA,MAAAA,CAYwCC,WAAUC,cAF5C,iBAAA,EAVNF,KAAAA,KAAAA,EASGV;;;eAiBY,iCAAA,IAAA,qCAAA,EAAoCD;;;eAMnC,mCAAA,IAAA,qCAAA,EAAqCA;;;eAMtC,iCAAA,IAAA,oCAAA,EAAoCA;;;eAM3B,mDAAA,IAAA,8CAAA,EAA6CA;;;eAMrD,mCAAA,IAAA,sCAAA,EAAqCA;;;eAMpC,qCAAA,IAAA,sCAAA,EAAsCA;;;eAMpC,yCAAA,IAAA,wCAAA,EAAwCA;;;eAM1C,qCAAA,IAAA,mCAAA,EAAsCA;;;eAMzC,+BAAA,IAAA,oCAAA,EAAmCA;;;eAMlC,iCAAA,IAAA,oCAAA,EAAoCA;;;eAMhC,yCAAA,IAAA,wCAAA,EAAwCA;;;eAMxC,yCAAA,IAAA,yCAAA,EAAwCA;;;eAO3C,mCAAA,IAAA,sCAAA,EAAqCA;;;WAOpC,yCAAA,IAAA,uCAAA,EAAsCA;;;eAMxC,iBAAA,IAAA,oCAAA,EAAoCA;;;eAuFpD,+BAAA,EAAA,kDAAA,EAAqBA,QAAAA,CAAAA;QA9Bbc,MAAAA,oBAOA,YAAA,EAAWC,gBALP,IAAA,yCAAA,CACoBC,aAAAA,aAAAA,EACRA,aAAAA,KAAAA,IAGoBA,aAAAA,aAAAA;QAExC,OAAA,IAAA,oBAAA,KAGW,SAAA,EAAA,CAAA,cACC,IAAA,qBAAA,CAEQC,YAAAA,KAAAA,CAAAA,cAAAA,CAAAA,CAAAA,YACID,aAAAA,MAAAA,CAAoBJ,WAAUI,aAAAA,MAAAA,IAE9BC,YAAAA,KAAAA,EACKA,YAAAA,UAAAA,EACAA,YAAAA,UAAAA,GATrBH,cAAAA,MAAAA,GAYKA,cAAAA,MAAAA,EACCA,cAAAA,OAAAA;;;;eAqBlB,cAAA,EAAA,CAAA;QACQI,MAAAA,UAAM,YAAA,EAAUjB,MAAKY;QAEzB,OAAA,IAAA,qBAAA,KACY,iCAAA,EAAmBM,OAAOD,IAAAA,MAAAA,GACzBA,IAAAA,MAAAA,EACCA,IAAAA,OAAAA;;;;eAgBlB,cAAA,EAAA,CAAA;QACQA,MAAAA,UAAM,YAAA,EAAUjB,MAAKY;QAEzB,OAAA,IAAA,qBAAA,KACY,+BAAA,EAAYK,IAAAA,MAAAA,GACXA,IAAAA,MAAAA,EACCA,IAAAA,OAAAA"}

package/FormSpec.TS/fable_modules/Fable.Form.Simple.Bulma.5.0.1/Form.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Form.fs"],"names":["config","form","model","output","newForm","currentForm","condition","child","parent","fn","field","_arg1","oldValues","values","filledElement","elementForIndex","elementState","filledField","res","title"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qJAiBY,uDAAAA,\u002BBAAAC,MAAAC;;;;;;;WAciD,4CAAaC;;;;;;;WAuClE,yCAAYC,SAAQC;;;;;;;;;WAWpB,uCAAaJ;;;;;;;;;WAWb,yCAAeK,WAAUL;;;;;;;;;WASgC,wCAAcA;;;;;;;;;WAWvE,0CAAgBK,WAAUL;;;;;;;;;WA8E1B,0CAAaM,OAAMC;;;;;;;;;;;WAoCnB,wCAAcP;;;;;;;;;;;WA0Cd,yCAAUQ;;;;;;;;;;;;;;;;;;;;;;;WAgCV,8EAGO,mFAGC,AAAAC,6CAF0B,AAZjC,AAAAC,YAYwCC,WAAUC,UAF5C,uCAVN,AAAAF,YASGV;;;;WAiBJ,AAAgB,kFAAoCD;;;;WAMpD,AAAiB,kFAAqCA;;;;WAMtD,AAAgB,iFAAoCA;;;;WAMpD,AAAyB,2FAA6CA;;;;WAMtE,AAAiB,mFAAqCA;;;;WAMtD,AAAkB,mFAAsCA;;;;WAMxD,AAAoB,qFAAwCA;;;;WAM5D,AAAkB,gFAAsCA;;;;WAMxD,AAAe,iFAAmCA;;;;WAMlD,AAAgB,iFAAoCA;;;;WAMpD,AAAoB,qFAAwCA;;;;WAM5D,AAAoB,sFAAwCA;;;;WAO5D,AAAiB,mFAAqCA;;;;WAOtD,AAAkB,oFAAsCA;;;;WAMxD,AAAgB,oEAAoCA;;;;;;;;;WAuFpD,6GAAqBA;AA9Bbc,6EAOA,qDAAW,AAAAC,gBALP,kCACoB,AAAAC,4BACR,AAAAA,sBAGoB,AAAAA;AAExC,eAAA,iBAGW,wKACC,kBAEQ,AAAAC,\u002BEACI,AAAAD,oBAAoBJ,WAAU,AAAAI,uBAE9B,AAAAC,mBACK,AAAAA,wBACA,AAAAA,0BATrB,AAAAH,uBAYK,AAAAA,sBACC,AAAAA;;;;;;;;;;;;;;WAqBlB;AACQI,4DAAM,uCAAUjB,MAAKY;AAEzB,eAAA,kBACY,\u002BBAAmBM,OAAO,AAAAD,aACzB,AAAAA,YACC,AAAAA;;;;;;;;;;;;;;WAgBlB;AACQA,4DAAM,uCAAUjB,MAAKY;AAEzB,eAAA,kBACY,\u002BBAAY,AAAAK,aACX,AAAAA,YACC,AAAAA","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.Form.Simple.Bulma.5.0.1/FormList.fs

@@ -0,0 +1,361 @@
+namespace Fable.Form.Simple.Bulma.Fields
+
+open Fable.Form
+open Feliz
+open Feliz.Bulma
+open Fable.Form.Simple
+open Fable.Form.Simple.Bulma
+open Fable.Form.Extensions
+
+module FormList =
+
+    [<NoComparison; NoEquality>]
+    type Form<'Values, 'Field> =
+        {
+            Fields: Base.FilledField<'Field> list
+            Delete: unit -> 'Values
+        }
+
+    type Attributes =
+        {
+            FieldId: string
+            Label: string
+            Add: string option
+            Delete: string option
+        }
+
+    [<NoComparison; NoEquality>]
+    type InnerField<'Values, 'Field> =
+        {
+            Forms: Form<'Values, 'Field> list
+            Add: unit -> 'Values
+            Attributes: Attributes
+        }
+
+    [<NoComparison; NoEquality>]
+    type Config<'Values, 'ElementValues> =
+        {
+            Value: 'Values -> 'ElementValues list
+            Update: 'ElementValues list -> 'Values -> 'Values
+            Default: 'ElementValues
+            Attributes: Attributes
+        }
+
+    type ElementContext =
+        {
+            FieldIdPrefix: string
+            Index: int
+        }
+
+    [<NoComparison; NoEquality>]
+    type ElementState<'Values, 'ElementValues> =
+        {
+            FieldIdPrefix: string
+            Index: int
+            Update: 'ElementValues -> 'Values -> 'Values
+            Values: 'Values
+            ElementValues: 'ElementValues
+        }
+
+    let form<'Values, 'Field, 'ElementValues, 'Output>
+        (tagger: InnerField<'Values, 'Field> -> 'Field)
+        (formConfig: Config<'Values, 'ElementValues>)
+        (buildElement: ElementState<'Values, 'ElementValues> -> Base.FilledForm<'Output, 'Field>)
+        : Base.Form<'Values, 'Output list, 'Field>
+        =
+
+        Base.custom (fun values ->
+            let listOfElementValues = formConfig.Value values
+
+            let elementForIndex index elementValues =
+                buildElement
+                    {
+                        FieldIdPrefix = formConfig.Attributes.FieldId + "-" + string index
+                        Update =
+                            fun newElementValues values ->
+                                let newList = List.setAt index newElementValues listOfElementValues
+
+                                formConfig.Update newList values
+                        Index = index
+                        Values = values
+                        ElementValues = elementValues
+                    }
+
+            let filledElements = List.mapi elementForIndex listOfElementValues
+
+            let toForm (index: int) (form: Base.FilledForm<'Output, 'Field>) =
+                {
+                    Fields = form.Fields
+                    Delete =
+                        fun () ->
+                            let previousForms = List.take index listOfElementValues
+
+                            let nextForms = List.drop (index + 1) listOfElementValues
+
+                            formConfig.Update (previousForms @ nextForms) values
+                }
+
+            let gatherResults
+                (next: Base.FilledForm<'Output, 'Field>)
+                (current: Result<'Output list, Error.Error * Error.Error list>)
+                : Result<'Output list, Error.Error * Error.Error list>
+                =
+
+                match next.Result with
+                | Ok output -> Result.map (fun x -> output :: x) current
+
+                | Error(head, errors) ->
+                    match current with
+                    | Ok _ -> Error(head, errors)
+
+                    | Error(currentHead, currentErrors) ->
+                        Error(head, errors @ (currentHead :: currentErrors))
+
+            let result = List.foldBack gatherResults filledElements (Ok [])
+
+            let isEmpty =
+                List.fold
+                    (fun state (element: Base.FilledForm<'Output, 'Field>) ->
+                        element.IsEmpty && state
+                    )
+                    false
+                    filledElements
+
+            {
+                State =
+                    tagger
+                        {
+                            Forms = List.mapi toForm filledElements
+                            Add =
+                                fun _ ->
+                                    formConfig.Update
+                                        (listOfElementValues
+                                         @ [
+                                             formConfig.Default
+                                         ])
+                                        values
+                            Attributes = formConfig.Attributes
+                        }
+                Result = result
+                IsEmpty = isEmpty
+            }
+        )
+
+    module View =
+
+        [<NoComparison; NoEquality>]
+        type FormListConfig =
+            {
+                Forms: ReactElement list
+                Label: string
+                Add:
+                    {|
+                        Action: unit -> unit
+                        Label: string
+                    |} option
+                Disabled: bool
+            }
+
+        [<NoComparison; NoEquality>]
+        type FormListItemConfig =
+            {
+                Fields: ReactElement list
+                Delete:
+                    {|
+                        Action: unit -> unit
+                        Label: string
+                    |} option
+                Disabled: bool
+            }
+
+        let formList
+            ({
+                 Forms = forms
+                 Label = label
+                 Add = add
+                 Disabled = disabled
+             }: FormListConfig)
+            =
+
+            let addButton =
+                match disabled, add with
+                | (false, Some add) ->
+                    Bulma.button.a [
+                        prop.onClick (fun _ -> add.Action())
+
+                        prop.children [
+                            Bulma.icon [
+                                icon.isSmall
+
+                                prop.children [
+                                    Html.i [
+                                        prop.className "fas fa-plus"
+                                    ]
+                                ]
+                            ]
+
+                            Html.span add.Label
+                        ]
+                    ]
+
+                | _ -> Html.none
+
+            Bulma.field.div [
+                Bulma.control.div [
+                    Html.View.fieldLabel label
+
+                    yield! forms
+
+                    addButton
+                ]
+            ]
+
+        let formListItem
+            ({
+                 Fields = fields
+                 Delete = delete
+                 Disabled = disabled
+             }: FormListItemConfig)
+            =
+
+            let removeButton =
+                match disabled, delete with
+                | (false, Some delete) ->
+                    Bulma.button.a [
+                        prop.onClick (fun _ -> delete.Action())
+
+                        prop.children [
+                            Bulma.icon [
+                                icon.isSmall
+
+                                prop.children [
+                                    Html.i [
+                                        prop.className "fas fa-times"
+                                    ]
+                                ]
+                            ]
+
+                            if delete.Label <> "" then
+                                Html.span delete.Label
+                        ]
+                    ]
+
+                | _ -> Html.none
+
+            Html.div [
+                prop.className "form-list"
+
+                prop.children [
+                    yield! fields
+
+                    Bulma.field.div [
+                        field.isGrouped
+                        field.isGroupedRight
+
+                        prop.children [
+                            Bulma.control.div [
+                                removeButton
+                            ]
+                        ]
+                    ]
+                ]
+            ]
+
+    type Field<'Values, 'Field, 'Output, 'Value>(innerField: InnerField<'Values, IField<'Values>>) =
+
+        inherit IGenericField<'Values>()
+
+        interface IField<'Values> with
+
+            member _.MapFieldValues(update: 'Values -> 'NewValues) : IField<'NewValues> =
+                Field
+                    {
+                        Forms =
+                            List.map
+                                (fun (form: Form<'Values, IField<'Values>>) ->
+                                    {
+                                        Fields =
+                                            List.map
+                                                (fun
+                                                    (filledField: Base.FilledField<IField<'Values>>) ->
+                                                    {
+                                                        State =
+                                                            filledField.State.MapFieldValues
+                                                                update
+                                                        Error = filledField.Error
+                                                        IsDisabled = filledField.IsDisabled
+                                                        IsReadOnly = filledField.IsReadOnly
+                                                    }
+                                                )
+                                                form.Fields
+                                        Delete = fun _ -> update (form.Delete())
+                                    }
+                                )
+                                innerField.Forms
+                        Add = fun _ -> update (innerField.Add())
+                        Attributes = innerField.Attributes
+                    }
+
+        override _.RenderField
+            (fieldConfig: Form.View.FieldConfig<'Values, 'Msg>)
+            (filledField: FilledField<'Values>)
+            =
+            View.formList
+                {
+                    Forms =
+                        innerField.Forms
+                        |> List.map (fun
+                                         {
+                                             Fields = fields
+                                             Delete = delete
+                                         } ->
+                            View.formListItem
+                                {
+                                    Fields = List.map (Html.View.renderField fieldConfig) fields
+                                    Delete =
+                                        innerField.Attributes.Delete
+                                        |> Option.map (fun deleteLabel ->
+                                            {|
+                                                Action = delete >> fieldConfig.OnChange
+                                                Label = deleteLabel
+                                            |}
+                                        )
+                                    Disabled = filledField.IsDisabled || fieldConfig.Disabled
+                                }
+                        )
+                    Label = innerField.Attributes.Label
+                    Add =
+                        innerField.Attributes.Add
+                        |> Option.map (fun addLabel ->
+                            {|
+                                Action = innerField.Add >> fieldConfig.OnChange
+                                Label = addLabel
+                            |}
+                        )
+                    Disabled = filledField.IsDisabled || fieldConfig.Disabled
+                }
+
+type FormList =
+
+    static member create(fieldId: string) : FormList.Attributes =
+        {
+            FieldId = fieldId
+            Label = ""
+            Add = None
+            Delete = None
+        }
+
+    static member withLabel (label: string) (attributes: FormList.Attributes) =
+        { attributes with
+            Label = label
+        }
+
+    static member withAdd (add: string) (attributes: FormList.Attributes) =
+        { attributes with
+            Add = Some add
+        }
+
+    static member withDelete (delete: string) (attributes: FormList.Attributes) =
+        { attributes with
+            Delete = Some delete
+        }