elm-pages 3.0.9 → 3.0.11

package/src/BackendTask.elm

@@ -199,27 +199,28 @@ combineHelp items =
     List.foldl (map2 (::)) (succeed []) items |> map List.reverse
 
 
-{-| Like map, but it takes in two `Request`s.
-
-    view siteMetadata page =
-        StaticHttp.map2
-            (\elmPagesStars elmMarkdownStars ->
-                { view =
-                    \model viewForPage ->
-                        { title = "Repo Stargazers"
-                        , body = starsView elmPagesStars elmMarkdownStars
-                        }
-                , head = head elmPagesStars elmMarkdownStars
-                }
-            )
-            (get
-                "https://api.github.com/repos/dillonkearns/elm-pages"
-                (Decode.field "stargazers_count" Decode.int)
-            )
-            (get
-                "https://api.github.com/repos/dillonkearns/elm-markdown"
-                (Decode.field "stargazers_count" Decode.int)
+{-| Like map, but it takes in two `BackendTask`s.
+
+    import BackendTask exposing (BackendTask)
+    import BackendTask.Env as Env
+    import BackendTask.Http
+    import FatalError exposing (FatalError)
+    import Json.Decode as Decode
+
+    type alias Data =
+        { pokemon : List String, envValue : Maybe String }
+
+    data : BackendTask FatalError Data
+    data =
+        BackendTask.map2 Data
+            (BackendTask.Http.getJson
+                "https://pokeapi.co/api/v2/pokemon/?limit=100&offset=0"
+                (Decode.field "results"
+                    (Decode.list (Decode.field "name" Decode.string))
+                )
+                |> BackendTask.allowFatal
             )
+            (Env.get "HELLO")
 
 -}
 map2 : (a -> b -> c) -> BackendTask error a -> BackendTask error b -> BackendTask error c
@@ -334,28 +335,15 @@ andMap =
     map2 (|>)
 
 
-{-| This is useful for prototyping with some hardcoded data, or for having a view that doesn't have any StaticHttp data.
+{-| This is useful for prototyping with some hardcoded data, or for having a view that doesn't have any BackendTask data.
 
-    import BackendTask
+    import BackendTask exposing (BackendTask)
+
+    type alias RouteParams = { name : String }
 
-    view :
-        List ( PagePath, Metadata )
-        ->
-            { path : PagePath
-            , frontmatter : Metadata
-            }
-        ->
-            StaticHttp.Request
-                { view : Model -> View -> { title : String, body : Html Msg }
-                , head : List (Head.Tag Pages.PathKey)
-                }
-    view siteMetadata page =
-        StaticHttp.succeed
-            { view =
-                \model viewForPage ->
-                    mainView model viewForPage
-            , head = head page.frontmatter
-            }
+    pages : BackendTask error (List RouteParams)
+    pages =
+        BackendTask.succeed [ { name = "elm-pages" } ]
 
 -}
 succeed : a -> BackendTask error a

package/src/FatalError.elm

@@ -20,8 +20,8 @@ For example, if you wanted to handle possible errors to present them to the user
         BackendTask.Http.getJson "https://api.github.com/repos/dillonkearns/elm-pages"
             (Decode.field "description" Decode.string)
             |> BackendTask.onError
-                (\error ->
-                    case FatalError.unwrap error of
+                (\{ recoverable } ->
+                    case recoverable of
                         BackendTask.Http.BadStatus metadata string ->
                             if metadata.statusCode == 401 || metadata.statusCode == 403 || metadata.statusCode == 404 then
                                 BackendTask.succeed "Either this repo doesn't exist or you don't have access to it."

package/src/Head/Seo.elm

@@ -52,8 +52,8 @@ includes common meta tags used for rich link previews, namely [OpenGraph tags](h
 import DateOrDateTime exposing (DateOrDateTime)
 import Head
 import Head.Twitter as Twitter
-import LanguageTag.Country
 import LanguageTag.Language
+import LanguageTag.Region
 import MimeType exposing (MimeType)
 import Pages.Url
 
@@ -315,7 +315,7 @@ localeToString : Locale -> String
 localeToString ( language, territory ) =
     LanguageTag.Language.toCodeString language
         ++ "_"
-        ++ LanguageTag.Country.toCodeString territory
+        ++ LanguageTag.Region.toCodeString territory
 
 
 tagsForCommon : Common -> List ( String, Maybe Head.AttributeValue )
@@ -361,7 +361,7 @@ tagsForAudio audio =
 
 
 type alias Locale =
-    ( LanguageTag.Language.Language, LanguageTag.Country.Country )
+    ( LanguageTag.Language.Language, LanguageTag.Region.Region )
 
 
 type Content

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

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

package/src/Pages/Manifest.elm

@@ -72,8 +72,8 @@ import FatalError exposing (FatalError)
 import Head
 import Json.Encode as Encode
 import LanguageTag exposing (LanguageTag, emptySubtags)
-import LanguageTag.Country as Country
 import LanguageTag.Language
+import LanguageTag.Region as Region
 import MimeType
 import Pages.Manifest.Category as Category exposing (Category)
 import Pages.Url
@@ -140,7 +140,7 @@ usEnglish =
     LanguageTag.Language.en
         |> LanguageTag.build
             { emptySubtags
-                | region = Just Country.us
+                | region = Just Region.us
             }
 
 

package/src/Scaffold/Route.elm

@@ -118,7 +118,15 @@ serverRender =
     ServerRender []
 
 
-{-| -}
+{-| Will scaffold using `RouteBuilder.preRender` if there are any dynamic segments (as in `Company.Team.Name_`),
+or using `RouteBuilder.single` if there are no dynamic segments (as in `Company.AboutUs`).
+
+When there are no dynamic segments, the `pages` field will be ignored as it is only relevant for Routes with dynamic segments.
+
+For dynamic segments, the `routeParams` parameter in the `data` function will be an `Elm.Expression` with the `RouteParams` parameter in the `data` function.
+For static segments, it will be a hardcoded empty record (`{}`).
+
+-}
 preRender :
     { data : ( Type, Elm.Expression -> Elm.Expression )
     , pages : Elm.Expression
@@ -127,29 +135,41 @@ preRender :
     }
     -> Builder
 preRender input =
-    --let
-    --    hasDynamicRouteSegments : Bool
-    --    hasDynamicRouteSegments =
-    --        RoutePattern.fromModuleName input.moduleName
-    --            -- TODO give error if not parseable here
-    --            |> Maybe.map RoutePattern.hasRouteParams
-    --            |> Maybe.withDefault False
-    --in
-    PreRender []
-        { data = input.data
-        , pages =
-            input.pages
-                |> Elm.withType
-                    (throwableTask
-                        (Elm.Annotation.list <| Elm.Annotation.named [] "RouteParams")
-                    )
-                |> Just
-        , head = input.head
-        , moduleName = input.moduleName
-        }
+    let
+        hasDynamicRouteSegments : Bool
+        hasDynamicRouteSegments =
+            RoutePattern.fromModuleName input.moduleName
+                |> Maybe.map RoutePattern.hasRouteParams
+                |> Maybe.withDefault False
+    in
+    if hasDynamicRouteSegments then
+        PreRender []
+            { data = input.data
+            , pages =
+                input.pages
+                    |> Elm.withType
+                        (throwableTask
+                            (Elm.Annotation.list <| Elm.Annotation.named [] "RouteParams")
+                        )
+                    |> Just
+            , head = input.head
+            , moduleName = input.moduleName
+            }
 
+    else
+        PreRender []
+            { data = input.data
+            , pages = Nothing
+            , head = input.head
+            , moduleName = input.moduleName
+            }
 
-{-| -}
+
+{-| @depreacted. This is obsolete and will be removed in a future release. Use [`preRender`](#preRender) instead.
+
+If you pass in only static route segments as the `moduleName` to `preRender` it will yield the same result as `single`.
+
+-}
 single :
     { data : ( Type, Elm.Expression )
     , head : Elm.Expression -> Elm.Expression
@@ -656,7 +676,7 @@ userFunction moduleName definitions =
                     Elm.Declare.function "data"
                         []
                         (\_ ->
-                            definitions.data Elm.unit Elm.unit
+                            definitions.data Elm.unit (Elm.record [])
                                 |> Elm.withType
                                     (case definitions.action of
                                         Pages _ ->
@@ -668,34 +688,60 @@ userFunction moduleName definitions =
                         )
 
                 _ ->
-                    Elm.Declare.function "data"
-                        [ ( "routeParams"
-                          , "RouteParams"
-                                |> Elm.Annotation.named []
-                                |> Just
-                          )
-                        , ( "request"
-                          , "Request"
-                                |> Elm.Annotation.named [ "Server", "Request" ]
-                                |> Just
-                          )
-                        ]
-                        (\args ->
-                            case args of
-                                [ arg, arg2 ] ->
-                                    definitions.data arg arg2
-                                        |> Elm.withType
-                                            (case definitions.action of
-                                                Pages _ ->
-                                                    throwableTask (Elm.Annotation.named [] "Data")
+                    case definitions.action of
+                        Pages _ ->
+                            Elm.Declare.function "data"
+                                [ ( "routeParams"
+                                  , "RouteParams"
+                                        |> Elm.Annotation.named []
+                                        |> Just
+                                  )
+                                ]
+                                (\args ->
+                                    case args of
+                                        [ arg ] ->
+                                            definitions.data
+                                                (arg
+                                                    |> Elm.withType
+                                                        (throwableTask
+                                                            (Elm.Annotation.named [] "Data")
+                                                        )
+                                                )
+                                                Elm.unit
 
-                                                Action _ ->
-                                                    myType "Data"
-                                            )
+                                        _ ->
+                                            Elm.unit
+                                )
 
-                                _ ->
-                                    Elm.unit
-                        )
+                        Action _ ->
+                            Elm.Declare.function "data"
+                                [ ( "routeParams"
+                                  , "RouteParams"
+                                        |> Elm.Annotation.named []
+                                        |> Just
+                                  )
+                                , ( "request"
+                                  , "Request"
+                                        |> Elm.Annotation.named [ "Server", "Request" ]
+                                        |> Just
+                                  )
+                                ]
+                                (\args ->
+                                    case args of
+                                        [ arg, arg2 ] ->
+                                            definitions.data arg arg2
+                                                |> Elm.withType
+                                                    (case definitions.action of
+                                                        Pages _ ->
+                                                            throwableTask (Elm.Annotation.named [] "Data")
+
+                                                        Action _ ->
+                                                            myType "Data"
+                                                    )
+
+                                        _ ->
+                                            Elm.unit
+                                )
 
         actionFn : Maybe { declaration : Elm.Declaration, call : List Elm.Expression -> Elm.Expression, callFrom : List String -> List Elm.Expression -> Elm.Expression, value : List String -> Elm.Expression }
         actionFn =