elm-pages 3.0.0-beta.16 → 3.0.0-beta.17

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: 2665303026, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 4015861069, 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: 2665303026,
+  initialSeed: 4015861069,
   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: 4260939212, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 1374716823, 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: 4260939212,
+  initialSeed: 1374716823,
   fuzzRuns: 100,
   mode: "consoleNoColor",
   verbosity: verbosity,

package/generator/src/build.js

@@ -143,9 +143,9 @@ async function run(options) {
 
     const portBackendTaskCompiled = esbuild
       .build({
-        entryPoints: ["./port-data-source"],
+        entryPoints: ["./custom-backend-task"],
         platform: "node",
-        outfile: ".elm-pages/compiled-ports/port-data-source.js",
+        outfile: ".elm-pages/compiled-ports/custom-backend-task.js",
         assetNames: "[name]-[hash]",
         chunkNames: "chunks/[name]-[hash]",
         outExtension: { ".js": ".js" },
@@ -161,11 +161,11 @@ async function run(options) {
       })
       .catch((error) => {
         const portBackendTaskFileFound =
-          globby.sync("./port-data-source.*").length > 0;
+          globby.sync("./custom-backend-task.*").length > 0;
         if (portBackendTaskFileFound) {
-          // don't present error if there are no files matching port-data-source
-          // if there are files matching port-data-source, warn the user in case something went wrong loading it
-          console.error("Failed to start port-data-source watcher", error);
+          // don't present error if there are no files matching custom-backend-task
+          // if there are files matching custom-backend-task, warn the user in case something went wrong loading it
+          console.error("Failed to start custom-backend-task watcher", error);
         }
       });
     // TODO extract common code for compiling ports file?
@@ -617,7 +617,7 @@ async function runAdapter(adaptFn, processedIndexTemplate) {
       apiRoutePatterns: JSON.parse(
         await fsPromises.readFile("./dist/api-patterns.json", "utf-8")
       ),
-      portsFilePath: "./.elm-pages/compiled-ports/port-data-source.js",
+      portsFilePath: "./.elm-pages/compiled-ports/custom-backend-task.js",
       htmlTemplate: processedIndexTemplate,
     });
     console.log("Success - Adapter script complete");

package/generator/src/cli.js

@@ -131,9 +131,9 @@ async function main() {
 
         const portBackendTaskCompiled = esbuild
           .build({
-            entryPoints: ["./port-data-source"],
+            entryPoints: ["./custom-backend-task"],
             platform: "node",
-            outfile: ".elm-pages/compiled-ports/port-data-source.js",
+            outfile: ".elm-pages/compiled-ports/custom-backend-task.js",
             assetNames: "[name]-[hash]",
             chunkNames: "chunks/[name]-[hash]",
             outExtension: { ".js": ".js" },
@@ -151,11 +151,14 @@ async function main() {
           })
           .catch((error) => {
             const portBackendTaskFileFound =
-              globby.sync("./port-data-source.*").length > 0;
+              globby.sync("./custom-backend-task.*").length > 0;
             if (portBackendTaskFileFound) {
-              // don't present error if there are no files matching port-data-source
-              // if there are files matching port-data-source, warn the user in case something went wrong loading it
-              console.error("Failed to start port-data-source watcher", error);
+              // don't present error if there are no files matching custom-backend-task
+              // if there are files matching custom-backend-task, warn the user in case something went wrong loading it
+              console.error(
+                "Failed to start custom-backend-task watcher",
+                error
+              );
             }
           });
         const portsPath = await portBackendTaskCompiled;

package/generator/src/dev-server.js

@@ -140,7 +140,7 @@ async function start(options) {
   );
   esbuild
     .build({
-      entryPoints: ["./port-data-source"],
+      entryPoints: ["./custom-backend-task"],
       platform: "node",
       assetNames: "[name]-[hash]",
       chunkNames: "chunks/[name]-[hash]",
@@ -171,15 +171,15 @@ async function start(options) {
       ],
     })
     .then((result) => {
-      console.log("Watching port-data-source...");
+      console.log("Watching custom-backend-task...");
     })
     .catch((error) => {
       const portBackendTaskFileFound =
-        globby.sync("./port-data-source.*").length > 0;
+        globby.sync("./custom-backend-task.*").length > 0;
       if (portBackendTaskFileFound) {
-        // don't present error if there are no files matching port-data-source
-        // if there are files matching port-data-source, warn the user in case something went wrong loading it
-        console.error("Failed to start port-data-source watcher", error);
+        // don't present error if there are no files matching custom-backend-task
+        // if there are files matching custom-backend-task, warn the user in case something went wrong loading it
+        console.error("Failed to start custom-backend-task watcher", error);
       }
     });
 

package/generator/src/render-test.js

@@ -27,7 +27,7 @@ async function run({ pathname, serverRequest }) {
     console.log("Compiling DONE");
 
     const portsFilePath =
-      ".elm-pages/compiled-ports/port-data-source-FA2IJND6.js";
+      ".elm-pages/compiled-ports/custom-backend-task-FA2IJND6.js";
     const mode = "dev-server";
 
     const renderResult = await renderer.render(

package/generator/src/request-cache.js

@@ -43,21 +43,21 @@ function lookupOrPerform(portsFile, mode, rawRequest, hasFsAccess, useCache) {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "PortNotDefined",
+                "elm-pages-internal-error": "CustomBackendTaskNotDefined",
               }),
             });
           } else if (portBackendTaskImportError === "missing") {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "MissingPortsFile",
+                "elm-pages-internal-error": "MissingCustomBackendTaskFile",
               }),
             });
           } else {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "ErrorInPortsFile",
+                "elm-pages-internal-error": "ErrorInCustomBackendTaskFile",
                 error:
                   (portBackendTaskImportError &&
                     portBackendTaskImportError.stack) ||
@@ -83,7 +83,7 @@ function lookupOrPerform(portsFile, mode, rawRequest, hasFsAccess, useCache) {
             resolve({
               kind: "response-json",
               value: jsonResponse({
-                "elm-pages-internal-error": "PortCallException",
+                "elm-pages-internal-error": "CustomBackendTaskException",
                 error: portCallError,
               }),
             });
@@ -92,7 +92,7 @@ function lookupOrPerform(portsFile, mode, rawRequest, hasFsAccess, useCache) {
       } catch (error) {
         console.trace(error);
         reject({
-          title: "BackendTask.Port Error",
+          title: "BackendTask.Custom Error",
           message: error.toString(),
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elm-pages",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.17",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",

package/src/BackendTask/{Port.elm → Custom.elm}

@@ -1,30 +1,30 @@
-module BackendTask.Port exposing
-    ( get
+module BackendTask.Custom exposing
+    ( run
     , Error(..)
     )
 
 {-| In a vanilla Elm application, ports let you either send or receive JSON data between your Elm application and the JavaScript context in the user's browser at runtime.
 
-With `BackendTask.Port`, you send and receive JSON to JavaScript running in NodeJS. As with any `BackendTask`, Port BackendTask's are either run at build-time (for pre-rendered routes) or at request-time (for server-rendered routes). See [`BackendTask`](BackendTask) for more about the
+With `BackendTask.Custom`, you send and receive JSON to JavaScript running in NodeJS. As with any `BackendTask`, Custom BackendTask's are either run at build-time (for pre-rendered routes) or at request-time (for server-rendered routes). See [`BackendTask`](BackendTask) for more about the
 lifecycle of `BackendTask`'s.
 
 This means that you can call shell scripts, run NPM packages that are installed, or anything else you could do with NodeJS to perform custom side-effects, get some data, or both.
 
-A `BackendTask.Port` will call an async JavaScript function with the given name from the definition in a file called `port-data-source.js` in your project's root directory. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
+A `BackendTask.Custom` will call an async JavaScript function with the given name from the definition in a file called `custom-backend-task.js` in your project's root directory. The function receives the input JSON value, and the Decoder is used to decode the return value of the async function.
 
-@docs get
+@docs run
 
-Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `FatalError BackendTask.Port.Error` if it isn't found). In this example,
+Here is the Elm code and corresponding JavaScript definition for getting an environment variable (or an `FatalError BackendTask.Custom.Error` if it isn't found). In this example,
 we're using `BackendTask.allowFatal` to let the framework treat that as an unexpected exception, but we could also handle the possible failures of the `FatalError` (see [`FatalError`](FatalError)).
 
     import BackendTask exposing (BackendTask)
-    import BackendTask.Port
+    import BackendTask.Custom
     import Json.Encode
     import OptimizedDecoder as Decode
 
     data : BackendTask FatalError String
     data =
-        BackendTask.Port.get "environmentVariable"
+        BackendTask.Custom.run "environmentVariable"
             (Json.Encode.string "EDITOR")
             Decode.string
             |> BackendTask.allowFatal
@@ -32,7 +32,7 @@ we're using `BackendTask.allowFatal` to let the framework treat that as an unexp
     -- will resolve to "VIM" if you run `EDITOR=vim elm-pages dev`
 
 ```javascript
-// port-data-source.js
+// custom-backend-task.js
 
 module.exports =
   /**
@@ -60,37 +60,37 @@ ${Object.keys(process.env).join("\n")}
 ## Performance
 
 As with any JavaScript or NodeJS code, avoid doing blocking IO operations. For example, avoid using `fs.readFileSync`, because blocking IO can slow down your elm-pages builds and dev server. `elm-pages` performances all `BackendTask`'s in parallel whenever possible.
-So if you do `BackendTask.map2 Tuple.pair myHttpBackendTask myPortBackendTask`, it will resolve those two in parallel. NodeJS performs best when you take advantage of its ability to do non-blocking I/O (file reads, HTTP requests, etc.). If you use `BackendTask.andThen`,
-it will need to resolve them in sequence rather than in parallel, but it's still best to avoid blocking IO operations in your BackendTask Port definitions.
+So if you do `BackendTask.map2 Tuple.pair myHttpBackendTask myCustomBackendTask`, it will resolve those two in parallel. NodeJS performs best when you take advantage of its ability to do non-blocking I/O (file reads, HTTP requests, etc.). If you use `BackendTask.andThen`,
+it will need to resolve them in sequence rather than in parallel, but it's still best to avoid blocking IO operations in your Custom BackendTask definitions.
 
 
 ## Error Handling
 
-There are a few different things that can go wrong when running a port-data-source. These possible errors are captured in the `BackendTask.Port.Error` type.
+There are a few different things that can go wrong when running a custom-backend-task. These possible errors are captured in the `BackendTask.Custom.Error` type.
 
 @docs Error
 
-Any time you throw a JavaScript exception from a BackendTask.Port definition, it will give you a `PortCallException`. It's usually easier to add a `try`/`catch` in your JavaScript code in `port-data-source.js`
-to handle possible errors, but you can throw a JSON value and handle it in Elm in the `PortCallException` call error.
+Any time you throw a JavaScript exception from a BackendTask.Custom definition, it will give you a `CustomBackendTaskException`. It's usually easier to add a `try`/`catch` in your JavaScript code in `custom-backend-task.js`
+to handle possible errors, but you can throw a JSON value and handle it in Elm in the `CustomBackendTaskException` call error.
 
 -}
 
 import BackendTask
 import BackendTask.Http
 import BackendTask.Internal.Request
-import FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 import Json.Decode as Decode exposing (Decoder)
 import Json.Encode as Encode
 import TerminalText
 
 
 {-| -}
-get :
+run :
     String
     -> Encode.Value
     -> Decoder b
     -> BackendTask.BackendTask { fatal : FatalError, recoverable : Error } b
-get portName input decoder =
+run portName input decoder =
     BackendTask.Internal.Request.request
         { name = "port"
         , body =
@@ -104,17 +104,17 @@ get portName input decoder =
                 [ Decode.field "elm-pages-internal-error" Decode.string
                     |> Decode.andThen
                         (\errorKind ->
-                            if errorKind == "PortNotDefined" then
+                            if errorKind == "CustomBackendTaskNotDefined" then
                                 FatalError.recoverable
-                                    { title = "Port Error"
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I expected to find a port named `"
                                         , TerminalText.yellow portName
-                                        , TerminalText.text "` but I couldn't find it. Is the function exported in your port-data-source file?"
+                                        , TerminalText.text "` but I couldn't find it. Is the function exported in your custom-backend-task file?"
                                         ]
                                             |> TerminalText.toString
                                     }
-                                    (PortNotDefined { name = portName })
+                                    (CustomBackendTaskNotDefined { name = portName })
                                     |> Decode.succeed
 
                             else if errorKind == "ExportIsNotFunction" then
@@ -122,78 +122,78 @@ get portName input decoder =
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
-                                        (\incorrectPortType ->
+                                        (\incorrectType ->
                                             FatalError.recoverable
-                                                { title = "Port Error"
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I found an export called `"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I found an export called `"
                                                     , TerminalText.yellow portName
                                                     , TerminalText.text "` but I expected its type to be function, but instead its type was: "
-                                                    , TerminalText.red incorrectPortType
+                                                    , TerminalText.red incorrectType
                                                     ]
                                                         |> TerminalText.toString
                                                 }
                                                 ExportIsNotFunction
                                         )
 
-                            else if errorKind == "MissingPortsFile" then
+                            else if errorKind == "MissingCustomBackendTaskFile" then
                                 FatalError.recoverable
-                                    { title = "Port Error"
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I couldn't find your port-data-source file. Be sure to create a 'port-data-source.ts' or 'port-data-source.js' file."
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I couldn't find your custom-backend-task file. Be sure to create a 'custom-backend-task.ts' or 'custom-backend-task.js' file."
                                         ]
                                             |> TerminalText.toString
                                     }
-                                    MissingPortsFile
+                                    MissingCustomBackendTaskFile
                                     |> Decode.succeed
 
-                            else if errorKind == "ErrorInPortsFile" then
+                            else if errorKind == "ErrorInCustomBackendTaskFile" then
                                 Decode.field "error" Decode.string
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault "")
                                     |> Decode.map
                                         (\errorMessage ->
                                             FatalError.recoverable
-                                                { title = "Port Error"
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I couldn't import the port definitions file, because of this exception:\n\n"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I couldn't import the port definitions file, because of this exception:\n\n"
                                                     , TerminalText.red errorMessage
                                                     , TerminalText.text "\n\nAre there syntax errors or exceptions thrown during import?"
                                                     ]
                                                         |> TerminalText.toString
                                                 }
-                                                ErrorInPortsFile
+                                                ErrorInCustomBackendTaskFile
                                         )
 
-                            else if errorKind == "PortCallException" then
+                            else if errorKind == "CustomBackendTaskException" then
                                 Decode.field "error" Decode.value
                                     |> Decode.maybe
                                     |> Decode.map (Maybe.withDefault Encode.null)
                                     |> Decode.map
                                         (\portCallError ->
                                             FatalError.recoverable
-                                                { title = "Port Error"
+                                                { title = "Custom BackendTask Error"
                                                 , body =
-                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I was able to import the port definitions file, but when running it I encountered this exception:\n\n"
+                                                    [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I was able to import the port definitions file, but when running it I encountered this exception:\n\n"
                                                     , TerminalText.red (Encode.encode 2 portCallError)
-                                                    , TerminalText.text "\n\nYou could add a `try`/`catch` in your `port-data-source` JavaScript code to handle that error."
+                                                    , TerminalText.text "\n\nYou could add a `try`/`catch` in your `custom-backend-task` JavaScript code to handle that error."
                                                     ]
                                                         |> TerminalText.toString
                                                 }
-                                                (PortCallException portCallError)
+                                                (CustomBackendTaskException portCallError)
                                         )
 
                             else
                                 FatalError.recoverable
-                                    { title = "Port Error"
+                                    { title = "Custom BackendTask Error"
                                     , body =
-                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Port.get. I expected to find a port named `"
+                                        [ TerminalText.text "Something went wrong in a call to BackendTask.Custom.run. I expected to find a port named `"
                                         , TerminalText.yellow portName
                                         , TerminalText.text "`."
                                         ]
                                             |> TerminalText.toString
                                     }
-                                    ErrorInPortsFile
+                                    ErrorInCustomBackendTaskFile
                                     |> Decode.succeed
                         )
                     |> Decode.map Err
@@ -207,8 +207,8 @@ get portName input decoder =
 {-| -}
 type Error
     = Error
-    | ErrorInPortsFile
-    | MissingPortsFile
-    | PortNotDefined { name : String }
-    | PortCallException Decode.Value
+    | ErrorInCustomBackendTaskFile
+    | MissingCustomBackendTaskFile
+    | CustomBackendTaskNotDefined { name : String }
+    | CustomBackendTaskException Decode.Value
     | ExportIsNotFunction

package/src/BackendTask/File.elm

@@ -366,7 +366,7 @@ errorDecoder :
     String
     ->
         Decoder
-            { fatal : FatalError.FatalError
+            { fatal : FatalError
             , recoverable : FileReadError decoding
             }
 errorDecoder filePath =

package/src/BackendTask.elm

@@ -16,7 +16,7 @@ A `BackendTask` lets you pull in data from:
   - Local files ([`BackendTask.File`](BackendTask-File))
   - HTTP requests ([`BackendTask.Http`](BackendTask-Http))
   - Globs, i.e. listing out local files based on a pattern like `content/*.txt` ([`BackendTask.Glob`](BackendTask-Glob))
-  - Ports, i.e. getting JSON data from running custom NodeJS, similar to a port in a vanilla Elm app except run at build-time in NodeJS, rather than at run-time in the browser ([`BackendTask.Port`](BackendTask-Port))
+  - Ports, i.e. getting JSON data from running custom NodeJS, similar to a port in a vanilla Elm app except run at build-time in NodeJS, rather than at run-time in the browser ([`BackendTask.Custom`](BackendTask-Custom))
   - Hardcoded data (`BackendTask.succeed "Hello!"`)
   - Or any combination of the above, using `BackendTask.map2`, `BackendTask.andThen`, or other combining/continuing helpers from this module
 

package/src/Pages/Internal/Platform/StaticResponses.elm

@@ -2,7 +2,7 @@ module Pages.Internal.Platform.StaticResponses exposing (NextStep(..), empty, ne
 
 import BackendTask exposing (BackendTask)
 import BuildError exposing (BuildError)
-import FatalError exposing (FatalError, Recoverable)
+import FatalError exposing (FatalError)
 import List.Extra
 import Pages.Internal.FatalError
 import Pages.StaticHttp.Request as HashRequest