@f1studio/form-spec 5.0.0-alpha.101

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Base.fs.js

@@ -0,0 +1,437 @@
+"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 CustomField$2 () {
+        return CustomField$2;
+    },
+    get CustomField$2_$reflection () {
+        return CustomField$2_$reflection;
+    },
+    get FieldConfig$4 () {
+        return FieldConfig$4;
+    },
+    get FieldConfig$4_$reflection () {
+        return FieldConfig$4_$reflection;
+    },
+    get FilledField$1 () {
+        return FilledField$1;
+    },
+    get FilledField$1_$reflection () {
+        return FilledField$1_$reflection;
+    },
+    get FilledForm$2 () {
+        return FilledForm$2;
+    },
+    get FilledForm$2_$reflection () {
+        return FilledForm$2_$reflection;
+    },
+    get Form$3 () {
+        return Form$3;
+    },
+    get Form$3_$reflection () {
+        return Form$3_$reflection;
+    },
+    get andThen () {
+        return andThen;
+    },
+    get append () {
+        return append;
+    },
+    get custom () {
+        return custom;
+    },
+    get disable () {
+        return disable;
+    },
+    get disableIf () {
+        return disableIf;
+    },
+    get field () {
+        return field;
+    },
+    get fill () {
+        return fill;
+    },
+    get map () {
+        return map;
+    },
+    get mapField () {
+        return mapField;
+    },
+    get mapValues () {
+        return mapValues;
+    },
+    get meta () {
+        return meta;
+    },
+    get optional () {
+        return optional;
+    },
+    get readOnly () {
+        return readOnly;
+    },
+    get readOnlyIf () {
+        return readOnlyIf;
+    },
+    get succeed () {
+        return succeed;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Option = require("@fable-org/fable-library-js/Option.js");
+const _Errorfs = require("./Error.fs.js");
+const _Util = require("@fable-org/fable-library-js/Util.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _Extensionsfs = require("./Extensions.fs.js");
+const _Fieldfs = require("./Field.fs.js");
+class FilledField$1 extends _Types.Record {
+    constructor(State, Error$, IsDisabled, IsReadOnly){
+        super();
+        this.State = State;
+        this.Error = Error$;
+        this.IsDisabled = IsDisabled;
+        this.IsReadOnly = IsReadOnly;
+    }
+}
+function FilledField$1_$reflection(gen0) {
+    return (0, _Reflection.record_type)("Fable.Form.Base.FilledField`1", [
+        gen0
+    ], FilledField$1, ()=>[
+            [
+                "State",
+                gen0
+            ],
+            [
+                "Error",
+                (0, _Reflection.option_type)((0, _Errorfs.Error$_$reflection)())
+            ],
+            [
+                "IsDisabled",
+                _Reflection.bool_type
+            ],
+            [
+                "IsReadOnly",
+                _Reflection.bool_type
+            ]
+        ]);
+}
+class FilledForm$2 extends _Types.Record {
+    constructor(Fields, Result, IsEmpty){
+        super();
+        this.Fields = Fields;
+        this.Result = Result;
+        this.IsEmpty = IsEmpty;
+    }
+}
+function FilledForm$2_$reflection(gen0, gen1) {
+    return (0, _Reflection.record_type)("Fable.Form.Base.FilledForm`2", [
+        gen0,
+        gen1
+    ], FilledForm$2, ()=>[
+            [
+                "Fields",
+                (0, _Reflection.list_type)(FilledField$1_$reflection(gen1))
+            ],
+            [
+                "Result",
+                (0, _Reflection.union_type)("Microsoft.FSharp.Core.FSharpResult`2", [
+                    gen0,
+                    (0, _Reflection.tuple_type)((0, _Errorfs.Error$_$reflection)(), (0, _Reflection.list_type)((0, _Errorfs.Error$_$reflection)()))
+                ], _Result.FSharpResult$2, ()=>[
+                        [
+                            [
+                                "ResultValue",
+                                gen0
+                            ]
+                        ],
+                        [
+                            [
+                                "ErrorValue",
+                                (0, _Reflection.tuple_type)((0, _Errorfs.Error$_$reflection)(), (0, _Reflection.list_type)((0, _Errorfs.Error$_$reflection)()))
+                            ]
+                        ]
+                    ])
+            ],
+            [
+                "IsEmpty",
+                _Reflection.bool_type
+            ]
+        ]);
+}
+class Form$3 extends _Types.Union {
+    cases() {
+        return [
+            "Form"
+        ];
+    }
+    constructor(Item){
+        super();
+        this.tag = 0;
+        this.fields = [
+            Item
+        ];
+    }
+}
+function Form$3_$reflection(gen0, gen1, gen2) {
+    return (0, _Reflection.union_type)("Fable.Form.Base.Form`3", [
+        gen0,
+        gen1,
+        gen2
+    ], Form$3, ()=>[
+            [
+                [
+                    "Item",
+                    (0, _Reflection.lambda_type)(gen0, FilledForm$2_$reflection(gen1, gen2))
+                ]
+            ]
+        ]);
+}
+class FieldConfig$4 extends _Types.Record {
+    constructor(Parser, Value, Update, Error$, Attributes){
+        super();
+        this.Parser = Parser;
+        this.Value = Value;
+        this.Update = Update;
+        this.Error = Error$;
+        this.Attributes = Attributes;
+    }
+}
+function FieldConfig$4_$reflection(gen0, gen1, gen2, gen3) {
+    return (0, _Reflection.record_type)("Fable.Form.Base.FieldConfig`4", [
+        gen0,
+        gen1,
+        gen2,
+        gen3
+    ], FieldConfig$4, ()=>[
+            [
+                "Parser",
+                (0, _Reflection.lambda_type)(gen1, (0, _Reflection.union_type)("Microsoft.FSharp.Core.FSharpResult`2", [
+                    gen3,
+                    _Reflection.string_type
+                ], _Result.FSharpResult$2, ()=>[
+                        [
+                            [
+                                "ResultValue",
+                                gen3
+                            ]
+                        ],
+                        [
+                            [
+                                "ErrorValue",
+                                _Reflection.string_type
+                            ]
+                        ]
+                    ]))
+            ],
+            [
+                "Value",
+                (0, _Reflection.lambda_type)(gen2, gen1)
+            ],
+            [
+                "Update",
+                (0, _Reflection.lambda_type)(gen1, (0, _Reflection.lambda_type)(gen2, gen2))
+            ],
+            [
+                "Error",
+                (0, _Reflection.lambda_type)(gen2, (0, _Reflection.option_type)(_Reflection.string_type))
+            ],
+            [
+                "Attributes",
+                gen0
+            ]
+        ]);
+}
+class CustomField$2 extends _Types.Record {
+    constructor(State, Result, IsEmpty){
+        super();
+        this.State = State;
+        this.Result = Result;
+        this.IsEmpty = IsEmpty;
+    }
+}
+function CustomField$2_$reflection(gen0, gen1) {
+    return (0, _Reflection.record_type)("Fable.Form.Base.CustomField`2", [
+        gen0,
+        gen1
+    ], CustomField$2, ()=>[
+            [
+                "State",
+                gen1
+            ],
+            [
+                "Result",
+                (0, _Reflection.union_type)("Microsoft.FSharp.Core.FSharpResult`2", [
+                    gen0,
+                    (0, _Reflection.tuple_type)((0, _Errorfs.Error$_$reflection)(), (0, _Reflection.list_type)((0, _Errorfs.Error$_$reflection)()))
+                ], _Result.FSharpResult$2, ()=>[
+                        [
+                            [
+                                "ResultValue",
+                                gen0
+                            ]
+                        ],
+                        [
+                            [
+                                "ErrorValue",
+                                (0, _Reflection.tuple_type)((0, _Errorfs.Error$_$reflection)(), (0, _Reflection.list_type)((0, _Errorfs.Error$_$reflection)()))
+                            ]
+                        ]
+                    ])
+            ],
+            [
+                "IsEmpty",
+                _Reflection.bool_type
+            ]
+        ]);
+}
+function succeed(output) {
+    return new Form$3((_arg)=>new FilledForm$2((0, _List.empty)(), (0, _Result.FSharpResult$2_Ok)(output), true));
+}
+function fill(_arg, values) {
+    return _arg.fields[0](values);
+}
+function custom(fillField) {
+    return new Form$3((values)=>{
+        let matchValue;
+        const filled = fillField(values);
+        return new FilledForm$2((0, _List.singleton)(new FilledField$1(filled.State, filled.IsEmpty ? (0, _Errorfs.Error$_RequiredFieldIsEmpty)() : (matchValue = filled.Result, matchValue.tag === /* Error */ 1 ? matchValue.fields[0][0] : undefined), false, false)), filled.Result, filled.IsEmpty);
+    });
+}
+function meta(fn) {
+    return new Form$3((values)=>fill(fn(values), values));
+}
+function mapValues(fn, form) {
+    return new Form$3((arg)=>fill(form, fn(arg)));
+}
+function mapField(fn, form) {
+    return new Form$3((values)=>{
+        const filled = fill(form, values);
+        return new FilledForm$2((0, _List.map)((filledField)=>new FilledField$1(fn(filledField.State), filledField.Error, filledField.IsDisabled, filledField.IsReadOnly), filled.Fields), filled.Result, filled.IsEmpty);
+    });
+}
+function append(newForm, currentForm) {
+    return new Form$3((values)=>{
+        const filledNew = fill(newForm, values);
+        const filledCurrent = fill(currentForm, values);
+        const fields = (0, _List.append)(filledCurrent.Fields, filledNew.Fields);
+        const isEmpty = filledCurrent.IsEmpty && filledNew.IsEmpty;
+        const matchValue = filledCurrent.Result;
+        if (matchValue.tag === /* Error */ 1) {
+            const otherErrors = matchValue.fields[0][1];
+            const firstError = matchValue.fields[0][0];
+            const matchValue_1 = filledNew.Result;
+            return matchValue_1.tag === /* Error */ 1 ? new FilledForm$2(fields, (0, _Result.FSharpResult$2_Error)([
+                firstError,
+                (0, _List.append)(otherErrors, (0, _List.cons)(matchValue_1.fields[0][0], matchValue_1.fields[0][1]))
+            ]), isEmpty) : new FilledForm$2(fields, (0, _Result.FSharpResult$2_Error)([
+                firstError,
+                otherErrors
+            ]), isEmpty);
+        } else {
+            return new FilledForm$2(fields, (0, _Result.Result_Map)(matchValue.fields[0], filledNew.Result), isEmpty);
+        }
+    });
+}
+function andThen(child, parent) {
+    return new Form$3((values)=>{
+        const filled = fill(parent, values);
+        const matchValue = filled.Result;
+        if (matchValue.tag === /* Error */ 1) {
+            return new FilledForm$2(filled.Fields, (0, _Result.FSharpResult$2_Error)(matchValue.fields[0]), filled.IsEmpty);
+        } else {
+            const childFilled = fill(child(matchValue.fields[0]), values);
+            return new FilledForm$2((0, _List.append)(filled.Fields, childFilled.Fields), childFilled.Result, filled.IsEmpty && childFilled.IsEmpty);
+        }
+    });
+}
+function disable(form) {
+    return new Form$3((values)=>{
+        const filled = fill(form, values);
+        return new FilledForm$2((0, _List.map)((filledField)=>new FilledField$1(filledField.State, filledField.Error, true, filledField.IsReadOnly), filled.Fields), filled.Result, filled.IsEmpty);
+    });
+}
+function disableIf(condition, form) {
+    if (condition) {
+        return disable(form);
+    } else {
+        return form;
+    }
+}
+function readOnly(form) {
+    return new Form$3((values)=>{
+        const filled = fill(form, values);
+        return new FilledForm$2((0, _List.map)((filledField)=>new FilledField$1(filledField.State, filledField.Error, filledField.IsDisabled, true), filled.Fields), filled.Result, filled.IsEmpty);
+    });
+}
+function readOnlyIf(condition, form) {
+    if (condition) {
+        return readOnly(form);
+    } else {
+        return form;
+    }
+}
+function map(fn, form) {
+    return new Form$3((values)=>{
+        const filled = fill(form, values);
+        return new FilledForm$2(filled.Fields, (0, _Result.Result_Map)(fn, filled.Result), filled.IsEmpty);
+    });
+}
+function field(isEmpty, build, config) {
+    return new Form$3((values_2)=>{
+        let value, values_1;
+        let result_2;
+        const values = values_2;
+        result_2 = (0, _Extensionsfs.Result_andThen)((output)=>(0, _Option.defaultArg)((0, _Option.map)((error_1)=>(0, _Result.FSharpResult$2_Error)([
+                    (0, _Errorfs.Error$_External)(error_1),
+                    (0, _List.empty)()
+                ]), config.Error(values)), (0, _Result.FSharpResult$2_Ok)(output)), (value = config.Value(values), isEmpty(value) ? (0, _Result.FSharpResult$2_Error)([
+            (0, _Errorfs.Error$_RequiredFieldIsEmpty)(),
+            (0, _List.empty)()
+        ]) : (0, _Result.Result_MapError)((error)=>[
+                (0, _Errorfs.Error$_ValidationFailed)(error),
+                (0, _List.empty)()
+            ], config.Parser(value))));
+        let patternInput;
+        if (result_2.tag === /* Error */ 1) {
+            const firstError = result_2.fields[0][0];
+            patternInput = [
+                firstError,
+                (0, _Util.equals)(firstError, (0, _Errorfs.Error$_RequiredFieldIsEmpty)())
+            ];
+        } else {
+            patternInput = [
+                undefined,
+                false
+            ];
+        }
+        return new FilledForm$2((0, _List.singleton)(new FilledField$1((values_1 = values_2, build(new _Fieldfs.Field$3(config.Value(values_1), (newValue)=>config.Update(newValue, values_1), config.Attributes))), patternInput[0], false, false)), result_2, patternInput[1]);
+    });
+}
+function optional(form) {
+    return new Form$3((values)=>{
+        const filled = fill(form, values);
+        const matchValue = filled.Result;
+        if (matchValue.tag === /* Error */ 1) {
+            const otherErrors = matchValue.fields[0][1];
+            const firstError = matchValue.fields[0][0];
+            return filled.IsEmpty ? new FilledForm$2((0, _List.map)((field_1)=>new FilledField$1(field_1.State, undefined, field_1.IsDisabled, field_1.IsReadOnly), filled.Fields), (0, _Result.FSharpResult$2_Ok)(undefined), filled.IsEmpty) : new FilledForm$2(filled.Fields, (0, _Result.FSharpResult$2_Error)([
+                firstError,
+                otherErrors
+            ]), false);
+        } else {
+            return new FilledForm$2(filled.Fields, (0, _Result.FSharpResult$2_Ok)((0, _Option.some)(matchValue.fields[0])), filled.IsEmpty);
+        }
+    });
+} //# sourceMappingURL=Base.fs.ts.map
+
+//# sourceMappingURL=Base.fs.js.map

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Base.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.3.0.0/Base.fs.ts"],"names":["output","_arg1","values","matchValue","filled","fillField","fill","fn","form","filledField","filledNew","newForm","filledCurrent","currentForm","fields","isEmpty","otherErrors","firstError","parent","childFilled","child","condition","disable","readOnly","value","result","error","config","patternInput","build","newValue","field"],"mappings":"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"}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Base.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Base.fs"],"names":["output","_arg1","values","matchValue","filled","fillField","fill","fn","form","filledField","filledNew","newForm","filledCurrent","currentForm","fields","isEmpty","otherErrors","firstError","parent","childFilled","child","condition","disable","readOnly","value","result","error","config","patternInput","build","newValue","field"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwGI,kFACI,iBACa,qGACGA,SACF;;;;;;;WAmBlB,AAJC,AAAAC,eAIIC;;;;;;;WAUL;YAakCC;AAZ1BC,qDAAS,AAAAC,UAAUH;AAEvB,eAAA,iBAEQ,UACI,kBACY,AAAAE,cAEJ,AAAG,AAAAA,mDAIOD,aAAA,AAAAC,eAAA,CAAA,AAAAD,oCAGoB,AAAAA,0BAFhB,aAGL,OACA,SAGhB,AAAAC,eACC,AAAAA;;;;;;;;;;;;WAclB,mFAAmB,AAAAE,4BAAM,AAAAC,GAAGL,SAAQA;;;;;;;;;WAcpC,sEAAW,AAAAI,uBAAAE,MAAND;;;;;;;WASL;AACQH,gDAAS,AAAAE,wBAAKE,MAAKN;AAEvB,eAAA,iBAGW,gGACC,kBACY,AAAAK,GAAG,AAAAE,oBACH,AAAAA,mBACK,AAAAA,wBACA,AAAAA,0BANrB,AAAAL,gBASK,AAAAA,eACC,AAAAA;;;;;;;;WAelB;AACQM,kDAAY,AAAAJ,uBAAKK,SAAQT;AAEzBU,qEAAgB,AAAAN,sCAAKO,aAAYX;AAEjCY,yDAAS,SAAA,AAAAF,sBAAuB,AAAAF;AAEhCK,iCAAU,AAAAH,yBAAyB,AAAAF;AAEjCP,gHAAA,AAAAS;AAAA,YAAA,AAAAT;AAQca,2DACV,AAAAb;AADFc,8CACE,AAAAd;AAAAA,uGAAA,AAAAO;AAAA,mBAAA,CAAA,AAAAP,uCASF,iBACaW,6EACMG,YAAY,SAAAD,aAAe,KAF9C,AAAAb,2BAAA,AAAAA,6EAGcY,aAVd,iBACaD,6EACMG,YAAYD,6DACjBD;;;AAZlB,mBAAA,iBACaD,QACA,6DAFb,AAAAX,sBAE2B,AAAAO,mBACbK;;;;;;;;;;;WAkCtB;AACQX,\u002BCAAS,AAAAE,uBAAKY,QAAOhB;AAEnBC,iGAAA,AAAAC;AAAA,YAAA,AAAAD;AAWF,mBAAA,iBACa,AAAAC,mFADb,AAAAD,uBAGc,AAAAC;;;AAZVe,wDAAc,AAAAb,uBAAM,AAAAc,MAApB,AAAAjB,uBAAkCD;AAEtC,mBAAA,iBACa,SAAA,AAAAE,eAAgB,AAAAe,qBAChB,AAAAA,oBACC,AAAAf,kBAAkB,AAAAe;;;;;;;;;;;WAmBxC;AACQf,oDAAS,AAAAE,4BAAKE,MAAKN;AAEvB,eAAA,iBAGW,gHACC,kBAAA,AAAAO,mBAAA,AAAAA,mBACiB,MADjB,AAAAA,0BAFJ,AAAAL,gBAMK,AAAAA,eACC,AAAAA;;;;;;;;;;AAiBlB,QAAGiB;AACC,eAAA,AAAAC,\u002BBAAQd;;;eAERA;;;;;;;;;;WAUJ;AACQJ,oDAAS,AAAAE,4BAAKE,MAAKN;AAEvB,eAAA,iBAGW,gHACC,kBAAA,AAAAO,mBAAA,AAAAA,mBAAA,AAAAA,wBACiB,QAHrB,AAAAL,gBAMK,AAAAA,eACC,AAAAA;;;;;;;;;;AAiBlB,QAAGiB;AACC,eAAA,AAAAE,gCAASf;;;eAETA;;;;;;;;;;;;;;WAaJ;AACQJ,\u002BCAAS,AAAAE,uBAAKE,MAAKN;AAEvB,eAAA,iBACa,AAAAE,eACA,6DAAWG,IAAG,AAAAH,gBACb,AAAAA;;;;;;;;;;;;WAiDlB;YA3BmBoB,cAeRtB;AAaHuB;AArBEvB,\u002BBAqBaA;AAnBhB,AAmBCuB,mBAnBD,0KAGI,WADA,mRAA8CC,UAAO,wEADxD,AAAAC,aAAazB,gFAEcF,WAZhBwB,QAQC,AAAAG,aAAazB,SAP7B,AAAG,AAAAa,QAAQS,kHAC2B,yEAG/B,qKAAsDE,QAAO,wEADhE,AAAAC,cAAcH;AA0BdI;AACM,YAAA,AAAAH;AAGER,8CAAkB,AAAAQ;AAJ1BG,6BAI\u002BBX,YAAY,OAAAA;;;AAJ3CW,6BAEW,WAAM;;AAIrB,eAAA,iBAEQ,UACI,mBAxBL1B,WAyBwBA,UApB/B,AAAA2B,MACI,YALQ,AAAAF,aAAazB,wCAEH,AAAAyB,cAAcG,UAAS5B,WAMxB,AAAAyB,sBAMjB,AAAAC,iBAYyB,OACA,SAGhBH,UAhBT,AAAAG;;;;;;;;;;;;WAgCR;AACQxB,oDAAS,AAAAE,4BAAKE,MAAKN;AAEjBC,sGAAA,AAAAC;AAAA,YAAA,AAAAD;AAQca,2DAChB,AAAAb;AADIc,8CACJ,AAAAd;AAAA,mBAAA,AAAG,AAAAC,kBACC,iBAGW,4GACC,kBAAA,AAAA2B,eACY,WADZ,AAAAA,oBAAA,AAAAA,sBAFJ,AAAA3B,8FAMQ,YACF,AAAAA,oBAGd,iBACa,AAAAA,iGACMa,YAAYD,6DACjB;;;AAvBlB,mBAAA,iBACa,AAAAZ,6FACG,KAFhB,AAAAD,wBAGc,AAAAC","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Error.fs

@@ -0,0 +1,16 @@
+module Fable.Form.Error
+
+type Error =
+    /// <summary>
+    /// Used to represents an empty field
+    /// </summary>
+    | RequiredFieldIsEmpty
+    /// <summary>
+    /// Used to represents an error due a validation failed like when parsing a field value.
+    /// </summary>
+    | ValidationFailed of string
+    /// <summary>
+    /// Used to represents an external error
+    /// <para>For example, it is used when doing server side validation</para>
+    /// </summary>
+    | External of string

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Error.fs.js

@@ -0,0 +1,73 @@
+"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 Error$ () {
+        return Error$;
+    },
+    get Error$_$reflection () {
+        return Error$_$reflection;
+    },
+    get Error$_External () {
+        return Error$_External;
+    },
+    get Error$_RequiredFieldIsEmpty () {
+        return Error$_RequiredFieldIsEmpty;
+    },
+    get Error$_ValidationFailed () {
+        return Error$_ValidationFailed;
+    }
+});
+const _Types = require("@fable-org/fable-library-js/Types.js");
+const _Reflection = require("@fable-org/fable-library-js/Reflection.js");
+function Error$_RequiredFieldIsEmpty() {
+    return new Error$(0, []);
+}
+function Error$_ValidationFailed(Item) {
+    return new Error$(1, [
+        Item
+    ]);
+}
+function Error$_External(Item) {
+    return new Error$(2, [
+        Item
+    ]);
+}
+class Error$ extends _Types.Union {
+    cases() {
+        return [
+            "RequiredFieldIsEmpty",
+            "ValidationFailed",
+            "External"
+        ];
+    }
+    constructor(tag, fields){
+        super(), this.tag = tag, this.fields = fields;
+    }
+}
+function Error$_$reflection() {
+    return (0, _Reflection.union_type)("Fable.Form.Error.Error", [], Error$, ()=>[
+            [],
+            [
+                [
+                    "Item",
+                    _Reflection.string_type
+                ]
+            ],
+            [
+                [
+                    "Item",
+                    _Reflection.string_type
+                ]
+            ]
+        ]);
+} //# sourceMappingURL=Error.fs.ts.map
+
+//# sourceMappingURL=Error.fs.js.map

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Error.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.3.0.0/Error.fs.ts"],"names":[],"mappings":""}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Error.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":null,"sourcesContent":null,"sourceRoot":null}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Extensions.fs

@@ -0,0 +1,50 @@
+namespace Fable.Form.Extensions
+
+module Result =
+
+    let andThen
+        (callback: 'ValueA -> Result<'ValueB, 'Error>)
+        (result: Result<'ValueA, 'Error>)
+        : Result<'ValueB, 'Error>
+        =
+
+        match result with
+        | Ok value -> callback value
+
+        | Error error -> Error error
+
+module List =
+
+    // Copied from https://github.com/fsprojects/FSharpPlus/blob/35fa2a97e0c3f93c7cf36c172314e7f2d921d438/src/FSharpPlus/Extensions/List.fs
+
+    /// <summary>Returns a list that drops N elements of the original list and then yields the
+    /// remaining elements of the list.</summary>
+    /// <remarks>When count exceeds the number of elements in the list it
+    /// returns an empty list instead of throwing an exception.</remarks>
+    /// <param name="count">The number of items to drop.</param>
+    /// <param name="source">The input list.</param>
+    ///
+    /// <returns>The result list.</returns>
+    let drop count source =
+        let rec loop i lst =
+            match lst, i with
+            | [] as x, _
+            | x, 0 -> x
+            | x, n -> loop (n - 1) (List.tail x)
+
+        if count > 0 then
+            loop count source
+        else
+            source
+
+    /// <summary>Updates the value of an item in a list</summary>
+    /// <param name="i">The index of the item to update</param>
+    /// <param name="x">The new value of the item</param>
+    /// <param name="lst">The input list</param>
+    ///
+    /// <returns>A new list with the updated element</returns>
+    let setAt i x lst =
+        if List.length lst > i && i >= 0 then
+            lst.[0 .. i - 1] @ x :: lst.[i + 1 ..]
+        else
+            lst

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Extensions.fs.js

@@ -0,0 +1,72 @@
+"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 List_drop () {
+        return List_drop;
+    },
+    get List_setAt () {
+        return List_setAt;
+    },
+    get Result_andThen () {
+        return Result_andThen;
+    }
+});
+const _Result = require("@fable-org/fable-library-js/Result.js");
+const _List = require("@fable-org/fable-library-js/List.js");
+function Result_andThen(callback, result) {
+    if (result.tag === /* Error */ 1) {
+        return (0, _Result.FSharpResult$2_Error)(result.fields[0]);
+    } else {
+        return callback(result.fields[0]);
+    }
+}
+function List_drop(count, source) {
+    const loop = (i_mut, lst_mut)=>{
+        loop: while(true){
+            const i = i_mut, lst = lst_mut;
+            let matchResult, x;
+            if ((0, _List.isEmpty)(lst)) {
+                matchResult = 0;
+                x = lst;
+            } else if (i === 0) {
+                matchResult = 0;
+                x = lst;
+            } else {
+                matchResult = 1;
+            }
+            switch(matchResult){
+                case 0:
+                    return x;
+                default:
+                    {
+                        i_mut = i - 1;
+                        lst_mut = (0, _List.tail)(lst);
+                        continue loop;
+                    }
+            }
+            break;
+        }
+    };
+    if (count > 0) {
+        return loop(count, source);
+    } else {
+        return source;
+    }
+}
+function List_setAt(i, x, lst) {
+    if ((0, _List.length)(lst) > i && i >= 0) {
+        return (0, _List.append)((0, _List.getSlice)(0, i - 1, lst), (0, _List.cons)(x, (0, _List.getSlice)(i + 1, undefined, lst)));
+    } else {
+        return lst;
+    }
+} //# sourceMappingURL=Extensions.fs.ts.map
+
+//# sourceMappingURL=Extensions.fs.js.map

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Extensions.fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.3.0.0/Extensions.fs.ts"],"names":["result","callback","loop","i","lst","x","count","source"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;IAUc,IAAAA,OAAAA,GAAAA,KAAAA,SAAAA,GAAAA,GAAAA;iDAGWA,OAAAA,MAAAA,CAAAA,EAAAA;;QAFH,OAAAC,SAAAD,OAAAA,MAAAA,CAAAA,EAAAA;;;;IAiBNE,MAAAA,OAAAA,CAAAA,OAAAA;;kBAAKC,IAAAA,OAAEC,MAAAA;6BAEHC;YADF,QAAA,aAAA,EAAAD,MAAAA;;gBACEC,IADFD;mBAAA,IAAKD,MAAL,GAAA;;gBACEE,IADFD;;;;;;2BAEIC;;;gCAFCF,IAGS;sCAAI,UAAA,EAHlBC;wBAGI,SAAA;;;;;;IAEd,IAAGE,QAAQ,GAAA;QACP,OAAAJ,KAAKI,OAAMC;;eAEXA;;;;IASJ,IAAG,gBAAA,EAAYH,OAAMD,KAAKA,KAAK,GAAA;QAC3B,WAAA,YAAA,MAAA,cAAA,EAAK,GAAKA,IAAI,GAAdC,UAAmB,UAAA,EAAAC,OAAK,cAAA,EAAKF,IAAI,GAAJ,WAALC;;eAExBA"}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Extensions.fs.ts.map

@@ -0,0 +1 @@
+{"version":3,"sources":["./Extensions.fs"],"names":["result","callback","loop","i","lst","x","count","source"],"mappings":";;;;;AAUc,QAAA,AAAAA;mDAGW,AAAAA;;;AAFH,eAAA,AAAAC,SAAA,AAAAD;;;;;;;;;AAiBNE;;;kBAAKC,kBAAEC;oCAEHC;AADF,gBAAA,QAAAD;;AACEC,oBADFD;;iBAAA,IAAA,AAAKD,MAAL;;AACEE,oBADFD;;;;;;;2BAEIC;;6BACM,AAHLF,IAGS;8BAAI,SAHlBC;AAGI;;;;;;AAEd,QAAG,AAAAE,QAAQ;AACP,eAAA,AAAAJ,KAAKI,OAAMC;;;eAEXA;;;;;;;;AASJ,QAAG,CAAA,WAAYH,OAAMD,OAAK,AAAAA,KAAK;AAC3B,eAAA,OAAA,SAAK,GAAK,AAAAA,IAAI,GAAdC,MAAmB,KAAAC,GAAK,SAAK,AAAAF,IAAI,GAAJ,WAALC;;;eAExBA","file":null,"sourcesContent":null,"sourceRoot":null}