@jam-comments/server-utilities 4.1.0 → 4.3.0

package/dist/esm/injectSchema.test.js

@@ -0,0 +1,61 @@
+import { expect, it } from "vitest";
+import { injectSchema } from "./injectSchema";
+it("injects schema into markup", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="[{&quot;@context&quot;:&quot;https:\/\/schema.org&quot;,&quot;@type&quot;:&quot;Comment&quot;,&quot;name&quot;:&quot;Alexis&quot;,&quot;dateCreated&quot;:&quot;2022-10-28T10:41:49+00:00&quot;,&quot;url&quot;:&quot;https:\/\/macarthur.me\/posts\/dynamic-routing#comment-133&quot;}]"></div>
+
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(`
+<div id="jcComments">
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","comment":[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]}</script>
+</div>`);
+});
+it("returns markup if schema is not found", () => {
+    const markup = `
+<div id="jcComments">
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(markup);
+});
+it("returns markup if schema is not valid JSON", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="not-valid-json"></div>
+    <!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(markup);
+});
+it("injects even when JSON is not HTML-encoded", () => {
+    const markup = `
+<div id="jcComments">
+    <div jc-data="jcSchema" data-schema="[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]"></div>
+
+<!-- JC:SCHEMA -->
+</div>`;
+    const blogPostSchema = {
+        "@context": "http://schema.org",
+        "@type": "BlogPosting",
+    };
+    const result = injectSchema(markup, blogPostSchema);
+    expect(result).toEqual(`
+<div id="jcComments">
+    <script type="application/ld+json">{"@context":"http://schema.org","@type":"BlogPosting","comment":[{"@context":"https://schema.org","@type":"Comment","name":"Alexis","dateCreated":"2022-10-28T10:41:49+00:00","url":"https://macarthur.me/posts/dynamic-routing#comment-133"}]}</script>
+</div>`);
+});

package/dist/esm/markupFetcher.js

@@ -1,39 +1,101 @@
-import { getEnvironment, isValidTimezone } from "./utils";
-export const markupFetcher = (platform, fetchImplementation = fetch) => {
-    return async ({ tz = undefined, path, domain, apiKey, schema, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }) => {
-        const trimmedTimezone = tz?.trim();
-        if (trimmedTimezone && !isValidTimezone(trimmedTimezone)) {
-            throw new Error(`The timezone passed to JamComments is invalid: ${trimmedTimezone}`);
+import { injectSchema } from "./injectSchema";
+import { createTempDirectory, deleteTempDirectory, getEnvironment, isValidTimezone, parseJson, readFile, saveFile, } from "./utils";
+export async function fetchAll({ tz = undefined, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }, platform, fetchImplementation, batchMarkupFetcherImpl = batchMarkupFetcher) {
+    const fetchBatchMarkup = batchMarkupFetcherImpl(platform, fetchImplementation);
+    createTempDirectory();
+    let shouldKeepFetching = true;
+    let page = 1;
+    console.log("Fetching comments from JamComments! This might take a sec.");
+    try {
+        while (shouldKeepFetching) {
+            const { data: items, meta: { current_page, last_page }, } = await fetchBatchMarkup({
+                domain,
+                apiKey,
+                baseUrl,
+                environment,
+                page,
+                tz,
+            });
+            console.log(`Checking for comment data. Batch: ${current_page}/${last_page}`);
+            const saveMarkupPromises = items.map((item) => {
+                return saveFile(item.path, item.markup);
+            });
+            await Promise.all(saveMarkupPromises);
+            if (current_page === last_page) {
+                shouldKeepFetching = false;
+            }
+            else {
+                page++;
+            }
         }
-        const params = new URLSearchParams({
-            path: path || "/",
-            domain,
-        });
+    }
+    catch (error) {
+        deleteTempDirectory();
+        throw error;
+    }
+}
+export function batchMarkupFetcher(platform, fetchImplementation = fetch) {
+    return async ({ tz = undefined, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), page = 1, }) => {
+        const response = await makeMarkupRequest({ tz, domain, apiKey, baseUrl, environment, page }, "/api/v3/markup/all", fetchImplementation, platform);
+        return response.json();
+    };
+}
+export async function fetchFreshMarkup({ tz = undefined, path, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }, fetchImplementation = fetch, platform) {
+    const response = await makeMarkupRequest({ tz, path, domain, apiKey, baseUrl, environment }, "/api/v3/markup", fetchImplementation, platform);
+    return response.text();
+}
+export async function makeMarkupRequest({ tz = undefined, path = undefined, domain, apiKey, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), page = undefined, }, baseServicePath, fetchImplementation = fetch, platform) {
+    const trimmedTimezone = tz?.trim();
+    if (trimmedTimezone && !isValidTimezone(trimmedTimezone)) {
+        throw new Error(`The timezone passed to JamComments is invalid: ${trimmedTimezone}`);
+    }
+    const params = new URLSearchParams({
+        domain,
+    });
+    if (path) {
+        params.set("path", path);
+    }
+    if (page) {
+        params.set("page", page.toString());
+    }
+    if (trimmedTimezone) {
+        params.set("tz", trimmedTimezone);
+    }
+    if (environment !== "production") {
+        params.set("stub", "true");
+    }
+    const requestUrl = `${baseUrl}${baseServicePath}?${params}`;
+    const response = await fetchImplementation(requestUrl, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            Accept: "application/json",
+            "X-Platform": platform,
+        },
+    });
+    if (response.status === 401) {
+        throw new Error(`Unauthorized! Are your domain and JamComments API key set correctly?`);
+    }
+    if (!response.ok) {
+        throw new Error(`JamComments request failed! Status code: ${response.status}, message: ${response.statusText}, request URL: ${requestUrl}`);
+    }
+    return response;
+}
+export function markupFetcher(platform, fetchImplementation = fetch) {
+    return async ({ tz = undefined, path, domain, apiKey, schema, baseUrl = "https://go.jamcomments.com", environment = getEnvironment(), }) => {
+        path = path || "/";
+        const savedFile = readFile(path);
+        const markup = savedFile
+            ? savedFile
+            : await fetchFreshMarkup({ tz, path, domain, apiKey, baseUrl, environment }, fetchImplementation, platform);
         if (schema) {
             const preparedSchema = typeof schema !== "string" ? JSON.stringify(schema) : schema;
-            params.set("schema", preparedSchema);
-        }
-        if (trimmedTimezone) {
-            params.set("tz", trimmedTimezone);
-        }
-        if (environment !== "production") {
-            params.set("stub", "true");
-        }
-        const requestUrl = `${baseUrl}/api/v3/markup?${params}`;
-        const response = await fetchImplementation(requestUrl, {
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                Accept: "application/json",
-                "X-Platform": platform,
-            },
-        });
-        if (response.status === 401) {
-            throw new Error(`Unauthorized! Are your domain and JamComments API key set correctly?`);
-        }
-        if (!response.ok) {
-            throw new Error(`JamComments request failed! Status code: ${response.status}, message: ${response.statusText}, request URL: ${requestUrl}`);
+            const parsedSchema = parseJson(preparedSchema);
+            if (!parsedSchema) {
+                return markup;
+            }
+            return injectSchema(markup, parsedSchema);
         }
-        return await response.text();
+        return markup;
     };
-};
+}

package/dist/esm/markupFetcher.test.js

@@ -1,7 +1,204 @@
-import { describe, expect, it, vi } from "vitest";
-import { markupFetcher } from "./markupFetcher";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as injectSchema from "./injectSchema";
+import * as fetcherExports from "./markupFetcher";
+import { afterEach } from "node:test";
+import * as utilsExports from "./utils";
+const { deleteTempDirectory } = utilsExports;
+const { markupFetcher, batchMarkupFetcher } = fetcherExports;
+beforeEach(() => {
+    deleteTempDirectory();
+});
+afterEach(() => {
+    vi.resetAllMocks();
+});
+describe("fetchAll()", () => {
+    it("fetches all comments in a single request", async () => {
+        const saveFileSpy = vi.spyOn(utilsExports, "saveFile");
+        const mockBatchFetcher = vi.fn().mockReturnValue({
+            data: [
+                { path: "/test", markup: "markup1" },
+                { path: "/test2", markup: "markup2" },
+            ],
+            meta: {
+                current_page: 1,
+                from: 1,
+                last_page: 1,
+                path: "/test",
+                per_page: 10,
+                to: 2,
+                total: 2,
+            },
+        });
+        const batchMarkupFetcherMock = vi.fn().mockImplementation((a, b) => {
+            return mockBatchFetcher;
+        });
+        await fetcherExports.fetchAll({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "production",
+        }, "test_platform", vi.fn(), batchMarkupFetcherMock);
+        expect(batchMarkupFetcherMock).toHaveBeenCalledWith("test_platform", expect.anything());
+        expect(mockBatchFetcher).toHaveBeenCalledWith({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "https://go.jamcomments.com",
+            environment: "production",
+            page: 1,
+            tz: undefined,
+        });
+        expect(saveFileSpy).toHaveBeenCalledTimes(2);
+        expect(saveFileSpy).toHaveBeenCalledWith("/test", "markup1");
+        expect(saveFileSpy).toHaveBeenCalledWith("/test2", "markup2");
+    });
+    it("fetches all comments in multiple requests", async () => {
+        const saveFileSpy = vi.spyOn(utilsExports, "saveFile");
+        const mockBatchFetcher = vi
+            .fn()
+            .mockReturnValueOnce({
+            data: [
+                { path: "/test", markup: "markup1" },
+                { path: "/test2", markup: "markup2" },
+            ],
+            meta: {
+                current_page: 1,
+                from: 1,
+                last_page: 2,
+                path: "/test",
+                per_page: 2,
+                to: 2,
+            },
+        })
+            .mockReturnValueOnce({
+            data: [
+                { path: "/test3", markup: "markup3" },
+                { path: "/test4", markup: "markup4" },
+            ],
+            meta: {
+                current_page: 2,
+                from: 3,
+                last_page: 2,
+                path: "/test",
+                per_page: 2,
+                to: 4,
+            },
+        });
+        const batchMarkupFetcherMock = vi.fn().mockImplementation((a, b) => {
+            return mockBatchFetcher;
+        });
+        await fetcherExports.fetchAll({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "production",
+        }, "test_platform", vi.fn(), batchMarkupFetcherMock);
+        expect(batchMarkupFetcherMock).toHaveBeenCalledWith("test_platform", expect.anything());
+        expect(mockBatchFetcher).toHaveBeenCalledWith({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "https://go.jamcomments.com",
+            environment: "production",
+            page: 1,
+            tz: undefined,
+        });
+        expect(mockBatchFetcher).toHaveBeenCalledTimes(2);
+        expect(mockBatchFetcher).toHaveBeenCalledWith({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "https://go.jamcomments.com",
+            environment: "production",
+            page: 2,
+            tz: undefined,
+        });
+        expect(saveFileSpy).toHaveBeenCalledTimes(4);
+        expect(saveFileSpy).toHaveBeenCalledWith("/test", "markup1");
+        expect(saveFileSpy).toHaveBeenCalledWith("/test2", "markup2");
+    });
+    it("deletes the temp directory of anything fails", async () => {
+        const deleteTempDirectorySpy = vi.spyOn(utilsExports, "deleteTempDirectory");
+        const mockBatchFetcher = vi.fn().mockImplementation(() => {
+            throw new Error("test error");
+        });
+        const batchMarkupFetcherMock = vi.fn().mockImplementation((a, b) => {
+            return mockBatchFetcher;
+        });
+        try {
+            await fetcherExports.fetchAll({
+                domain: "test.com",
+                apiKey: "123abc",
+                environment: "production",
+            }, "test_platform", vi.fn(), batchMarkupFetcherMock);
+        }
+        catch (e) {
+            expect(e.message).toEqual("test error");
+        }
+        expect(deleteTempDirectorySpy).toHaveBeenCalledOnce();
+    });
+});
+describe("batchMarkupFetcher", () => {
+    it("constructs fetch request correctly", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                json: () => "results!",
+            };
+        });
+        const fetcher = batchMarkupFetcher("test", fetchMock);
+        const result = await fetcher({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "production",
+        });
+        expect(injectSchemaSpy).not.toHaveBeenCalled();
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup/all?domain=test.com&page=1", expect.objectContaining({
+            headers: expect.objectContaining({
+                Accept: "application/json",
+                Authorization: "Bearer 123abc",
+                "X-Platform": "test",
+            }),
+            method: "GET",
+        }));
+        expect(result).toEqual("results!");
+    });
+    it("stubs comments", async () => {
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                json: () => "results!",
+            };
+        });
+        const fetcher = batchMarkupFetcher("test", fetchMock);
+        const result = await fetcher({
+            domain: "test.com",
+            apiKey: "123abc",
+            environment: "development",
+        });
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup/all?domain=test.com&page=1&stub=true", expect.anything());
+        expect(result).toEqual("results!");
+    });
+    it("uses different base URL", async () => {
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                json: () => "results!",
+            };
+        });
+        const fetcher = batchMarkupFetcher("test", fetchMock);
+        const result = await fetcher({
+            domain: "test.com",
+            apiKey: "123abc",
+            baseUrl: "http://ur-mom.com",
+            environment: "production",
+        });
+        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup/all?domain=test.com&page=1", expect.anything());
+        expect(result).toEqual("results!");
+    });
+});
 describe("markupFetcher", () => {
     it("constructs fetch request correctly", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
         const fetchMock = vi.fn().mockImplementation(() => {
             return {
                 status: 200,
@@ -16,7 +213,8 @@ describe("markupFetcher", () => {
             apiKey: "123abc",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.objectContaining({
+        expect(injectSchemaSpy).not.toHaveBeenCalled();
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.objectContaining({
             headers: expect.objectContaining({
                 Accept: "application/json",
                 Authorization: "Bearer 123abc",
@@ -41,7 +239,7 @@ describe("markupFetcher", () => {
             apiKey: "123abc",
             environment: "development",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com&stub=true", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest&stub=true", expect.anything());
         expect(result).toEqual("results!");
     });
     it("uses different base URL", async () => {
@@ -60,7 +258,7 @@ describe("markupFetcher", () => {
             baseUrl: "http://ur-mom.com",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("respects production!!!", async () => {
@@ -79,7 +277,7 @@ describe("markupFetcher", () => {
             baseUrl: "http://ur-mom.com",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?path=%2Ftest&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("http://ur-mom.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("falls back to root path", async () => {
@@ -97,7 +295,7 @@ describe("markupFetcher", () => {
             apiKey: "123abc",
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2F&domain=test.com", expect.anything());
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2F", expect.anything());
         expect(result).toEqual("results!");
     });
     it("credentials are invalid", async () => {
@@ -132,9 +330,9 @@ describe("markupFetcher", () => {
     });
     describe("timezone validation", () => {
         it("throws error when invalid timezone is provided", async () => {
-            const fetchMock = vi.fn();
-            const fetcher = markupFetcher("test", fetchMock);
-            expect(fetchMock).not.toHaveBeenCalled();
+            const fetchImplMock = vi.fn();
+            const fetcher = markupFetcher("test", fetchImplMock);
+            expect(fetchImplMock).not.toHaveBeenCalled();
             expect(fetcher({
                 path: "/test",
                 domain: "test.com",
@@ -153,13 +351,13 @@ describe("markupFetcher", () => {
             });
             const fetcher = markupFetcher("test", fetchMock);
             const result = await fetcher({
-                path: null,
+                path: "/some/path",
                 domain: "test.com",
                 apiKey: "123abc",
                 tz: "America/New_York",
                 environment: "production",
             });
-            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2F&domain=test.com&tz=America%2FNew_York", expect.anything());
+            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Fsome%2Fpath&tz=America%2FNew_York", expect.anything());
             expect(result).toEqual("results!");
         });
         it("trims a valid timezone", async () => {
@@ -172,19 +370,20 @@ describe("markupFetcher", () => {
             });
             const fetcher = markupFetcher("test", fetchMock);
             const result = await fetcher({
-                path: null,
+                path: "/some/path",
                 domain: "test.com",
                 apiKey: "123abc",
                 tz: "   America/Chicago   ",
                 environment: "production",
             });
-            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2F&domain=test.com&tz=America%2FChicago", expect.anything());
+            expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Fsome%2Fpath&tz=America%2FChicago", expect.anything());
             expect(result).toEqual("results!");
         });
     });
 });
 describe("passing schema", function () {
     it("first stringifies schema if given an object", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
         const fetchMock = vi.fn().mockImplementation(() => {
             return {
                 status: 200,
@@ -200,10 +399,12 @@ describe("passing schema", function () {
             schema: { foo: "bar" },
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com&schema=%7B%22foo%22%3A%22bar%22%7D", expect.anything());
+        expect(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
     it("does not stringify schema if given a string", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
         const fetchMock = vi.fn().mockImplementation(() => {
             return {
                 status: 200,
@@ -219,7 +420,29 @@ describe("passing schema", function () {
             schema: '{"foo":"bar"}',
             environment: "production",
         });
-        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?path=%2Ftest&domain=test.com&schema=%7B%22foo%22%3A%22bar%22%7D", expect.anything());
+        expect(injectSchemaSpy).toHaveBeenCalledWith("results!", { foo: "bar" });
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
+        expect(result).toEqual("results!");
+    });
+    it("returns markup if invalid json is provided", async () => {
+        const injectSchemaSpy = vi.spyOn(injectSchema, "injectSchema");
+        const fetchMock = vi.fn().mockImplementation(() => {
+            return {
+                status: 200,
+                ok: true,
+                text: () => "results!",
+            };
+        });
+        const fetcher = markupFetcher("test", fetchMock);
+        const result = await fetcher({
+            path: "/test",
+            domain: "test.com",
+            apiKey: "123abc",
+            schema: "not-valid-json",
+            environment: "production",
+        });
+        expect(injectSchemaSpy).not.toHaveBeenCalled();
+        expect(fetchMock).toHaveBeenCalledWith("https://go.jamcomments.com/api/v3/markup?domain=test.com&path=%2Ftest", expect.anything());
         expect(result).toEqual("results!");
     });
 });

package/dist/esm/utils.js

@@ -1,3 +1,5 @@
+import { existsSync, mkdirSync, readFileSync, rmdirSync, writeFile } from "fs";
+import { TEMP_DIRECTORY } from ".";
 export function isValidTimezone(tz) {
     try {
         Intl.DateTimeFormat(undefined, { timeZone: tz });
@@ -22,3 +24,72 @@ export function reAppendMarkup(element, markup) {
     element.innerHTML = "";
     element.append(documentFragment);
 }
+export function parseJson(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (ex) {
+        return null;
+    }
+}
+export function unescapeHTML(str) {
+    var htmlEntities = {
+        nbsp: " ",
+        cent: "¢",
+        pound: "£",
+        yen: "¥",
+        euro: "€",
+        copy: "©",
+        reg: "®",
+        lt: "<",
+        gt: ">",
+        quot: '"',
+        amp: "&",
+        apos: "'",
+    };
+    return str.replace(/\&([^;]+);/g, function (entity, entityCode) {
+        var match;
+        if (entityCode in htmlEntities) {
+            return htmlEntities[entityCode];
+        }
+        else if ((match = entityCode.match(/^#x([\da-fA-F]+)$/))) {
+            return String.fromCharCode(parseInt(match[1], 16));
+        }
+        else if ((match = entityCode.match(/^#(\d+)$/))) {
+            return String.fromCharCode(~~match[1]);
+        }
+        else {
+            return entity;
+        }
+    });
+}
+export function deleteTempDirectory() {
+    if (existsSync(TEMP_DIRECTORY)) {
+        rmdirSync(TEMP_DIRECTORY, { recursive: true });
+    }
+}
+export function createTempDirectory(mkdirSyncImpl = mkdirSync, existsSyncImpl = existsSync) {
+    if (!existsSyncImpl(TEMP_DIRECTORY)) {
+        mkdirSyncImpl(TEMP_DIRECTORY);
+    }
+}
+export function toSavedFileName(name) {
+    return name.replace(/^\//, "").replace(/\//g, "::");
+}
+export function readFile(name, readFileSyncImpl = readFileSync) {
+    const fileName = toSavedFileName(name);
+    try {
+        return readFileSyncImpl(`${TEMP_DIRECTORY}/${fileName}`, "utf8");
+    }
+    catch (error) {
+        return null;
+    }
+}
+export function saveFile(name, data, writeFileImpl = writeFile) {
+    const fileName = toSavedFileName(name);
+    return new Promise((resolve) => {
+        writeFileImpl(`${TEMP_DIRECTORY}/${fileName}`, data, () => {
+            resolve();
+        });
+    });
+}

package/dist/esm/utils.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { getEnvironment } from "./utils";
+import { getEnvironment, createTempDirectory, toSavedFileName, readFile, saveFile, } from "./utils";
+import { TEMP_DIRECTORY } from ".";
 const env = process.env;
 beforeEach(() => {
     vi.resetModules();
@@ -42,3 +43,45 @@ describe("getEnvironment()", () => {
         });
     });
 });
+describe("createTempDirectory()", () => {
+    it("creates temp directory fresh", () => {
+        const mkdirSyncMock = vi.fn();
+        const existsSyncMock = vi.fn().mockReturnValue(false);
+        expect(() => createTempDirectory(mkdirSyncMock, existsSyncMock)).not.toThrow();
+        expect(mkdirSyncMock).toHaveBeenCalledWith(TEMP_DIRECTORY);
+    });
+    it("does not throw error when it already exists", () => {
+        const mkdirSyncMock = vi.fn().mockImplementation(() => {
+            throw new Error("Directory already exists");
+        });
+        const existsSyncMock = vi.fn().mockReturnValue(true);
+        expect(() => createTempDirectory(mkdirSyncMock, existsSyncMock)).not.toThrow();
+        expect(mkdirSyncMock).not.toHaveBeenCalledWith();
+    });
+});
+describe("toSavedFileName()", () => {
+    it("replaces slashes with double colons", () => {
+        expect(toSavedFileName("/hey/there")).toEqual("hey::there");
+    });
+});
+describe("readFile()", () => {
+    it("reads the file", () => {
+        const readFileSyncMock = vi.fn().mockReturnValue("file contents");
+        expect(readFile("hey/there", readFileSyncMock)).toEqual("file contents");
+        expect(readFileSyncMock).toHaveBeenCalledWith(`${TEMP_DIRECTORY}/hey::there`, "utf8");
+    });
+    it("returns null when file doesn't exist", () => {
+        const readFileSyncMock = vi.fn().mockImplementation(() => {
+            throw new Error("File not found");
+        });
+        expect(readFile("hey/there", readFileSyncMock)).toEqual(null);
+    });
+});
+describe("saveFile()", () => {
+    it("saves the file", async () => {
+        const writeFileMock = vi.fn();
+        const result = saveFile("hey/there", "file contents", writeFileMock);
+        expect(writeFileMock).toHaveBeenCalledWith(`${TEMP_DIRECTORY}/hey::there`, "file contents", expect.any(Function));
+        expect(result).toBeInstanceOf(Promise);
+    });
+});