elm-pages 3.0.0-beta.37 → 3.0.0-beta.39

package/README.md

@@ -81,7 +81,7 @@ https://github.com/dillonkearns/elm-pages/projects
 You will see an error if the NPM and Elm package do not have a matching Compatibility Key. Usually it's best to upgrade to the latest version of both the Elm and NPM
 packages when you upgrade. However, in case you want to install versions that are behind the latest, the Compatibility Key is included here for reference.
 
-Current Compatibility Key: 15.
+Current Compatibility Key: 16.
 
 ## Contributors ✨
 

package/adapter/netlify.js

@@ -0,0 +1,209 @@
+import * as fs from "fs";
+
+export default async function run({
+  renderFunctionFilePath,
+  routePatterns,
+  apiRoutePatterns,
+}) {
+  console.log("Running Netlify adapter");
+  ensureDirSync("functions/render");
+  ensureDirSync("functions/server-render");
+
+  fs.copyFileSync(
+    renderFunctionFilePath,
+    "./functions/render/elm-pages-cli.mjs"
+  );
+  fs.copyFileSync(
+    renderFunctionFilePath,
+    "./functions/server-render/elm-pages-cli.mjs"
+  );
+
+  fs.writeFileSync("./functions/render/index.mjs", rendererCode(true));
+  fs.writeFileSync("./functions/server-render/index.mjs", rendererCode(false));
+  // TODO rename functions/render to functions/fallback-render
+  // TODO prepend instead of writing file
+
+  const apiServerRoutes = apiRoutePatterns.filter(isServerSide);
+
+  ensureValidRoutePatternsForNetlify(apiServerRoutes);
+
+  const apiRouteRedirects = apiServerRoutes
+    .map((apiRoute) => {
+      if (apiRoute.kind === "prerender-with-fallback") {
+        return `${apiPatternToRedirectPattern(
+          apiRoute.pathPattern
+        )} /.netlify/builders/render 200`;
+      } else if (apiRoute.kind === "serverless") {
+        return `${apiPatternToRedirectPattern(
+          apiRoute.pathPattern
+        )} /.netlify/functions/server-render 200`;
+      } else {
+        throw "Unhandled API Server Route";
+      }
+    })
+    .join("\n");
+
+  const redirectsFile =
+    routePatterns
+      .filter(isServerSide)
+      .map((route) => {
+        if (route.kind === "prerender-with-fallback") {
+          return `${route.pathPattern} /.netlify/builders/render 200
+${route.pathPattern}/content.dat /.netlify/builders/render 200`;
+        } else {
+          return `${route.pathPattern} /.netlify/functions/server-render 200
+${route.pathPattern}/content.dat /.netlify/functions/server-render 200`;
+        }
+      })
+      .join("\n") +
+    "\n" +
+    apiRouteRedirects +
+    "\n";
+
+  fs.writeFileSync("dist/_redirects", redirectsFile);
+}
+
+function ensureValidRoutePatternsForNetlify(apiRoutePatterns) {
+  const invalidNetlifyRoutes = apiRoutePatterns.filter((apiRoute) =>
+    apiRoute.pathPattern.some(({ kind }) => kind === "hybrid")
+  );
+  if (invalidNetlifyRoutes.length > 0) {
+    throw (
+      "Invalid Netlify routes!\n" +
+      invalidNetlifyRoutes
+        .map((value) => JSON.stringify(value, null, 2))
+        .join(", ")
+    );
+  }
+}
+
+function isServerSide(route) {
+  return (
+    route.kind === "prerender-with-fallback" || route.kind === "serverless"
+  );
+}
+
+/**
+ * @param {boolean} isOnDemand
+ */
+function rendererCode(isOnDemand) {
+  return `import * as elmPages from "./elm-pages-cli.mjs";
+import * as busboy from "busboy";
+
+${
+  isOnDemand
+    ? `import { builder } from "@netlify/functions";
+
+export const handler = builder(render);`
+    : `
+
+export const handler = render;`
+}
+
+
+/**
+ * @param {import('aws-lambda').APIGatewayProxyEvent} event
+ * @param {any} context
+ */
+async function render(event, context) {
+  try {
+    const renderResult = await elmPages.render(await reqToJson(event));
+
+    const statusCode = renderResult.statusCode;
+    const headers = renderResult.headers;
+
+    if (renderResult.kind === "bytes") {
+      return {
+        body: Buffer.from(renderResult.body).toString("base64"),
+        isBase64Encoded: true,
+        multiValueHeaders: {
+          "Content-Type": "application/octet-stream",
+          "x-powered-by": "elm-pages",
+          ...headers,
+        },
+        statusCode,
+      };
+    } else if (renderResult.kind === "api-response") {
+      return {
+        body: renderResult.body,
+        multiValueHeaders: headers,
+        statusCode,
+        isBase64Encoded: renderResult.isBase64Encoded,
+      };
+    } else {
+      return {
+        body: renderResult.body,
+        multiValueHeaders: {
+          "Content-Type": "text/html",
+          "x-powered-by": "elm-pages",
+          ...headers,
+        },
+        statusCode,
+      };
+    }
+  } catch (error) {
+    console.error(error);
+    console.error(JSON.stringify(error, null, 2));
+    return {
+      body: \`<body><h1>Error</h1><pre>\${JSON.stringify(error, null, 2)}</pre></body>\`,
+      statusCode: 500,
+      headers: {
+        "Content-Type": "text/html",
+        "x-powered-by": "elm-pages",
+      },
+    };
+  }
+}
+
+/**
+ * @param {import('aws-lambda').APIGatewayProxyEvent} req
+ * @returns {{method: string; rawUrl: string; body: string?; headers: Record<string, string>; multiPartFormData: unknown }}
+ */
+function reqToJson(req) {
+  return {
+    method: req.httpMethod,
+    headers: req.headers,
+    rawUrl: req.rawUrl,
+    body: req.body,
+    multiPartFormData: null,
+  };
+}
+`;
+}
+
+/**
+ * @param {fs.PathLike} dirpath
+ */
+function ensureDirSync(dirpath) {
+  try {
+    fs.mkdirSync(dirpath, { recursive: true });
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+}
+
+/** @typedef {{kind: 'dynamic'} | {kind: 'literal', value: string}} ApiSegment */
+
+/**
+ * @param {ApiSegment[]} pathPattern
+ */
+function apiPatternToRedirectPattern(pathPattern) {
+  return (
+    "/" +
+    pathPattern
+      .map((segment, index) => {
+        switch (segment.kind) {
+          case "literal": {
+            return segment.value;
+          }
+          case "dynamic": {
+            return `:dynamic${index}`;
+          }
+          default: {
+            throw "Unhandled segment: " + JSON.stringify(segment);
+          }
+        }
+      })
+      .join("/")
+  );
+}

package/codegen/elm-pages-codegen.cjs

@@ -26325,6 +26325,36 @@ var $author$project$Gen$Pages$Transition$annotation_ = {
 			_List_fromArray(
 				[fetcherSubmitStatusArg0]));
 	},
+	formData: A4(
+		$author$project$Elm$Annotation$alias,
+		$author$project$Gen$Pages$Transition$moduleName_,
+		'FormData',
+		_List_Nil,
+		$author$project$Elm$Annotation$record(
+			_List_fromArray(
+				[
+					_Utils_Tuple2(
+					'fields',
+					$author$project$Elm$Annotation$list(
+						A2($author$project$Elm$Annotation$tuple, $author$project$Elm$Annotation$string, $author$project$Elm$Annotation$string))),
+					_Utils_Tuple2(
+					'method',
+					A3(
+						$author$project$Elm$Annotation$namedWith,
+						_List_fromArray(
+							['Form']),
+						'Method',
+						_List_Nil)),
+					_Utils_Tuple2('action', $author$project$Elm$Annotation$string),
+					_Utils_Tuple2(
+					'id',
+					A3(
+						$author$project$Elm$Annotation$namedWith,
+						_List_Nil,
+						'Maybe',
+						_List_fromArray(
+							[$author$project$Elm$Annotation$string])))
+				]))),
 	loadingState: A3(
 		$author$project$Elm$Annotation$namedWith,
 		_List_fromArray(

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: 203591880, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 2220181744, 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: 203591880,
+  initialSeed: 2220181744,
   fuzzRuns: 100,
   mode: "consoleColor",
   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: 2714937880, fuzzRuns: 100, filter: null };
+const flags = { initialSeed: 1451258136, 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: 2714937880,
+  initialSeed: 1451258136,
   fuzzRuns: 100,
   mode: "consoleColor",
   verbosity: verbosity,

package/generator/src/build.js

@@ -67,6 +67,16 @@ async function ensureRequiredExecutables() {
 }
 
 export async function run(options) {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  console.warn = function (...messages) {
+    // This is a temporary hack to avoid this warning. elm-pages manages compiling the Elm code without Vite's involvement, so it is external to Vite.
+    // There is a pending issue to allow having external scripts in Vite, once this issue is fixed we can remove this hack:
+    // https://github.com/vitejs/vite/issues/3533
+    if (!messages[0]?.startsWith(`<script src="/elm.js">`)) {
+      console.info(...messages);
+    }
+  };
   try {
     await ensureRequiredDirs();
     await ensureRequiredExecutables();
@@ -114,11 +124,9 @@ export async function run(options) {
       withoutExtension
     );
     const assetManifestPath = path.join(process.cwd(), "dist/manifest.json");
-    const manifest = (
-      await import(assetManifestPath, {
-        assert: { type: "json" },
-      })
-    ).default;
+    const manifest = JSON.parse(
+      await fsPromises.readFile(assetManifestPath, { encoding: "utf-8" })
+    );
     const indexTemplate = await fsPromises.readFile(
       "dist/elm-stuff/elm-pages/index.html",
       "utf-8"
@@ -176,13 +184,84 @@ export async function run(options) {
           console.error("Failed to start custom-backend-task watcher", error);
         }
       });
-    // TODO extract common code for compiling ports file?
 
     global.XMLHttpRequest = {};
     const compileCli = compileCliApp(options);
     try {
       await compileCli;
       await compileClientDone;
+      await portBackendTaskCompiled;
+      const inlineRenderCode = `
+import * as renderer from "./render.js";
+import * as elmModule from "${path.resolve("./elm-stuff/elm-pages/elm.cjs")}";
+import * as url from 'url';
+${
+  global.portsFilePath
+    ? `import * as customBackendTask from "${path.resolve(
+        global.portsFilePath
+      )}";`
+    : `const customBackendTask = {};`
+}
+
+import * as preRenderHtml from "./pre-render-html.js";
+const basePath = \`${options.base || "/"}\`;
+const htmlTemplate = ${JSON.stringify(processedIndexTemplate)};
+const mode = "build";
+const addWatcher = () => {};
+
+export async function render(request) {
+  const requestTime = new Date();
+  const response = await renderer.render(
+    customBackendTask,
+    basePath,
+    elmModule.default,
+    mode,
+    (new url.URL(request.rawUrl)).pathname,
+    request,
+    addWatcher,
+    false
+  );
+  console.dir(response);
+  if (response.kind === "bytes") {
+    return {
+        body: response.contentDatPayload.buffer,
+        statusCode: response.statusCode,
+        kind: response.kind,
+        headers: response.headers,
+    }
+  } else if (response.kind === "api-response") {
+    // isBase64Encoded
+    return {
+        body: response.body.body,
+        statusCode: response.statusCode,
+        kind: response.kind,
+        headers: response.headers,
+        isBase64Encoded: response.body.isBase64Encoded,
+    }
+  } else {
+    return {
+        body: preRenderHtml.replaceTemplate(htmlTemplate, response.htmlString),
+        statusCode: response.statusCode,
+        kind: response.kind,
+        headers: response.headers,
+    }
+  }
+}
+`;
+      await esbuild.build({
+        format: "esm",
+        platform: "node",
+        stdin: { contents: inlineRenderCode, resolveDir: __dirname },
+        bundle: true,
+        // TODO do I need to make the outfile joined with the current working directory?
+
+        outfile: ".elm-pages/compiled/render.mjs",
+        // external: ["node:*", ...options.external],
+        packages: "external",
+        minify: true,
+        // absWorkingDir: projectDirectory,
+        // banner: { js: `#!/usr/bin/env node\n\n${ESM_REQUIRE_SHIM}` },
+      });
     } catch (cliError) {
       // TODO make sure not to print duplicate error output if cleaner review output is printed
       console.error(cliError);
@@ -622,19 +701,17 @@ function _HtmlAsJson_toJson(html) {
 async function runAdapter(adaptFn, processedIndexTemplate) {
   try {
     await adaptFn({
-      renderFunctionFilePath: "./elm-stuff/elm-pages/elm.cjs",
+      renderFunctionFilePath: "./.elm-pages/compiled/render.mjs",
       routePatterns: JSON.parse(
         await fsPromises.readFile("./dist/route-patterns.json", "utf-8")
       ),
       apiRoutePatterns: JSON.parse(
         await fsPromises.readFile("./dist/api-patterns.json", "utf-8")
       ),
-      portsFilePath: "./.elm-pages/compiled-ports/custom-backend-task.mjs",
-      htmlTemplate: processedIndexTemplate,
     });
     console.log("Success - Adapter script complete");
   } catch (error) {
-    console.error("ERROR - Adapter script failed");
+    console.trace("ERROR - Adapter script failed", error);
     try {
       console.error(JSON.stringify(error));
     } catch (parsingError) {

package/generator/src/compatibility-key.js

@@ -1,3 +1,3 @@
-export const compatibilityKey = 15;
+export const compatibilityKey = 16;
 
-export const packageVersion = "3.0.0-beta.37";
+export const packageVersion = "3.0.0-beta.39";

package/generator/src/dev-server.js

@@ -36,6 +36,12 @@ const __dirname = path.dirname(__filename);
  * @param {{ port: string; base: string; https: boolean; debug: boolean; }} options
  */
 export async function start(options) {
+  console.error = function (...messages) {
+    if (!messages[0]?.startsWith("Failed to load url")) {
+      console.info(...messages);
+    }
+  };
+
   let threadReadyQueue = [];
   let pool = [];
 

package/generator/src/generate-template-module-connector.js

@@ -189,7 +189,6 @@ function fetcherModule(name) {
 
 import Bytes exposing (Bytes)
 import Bytes.Decode
-import FormDecoder
 import Http
 import Pages.Fetcher
 import Route.${moduleName}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elm-pages",
   "type": "module",
-  "version": "3.0.0-beta.37",
+  "version": "3.0.0-beta.39",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
@@ -68,6 +68,7 @@
     "vitest": "^0.31.0"
   },
   "files": [
+    "adapter/",
     "generator/src/",
     "generator/review/",
     "generator/dead-code-review/",

package/src/BackendTask/Internal/Request.elm

@@ -1,7 +1,7 @@
 module BackendTask.Internal.Request exposing (request, request2)
 
 import BackendTask exposing (BackendTask)
-import BackendTask.Http exposing (Body, Error(..), Expect)
+import BackendTask.Http exposing (Body, Expect)
 import Json.Decode exposing (Decoder)
 import Json.Encode as Encode
 
@@ -24,7 +24,7 @@ request ({ name, body, expect } as params) =
         }
         expect
         |> BackendTask.onError
-            (\error ->
+            (\_ ->
                 -- TODO avoid crash here, this should be handled as an internal error
                 request params
             )
@@ -38,7 +38,7 @@ request2 :
     , onError : Json.Decode.Error -> error
     }
     -> BackendTask error a
-request2 ({ name, body, expect, onError, errorDecoder } as params) =
+request2 { name, body, expect, onError, errorDecoder } =
     -- elm-review: known-unoptimized-recursion
     BackendTask.Http.request
         { url = "elm-pages-internal://" ++ name
@@ -50,7 +50,7 @@ request2 ({ name, body, expect, onError, errorDecoder } as params) =
         }
         (BackendTask.Http.expectJson Json.Decode.value)
         |> BackendTask.onError
-            (\error ->
+            (\_ ->
                 BackendTask.succeed Encode.null
             )
         |> BackendTask.andThen

package/src/Pages/Form.elm

@@ -16,7 +16,7 @@ import Dict exposing (Dict)
 import FatalError exposing (FatalError)
 import Form
 import Form.Handler
-import Form.Validation as Validation exposing (Validation)
+import Form.Validation exposing (Validation)
 import Html
 import Html.Styled
 import Pages.Internal.Msg
@@ -42,7 +42,7 @@ type alias FormWithServerValidations error combined input view =
 
 {-| -}
 type alias Handler error combined =
-    Form.Handler.Handler error (BackendTask FatalError (Validation.Validation error combined Never Never))
+    Form.Handler.Handler error (BackendTask FatalError (Validation error combined Never Never))
 
 
 {-| -}

package/src/Pages/Internal/Msg.elm

@@ -1,20 +1,15 @@
 module Pages.Internal.Msg exposing
-    (  Msg(..)
-       --, fetcherOnSubmit
-
-    ,  map
-       --, onSubmit
-       --, submitIfValid
-
+    ( Msg(..)
+      --, fetcherOnSubmit
+    , map
+      --, onSubmit
+      --, submitIfValid
     )
 
 --import Form.FormData exposing (FormData)
 --import FormDecoder
 
 import Form exposing (Method)
-import Html exposing (Attribute)
-import Html.Attributes as Attr
-import Json.Decode
 
 
 {-| -}
@@ -75,6 +70,7 @@ type Msg userMsg
 {-| -}
 map : (a -> b) -> Msg a -> Msg b
 map mapFn msg =
+    -- elm-review: known-unoptimized-recursion
     case msg of
         UserMsg userMsg ->
             UserMsg (mapFn userMsg)
@@ -91,8 +87,7 @@ map mapFn msg =
                 }
 
         FormMsg value ->
-            FormMsg
-                (Form.mapMsg (map mapFn) value)
+            FormMsg (Form.mapMsg (map mapFn) value)
 
         NoOp ->
             NoOp

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

@@ -3,4 +3,4 @@ module Pages.Internal.Platform.CompatibilityKey exposing (currentCompatibilityKe
 
 currentCompatibilityKey : Int
 currentCompatibilityKey =
-    15
+    16

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

@@ -32,7 +32,7 @@ type alias JsonValue =
 
 {-| -}
 type alias Program =
-    Program.StatefulProgram Model Msg (BackendTask FatalError.FatalError ()) Flags
+    Program.StatefulProgram Model Msg (BackendTask FatalError ()) Flags
 
 
 {-| -}

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

@@ -1,9 +1,8 @@
-module Pages.Internal.Platform.StaticResponses exposing (NextStep(..), empty, nextStep, renderApiRequest)
+module Pages.Internal.Platform.StaticResponses exposing (NextStep(..), empty, nextStep)
 
 import BackendTask exposing (BackendTask)
 import BuildError exposing (BuildError)
 import FatalError exposing (FatalError)
-import List.Extra
 import Pages.Internal.FatalError
 import Pages.StaticHttp.Request as HashRequest
 import Pages.StaticHttpRequest as StaticHttpRequest
@@ -16,13 +15,6 @@ empty a =
     BackendTask.succeed a
 
 
-renderApiRequest :
-    BackendTask FatalError response
-    -> BackendTask FatalError response
-renderApiRequest request =
-    request
-
-
 type NextStep route value
     = Continue (List HashRequest.Request) (StaticHttpRequest.RawRequest FatalError value)
     | Finish value

package/src/Pages/Internal/Platform.elm

@@ -505,16 +505,16 @@ update config appMsg model =
                         |> performUserMsg userMsg config
 
                 Pages.Internal.Msg.Submit fields ->
-                    let
-                        payload : { fields : List ( String, String ), method : Form.Method, action : String, id : Maybe String }
-                        payload =
-                            { fields = fields.fields
-                            , method = fields.method
-                            , action = fields.action
-                            , id = Just fields.id
-                            }
-                    in
                     if fields.valid then
+                        let
+                            payload : { fields : List ( String, String ), method : Form.Method, action : String, id : Maybe String }
+                            payload =
+                                { fields = fields.fields
+                                , method = fields.method
+                                , action = fields.action
+                                , id = Just fields.id
+                                }
+                        in
                         if fields.useFetcher then
                             ( { model | nextTransitionKey = model.nextTransitionKey + 1 }
                             , SubmitFetcher fields.id model.nextTransitionKey payload
@@ -988,7 +988,7 @@ perform config model effect =
                             , fromPageMsg = Pages.Internal.Msg.UserMsg >> UserMsg
                             , key = key
                             , setField =
-                                \info ->
+                                \_ ->
                                     --Task.succeed (SetField info) |> Task.perform identity
                                     -- TODO
                                     Cmd.none

package/src/Pages/Transition.elm

@@ -1,11 +1,11 @@
 module Pages.Transition exposing
-    ( Transition(..), LoadingState(..), map
+    ( Transition(..), LoadingState(..), map, FormData
     , FetcherState, FetcherSubmitStatus(..)
     )
 
 {-|
 
-@docs Transition, LoadingState, map
+@docs Transition, LoadingState, map, FormData
 
 
 ## Fetchers
@@ -19,6 +19,7 @@ import Path exposing (Path)
 import Time
 
 
+{-| -}
 type alias FormData =
     { fields : List ( String, String )
     , method : Form.Method

package/src/Server/Request.elm

@@ -98,7 +98,6 @@ import Internal.Request
 import Json.Decode
 import Json.Encode
 import List.NonEmpty
-import Pages.Form
 import QueryParams
 import Time
 import Url
@@ -949,7 +948,7 @@ formData formParsers =
         |> andThen
             (\rawFormData_ ->
                 case Form.Handler.run rawFormData_ formParsers of
-                    (Form.Valid decoded) as validated ->
+                    (Form.Valid _) as validated ->
                         ( { persisted =
                                 { fields = Just rawFormData_
                                 , clientSideErrors = Just Dict.empty
@@ -960,7 +959,7 @@ formData formParsers =
                         )
                             |> succeed
 
-                    (Form.Invalid maybeDecoded maybeErrors) as validated ->
+                    (Form.Invalid _ maybeErrors) as validated ->
                         ( { persisted =
                                 { fields = Just rawFormData_
                                 , clientSideErrors = Just maybeErrors

package/src/Stub.elm

@@ -1,4 +1,4 @@
-module Stub exposing (..)
+module Stub exposing (Id, Model, Task(..), map2, nextId)
 
 import Json.Decode as Decode
 import Set exposing (Set)
@@ -24,22 +24,18 @@ type alias Model =
 
 type Task error value
     = Pending (Id -> Id) (Decode.Value -> Model -> ( Model, Task error value ))
-    | Done (Result error value)
 
 
 map2 : (value1 -> value2 -> combined) -> Task error value1 -> Task error value2 -> Task error combined
 map2 mapFn task1 task2 =
     case ( task1, task2 ) of
-        ( Done resolved1, Done resolved2 ) ->
-            Debug.todo ""
-
-        ( Pending toId1 resolved1, Pending toId2 resolved2 ) ->
+        ( Pending toId1 _, Pending toId2 _ ) ->
             Pending
                 (\id ->
                     max (toId1 id) (toId2 id)
                         |> nextId
                 )
-                (\value id ->
+                (\_ _ ->
                     Debug.todo ""
                 )
 
@@ -47,6 +43,7 @@ map2 mapFn task1 task2 =
             Debug.todo ""
 
 
+nextId : Int -> Int
 nextId id =
     id + 1
 

package/src/Internal/Field.elm

@@ -1,19 +0,0 @@
-module Internal.Field exposing (Field(..), FieldInfo)
-
-{-| -}
-
-import Json.Encode as Encode
-
-
-type Field error parsed input initial kind constraints
-    = Field (FieldInfo error parsed input initial) kind
-
-
-{-| -}
-type alias FieldInfo error parsed input initial =
-    { initialValue : input -> Maybe String
-    , decode : Maybe String -> ( Maybe parsed, List error )
-    , properties : List ( String, Encode.Value )
-    , initialToString : initial -> String
-    , compare : String -> initial -> Order
-    }

package/src/Internal/Input.elm

@@ -1,81 +0,0 @@
-module Internal.Input exposing
-    ( Hidden(..)
-    , Input(..)
-    , InputType(..)
-    , Options(..)
-    , inputTypeToString
-    )
-
-
-type InputType
-    = Text
-    | Number
-      -- TODO should range have arguments for initial, min, and max?
-    | Range
-    | Radio
-      -- TODO should submit be a special type, or an Input type?
-      -- TODO have an option for a submit with a name/value?
-    | Date
-    | Time
-    | Checkbox
-    | Tel
-    | Search
-    | Password
-    | Email
-    | Url
-    | Textarea { rows : Maybe Int, cols : Maybe Int }
-
-
-inputTypeToString : InputType -> String
-inputTypeToString inputType =
-    case inputType of
-        Text ->
-            "text"
-
-        Textarea _ ->
-            "text"
-
-        Number ->
-            "number"
-
-        Range ->
-            "range"
-
-        Radio ->
-            "radio"
-
-        Date ->
-            "date"
-
-        Time ->
-            "time"
-
-        Checkbox ->
-            "checkbox"
-
-        Tel ->
-            "tel"
-
-        Search ->
-            "search"
-
-        Password ->
-            "password"
-
-        Email ->
-            "email"
-
-        Url ->
-            "url"
-
-
-type Input
-    = Input InputType
-
-
-type Hidden
-    = Hidden
-
-
-type Options a
-    = Options (String -> Maybe a) (List String)