@vizhub/runtime 0.0.1 → 0.0.2

package/dist/assets/setupV3Runtime-BVr5lyKp.js

@@ -0,0 +1,240 @@
+import { cleanRollupErrorMessage, p as parseId, g as getFileText } from "../index.js";
+import "buble";
+import "path-posix";
+import "vizhub-libraries";
+import "sharedb-client-browser/dist/ot-json1-presence-umd.cjs";
+import "json0-ot-diff";
+import "diff-match-patch";
+import "react";
+function WorkerWrapper(options) {
+  return new Worker(
+    "/assets/worker-CLxqJrPo.js",
+    {
+      name: options == null ? void 0 : options.name
+    }
+  );
+}
+const IDLE = "IDLE";
+const ENQUEUED = "ENQUEUED";
+const PENDING_CLEAN = "PENDING_CLEAN";
+const PENDING_DIRTY = "PENDING_DIRTY";
+const setupV3Runtime = ({
+  vizId,
+  iframe,
+  setSrcdocErrorMessage,
+  getLatestContent,
+  resolveSlugKey,
+  writeFile
+}) => {
+  const worker = new WorkerWrapper();
+  let state = IDLE;
+  let pendingBuildPromise = null;
+  let pendingRunPromise = null;
+  worker.addEventListener("message", async ({ data }) => {
+    const message = data;
+    if (message.type === "buildResponse") {
+      const buildResult = message.buildResult;
+      const error = message.error;
+      if (pendingBuildPromise) {
+        pendingBuildPromise(buildResult);
+        pendingBuildPromise = null;
+      }
+      if (error) {
+        setSrcdocErrorMessage(
+          cleanRollupErrorMessage({
+            rawMessage: error.message,
+            vizId
+          })
+        );
+      }
+    }
+    if (message.type === "contentRequest") {
+      const { vizId: vizId2 } = message;
+      const content = await getLatestContent(vizId2);
+      const contentResponseMessage = {
+        type: "contentResponse",
+        vizId: message.vizId,
+        content
+      };
+      worker.postMessage(contentResponseMessage);
+    }
+    if (message.type === "resolveSlugRequest") {
+      const { slugKey } = message;
+      const resolveSlugResponseMessage = {
+        type: "resolveSlugResponse",
+        slugKey,
+        requestId: message.requestId,
+        vizId: await resolveSlugKey(slugKey)
+      };
+      worker.postMessage(resolveSlugResponseMessage);
+    }
+    if (message.type === "invalidateVizCacheResponse") {
+      handleCodeChange();
+    }
+    if (message.type === "resetSrcdocResponse") {
+      const srcdoc = message.srcdoc;
+      const error = message.error;
+      if (error) {
+        setSrcdocErrorMessage(
+          cleanRollupErrorMessage({
+            rawMessage: error.message,
+            vizId
+          })
+        );
+      } else {
+        setSrcdocErrorMessage(null);
+        if (srcdoc) {
+          iframe.srcdoc = srcdoc;
+        }
+      }
+    }
+  });
+  window.addEventListener("message", ({ data }) => {
+    if (data.type === "runDone" || data.type === "runError") {
+      if (pendingRunPromise) {
+        pendingRunPromise();
+        pendingRunPromise = null;
+      }
+    }
+    if (data.type === "runError") {
+      setSrcdocErrorMessage(data.error.message);
+    }
+    if (data.type === "writeFile") {
+      if (data.fileName && data.content) {
+        writeFile(data.fileName, data.content);
+      }
+    }
+  });
+  const handleCodeChange = () => {
+    if (state === IDLE) {
+      state = ENQUEUED;
+      update();
+    } else if (state === PENDING_CLEAN) {
+      state = PENDING_DIRTY;
+    }
+  };
+  const invalidateVizCache = (changedVizIds) => {
+    const message = {
+      type: "invalidateVizCacheRequest",
+      changedVizIds
+    };
+    worker.postMessage(message);
+  };
+  {
+    setInterval(() => {
+    }, 1e3);
+  }
+  const build = () => {
+    return new Promise(
+      (resolve) => {
+        pendingBuildPromise = resolve;
+        const message = {
+          type: "buildRequest",
+          vizId,
+          enableSourcemap: true
+        };
+        worker.postMessage(message);
+      }
+    );
+  };
+  const update = async () => {
+    state = PENDING_CLEAN;
+    const buildResult = await build();
+    if (buildResult !== void 0) {
+      await run(buildResult);
+    }
+    if (state === PENDING_DIRTY) {
+      requestAnimationFrame(update);
+      state = ENQUEUED;
+    } else {
+      state = IDLE;
+    }
+  };
+  let previousCSSFiles = [];
+  const run = (buildResult) => {
+    return new Promise((resolve) => {
+      var _a;
+      const { src, warnings, cssFiles } = buildResult;
+      if (src === void 0) {
+        throw new Error(
+          "[v3 runtime] src is undefined, but no errors!"
+        );
+      }
+      pendingRunPromise = resolve;
+      if (warnings.length > 0) {
+        setSrcdocErrorMessage(
+          warnings.map((warning) => warning.message).join("\n\n")
+        );
+      } else {
+        setSrcdocErrorMessage(null);
+      }
+      if (iframe.contentWindow) {
+        for (const cssFile of cssFiles) {
+          const { vizId: vizId2, fileName } = parseId(cssFile);
+          getLatestContent(vizId2).then((content) => {
+            var _a2;
+            const src2 = getFileText(content, fileName);
+            if (src2 === null) {
+              console.warn(
+                `Imported CSS file ${fileName} doesn't exist.`
+              );
+              return;
+            }
+            const runCSSMessage = {
+              type: "runCSS",
+              id: cssFile,
+              src: src2
+            };
+            (_a2 = iframe.contentWindow) == null ? void 0 : _a2.postMessage(
+              runCSSMessage,
+              window.location.origin
+            );
+          });
+        }
+        const removedCSSFiles = previousCSSFiles.filter(
+          (id) => !cssFiles.includes(id)
+        );
+        previousCSSFiles = cssFiles;
+        for (const id of removedCSSFiles) {
+          const removeCSSMessage = {
+            type: "runCSS",
+            id,
+            src: ""
+          };
+          (_a = iframe.contentWindow) == null ? void 0 : _a.postMessage(
+            removeCSSMessage,
+            window.location.origin
+          );
+        }
+        console.clear();
+        const runJSMessage = {
+          type: "runJS",
+          src
+        };
+        iframe.contentWindow.postMessage(
+          runJSMessage,
+          window.location.origin
+        );
+      }
+    });
+  };
+  const resetSrcdoc = (changedVizIds) => {
+    state = IDLE;
+    pendingBuildPromise = null;
+    pendingRunPromise = null;
+    const message = {
+      type: "resetSrcdocRequest",
+      vizId,
+      changedVizIds
+    };
+    worker.postMessage(message);
+  };
+  return {
+    handleCodeChange,
+    invalidateVizCache,
+    resetSrcdoc
+  };
+};
+export {
+  setupV3Runtime
+};