elm-pages 2.1.7 → 2.1.11

package/src/Pages/ContentCache.elm

@@ -0,0 +1,248 @@
+module Pages.ContentCache exposing
+    ( ContentCache
+    , ContentJson
+    , Entry(..)
+    , Path
+    , contentJsonDecoder
+    , init
+    , is404
+    , lazyLoad
+    , notFoundReason
+    , 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
+        |> String.chopForwardSlashes
+        |> 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

package/src/Pages/Flags.elm

@@ -0,0 +1,26 @@
+module Pages.Flags exposing (Flags(..))
+
+{-|
+
+@docs Flags
+
+-}
+
+import Json.Decode
+
+
+{-| elm-pages apps run in two different contexts
+
+1.  In the browser (like a regular Elm app)
+2.  In pre-render mode. For example when you run `elm-pages build`, there is no browser involved, it just runs Elm directly.
+
+You can pass in Flags and use them in your `Shared.init` function. You can store data in your `Shared.Model` from these flags and then access it across any page.
+
+You will need to handle the `PreRender` case with no flags value because there is no browser to get flags from. For example, say you wanted to get the
+current user's Browser window size and pass it in as a flag. When that page is pre-rendered, you need to decide on a value to use for the window size
+since there is no window (the user hasn't requested the page yet, and the page isn't even loaded in a Browser window yet).
+
+-}
+type Flags
+    = BrowserFlags Json.Decode.Value
+    | PreRenderFlags

package/src/Pages/Http.elm

@@ -0,0 +1,10 @@
+module Pages.Http exposing (Error(..))
+
+import Http
+
+
+type Error
+    = BadUrl String
+    | Timeout
+    | NetworkError
+    | BadStatus Http.Metadata String

package/src/Pages/Internal/ApplicationType.elm

@@ -0,0 +1,6 @@
+module Pages.Internal.ApplicationType exposing (ApplicationType(..))
+
+
+type ApplicationType
+    = Browser
+    | Cli

package/src/Pages/Internal/NotFoundReason.elm

@@ -0,0 +1,256 @@
+module Pages.Internal.NotFoundReason exposing (codec, ModuleContext, NotFoundReason(..), Payload, Record, document)
+
+{-| Exposed for internal use only (used in generated code).
+
+@docs codec, ModuleContext, NotFoundReason, Payload, Record, document
+
+-}
+
+import Codec exposing (Codec)
+import Html exposing (Html)
+import Html.Attributes as Attr
+import Pages.Internal.RoutePattern exposing (RoutePattern)
+import Path exposing (Path)
+
+
+{-| -}
+type alias ModuleContext =
+    { moduleName : List String
+    , routePattern : RoutePattern
+    , matchedRouteParams : Record
+    }
+
+
+{-| -}
+type alias Payload =
+    { path : Path
+    , reason : NotFoundReason
+    }
+
+
+{-| -}
+type alias Record =
+    List ( String, String )
+
+
+{-| -}
+type NotFoundReason
+    = NoMatchingRoute
+    | NotPrerendered ModuleContext (List Record)
+    | NotPrerenderedOrHandledByFallback ModuleContext (List Record)
+    | UnhandledServerRoute ModuleContext
+
+
+{-| -}
+document :
+    List RoutePattern
+    -> Payload
+    -> { title : String, body : Html msg }
+document pathPatterns payload =
+    { title = "Page not found"
+    , body =
+        Html.div
+            [ Attr.id "not-found-reason"
+            , Attr.style "padding" "30px"
+            ]
+            (case payload.reason of
+                NoMatchingRoute ->
+                    [ Html.text <| "No route found for "
+                    , Html.code []
+                        [ Html.text
+                            (payload.path
+                                |> Path.toAbsolute
+                            )
+                        ]
+                    , Html.text " Did you mean to go to one of these routes:"
+                    , Html.ul
+                        [ Attr.style "padding-top" "30px"
+                        ]
+                        (pathPatterns
+                            |> List.map
+                                (\route ->
+                                    Html.li
+                                        [ Attr.style "list-style" "inside"
+                                        ]
+                                        [ route
+                                            |> Pages.Internal.RoutePattern.view
+                                        ]
+                                )
+                        )
+                    ]
+
+                NotPrerendered moduleContext routes ->
+                    [ Html.h1 []
+                        [ Html.text "Page Not Found"
+                        ]
+                    , Html.code []
+                        [ Html.text
+                            (payload.path
+                                |> Path.toAbsolute
+                            )
+                        ]
+                    , Html.text " successfully matched the route "
+                    , Html.br [] []
+                    , Html.br [] []
+                    , Html.code []
+                        [ Pages.Internal.RoutePattern.view moduleContext.routePattern
+                        ]
+                    , Html.br [] []
+                    , Html.br [] []
+                    , Html.text " from the Page Module "
+                    , Html.br [] []
+                    , Html.br [] []
+                    , Html.code []
+                        [ Html.text (moduleName moduleContext)
+                        ]
+                    , prerenderedOptionsView moduleContext routes
+                    ]
+
+                _ ->
+                    [ Html.text "Page not found"
+                    , Html.text <| "TODO"
+                    ]
+            )
+    }
+
+
+prerenderedOptionsView : ModuleContext -> List Record -> Html msg
+prerenderedOptionsView moduleContext routes =
+    case routes of
+        [] ->
+            Html.div []
+                [ Html.br [] []
+                , Html.text "But this Page module has no pre-rendered routes! If you want to pre-render this page, add these "
+                , Html.code [] [ Html.text "RouteParams" ]
+                , Html.text " to the module's "
+                , Html.code [] [ Html.text "routes" ]
+                , Html.br [] []
+                , Html.br [] []
+                , Html.code
+                    [ Attr.style "border-bottom" "dotted 2px"
+                    , Attr.style "font-weight" "bold"
+                    ]
+                    [ Html.text <| recordToString moduleContext.matchedRouteParams
+                    ]
+                ]
+
+        _ ->
+            Html.div []
+                [ Html.br [] []
+                , Html.br [] []
+                , Html.text " but these RouteParams were not present "
+                , Html.br [] []
+                , Html.br [] []
+                , Html.code
+                    [ Attr.style "border-bottom" "dotted 2px"
+                    , Attr.style "font-weight" "bold"
+                    ]
+                    [ Html.text <| recordToString moduleContext.matchedRouteParams
+                    ]
+                , Html.br [] []
+                , Html.br [] []
+                , Html.text "The following RouteParams are pre-rendered:"
+                , Html.ul
+                    [ Attr.style "padding-top" "30px"
+                    ]
+                    (routes
+                        |> List.map
+                            (\record ->
+                                Html.li
+                                    [ Attr.style "list-style" "inside"
+                                    ]
+                                    [ --Html.a
+                                      --    [-- Attr.href "/blog/extensible-markdown-parsing-in-elm"
+                                      --     -- TODO get href data
+                                      --    ]
+                                      --    [
+                                      Html.code
+                                        []
+                                        [ Html.text (recordToString record)
+                                        ]
+
+                                    --]
+                                    ]
+                            )
+                    )
+                , Html.br [] []
+                , Html.br [] []
+                , Html.p []
+                    [ Html.text "Try changing "
+                    , Html.code [] [ Html.text "routes" ]
+                    , Html.text " in "
+                    , Html.code [] [ Html.text (moduleName moduleContext) ]
+                    , Html.text " to make sure it includes these "
+                    , Html.code [] [ Html.text "RouteParams" ]
+                    , Html.text "."
+                    ]
+                ]
+
+
+{-| -}
+codec : Codec Payload
+codec =
+    Codec.object Payload
+        |> Codec.field "path"
+            .path
+            (Codec.list Codec.string
+                |> Codec.map Path.join Path.toSegments
+            )
+        |> Codec.field "reason" .reason reasonCodec
+        |> Codec.buildObject
+
+
+reasonCodec : Codec NotFoundReason
+reasonCodec =
+    Codec.custom
+        (\vNoMatchingRoute vNotPrerendered vNotPrerenderedOrHandledByFallback vUnhandledServerRoute value ->
+            case value of
+                NoMatchingRoute ->
+                    vNoMatchingRoute
+
+                NotPrerendered moduleContext prerenderedRoutes ->
+                    vNotPrerendered moduleContext prerenderedRoutes
+
+                NotPrerenderedOrHandledByFallback moduleContext prerenderedRoutes ->
+                    vNotPrerenderedOrHandledByFallback moduleContext prerenderedRoutes
+
+                UnhandledServerRoute moduleContext ->
+                    vUnhandledServerRoute moduleContext
+        )
+        |> Codec.variant0 "NoMatchingRoute" NoMatchingRoute
+        |> Codec.variant2 "NotPrerendered" NotPrerendered moduleContextCodec (Codec.list recordCodec)
+        |> Codec.variant2 "NotPrerenderedOrHandledByFallback" NotPrerenderedOrHandledByFallback moduleContextCodec (Codec.list recordCodec)
+        |> Codec.variant1 "UnhandledServerRoute" UnhandledServerRoute moduleContextCodec
+        |> Codec.buildCustom
+
+
+moduleContextCodec : Codec ModuleContext
+moduleContextCodec =
+    Codec.object ModuleContext
+        |> Codec.field "moduleName" .moduleName (Codec.list Codec.string)
+        |> Codec.field "routePattern" .routePattern Pages.Internal.RoutePattern.codec
+        |> Codec.field "matchedRouteParams" .matchedRouteParams recordCodec
+        |> Codec.buildObject
+
+
+recordCodec : Codec (List ( String, String ))
+recordCodec =
+    Codec.list (Codec.tuple Codec.string Codec.string)
+
+
+recordToString : List ( String, String ) -> String
+recordToString fields =
+    "{ "
+        ++ (fields
+                |> List.map
+                    (\( key, value ) ->
+                        key ++ " = " ++ value
+                    )
+                |> String.join ", "
+           )
+        ++ " }"
+
+
+moduleName : ModuleContext -> String
+moduleName moduleContext =
+    ("src" :: moduleContext.moduleName |> String.join "/") ++ ".elm"