elm-pages 3.0.0-beta.1 → 3.0.0-beta.10

package/src/DataSource/File.elm

@@ -171,7 +171,7 @@ just the metadata.
             (Decode.field "tags" (Decode.list Decode.string))
 
 If you wanted to use this to get this metadata for all blog posts in a folder, you could use
-the [`DataSource`](DataSource) API along with [`DataSource.Glob`](DataSource.Glob).
+the [`DataSource`](DataSource) API along with [`DataSource.Glob`](DataSource-Glob).
 
     import DataSource exposing (DataSource)
     import DataSource.File as File

package/src/DataSource/Internal/Request.elm

@@ -1,10 +1,5 @@
 module DataSource.Internal.Request exposing (request)
 
-{-| Build a `DataSource.Http` request (analogous to [Http.request](https://package.elm-lang.org/packages/elm/http/latest/Http#request)).
-This function takes in all the details to build a `DataSource.Http` request, but you can build your own simplified helper functions
-with this as a low-level detail, or you can use functions like [DataSource.Http.get](#get).
--}
-
 import DataSource exposing (DataSource)
 import DataSource.Http exposing (Body, Expect)
 

package/src/DataSource.elm

@@ -7,7 +7,7 @@ module DataSource exposing
     , map2, map3, map4, map5, map6, map7, map8, map9
     )
 
-{-| In an `elm-pages` app, each page can define a value `data` which is a `DataSource` that will be resolved **before** `init` is called. That means it is also available
+{-| In an `elm-pages` app, each Route Module can define a value `data` which is a `DataSource` that will be resolved **before** `init` is called. That means it is also available
 when the page's HTML is pre-rendered during the build step. You can also access the resolved data in `head` to use it for the page's SEO meta tags.
 
 A `DataSource` lets you pull in data from:
@@ -20,9 +20,17 @@ A `DataSource` lets you pull in data from:
   - Or any combination of the above, using `DataSource.map2`, `DataSource.andThen`, or other combining/continuing helpers from this module
 
 
-## Where Does DataSource Data Come From?
+## DataSource's vs. Effect's/Cmd's
 
-Data from a `DataSource` is resolved when you load a page in the `elm-pages` dev server, or when you run `elm-pages build`.
+DataSource's are always resolved before the page is rendered and sent to the browser. A DataSource is never executed
+in the Browser. Instead, the resolved data from the DataSource is passed down to the Browser - it has been resolved
+before any client-side JavaScript ever executes. In the case of a pre-rendered route, this is during the CLI build phase,
+and for server-rendered routes its DataSource is resolved on the server.
+
+Effect's/Cmd's are never executed on the CLI or server, they are only executed in the Browser. The data from a Route Module's
+`init` function is used to render the initial HTML on the server or build step, but the Effect isn't executed and `update` is never called
+before the page is hydrated in the Browser. This gives a deterministic mental model of what the first render will look like,
+and a nicely typed way to define the initial `Data` you have to render your initial view.
 
 Because `elm-pages` hydrates into a full Elm single-page app, it does need the data in order to initialize the Elm app.
 So why not just get the data the old-fashioned way, with `elm/http`, for example?
@@ -123,16 +131,16 @@ A common use for this is to map your data into your elm-pages view:
 map : (a -> b) -> DataSource a -> DataSource b
 map fn requestInfo =
     case requestInfo of
-        RequestError error ->
-            RequestError error
+        ApiRoute value ->
+            ApiRoute (fn value)
 
         Request urls lookupFn ->
             Request
                 urls
                 (mapLookupFn fn lookupFn)
 
-        ApiRoute value ->
-            ApiRoute (fn value)
+        RequestError error ->
+            RequestError error
 
 
 mapLookupFn : (a -> b) -> (d -> c -> DataSource a) -> d -> c -> DataSource b
@@ -182,8 +190,8 @@ resolve =
 
 -}
 combine : List (DataSource value) -> DataSource (List value)
-combine =
-    List.foldr (map2 (::)) (succeed [])
+combine items =
+    List.foldl (map2 (::)) (succeed []) items |> map List.reverse
 
 
 {-| Like map, but it takes in two `Request`s.
@@ -212,11 +220,8 @@ combine =
 map2 : (a -> b -> c) -> DataSource a -> DataSource b -> DataSource c
 map2 fn request1 request2 =
     case ( request1, request2 ) of
-        ( RequestError error, _ ) ->
-            RequestError error
-
-        ( _, RequestError error ) ->
-            RequestError error
+        ( ApiRoute value1, ApiRoute value2 ) ->
+            ApiRoute (fn value1 value2)
 
         ( Request urls1 lookupFn1, Request urls2 lookupFn2 ) ->
             Request
@@ -233,8 +238,11 @@ map2 fn request1 request2 =
                 urls1
                 (mapReq fn (\_ _ -> ApiRoute value2) lookupFn1)
 
-        ( ApiRoute value1, ApiRoute value2 ) ->
-            ApiRoute (fn value1 value2)
+        ( RequestError error, _ ) ->
+            RequestError error
+
+        ( _, RequestError error ) ->
+            RequestError error
 
 
 mapReq : (a -> b -> c) -> (e -> d -> DataSource a) -> (e -> d -> DataSource b) -> e -> d -> DataSource c
@@ -247,9 +255,6 @@ mapReq fn lookupFn1 lookupFn2 maybeMock rawResponses =
 lookup : Maybe Pages.StaticHttpRequest.MockResolver -> DataSource value -> RequestsAndPending -> Result Pages.StaticHttpRequest.Error value
 lookup maybeMockResolver requestInfo rawResponses =
     case requestInfo of
-        RequestError error ->
-            Err error
-
         Request urls lookupFn ->
             lookup maybeMockResolver
                 (addUrls urls (lookupFn maybeMockResolver rawResponses))
@@ -258,18 +263,21 @@ lookup maybeMockResolver requestInfo rawResponses =
         ApiRoute value ->
             Ok value
 
+        RequestError error ->
+            Err error
+
 
 addUrls : List HashRequest.Request -> DataSource value -> DataSource value
 addUrls urlsToAdd requestInfo =
     case requestInfo of
-        RequestError error ->
-            RequestError error
+        ApiRoute value ->
+            ApiRoute value
 
         Request initialUrls function ->
             Request (initialUrls ++ urlsToAdd) function
 
-        ApiRoute value ->
-            ApiRoute value
+        RequestError error ->
+            RequestError error
 
 
 {-| The full details to perform a StaticHttp request.
@@ -286,14 +294,14 @@ type alias RequestDetails =
 lookupUrls : DataSource value -> List RequestDetails
 lookupUrls requestInfo =
     case requestInfo of
-        RequestError _ ->
-            -- TODO should this have URLs passed through?
+        ApiRoute _ ->
             []
 
         Request urls _ ->
             urls
 
-        ApiRoute _ ->
+        RequestError _ ->
+            -- TODO should this have URLs passed through?
             []
 
 
@@ -324,19 +332,19 @@ andThen fn requestInfo =
                 rawResponses
                 |> (\result ->
                         case result of
-                            Err error ->
-                                RequestError error
-
                             Ok value ->
                                 case fn value of
+                                    ApiRoute finalValue ->
+                                        ApiRoute finalValue
+
                                     Request values function ->
                                         Request values function
 
                                     RequestError error ->
                                         RequestError error
 
-                                    ApiRoute finalValue ->
-                                        ApiRoute finalValue
+                            Err error ->
+                                RequestError error
                    )
         )
 

package/src/Form/Field.elm

@@ -6,7 +6,7 @@ module Form.Field exposing
     , required, withClientValidation, withInitialValue, map
     , email, password, search, telephone, url, textarea
     , withMax, withMin, withStep, withMinLength, withMaxLength
-    , No(..), Yes(..)
+    , No, Yes
     )
 
 {-|

package/src/Form.elm

@@ -575,7 +575,7 @@ field name (Field fieldParser kind) (Form definitions parseFn toInitialValues) =
 
 {-| Declare a hidden field for the form.
 
-Unlike [`field`](#field) declarations which are rendered using [`Form.ViewField`](Form-ViewField)
+Unlike [`field`](#field) declarations which are rendered using [`Form.FieldView`](Form-FieldView)
 functions, `hiddenField` inputs are automatically inserted into the form when you render it.
 
 You define the field's validations the same way as for `field`, with the

package/src/Head/Seo.elm

@@ -49,10 +49,12 @@ with the `head` function that you pass to your Pages config (`Pages.application`
 
 -}
 
+import DateOrDateTime exposing (DateOrDateTime)
 import Head
 import Head.Twitter as Twitter
 import LanguageTag.Country
 import LanguageTag.Language
+import MimeType exposing (MimeType)
 import Pages.Url
 
 
@@ -235,9 +237,9 @@ website common =
 article :
     { tags : List String
     , section : Maybe String
-    , publishedTime : Maybe Iso8601DateTime
-    , modifiedTime : Maybe Iso8601DateTime
-    , expirationTime : Maybe Iso8601DateTime
+    , publishedTime : Maybe DateOrDateTime
+    , modifiedTime : Maybe DateOrDateTime
+    , expirationTime : Maybe DateOrDateTime
     }
     -> Common
     -> List Head.Tag
@@ -252,7 +254,7 @@ book :
     ->
         { tags : List String
         , isbn : Maybe String
-        , releaseDate : Maybe Iso8601DateTime
+        , releaseDate : Maybe DateOrDateTime
         }
     -> List Head.Tag
 book common details =
@@ -354,7 +356,7 @@ tagsForAudio : Audio -> List ( String, Maybe Head.AttributeValue )
 tagsForAudio audio =
     [ ( "og:audio", audio.url |> Head.raw |> Just )
     , ( "og:audio:secure_url", audio.url |> Head.raw |> Just )
-    , ( "og:audio:type", audio.mimeType |> Maybe.map Head.raw )
+    , ( "og:audio:type", audio.mimeType |> Maybe.map (MimeType.toString >> Head.raw) )
     ]
 
 
@@ -371,14 +373,14 @@ type ContentDetails
     | Article
         { tags : List String
         , section : Maybe String
-        , publishedTime : Maybe Iso8601DateTime
-        , modifiedTime : Maybe Iso8601DateTime
-        , expirationTime : Maybe Iso8601DateTime
+        , publishedTime : Maybe DateOrDateTime
+        , modifiedTime : Maybe DateOrDateTime
+        , expirationTime : Maybe DateOrDateTime
         }
     | Book
         { tags : List String
         , isbn : Maybe String
-        , releaseDate : Maybe Iso8601DateTime
+        , releaseDate : Maybe DateOrDateTime
         }
     | Song
         {-
@@ -399,20 +401,6 @@ type ContentDetails
         }
 
 
-{-| <https://en.wikipedia.org/wiki/ISO_8601>
--}
-type alias Iso8601DateTime =
-    -- TODO should be more type-safe here
-    String
-
-
-{-| <https://en.wikipedia.org/wiki/Media_type>
--}
-type alias MimeType =
-    -- TODO should be more type-safe here
-    String
-
-
 {-| See <https://ogp.me/#structured>
 -}
 type alias Image =
@@ -448,6 +436,7 @@ tagsForVideo video =
     , ( "og:video:secure_url", video.url |> Head.raw |> Just )
     , ( "og:video:width", video.dimensions |> Maybe.map .width |> Maybe.map String.fromInt |> Maybe.map Head.raw )
     , ( "og:video:height", video.dimensions |> Maybe.map .height |> Maybe.map String.fromInt |> Maybe.map Head.raw )
+    , ( "og:video:type", video.mimeType |> Maybe.map (MimeType.toString >> Head.raw) )
     ]
 
 
@@ -466,9 +455,9 @@ tags (Content common details) =
                     -}
                     [ ( "og:type", "article" |> Head.raw |> Just )
                     , ( "article:section", articleDetails.section |> Maybe.map Head.raw )
-                    , ( "article:published_time", articleDetails.publishedTime |> Maybe.map Head.raw )
-                    , ( "article:modified_time", articleDetails.modifiedTime |> Maybe.map Head.raw )
-                    , ( "article:expiration_time", articleDetails.expirationTime |> Maybe.map Head.raw )
+                    , ( "article:published_time", articleDetails.publishedTime |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
+                    , ( "article:modified_time", articleDetails.modifiedTime |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
+                    , ( "article:expiration_time", articleDetails.expirationTime |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
                     ]
                         ++ List.map
                             (\tag -> ( "article:tag", tag |> Head.raw |> Just ))
@@ -477,7 +466,7 @@ tags (Content common details) =
                 Book bookDetails ->
                     [ ( "og:type", "book" |> Head.raw |> Just )
                     , ( "og:isbn", bookDetails.isbn |> Maybe.map Head.raw )
-                    , ( "og:release_date", bookDetails.releaseDate |> Maybe.map Head.raw )
+                    , ( "og:release_date", bookDetails.releaseDate |> Maybe.map (DateOrDateTime.toIso8601 >> Head.raw) )
                     ]
                         ++ List.map
                             (\tag -> ( "book:tag", tag |> Head.raw |> Just ))

package/src/Head.elm

@@ -1,6 +1,7 @@
 module Head exposing
     ( Tag, metaName, metaProperty, metaRedirect
     , rssLink, sitemapLink, rootLanguage, manifestLink
+    , nonLoadingNode
     , structuredData
     , AttributeValue
     , currentPageFullUrl, urlAttribute, raw
@@ -20,6 +21,8 @@ writing a plugin package to extend `elm-pages`.
 @docs Tag, metaName, metaProperty, metaRedirect
 @docs rssLink, sitemapLink, rootLanguage, manifestLink
 
+@docs nonLoadingNode
+
 
 ## Structured Data
 
@@ -45,9 +48,11 @@ writing a plugin package to extend `elm-pages`.
 
 import Json.Encode
 import LanguageTag exposing (LanguageTag)
+import List.Extra
 import MimeType
 import Pages.Internal.String as String
 import Pages.Url
+import Regex
 
 
 {-| Values that can be passed to the generated `Pages.application` config
@@ -57,6 +62,7 @@ type Tag
     = Tag Details
     | StructuredData Json.Encode.Value
     | RootModifier String String
+    | Stripped String
 
 
 type alias Details =
@@ -211,6 +217,120 @@ canonicalLink maybePath =
         ]
 
 
+{-| Escape hatch for any head tags that don't have high-level helpers. This lets you build arbitrary head nodes as long as they
+are not loading or preloading directives.
+
+Tags that do loading/pre-loading will not work from this function. `elm-pages` uses ViteJS for loading assets like
+script tags, stylesheets, fonts, etc., and allows you to customize which assets to preload and how through the elm-pages.config.mjs file.
+See the full discussion of the design in [#339](https://github.com/dillonkearns/elm-pages/discussions/339).
+
+So for example the following tags would _not_ load if defined through `nonLoadingNode`, and would instead need to be registered through Vite:
+
+  - `<script src="...">`
+  - `<link href="/style.css">`
+  - `<link rel="preload">`
+
+The following tag would successfully render as it is a non-loading tag:
+
+    Head.nonLoadingNode "link"
+        [ ( "rel", Head.raw "alternate" )
+        , ( "type", Head.raw "application/atom+xml" )
+        , ( "title", Head.raw "News" )
+        , ( "href", Head.raw "/news/atom" )
+        ]
+
+Renders the head tag:
+
+`<link rel="alternate" type="application/atom+xml" title="News" href="/news/atom">`
+
+-}
+nonLoadingNode : String -> List ( String, AttributeValue ) -> Tag
+nonLoadingNode nodeName attributes =
+    let
+        relTag : Maybe AttributeValue
+        relTag =
+            attributes
+                |> List.Extra.find (\( key, _ ) -> key == "rel")
+                |> Maybe.map Tuple.second
+
+        isPreloadDirective : Bool
+        isPreloadDirective =
+            case relTag of
+                Just (Raw rel) ->
+                    let
+                        isLinkTag : Bool
+                        isLinkTag =
+                            nodeName |> matchesKeyword "link"
+                    in
+                    isLinkTag
+                        && (rel
+                                |> matchesOneKeyword
+                                    [ "preload"
+                                    , "modulepreload"
+                                    , "preconnect"
+                                    , "dns-prefetch"
+                                    , "stylesheet"
+                                    ]
+                           )
+
+                _ ->
+                    False
+    in
+    if
+        (nodeName |> matchesKeyword "script")
+            || isPreloadDirective
+    then
+        Stripped
+            ("<"
+                ++ nodeName
+                ++ " "
+                ++ (attributes
+                        |> List.map
+                            (\( name, value ) ->
+                                name
+                                    ++ "=\""
+                                    ++ ((case value of
+                                            Raw rawValue ->
+                                                rawValue
+
+                                            _ ->
+                                                "<internals>"
+                                        )
+                                            ++ "\""
+                                       )
+                            )
+                        |> String.join " "
+                   )
+                ++ " />"
+            )
+
+    else
+        node nodeName attributes
+
+
+matchesOneKeyword : List String -> String -> Bool
+matchesOneKeyword keywords string =
+    List.any
+        (\keyword -> string |> matchesKeyword keyword)
+        keywords
+
+
+matchesKeyword : String -> String -> Bool
+matchesKeyword regex string =
+    string |> matchesRegex ("^\\s*" ++ regex ++ "\\s*$")
+
+
+matchesRegex : String -> String -> Bool
+matchesRegex regex string =
+    string
+        |> Regex.contains
+            (Regex.fromStringWith
+                { caseInsensitive = True, multiline = True }
+                regex
+                |> Maybe.withDefault Regex.never
+            )
+
+
 {-| 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
@@ -443,6 +563,12 @@ toJson canonicalSiteUrl currentPagePath tag =
                 , ( "keyValuePair", Json.Encode.list Json.Encode.string [ key, value ] )
                 ]
 
+        Stripped message ->
+            Json.Encode.object
+                [ ( "type", Json.Encode.string "stripped" )
+                , ( "message", Json.Encode.string message )
+                ]
+
 
 encodeProperty : String -> String -> ( String, AttributeValue ) -> Json.Encode.Value
 encodeProperty canonicalSiteUrl currentPagePath ( name, value ) =

package/src/HtmlPrinter.elm

@@ -8,15 +8,19 @@ import Test.Html.Internal.ElmHtml.ToString exposing (defaultFormatOptions, nodeT
 import VirtualDom
 
 
-htmlToString : Html msg -> String
-htmlToString viewHtml =
+htmlToString : Maybe { indent : Int, newLines : Bool } -> Html msg -> String
+htmlToString formatOptions viewHtml =
     case
         Decode.decodeValue
             (decodeElmHtml (\_ _ -> VirtualDom.Normal (Decode.succeed ())))
             (asJsonView viewHtml)
     of
         Ok str ->
-            nodeToStringWithOptions defaultFormatOptions str
+            nodeToStringWithOptions
+                (formatOptions
+                    |> Maybe.withDefault defaultFormatOptions
+                )
+                str
 
         Err err ->
             "Error pre-rendering HTML in HtmlPrinter.elm: " ++ Decode.errorToString err