@f1studio/form-spec 5.0.0-alpha.149 → 5.0.0-alpha.151

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

@@ -1,511 +0,0 @@
-module Fable.Form.Base
-
-open Fable.Form.Extensions
-
-/// <summary>
-/// Represents a filled field
-/// </summary>
-type FilledField<'Field> =
-    {
-        State: 'Field
-        Error: Error.Error option
-        IsDisabled: bool
-        IsReadOnly: bool
-    }
-
-/// <summary>
-/// Represents a filled form
-///
-/// You can obtain this by using <see cref="fill"/>
-/// </summary>
-type FilledForm<'Output, 'Field> =
-    {
-        Fields: FilledField<'Field> list
-        Result: Result<'Output, (Error.Error * Error.Error list)>
-        IsEmpty: bool
-    }
-
-/// <summary>
-/// A <see cref="T:Form"/> which can contain any type of 'field'
-/// </summary>
-[<NoComparison; NoEquality>]
-type Form<'Values, 'Output, 'Field> = Form of ('Values -> FilledForm<'Output, 'Field>)
-
-/// <summary>
-/// <see cref="T:FieldConfig"/> is a contract allowing you to describe how a field will behave
-/// </summary>
-[<NoComparison; NoEquality>]
-type FieldConfig<'Attributes, 'Input, 'Values, 'Output> =
-    {
-        /// <summary>
-        /// Function that valides the <c>'Input</c> value and produce an <c>Ok 'Ouput</c> on success or an <c>Error</c> describing the problem
-        /// </summary>
-        Parser: 'Input -> Result<'Output, string>
-        /// <summary>
-        /// Function which defined how to access the <c>'Input</c> from <c>'Value</c> type
-        /// </summary>
-        Value: 'Values -> 'Input
-        /// <summary>
-        /// Function which defined how the current form <c>'Values</c> should be update with the new <c>'Input</c>
-        /// </summary>
-        Update: 'Input -> 'Values -> 'Values
-        /// <summary>
-        /// Define how to obtain a potential external error. Useful when dealing with Server-side validation for example
-        /// </summary>
-        Error: 'Values -> string option
-        /// <summary>
-        /// Type used to represents data specific to the field. For example, you can use it to ask the user to provide a label and placeholder.
-        /// </summary>
-        Attributes: 'Attributes
-    }
-
-/// <summary>
-/// Represents a custom field on a form that has been filled with some values.
-/// </summary>
-type CustomField<'Output, 'Field> =
-    {
-        /// <summary>
-        /// The field
-        /// </summary>
-        State: 'Field
-        /// <summary>
-        /// The result of the field
-        /// </summary>
-        Result: Result<'Output, (Error.Error * Error.Error list)>
-        /// <summary>
-        /// Whether the field is empty or not.
-        ///
-        /// <para>
-        /// <c>True</c>, if it is empty
-        /// </para>
-        ///
-        /// <para>
-        /// <c/>False<c/>, otherwise
-        /// </para>
-        /// </summary>
-        IsEmpty: bool
-    }
-
-/// <summary>
-/// Create a form that always succeeds when filled.
-///
-/// Note: You can choose to discard one of the function argument. The classic example for that is when dealing with a <c>repeatPasswordField</c>
-///
-/// <para>
-/// <code lang="fsharp">
-/// Form.succeed (fun password _ -> password )
-///     |> Form.append passwordField
-///     |> Form.append repeatPasswordField
-/// </code>
-/// </para>
-/// </summary>
-/// <param name="output">The value to return when the form is filled</param>
-/// <returns>The given <c>Output</c></returns>
-let succeed (output: 'Output) : Form<'Values, 'Output, 'Field> =
-    Form(fun _ ->
-        {
-            Fields = []
-            Result = Ok output
-            IsEmpty = true
-        }
-    )
-
-/// <summary>
-/// Fill a form with some <c>'Values</c>
-/// </summary>
-/// <returns>
-/// - A list of the fields of the form, with their errors
-/// - The result of the filled form which can be:
-///     - The correct <c>'Output</c>
-///     - A non-empty list of validation errors
-/// - Whether the form is empty or not
-/// </returns>
-let fill<'Values, 'Output, 'Field>
-    (Form form: Form<'Values, 'Output, 'Field>)
-    (values: 'Values)
-    : FilledForm<'Output, 'Field>
-    =
-    form values
-
-/// <summary>
-/// Create a custom field
-/// </summary>
-/// <param name="fillField">A function given some <c>'Values</c> that produce a <see cref="T:FilledField"/></param>
-/// <returns>
-/// A form build by applying <c>fillField</c> to a provided <c>'Values</c>
-/// </returns>
-let custom (fillField: 'Values -> CustomField<'Output, 'Field>) : Form<'Values, 'Output, 'Field> =
-    Form(fun values ->
-        let filled = fillField values
-
-        {
-            Fields =
-                [
-                    {
-                        State = filled.State
-                        Error =
-                            if filled.IsEmpty then
-                                Some Error.RequiredFieldIsEmpty
-
-                            else
-                                match filled.Result with
-                                | Ok _ -> None
-
-                                | Error(firstError, _) -> Some firstError
-                        IsDisabled = false
-                        IsReadOnly = false
-                    }
-                ]
-            Result = filled.Result
-            IsEmpty = filled.IsEmpty
-        }
-    )
-
-/// <summary>
-/// Build a form that depends on its own <c>'Values</c>
-///
-/// This is useful when a field need to checks it's value against another field value.
-///
-/// The classic example for using <c>meta</c> is when dealing with a repeat password field.
-/// </summary>
-/// <param name="fn">Function to apply to transform the form values</param>
-/// <returns>A new form resulting of the application of <c>fn</c> when filling it</returns>
-let meta (fn: 'Values -> Form<'Values, 'Output, 'Field>) : Form<'Values, 'Output, 'Field> =
-    Form(fun values -> fill (fn values) values)
-
-/// <summary>
-/// Transform the values of a form.
-///
-/// This function is useful when you want to re-use existing form or nest them.
-/// </summary>
-/// <param name="fn">Function to apply transform the data</param>
-/// <param name="form">The form to which we want to pass the result of the transformation</param>
-/// <returns>
-/// A new form resulting of <c>fn >> fill form</c>
-/// </returns>
-let mapValues (fn: 'A -> 'B) (form: Form<'B, 'Output, 'Field>) : Form<'A, 'Output, 'Field> =
-
-    Form(fn >> fill form)
-
-/// <summary>
-///  Apply the given function to all the field
-/// </summary>
-/// <param name="fn">Function to apply</param>
-/// <param name="form">Form containing the list of fields to which we want to apply the function</param>
-/// <returns>A new form, when <c>fn</c> has been apply to all the field of <c>form</c></returns>
-let mapField (fn: 'A -> 'B) (form: Form<'Values, 'Output, 'A>) : Form<'Values, 'Output, 'B> =
-    Form(fun values ->
-        let filled = fill form values
-
-        {
-            Fields =
-                filled.Fields
-                |> List.map (fun filledField ->
-                    {
-                        State = fn filledField.State
-                        Error = filledField.Error
-                        IsDisabled = filledField.IsDisabled
-                        IsReadOnly = filledField.IsReadOnly
-                    }
-                )
-            Result = filled.Result
-            IsEmpty = filled.IsEmpty
-        }
-    )
-
-/// <summary>
-/// Append a form to another one while <b>capturing</b> the output of the first one
-/// </summary>
-/// <param name="newForm">Form to append</param>
-/// <param name="currentForm">Form to append to</param>
-/// <returns>A new form resulting in the combination of <c>newForm</c> and <c>currentForm</c></returns>
-let append
-    (newForm: Form<'Values, 'A, 'Field>)
-    (currentForm: Form<'Values, 'A -> 'B, 'Field>)
-    : Form<'Values, 'B, 'Field>
-    =
-    Form(fun values ->
-        let filledNew = fill newForm values
-
-        let filledCurrent = fill currentForm values
-
-        let fields = filledCurrent.Fields @ filledNew.Fields
-
-        let isEmpty = filledCurrent.IsEmpty && filledNew.IsEmpty
-
-        match filledCurrent.Result with
-        | Ok fn ->
-            {
-                Fields = fields
-                Result = Result.map fn filledNew.Result
-                IsEmpty = isEmpty
-            }
-
-        | Error(firstError, otherErrors) ->
-            match filledNew.Result with
-            | Ok _ ->
-                {
-                    Fields = fields
-                    Result = Error(firstError, otherErrors)
-                    IsEmpty = isEmpty
-                }
-
-            | Error(newFirstError, newOtherErrors) ->
-                {
-                    Fields = fields
-                    Result = Error(firstError, otherErrors @ (newFirstError :: newOtherErrors))
-                    IsEmpty = isEmpty
-                }
-    )
-
-/// <summary>
-/// Fill a form <c>andThen</c> fill another one.
-///
-/// This type of form is useful when some part of your form can dynamically change based on the value of another field.
-/// </summary>
-/// <param name="child">The child form</param>
-/// <param name="parent">The parent form which is filled first</param>
-/// <returns>A new form which is the result of filling the <c>parent</c> and then filling the <c>child</c> form</returns>
-let andThen
-    (child: 'A -> Form<'Values, 'B, 'Field>)
-    (parent: Form<'Values, 'A, 'Field>)
-    : Form<'Values, 'B, 'Field>
-    =
-
-    Form(fun values ->
-        let filled = fill parent values
-
-        match filled.Result with
-        | Ok output ->
-            let childFilled = fill (child output) values
-
-            {
-                Fields = filled.Fields @ childFilled.Fields
-                Result = childFilled.Result
-                IsEmpty = filled.IsEmpty && childFilled.IsEmpty
-            }
-
-        | Error errors ->
-            {
-                Fields = filled.Fields
-                Result = Error errors
-                IsEmpty = filled.IsEmpty
-            }
-    )
-
-/// <summary>
-/// Disable a form
-///
-/// You can combine this with meta to disable parts of a form based on its own values.
-/// </summary>
-/// <param name="form">The form to disable</param>
-/// <returns>A new form which has been marked as disabled</returns>
-let disable (form: Form<'Values, 'Output, 'Field>) : Form<'Values, 'Output, 'Field> =
-    Form(fun values ->
-        let filled = fill form values
-
-        {
-            Fields =
-                filled.Fields
-                |> List.map (fun filledField ->
-                    { filledField with
-                        IsDisabled = true
-                    }
-                )
-            Result = filled.Result
-            IsEmpty = filled.IsEmpty
-        }
-    )
-
-/// <summary>
-/// Disable a form based on a condition
-///
-/// You can combine this with meta to disable parts of a form based on its own values.
-/// </summary>
-/// <param name="condition">The condition to check</param>
-/// <param name="form">The form to disable</param>
-/// <returns>A new form which has been marked as disabled if the condition is <c>true</c></returns>
-let disableIf
-    (condition: bool)
-    (form: Form<'Values, 'Output, 'Field>)
-    : Form<'Values, 'Output, 'Field>
-    =
-    if condition then
-        disable form
-    else
-        form
-
-/// <summary>
-/// Make a form read-only
-///
-/// You can combine this with meta to make parts of a form read-only based on its own values.
-/// </summary>
-/// <param name="form">The form to make read-only</param>
-/// <returns>A new form which has been marked as read-only</returns>
-let readOnly (form: Form<'Values, 'Output, 'Field>) : Form<'Values, 'Output, 'Field> =
-    Form(fun values ->
-        let filled = fill form values
-
-        {
-            Fields =
-                filled.Fields
-                |> List.map (fun filledField ->
-                    { filledField with
-                        IsReadOnly = true
-                    }
-                )
-            Result = filled.Result
-            IsEmpty = filled.IsEmpty
-        }
-    )
-
-/// <summary>
-/// Make a form read-only based on a condition
-///
-/// You can combine this with meta to make parts of a form read-only based on its own values.
-/// </summary>
-/// <param name="condition">The condition to check</param>
-/// <param name="form">The form to make read-only</param>
-/// <returns>A new form which has been marked as read-only if the condition is <c>true</c></returns>
-let readOnlyIf
-    (condition: bool)
-    (form: Form<'Values, 'Output, 'Field>)
-    : Form<'Values, 'Output, 'Field>
-    =
-    if condition then
-        readOnly form
-    else
-        form
-
-/// <summary>
-/// Transform the 'output' of a form
-///
-/// You can use it to keep your forms decoupled from your specific view messages:
-///
-/// <code lang="fsharp">
-/// Base.map SignUp signupForm
-/// </code>
-/// </summary>
-let map (fn: 'A -> 'B) (form: Form<'Values, 'A, 'Field>) : Form<'Values, 'B, 'Field> =
-
-    Form(fun values ->
-        let filled = fill form values
-
-        {
-            Fields = filled.Fields
-            Result = Result.map fn filled.Result
-            IsEmpty = filled.IsEmpty
-        }
-    )
-
-/// <summary>
-/// Create function which is used to created a single form field
-///
-/// This functions is meant to be used when you want to design your own View layer.
-///
-/// See how it is use for Fable.Form.Simple <a href="https://github.com/MangelMaxime/Fable.Form/blob/91c70b9504706fd3d65fd0bbcad97d865b18284a/packages/Fable.Form.Simple/TextField.fs#L15-L17">TextField</a>
-/// </summary>
-/// <param name="isEmpty">Function used to detect if the field is empty</param>
-/// <param name="build">Field builder configuration</param>
-/// <param name="config">Field configuration</param>
-/// <returns>A form containing a single field</returns>
-let field
-    (isEmpty: 'Input -> bool)
-    (build: Field.Field<'Attributes, 'Input, 'Values> -> 'Field)
-    (config: FieldConfig<'Attributes, 'Input, 'Values, 'Output>)
-    : Form<'Values, 'Output, 'Field>
-    =
-
-    let requiredParser value =
-        if isEmpty value then
-            Error(Error.RequiredFieldIsEmpty, [])
-        else
-            config.Parser value
-            |> Result.mapError (fun error -> (Error.ValidationFailed error, []))
-
-    let parse values =
-        requiredParser (config.Value values)
-        |> Result.andThen (fun output ->
-            config.Error values
-            |> Option.map (fun error -> Error(Error.External error, []))
-            |> Option.defaultValue (Ok output)
-        )
-
-    let field_ values =
-        let value = config.Value values
-
-        let update newValue = config.Update newValue values
-
-        build
-            {
-                Value = value
-                Update = update
-                Attributes = config.Attributes
-            }
-
-    Form(fun values ->
-        let result = parse values
-
-        let (error, isEmpty_) =
-            match result with
-            | Ok _ -> (None, false)
-
-            | Error(firstError, _) -> Some firstError, firstError = Error.RequiredFieldIsEmpty
-
-        {
-            Fields =
-                [
-                    {
-                        State = field_ values
-                        Error = error
-                        IsDisabled = false
-                        IsReadOnly = false
-                    }
-                ]
-            Result = result
-            IsEmpty = isEmpty_
-        }
-    )
-
-/// <summary>
-/// Make a form optional.
-///
-/// An optional form succeeds when:
-/// - All of its fields are empty, in this case it returns <c>None</c>
-/// - All of its fields are correct, in this case it returns <c>Some 'Output</c>
-/// </summary>
-/// <param name="form">The form to make optional</param>
-/// <returns>A form producing an optional 'Output</returns>
-let optional (form: Form<'Values, 'Output, 'Field>) : Form<'Values, 'Output option, 'Field> =
-
-    Form(fun values ->
-        let filled = fill form values
-
-        match filled.Result with
-        | Ok value ->
-            {
-                Fields = filled.Fields
-                Result = Ok(Some value)
-                IsEmpty = filled.IsEmpty
-            }
-
-        | Error(firstError, otherErrors) ->
-            if filled.IsEmpty then
-                {
-                    Fields =
-                        filled.Fields
-                        |> List.map (fun field ->
-                            { field with
-                                Error = None
-                            }
-                        )
-                    Result = Ok None
-                    IsEmpty = filled.IsEmpty
-                }
-            else
-                {
-                    Fields = filled.Fields
-                    Result = Error(firstError, otherErrors)
-                    IsEmpty = false
-                }
-    )

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

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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":"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","file":null,"sourcesContent":null,"sourceRoot":null}

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

@@ -1,16 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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

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

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

@@ -1,50 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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

@@ -1 +0,0 @@
-{"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}

package/FormSpec.TS/fable_modules/Fable.Form.3.0.0/Fable.Form.fableproj

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Microsoft.NET.Sdk">
-    <PropertyGroup>
-        <TargetFramework>netstandard2.1</TargetFramework>
-        <Description>
-            Extensible core library used to build forms
-        </Description>
-        <FablePackageType>library</FablePackageType>
-        <PackageTags>fable-javascript</PackageTags>
-    </PropertyGroup>
-    <ItemGroup>
-        <Compile Include="Extensions.fs" />
-        <Compile Include="Error.fs" />
-        <Compile Include="Field.fs" />
-        <Compile Include="Base.fs" />
-    </ItemGroup>
-    <ItemGroup>
-      <PackageReference Include="EasyBuild.PackageReleaseNotes.Tasks">
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        <PrivateAssets>all</PrivateAssets>
-      </PackageReference>
-      <PackageReference Include="Fable.Package.SDK">
-        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        <PrivateAssets>all</PrivateAssets>
-      </PackageReference>
-      <PackageReference Include="FSharp.Core" />
-    </ItemGroup>
-</Project>

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

@@ -1,24 +0,0 @@
-module Fable.Form.Field
-
-type IAttributes =
-    abstract GetFieldId: unit -> string
-
-[<NoComparison; NoEquality>]
-type Field<'Attributes, 'Value, 'Values when 'Attributes :> IAttributes> =
-    {
-        Value: 'Value
-        Update: 'Value -> 'Values
-        Attributes: 'Attributes
-    }
-
-let mapValues
-    (fn: 'A -> 'B)
-    (field: Field<'Attributes, 'Value, 'A>)
-    : Field<'Attributes, 'Value, 'B>
-    =
-
-    {
-        Value = field.Value
-        Update = field.Update >> fn
-        Attributes = field.Attributes
-    }

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../FormSpec.TS/fable_modules/Fable.Form.3.0.0/Field.fs.ts"],"names":["field","fn"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAmBI,IAAA,QACYA,MAAAA,KAAAA,EAAAA,CAAAA,MACiBC,GAAhBD,MAAAA,MAAAA,CAAAA,OACIA,MAAAA,UAAAA"}