elm-pages 3.0.0-beta.32 → 3.0.0-beta.34

package/src/FormDecoder.elm

@@ -1,102 +0,0 @@
-module FormDecoder exposing (encodeFormData, formDataOnSubmit, methodToString)
-
-import Form.FormData as FormData exposing (FormData)
-import Html
-import Html.Events
-import Json.Decode as Decode
-import Json.Encode
-import Url
-
-
-formDataOnSubmit : Html.Attribute FormData
-formDataOnSubmit =
-    Html.Events.preventDefaultOn "submit"
-        (Decode.map4 FormData
-            (Decode.value
-                |> Decode.andThen
-                    (\decodeValue ->
-                        case Decode.decodeValue tuplesDecoder (decoder decodeValue) of
-                            Ok decoded ->
-                                Decode.succeed decoded
-
-                            Err error ->
-                                Decode.succeed
-                                    [ ( "error"
-                                      , Decode.errorToString error
-                                      )
-                                    ]
-                    )
-            )
-            (currentForm "method" methodDecoder)
-            (currentForm "action" Decode.string)
-            (currentForm "id" (Decode.nullable Decode.string))
-            |> Decode.map alwaysPreventDefault
-        )
-
-
-currentForm : String -> Decode.Decoder a -> Decode.Decoder a
-currentForm field decoder_ =
-    Decode.oneOf
-        [ Decode.at [ "submitter", "form" ] decoder_
-        , Decode.at [ "currentTarget", field ] decoder_
-        ]
-
-
-methodDecoder : Decode.Decoder FormData.Method
-methodDecoder =
-    Decode.string
-        |> Decode.map
-            (\methodString ->
-                case methodString |> String.toUpper of
-                    "GET" ->
-                        FormData.Get
-
-                    "POST" ->
-                        FormData.Post
-
-                    _ ->
-                        -- TODO what about "dialog" method? Is it okay for that to be interpreted as GET,
-                        -- or should there be a variant for that?
-                        FormData.Get
-            )
-
-
-decoder : Decode.Value -> Decode.Value
-decoder event =
-    Json.Encode.string "REPLACE_ME_WITH_FORM_TO_STRING"
-
-
-alwaysPreventDefault : msg -> ( msg, Bool )
-alwaysPreventDefault msg =
-    ( msg, True )
-
-
-tuplesDecoder : Decode.Decoder (List ( String, String ))
-tuplesDecoder =
-    Decode.list
-        (Decode.map2 Tuple.pair
-            (Decode.index 0 Decode.string)
-            (Decode.index 1 Decode.string)
-        )
-
-
-methodToString : FormData.Method -> String
-methodToString method =
-    case method of
-        FormData.Get ->
-            "GET"
-
-        FormData.Post ->
-            "POST"
-
-
-encodeFormData :
-    FormData
-    -> String
-encodeFormData data =
-    data.fields
-        |> List.map
-            (\( name, value ) ->
-                Url.percentEncode name ++ "=" ++ Url.percentEncode value
-            )
-        |> String.join "&"

package/src/Pages/FormState.elm

@@ -1,257 +0,0 @@
-module Pages.FormState exposing (Event(..), FieldEvent, FieldState, FormState, PageFormState, init, listeners, setField, setSubmitAttempted, update)
-
-{-|
-
-@docs Event, FieldEvent, FieldState, FormState, PageFormState, init, listeners, setField, setSubmitAttempted, update
-
--}
-
-import Dict exposing (Dict)
-import Form.FieldStatus as FieldStatus exposing (FieldStatus)
-import Html exposing (Attribute)
-import Html.Attributes as Attr
-import Html.Events
-import Json.Decode as Decode exposing (Decoder)
-import Pages.Internal.Msg
-import PagesMsg exposing (PagesMsg)
-
-
-{-| -}
-listeners : String -> List (Attribute (PagesMsg userMsg))
-listeners formId =
-    [ Html.Events.on "focusin" (Decode.value |> Decode.map Pages.Internal.Msg.FormFieldEvent)
-    , Html.Events.on "focusout" (Decode.value |> Decode.map Pages.Internal.Msg.FormFieldEvent)
-    , Html.Events.on "input" (Decode.value |> Decode.map Pages.Internal.Msg.FormFieldEvent)
-    , Attr.id formId
-    ]
-
-
-{-| -}
-type Event
-    = InputEvent String
-    | FocusEvent
-      --| ChangeEvent
-    | BlurEvent
-
-
-{-| -}
-type alias FieldEvent =
-    { value : String
-    , formId : String
-    , name : String
-    , event : Event
-    }
-
-
-{-| -}
-fieldEventDecoder : Decoder FieldEvent
-fieldEventDecoder =
-    Decode.map4 FieldEvent
-        inputValueDecoder
-        (Decode.at [ "currentTarget", "id" ] Decode.string)
-        (Decode.at [ "target", "name" ] Decode.string)
-        fieldDecoder
-
-
-{-| -}
-inputValueDecoder : Decoder String
-inputValueDecoder =
-    Decode.at [ "target", "type" ] Decode.string
-        |> Decode.andThen
-            (\targetType ->
-                case targetType of
-                    "checkbox" ->
-                        Decode.map2
-                            (\valueWhenChecked isChecked ->
-                                if isChecked then
-                                    valueWhenChecked
-
-                                else
-                                    ""
-                            )
-                            (Decode.at [ "target", "value" ] Decode.string)
-                            (Decode.at [ "target", "checked" ] Decode.bool)
-
-                    _ ->
-                        Decode.at [ "target", "value" ] Decode.string
-            )
-
-
-{-| -}
-fieldDecoder : Decoder Event
-fieldDecoder =
-    Decode.field "type" Decode.string
-        |> Decode.andThen
-            (\type_ ->
-                case type_ of
-                    "input" ->
-                        inputValueDecoder |> Decode.map InputEvent
-
-                    "focusin" ->
-                        FocusEvent
-                            |> Decode.succeed
-
-                    "focusout" ->
-                        BlurEvent
-                            |> Decode.succeed
-
-                    _ ->
-                        Decode.fail "Unexpected event.type"
-            )
-
-
-{-| -}
-update : Decode.Value -> PageFormState -> PageFormState
-update eventObject pageFormState =
-    --if Dict.isEmpty pageFormState then
-    --    -- TODO get all initial field values
-    --    pageFormState
-    --
-    --else
-    case eventObject |> Decode.decodeValue fieldEventDecoder of
-        Ok fieldEvent ->
-            pageFormState
-                |> Dict.update fieldEvent.formId
-                    (\previousValue_ ->
-                        let
-                            previousValue : FormState
-                            previousValue =
-                                previousValue_
-                                    |> Maybe.withDefault init
-                        in
-                        previousValue
-                            |> updateForm fieldEvent
-                            |> Just
-                    )
-
-        Err _ ->
-            pageFormState
-
-
-{-| -}
-setField : { formId : String, name : String, value : String } -> PageFormState -> PageFormState
-setField info pageFormState =
-    pageFormState
-        |> Dict.update info.formId
-            (\previousValue_ ->
-                let
-                    previousValue : FormState
-                    previousValue =
-                        previousValue_
-                            |> Maybe.withDefault init
-                in
-                { previousValue
-                    | fields =
-                        previousValue.fields
-                            |> Dict.update info.name
-                                (\previousFieldValue_ ->
-                                    let
-                                        previousFieldValue : FieldState
-                                        previousFieldValue =
-                                            previousFieldValue_
-                                                |> Maybe.withDefault { value = "", status = FieldStatus.NotVisited }
-                                    in
-                                    { previousFieldValue | value = info.value }
-                                        |> Just
-                                )
-                }
-                    |> Just
-            )
-
-
-{-| -}
-updateForm : FieldEvent -> FormState -> FormState
-updateForm fieldEvent formState =
-    { formState
-        | fields =
-            formState.fields
-                |> Dict.update fieldEvent.name
-                    (\previousValue_ ->
-                        let
-                            previousValue : FieldState
-                            previousValue =
-                                previousValue_
-                                    |> Maybe.withDefault { value = fieldEvent.value, status = FieldStatus.NotVisited }
-                        in
-                        (case fieldEvent.event of
-                            InputEvent newValue ->
-                                { previousValue | value = newValue }
-
-                            FocusEvent ->
-                                { previousValue | status = previousValue.status |> increaseStatusTo FieldStatus.Focused }
-
-                            BlurEvent ->
-                                { previousValue | status = previousValue.status |> increaseStatusTo FieldStatus.Blurred }
-                        )
-                            |> Just
-                    )
-    }
-
-
-{-| -}
-setSubmitAttempted : String -> PageFormState -> PageFormState
-setSubmitAttempted fieldId pageFormState =
-    pageFormState
-        |> Dict.update fieldId
-            (\maybeForm ->
-                case maybeForm of
-                    Just formState ->
-                        Just { formState | submitAttempted = True }
-
-                    Nothing ->
-                        Just { init | submitAttempted = True }
-            )
-
-
-{-| -}
-init : FormState
-init =
-    { fields = Dict.empty
-    , submitAttempted = False
-    }
-
-
-{-| -}
-type alias PageFormState =
-    Dict String FormState
-
-
-{-| -}
-type alias FormState =
-    { fields : Dict String FieldState
-    , submitAttempted : Bool
-    }
-
-
-{-| -}
-type alias FieldState =
-    { value : String
-    , status : FieldStatus
-    }
-
-
-{-| -}
-increaseStatusTo : FieldStatus -> FieldStatus -> FieldStatus
-increaseStatusTo increaseTo currentStatus =
-    if statusRank increaseTo > statusRank currentStatus then
-        increaseTo
-
-    else
-        currentStatus
-
-
-{-| -}
-statusRank : FieldStatus -> Int
-statusRank status =
-    case status of
-        FieldStatus.NotVisited ->
-            0
-
-        FieldStatus.Focused ->
-            1
-
-        FieldStatus.Changed ->
-            2
-
-        FieldStatus.Blurred ->
-            3

package/src/Pages/Internal/Form.elm

@@ -1,37 +0,0 @@
-module Pages.Internal.Form exposing (Response(..), Validation(..), ViewField, unwrapResponse)
-
-import Dict exposing (Dict)
-import Form.FieldStatus exposing (FieldStatus)
-import Json.Encode as Encode
-
-
-type Validation error parsed kind field
-    = Validation (Maybe (ViewField kind)) (Maybe String) ( Maybe parsed, Dict String (List error) )
-
-
-{-| -}
-type alias ViewField kind =
-    { value : Maybe String
-    , status : FieldStatus
-    , kind : ( kind, List ( String, Encode.Value ) )
-    }
-
-
-{-| -}
-type Response error
-    = Response
-        { fields : List ( String, String )
-        , errors : Dict String (List error)
-        , clientErrors : Dict String (List error)
-        }
-
-
-unwrapResponse :
-    Response error
-    ->
-        { fields : List ( String, String )
-        , errors : Dict String (List error)
-        , clientErrors : Dict String (List error)
-        }
-unwrapResponse (Response response) =
-    response