elm-pages 3.0.0-beta.30 → 3.0.0-beta.32

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

package/generator/review/elm.json

@@ -11,8 +11,8 @@
             "elm/html": "1.0.0",
             "elm/json": "1.1.3",
             "elm/regex": "1.0.0",
-            "jfmengels/elm-review": "2.10.0",
-            "mdgriffith/elm-codegen": "2.0.0",
+            "jfmengels/elm-review": "2.12.2",
+            "mdgriffith/elm-codegen": "3.0.0",
             "stil4m/elm-syntax": "7.2.9",
             "the-sett/elm-syntax-dsl": "6.0.2"
         },
@@ -27,8 +27,8 @@
             "elm-community/basics-extra": "4.1.0",
             "elm-community/list-extra": "8.7.0",
             "elm-community/maybe-extra": "5.3.0",
-            "elm-explorations/test": "2.1.0",
-            "miniBill/elm-unicode": "1.0.2",
+            "elm-explorations/test": "2.1.1",
+            "miniBill/elm-unicode": "1.0.3",
             "rtfeldman/elm-hex": "1.0.0",
             "stil4m/structured-writer": "1.0.3",
             "the-sett/elm-pretty-printer": "3.0.0"
@@ -36,7 +36,7 @@
     },
     "test-dependencies": {
         "direct": {
-            "elm-explorations/test": "2.1.0"
+            "elm-explorations/test": "2.1.1"
         },
         "indirect": {}
     }

package/generator/src/build.js

@@ -446,8 +446,9 @@ function modeToOptions(mode) {
  */
 function runElmMake(mode, options, elmEntrypointPath, outputPath, cwd) {
   return new Promise(async (resolve, reject) => {
+    const executableName = options.executableName || "lamdera";
     const subprocess = spawnCallback(
-      `lamdera`,
+      executableName,
       [
         "make",
         elmEntrypointPath,

package/generator/src/cli.js

@@ -14,10 +14,11 @@ import * as esbuild from "esbuild";
 import { rewriteElmJson } from "./rewrite-elm-json.js";
 import { ensureDirSync } from "./file-helpers.js";
 import * as url from "url";
-
+import { default as which } from "which";
 import * as commander from "commander";
 import { runElmCodegenInstall } from "./elm-codegen.js";
 import { packageVersion } from "./compatibility-key.js";
+import { resolveInputPathOrModuleName } from "./resolve-elm-module.js";
 
 const Argument = commander.Argument;
 const Option = commander.Option;
@@ -85,52 +86,31 @@ async function main() {
     });
 
   program
-    .command("run <moduleName>")
+    .command("run <elmModulePath>")
     .description("run an elm-pages script")
     .allowUnknownOption()
     .allowExcessArguments()
-    .action(async (moduleName, options, options2) => {
+    .action(async (elmModulePath, options, options2) => {
       const unprocessedCliOptions = options2.args.splice(
         options2.processedArgs.length,
         options2.args.length
       );
-      if (!/^[A-Z][a-zA-Z0-9_]*(\.[A-Z][a-zA-Z0-9_]*)*$/.test(moduleName)) {
-        throw `Invalid module name "${moduleName}", must be in the format of an Elm module`;
-      }
-      const splitModuleName = moduleName.split(".");
-      const expectedFilePath = path.join(
-        process.cwd(),
-        "script/src/",
-        `${splitModuleName.join("/")}.elm`
-      );
-      if (!fs.existsSync(expectedFilePath)) {
-        throw `I couldn't find a module named ${expectedFilePath}`;
-      }
       try {
-        // await codegen.generate("");
-        ensureDirSync(
-          path.join(process.cwd(), ".elm-pages", "http-response-cache")
-        );
-        if (fs.existsSync("./codegen/")) {
-          await runElmCodegenInstall();
-        }
+        await compileElmForScript(elmModulePath);
 
-        ensureDirSync("./script/elm-stuff");
-        ensureDirSync("./script/elm-stuff/elm-pages/.elm-pages");
-        await fs.promises.writeFile(
-          path.join("./script/elm-stuff/elm-pages/.elm-pages/Main.elm"),
-          generatorWrapperFile(moduleName)
-        );
-        await rewriteElmJson(
-          "./script/elm.json",
-          "./script/elm-stuff/elm-pages/elm.json"
-        );
+        const { moduleName, projectDirectory, sourceDirectory } =
+          resolveInputPathOrModuleName(elmModulePath);
 
         const portBackendTaskCompiled = esbuild
           .build({
-            entryPoints: ["./custom-backend-task"],
+            entryPoints: [
+              path.resolve(projectDirectory, "./custom-backend-task"),
+            ],
             platform: "node",
-            outfile: ".elm-pages/compiled-ports/custom-backend-task.mjs",
+            outfile: path.resolve(
+              projectDirectory,
+              ".elm-pages/compiled-ports/custom-backend-task.mjs"
+            ),
             assetNames: "[name]-[hash]",
             chunkNames: "chunks/[name]-[hash]",
             metafile: true,
@@ -148,32 +128,34 @@ async function main() {
           })
           .catch((error) => {
             const portBackendTaskFileFound =
-              globby.globbySync("./custom-backend-task.*").length > 0;
+              globby.globbySync(
+                path.resolve(projectDirectory, "./custom-backend-task.*")
+              ).length > 0;
             if (portBackendTaskFileFound) {
               // 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
-              );
+              console.error("Failed to load custom-backend-task file.", error);
             }
           });
         const portsPath = await portBackendTaskCompiled;
 
-        process.chdir("./script");
+        const cwd = process.cwd();
+        process.chdir(projectDirectory);
         // TODO have option for compiling with --debug or not (maybe allow running with elm-optimize-level-2 as well?)
-        await build.compileCliApp({ debug: "debug" });
-        process.chdir("../");
+
+        let executableName = await lamderaOrElmFallback();
+        await build.compileCliApp({ debug: "debug", executableName });
         fs.renameSync(
-          "./script/elm-stuff/elm-pages/elm.js",
-          "./script/elm-stuff/elm-pages/elm.cjs"
+          `${projectDirectory}/elm-stuff/elm-pages/elm.js`,
+          `${projectDirectory}/elm-stuff/elm-pages/elm.cjs`
         );
+        process.chdir(cwd);
         await renderer.runGenerator(
           unprocessedCliOptions,
           portsPath
             ? await import(url.pathToFileURL(path.resolve(portsPath)).href)
             : null,
-          await requireElm("./script/elm-stuff/elm-pages/elm.cjs"),
+          await requireElm(`${projectDirectory}/elm-stuff/elm-pages/elm.cjs`),
           moduleName
         );
       } catch (error) {
@@ -200,65 +182,44 @@ async function main() {
       collect,
       []
     )
-    .action(async (moduleName, options, options2) => {
-      if (!/^[A-Z][a-zA-Z0-9_]*(\.[A-Z][a-zA-Z0-9_]*)*$/.test(moduleName)) {
-        throw `Invalid module name "${moduleName}", must be in the format of an Elm module`;
-      }
-      const splitModuleName = moduleName.split(".");
-      const expectedFilePath = path.join(
-        process.cwd(),
-        "script/src/",
-        `${splitModuleName.join("/")}.elm`
+    .action(async (elmModulePath, options, options2) => {
+      const { moduleName, projectDirectory, sourceDirectory } =
+        resolveInputPathOrModuleName(elmModulePath);
+      await compileElmForScript(elmModulePath);
+
+      const cwd = process.cwd();
+      process.chdir(projectDirectory);
+      // TODO have option for compiling with --debug or not (maybe allow running with elm-optimize-level-2 as well?)
+
+      let executableName = await lamderaOrElmFallback();
+      await build.compileCliApp({ debug: options.debug, executableName });
+      fs.renameSync(
+        `${projectDirectory}/elm-stuff/elm-pages/elm.js`,
+        `${projectDirectory}/elm-stuff/elm-pages/elm.cjs`
       );
-      if (!fs.existsSync(expectedFilePath)) {
-        throw `I couldn't find a module named ${expectedFilePath}`;
-      }
-      try {
-        if (fs.existsSync("./codegen/")) {
-          await runElmCodegenInstall();
-        }
+      process.chdir(cwd);
 
-        ensureDirSync("./script/elm-stuff");
-        ensureDirSync("./script/elm-stuff/elm-pages/.elm-pages");
-        await fs.promises.writeFile(
-          path.join("./script/elm-stuff/elm-pages/.elm-pages/Main.elm"),
-          generatorWrapperFile(moduleName)
-        );
-        await rewriteElmJson(
-          "./script/elm.json",
-          "./script/elm-stuff/elm-pages/elm.json"
-        );
+      try {
+        const { moduleName, projectDirectory, sourceDirectory } =
+          resolveInputPathOrModuleName(elmModulePath);
 
-        process.chdir("./script");
-        // TODO have option for compiling with --debug or not (maybe allow running with elm-optimize-level-2 as well?)
-        console.log("Compiling...");
-        await build.compileCliApp({ debug: options.debug });
-        process.chdir("../");
-        if (!options.debug) {
-          console.log("Running elm-optimize-level-2...");
-          await build.elmOptimizeLevel2(
-            "./script/elm-stuff/elm-pages/elm.js",
-            process.cwd()
-          );
-        }
-        fs.renameSync(
-          "./script/elm-stuff/elm-pages/elm.js",
-          "./script/elm-stuff/elm-pages/elm.cjs"
-        );
-        // TODO allow no custom-backend-task
         const portBackendTaskFileFound =
-          globby.globbySync("./custom-backend-task.*").length > 0;
+          globby.globbySync(
+            path.resolve(projectDirectory, "custom-backend-task.*")
+          ).length > 0;
 
         const scriptRunner = `${
           portBackendTaskFileFound
             ? `import * as customBackendTask from "${path.resolve(
+                projectDirectory,
                 "./custom-backend-task"
               )}";`
             : "const customBackendTask = {};"
         }
 import * as renderer from "./render.js";
-import { default as Elm } from "${path.resolve(
-          "./script/elm-stuff/elm-pages/elm.cjs"
+import { default as Elm } from "${path.join(
+          projectDirectory,
+          "elm-stuff/elm-pages/elm.cjs"
         )}";
 
 await renderer.runGenerator(
@@ -278,9 +239,12 @@ await(async()=>{let{dirname:e}=await import("path"),{fileURLToPath:i}=await impo
           platform: "node",
           stdin: { contents: scriptRunner, resolveDir: __dirname },
           bundle: true,
-          outfile: options.output,
+          // TODO do I need to make the outfile joined with the current working directory?
+
+          outfile: path.resolve(cwd, options.output),
           external: ["node:*", ...options.external],
           minify: true,
+          absWorkingDir: projectDirectory,
           banner: { js: `#!/usr/bin/env node\n\n${ESM_REQUIRE_SHIM}` },
         });
       } catch (error) {
@@ -361,7 +325,6 @@ async function requireElm(compiledElmPath) {
 function generatorWrapperFile(moduleName) {
   return `port module Main exposing (main)
 
-import Bytes
 import BackendTask exposing (BackendTask)
 import FatalError
 import Cli.Program as Program
@@ -378,7 +341,7 @@ main =
         , toJsPort = toJsPort
         , fromJsPort = fromJsPort identity
         , gotBatchSub = gotBatchSub identity
-        , sendPageData = sendPageData
+        , sendPageData = \\_ -> Cmd.none
         }
 
 
@@ -389,13 +352,57 @@ port fromJsPort : (Decode.Value -> msg) -> Sub msg
 
 
 port gotBatchSub : (Decode.Value -> msg) -> Sub msg
-
-
-port sendPageData : { oldThing : Encode.Value, binaryPageData : Bytes.Bytes } -> Cmd msg
 `;
 }
 function collect(value, previous) {
   return previous.concat([value]);
 }
 
+async function compileElmForScript(elmModulePath) {
+  const { moduleName, projectDirectory, sourceDirectory } =
+    resolveInputPathOrModuleName(elmModulePath);
+  const splitModuleName = moduleName.split(".");
+  const expectedFilePath = path.join(
+    sourceDirectory,
+    `${splitModuleName.join("/")}.elm`
+  );
+  if (!fs.existsSync(expectedFilePath)) {
+    throw `I couldn't find a module named ${expectedFilePath}`;
+  }
+  // await codegen.generate("");
+  ensureDirSync(path.join(process.cwd(), ".elm-pages", "http-response-cache"));
+  if (fs.existsSync("./codegen/")) {
+    await runElmCodegenInstall();
+  }
+
+  ensureDirSync(`${projectDirectory}/elm-stuff`);
+  ensureDirSync(`${projectDirectory}/elm-stuff/elm-pages/.elm-pages`);
+  await fs.promises.writeFile(
+    path.join(`${projectDirectory}/elm-stuff/elm-pages/.elm-pages/Main.elm`),
+    generatorWrapperFile(moduleName)
+  );
+  let executableName = await lamderaOrElmFallback();
+  try {
+    await which("lamdera");
+  } catch (error) {
+    await which("elm");
+    executableName = "elm";
+  }
+  await rewriteElmJson(
+    `${projectDirectory}/elm.json`,
+    `${projectDirectory}/elm-stuff/elm-pages/elm.json`,
+    { executableName }
+  );
+}
+
+async function lamderaOrElmFallback() {
+  try {
+    await which("lamdera");
+    return "lamdera";
+  } catch (error) {
+    await which("elm");
+    return "elm";
+  }
+}
+
 main();

package/generator/src/compatibility-key.js

@@ -1,3 +1,3 @@
 export const compatibilityKey = 12;
 
-export const packageVersion = "3.0.0-beta.29";
+export const packageVersion = "3.0.0-beta.32";

package/generator/src/compile-elm.js

@@ -6,6 +6,8 @@ import * as path from "path";
 import * as kleur from "kleur/colors";
 import { inject } from "elm-hot";
 import { fileURLToPath } from "url";
+import { rewriteElmJson } from "./rewrite-elm-json-help.js";
+import { ensureDirSync } from "./file-helpers.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
@@ -16,7 +18,22 @@ export async function compileElmForBrowser(options) {
     "elm-stuff/elm-pages/",
     "browser-elm.js"
   );
-  await runElm(options, "./.elm-pages/Main.elm", pathToClientElm);
+  const secretDir = path.join(process.cwd(), "elm-stuff/elm-pages/browser-elm");
+  await fsHelpers.tryMkdir(secretDir);
+  rewriteElmJson(process.cwd(), secretDir, function (elmJson) {
+    elmJson["source-directories"] = elmJson["source-directories"].map(
+      (item) => {
+        return "../../../" + item;
+      }
+    );
+    return elmJson;
+  });
+  await runElm(
+    options,
+    "../../../.elm-pages/Main.elm",
+    pathToClientElm,
+    secretDir
+  );
   return fs.promises.writeFile(
     "./.elm-pages/cache/elm.js",
     inject(await fs.promises.readFile(pathToClientElm, "utf-8")).replace(

package/generator/src/render.js

@@ -133,7 +133,6 @@ function runGeneratorAppHelp(
 
     killApp = () => {
       app.ports.toJsPort.unsubscribe(portHandler);
-      app.ports.sendPageData.unsubscribe(portHandler);
       app.die();
       app = null;
       // delete require.cache[require.resolve(compiledElmPath)];
@@ -209,7 +208,6 @@ function runGeneratorAppHelp(
       }
     }
     app.ports.toJsPort.subscribe(portHandler);
-    app.ports.sendPageData.subscribe(portHandler);
   }).finally(() => {
     try {
       killApp();

package/generator/src/resolve-elm-module.js

@@ -0,0 +1,64 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+function findNearestElmJson(filePath) {
+  function searchForElmJson(directory) {
+    if (directory === "/") {
+      return null;
+    }
+
+    const elmJsonPath = path.join(directory, "elm.json");
+    return fs.existsSync(elmJsonPath)
+      ? elmJsonPath
+      : searchForElmJson(path.dirname(directory));
+  }
+
+  return searchForElmJson(path.dirname(filePath));
+}
+
+function getElmModuleName(inputPath) {
+  const filePath = path.normalize(
+    path.isAbsolute(inputPath) ? inputPath : path.resolve(inputPath)
+  );
+  const elmJsonPath = findNearestElmJson(filePath);
+
+  if (!elmJsonPath) {
+    throw new Error("No elm.json found");
+  }
+
+  const elmJson = JSON.parse(fs.readFileSync(elmJsonPath, "utf8"));
+  const sourceDirectories = elmJson["source-directories"];
+  const projectDirectory = path.dirname(elmJsonPath);
+
+  const matchingSourceDir = sourceDirectories
+    .map((sourceDir) => path.join(projectDirectory, sourceDir))
+    .find((absoluteSourceDir) => filePath.startsWith(absoluteSourceDir));
+
+  if (!matchingSourceDir) {
+    throw new Error(
+      "File is not in any source-directories specified in elm.json"
+    );
+  }
+
+  const relativePath = path.relative(matchingSourceDir, filePath);
+  const moduleName = relativePath
+    .replace(path.extname(relativePath), "")
+    .replace("/", ".");
+
+  return { projectDirectory, moduleName, sourceDirectory: matchingSourceDir };
+}
+
+export function resolveInputPathOrModuleName(inputPathOrModuleName) {
+  if (
+    /^[A-Z][a-zA-Z0-9_]*(\.[A-Z][a-zA-Z0-9_]*)*$/.test(inputPathOrModuleName)
+  ) {
+    const absolutePathForScript = path.resolve("./script/src");
+    return {
+      moduleName: inputPathOrModuleName,
+      projectDirectory: path.resolve("./script"),
+      sourceDirectory: path.resolve("./script/src"),
+    };
+  } else {
+    return getElmModuleName(inputPathOrModuleName);
+  }
+}

package/generator/src/rewrite-client-elm-json.js

@@ -27,6 +27,7 @@ function rewriteClientElmJsonHelp(elmJson) {
   elmJson["source-directories"] = elmJson["source-directories"].map((item) => {
     return "../../../" + item;
   });
+  elmJson["dependencies"]["direct"]["lamdera/codecs"] = "1.0.0";
   // 3. add our own secret My.elm module 😈
   elmJson["source-directories"].push(".elm-pages");
   elmJson["source-directories"].push("app");

package/generator/src/rewrite-elm-json-help.js

@@ -0,0 +1,56 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/**
+ * @param {string} sourceElmJsonPath
+ * @param {string} targetElmJsonPath
+ * @param {( (arg0: JSON) => JSON )?} modifyElmJson
+ */
+export async function rewriteElmJson(
+  sourceElmJsonPath,
+  targetElmJsonPath,
+  modifyElmJson
+) {
+  if (!modifyElmJson) {
+    modifyElmJson = function (json) {
+      return json;
+    };
+  }
+  var elmJson = JSON.parse(
+    (
+      await fs.promises.readFile(path.join(sourceElmJsonPath, "elm.json"))
+    ).toString()
+  );
+
+  let modifiedElmJson = modifyElmJson(elmJson);
+  // always add `lamdera/codecs` dependency
+  modifiedElmJson["dependencies"]["direct"]["lamdera/codecs"] = "1.0.0";
+
+  // write new elm.json
+  await writeFileIfChanged(
+    path.join(targetElmJsonPath, "elm.json"),
+    JSON.stringify(modifiedElmJson)
+  );
+}
+
+/**
+ * @param {fs.PathLike | fs.promises.FileHandle} filePath
+ * @param {string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | import("stream").Stream} content
+ */
+async function writeFileIfChanged(filePath, content) {
+  if (
+    !(await fileExists(filePath)) ||
+    (await fs.promises.readFile(filePath, "utf8")) !== content
+  ) {
+    await fs.promises.writeFile(filePath, content);
+  }
+}
+/**
+ * @param {fs.PathLike} file
+ */
+function fileExists(file) {
+  return fs.promises
+    .access(file, fs.constants.F_OK)
+    .then(() => true)
+    .catch(() => false);
+}

package/generator/src/rewrite-elm-json.js

@@ -1,6 +1,10 @@
 import * as fs from "node:fs";
 
-export async function rewriteElmJson(sourceElmJsonPath, targetElmJsonPath) {
+export async function rewriteElmJson(
+  sourceElmJsonPath,
+  targetElmJsonPath,
+  options
+) {
   var elmJson = JSON.parse(
     (await fs.promises.readFile(sourceElmJsonPath)).toString()
   );
@@ -9,11 +13,11 @@ export async function rewriteElmJson(sourceElmJsonPath, targetElmJsonPath) {
 
   await writeFileIfChanged(
     targetElmJsonPath,
-    JSON.stringify(rewriteElmJsonHelp(elmJson))
+    JSON.stringify(rewriteElmJsonHelp(elmJson, options))
   );
 }
 
-function rewriteElmJsonHelp(elmJson) {
+function rewriteElmJsonHelp(elmJson, options) {
   // The internal generated file will be at:
   // ./elm-stuff/elm-pages/
   // So, we need to take the existing elmJson and
@@ -27,6 +31,12 @@ function rewriteElmJsonHelp(elmJson) {
   elmJson["source-directories"] = elmJson["source-directories"].map((item) => {
     return "../../" + item;
   });
+  if (options && options.executableName === "elm") {
+    // elm, don't add lamdera/codecs
+  } else {
+    // lamdera, add codecs dependency
+    elmJson["dependencies"]["direct"]["lamdera/codecs"] = "1.0.0";
+  }
   // 3. add our own secret My.elm module 😈
   elmJson["source-directories"].push(".elm-pages");
   return elmJson;

package/generator/template/elm.json

@@ -30,7 +30,6 @@
             "elm-community/result-extra": "2.4.0",
             "jluckyiv/elm-utc-date-strings": "1.0.0",
             "justinmimbs/date": "4.0.1",
-            "lamdera/codecs": "1.0.0",
             "mdgriffith/elm-codegen": "2.0.0",
             "miniBill/elm-codec": "2.0.0",
             "noahzgordon/elm-color-extra": "1.0.2",
@@ -62,4 +61,4 @@
         "direct": {},
         "indirect": {}
     }
-}
+}