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

package/src/ApiRoute.elm

@@ -11,9 +11,6 @@ module ApiRoute exposing
 to a DataSource so you can pull in HTTP data, etc. Because ApiRoutes don't hydrate into Elm apps (like pages in elm-pages do), you can pull in as much data as you want in
 the DataSource for your ApiRoutes, and it won't effect the payload size. Instead, the size of an ApiRoute is just the content you output for that route.
 
-In a future release, ApiRoutes may be able to run at request-time in a serverless function, allowing you to use pure Elm code to create dynamic APIs, and even pulling in data from
-DataSources dynamically.
-
 @docs ApiRoute, ApiRouteBuilder, Response
 
 @docs capture, literal, slash, succeed

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