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

package/src/Pages/Generate.elm

@@ -1,8 +1,28 @@
-module Pages.Generate exposing (Type(..), serverRender, buildWithLocalState, buildNoState, Builder)
+module Pages.Generate exposing
+    ( buildWithLocalState, buildWithSharedState, buildNoState, Builder
+    , Type(..)
+    , serverRender
+    , preRender, single
+    )
 
 {-|
 
-@docs Type, serverRender, buildWithLocalState, buildNoState, Builder
+
+## Initializing the Generator Builder
+
+@docs buildWithLocalState, buildWithSharedState, buildNoState, Builder
+
+@docs Type
+
+
+## Generating Server-Rendered Pages
+
+@docs serverRender
+
+
+## Generating pre-rendered pages
+
+@docs preRender, single
 
 -}
 
@@ -30,12 +50,18 @@ typeToDeclaration name type_ =
 
 {-| -}
 type Builder
-    = Builder
+    = ServerRender
         { data : ( Type, Elm.Expression -> Elm.Expression )
         , action : ( Type, Elm.Expression -> Elm.Expression )
         , head : Elm.Expression -> Elm.Expression
         , moduleName : List String
         }
+    | PreRender
+        { data : ( Type, Elm.Expression -> Elm.Expression )
+        , pages : Maybe Elm.Expression
+        , head : Elm.Expression -> Elm.Expression
+        , moduleName : List String
+        }
 
 
 {-| -}
@@ -47,7 +73,56 @@ serverRender :
     }
     -> Builder
 serverRender =
-    Builder
+    ServerRender
+
+
+{-| -}
+preRender :
+    { data : ( Type, Elm.Expression -> Elm.Expression )
+    , pages : Elm.Expression
+    , head : Elm.Expression -> Elm.Expression
+    , moduleName : List String
+    }
+    -> 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
+                    (Elm.Annotation.namedWith [ "DataSource" ]
+                        "DataSource"
+                        [ Elm.Annotation.list <| Elm.Annotation.named [] "RouteParams"
+                        ]
+                    )
+                |> Just
+        , head = input.head
+        , moduleName = input.moduleName
+        }
+
+
+{-| -}
+single :
+    { data : ( Type, Elm.Expression )
+    , head : Elm.Expression -> Elm.Expression
+    , moduleName : List String
+    }
+    -> Builder
+single input =
+    PreRender
+        { data = ( Tuple.first input.data, \_ -> Tuple.second input.data )
+        , pages = Nothing
+        , head = input.head
+        , moduleName = input.moduleName
+        }
 
 
 {-| -}
@@ -56,20 +131,42 @@ buildNoState :
     }
     -> Builder
     -> Elm.File
-buildNoState definitions (Builder builder) =
-    userFunction builder.moduleName
-        { view = \_ -> definitions.view
-        , localState = Nothing
-        , data = builder.data |> Tuple.second
-        , action = builder.action |> Tuple.second
-        , head = builder.head
-        , types =
-            { model = Alias (Elm.Annotation.record [])
-            , msg = Alias Elm.Annotation.unit
-            , data = builder.data |> Tuple.first
-            , actionData = builder.action |> Tuple.first
-            }
-        }
+buildNoState definitions builder_ =
+    case builder_ of
+        ServerRender builder ->
+            userFunction builder.moduleName
+                { view = \_ -> definitions.view
+                , localState = Nothing
+                , data = builder.data |> Tuple.second
+                , action = builder.action |> Tuple.second |> Action
+                , head = builder.head
+                , types =
+                    { model = Alias (Elm.Annotation.record [])
+                    , msg = Alias Elm.Annotation.unit
+                    , data = builder.data |> Tuple.first
+                    , actionData = builder.action |> Tuple.first
+                    }
+                }
+
+        PreRender builder ->
+            userFunction builder.moduleName
+                { view = \_ -> definitions.view
+                , localState = Nothing
+                , data = builder.data |> Tuple.second
+                , action = builder.pages |> Pages
+                , head = builder.head
+                , types =
+                    { model = Alias (Elm.Annotation.record [])
+                    , msg = Alias Elm.Annotation.unit
+                    , data = builder.data |> Tuple.first
+                    , actionData =
+                        Elm.Annotation.namedWith [ "DataSource" ]
+                            "DataSource"
+                            [ Elm.Annotation.list (Elm.Annotation.named [] "RouteParams")
+                            ]
+                            |> Alias
+                    }
+                }
 
 
 {-| -}
@@ -83,25 +180,125 @@ buildWithLocalState :
     }
     -> Builder
     -> Elm.File
-buildWithLocalState definitions (Builder builder) =
-    userFunction builder.moduleName
-        { view = definitions.view
-        , localState =
-            Just
-                { update = definitions.update
-                , init = definitions.init
-                , subscriptions = definitions.subscriptions
+buildWithLocalState definitions builder_ =
+    case builder_ of
+        ServerRender builder ->
+            userFunction builder.moduleName
+                { view = definitions.view
+                , localState =
+                    Just
+                        { update = definitions.update
+                        , init = definitions.init
+                        , subscriptions = definitions.subscriptions
+                        , state = LocalState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.action |> Tuple.second |> Action
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData = builder.action |> Tuple.first
+                    }
+                }
+
+        PreRender builder ->
+            userFunction builder.moduleName
+                { view = definitions.view
+                , localState =
+                    Just
+                        { update = definitions.update
+                        , init = definitions.init
+                        , subscriptions = definitions.subscriptions
+                        , state = LocalState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.pages |> Pages
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData =
+                        Elm.Annotation.namedWith [ "DataSource" ]
+                            "DataSource"
+                            [ Elm.Annotation.list (Elm.Annotation.named [] "RouteParams")
+                            ]
+                            |> Alias
+                    }
+                }
+
+
+{-| -}
+buildWithSharedState :
+    { view : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    , update : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    , init : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    , subscriptions : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    , msg : Type
+    , model : Type
+    }
+    -> Builder
+    -> Elm.File
+buildWithSharedState definitions builder_ =
+    case builder_ of
+        ServerRender builder ->
+            userFunction builder.moduleName
+                { view = definitions.view
+                , localState =
+                    Just
+                        { update = definitions.update
+                        , init = definitions.init
+                        , subscriptions = definitions.subscriptions
+                        , state = SharedState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.action |> Tuple.second |> Action
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData = builder.action |> Tuple.first
+                    }
                 }
-        , data = builder.data |> Tuple.second
-        , action = builder.action |> Tuple.second
-        , head = builder.head
-        , types =
-            { model = definitions.model
-            , msg = definitions.msg
-            , data = builder.data |> Tuple.first
-            , actionData = builder.action |> Tuple.first
-            }
-        }
+
+        PreRender builder ->
+            userFunction builder.moduleName
+                { view = definitions.view
+                , localState =
+                    Just
+                        { update = definitions.update
+                        , init = definitions.init
+                        , subscriptions = definitions.subscriptions
+                        , state = SharedState
+                        }
+                , data = builder.data |> Tuple.second
+                , action = builder.pages |> Pages
+                , head = builder.head
+                , types =
+                    { model = definitions.model
+                    , msg = definitions.msg
+                    , data = builder.data |> Tuple.first
+                    , actionData =
+                        Elm.Annotation.namedWith [ "DataSource" ]
+                            "DataSource"
+                            [ Elm.Annotation.list (Elm.Annotation.named [] "RouteParams")
+                            ]
+                            |> Alias
+                    }
+                }
+
+
+type State
+    = SharedState
+    | LocalState
+
+
+type ActionOrPages
+    = Action (Elm.Expression -> Elm.Expression)
+    | Pages (Maybe Elm.Expression)
 
 
 {-| -}
@@ -114,9 +311,10 @@ userFunction :
                 { update : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
                 , init : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
                 , subscriptions : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
+                , state : State
                 }
         , data : Elm.Expression -> Elm.Expression
-        , action : Elm.Expression -> Elm.Expression
+        , action : ActionOrPages
         , head : Elm.Expression -> Elm.Expression
         , types : { model : Type, msg : Type, data : Type, actionData : Type }
         }
@@ -180,6 +378,7 @@ userFunction moduleName definitions =
                     }
                 , initFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression }
                 , subscriptionsFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression }
+                , state : State
                 }
         localDefinitions =
             definitions.localState
@@ -222,28 +421,88 @@ userFunction moduleName definitions =
                                 ( "sharedModel", Nothing )
                                 ( "model", Nothing )
                                 localState.subscriptions
+                        , state = localState.state
                         }
                     )
 
-        dataFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression }
+        dataFn : { declaration : Elm.Declaration, call : List Elm.Expression -> Elm.Expression, callFrom : List String -> List Elm.Expression -> Elm.Expression }
         dataFn =
-            Elm.Declare.fn "data"
-                ( "routeParams"
-                , "RouteParams"
-                    |> Elm.Annotation.named []
-                    |> Just
-                )
-                (definitions.data >> Elm.withType (myType "Data"))
+            case definitions.action of
+                Pages Nothing ->
+                    Elm.Declare.function "data"
+                        []
+                        (\_ ->
+                            definitions.data Elm.unit
+                                |> Elm.withType
+                                    (case definitions.action of
+                                        Pages _ ->
+                                            Elm.Annotation.namedWith [ "DataSource" ]
+                                                "DataSource"
+                                                [ Elm.Annotation.named [] "Data"
+                                                ]
+
+                                        Action _ ->
+                                            myType "Data"
+                                    )
+                        )
 
-        actionFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression }
+                _ ->
+                    Elm.Declare.function "data"
+                        [ ( "routeParams"
+                          , "RouteParams"
+                                |> Elm.Annotation.named []
+                                |> Just
+                          )
+                        ]
+                        (\args ->
+                            case args of
+                                [ arg ] ->
+                                    definitions.data arg
+                                        |> Elm.withType
+                                            (case definitions.action of
+                                                Pages _ ->
+                                                    Elm.Annotation.namedWith [ "DataSource" ]
+                                                        "DataSource"
+                                                        [ 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 }
         actionFn =
-            Elm.Declare.fn "action"
-                ( "routeParams"
-                , "RouteParams"
-                    |> Elm.Annotation.named []
-                    |> Just
-                )
-                (definitions.action >> Elm.withType (myType "ActionData"))
+            case definitions.action of
+                Action action_ ->
+                    Elm.Declare.function "action"
+                        [ ( "routeParams"
+                          , "RouteParams"
+                                |> Elm.Annotation.named []
+                                |> Just
+                          )
+                        ]
+                        (\args ->
+                            case args of
+                                [ arg ] ->
+                                    action_ arg |> Elm.withType (myType "ActionData")
+
+                                _ ->
+                                    Elm.unit
+                        )
+                        |> Just
+
+                Pages pages_ ->
+                    pages_
+                        |> Maybe.map
+                            (\justPagesExpression ->
+                                Elm.Declare.function "pages"
+                                    []
+                                    (\_ -> justPagesExpression)
+                            )
 
         headFn : { declaration : Elm.Declaration, call : Elm.Expression -> Elm.Expression, callFrom : List String -> Elm.Expression -> Elm.Expression }
         headFn =
@@ -268,49 +527,88 @@ userFunction moduleName definitions =
                 )
             )
          , Elm.declaration "route"
-            (serverRender_
-                { action =
-                    \routeParams ->
-                        actionFn.call routeParams
-                            |> Elm.withType (myType "ActionData")
-                , data =
-                    \routeParams ->
-                        dataFn.call routeParams
-                            |> Elm.withType (myType "Data")
-                , head = headFn.call
-                }
-                |> (case localDefinitions of
-                        Just local ->
-                            buildWithLocalState_
-                                { view = viewFn.call
-                                , update = local.updateFn.call
-                                , init = local.initFn.call
-                                , subscriptions = local.subscriptionsFn.call
-                                }
-                                >> Elm.withType
-                                    (Elm.Annotation.namedWith [ "RouteBuilder" ]
-                                        "StatefulRoute"
-                                        [ localType "RouteParams"
-                                        , localType "Data"
-                                        , localType "ActionData"
-                                        , localType "Model"
-                                        , localType "Msg"
-                                        ]
-                                    )
+            (case definitions.action of
+                Action _ ->
+                    serverRender_
+                        { action =
+                            \routeParams ->
+                                actionFn
+                                    |> Maybe.map
+                                        (\justActionFn ->
+                                            justActionFn.call [ routeParams ]
+                                                |> Elm.withType (myType "ActionData")
+                                        )
+                                    |> Maybe.withDefault Elm.unit
+                        , data =
+                            \routeParams ->
+                                dataFn.call [ routeParams ]
+                                    |> Elm.withType (myType "Data")
+                        , head = headFn.call
+                        }
 
+                Pages _ ->
+                    (case actionFn of
                         Nothing ->
-                            buildNoState_
-                                { view = viewFn.call Elm.unit
+                            single_
+                                { data =
+                                    dataFn.call []
+                                        |> Elm.withType
+                                            (Elm.Annotation.namedWith [ "DataSource" ]
+                                                "DataSource"
+                                                [ Elm.Annotation.named [] "Data"
+                                                ]
+                                            )
+                                , head = headFn.call
                                 }
-                                >> Elm.withType
-                                    (Elm.Annotation.namedWith [ "RouteBuilder" ]
-                                        "StatelessRoute"
-                                        [ localType "RouteParams"
-                                        , localType "Data"
-                                        , localType "ActionData"
-                                        ]
-                                    )
-                   )
+
+                        Just justActionFn ->
+                            preRender_
+                                { pages = justActionFn.call []
+                                , data =
+                                    \routeParams ->
+                                        dataFn.call [ routeParams ]
+                                            |> Elm.withType
+                                                (Elm.Annotation.namedWith [ "DataSource" ]
+                                                    "DataSource"
+                                                    [ Elm.Annotation.named [] "Data"
+                                                    ]
+                                                )
+                                , head = headFn.call
+                                }
+                    )
+                        |> (case localDefinitions of
+                                Just local ->
+                                    buildWithLocalState_
+                                        { view = viewFn.call
+                                        , update = local.updateFn.call
+                                        , init = local.initFn.call
+                                        , subscriptions = local.subscriptionsFn.call
+                                        , state = local.state
+                                        }
+                                        >> Elm.withType
+                                            (Elm.Annotation.namedWith [ "RouteBuilder" ]
+                                                "StatefulRoute"
+                                                [ localType "RouteParams"
+                                                , localType "Data"
+                                                , localType "ActionData"
+                                                , localType "Model"
+                                                , localType "Msg"
+                                                ]
+                                            )
+
+                                Nothing ->
+                                    buildNoState_
+                                        { view = viewFn.call Elm.unit
+                                        }
+                                        >> Elm.withType
+                                            (Elm.Annotation.namedWith [ "RouteBuilder" ]
+                                                "StatelessRoute"
+                                                [ localType "RouteParams"
+                                                , localType "Data"
+                                                , localType "ActionData"
+                                                ]
+                                            )
+                           )
             )
          ]
             ++ (case localDefinitions of
@@ -326,10 +624,13 @@ userFunction moduleName definitions =
             ++ [ definitions.types.data |> typeToDeclaration "Data"
                , definitions.types.actionData |> typeToDeclaration "ActionData"
                , dataFn.declaration
-               , actionFn.declaration
                , headFn.declaration
                , viewFn.declaration
                ]
+            ++ ([ actionFn |> Maybe.map .declaration
+                ]
+                    |> List.filterMap identity
+               )
         )
 
 
@@ -463,6 +764,128 @@ serverRender_ serverRenderArg =
         ]
 
 
+preRender_ :
+    { data : Elm.Expression -> Elm.Expression
+    , pages : Elm.Expression
+    , head : Elm.Expression -> Elm.Expression
+    }
+    -> Elm.Expression
+preRender_ serverRenderArg =
+    Elm.apply
+        (Elm.value
+            { importFrom = [ "RouteBuilder" ]
+            , name = "preRender"
+            , annotation =
+                Just
+                    (Elm.Annotation.function
+                        [ Elm.Annotation.record
+                            [ ( "data"
+                              , Elm.Annotation.function
+                                    [ Elm.Annotation.var "routeParams" ]
+                                    (Elm.Annotation.namedWith
+                                        [ "DataSource" ]
+                                        "DataSource"
+                                        [ Elm.Annotation.var "data"
+                                        ]
+                                    )
+                              )
+                            , ( "pages"
+                              , Elm.Annotation.namedWith
+                                    [ "DataSource" ]
+                                    "DataSource"
+                                    [ Elm.Annotation.list (Elm.Annotation.named [] "RouteParams")
+                                    ]
+                              )
+                            , ( "head"
+                              , Elm.Annotation.function
+                                    [ Elm.Annotation.namedWith
+                                        [ "RouteBuilder" ]
+                                        "StaticPayload"
+                                        [ Elm.Annotation.var "data"
+                                        , Elm.Annotation.var "action"
+                                        , Elm.Annotation.var "routeParams"
+                                        ]
+                                    ]
+                                    (Elm.Annotation.list
+                                        (Elm.Annotation.namedWith [ "Head" ] "Tag" [])
+                                    )
+                              )
+                            ]
+                        ]
+                        (Elm.Annotation.namedWith
+                            [ "RouteBuilder" ]
+                            "Builder"
+                            [ Elm.Annotation.named [] "RouteParams"
+                            , Elm.Annotation.named [] "Data"
+                            , Elm.Annotation.named [] "Action"
+                            ]
+                        )
+                    )
+            }
+        )
+        [ Elm.record
+            [ Tuple.pair "data" (Elm.functionReduced "serverRenderUnpack" serverRenderArg.data)
+            , Tuple.pair "pages" serverRenderArg.pages
+            , Tuple.pair "head" (Elm.functionReduced "serverRenderUnpack" serverRenderArg.head)
+            ]
+        ]
+
+
+single_ :
+    { data : Elm.Expression
+    , head : Elm.Expression -> Elm.Expression
+    }
+    -> Elm.Expression
+single_ serverRenderArg =
+    Elm.apply
+        (Elm.value
+            { importFrom = [ "RouteBuilder" ]
+            , name = "single"
+            , annotation =
+                Just
+                    (Elm.Annotation.function
+                        [ Elm.Annotation.record
+                            [ ( "data"
+                              , Elm.Annotation.namedWith
+                                    [ "DataSource" ]
+                                    "DataSource"
+                                    [ Elm.Annotation.var "data"
+                                    ]
+                              )
+                            , ( "head"
+                              , Elm.Annotation.function
+                                    [ Elm.Annotation.namedWith
+                                        [ "RouteBuilder" ]
+                                        "StaticPayload"
+                                        [ Elm.Annotation.var "data"
+                                        , Elm.Annotation.var "action"
+                                        , Elm.Annotation.var "routeParams"
+                                        ]
+                                    ]
+                                    (Elm.Annotation.list
+                                        (Elm.Annotation.namedWith [ "Head" ] "Tag" [])
+                                    )
+                              )
+                            ]
+                        ]
+                        (Elm.Annotation.namedWith
+                            [ "RouteBuilder" ]
+                            "Builder"
+                            [ Elm.Annotation.named [] "RouteParams"
+                            , Elm.Annotation.named [] "Data"
+                            , Elm.Annotation.named [] "Action"
+                            ]
+                        )
+                    )
+            }
+        )
+        [ Elm.record
+            [ Tuple.pair "data" serverRenderArg.data
+            , Tuple.pair "head" (Elm.functionReduced "serverRenderUnpack" serverRenderArg.head)
+            ]
+        ]
+
+
 buildWithLocalState_ :
     { view :
         Elm.Expression
@@ -486,6 +909,7 @@ buildWithLocalState_ :
         -> Elm.Expression
         -> Elm.Expression
         -> Elm.Expression
+    , state : State
     }
     -> Elm.Expression
     -> Elm.Expression
@@ -493,7 +917,13 @@ buildWithLocalState_ buildWithLocalStateArg buildWithLocalStateArg0 =
     Elm.apply
         (Elm.value
             { importFrom = [ "RouteBuilder" ]
-            , name = "buildWithLocalState"
+            , name =
+                case buildWithLocalStateArg.state of
+                    LocalState ->
+                        "buildWithLocalState"
+
+                    SharedState ->
+                        "buildWithSharedState"
             , annotation =
                 Just
                     (Elm.Annotation.function
@@ -569,13 +999,25 @@ buildWithLocalState_ buildWithLocalStateArg buildWithLocalStateArg0 =
                                     , Elm.Annotation.var "msg"
                                     , Elm.Annotation.var "model"
                                     ]
-                                    (Elm.Annotation.tuple
-                                        (Elm.Annotation.var "model")
-                                        (Elm.Annotation.namedWith
-                                            [ "Effect" ]
-                                            "Effect"
-                                            [ Elm.Annotation.var "msg" ]
-                                        )
+                                    (case buildWithLocalStateArg.state of
+                                        LocalState ->
+                                            Elm.Annotation.tuple
+                                                (Elm.Annotation.var "model")
+                                                (Elm.Annotation.namedWith
+                                                    [ "Effect" ]
+                                                    "Effect"
+                                                    [ Elm.Annotation.var "msg" ]
+                                                )
+
+                                        SharedState ->
+                                            Elm.Annotation.triple
+                                                (Elm.Annotation.var "model")
+                                                (Elm.Annotation.namedWith
+                                                    [ "Effect" ]
+                                                    "Effect"
+                                                    [ Elm.Annotation.var "msg" ]
+                                                )
+                                                (Elm.Annotation.maybe (Elm.Annotation.named [ "Shared" ] "Msg"))
                                     )
                               )
                             , ( "subscriptions"