elm-pages 3.0.9 → 3.0.10

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 =