elm-pages 3.0.0-beta.5 → 3.0.0-beta.7

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_runner.js

@@ -75,7 +75,7 @@ console.elmlog = (str) => logs.push(str + "\n");
 const { Elm } = require("./Runner.elm.js");
 
 // Start the Elm app
-const flags = { initialSeed: 4067606959, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 2254786925, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

package/generator/dead-code-review/elm-stuff/tests-0.19.1/js/node_supervisor.js

@@ -82,7 +82,7 @@ const verbosity = 0;
 // Create a long lived reporter worker
 const { Elm } = require("./Reporter.elm.js");
 const flags = {
-  initialSeed: 4067606959,
+  initialSeed: 2254786925,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/review/elm-stuff/tests-0.19.1/js/node_runner.js

@@ -75,7 +75,7 @@ console.elmlog = (str) => logs.push(str + "\n");
 const { Elm } = require("./Runner.elm.js");
 
 // Start the Elm app
-const flags = { initialSeed: 1129837679, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 3791732356, fuzzRuns: 100, filter: null };
 const app = Elm.Runner.init({ flags: flags });
 
 // Record the timing at which we received the last "runTest" message

package/generator/review/elm-stuff/tests-0.19.1/js/node_supervisor.js

@@ -82,7 +82,7 @@ const verbosity = 0;
 // Create a long lived reporter worker
 const { Elm } = require("./Reporter.elm.js");
 const flags = {
-  initialSeed: 1129837679,
+  initialSeed: 3791732356,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/src/build.js

@@ -16,6 +16,8 @@ const { build } = require("vite");
 const preRenderHtml = require("./pre-render-html.js");
 const esbuild = require("esbuild");
 const { createHash } = require("crypto");
+const { merge_vite_configs } = require("./vite-utils.js");
+const { resolveConfig } = require("./config.js");
 
 let pool = [];
 let pagesReady;
@@ -75,40 +77,31 @@ async function run(options) {
     const generateCode = codegen.generate(options.base);
 
     await generateCode;
+
+    const config = await resolveConfig();
     await fsPromises.writeFile(
       "elm-stuff/elm-pages/index.html",
-      preRenderHtml.templateHtml()
+      preRenderHtml.templateHtml(false, config.headTagsTemplate)
     );
-
-    const config = await import(
-      path.join(process.cwd(), "elm-pages.config.mjs")
-    )
-      .then(async (elmPagesConfig) => {
-        return elmPagesConfig.default || {};
-      })
-      .catch((error) => {
-        console.warn(
-          "No `elm-pages.config.mjs` file found. Using default config."
-        );
-        return {};
-      });
-    const viteConfig = config.vite || {};
-
-    const buildComplete = build({
-      configFile: false,
-      root: process.cwd(),
-      base: options.base,
-      ssr: false,
-
-      build: {
-        manifest: true,
-        outDir: "dist",
-        rollupOptions: {
-          input: "elm-stuff/elm-pages/index.html",
+    const viteConfig = merge_vite_configs(
+      {
+        configFile: false,
+        root: process.cwd(),
+        base: options.base,
+        ssr: false,
+
+        build: {
+          manifest: true,
+          outDir: "dist",
+          rollupOptions: {
+            input: "elm-stuff/elm-pages/index.html",
+          },
         },
       },
-      ...viteConfig,
-    });
+      config.vite || {}
+    );
+
+    const buildComplete = build(viteConfig);
     const compileClientDone = compileElm(options);
     await buildComplete;
     await compileClientDone;

package/generator/src/config.js

@@ -0,0 +1,39 @@
+const path = require("path");
+
+async function resolveConfig() {
+  return await import(path.join(process.cwd(), "elm-pages.config.mjs"))
+    .then(async (elmPagesConfig) => {
+      return (
+        elmPagesConfig.default || {
+          headTagsTemplate: defaultHeadTagsTemplate,
+        }
+      );
+    })
+    .catch((error) => {
+      console.warn(
+        "No `elm-pages.config.mjs` file found. Using default config."
+      );
+      return {
+        headTagsTemplate: defaultHeadTagsTemplate,
+        vite: {},
+      };
+    });
+}
+
+function defaultHeadTagsTemplate(context) {
+  return `
+<link rel="stylesheet" href="/style.css" />
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width,initial-scale=1" />
+<meta name="generator" content="elm-pages v${context.cliVersion}" />
+<meta name="mobile-web-app-capable" content="yes" />
+<meta name="theme-color" content="#ffffff" />
+<meta name="apple-mobile-web-app-capable" content="yes" />
+<meta
+  name="apple-mobile-web-app-status-bar-style"
+  content="black-translucent"
+/>
+`;
+}
+
+module.exports = { resolveConfig };

package/generator/src/dev-server.js

@@ -24,6 +24,9 @@ const busboy = require("busboy");
 const { createServer: createViteServer } = require("vite");
 const cliVersion = require("../../package.json").version;
 const esbuild = require("esbuild");
+const { merge_vite_configs } = require("./vite-utils.js");
+const { templateHtml } = require("./pre-render-html.js");
+const { resolveConfig } = require("./config.js");
 
 /**
  * @param {{ port: string; base: string; https: boolean; debug: boolean; }} options
@@ -117,27 +120,23 @@ async function start(options) {
     watcher.add(sourceDirs);
   }
 
-  const viteConfig = await import(
-    path.join(process.cwd(), "elm-pages.config.mjs")
-  )
-    .then(async (elmPagesConfig) => {
-      return elmPagesConfig.default.vite || {};
-    })
-    .catch((error) => {
-      console.warn(
-        kleur.yellow(
-          "No `elm-pages.config.mjs` file found. Using default config."
-        )
-      );
-      return {};
-    });
-  const vite = await createViteServer({
-    server: { middlewareMode: "ssr", base: options.base, port: options.port },
-    configFile: false,
-    root: process.cwd(),
-    base: options.base,
-    ...viteConfig,
-  });
+  const config = await resolveConfig();
+  const vite = await createViteServer(
+    merge_vite_configs(
+      {
+        server: {
+          middlewareMode: "ssr",
+          base: options.base,
+          port: options.port,
+        },
+        configFile: false,
+        root: process.cwd(),
+        base: options.base,
+      },
+
+      config.vite
+    )
+  );
   esbuild
     .build({
       entryPoints: ["./port-data-source"],
@@ -459,35 +458,7 @@ async function start(options) {
             }
             case "html": {
               try {
-                const template =
-                  /*html*/
-                  `<!DOCTYPE html>
-<!-- ROOT --><html lang="en">
-  <head>
-    <script src="/hmr.js" type="text/javascript"></script>
-    <script src="/elm.js" type="text/javascript"></script>
-    <link rel="stylesheet" href="/style.css">
-    <link rel="stylesheet" href="/dev-style.css">
-    <script src="/elm-pages.js" type="module"></script>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width,initial-scale=1" />
-    <title><!-- PLACEHOLDER_TITLE --></title>
-    <meta name="generator" content="elm-pages v${cliVersion}" />
-    <meta name="mobile-web-app-capable" content="yes" />
-    <meta name="theme-color" content="#ffffff" />
-    <meta name="apple-mobile-web-app-capable" content="yes" />
-    <meta
-      name="apple-mobile-web-app-status-bar-style"
-      content="black-translucent"
-    />
-    <!-- PLACEHOLDER_HEAD_AND_DATA -->
-  </head>
-  <body>
-    <div data-url="" display="none"></div>
-    <!-- PLACEHOLDER_HTML -->
-  </body>
-</html>
-                `;
+                const template = templateHtml(true, config.headTagsTemplate);
                 const processedTemplate = await vite.transformIndexHtml(
                   req.originalUrl,
                   template

package/generator/src/pre-render-html.js

@@ -17,28 +17,34 @@ function wrapHtml(basePath, fromElm, contentDatPayload) {
   };
 }
 
-function templateHtml() {
+/**
+ * @param {boolean} devMode
+ * @param {(context: {cliVersion: string;}) => string} userHeadTagsTemplate
+ */
+function templateHtml(devMode, userHeadTagsTemplate) {
   return /* html */ `<!DOCTYPE html>
 <!-- ROOT --><html lang="en">
   <head>
-    <!-- PLACEHOLDER_PRELOADS -->
-    <script defer src="/elm.js" type="text/javascript"></script>
-    <script defer src="${path.join(
-      __dirname,
-      "../static-code/elm-pages.js"
-    )}" type="module"></script>
-    <link rel="stylesheet" href="/style.css" />
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width,initial-scale=1" />
     <title><!-- PLACEHOLDER_TITLE --></title>
-    <meta name="generator" content="elm-pages v${cliVersion}" />
-    <meta name="mobile-web-app-capable" content="yes" />
-    <meta name="theme-color" content="#ffffff" />
-    <meta name="apple-mobile-web-app-capable" content="yes" />
-    <meta
-      name="apple-mobile-web-app-status-bar-style"
-      content="black-translucent"
-    />
+    ${
+      devMode
+        ? `
+    <script src="/hmr.js" type="text/javascript"></script>
+    <link rel="stylesheet" href="/dev-style.css">`
+        : `
+    <!-- PLACEHOLDER_PRELOADS -->`
+    }
+    <script defer src="/elm.js" type="text/javascript"></script>
+    ${
+      devMode
+        ? `<script src="/elm-pages.js" type="module"></script>
+`
+        : `<script defer src="${path.join(
+            __dirname,
+            "../static-code/elm-pages.js"
+          )}" type="module"></script>`
+    }
+    ${indent(userHeadTagsTemplate({ cliVersion }))}
     <!-- PLACEHOLDER_HEAD_AND_DATA -->
   </head>
   <body>
@@ -48,6 +54,16 @@ function templateHtml() {
 </html>`;
 }
 
+/**
+ * @param {string} snippet
+ */
+function indent(snippet) {
+  return snippet
+    .split("\n")
+    .map((line) => `    ${line}`)
+    .join("\n");
+}
+
 /**
  * @param {string} processedTemplate
  */

package/generator/src/vite-utils.js

@@ -0,0 +1,78 @@
+/** This code is from https://github.com/sveltejs/kit/blob/3b457f67d4d7c59fc63bb3f600a490e4dacc2e62/packages/kit/src/exports/vite/utils.js */
+
+/**
+ * @param {...import('vite').UserConfig} configs
+ * @returns {import('vite').UserConfig}
+ */
+function merge_vite_configs(...configs) {
+  return deep_merge(
+    ...configs.map((config) => ({
+      ...config,
+      resolve: {
+        ...config.resolve,
+        alias: normalize_alias(config.resolve?.alias || {}),
+      },
+    }))
+  );
+}
+
+/**
+ * Takes zero or more objects and returns a new object that has all the values
+ * deeply merged together. None of the original objects will be mutated at any
+ * level, and the returned object will have no references to the original
+ * objects at any depth. If there's a conflict the last one wins, except for
+ * arrays which will be combined.
+ * @param {...Object} objects
+ * @returns {Record<string, any>} the merged object
+ */
+function deep_merge(...objects) {
+  const result = {};
+  /** @type {string[]} */
+  objects.forEach((o) => merge_into(result, o));
+  return result;
+}
+
+/**
+ * normalize kit.vite.resolve.alias as an array
+ * @param {import('vite').AliasOptions} o
+ * @returns {import('vite').Alias[]}
+ */
+function normalize_alias(o) {
+  if (Array.isArray(o)) return o;
+  return Object.entries(o).map(([find, replacement]) => ({
+    find,
+    replacement,
+  }));
+}
+
+/**
+ * Merges b into a, recursively, mutating a.
+ * @param {Record<string, any>} a
+ * @param {Record<string, any>} b
+ */
+function merge_into(a, b) {
+  /**
+   * Checks for "plain old Javascript object", typically made as an object
+   * literal. Excludes Arrays and built-in types like Buffer.
+   * @param {any} x
+   */
+  const is_plain_object = (x) =>
+    typeof x === "object" && x.constructor === Object;
+
+  for (const prop in b) {
+    if (is_plain_object(b[prop])) {
+      if (!is_plain_object(a[prop])) {
+        a[prop] = {};
+      }
+      merge_into(a[prop], b[prop]);
+    } else if (Array.isArray(b[prop])) {
+      if (!Array.isArray(a[prop])) {
+        a[prop] = [];
+      }
+      a[prop].push(...b[prop]);
+    } else {
+      a[prop] = b[prop];
+    }
+  }
+}
+module.exports = { merge_vite_configs };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elm-pages",
-  "version": "3.0.0-beta.5",
+  "version": "3.0.0-beta.7",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
@@ -45,7 +45,7 @@
     "object-hash": "^2.2.0",
     "serve-static": "^1.15.0",
     "terser": "^5.14.2",
-    "vite": "^3.0.9",
+    "vite": "^3.1.8",
     "which": "^2.0.2"
   },
   "devDependencies": {

package/src/DataSource.elm

@@ -123,16 +123,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 +182,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 +212,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 +230,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 +247,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 +255,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 +286,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 +324,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/Pages/Generate.elm

@@ -1,8 +1,28 @@
-module Pages.Generate exposing (Type(..), serverRender, buildWithLocalState, buildNoState, Builder)
+module Pages.Generate exposing
+    ( buildWithLocalState, buildNoState, Builder
+    , Type(..)
+    , serverRender
+    , preRender, single
+    )
 
 {-|
 
-@docs Type, serverRender, buildWithLocalState, buildNoState, Builder
+
+## Initializing the Generator Builder
+
+@docs buildWithLocalState, 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,57 @@ 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
+                        }
+                , 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
+                        }
+                , 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
+                    }
                 }
-        , 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
-            }
-        }
+
+
+type ActionOrPages
+    = Action (Elm.Expression -> Elm.Expression)
+    | Pages (Maybe Elm.Expression)
 
 
 {-| -}
@@ -116,7 +245,7 @@ userFunction :
                 , subscriptions : Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression -> Elm.Expression
                 }
         , 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 }
         }
@@ -225,25 +354,84 @@ userFunction moduleName definitions =
                         }
                     )
 
-        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 +456,87 @@ 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
+                                        }
+                                        >> 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 +552,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 +692,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

package/src/Pages/Internal/Platform.elm

@@ -423,9 +423,7 @@ update config appMsg model =
                         )
 
                     else
-                        ( { model
-                            | url = url
-                          }
+                        ( model
                         , NoEffect
                         )
                             -- TODO is it reasonable to always re-fetch route data if you re-navigate to the current route? Might be a good
@@ -605,27 +603,32 @@ update config appMsg model =
                                 , actionData = newActionData
                                 }
 
-                            ( userModel, _ ) =
+                            ( userModel, userEffect ) =
                                 -- TODO if urlWithoutRedirectResolution is different from the url with redirect resolution, then
                                 -- instead of calling update, call pushUrl (I think?)
                                 -- TODO include user Cmd
-                                config.update model.pageFormState
-                                    (model.inFlightFetchers |> toFetcherState)
-                                    (model.transition |> Maybe.map Tuple.second)
-                                    newSharedData
-                                    newPageData
-                                    model.key
-                                    (config.onPageChange
-                                        { protocol = model.url.protocol
-                                        , host = model.url.host
-                                        , port_ = model.url.port_
-                                        , path = urlPathToPath urlWithoutRedirectResolution
-                                        , query = urlWithoutRedirectResolution.query
-                                        , fragment = urlWithoutRedirectResolution.fragment
-                                        , metadata = config.urlToRoute urlWithoutRedirectResolution
-                                        }
-                                    )
-                                    previousPageData.userModel
+                                if stayingOnSamePath then
+                                    ( previousPageData.userModel, NoEffect )
+
+                                else
+                                    config.update model.pageFormState
+                                        (model.inFlightFetchers |> toFetcherState)
+                                        (model.transition |> Maybe.map Tuple.second)
+                                        newSharedData
+                                        newPageData
+                                        model.key
+                                        (config.onPageChange
+                                            { protocol = model.url.protocol
+                                            , host = model.url.host
+                                            , port_ = model.url.port_
+                                            , path = urlPathToPath urlWithoutRedirectResolution
+                                            , query = urlWithoutRedirectResolution.query
+                                            , fragment = urlWithoutRedirectResolution.fragment
+                                            , metadata = config.urlToRoute urlWithoutRedirectResolution
+                                            }
+                                        )
+                                        previousPageData.userModel
+                                        |> Tuple.mapSecond UserCmd
 
                             updatedModel : Model userModel pageData actionData sharedData
                             updatedModel =
@@ -656,10 +659,13 @@ update config appMsg model =
                             , currentPath = newUrl.path
                           }
                         , if not stayingOnSamePath && scrollToTopWhenDone then
-                            ScrollToTop
+                            Batch
+                                [ ScrollToTop
+                                , userEffect
+                                ]
 
                           else
-                            NoEffect
+                            userEffect
                         )
                             |> (case maybeUserMsg of
                                     Just userMsg ->
@@ -1392,7 +1398,8 @@ loadDataAndUpdateUrl ( newPageData, newSharedData, newActionData ) maybeUserMsg
                     , actionData = newActionData
                     }
 
-                ( userModel, _ ) =
+                -- TODO use userEffect here?
+                ( userModel, userEffect ) =
                     -- TODO if urlWithoutRedirectResolution is different from the url with redirect resolution, then
                     -- instead of calling update, call pushUrl (I think?)
                     -- TODO include user Cmd