elm-pages 3.0.12 → 3.0.14

package/generator/src/request-cache.js

@@ -9,7 +9,7 @@ const defaultHttpCachePath = "./.elm-pages/http-cache";
 
 /**
  * @param {string} mode
- * @param {{url: string;headers: {[x: string]: string;};method: string;body: Body;}} rawRequest
+ * @param {{url: string;headers: {[x: string]: string;};method: string;body: Body; }} rawRequest
  * @param {Record<string, unknown>} portsFile
  * @param {boolean} hasFsAccess
  * @returns {Promise<Response>}
@@ -92,12 +92,18 @@ export function lookupOrPerform(
             }),
           });
         } else {
-          console.time(`BackendTask.Custom.run "${portName}"`);
+          !rawRequest.quiet &&
+            console.time(`BackendTask.Custom.run "${portName}"`);
+          let context = {
+            cwd: path.resolve(...rawRequest.dir),
+            quiet: rawRequest.quiet,
+            env: { ...process.env, ...rawRequest.env },
+          };
           try {
             resolve({
               kind: "response-json",
               value: jsonResponse(
-                toElmJson(await portBackendTask[portName](input))
+                toElmJson(await portBackendTask[portName](input, context))
               ),
             });
           } catch (portCallError) {
@@ -129,7 +135,8 @@ export function lookupOrPerform(
               });
             }
           }
-          console.timeEnd(`BackendTask.Custom.run "${portName}"`);
+          !rawRequest.quiet &&
+            console.timeEnd(`BackendTask.Custom.run "${portName}"`);
         }
       } catch (error) {
         console.trace(error);
@@ -140,7 +147,7 @@ export function lookupOrPerform(
       }
     } else {
       try {
-        console.time(`fetch ${request.url}`);
+        !rawRequest.quiet && console.time(`fetch ${request.url}`);
         const response = await safeFetch(makeFetchHappen, request.url, {
           method: request.method,
           body: request.body,
@@ -151,7 +158,7 @@ export function lookupOrPerform(
           ...rawRequest.cacheOptions,
         });
 
-        console.timeEnd(`fetch ${request.url}`);
+        !rawRequest.quiet && console.timeEnd(`fetch ${request.url}`);
         const expectString = request.headers["elm-pages-internal"];
 
         let body;

package/generator/src/spinnies/index.js

@@ -0,0 +1,200 @@
+'use strict';
+
+import * as readline from 'readline';
+import * as chalk from "kleur/colors";
+import cliCursor from 'cli-cursor';
+
+
+import { purgeSpinnerOptions, purgeSpinnersOptions, colorOptions, breakText, getLinesLength, terminalSupportsUnicode } from './utils.js';
+import { dots, dashes, writeStream, cleanStream } from './utils.js';
+
+export class Spinnies {
+  constructor(options = {}) {
+    options = purgeSpinnersOptions(options);
+    this.options = {
+	// TODO kleur doesn't support brightGreen, only nested function or chained syntax
+//       spinnerColor: 'brightGreen',
+      spinnerColor: 'green',
+      succeedColor: 'green',
+      failColor: 'red',
+      spinner: terminalSupportsUnicode() ? dots : dashes,
+      disableSpins: false,
+      ...options
+    };
+    this.spinners = {};
+    this.isCursorHidden = false;
+    this.currentInterval = null;
+    this.stream = process.stderr;
+    this.lineCount = 0;
+    this.currentFrameIndex = 0;
+    this.spin = !this.options.disableSpins && !process.env.CI && process.stderr && process.stderr.isTTY;
+    this.bindSigint();
+  }
+
+  pick(name) {
+    return this.spinners[name];
+  }
+
+  add(name, options = {}) {
+    if (typeof name !== 'string') throw Error('A spinner reference name must be specified');
+    if (!options.text) options.text = name;
+    const spinnerProperties = {
+      ...colorOptions(this.options),
+      succeedPrefix: this.options.succeedPrefix,
+      failPrefix: this.options.failPrefix,
+      status: 'spinning',
+      ...purgeSpinnerOptions(options),
+    };
+
+    this.spinners[name] = spinnerProperties;
+    this.updateSpinnerState();
+
+    return spinnerProperties;
+  }
+
+  update(name, options = {}) {
+    const { status } = options;
+    this.setSpinnerProperties(name, options, status);
+    this.updateSpinnerState();
+
+    return this.spinners[name];
+  }
+
+  succeed(name, options = {}) {
+    this.setSpinnerProperties(name, options, 'succeed');
+    this.updateSpinnerState();
+
+    return this.spinners[name];
+  }
+
+  fail(name, options = {}) {
+    this.setSpinnerProperties(name, options, 'fail');
+    this.updateSpinnerState();
+
+    return this.spinners[name];
+  }
+
+  remove(name) {
+    if (typeof name !== 'string') throw Error('A spinner reference name must be specified');
+    const spinner = this.spinners[name];
+    delete this.spinners[name];
+
+    return spinner;
+  }
+
+  stopAll(newStatus = 'stopped') {
+    Object.keys(this.spinners).forEach(name => {
+      const { status: currentStatus } = this.spinners[name];
+      if (currentStatus !== 'fail' && currentStatus !== 'succeed' && currentStatus !== 'non-spinnable') {
+        if (newStatus === 'succeed' || newStatus === 'fail') {
+          this.spinners[name].status = newStatus;
+          this.spinners[name].color = this.options[`${newStatus}Color`];
+        } else {
+          this.spinners[name].status = 'stopped';
+          this.spinners[name].color = 'grey';
+        }
+      }
+    });
+    this.checkIfActiveSpinners();
+
+    return this.spinners;
+  }
+
+  hasActiveSpinners() {
+    return !!Object.values(this.spinners).find(({ status }) => status === 'spinning');
+  }
+
+  setSpinnerProperties(name, options, status) {
+    if (typeof name !== 'string') throw Error('A spinner reference name must be specified');
+    if (!this.spinners[name]) throw Error(`No spinner initialized with name ${name}`);
+    options = purgeSpinnerOptions(options);
+    status = status || 'spinning';
+
+    this.spinners[name] = { ...this.spinners[name], ...options, status };
+  }
+
+  updateSpinnerState(name, options = {}, status) {
+    if (this.spin) {
+      clearInterval(this.currentInterval);
+      this.currentInterval = this.loopStream();
+      if (!this.isCursorHidden) cliCursor.hide();
+      this.isCursorHidden = true;
+      this.checkIfActiveSpinners();
+    } else {
+      this.setRawStreamOutput();
+    }
+  }
+
+  loopStream() {
+    const { frames, interval } = this.options.spinner;
+    return setInterval(() => {
+      this.setStreamOutput(frames[this.currentFrameIndex]);
+      this.currentFrameIndex = this.currentFrameIndex === frames.length - 1 ? 0 : ++this.currentFrameIndex
+    }, interval);
+  }
+
+  setStreamOutput(frame = '') {
+    let output = '';
+    const linesLength = [];
+    const hasActiveSpinners = this.hasActiveSpinners();
+    Object
+      .values(this.spinners)
+      .map(({ text, status, color, spinnerColor, succeedColor, failColor, succeedPrefix, failPrefix, indent }) => {
+        let line;
+        let prefixLength = indent || 0;
+        if (status === 'spinning') {
+          prefixLength += frame.length + 1;
+          text = breakText(text, prefixLength);
+          line = `${chalk[spinnerColor](frame)} ${color ? chalk[color](text) : text}`;
+        } else {
+          if (status === 'succeed') {
+            prefixLength += succeedPrefix.length + 1;
+            if (hasActiveSpinners) text = breakText(text, prefixLength);
+            line = `${chalk.green(succeedPrefix)} ${chalk[succeedColor](text)}`;
+          } else if (status === 'fail') {
+            prefixLength += failPrefix.length + 1;
+            if (hasActiveSpinners) text = breakText(text, prefixLength);
+            line = `${chalk.red(failPrefix)} ${chalk[failColor](text)}`;
+          } else {
+            if (hasActiveSpinners) text = breakText(text, prefixLength);
+            line = color ? chalk[color](text) : text;
+          }
+        }
+        linesLength.push(...getLinesLength(text, prefixLength));
+        output += indent ? `${" ".repeat(indent)}${line}\n` : `${line}\n`;
+      });
+
+    if(!hasActiveSpinners) readline.clearScreenDown(this.stream);
+    writeStream(this.stream, output, linesLength);
+    if (hasActiveSpinners) cleanStream(this.stream, linesLength);
+    this.lineCount = linesLength.length;
+  }
+
+  setRawStreamOutput() {
+    Object.values(this.spinners).forEach(i => {
+      process.stderr.write(`- ${i.text}\n`);
+    });
+  }
+
+  checkIfActiveSpinners() {
+    if (!this.hasActiveSpinners()) {
+      if (this.spin) {
+        this.setStreamOutput();
+        readline.moveCursor(this.stream, 0, this.lineCount);
+        clearInterval(this.currentInterval);
+        this.isCursorHidden = false;
+        cliCursor.show();
+      }
+      this.spinners = {};
+    }
+  }
+
+  bindSigint(lines) {
+    process.removeAllListeners('SIGINT');
+    process.on('SIGINT', () => {
+      cliCursor.show();
+      readline.moveCursor(process.stderr, 0, this.lineCount);
+      process.exit(0);
+    });
+  }
+}

package/generator/src/spinnies/utils.js

@@ -0,0 +1,123 @@
+'use strict';
+
+// source: https://github.com/jbcarpanelli/spinnies/blob/master/utils.js
+// Code  vemodified to ESM syntax from original repo
+
+import * as readline from "readline";
+// original code dependend on this for `getLinesLength`. Is this necessary?
+// const stripAnsi = require('strip-ansi');
+export const { dashes,dots } =
+{
+  "dots": {
+    "interval": 50,
+    "frames": ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+  },
+  "dashes": {
+    "interval": 80,
+    "frames": ["-", "_"]
+  }
+}
+
+const VALID_STATUSES = ['succeed', 'fail', 'spinning', 'non-spinnable', 'stopped'];
+const VALID_COLORS = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white', 'gray', 'redBright', 'greenBright', 'yellowBright', 'blueBright', 'magentaBright', 'cyanBright', 'whiteBright'];
+
+export function purgeSpinnerOptions(options) {
+  const { text, status, indent } = options;
+  const opts = { text, status, indent };
+  const colors = colorOptions(options);
+
+  if (!VALID_STATUSES.includes(status)) delete opts.status;
+  if (typeof text !== 'string') delete opts.text;
+  if (typeof indent !== 'number') delete opts.indent;
+
+  return { ...colors, ...opts };
+}
+
+export function purgeSpinnersOptions({ spinner, disableSpins, ...others }) {
+  const colors = colorOptions(others);
+  const prefixes = prefixOptions(others);
+  const disableSpinsOption = typeof disableSpins === 'boolean' ? { disableSpins } : {};
+  spinner = turnToValidSpinner(spinner);
+
+  return { ...colors, ...prefixes, ...disableSpinsOption, spinner }
+}
+
+function turnToValidSpinner(spinner = {}) {
+  const platformSpinner = terminalSupportsUnicode() ? dots : dashes;
+  if (!typeof spinner === 'object') return platformSpinner;
+  let { interval, frames } = spinner;
+  if (!Array.isArray(frames) || frames.length < 1) frames = platformSpinner.frames;
+  if (typeof interval !== 'number') interval = platformSpinner.interval;
+
+  return { interval, frames };
+}
+
+export function colorOptions({ color, succeedColor, failColor, spinnerColor }) {
+  const colors = { color, succeedColor, failColor, spinnerColor };
+  Object.keys(colors).forEach(key => {
+    if (!VALID_COLORS.includes(colors[key])) delete colors[key];
+  });
+
+  return colors;
+}
+
+function prefixOptions({ succeedPrefix, failPrefix }) {
+  if(terminalSupportsUnicode()) {
+    succeedPrefix = succeedPrefix || '✓';
+    failPrefix = failPrefix || '✖';
+  } else {
+    succeedPrefix = succeedPrefix || '√';
+    failPrefix = failPrefix || '×';
+  }
+
+  return { succeedPrefix, failPrefix };
+}
+
+export function breakText(text, prefixLength) {
+  return text.split('\n')
+    .map((line, index) => index === 0 ? breakLine(line, prefixLength) : breakLine(line, 0))
+    .join('\n');
+}
+
+function breakLine(line, prefixLength) {
+  const columns = process.stderr.columns || 95;
+  return line.length  >= columns - prefixLength
+    ? `${line.substring(0, columns - prefixLength - 1)}\n${
+      breakLine(line.substring(columns - prefixLength - 1, line.length), 0)
+    }`
+    : line;
+}
+
+// function getLinesLength(text, prefixLength) {
+//   return stripAnsi(text)
+//     .split('\n')
+//     .map((line, index) => index === 0 ? line.length + prefixLength : line.length);
+// }
+export function getLinesLength(text, prefixLength) {
+  return text.split('\n')
+    .map((line, index) => index === 0 ? line.length + prefixLength : line.length);
+}
+
+export function writeStream(stream, output, rawLines) {
+  stream.write(output);
+  readline.moveCursor(stream, 0, -rawLines.length);
+}
+
+export function cleanStream(stream, rawLines) {
+  rawLines.forEach((lineLength, index) => {
+    readline.moveCursor(stream, lineLength, index);
+    readline.clearLine(stream, 1);
+    readline.moveCursor(stream, -lineLength, -index);
+  });
+  readline.moveCursor(stream, 0, rawLines.length);
+  readline.clearScreenDown(stream);
+  readline.moveCursor(stream, 0, -rawLines.length);
+}
+
+export function terminalSupportsUnicode() {
+    // The default command prompt and powershell in Windows do not support Unicode characters.
+    // However, the VSCode integrated terminal and the Windows Terminal both do.
+    return process.platform !== 'win32'
+      || process.env.TERM_PROGRAM === 'vscode'
+      || !!process.env.WT_SESSION
+}

package/generator/src/validate-stream.js

@@ -0,0 +1,25 @@
+// source: https://www.30secondsofcode.org/js/s/typecheck-nodejs-streams/
+
+export function isReadableStream(val) {
+  return (
+    val !== null &&
+    typeof val === "object" &&
+    typeof val.pipe === "function" &&
+    typeof val._read === "function" &&
+    typeof val._readableState === "object"
+  );
+}
+
+export function isWritableStream(val) {
+  return (
+    val !== null &&
+    typeof val === "object" &&
+    typeof val.pipe === "function" &&
+    typeof val._write === "function" &&
+    typeof val._writableState === "object"
+  );
+}
+
+export function isDuplexStream(val) {
+  return isReadableStream(val) && isWritableStream(val);
+}

package/generator/template/elm.json

@@ -14,7 +14,7 @@
             "dillonkearns/elm-bcp47-language-tag": "2.0.0",
             "dillonkearns/elm-form": "3.0.0",
             "dillonkearns/elm-markdown": "7.0.1",
-            "dillonkearns/elm-pages": "10.0.3",
+            "dillonkearns/elm-pages": "10.1.0",
             "elm/browser": "1.0.2",
             "elm/bytes": "1.0.8",
             "elm/core": "1.0.5",
@@ -30,8 +30,8 @@
             "elm-community/list-extra": "8.7.0",
             "elm-community/result-extra": "2.4.0",
             "jluckyiv/elm-utc-date-strings": "1.0.0",
-            "justinmimbs/date": "4.0.1",
-            "mdgriffith/elm-codegen": "4.1.1",
+            "justinmimbs/date": "4.1.0",
+            "mdgriffith/elm-codegen": "4.2.1",
             "miniBill/elm-codec": "2.1.0",
             "noahzgordon/elm-color-extra": "1.0.2",
             "robinheghan/fnv1a": "1.0.0",
@@ -49,7 +49,7 @@
             "elm-community/basics-extra": "4.1.0",
             "elm-community/maybe-extra": "5.3.0",
             "fredcy/elm-parseint": "2.0.1",
-            "miniBill/elm-unicode": "1.1.0",
+            "miniBill/elm-unicode": "1.1.1",
             "robinheghan/murmur3": "1.0.0",
             "rtfeldman/elm-hex": "1.0.0",
             "rtfeldman/elm-iso8601-date-strings": "1.1.4",

package/generator/template/package.json

@@ -7,15 +7,15 @@
     "build": "elm-pages build"
   },
   "devDependencies": {
-    "elm-codegen": "^0.5.1",
+    "elm-codegen": "^0.5.3",
     "elm-optimize-level-2": "^0.3.5",
-    "elm-pages": "^3.0.10",
-    "elm-review": "^2.10.3",
-    "elm-tooling": "^1.15.0",
+    "elm-pages": "^3.0.14",
+    "elm-review": "^2.11.1",
+    "elm-tooling": "^1.15.1",
     "lamdera": "^0.19.1-1.2.1-1",
-    "vite": "^5.0.11"
+    "vite": "^5.2.10"
   },
   "dependencies": {
-    "@netlify/functions": "^1.4.0"
+    "@netlify/functions": "^2.4.1"
   }
 }

package/generator/template/script/elm.json

@@ -8,12 +8,12 @@
     "dependencies": {
         "direct": {
             "dillonkearns/elm-cli-options-parser": "3.2.0",
-            "dillonkearns/elm-pages": "10.0.3",
+            "dillonkearns/elm-pages": "10.1.0",
             "elm/bytes": "1.0.8",
             "elm/core": "1.0.5",
             "elm/html": "1.0.0",
             "elm/json": "1.1.3",
-            "mdgriffith/elm-codegen": "4.1.1"
+            "mdgriffith/elm-codegen": "4.2.1"
         },
         "indirect": {
             "Chadtech/elm-bool-extra": "2.4.2",
@@ -37,20 +37,19 @@
             "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",
+            "justinmimbs/date": "4.1.0",
+            "miniBill/elm-codec": "2.1.0",
+            "miniBill/elm-unicode": "1.1.1",
             "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/elm-syntax": "7.3.2",
             "stil4m/structured-writer": "1.0.3",
-            "the-sett/elm-pretty-printer": "3.0.0",
+            "the-sett/elm-pretty-printer": "3.1.0",
             "the-sett/elm-syntax-dsl": "6.0.2",
-            "turboMaCk/non-empty-list-alias": "1.3.1",
             "vito/elm-ansi": "10.0.1"
         }
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elm-pages",
   "type": "module",
-  "version": "3.0.12",
+  "version": "3.0.14",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Type-safe static sites, written in pure elm with your own custom elm-markup syntax.",
@@ -25,8 +25,10 @@
   "author": "Dillon Kearns",
   "license": "BSD-3-Clause",
   "dependencies": {
+    "@sindresorhus/merge-streams": "^3.0.0",
     "busboy": "^1.6.0",
     "chokidar": "^3.5.3",
+    "cli-cursor": "^4.0.0",
     "commander": "^11.1.0",
     "connect": "^3.7.0",
     "cookie-signature": "^1.2.1",
@@ -56,13 +58,12 @@
     "@types/node": "^20.10.7",
     "@types/serve-static": "^1.15.5",
     "cypress": "^13.6.2",
-    "elm-codegen": "0.3.0",
+    "elm-codegen": "^0.5.0",
     "elm-optimize-level-2": "^0.3.5",
     "elm-review": "^2.10.3",
     "elm-test": "^0.19.1-revision12",
     "elm-tooling": "^1.15.0",
     "elm-verify-examples": "^5.3.0",
-    "elmi-to-json": "^1.4.3",
     "lamdera": "^0.19.1-1.2.1-1",
     "typescript": "^5.3.3",
     "vite": "^5.0.11",

package/src/BackendTask/Custom.elm

@@ -55,6 +55,44 @@ ${Object.keys(process.env).join("\n")}
 ```
 
 
+## Context Parameter
+
+If you define a second parameter in an exported `custom-backend-task` file function, you can access the `context` object. This object is a JSON object that contains the following fields:
+
+  - `cwd` - the current working directory for the `BackendTask`, set by calls to [`BackendTask.inDir`](BackendTask#inDir). If you don't use `BackendTask.inDir`, this will be the directory from which you are invoking `elm-pages`.
+  - `env` - the environment variables for the `BackendTask`, set by calls to [`BackendTask.withEnv`](BackendTask#withEnv)
+  - `quiet` - a boolean that is `true` if the `BackendTask` is running in quiet mode, set by calls to [`BackendTask.quiet`](BackendTask#quiet)
+
+If your `BackendTask.Custom` implementation depends on relative file paths, `process.env`, or has logging, it is recommended to use the `context.cwd` and `context.env` fields to ensure
+that the behavior of your `BackendTask.Custom` is consistent with the core `BackendTask` definitions provided by the framework. For example, the [`BackendTask.Glob`](BackendTask-Glob)
+API will resolve glob patterns relative to the `cwd` context.
+
+```js
+import toml from 'toml';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+
+export async function readTomlFile(relativeFilePath, context) {
+  const filePath = path.resolve(context.cwd, relativeFilePath);
+  // toml.parse returns a JSON representation of the TOML input
+  return toml.parse(fs.readFile(filePath));
+}
+```
+
+        import BackendTask exposing (BackendTask)
+        import BackendTask.Custom
+        import Json.Encode
+        import OptimizedDecoder as Decode
+
+        data : BackendTask FatalError String
+        data =
+            BackendTask.Custom.run "parseTomlFile"
+                (Json.Encode.string "my-file.toml")
+                myJsonDecoder
+                |> BackendTask.allowFatal
+
+
 ## 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` performs all `BackendTask`'s in parallel whenever possible.