elm-pages 3.0.0-beta.27 → 3.0.0-beta.29

package/src/Head.elm

@@ -61,7 +61,7 @@ are using it to populate article metadata like the article's image, publish date
     import Head.Seo
     import Path
     import Route exposing (Route)
-    import RouteBuilder exposing (StatelessRoute, StaticPayload)
+    import RouteBuilder exposing (App, StatelessRoute)
 
     type alias RouteParams =
         { slug : String }
@@ -81,7 +81,7 @@ are using it to populate article metadata like the article's image, publish date
             |> RouteBuilder.buildNoState { view = view }
 
     head :
-        StaticPayload Data ActionData RouteParams
+        App Data ActionData RouteParams
         -> List Head.Tag
     head static =
         let

package/src/Pages/Internal/Platform/CompatibilityKey.elm

@@ -3,4 +3,4 @@ module Pages.Internal.Platform.CompatibilityKey exposing (currentCompatibilityKe
 
 currentCompatibilityKey : Int
 currentCompatibilityKey =
-    11
+    12

package/src/Pages/Internal/Platform.elm

@@ -226,7 +226,7 @@ init config flags url key =
                                 , host = url.host
                                 , port_ = url.port_
                                 , path = pagePath
-                                , query = url.query |> Maybe.map QueryParams.fromString
+                                , query = url.query |> Maybe.map QueryParams.fromString |> Maybe.withDefault Dict.empty
                                 , fragment = url.fragment
                                 }
                         }
@@ -829,7 +829,7 @@ update config appMsg model =
                                                 , host = model.url.host
                                                 , port_ = model.url.port_
                                                 , path = pagePath
-                                                , query = model.url.query |> Maybe.map QueryParams.fromString
+                                                , query = model.url.query |> Maybe.map QueryParams.fromString |> Maybe.withDefault Dict.empty
                                                 , fragment = model.url.fragment
                                                 }
                                         }

package/src/Pages/PageUrl.elm

@@ -1,17 +1,15 @@
 module Pages.PageUrl exposing (PageUrl, toUrl)
 
-{-| Same as a Url in `elm/url`, but slightly more structured. The path portion of the URL is parsed into a [`Path`](Path) type, and
-the query params use the [`QueryParams`](QueryParams) type which allows you to parse just the query params or access them into a Dict.
-
-Because `elm-pages` takes care of the main routing for pages in your app, the standard Elm URL parser API isn't suited
-to parsing query params individually, which is why the structure of these types is different.
+{-| Same as a Url in `elm/url`, but slightly more structured. The path portion of the URL is parsed into a `List String` representing each segment, and
+the query params are parsed into a `Dict String (List String)`.
 
 @docs PageUrl, toUrl
 
 -}
 
+import Dict exposing (Dict)
 import Path exposing (Path)
-import QueryParams exposing (QueryParams)
+import QueryParams
 import Url
 
 
@@ -21,7 +19,7 @@ type alias PageUrl =
     , host : String
     , port_ : Maybe Int
     , path : Path
-    , query : Maybe QueryParams
+    , query : Dict String (List String)
     , fragment : Maybe String
     }
 
@@ -33,6 +31,11 @@ toUrl url =
     , host = url.host
     , port_ = url.port_
     , path = url.path |> Path.toRelative
-    , query = url.query |> Maybe.map QueryParams.toString
+    , query =
+        if url.query |> Dict.isEmpty then
+            Nothing
+
+        else
+            url.query |> QueryParams.toString |> Just
     , fragment = url.fragment
     }

package/src/PagesMsg.elm

@@ -40,7 +40,7 @@ type alias PagesMsg userMsg =
         Maybe PageUrl
         -> Shared.Model
         -> Model
-        -> StaticPayload Data ActionData RouteParams
+        -> App Data ActionData RouteParams
         -> View (PagesMsg Msg)
     view maybeUrl sharedModel model app =
         { title = "My Page"
@@ -52,9 +52,8 @@ type alias PagesMsg userMsg =
 
             -- `Form.renderHtml` gives us `Html (PagesMsg msg)`, so we don't need to wrap its Msg type
             , logoutForm
-                |> Form.toDynamicTransition "logout"
                 |> Form.withOnSubmit (\_ -> NewItemSubmitted)
-                |> Form.renderHtml [] (\_ -> Nothing) app Nothing
+                |> Form.renderHtml "logout" [] (\_ -> Nothing) app Nothing
             ]
         }
 

package/src/Path.elm

@@ -40,20 +40,25 @@ import Pages.Internal.String exposing (chopEnd, chopStart)
 
 {-| The path portion of the URL, normalized to ensure that path segments are joined with `/`s in the right places (no doubled up or missing slashes).
 -}
-type Path
-    = Path String
+type alias Path =
+    List String
 
 
-{-| Create a Path from multiple path parts. Each part can either be a single path segment, like `blog`, or a
-multi-part path part, like `blog/post-1`.
+{-| Turn a Path to a relative URL.
 -}
-join : List String -> Path
+join : Path -> Path
 join parts =
     parts
         |> List.filter (\segment -> segment /= "/")
         |> List.map normalize
+
+
+{-| Turn a Path to a relative URL.
+-}
+toRelative : Path -> String
+toRelative parts =
+    join parts
         |> String.join "/"
-        |> Path
 
 
 {-| Create a Path from a path String.
@@ -66,28 +71,20 @@ join parts =
 fromString : String -> Path
 fromString path =
     path
-        |> normalize
-        |> Path
+        |> toSegments
 
 
 {-| -}
-toSegments : Path -> List String
-toSegments (Path path) =
+toSegments : String -> List String
+toSegments path =
     path |> String.split "/" |> List.filter ((/=) "")
 
 
 {-| Turn a Path to an absolute URL (with no trailing slash).
 -}
 toAbsolute : Path -> String
-toAbsolute (Path path) =
-    "/" ++ path
-
-
-{-| Turn a Path to a relative URL.
--}
-toRelative : Path -> String
-toRelative (Path path) =
-    path
+toAbsolute path =
+    "/" ++ toRelative path
 
 
 normalize : String -> String

package/src/QueryParams.elm

@@ -1,178 +1,37 @@
 module QueryParams exposing
     ( QueryParams
-    , Parser
-    , andThen, fail, fromResult, fromString, optionalString, parse, string, strings, succeed
-    , map2, oneOf
-    , toDict, toString
+    , fromString
+    , toString
     )
 
-{-| Represents the query portion of a URL. You can use `toDict` or `toString` to turn it into basic types, or you can
-parse it into a custom type using the other functions in this module.
-
-@docs QueryParams
-
-
-## Parsing
-
-@docs Parser
-
-@docs andThen, fail, fromResult, fromString, optionalString, parse, string, strings, succeed
-
-
-## Combining
-
-@docs map2, oneOf
-
-
-## Accessing as Built-In Types
-
-@docs toDict, toString
-
--}
-
 import Dict exposing (Dict)
 import Url
 
 
 {-| -}
-type QueryParams
-    = QueryParams String
-
-
-{-| -}
-type Parser a
-    = Parser (Dict String (List String) -> Result String a)
-
-
-{-| -}
-succeed : a -> Parser a
-succeed value =
-    Parser (\_ -> Ok value)
-
-
-{-| -}
-fail : String -> Parser a
-fail errorMessage =
-    Parser (\_ -> Err errorMessage)
-
-
-{-| -}
-fromResult : Result String a -> Parser a
-fromResult result =
-    Parser (\_ -> result)
-
-
-{-| -}
-andThen : (a -> Parser b) -> Parser a -> Parser b
-andThen andThenFn (Parser parser) =
-    Parser
-        (\dict ->
-            case Result.map andThenFn (parser dict) of
-                Ok (Parser result) ->
-                    result dict
-
-                Err error ->
-                    Err error
-        )
-
-
-{-| -}
-oneOf : List (Parser a) -> Parser a
-oneOf parsers =
-    Parser
-        (tryParser parsers)
-
-
-{-| -}
-tryParser : List (Parser a) -> Dict String (List String) -> Result String a
-tryParser parsers dict =
-    case parsers of
-        [] ->
-            Err ""
-
-        (Parser nextParser) :: otherParsers ->
-            case nextParser dict of
-                Ok okValue ->
-                    Ok okValue
-
-                Err _ ->
-                    tryParser otherParsers dict
-
-
-{-| -}
-map2 : (a -> b -> combined) -> Parser a -> Parser b -> Parser combined
-map2 func (Parser a) (Parser b) =
-    Parser <|
-        \dict ->
-            Result.map2 func (a dict) (b dict)
-
-
-{-| -}
-optionalString : String -> Parser (Maybe String)
-optionalString key =
-    custom key
-        (\stringList ->
-            case stringList of
-                str :: _ ->
-                    Ok (Just str)
-
-                _ ->
-                    Ok Nothing
-        )
-
-
-{-| -}
-string : String -> Parser String
-string key =
-    custom key
-        (\stringList ->
-            case stringList of
-                [ str ] ->
-                    Ok str
-
-                _ ->
-                    Err ("Missing key " ++ key)
-        )
-
-
-{-| -}
-custom : String -> (List String -> Result String a) -> Parser a
-custom key customFn =
-    Parser <|
-        \dict ->
-            customFn (Maybe.withDefault [] (Dict.get key dict))
-
-
-{-| -}
-strings : String -> Parser (List String)
-strings key =
-    custom key
-        (\stringList -> Ok stringList)
-
-
-{-| -}
-fromString : String -> QueryParams
-fromString =
-    QueryParams
+type alias QueryParams =
+    Dict String (List String)
 
 
 {-| -}
 toString : QueryParams -> String
-toString (QueryParams queryParams) =
-    queryParams
-
-
-{-| -}
-parse : Parser a -> QueryParams -> Result String a
-parse (Parser queryParser) queryParams =
+toString queryParams =
     queryParams
-        |> toDict
-        |> queryParser
+        |> Dict.toList
+        |> List.concatMap
+            (\( key, values ) ->
+                values
+                    |> List.map
+                        (\value ->
+                            key ++ "=" ++ value
+                        )
+            )
+        |> String.join "&"
 
 
 {-| -}
-toDict : QueryParams -> Dict String (List String)
-toDict (QueryParams queryParams) =
+fromString : String -> Dict String (List String)
+fromString queryParams =
     prepareQuery (Just queryParams)