elm-pages 2.1.11 → 3.0.0-beta.0

package/src/FormData.elm

@@ -0,0 +1,58 @@
+module FormData exposing (encode, parse)
+
+import Dict exposing (Dict)
+import List.NonEmpty exposing (NonEmpty)
+import Url
+
+
+parse : String -> Dict String ( String, List String )
+parse rawString =
+    rawString
+        |> String.split "&"
+        |> List.foldl
+            (\entry soFar ->
+                case entry |> String.split "=" of
+                    [ key, value ] ->
+                        let
+                            newValue : String
+                            newValue =
+                                value |> decode
+                        in
+                        Dict.update (decode key)
+                            (\maybeExistingList ->
+                                maybeExistingList
+                                    |> Maybe.map (\( first, rest ) -> ( first, rest ++ [ newValue ] ))
+                                    |> Maybe.withDefault ( newValue, [] )
+                                    |> Just
+                            )
+                            soFar
+
+                    _ ->
+                        --( entry |> Url.percentDecode |> Maybe.withDefault entry, ( "", [] ) )
+                        soFar
+            )
+            Dict.empty
+
+
+decode : String -> String
+decode string =
+    string
+        |> String.replace "+" " "
+        |> Url.percentDecode
+        |> Maybe.withDefault ""
+
+
+encode : Dict String (NonEmpty String) -> String
+encode dict =
+    dict
+        |> Dict.toList
+        |> List.concatMap
+            (\( key, values ) ->
+                values
+                    |> List.NonEmpty.toList
+                    |> List.map
+                        (\value ->
+                            Url.percentEncode key ++ "=" ++ Url.percentEncode value
+                        )
+            )
+        |> String.join "&"

package/src/FormDecoder.elm

@@ -0,0 +1,102 @@
+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/Head/Seo.elm

@@ -51,6 +51,8 @@ with the `head` function that you pass to your Pages config (`Pages.application`
 
 import Head
 import Head.Twitter as Twitter
+import LanguageTag.Country
+import LanguageTag.Language
 import Pages.Url
 
 
@@ -307,6 +309,13 @@ type alias Common =
     }
 
 
+localeToString : Locale -> String
+localeToString ( language, territory ) =
+    LanguageTag.Language.toCodeString language
+        ++ "_"
+        ++ LanguageTag.Country.toCodeString territory
+
+
 tagsForCommon : Common -> List ( String, Maybe Head.AttributeValue )
 tagsForCommon common =
     tagsForImage common.image
@@ -316,12 +325,12 @@ tagsForCommon common =
            , ( "og:url", common.canonicalUrlOverride |> Maybe.map Head.raw |> Maybe.withDefault Head.currentPageFullUrl |> Just )
            , ( "og:description", Just (Head.raw common.description) )
            , ( "og:site_name", Just (Head.raw common.siteName) )
-           , ( "og:locale", common.locale |> Maybe.map Head.raw )
+           , ( "og:locale", common.locale |> Maybe.map localeToString |> Maybe.map Head.raw )
            ]
         ++ (common.alternateLocales
                 |> List.map
                     (\alternateLocale ->
-                        ( "og:locale:alternate", alternateLocale |> Head.raw |> Just )
+                        ( "og:locale:alternate", alternateLocale |> localeToString |> Head.raw |> Just )
                     )
            )
         ++ Twitter.rawTags common.twitterCard
@@ -350,8 +359,7 @@ tagsForAudio audio =
 
 
 type alias Locale =
-    -- TODO make this more type-safe
-    String
+    ( LanguageTag.Language.Language, LanguageTag.Country.Country )
 
 
 type Content

package/src/Head.elm

@@ -1,6 +1,6 @@
 module Head exposing
     ( Tag, metaName, metaProperty, metaRedirect
-    , rssLink, sitemapLink, rootLanguage
+    , rssLink, sitemapLink, rootLanguage, manifestLink
     , structuredData
     , AttributeValue
     , currentPageFullUrl, urlAttribute, raw
@@ -18,7 +18,7 @@ But this module might be useful if you have a special use case, or if you are
 writing a plugin package to extend `elm-pages`.
 
 @docs Tag, metaName, metaProperty, metaRedirect
-@docs rssLink, sitemapLink, rootLanguage
+@docs rssLink, sitemapLink, rootLanguage, manifestLink
 
 
 ## Structured Data
@@ -211,6 +211,16 @@ canonicalLink maybePath =
         ]
 
 
+{-| Let's you link to your manifest.json file, see <https://developer.mozilla.org/en-US/docs/Web/Manifest#deploying_a_manifest>.
+-}
+manifestLink : String -> Tag
+manifestLink path =
+    node "link"
+        [ ( "rel", raw "manifest" )
+        , ( "href", raw path )
+        ]
+
+
 {-| Add a link to the site's RSS feed.
 
 Example:

package/src/HtmlPrinter.elm

@@ -19,7 +19,7 @@ htmlToString viewHtml =
             nodeToStringWithOptions defaultFormatOptions str
 
         Err err ->
-            "Error: " ++ Decode.errorToString err
+            "Error pre-rendering HTML in HtmlPrinter.elm: " ++ Decode.errorToString err
 
 
 asJsonView : Html msg -> Decode.Value

package/src/Internal/ApiRoute.elm

@@ -3,11 +3,14 @@ module Internal.ApiRoute exposing
     , ApiRouteBuilder(..)
     , firstMatch
     , pathToMatches
+    , toPattern
     , tryMatch
     , withRoutes
     )
 
 import DataSource exposing (DataSource)
+import Head
+import Pattern exposing (Pattern)
 import Regex exposing (Regex)
 
 
@@ -44,12 +47,20 @@ type ApiRoute response
         , matchesToResponse : String -> DataSource (Maybe response)
         , buildTimeRoutes : DataSource (List String)
         , handleRoute : String -> DataSource Bool
+        , pattern : Pattern
+        , kind : String
+        , globalHeadTags : Maybe (DataSource (List Head.Tag))
         }
 
 
+toPattern : ApiRoute response -> Pattern
+toPattern (ApiRoute { pattern }) =
+    pattern
+
+
 {-| -}
 pathToMatches : String -> ApiRouteBuilder a constructor -> List String
-pathToMatches path (ApiRouteBuilder pattern _ _ _) =
+pathToMatches path (ApiRouteBuilder _ pattern _ _ _) =
     Regex.find
         (Regex.fromString pattern
             |> Maybe.withDefault Regex.never
@@ -57,18 +68,19 @@ pathToMatches path (ApiRouteBuilder pattern _ _ _) =
         path
         |> List.concatMap .submatches
         |> List.filterMap identity
+        |> List.reverse
 
 
 {-| -}
 withRoutes : (constructor -> List (List String)) -> ApiRouteBuilder a constructor -> List String
-withRoutes buildUrls (ApiRouteBuilder _ _ toString constructor) =
+withRoutes buildUrls (ApiRouteBuilder _ _ _ toString constructor) =
     buildUrls (constructor [])
         |> List.map toString
 
 
 {-| -}
 tryMatch : String -> ApiRouteBuilder response constructor -> Maybe response
-tryMatch path (ApiRouteBuilder pattern handler _ _) =
+tryMatch path (ApiRouteBuilder _ pattern handler _ _) =
     let
         matches : List String
         matches =
@@ -79,6 +91,7 @@ tryMatch path (ApiRouteBuilder pattern handler _ _) =
                 path
                 |> List.concatMap .submatches
                 |> List.filterMap identity
+                |> List.reverse
     in
     handler matches
         |> Just
@@ -86,4 +99,4 @@ tryMatch path (ApiRouteBuilder pattern handler _ _) =
 
 {-| -}
 type ApiRouteBuilder a constructor
-    = ApiRouteBuilder String (List String -> a) (List String -> String) (List String -> constructor)
+    = ApiRouteBuilder Pattern String (List String -> a) (List String -> String) (List String -> constructor)

package/src/Internal/Request.elm

@@ -0,0 +1,7 @@
+module Internal.Request exposing (Parser(..))
+
+import Json.Decode
+
+
+type Parser decodesTo validationError
+    = Parser (Json.Decode.Decoder ( Result validationError decodesTo, List validationError ))

package/src/PageServerResponse.elm

@@ -0,0 +1,68 @@
+module PageServerResponse exposing (PageServerResponse(..), Response, toJson, toRedirect)
+
+import Dict
+import Json.Encode
+import List.Extra
+
+
+type PageServerResponse data error
+    = RenderPage
+        { statusCode : Int
+        , headers : List ( String, String )
+        }
+        data
+    | ServerResponse Response
+    | ErrorPage error { headers : List ( String, String ) }
+
+
+toRedirect : Response -> Maybe { statusCode : Int, location : String }
+toRedirect response =
+    response.headers
+        |> Dict.fromList
+        |> Dict.get "Location"
+        |> Maybe.andThen
+            (\location ->
+                if response.statusCode == 302 then
+                    Just { statusCode = 302, location = location }
+
+                else
+                    Nothing
+            )
+
+
+type alias Response =
+    { statusCode : Int
+    , headers : List ( String, String )
+    , body : Maybe String
+    , isBase64Encoded : Bool
+    }
+
+
+toJson : Response -> Json.Encode.Value
+toJson serverResponse =
+    Json.Encode.object
+        [ ( "body", serverResponse.body |> Maybe.map Json.Encode.string |> Maybe.withDefault Json.Encode.null )
+        , ( "statusCode", serverResponse.statusCode |> Json.Encode.int )
+        , ( "headers"
+          , serverResponse.headers
+                |> collectMultiValueHeaders
+                |> List.map (Tuple.mapSecond (Json.Encode.list Json.Encode.string))
+                |> Json.Encode.object
+          )
+        , ( "kind", Json.Encode.string "server-response" )
+        , ( "isBase64Encoded", Json.Encode.bool serverResponse.isBase64Encoded )
+        ]
+
+
+collectMultiValueHeaders : List ( String, String ) -> List ( String, List String )
+collectMultiValueHeaders headers =
+    headers
+        |> List.Extra.groupWhile
+            (\( key1, _ ) ( key2, _ ) -> key1 == key2)
+        |> List.map
+            (\( ( key, firstValue ), otherValues ) ->
+                ( key
+                , firstValue
+                    :: (otherValues |> List.map Tuple.second)
+                )
+            )

package/src/Pages/ContentCache.elm

@@ -1,212 +1,16 @@
 module Pages.ContentCache exposing
-    ( ContentCache
-    , ContentJson
-    , Entry(..)
-    , Path
-    , contentJsonDecoder
-    , init
-    , is404
-    , lazyLoad
-    , notFoundReason
+    ( Path
     , pathForUrl
     )
 
-import BuildError exposing (BuildError)
-import Codec
-import Dict exposing (Dict)
-import Html exposing (Html)
-import Http
-import Json.Decode as Decode
-import Pages.Internal.NotFoundReason
 import Pages.Internal.String as String
-import RequestsAndPending exposing (RequestsAndPending)
-import Task exposing (Task)
 import Url exposing (Url)
 
 
-type alias Content =
-    List ( List String, { extension : String, frontMatter : String, body : Maybe String } )
-
-
-type alias ContentCache =
-    Dict Path Entry
-
-
-type alias Errors =
-    List ( Html Never, BuildError )
-
-
-type alias ContentCacheInner =
-    Dict Path Entry
-
-
-type Entry
-    = Parsed ContentJson
-
-
-type alias ParseError =
-    String
-
-
 type alias Path =
     List String
 
 
-init :
-    Maybe ( Path, ContentJson )
-    -> ContentCache
-init maybeInitialPageContent =
-    case maybeInitialPageContent of
-        Nothing ->
-            Dict.empty
-
-        Just ( urls, contentJson ) ->
-            Dict.singleton urls (Parsed contentJson)
-
-
-{-| Get from the Cache... if it's not already parsed, it will
-parse it before returning it and store the parsed version in the Cache
--}
-lazyLoad :
-    { currentUrl : Url, basePath : List String }
-    -> ContentCache
-    -> Task Http.Error ( Url, ContentJson, ContentCache )
-lazyLoad urls cache =
-    case Dict.get (pathForUrl urls) cache of
-        Just (Parsed contentJson) ->
-            Task.succeed
-                ( urls.currentUrl
-                , contentJson
-                , cache
-                )
-
-        Nothing ->
-            urls.currentUrl
-                |> httpTask
-                |> Task.map
-                    (\downloadedContent ->
-                        ( urls.currentUrl
-                        , downloadedContent
-                        , update
-                            cache
-                            urls
-                            downloadedContent
-                        )
-                    )
-
-
-httpTask : Url -> Task Http.Error ContentJson
-httpTask url =
-    Http.task
-        { method = "GET"
-        , headers = []
-        , url =
-            url.path
-                |> String.chopForwardSlashes
-                |> String.split "/"
-                |> List.filter ((/=) "")
-                |> (\l -> l ++ [ "content.json" ])
-                |> String.join "/"
-                |> String.append "/"
-        , body = Http.emptyBody
-        , resolver =
-            Http.stringResolver
-                (\response ->
-                    case response of
-                        Http.BadUrl_ url_ ->
-                            Err (Http.BadUrl url_)
-
-                        Http.Timeout_ ->
-                            Err Http.Timeout
-
-                        Http.NetworkError_ ->
-                            Err Http.NetworkError
-
-                        Http.BadStatus_ metadata _ ->
-                            Err (Http.BadStatus metadata.statusCode)
-
-                        Http.GoodStatus_ _ body ->
-                            body
-                                |> Decode.decodeString contentJsonDecoder
-                                |> Result.mapError (\err -> Http.BadBody (Decode.errorToString err))
-                )
-        , timeout = Nothing
-        }
-
-
-type alias ContentJson =
-    { staticData : RequestsAndPending
-    , is404 : Bool
-    , path : Maybe String
-    , notFoundReason : Maybe Pages.Internal.NotFoundReason.Payload
-    }
-
-
-contentJsonDecoder : Decode.Decoder ContentJson
-contentJsonDecoder =
-    Decode.field "is404" Decode.bool
-        |> Decode.andThen
-            (\is404Value ->
-                if is404Value then
-                    Decode.map4 ContentJson
-                        (Decode.succeed Dict.empty)
-                        (Decode.succeed is404Value)
-                        (Decode.field "path" Decode.string |> Decode.map Just)
-                        (Decode.at [ "staticData", "notFoundReason" ]
-                            (Decode.string
-                                |> Decode.andThen
-                                    (\jsonString ->
-                                        case
-                                            Decode.decodeString
-                                                (Codec.decoder Pages.Internal.NotFoundReason.codec
-                                                    |> Decode.map Just
-                                                )
-                                                jsonString
-                                        of
-                                            Ok okValue ->
-                                                Decode.succeed okValue
-
-                                            Err error ->
-                                                Decode.fail
-                                                    (Decode.errorToString error)
-                                    )
-                            )
-                        )
-
-                else
-                    Decode.map4 ContentJson
-                        (Decode.field "staticData" RequestsAndPending.decoder)
-                        (Decode.succeed is404Value)
-                        (Decode.succeed Nothing)
-                        (Decode.succeed Nothing)
-            )
-
-
-update :
-    ContentCache
-    -> { currentUrl : Url, basePath : List String }
-    -> ContentJson
-    -> ContentCache
-update cache urls rawContent =
-    Dict.update
-        (pathForUrl urls)
-        (\entry ->
-            case entry of
-                Just (Parsed _) ->
-                    entry
-
-                Nothing ->
-                    { staticData = rawContent.staticData
-                    , is404 = rawContent.is404
-                    , path = rawContent.path
-                    , notFoundReason = rawContent.notFoundReason
-                    }
-                        |> Parsed
-                        |> Just
-        )
-        cache
-
-
 pathForUrl : { currentUrl : Url, basePath : List String } -> Path
 pathForUrl { currentUrl, basePath } =
     currentUrl.path
@@ -214,35 +18,3 @@ pathForUrl { currentUrl, basePath } =
         |> String.split "/"
         |> List.filter ((/=) "")
         |> List.drop (List.length basePath)
-
-
-is404 :
-    ContentCache
-    -> { currentUrl : Url, basePath : List String }
-    -> Bool
-is404 dict urls =
-    dict
-        |> Dict.get (pathForUrl urls)
-        |> Maybe.map
-            (\entry ->
-                case entry of
-                    Parsed data ->
-                        data.is404
-            )
-        |> Maybe.withDefault True
-
-
-notFoundReason :
-    ContentCache
-    -> { currentUrl : Url, basePath : List String }
-    -> Maybe Pages.Internal.NotFoundReason.Payload
-notFoundReason dict urls =
-    dict
-        |> Dict.get (pathForUrl urls)
-        |> Maybe.map
-            (\entry ->
-                case entry of
-                    Parsed data ->
-                        data.notFoundReason
-            )
-        |> Maybe.withDefault Nothing