elm-pages 2.1.10 → 3.0.0-beta.0

package/src/Pages/Transition.elm

@@ -0,0 +1,70 @@
+module Pages.Transition exposing
+    ( Transition(..), LoadingState(..), map
+    , FetcherState, FetcherSubmitStatus(..)
+    )
+
+{-|
+
+@docs Transition, LoadingState, map
+
+
+## Fetchers
+
+@docs FetcherState, FetcherSubmitStatus
+
+-}
+
+import Form.FormData exposing (FormData)
+import Path exposing (Path)
+import Time
+
+
+{-| -}
+type Transition
+    = Submitting FormData
+    | LoadAfterSubmit FormData Path LoadingState
+    | Loading Path LoadingState
+
+
+{-| -}
+type LoadingState
+    = Redirecting
+    | Load
+    | ActionRedirect
+
+
+{-| -}
+type alias FetcherState actionData =
+    { status : FetcherSubmitStatus actionData
+    , payload : FormData
+    , initiatedAt : Time.Posix
+    }
+
+
+{-| -}
+type FetcherSubmitStatus actionData
+    = FetcherSubmitting
+    | FetcherReloading actionData
+    | FetcherComplete actionData
+
+
+{-| -}
+map : (a -> b) -> FetcherState a -> FetcherState b
+map mapFn fetcherState =
+    { status = mapStatus mapFn fetcherState.status
+    , payload = fetcherState.payload
+    , initiatedAt = fetcherState.initiatedAt
+    }
+
+
+mapStatus : (a -> b) -> FetcherSubmitStatus a -> FetcherSubmitStatus b
+mapStatus mapFn fetcherSubmitStatus =
+    case fetcherSubmitStatus of
+        FetcherSubmitting ->
+            FetcherSubmitting
+
+        FetcherReloading value ->
+            FetcherReloading (mapFn value)
+
+        FetcherComplete value ->
+            FetcherComplete (mapFn value)

package/src/Path.elm

@@ -50,6 +50,7 @@ multi-part path part, like `blog/post-1`.
 join : List String -> Path
 join parts =
     parts
+        |> List.filter (\segment -> segment /= "/")
         |> List.map normalize
         |> String.join "/"
         |> Path

package/src/Pattern.elm

@@ -0,0 +1,98 @@
+module Pattern exposing (Pattern(..), Segment(..), State(..), addCapture, addLiteral, addSlash, empty, toJson)
+
+import Json.Encode
+
+
+toJson : Pattern -> Json.Encode.Value
+toJson (Pattern segments _) =
+    Json.Encode.list segmentToJson segments
+
+
+segmentToJson : Segment -> Json.Encode.Value
+segmentToJson segment =
+    -- elm-review: known-unoptimized-recursion
+    case segment of
+        Literal literalString ->
+            Json.Encode.object
+                [ ( "kind", Json.Encode.string "literal" )
+                , ( "value", Json.Encode.string literalString )
+                ]
+
+        Dynamic ->
+            Json.Encode.object
+                [ ( "kind", Json.Encode.string "dynamic" )
+                ]
+
+        HybridSegment ( first, second, rest ) ->
+            Json.Encode.object
+                [ ( "kind", Json.Encode.string "hybrid" )
+                , ( "value", Json.Encode.list segmentToJson (first :: second :: rest) )
+                ]
+
+
+empty : Pattern
+empty =
+    Pattern [] NoPendingSlash
+
+
+addSlash : Pattern -> Pattern
+addSlash (Pattern segments _) =
+    Pattern segments PendingSlash
+
+
+addCapture : Pattern -> Pattern
+addCapture (Pattern segments state) =
+    case state of
+        PendingSlash ->
+            Pattern (segments ++ [ Dynamic ]) NoPendingSlash
+
+        NoPendingSlash ->
+            case segments |> List.reverse of
+                [] ->
+                    Pattern [ Dynamic ] NoPendingSlash
+
+                last :: rest ->
+                    Pattern (List.reverse rest ++ [ HybridSegment ( last, Dynamic, [] ) ]) NoPendingSlash
+
+
+addLiteral : String -> Pattern -> Pattern
+addLiteral newLiteral (Pattern segments state) =
+    case state of
+        PendingSlash ->
+            Pattern
+                (segments ++ [ Literal newLiteral ])
+                NoPendingSlash
+
+        NoPendingSlash ->
+            case segments |> List.reverse of
+                (Literal literalSegment) :: rest ->
+                    Pattern
+                        (List.reverse rest ++ [ Literal (literalSegment ++ newLiteral) ])
+                        NoPendingSlash
+
+                last :: rest ->
+                    Pattern (List.reverse rest ++ [ HybridSegment ( last, Literal newLiteral, [] ) ]) NoPendingSlash
+
+                _ ->
+                    Pattern
+                        (segments ++ [ Literal newLiteral ])
+                        state
+
+
+
+--Pattern segments state
+
+
+type Pattern
+    = Pattern (List Segment) State
+
+
+type State
+    = PendingSlash
+    | NoPendingSlash
+
+
+type Segment
+    = Literal String
+    | Dynamic
+    | HybridSegment ( Segment, Segment, List Segment )

package/src/RenderRequest.elm

@@ -49,7 +49,7 @@ type IncludeHtml
 
 
 decoder :
-    ProgramConfig userMsg userModel (Maybe route) siteData pageData sharedData
+    ProgramConfig userMsg userModel (Maybe route) pageData actionData sharedData effect mappedMsg errorPage
     -> Decode.Decoder (RenderRequest (Maybe route))
 decoder config =
     Decode.field "request"
@@ -90,7 +90,7 @@ decoder config =
 
 
 requestPayloadDecoder :
-    ProgramConfig userMsg userModel (Maybe route) siteData pageData sharedData
+    ProgramConfig userMsg userModel (Maybe route) pageData actionData sharedData effect mappedMsg errorPage
     -> Decode.Decoder (RequestPayload (Maybe route))
 requestPayloadDecoder config =
     (Decode.string

package/src/RequestsAndPending.elm

@@ -1,20 +1,122 @@
-module RequestsAndPending exposing (RequestsAndPending, decoder, get)
+module RequestsAndPending exposing (RequestsAndPending, Response(..), ResponseBody(..), batchDecoder, bodyEncoder, decoder, get)
 
+import Base64
+import Bytes exposing (Bytes)
+import Codec
 import Dict exposing (Dict)
-import Json.Decode as Decode
+import Json.Decode as Decode exposing (Decoder)
+import Json.Encode as Encode
+import Pages.StaticHttp.Request
 
 
 type alias RequestsAndPending =
-    Dict String (Maybe String)
+    Dict String (Maybe Response)
 
 
-get : String -> RequestsAndPending -> Maybe String
+type ResponseBody
+    = BytesBody Bytes
+    | StringBody String
+    | JsonBody Decode.Value
+    | WhateverBody
+
+
+batchDecoder : Decoder (List { request : Pages.StaticHttp.Request.Request, response : Response })
+batchDecoder =
+    Decode.map2 (\request response -> { request = request, response = response })
+        (Decode.field "request"
+            (Pages.StaticHttp.Request.codec
+                |> Codec.decoder
+            )
+        )
+        (Decode.field "response" decoder)
+        |> Decode.list
+
+
+decoder : Decoder Response
+decoder =
+    Decode.map2 Response
+        (Decode.maybe responseDecoder)
+        bodyDecoder
+
+
+bodyDecoder : Decoder ResponseBody
+bodyDecoder =
+    Decode.field "bodyKind" Decode.string
+        |> Decode.andThen
+            (\bodyKind ->
+                Decode.field "body"
+                    (case bodyKind of
+                        "bytes" ->
+                            Decode.string
+                                |> Decode.andThen
+                                    (\base64String ->
+                                        base64String
+                                            |> Base64.toBytes
+                                            |> Maybe.map (BytesBody >> Decode.succeed)
+                                            |> Maybe.withDefault (Decode.fail "Couldn't parse base64 string into Bytes.")
+                                    )
+
+                        "string" ->
+                            Decode.string |> Decode.map StringBody
+
+                        "json" ->
+                            Decode.value |> Decode.map JsonBody
+
+                        "whatever" ->
+                            Decode.succeed WhateverBody
+
+                        _ ->
+                            Decode.fail "Unexpected bodyKind."
+                    )
+            )
+
+
+bodyEncoder : ResponseBody -> Encode.Value
+bodyEncoder body =
+    (case body of
+        JsonBody jsonValue ->
+            ( "json", jsonValue )
+
+        StringBody string ->
+            ( "string", Encode.string string )
+
+        BytesBody _ ->
+            ( "Unhandled", Encode.null )
+
+        WhateverBody ->
+            ( "whatever", Encode.null )
+    )
+        |> (\( bodyKind, encodedBody ) ->
+                Encode.object
+                    [ ( "bodyKind", Encode.string bodyKind )
+                    , ( "body", encodedBody )
+                    ]
+           )
+
+
+type alias RawResponse =
+    { statusCode : Int
+    , statusText : String
+    , headers : Dict String String
+    , url : String
+    }
+
+
+type Response
+    = Response (Maybe RawResponse) ResponseBody
+
+
+responseDecoder : Decoder RawResponse
+responseDecoder =
+    Decode.map4 RawResponse
+        (Decode.field "statusCode" Decode.int)
+        (Decode.field "statusText" Decode.string)
+        (Decode.field "headers" (Decode.dict Decode.string))
+        (Decode.field "url" Decode.string)
+
+
+get : String -> RequestsAndPending -> Maybe Response
 get key requestsAndPending =
     requestsAndPending
         |> Dict.get key
         |> Maybe.andThen identity
-
-
-decoder : Decode.Decoder RequestsAndPending
-decoder =
-    Decode.dict (Decode.string |> Decode.map Just)