@vizhub/runtime 0.1.4 → 0.2.0

package/dist/v3/slugCache.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, vi } from "vitest";
+import { createSlugCache } from "./slugCache";
+describe("SlugCache", () => {
+    describe("SlugCache - get method", () => {
+        it("should return vizId from cache if available", async () => {
+            const initialMappings = {
+                "user1/viz-slug": "viz-123",
+            };
+            const slugCache = createSlugCache({
+                initialMappings,
+                handleCacheMiss: vi.fn(),
+            });
+            const vizId = await slugCache.get("user1/viz-slug");
+            expect(vizId).toEqual("viz-123");
+            expect(vi.fn()).toHaveBeenCalledTimes(0); // handleCacheMiss should not be called
+        });
+        it("should resolve slug on cache miss and store it", async () => {
+            const handleCacheMissMock = vi
+                .fn()
+                .mockResolvedValue("viz-456");
+            const slugCache = createSlugCache({
+                initialMappings: {},
+                handleCacheMiss: handleCacheMissMock,
+            });
+            const vizId = await slugCache.get("user2/new-viz");
+            expect(handleCacheMissMock).toHaveBeenCalledWith("user2/new-viz");
+            expect(vizId).toEqual("viz-456");
+            // Verify that the cache now contains the resolved mapping
+            const cachedVizId = await slugCache.get("user2/new-viz");
+            expect(cachedVizId).toEqual("viz-456");
+            expect(handleCacheMissMock).toHaveBeenCalledTimes(1); // Should only be called once
+        });
+        it("should throw an error if handleCacheMiss does not return a vizId", async () => {
+            const handleCacheMissMock = vi
+                .fn()
+                .mockResolvedValue(undefined);
+            const slugCache = createSlugCache({
+                initialMappings: {},
+                handleCacheMiss: handleCacheMissMock,
+            });
+            await expect(slugCache.get("nonexistent/slug")).rejects.toThrow("Unresolved slug nonexistent/slug");
+        });
+        it("should throw an error if no handleCacheMiss is provided and slug not found", async () => {
+            const slugCache = createSlugCache({
+                initialMappings: {},
+            });
+            await expect(slugCache.get("missing/slug")).rejects.toThrow("Unresolved slug missing/slug, cache miss handler not provided.");
+        });
+    });
+    describe("SlugCache - set method", () => {
+        it("should add new mapping to the cache", async () => {
+            const slugCache = createSlugCache({
+                initialMappings: {},
+                handleCacheMiss: vi.fn(),
+            });
+            const slug = "user3/new-viz";
+            const vizId = "viz-789";
+            slugCache.set(slug, vizId);
+            // Verify new mapping is added
+            const resolvedVizId = await slugCache.get(slug);
+            expect(resolvedVizId).toEqual(vizId);
+        });
+        it("should update existing mapping in the cache", async () => {
+            const initialMappings = {
+                "user4/existing-viz": "old-viz-id",
+            };
+            const slugCache = createSlugCache({
+                initialMappings,
+                handleCacheMiss: vi.fn(),
+            });
+            const slug = "user4/existing-viz";
+            const updatedVizId = "updated-viz-id";
+            // Update existing mapping
+            slugCache.set(slug, updatedVizId);
+            // Verify mapping is updated
+            const resolvedVizId = await slugCache.get(slug);
+            expect(resolvedVizId).toEqual(updatedVizId);
+        });
+    });
+    describe("SlugCache - invalidate method", () => {
+        it("should remove a mapping from the cache", async () => {
+            const initialMappings = {
+                "user5/to-remove": "viz-to-remove",
+            };
+            const handleCacheMissMock = vi.fn();
+            const slugCache = createSlugCache({
+                initialMappings,
+                handleCacheMiss: handleCacheMissMock,
+            });
+            // Verify mapping exists initially
+            const initialVizId = await slugCache.get("user5/to-remove");
+            expect(initialVizId).toEqual("viz-to-remove");
+            // Invalidate the mapping
+            slugCache.invalidate("user5/to-remove");
+            // Trying to get it should trigger the cache miss handler
+            try {
+                await slugCache.get("user5/to-remove");
+            }
+            catch (e) {
+                // Ignore error if handleCacheMiss throws
+            }
+            expect(handleCacheMissMock).toHaveBeenCalledWith("user5/to-remove");
+        });
+    });
+});

package/dist/v3/transformDSV/dsvParseSrc.d.ts

@@ -0,0 +1 @@
+export declare const dsvParseSrc = "var EOL = {},\n  EOF = {},\n  QUOTE = 34,\n  NEWLINE = 10,\n  RETURN = 13;\n\nfunction objectConverter(columns) {\n  return new Function(\n    'd',\n    'return {' +\n      columns\n        .map(function (name, i) {\n          return (\n            JSON.stringify(name) + ': d[' + i + '] || \"\"'\n          );\n        })\n        .join(',') +\n      '}',\n  );\n}\n\nfunction customConverter(columns, f) {\n  var object = objectConverter(columns);\n  return function (row, i) {\n    return f(object(row), i, columns);\n  };\n}\n\nfunction dsv(delimiter) {\n  var DELIMITER = delimiter.charCodeAt(0);\n\n  function parse(text, f) {\n    var convert,\n      columns,\n      rows = parseRows(text, function (row, i) {\n        if (convert) return convert(row, i - 1);\n        (columns = row),\n          (convert = f\n            ? customConverter(row, f)\n            : objectConverter(row));\n      });\n    rows.columns = columns || [];\n    return rows;\n  }\n\n  function parseRows(text, f) {\n    var rows = [], // output rows\n      N = text.length,\n      I = 0, // current character index\n      n = 0, // current line number\n      t, // current token\n      eof = N <= 0, // current token followed by EOF?\n      eol = false; // current token followed by EOL?\n\n    // Strip the trailing newline.\n    if (text.charCodeAt(N - 1) === NEWLINE) --N;\n    if (text.charCodeAt(N - 1) === RETURN) --N;\n\n    function token() {\n      if (eof) return EOF;\n      if (eol) return (eol = false), EOL;\n\n      // Unescape quotes.\n      var i,\n        j = I,\n        c;\n      if (text.charCodeAt(j) === QUOTE) {\n        while (\n          (I++ < N && text.charCodeAt(I) !== QUOTE) ||\n          text.charCodeAt(++I) === QUOTE\n        );\n        if ((i = I) >= N) eof = true;\n        else if ((c = text.charCodeAt(I++)) === NEWLINE)\n          eol = true;\n        else if (c === RETURN) {\n          eol = true;\n          if (text.charCodeAt(I) === NEWLINE) ++I;\n        }\n        return text.slice(j + 1, i - 1).replace(/\"\"/g, '\"');\n      }\n\n      // Find next delimiter or newline.\n      while (I < N) {\n        if ((c = text.charCodeAt((i = I++))) === NEWLINE)\n          eol = true;\n        else if (c === RETURN) {\n          eol = true;\n          if (text.charCodeAt(I) === NEWLINE) ++I;\n        } else if (c !== DELIMITER) continue;\n        return text.slice(j, i);\n      }\n\n      // Return last token before EOF.\n      return (eof = true), text.slice(j, N);\n    }\n\n    while ((t = token()) !== EOF) {\n      var row = [];\n      while (t !== EOL && t !== EOF)\n        row.push(t), (t = token());\n      if (f && (row = f(row, n++)) == null) continue;\n      rows.push(row);\n    }\n\n    return rows;\n  }\n\n  return {\n    parse: parse,\n  };\n}\n\nvar csv = dsv(',');\n\nvar csvParse = csv.parse;\n\nvar tsv = dsv('\t');\n\nvar tsvParse = tsv.parse;\n\nexport { csvParse, tsvParse };";

package/dist/v3/transformDSV/dsvParseSrc.js

@@ -0,0 +1,121 @@
+export const dsvParseSrc = `var EOL = {},
+  EOF = {},
+  QUOTE = 34,
+  NEWLINE = 10,
+  RETURN = 13;
+
+function objectConverter(columns) {
+  return new Function(
+    'd',
+    'return {' +
+      columns
+        .map(function (name, i) {
+          return (
+            JSON.stringify(name) + ': d[' + i + '] || ""'
+          );
+        })
+        .join(',') +
+      '}',
+  );
+}
+
+function customConverter(columns, f) {
+  var object = objectConverter(columns);
+  return function (row, i) {
+    return f(object(row), i, columns);
+  };
+}
+
+function dsv(delimiter) {
+  var DELIMITER = delimiter.charCodeAt(0);
+
+  function parse(text, f) {
+    var convert,
+      columns,
+      rows = parseRows(text, function (row, i) {
+        if (convert) return convert(row, i - 1);
+        (columns = row),
+          (convert = f
+            ? customConverter(row, f)
+            : objectConverter(row));
+      });
+    rows.columns = columns || [];
+    return rows;
+  }
+
+  function parseRows(text, f) {
+    var rows = [], // output rows
+      N = text.length,
+      I = 0, // current character index
+      n = 0, // current line number
+      t, // current token
+      eof = N <= 0, // current token followed by EOF?
+      eol = false; // current token followed by EOL?
+
+    // Strip the trailing newline.
+    if (text.charCodeAt(N - 1) === NEWLINE) --N;
+    if (text.charCodeAt(N - 1) === RETURN) --N;
+
+    function token() {
+      if (eof) return EOF;
+      if (eol) return (eol = false), EOL;
+
+      // Unescape quotes.
+      var i,
+        j = I,
+        c;
+      if (text.charCodeAt(j) === QUOTE) {
+        while (
+          (I++ < N && text.charCodeAt(I) !== QUOTE) ||
+          text.charCodeAt(++I) === QUOTE
+        );
+        if ((i = I) >= N) eof = true;
+        else if ((c = text.charCodeAt(I++)) === NEWLINE)
+          eol = true;
+        else if (c === RETURN) {
+          eol = true;
+          if (text.charCodeAt(I) === NEWLINE) ++I;
+        }
+        return text.slice(j + 1, i - 1).replace(/""/g, '"');
+      }
+
+      // Find next delimiter or newline.
+      while (I < N) {
+        if ((c = text.charCodeAt((i = I++))) === NEWLINE)
+          eol = true;
+        else if (c === RETURN) {
+          eol = true;
+          if (text.charCodeAt(I) === NEWLINE) ++I;
+        } else if (c !== DELIMITER) continue;
+        return text.slice(j, i);
+      }
+
+      // Return last token before EOF.
+      return (eof = true), text.slice(j, N);
+    }
+
+    while ((t = token()) !== EOF) {
+      var row = [];
+      while (t !== EOL && t !== EOF)
+        row.push(t), (t = token());
+      if (f && (row = f(row, n++)) == null) continue;
+      rows.push(row);
+    }
+
+    return rows;
+  }
+
+  return {
+    parse: parse,
+  };
+}
+
+var csv = dsv(',');
+
+var csvParse = csv.parse;
+
+var tsv = dsv('\t');
+
+var tsvParse = tsv.parse;
+
+export { csvParse, tsvParse };`;

package/dist/v3/transformDSV/index.d.ts

@@ -0,0 +1,2 @@
+import { InputPluginOption } from "rollup";
+export declare const transformDSV: () => InputPluginOption;

package/dist/v3/transformDSV/index.js

@@ -0,0 +1,40 @@
+import { parseId } from "../parseId";
+import { dsvParseSrc } from "./dsvParseSrc";
+const DEBUG = false;
+// Escape backticks in a string so that it can be
+// used in a template literal. Also need to escape backslashes.
+const escapeBackticks = (str) => 
+// str.replace(/`/g, '\\`');
+str.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+// Responsible for loading CSV and TSV files, which are
+// in general called Delimiter-Separated Values (DSV).
+export const transformDSV = () => ({
+    name: "transformDSV",
+    // `id` here is of the form
+    // `{vizId}/{fileName}`
+    transform: async (text, id) => {
+        DEBUG && console.log("[transformDSV]: load() " + id);
+        const { vizId, fileName } = parseId(id);
+        DEBUG &&
+            console.log("  [transformDSV] vizId: " + vizId);
+        DEBUG &&
+            console.log("  [transformDSV] fileName: " + fileName);
+        const isCSV = fileName.endsWith(".csv");
+        const isTSV = fileName.endsWith(".tsv");
+        if (isCSV || isTSV) {
+            DEBUG &&
+                console.log("    [transformDSV] tracking DSV import for " +
+                    id);
+            const parseFunction = isCSV ? "csvParse" : "tsvParse";
+            return {
+                code: `
+            ${dsvParseSrc}
+            const data = ${parseFunction}(\`${escapeBackticks(text)}\`);
+            export default data;
+          `,
+                map: { mappings: "" },
+            };
+        }
+        return undefined;
+    },
+});

package/dist/{v3Runtime → v3}/transformSvelte.d.ts

@@ -1,6 +1,8 @@
-import { InputPluginOption } from 'rollup';
+import { InputPluginOption } from "rollup";
+export type SvelteCompiler = (code: string, options: any) => {
+    js: string;
+};
 export declare const svelteCompilerUrl = "https://cdn.jsdelivr.net/npm/svelte@4.2.9/compiler.cjs";
 export declare const transformSvelte: ({ getSvelteCompiler, }: {
     getSvelteCompiler?: () => Promise<any>;
 }) => InputPluginOption;
-//# sourceMappingURL=transformSvelte.d.ts.map

package/dist/v3/transformSvelte.js

@@ -0,0 +1,77 @@
+import { parseId } from "./parseId";
+const debug = false;
+// The cache of fetched files.
+const fetchedFileCache = new Map();
+let compile;
+const svelteURL = "https://cdn.jsdelivr.net/npm/svelte@4.2.9";
+export const svelteCompilerUrl = `${svelteURL}/compiler.cjs`;
+// Responsible for transforming Svelte files.
+// Inspired by:
+//  * https://github.com/sveltejs/sites/blob/master/packages/repl/src/lib/workers/compiler/index.js#L2
+//  * https://github.com/sveltejs/sites/blob/master/packages/repl/src/lib/workers/bundler/index.js#L358
+//  * https://github.com/sveltejs/rollup-plugin-svelte/blob/master/index.js#L146C4-L146C51
+export const transformSvelte = ({ getSvelteCompiler, }) => ({
+    name: "transformSvelte",
+    load: async (resolved) => {
+        if (!resolved.startsWith(svelteURL)) {
+            return;
+        }
+        if (debug) {
+            console.log("[transformSvelte]: load() " + resolved);
+        }
+        const cachedFile = fetchedFileCache.get(resolved);
+        if (cachedFile)
+            return cachedFile;
+        const fetchedFile = await fetch(resolved).then((res) => res.text());
+        fetchedFileCache.set(resolved, fetchedFile);
+        return fetchedFile;
+    },
+    // From https://github.com/sveltejs/sites/blob/master/packages/repl/src/lib/workers/bundler/index.js#L255C2-L271C5
+    resolveId: async (importee, importer) => {
+        if (debug) {
+            console.log("[transformSvelte] resolveId() " + importee);
+            console.log("importee: " + importee);
+            console.log("importer: " + importer);
+        }
+        // importing from Svelte
+        if (importee === `svelte`) {
+            return `${svelteURL}/src/runtime/index.js`;
+        }
+        if (importee.startsWith(`svelte/`)) {
+            const sub_path = importee.slice(7);
+            return `${svelteURL}/src/runtime/${sub_path}/index.js`;
+        }
+        // importing from a URL
+        if (/^https?:/.test(importee))
+            return importee;
+        // Relative imports
+        if (importee.startsWith(".")) {
+            if (importer && importer.startsWith(svelteURL)) {
+                const resolved = new URL(importee, importer).href;
+                const url = new URL(importee, importer).href;
+                if (debug) {
+                    console.log("[transformSvelte] resolveId() " + resolved);
+                }
+                return resolved;
+            }
+        }
+    },
+    transform: async (code, id) => {
+        const { fileName } = parseId(id);
+        const isSvelte = fileName.endsWith(".svelte");
+        if (isSvelte) {
+            if (!compile) {
+                if (!getSvelteCompiler) {
+                    throw new Error("Svelte compiler not available");
+                }
+                compile = await getSvelteCompiler();
+            }
+            const compiled = compile(code, {
+                filename: fileName,
+                hydratable: true,
+            });
+            return compiled.js;
+        }
+        return undefined;
+    },
+});

package/dist/{v3Runtime → v3}/types.d.ts

@@ -1,7 +1,8 @@
-import { Content, V3PackageJson, VizId } from 'entities';
+import { VizContent, VizId } from "@vizhub/viz-types";
+import type { PackageJson } from "../common/packageJson";
 export type V3BuildResult = {
     src: string | undefined;
-    pkg: V3PackageJson | undefined;
+    pkg: PackageJson | undefined;
     warnings: Array<V3BuildError>;
     time: number;
     cssFiles: Array<ResolvedVizFileId>;
@@ -12,54 +13,53 @@ export type V3BuildError = {
 };
 export type ResolvedVizFileId = string;
 export type V3WorkerMessage = {
-    type: 'contentRequest';
+    type: "contentRequest";
     vizId: VizId;
 } | {
-    type: 'contentResponse';
+    type: "contentResponse";
     vizId: VizId;
-    content: Content;
+    content: VizContent;
 } | {
-    type: 'buildRequest';
+    type: "buildRequest";
     vizId: VizId;
     enableSourcemap: boolean;
 } | {
-    type: 'buildResponse';
+    type: "buildResponse";
     buildResult?: V3BuildResult;
     error?: Error;
 } | {
-    type: 'invalidateVizCacheRequest';
+    type: "invalidateVizCacheRequest";
     changedVizIds: Array<VizId>;
 } | {
-    type: 'invalidateVizCacheResponse';
+    type: "invalidateVizCacheResponse";
 } | {
-    type: 'resolveSlugRequest';
+    type: "resolveSlugRequest";
     slugKey: string;
     requestId: string;
 } | {
-    type: 'resolveSlugResponse';
+    type: "resolveSlugResponse";
     slugKey: string;
     vizId: VizId;
     requestId: string;
 } | {
-    type: 'resetSrcdocRequest';
+    type: "resetSrcdocRequest";
     vizId: VizId;
     changedVizIds: Array<VizId>;
 } | {
-    type: 'resetSrcdocResponse';
+    type: "resetSrcdocResponse";
     srcdoc?: string;
     error?: Error;
 };
 export type V3WindowMessage = {
-    type: 'runJS';
+    type: "runJS";
     src: string;
 } | {
-    type: 'runCSS';
+    type: "runCSS";
     src: string;
     id: ResolvedVizFileId;
 } | {
-    type: 'runDone';
+    type: "runDone";
 } | {
-    type: 'runError';
+    type: "runError";
     error: Error;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/v3/types.js

@@ -0,0 +1 @@
+export {};

package/dist/v3/v3Build.d.ts

@@ -0,0 +1,15 @@
+import { RollupBuild, RollupOptions } from "rollup";
+import { FileCollection } from "../types";
+import { VizCache } from "./vizCache";
+import { VizId } from "@vizhub/viz-types";
+import { SlugCache } from "./slugCache";
+import { SvelteCompiler } from "./transformSvelte";
+export declare const v3Build: ({ files, rollup, enableSourcemap, vizCache, vizId, slugCache, getSvelteCompiler, }: {
+    files: FileCollection;
+    rollup: (options: RollupOptions) => Promise<RollupBuild>;
+    enableSourcemap?: boolean;
+    vizCache: VizCache;
+    vizId: VizId;
+    slugCache?: SlugCache;
+    getSvelteCompiler?: () => Promise<SvelteCompiler>;
+}) => Promise<string>;

package/dist/v3/v3Build.js

@@ -0,0 +1,30 @@
+import { computeBundleJSV3 } from "./computeBundleJSV3";
+import { htmlTemplate } from "./htmlTemplate";
+import { parseId } from "./parseId";
+import { getFileText } from "../utils/getFileText";
+export const v3Build = async ({ files, rollup, enableSourcemap = true, vizCache, vizId, slugCache, getSvelteCompiler, }) => {
+    const { src, cssFiles } = await computeBundleJSV3({
+        files,
+        rollup,
+        enableSourcemap,
+        vizCache,
+        vizId,
+        slugCache,
+        getSvelteCompiler,
+    });
+    // Generate CSS styles from imported CSS files
+    let styles = "";
+    // Inject CSS files.
+    if (cssFiles.length > 0) {
+        for (let i = 0; i < cssFiles.length; i++) {
+            const id = cssFiles[i];
+            const indent = i > 0 ? "    " : "\n    ";
+            const styleElementId = "injected-style" + id;
+            const { vizId, fileName } = parseId(id);
+            const content = await vizCache.get(vizId);
+            const src = getFileText(content, fileName);
+            styles += `${indent}<style id="${styleElementId}">${src}</style>`;
+        }
+    }
+    return htmlTemplate({ cdn: "", src, styles });
+};

package/dist/v3/vizCache.d.ts

@@ -0,0 +1,10 @@
+import { VizContent, VizId } from "@vizhub/viz-types";
+export type VizCache = {
+    get: (vizId: string) => Promise<VizContent>;
+    set: (content: VizContent) => void;
+    invalidate: (vizId: string) => void;
+};
+export declare const createVizCache: ({ initialContents, handleCacheMiss, }: {
+    initialContents: Array<VizContent>;
+    handleCacheMiss?: (vizId: VizId) => Promise<VizContent>;
+}) => VizCache;

package/dist/v3/vizCache.js

@@ -0,0 +1,36 @@
+// A cache of viz content.
+// For use in resolving imports from other vizzes.
+// Runs both on the server and in the browser.
+export const createVizCache = ({ initialContents, handleCacheMiss, }) => {
+    // Track the content of cached vizzes.
+    const contentMap = new Map(initialContents.map((content) => [content.id, content]));
+    // Gets the content of a viz.
+    // Returns the cached content if it exists.
+    // Otherwise, calls handleCacheMiss to fetch the content.
+    const get = async (vizId) => {
+        const cachedContent = contentMap.get(vizId);
+        // Cache hit
+        if (cachedContent !== undefined) {
+            return cachedContent;
+        }
+        // Cache miss
+        if (!handleCacheMiss) {
+            throw new Error(`Unresolved import from vizId ${vizId}, cache miss handler not provided.`);
+        }
+        const freshContent = await handleCacheMiss(vizId);
+        if (freshContent) {
+            contentMap.set(vizId, freshContent);
+            return freshContent;
+        }
+        // TODO surface this error to the user
+        throw new Error(`Unresolved import from vizId ${vizId}`);
+    };
+    // Updates the content of a viz in the cache.
+    const set = (content) => {
+        contentMap.set(content.id, content);
+    };
+    const invalidate = (vizId) => {
+        contentMap.delete(vizId);
+    };
+    return { get, set, invalidate };
+};

package/dist/v3/vizCache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/vizCache.test.js

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi } from "vitest";
+import { createVizCache } from "./vizCache";
+import { sampleVizContent } from "../test/fixtures/v3";
+describe("VizCache", () => {
+    describe("VizCache - get method", () => {
+        it("should return content from cache if available", async () => {
+            const vizCache = createVizCache({
+                initialContents: [sampleVizContent],
+                handleCacheMiss: vi.fn(),
+            });
+            const content = await vizCache.get(sampleVizContent.id);
+            expect(content).toEqual(sampleVizContent);
+            expect(vi.fn()).toHaveBeenCalledTimes(0); // handleCacheMiss should not be called
+        });
+        it("should fetch content on cache miss and store it", async () => {
+            const handleCacheMissMock = vi
+                .fn()
+                .mockResolvedValue(sampleVizContent);
+            const vizCache = createVizCache({
+                initialContents: [],
+                handleCacheMiss: handleCacheMissMock,
+            });
+            const content = await vizCache.get(sampleVizContent.id);
+            expect(handleCacheMissMock).toHaveBeenCalledWith(sampleVizContent.id);
+            expect(content).toEqual(sampleVizContent);
+            // Verify that the cache now contains the fetched content
+            const cachedContent = await vizCache.get(sampleVizContent.id);
+            expect(cachedContent).toEqual(sampleVizContent);
+        });
+        it("should throw an error if handleCacheMiss does not return content", async () => {
+            const handleCacheMissMock = vi
+                .fn()
+                .mockResolvedValue(undefined);
+            const vizCache = createVizCache({
+                initialContents: [],
+                handleCacheMiss: handleCacheMissMock,
+            });
+            await expect(vizCache.get("nonexistentId")).rejects.toThrow("Unresolved import from vizId nonexistentId");
+        });
+        // Add tests for set
+    });
+    describe("VizCache - set method", () => {
+        it("should add new content to the cache", async () => {
+            const vizCache = createVizCache({
+                initialContents: [],
+                handleCacheMiss: vi.fn(),
+            });
+            const newContent = {
+                id: "newContent",
+                files: {},
+                title: "New Content",
+            };
+            vizCache.set(newContent);
+            // Verify new content is added
+            const content = await vizCache.get(newContent.id);
+            expect(content).toEqual(newContent);
+        });
+        it("should update existing content in the cache", async () => {
+            const updatedContent = {
+                ...sampleVizContent,
+                title: "Updated Content Title",
+            };
+            const vizCache = createVizCache({
+                initialContents: [sampleVizContent],
+                handleCacheMiss: vi.fn(),
+            });
+            // Update existing content
+            vizCache.set(updatedContent);
+            // Verify content is updated
+            const content = await vizCache.get(updatedContent.id);
+            expect(content).toEqual(updatedContent);
+        });
+        it("should keep the cache consistent after multiple set operations", async () => {
+            const vizCache = createVizCache({
+                initialContents: [],
+                handleCacheMiss: vi.fn(),
+            });
+            // Adding multiple contents
+            const contentA = {
+                id: "contentA",
+                files: {},
+                title: "Content A",
+            };
+            const contentB = {
+                id: "contentB",
+                files: {},
+                title: "Content B",
+            };
+            vizCache.set(contentA);
+            vizCache.set(contentB);
+            // Verify both contents are retrievable
+            const retrievedA = await vizCache.get(contentA.id);
+            const retrievedB = await vizCache.get(contentB.id);
+            expect(retrievedA).toEqual(contentA);
+            expect(retrievedB).toEqual(contentB);
+        });
+    });
+});

package/dist/{v3Runtime → v3}/vizLoad.d.ts

@@ -1,8 +1,7 @@
-import { InputPluginOption } from 'rollup';
-import { ResolvedVizFileId } from './types';
-import { VizCache } from './vizCache';
+import { InputPluginOption } from "rollup";
+import { ResolvedVizFileId } from "./types";
+import { VizCache } from "./vizCache";
 export declare const vizLoad: ({ vizCache, trackCSSImport, }: {
     vizCache: VizCache;
     trackCSSImport: (cssFile: ResolvedVizFileId) => void;
 }) => InputPluginOption;
-//# sourceMappingURL=vizLoad.d.ts.map