feat: make the filters async

- Make you Eleventy builds much faster

Author: saneef

index.js

@@ -3,11 +3,11 @@ import getCollectionNewestGitCommitDate from "./src/getCollectionNewestGitCommit
 import getGitCommitDateFromPath from "./src/getGitCommitDateFromPath.js";
 
 export default function (eleventyConfig) {
-  eleventyConfig.addFilter(
+  eleventyConfig.addAsyncFilter(
     "getGitCommitDateFromPath",
     getGitCommitDateFromPath,
   );
-  eleventyConfig.addFilter(
+  eleventyConfig.addAsyncFilter(
     "getCollectionNewestGitCommitDate",
     getCollectionNewestGitCommitDate,
   );

src/getCollectionNewestGitCommitDate.js

@@ -5,23 +5,27 @@ import memoize from "./utils/memoize.js";
 /**
  * Gets the collection's newest Git commit date.
  *
- * @param {object[]} collection The collection
- * @returns {Date | undefined} The collection newest git commit date.
+ * @param {object[]} collection Collection
+ * @returns {Promise<Date | undefined>} Newest git commit date among the items
+ *   in the collection
  */
-function getCollectionNewestGitCommitDate(collection) {
+async function getCollectionNewestGitCommitDate(collection) {
   if (!collection || !collection.length) {
     return;
   }
 
-  const timestamps = collection
-    .map((item) => getGitCommitDateFromPath(item.inputPath))
+  const timestamps = await Promise.all(
+    collection.map((item) => getGitCommitDateFromPath(item.inputPath)),
+  );
+
+  const dates = timestamps
     // Timestamps will be undefined for the paths not
     // yet commited to Git. So weeding them out.
     .filter((ts) => Boolean(ts))
-    .map((ts) => /** @type Date */ (ts).getTime());
+    .map((ts) => ts.getTime());
 
-  if (timestamps.length) {
-    return new Date(Math.max(...timestamps));
+  if (dates.length) {
+    return new Date(Math.max(...dates));
   }
 }
 

src/getGitCommitDateFromPath.js

@@ -1,7 +1,6 @@
 // @ts-check
-import spawn from "cross-spawn";
-import path from "node:path";
 import memoize from "./utils/memoize.js";
+import { spawnAsync } from "./utils/spawn.js";
 
 /**
  * Gets the Git commit date from path.
@@ -10,29 +9,25 @@ import memoize from "./utils/memoize.js";
  * https://github.com/vuejs/vuepress/blob/master/packages/%40vuepress/plugin-last-updated/
  *
  * @param {string} filePath The file path
- * @returns {Date | undefined} The git commit date if path is commited to Git.
+ * @returns {Promise<Date | undefined>} Commit date if path is commited to Git,
+ *   otherwise `undefined`
  */
-function getGitCommitDateFromPath(filePath) {
+async function getGitCommitDateFromPath(filePath) {
   let output;
 
   try {
-    output = spawn.sync(
-      "git",
-      ["log", "-1", "--format=%at", path.basename(filePath)],
-      { cwd: path.dirname(filePath) },
-    );
-  } catch {
+    output = await spawnAsync("git", ["log", "-1", "--format=%at", filePath]);
+  } catch (e) {
+    console.log(e);
     throw new Error("Fail to run 'git log'");
   }
 
-  if (output && output.stdout) {
-    const ts = parseInt(output.stdout.toString("utf-8"), 10) * 1000;
+  const ts = parseInt(output, 10) * 1000;
 
-    // Paths not commited to Git returns empty timestamps, resulting in NaN.
-    // So, convert only valid timestamps.
-    if (!isNaN(ts)) {
-      return new Date(ts);
-    }
+  // Paths not commited to Git returns empty timestamps, resulting in NaN.
+  // So, convert only valid timestamps.
+  if (!isNaN(ts)) {
+    return new Date(ts);
   }
 }
 

src/utils/spawn.js

@@ -0,0 +1,28 @@
+import { spawn } from "node:child_process";
+
+export function spawnAsync(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const cmd = spawn(command, args, options);
+    const res = [];
+    cmd.stdout.on("data", (data) => {
+      res.push(data.toString("utf8"));
+    });
+
+    const err = [];
+    cmd.stderr.on("data", (data) => {
+      err.push(data.toString("utf8"));
+    });
+
+    cmd.on("close", (code) => {
+      if (err.length > 0) {
+        reject(err.join("\n"));
+      } else if (code === 1) {
+        reject(
+          new Error("Internal error: process closed with error exit code."),
+        );
+      } else {
+        resolve(res.join("\n"));
+      }
+    });
+  });
+}

tests/getCollectionNewestGitCommitDate.js

@@ -7,24 +7,24 @@ import { getCollectionNewestGitCommitDate } from "../index.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-test("Get newest commit date of collection", (t) => {
+test("Get newest commit date of collection", async (t) => {
   const collection = [
     { inputPath: path.join(__dirname, "./fixtures/sample.md") },
     { inputPath: path.join(__dirname, "./fixtures/another-sample-file.md") },
   ];
-  const date = getCollectionNewestGitCommitDate(collection);
+  const date = await getCollectionNewestGitCommitDate(collection);
   t.truthy(date);
   t.is(date.toISOString(), "2021-08-19T09:57:47.000Z");
 });
 
 test("Shouldn't get commit date from an empty collection", async (t) => {
   const collection = [];
 
-  t.is(getCollectionNewestGitCommitDate(collection), undefined);
+  t.is(await getCollectionNewestGitCommitDate(collection), undefined);
 });
 
 test("Shouldn't get commit date from collection of uncommited files", async (t) => {
-  const outputBase = path.join("tests/output/");
+  const outputBase = path.join(__dirname, "output/collection");
   const collection = [
     { inputPath: path.join(outputBase, "test-01.md") },
     { inputPath: path.join(outputBase, "test-02.md") },
@@ -35,7 +35,7 @@ test("Shouldn't get commit date from collection of uncommited files", async (t)
   await mkdir(outputBase, { recursive: true });
   await Promise.all(collection.map((p) => writeFile(p.inputPath, "")));
 
-  t.is(getCollectionNewestGitCommitDate(collection), undefined);
+  t.is(await getCollectionNewestGitCommitDate(collection), undefined);
 
   await rimraf(outputBase);
 });

tests/getGitCommitDateFromPath.js

@@ -7,24 +7,22 @@ import { getGitCommitDateFromPath } from "../index.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-test("Get commit date of a committed file", (t) => {
+test("Get commit date of a committed file", async (t) => {
   const filePath = path.join(__dirname, "./fixtures/sample.md");
-  const date = getGitCommitDateFromPath(filePath);
+  const date = await getGitCommitDateFromPath(filePath);
   t.truthy(date);
   t.is(date.toISOString(), "2021-08-19T09:57:47.000Z");
 });
 
 test("Should not get commit date of a uncommitted file", async (t) => {
-  const outputBase = path.join(__dirname, "/output/");
+  const outputBase = path.join(__dirname, "/output/single-file-path");
   const filePath = path.join(outputBase, "test.md");
   await rimraf(outputBase);
 
-  await mkdir(outputBase, { recursive: true }, (err) => {
-    console.error(err);
-  });
+  await mkdir(outputBase, { recursive: true });
   await writeFile(filePath, "");
 
-  t.is(getGitCommitDateFromPath(filePath), undefined);
+  t.is(await getGitCommitDateFromPath(filePath), undefined);
 
   await rimraf(outputBase);
 });