rehype-og-card 0.3.2 → 0.4.0

package/README.md

@@ -10,7 +10,7 @@ Rehype plugin to convert text links to link cards inspired by [remark-link-card]
 | Shorten URLs displayed on link cards           |                                             ✅                                             |       ✅        |
 | Server-side cache for images                   |                                             ✅                                             |       ✅        |
 | Cache images with long URLs                    | ❌ ([implemented](https://github.com/gladevise/remark-link-card/pull/16) but not released) |       ✅        |
-| Build cache for Open Graph metadata and images |                                             ❌                                             | ✅ (image only) |
+| Build cache for Open Graph metadata and images |                                             ❌                                             |       ✅        |
 | Exclude links in lists from conversion         |                                             ❌                                             |       ✅        |
 | Exclude specific domains from conversion       |                                             ❌                                             |       ✅        |
 | Lazy loading images                            |                                             ❌                                             |       ✅        |

package/dist/index.js

@@ -8,8 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { convertTextToAnchorElement, createOGCard, isAnchorElement, isTextNode } from "./util/hast.js";
+import { checkFileExistsSync, createDirectorySync } from "./util/file.js";
 import { downloadImage, getOGData, isValidURL } from "./util/network.js";
-import { restoreBuildCache, saveBuildCache } from "./util/cache.js";
+import { restoreBuildCache, restoreOGDataBuildCache, saveBuildCacheFile, saveOGDataBuildCache } from "./util/cache.js";
 import { isElement } from "hast-util-is-element";
 import path from "path";
 import { visitParents } from "unist-util-visit-parents";
@@ -32,7 +33,7 @@ const DEFAULT_OPTIONS = {
  * @param options Plugin options.
  * @returns Transformer function.
  */
-// eslint-disable-next-line max-lines-per-function
+// eslint-disable-next-line max-lines-per-function, max-statements
 const rehypeOGCard = (options) => {
     const mergedOptions = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
     if (mergedOptions.buildCache && !mergedOptions.serverCache) {
@@ -40,15 +41,21 @@ const rehypeOGCard = (options) => {
     }
     mergedOptions.serverCachePath = path.posix.join(mergedOptions.serverCachePath, "./rehype-og-card/");
     mergedOptions.buildCachePath = path.posix.join(mergedOptions.buildCachePath, "./rehype-og-card/");
+    const buildCacheExists = checkFileExistsSync(mergedOptions.buildCachePath);
+    if (mergedOptions.buildCache) {
+        if (buildCacheExists) {
+            restoreBuildCache(mergedOptions.buildCachePath, mergedOptions.serverCachePath);
+        }
+        else {
+            createDirectorySync(mergedOptions.buildCachePath);
+        }
+    }
     /**
      * Transform function to create OG card from bare links.
      * @param tree Root node of the HAST tree.
      */
     // eslint-disable-next-line max-lines-per-function
     const transform = (tree) => __awaiter(void 0, void 0, void 0, function* () {
-        if (mergedOptions.buildCache) {
-            yield restoreBuildCache(mergedOptions.buildCachePath, mergedOptions.serverCachePath);
-        }
         const linkCardPromises = [];
         // eslint-disable-next-line max-statements, max-lines-per-function
         visitParents(tree, ["element", "text"], (node, ancestors) => {
@@ -85,30 +92,48 @@ const rehypeOGCard = (options) => {
             const targetURL = new URL(anchorNode.properties.href);
             if ((_a = mergedOptions.excludeDomains) === null || _a === void 0 ? void 0 : _a.includes(targetURL.hostname))
                 return;
-            // eslint-disable-next-line jsdoc/require-jsdoc, max-statements
+            // eslint-disable-next-line jsdoc/require-jsdoc, max-statements, max-lines-per-function
             const linkCardPromise = () => __awaiter(void 0, void 0, void 0, function* () {
-                const OGData = yield getOGData(anchorNode.properties.href, mergedOptions.crawlerUserAgent);
-                if (!OGData)
-                    return;
+                let OGData = mergedOptions.buildCache
+                    ? yield restoreOGDataBuildCache(anchorNode.properties.href, mergedOptions.buildCachePath)
+                    : null;
+                if (!OGData) {
+                    OGData = yield getOGData(anchorNode.properties.href, mergedOptions.crawlerUserAgent);
+                    if (!OGData)
+                        return;
+                    if (mergedOptions.buildCache) {
+                        yield saveOGDataBuildCache(anchorNode.properties.href, OGData, mergedOptions.buildCachePath);
+                    }
+                }
                 if (OGData.OGImageURL && mergedOptions.serverCache) {
                     const filename = yield downloadImage({
-                        directly: mergedOptions.serverCachePath,
+                        directory: mergedOptions.serverCachePath,
                         url: OGData.OGImageURL,
                         userAgent: mergedOptions.crawlerUserAgent
                     });
                     if (filename && mergedOptions.serverCache) {
                         OGData.OGImageURL = path.posix.join("/rehype-og-card", filename);
                     }
+                    if (filename && mergedOptions.buildCache) {
+                        const downloadedFilePath = path.join(mergedOptions.serverCachePath, filename);
+                        const buildCachePath = path.join(mergedOptions.buildCachePath, filename);
+                        yield saveBuildCacheFile(downloadedFilePath, buildCachePath);
+                    }
                 }
                 if (OGData.faviconURL && mergedOptions.serverCache) {
                     const filename = yield downloadImage({
-                        directly: mergedOptions.serverCachePath,
+                        directory: mergedOptions.serverCachePath,
                         url: OGData.faviconURL,
                         userAgent: mergedOptions.crawlerUserAgent
                     });
                     if (filename && mergedOptions.serverCache) {
                         OGData.faviconURL = path.posix.join("/rehype-og-card", filename);
                     }
+                    if (filename && mergedOptions.buildCache) {
+                        const downloadedFilePath = path.join(mergedOptions.serverCachePath, filename);
+                        const buildCachePath = path.join(mergedOptions.buildCachePath, filename);
+                        yield saveBuildCacheFile(downloadedFilePath, buildCachePath);
+                    }
                 }
                 if (mergedOptions.shortenURL) {
                     const shortenedURL = new URL(anchorNode.properties.href);
@@ -126,9 +151,6 @@ const rehypeOGCard = (options) => {
             linkCardPromises.push(linkCardPromise());
         });
         yield Promise.all(linkCardPromises);
-        if (mergedOptions.buildCache) {
-            yield saveBuildCache(mergedOptions.serverCachePath, mergedOptions.buildCachePath);
-        }
     });
     return transform;
 };

package/dist/util/cache.d.ts

@@ -1,13 +1,28 @@
+import { OGCardData } from "../types.js";
 /**
  * Save build cache if server cache exists.
  * @param serverCachePath Server cache path.
  * @param buildCachePath Build cache path.
  */
-declare const saveBuildCache: (serverCachePath: string, buildCachePath: string) => Promise<void>;
+declare const saveBuildCacheFile: (serverCachePath: string, buildCachePath: string) => Promise<void>;
 /**
  * Restore build cache if it exists.
  * @param buildCachePath Build cache path.
  * @param serverCachePath Server cache path.
  */
-declare const restoreBuildCache: (buildCachePath: string, serverCachePath: string) => Promise<void>;
-export { saveBuildCache, restoreBuildCache };
+declare const restoreBuildCache: (buildCachePath: string, serverCachePath: string) => void;
+/**
+ * Save OG data to build cache.
+ * @param url URL of the OG data.
+ * @param OGData OG data to save.
+ * @param buildCachePath Build cache path.
+ */
+declare const saveOGDataBuildCache: (url: string, OGData: OGCardData, buildCachePath: string) => Promise<void>;
+/**
+ * Restore OG data from build cache.
+ * @param url URL of the OG data.
+ * @param buildCachePath Build cache path.
+ * @returns Restored OG data. If not found, returns `null`.
+ */
+declare const restoreOGDataBuildCache: (url: string, buildCachePath: string) => Promise<OGCardData | null>;
+export { saveBuildCacheFile, restoreBuildCache, saveOGDataBuildCache, restoreOGDataBuildCache };

package/dist/util/cache.js

@@ -7,46 +7,59 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { checkFileExists } from "./file.js";
+import { checkFileExists, copyDirectory, generateFilename } from "./file.js";
 import fs from "fs/promises";
 import path from "path";
 /**
- * Copy directory from source to destination.
- * @param source Source directory.
- * @param destination Destination directory.
+ * Save build cache if server cache exists.
+ * @param serverCachePath Server cache path.
+ * @param buildCachePath Build cache path.
  */
-// eslint-disable-next-line max-statements
-const copyDirectory = (source, destination) => __awaiter(void 0, void 0, void 0, function* () {
-    const sourceExists = yield checkFileExists(source);
-    if (!sourceExists)
-        return;
-    const destinationExists = yield checkFileExists(destination);
-    if (!destinationExists) {
-        yield fs.mkdir(destination, { recursive: true });
-    }
-    const files = yield fs.readdir(source);
-    const promises = [];
-    for (const file of files) {
-        const sourceFile = path.join(source, file);
-        const destFile = path.join(destination, file);
-        promises.push(fs.copyFile(sourceFile, destFile));
+const saveBuildCacheFile = (serverCachePath, buildCachePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const serverCacheExists = yield checkFileExists(serverCachePath);
+    const buildCacheExists = yield checkFileExists(buildCachePath);
+    if (serverCacheExists && !buildCacheExists) {
+        yield fs.copyFile(serverCachePath, buildCachePath);
     }
-    yield Promise.all(promises);
 });
 /**
- * Save build cache if server cache exists.
+ * Restore build cache if it exists.
+ * @param buildCachePath Build cache path.
  * @param serverCachePath Server cache path.
+ */
+const restoreBuildCache = (buildCachePath, serverCachePath) => {
+    copyDirectory(buildCachePath, serverCachePath);
+};
+/**
+ * Save OG data to build cache.
+ * @param url URL of the OG data.
+ * @param OGData OG data to save.
  * @param buildCachePath Build cache path.
  */
-const saveBuildCache = (serverCachePath, buildCachePath) => __awaiter(void 0, void 0, void 0, function* () {
-    yield copyDirectory(serverCachePath, buildCachePath);
+const saveOGDataBuildCache = (url, OGData, buildCachePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const filename = generateFilename(url, false);
+    const savePath = `${path.join(buildCachePath, filename)}.json`;
+    const cacheDirectoryExists = yield checkFileExists(buildCachePath);
+    if (!cacheDirectoryExists) {
+        yield fs.mkdir(buildCachePath, { recursive: true });
+    }
+    yield fs.writeFile(savePath, JSON.stringify(OGData));
 });
 /**
- * Restore build cache if it exists.
+ * Restore OG data from build cache.
+ * @param url URL of the OG data.
  * @param buildCachePath Build cache path.
- * @param serverCachePath Server cache path.
+ * @returns Restored OG data. If not found, returns `null`.
  */
-const restoreBuildCache = (buildCachePath, serverCachePath) => __awaiter(void 0, void 0, void 0, function* () {
-    yield copyDirectory(buildCachePath, serverCachePath);
+const restoreOGDataBuildCache = (url, buildCachePath) => __awaiter(void 0, void 0, void 0, function* () {
+    const filename = generateFilename(url, false);
+    const savePath = `${path.join(buildCachePath, filename)}.json`;
+    try {
+        const data = yield fs.readFile(savePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch (_a) {
+        return null;
+    }
 });
-export { saveBuildCache, restoreBuildCache };
+export { saveBuildCacheFile, restoreBuildCache, saveOGDataBuildCache, restoreOGDataBuildCache };

package/dist/util/file.d.ts

@@ -4,4 +4,28 @@
  * @returns `true` if the file exists, `false` otherwise.
  */
 declare const checkFileExists: (filePath: string) => Promise<boolean>;
-export { checkFileExists };
+/**
+ * Check if the file exists.
+ * @param filePath Path to check.
+ * @returns `true` if the file exists, `false` otherwise.
+ */
+declare const checkFileExistsSync: (filePath: string) => boolean;
+/**
+ * Create directory.
+ * @param dir Directory path.
+ */
+declare const createDirectorySync: (dir: string) => void;
+/**
+ * Copy directory from source to destination.
+ * @param source Source directory.
+ * @param destination Destination directory.
+ */
+declare const copyDirectory: (source: string, destination: string) => void;
+/**
+ * Generate filename from URL.
+ * @param url URL to generate filename.
+ * @param extension Include extension in the filename.
+ * @returns Generated filename.
+ */
+declare const generateFilename: (url: string, extension?: boolean) => string;
+export { checkFileExists, checkFileExistsSync, createDirectorySync, copyDirectory, generateFilename };

package/dist/util/file.js

@@ -7,7 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import fs from "fs/promises";
+import { createHash } from "crypto";
+import fs from "fs";
+import path from "path";
 /**
  * Check if the file exists.
  * @param filePath Path to check.
@@ -15,11 +17,66 @@ import fs from "fs/promises";
  */
 const checkFileExists = (filePath) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        yield fs.access(filePath);
+        yield fs.promises.access(filePath);
         return true;
     }
     catch (_a) {
         return false;
     }
 });
-export { checkFileExists };
+/**
+ * Check if the file exists.
+ * @param filePath Path to check.
+ * @returns `true` if the file exists, `false` otherwise.
+ */
+const checkFileExistsSync = (filePath) => {
+    let result = false;
+    fs.access(filePath, (error) => {
+        result = !error;
+    });
+    return result;
+};
+/**
+ * Create directory.
+ * @param dir Directory path.
+ */
+const createDirectorySync = (dir) => {
+    fs.mkdir(dir, { recursive: true }, (error) => {
+        if (error) {
+            // eslint-disable-next-line no-console
+            console.error("[rehype-og-card] Failed to copy files: ", error);
+        }
+    });
+};
+/**
+ * Copy directory from source to destination.
+ * @param source Source directory.
+ * @param destination Destination directory.
+ */
+const copyDirectory = (source, destination) => {
+    const sourceExists = checkFileExistsSync(source);
+    if (!sourceExists)
+        return;
+    const destinationExists = checkFileExistsSync(destination);
+    if (!destinationExists) {
+        createDirectorySync(destination);
+    }
+    fs.cp(source, destination, { recursive: true }, (error) => {
+        if (error) {
+            // eslint-disable-next-line no-console
+            console.error("[rehype-og-card] Failed to copy files: ", error);
+        }
+    });
+};
+/**
+ * Generate filename from URL.
+ * @param url URL to generate filename.
+ * @param extension Include extension in the filename.
+ * @returns Generated filename.
+ */
+const generateFilename = (url, extension = true) => {
+    const hash = createHash("sha256").update(url).digest("hex");
+    const filename = extension ? hash + path.extname(new URL(url).pathname) : hash;
+    return filename;
+};
+export { checkFileExists, checkFileExistsSync, createDirectorySync, copyDirectory, generateFilename };

package/dist/util/network.d.ts

@@ -20,16 +20,16 @@ interface DownloadImageOptions {
     /**
      * Directory to save the downloaded image.
      */
-    directly: string;
+    directory: string;
     /**
      * User agent to use for fetching the image.
      */
     userAgent: string;
 }
 /**
- * Download image from given URL.
+ * Download image from given URL. If the image already exists, return the filename.
  * @param options Options to download image.
- * @returns Path to the downloaded image.
+ * @returns Filename of the downloaded image.
  */
 declare const downloadImage: (options: DownloadImageOptions) => Promise<string | null>;
 export { isValidURL, getOGData, downloadImage };

package/dist/util/network.js

@@ -7,8 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { checkFileExists } from "./file.js";
-import { createHash } from "crypto";
+import { checkFileExists, generateFilename } from "./file.js";
 import fs from "fs/promises";
 import path from "path";
 import scraper from "open-graph-scraper";
@@ -67,9 +66,9 @@ const getOGData = (url, userAgent) => __awaiter(void 0, void 0, void 0, function
     }
 });
 /**
- * Download image from given URL.
+ * Download image from given URL. If the image already exists, return the filename.
  * @param options Options to download image.
- * @returns Path to the downloaded image.
+ * @returns Filename of the downloaded image.
  */
 // eslint-disable-next-line max-statements
 const downloadImage = (options) => __awaiter(void 0, void 0, void 0, function* () {
@@ -79,14 +78,12 @@ const downloadImage = (options) => __awaiter(void 0, void 0, void 0, function* (
         return null;
     }
     try {
-        const hash = createHash("sha256").update(options.url).digest("hex");
-        const filename = hash + path.extname(new URL(options.url).pathname);
-        const savePath = path.posix.join(options.directly, filename);
+        const filename = generateFilename(options.url);
+        const savePath = path.posix.join(options.directory, filename);
         // If the file already exists, return the filename.
         const fileExists = yield checkFileExists(savePath);
-        if (fileExists) {
+        if (fileExists)
             return filename;
-        }
         const response = yield fetch(options.url, {
             headers: {
                 "user-agent": options.userAgent
@@ -94,7 +91,10 @@ const downloadImage = (options) => __awaiter(void 0, void 0, void 0, function* (
         });
         const arrayBuffer = yield response.arrayBuffer();
         const buffer = Buffer.from(arrayBuffer);
-        yield fs.mkdir(options.directly, { recursive: true });
+        const saveDirectoryExists = yield checkFileExists(options.directory);
+        if (!saveDirectoryExists) {
+            yield fs.mkdir(options.directory, { recursive: true });
+        }
         yield fs.writeFile(savePath, buffer);
         return filename;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rehype-og-card",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Rehype plugin to convert text links to link cards",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",