@vizhub/runtime 0.3.8 → 0.4.0

package/dist/v3/slugCache.test.js

@@ -1,105 +0,0 @@
-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.js

@@ -1,121 +0,0 @@
-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.js

@@ -1,40 +0,0 @@
-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/v3/transformSvelte.js

@@ -1,77 +0,0 @@
-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/v3/types.js

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

package/dist/v3/v3Build.js

@@ -1,30 +0,0 @@
-import { computeBundleJSV3 } from "./computeBundleJSV3";
-import { htmlTemplate } from "./htmlTemplate";
-import { parseId } from "./parseId";
-import { getFileText } from "@vizhub/viz-utils";
-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.js

@@ -1,36 +0,0 @@
-// 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.js

@@ -1,98 +0,0 @@
-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/v3/vizLoad.js

@@ -1,46 +0,0 @@
-import { parseId } from "./parseId";
-import { getFileText } from "@vizhub/viz-utils";
-const debug = false;
-// Responsible for loading all imports and
-// tracking which CSS files are imported.
-// Throws an error if a file is imported but not found.
-export const vizLoad = ({ vizCache, trackCSSImport, }) => ({
-    name: "vizLoad",
-    // `id` here is of the form
-    // `{vizId}/{fileName}`
-    load: async (id) => {
-        if (debug) {
-            console.log("[vizLoadCSS]: load() " + id);
-        }
-        const { vizId, fileName } = parseId(id);
-        if (debug) {
-            console.log("  [vizLoadCSS] vizId: " + vizId);
-            console.log("  [vizLoadCSS] fileName: " + fileName);
-        }
-        // For CSS imports, all we need to do here is
-        // keep track of them so they can be injected
-        // into the IFrame later.
-        if (fileName.endsWith(".css")) {
-            if (debug) {
-                console.log("    [vizResolve] tracking CSS import for " + id);
-            }
-            // The import is tracked here so that it can be
-            // injected into the IFrame later, external to the
-            // Rollup build.
-            trackCSSImport(id);
-            // TODO consider using Rollup's `emitFile` to emit a CSS file.
-            return "";
-        }
-        const content = await vizCache.get(vizId);
-        const fileText = getFileText(content, fileName);
-        // If a file is imported but not found, throw an error.
-        if (fileText === null) {
-            throw new Error(`Imported file "${fileName}" not found.`);
-            // TODO ideally show username/slug instead of vizId
-            // `Imported file "${fileName}" not found in viz ${vizId}`,
-            // `Imported file "${fileName}" not found.`,
-            // );
-        }
-        return fileText;
-    },
-});

package/dist/v3/vizResolve.js

@@ -1,69 +0,0 @@
-import { extractVizImport } from "./extractVizImport";
-import { parseId } from "./parseId";
-import { isVizId } from "@vizhub/viz-utils";
-const debug = false;
-export const vizResolve = ({ vizId, slugCache, }) => ({
-    name: "vizResolve",
-    resolveId: async (id, importer) => {
-        if (debug) {
-            console.log("[vizIdResolve] resolveId() " + id);
-            console.log("  importer: " + importer);
-        }
-        // Handle virtual file system resolution
-        // .e.g. `import { foo } from './foo.js'`
-        // .e.g. `import { foo } from './foo'`
-        if (id.startsWith("./") &&
-            !importer?.startsWith("https://")) {
-            let fileName = id.substring(2);
-            // Handle CSS files
-            // e.g. `import './styles.css'`
-            // Handle JS files
-            // e.g. `import { foo } from './foo.js'`
-            // e.g. `import { foo } from './foo'`
-            if (!fileName.endsWith(".js") &&
-                !fileName.endsWith(".css") &&
-                !fileName.endsWith(".csv") &&
-                !fileName.endsWith(".svelte")) {
-                fileName += ".js";
-            }
-            // const js = (name: string) =>
-            // name.endsWith('.js') ? name : name + '.js';
-            // If there is an importer, then the file is not part of
-            // the entry point, so it should be resolved relative
-            // to the importer's directory
-            if (importer) {
-                const { vizId: importerVizId, fileName: importerFileName, } = parseId(importer);
-                // Get the directory of the importing file
-                const importerDir = importerFileName
-                    .split("/")
-                    .slice(0, -1)
-                    .join("/");
-                // Combine the directory with the imported file name
-                const resolvedFileName = importerDir
-                    ? `${importerDir}/${fileName}`
-                    : fileName;
-                return `${importerVizId}/${resolvedFileName}`;
-            }
-            return vizId + "/" + fileName;
-        }
-        // Handle viz import resolution
-        // e.g. `import { foo } from '@curran/98e6d6509a1e407897d4f238a330efec'`
-        // e.g. `import { foo } from '@curran/scatter-plot'`
-        const vizImport = extractVizImport(id);
-        if (vizImport) {
-            let vizId;
-            if (isVizId(vizImport.idOrSlug)) {
-                vizId = vizImport.idOrSlug;
-            }
-            else {
-                if (!slugCache) {
-                    throw new Error("slugCache is required to import by slug in v3 runtime");
-                }
-                vizId = await slugCache.get(`${vizImport.userName}/${vizImport.idOrSlug}`);
-            }
-            return vizId + "/index.js";
-        }
-        // If neither condition is met, return undefined.
-        return undefined;
-    },
-});