elm-pages 3.0.0-beta.9 → 3.0.1

package/generator/template/package.json

@@ -1,14 +1,20 @@
 {
   "name": "elm-pages-app",
+  "type": "module",
   "scripts": {
     "postinstall": "elm-tooling install",
     "start": "elm-pages dev",
     "build": "elm-pages build"
   },
   "devDependencies": {
-    "elm-optimize-level-2": "0.3.4",
-    "elm-pages": "2.1.10",
-    "elm-review": "^2.7.0",
-    "elm-tooling": "^1.7.0"
+    "elm-codegen": "^0.3.0",
+    "elm-optimize-level-2": "^0.3.5",
+    "elm-pages": "^3.0.0-beta.42",
+    "elm-review": "^2.10.2",
+    "elm-tooling": "^1.14.0",
+    "vite": "^4.3.5"
+  },
+  "dependencies": {
+    "@netlify/functions": "^1.4.0"
   }
 }

package/generator/template/script/.elm-pages/compiled-ports/custom-backend-task.mjs

@@ -0,0 +1,7 @@
+// script/custom-backend-task.ts
+async function hello(name) {
+  return `Hello ${name}!`;
+}
+export {
+  hello
+};

package/generator/template/script/custom-backend-task.ts

@@ -0,0 +1,3 @@
+export async function hello(name) {
+  return `Hello ${name}!`;
+}

package/generator/template/script/elm.json

@@ -0,0 +1,61 @@
+{
+    "type": "application",
+    "source-directories": [
+        "src",
+        "../codegen"
+    ],
+    "elm-version": "0.19.1",
+    "dependencies": {
+        "direct": {
+            "dillonkearns/elm-cli-options-parser": "3.2.0",
+            "dillonkearns/elm-pages": "10.0.0",
+            "elm/bytes": "1.0.8",
+            "elm/core": "1.0.5",
+            "elm/html": "1.0.0",
+            "elm/json": "1.1.3",
+            "mdgriffith/elm-codegen": "3.0.0"
+        },
+        "indirect": {
+            "Chadtech/elm-bool-extra": "2.4.2",
+            "avh4/elm-color": "1.0.0",
+            "danfishgold/base64-bytes": "1.1.0",
+            "danyx23/elm-mimetype": "4.0.1",
+            "dillonkearns/elm-bcp47-language-tag": "1.0.1",
+            "dillonkearns/elm-date-or-date-time": "2.0.0",
+            "dillonkearns/elm-form": "3.0.0",
+            "elm/browser": "1.0.2",
+            "elm/file": "1.0.5",
+            "elm/http": "2.0.0",
+            "elm/parser": "1.1.0",
+            "elm/random": "1.0.0",
+            "elm/regex": "1.0.0",
+            "elm/time": "1.0.0",
+            "elm/url": "1.0.0",
+            "elm/virtual-dom": "1.0.3",
+            "elm-community/basics-extra": "4.1.0",
+            "elm-community/list-extra": "8.7.0",
+            "elm-community/maybe-extra": "5.3.0",
+            "fredcy/elm-parseint": "2.0.1",
+            "jluckyiv/elm-utc-date-strings": "1.0.0",
+            "justinmimbs/date": "4.0.1",
+            "miniBill/elm-codec": "2.0.0",
+            "miniBill/elm-unicode": "1.0.3",
+            "noahzgordon/elm-color-extra": "1.0.2",
+            "robinheghan/fnv1a": "1.0.0",
+            "robinheghan/murmur3": "1.0.0",
+            "rtfeldman/elm-css": "18.0.0",
+            "rtfeldman/elm-hex": "1.0.0",
+            "rtfeldman/elm-iso8601-date-strings": "1.1.4",
+            "stil4m/elm-syntax": "7.2.9",
+            "stil4m/structured-writer": "1.0.3",
+            "the-sett/elm-pretty-printer": "3.0.0",
+            "the-sett/elm-syntax-dsl": "6.0.2",
+            "turboMaCk/non-empty-list-alias": "1.3.1",
+            "vito/elm-ansi": "10.0.1"
+        }
+    },
+    "test-dependencies": {
+        "direct": {},
+        "indirect": {}
+    }
+}

package/generator/template/script/src/AddRoute.elm

@@ -0,0 +1,312 @@
+module AddRoute exposing (run)
+
+import BackendTask
+import Cli.Option as Option
+import Cli.OptionsParser as OptionsParser
+import Cli.Program as Program
+import Elm
+import Elm.Annotation as Type
+import Elm.Case
+import Elm.Declare
+import Elm.Let
+import Elm.Op
+import Gen.BackendTask
+import Gen.Effect as Effect
+import Gen.FatalError
+import Gen.Form as Form
+import Gen.Form.FieldView as FieldView
+import Gen.Html as Html
+import Gen.Html.Attributes as Attr
+import Gen.Json.Encode
+import Gen.List
+import Gen.Maybe
+import Gen.Pages.Form as PagesForm
+import Gen.Pages.Script
+import Gen.Server.Request as Request
+import Gen.Server.Response as Response
+import Gen.View
+import Pages.Script as Script exposing (Script)
+import Scaffold.Form
+import Scaffold.Route exposing (Type(..))
+
+
+type alias CliOptions =
+    { moduleName : List String
+    , fields : List ( String, Scaffold.Form.Kind )
+    }
+
+
+run : Script
+run =
+    Script.withCliOptions program
+        (\cliOptions ->
+            cliOptions
+                |> createFile
+                |> Script.writeFile
+                |> BackendTask.allowFatal
+        )
+
+
+program : Program.Config CliOptions
+program =
+    Program.config
+        |> Program.add
+            (OptionsParser.build CliOptions
+                |> OptionsParser.with (Option.requiredPositionalArg "module" |> Scaffold.Route.moduleNameCliArg)
+                |> OptionsParser.withRestArgs Scaffold.Form.restArgsParser
+            )
+
+
+createFile : CliOptions -> { path : String, body : String }
+createFile { moduleName, fields } =
+    let
+        formHelpers :
+            Maybe
+                { formHandlers : Elm.Expression
+                , form : Elm.Expression
+                , declarations : List Elm.Declaration
+                }
+        formHelpers =
+            Scaffold.Form.provide
+                { fields = fields
+                , elmCssView = False
+                , view =
+                    \{ formState, params } ->
+                        Elm.Let.letIn
+                            (\fieldView ->
+                                Elm.list
+                                    ((params
+                                        |> List.map
+                                            (\{ name, kind, param } ->
+                                                fieldView (Elm.string name) param
+                                            )
+                                     )
+                                        ++ [ Elm.ifThen formState.submitting
+                                                (Html.button
+                                                    [ Attr.disabled True
+                                                    ]
+                                                    [ Html.text "Submitting..."
+                                                    ]
+                                                )
+                                                (Html.button []
+                                                    [ Html.text "Submit"
+                                                    ]
+                                                )
+                                           ]
+                                    )
+                            )
+                            |> Elm.Let.fn2 "fieldView"
+                                ( "label", Type.string |> Just )
+                                ( "field", Nothing )
+                                (\label field ->
+                                    Html.div []
+                                        [ Html.label []
+                                            [ Html.call_.text (Elm.Op.append label (Elm.string " "))
+                                            , field |> FieldView.input []
+                                            , errorsView.call formState.errors field
+                                            ]
+                                        ]
+                                )
+                            |> Elm.Let.toExpression
+                }
+    in
+    Scaffold.Route.serverRender
+        { moduleName = moduleName
+        , action =
+            ( Alias
+                (Type.record
+                    (case formHelpers of
+                        Just _ ->
+                            [ ( "errors", Type.namedWith [ "Form" ] "ServerResponse" [ Type.string ] )
+                            ]
+
+                        Nothing ->
+                            []
+                    )
+                )
+            , \routeParams request ->
+                formHelpers
+                    |> Maybe.map
+                        (\justFormHelp ->
+                            Request.formData justFormHelp.formHandlers request
+                                |> Gen.Maybe.call_.map
+                                    (Elm.fn ( "formData", Nothing )
+                                        (\formData ->
+                                            Elm.Case.tuple formData
+                                                "response"
+                                                "parsedForm"
+                                                (\response parsedForm ->
+                                                    Elm.Case.custom parsedForm
+                                                        Type.int
+                                                        [ Elm.Case.branch1 "Form.Valid"
+                                                            ( "validatedForm", Type.int )
+                                                            (\validatedForm ->
+                                                                Elm.Case.custom validatedForm
+                                                                    Type.int
+                                                                    [ Elm.Case.branch1 "Action"
+                                                                        ( "parsed", Type.int )
+                                                                        (\parsed ->
+                                                                            Scaffold.Form.recordEncoder parsed fields
+                                                                                |> Gen.Json.Encode.encode 2
+                                                                                |> Gen.Pages.Script.call_.log
+                                                                                |> Gen.BackendTask.call_.map
+                                                                                    (Elm.fn ( "_", Nothing )
+                                                                                        (\_ ->
+                                                                                            Response.render
+                                                                                                (Elm.record
+                                                                                                    [ ( "errors", response )
+                                                                                                    ]
+                                                                                                )
+                                                                                        )
+                                                                                    )
+                                                                        )
+                                                                    ]
+                                                            )
+                                                        , Elm.Case.branch2 "Form.Invalid"
+                                                            ( "parsed", Type.int )
+                                                            ( "error", Type.int )
+                                                            (\_ _ ->
+                                                                "Form validations did not succeed!"
+                                                                    |> Gen.Pages.Script.log
+                                                                    |> Gen.BackendTask.call_.map
+                                                                        (Elm.fn ( "_", Nothing )
+                                                                            (\_ ->
+                                                                                Response.render
+                                                                                    (Elm.record
+                                                                                        [ ( "errors", response )
+                                                                                        ]
+                                                                                    )
+                                                                            )
+                                                                        )
+                                                            )
+                                                        ]
+                                                )
+                                        )
+                                    )
+                                |> Gen.Maybe.withDefault
+                                    (Gen.BackendTask.fail
+                                        (Gen.FatalError.fromString "Expected form post")
+                                    )
+                        )
+                    |> Maybe.withDefault
+                        (Gen.BackendTask.succeed
+                            (Response.render
+                                (Elm.record [])
+                            )
+                        )
+            )
+        , data =
+            ( Alias (Type.record [])
+            , \routeParams request ->
+                Gen.BackendTask.succeed
+                    (Response.render
+                        (Elm.record [])
+                    )
+            )
+        , head = \app -> Elm.list []
+        }
+        |> Scaffold.Route.addDeclarations
+            (formHelpers
+                |> Maybe.map .declarations
+                |> Maybe.map ((::) errorsView.declaration)
+                |> Maybe.withDefault []
+            )
+        |> Scaffold.Route.buildWithLocalState
+            { view =
+                \{ shared, model, app } ->
+                    Gen.View.make_.view
+                        { title = moduleName |> String.join "." |> Elm.string
+                        , body =
+                            Elm.list
+                                (case formHelpers of
+                                    Just justFormHelp ->
+                                        [ Html.h2 [] [ Html.text "Form" ]
+                                        , justFormHelp.form
+                                            |> PagesForm.call_.renderHtml
+                                                (Elm.list [])
+                                                (Form.options "form"
+                                                    |> Form.withServerResponse
+                                                        (app
+                                                            |> Elm.get "action"
+                                                            |> Gen.Maybe.map (Elm.get "errors")
+                                                        )
+                                                )
+                                                app
+                                        ]
+
+                                    Nothing ->
+                                        [ Html.h2 [] [ Html.text "New Page" ]
+                                        ]
+                                )
+                        }
+            , update =
+                \{ shared, app, msg, model } ->
+                    Elm.Case.custom msg
+                        (Type.named [] "Msg")
+                        [ Elm.Case.branch0 "NoOp"
+                            (Elm.tuple model
+                                Effect.none
+                            )
+                        ]
+            , init =
+                \{ shared, app } ->
+                    Elm.tuple (Elm.record []) Effect.none
+            , subscriptions =
+                \{ routeParams, path, shared, model } ->
+                    Elm.val "Sub.none"
+            , model =
+                Alias (Type.record [])
+            , msg =
+                Custom [ Elm.variant "NoOp" ]
+            }
+
+
+errorsView :
+    { declaration : Elm.Declaration
+    , call : Elm.Expression -> Elm.Expression -> Elm.Expression
+    , callFrom : List String -> Elm.Expression -> Elm.Expression -> Elm.Expression
+    , value : List String -> Elm.Expression
+    }
+errorsView =
+    Elm.Declare.fn2 "errorsView"
+        ( "errors", Type.namedWith [ "Form" ] "Errors" [ Type.string ] |> Just )
+        ( "field"
+        , Type.namedWith [ "Form", "Validation" ]
+            "Field"
+            [ Type.string
+            , Type.var "parsed"
+            , Type.var "kind"
+            ]
+            |> Just
+        )
+        (\errors field ->
+            Elm.ifThen
+                (Gen.List.call_.isEmpty (Form.errorsForField field errors))
+                (Html.div [] [])
+                (Html.div
+                    []
+                    [ Html.call_.ul (Elm.list [])
+                        (Gen.List.call_.map
+                            (Elm.fn ( "error", Nothing )
+                                (\error ->
+                                    Html.li
+                                        [ Attr.style "color" "red"
+                                        ]
+                                        [ Html.call_.text error
+                                        ]
+                                )
+                            )
+                            (Form.errorsForField field errors)
+                        )
+                    ]
+                )
+                |> Elm.withType
+                    (Type.namedWith [ "Html" ]
+                        "Html"
+                        [ Type.namedWith
+                            [ "PagesMsg" ]
+                            "PagesMsg"
+                            [ Type.named [] "Msg" ]
+                        ]
+                    )
+        )

package/generator/template/script/src/Stars.elm

@@ -0,0 +1,42 @@
+module Stars exposing (run)
+
+import BackendTask exposing (BackendTask)
+import BackendTask.Http
+import Cli.Option as Option
+import Cli.OptionsParser as OptionsParser
+import Cli.Program as Program
+import Json.Decode as Decode
+import Pages.Script as Script exposing (Script)
+
+
+run : Script
+run =
+    Script.withCliOptions program
+        (\{ username, repo } ->
+            BackendTask.Http.getJson
+                ("https://api.github.com/repos/dillonkearns/" ++ repo)
+                (Decode.field "stargazers_count" Decode.int)
+                |> BackendTask.allowFatal
+                |> BackendTask.andThen
+                    (\stars ->
+                        Script.log (String.fromInt stars)
+                    )
+        )
+
+
+type alias CliOptions =
+    { username : String
+    , repo : String
+    }
+
+
+program : Program.Config CliOptions
+program =
+    Program.config
+        |> Program.add
+            (OptionsParser.build CliOptions
+                |> OptionsParser.with
+                    (Option.optionalKeywordArg "username" |> Option.withDefault "dillonkearns")
+                |> OptionsParser.with
+                    (Option.optionalKeywordArg "repo" |> Option.withDefault "elm-pages")
+            )

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "elm-pages",
-  "version": "3.0.0-beta.9",
+  "type": "module",
+  "version": "3.0.1",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
@@ -10,7 +11,7 @@
     "test": "./test.sh",
     "test:snapshot": "(cd examples/escaping && npm install && npm test) && (cd examples/base-path && npm install && npm test)",
     "cypress": "npm start & cypress run",
-    "build:generator": "elm-codegen install && (cd codegen && lamdera make Generate.elm --output elm-pages-codegen.js)",
+    "build:generator": "elm-codegen install && (cd codegen && lamdera make Generate.elm --output elm-pages-codegen.js && mv elm-pages-codegen.js elm-pages-codegen.cjs)",
     "review": "elm-review"
   },
   "repository": "https://github.com/dillonkearns/elm-pages",
@@ -24,53 +25,55 @@
   "author": "Dillon Kearns",
   "license": "BSD-3-Clause",
   "dependencies": {
-    "busboy": "^1.0.0",
+    "busboy": "^1.6.0",
     "chokidar": "^3.5.3",
-    "commander": "^9.4.0",
+    "commander": "^10.0.1",
     "connect": "^3.7.0",
-    "cookie-signature": "^1.1.0",
+    "cookie-signature": "^1.2.1",
     "cross-spawn": "7.0.3",
     "devcert": "^1.2.2",
     "elm-doc-preview": "^5.0.5",
     "elm-hot": "^1.1.6",
-    "esbuild": "^0.15.5",
-    "fs-extra": "^10.1.0",
-    "globby": "11.0.4",
+    "esbuild": "^0.17.18",
+    "fs-extra": "^11.1.1",
+    "globby": "13.1.4",
     "gray-matter": "^4.0.3",
     "jsesc": "^3.0.2",
     "kleur": "^4.1.5",
-    "memfs": "^3.4.7",
+    "make-fetch-happen": "^11.1.1",
+    "memfs": "^3.5.1",
     "micromatch": "^4.0.5",
-    "node-fetch": "^2.6.7",
-    "object-hash": "^2.2.0",
     "serve-static": "^1.15.0",
-    "terser": "^5.14.2",
-    "vite": "^3.1.8",
-    "which": "^2.0.2"
+    "terser": "^5.17.1",
+    "vite": "^4.3.5",
+    "which": "^3.0.1"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.2",
-    "@types/fs-extra": "^9.0.13",
+    "@types/fs-extra": "^11.0.1",
+    "@types/make-fetch-happen": "^10.0.1",
     "@types/micromatch": "^4.0.2",
-    "@types/node": "12.20.12",
-    "@types/serve-static": "^1.15.0",
-    "cypress": "^10.6.0",
-    "elm-codegen": "^0.2.0",
-    "elm-optimize-level-2": "^0.1.5",
-    "elm-review": "^2.7.4",
-    "elm-test": "^0.19.1-revision9",
-    "elm-tooling": "^1.8.0",
+    "@types/node": "^20.1.0",
+    "@types/serve-static": "^1.15.1",
+    "cypress": "^12.13.0",
+    "elm-codegen": "^0.3.0",
+    "elm-optimize-level-2": "^0.3.5",
+    "elm-review": "^2.10.2",
+    "elm-test": "^0.19.1-revision12",
+    "elm-tooling": "^1.14.0",
     "elm-verify-examples": "^5.2.0",
-    "elmi-to-json": "^1.2.0",
-    "mocha": "^10.0.0",
-    "typescript": "^4.7.4"
+    "elmi-to-json": "^1.4.3",
+    "typescript": "^5.0.4",
+    "vite": "^4.3.5",
+    "vitest": "^0.31.0"
   },
   "files": [
+    "adapter/",
     "generator/src/",
     "generator/review/",
     "generator/dead-code-review/",
     "src/",
-    "codegen/elm-pages-codegen.js",
+    "codegen/elm-pages-codegen.cjs",
     "generator/template/",
     "generator/static-code/"
   ],