@replohq/sandbox-runtime 1.17.0 → 1.18.0

package/ClientErrorBoundary.js

@@ -1,17 +1,43 @@
 "use client";
 import { jsx } from "react/jsx-runtime";
 import * as React from "react";
+import { v4 as uuidv4 } from "uuid";
+import { getPreviewHealthActions } from "./previewHealth";
 class ErrorBoundary extends React.Component {
   state = {
     didCatch: false
   };
+  boundaryId = uuidv4();
+  caughtError = null;
   static getDerivedStateFromError() {
     return { didCatch: true };
   }
+  componentDidMount() {
+    if (!this.state.didCatch) {
+      getPreviewHealthActions()?.boundaryRendered(this.boundaryId);
+    } else if (this.caughtError) {
+      getPreviewHealthActions()?.boundaryCaughtError(
+        this.boundaryId,
+        this.caughtError
+      );
+    }
+  }
+  componentWillUnmount() {
+    getPreviewHealthActions()?.boundaryUnmounted(this.boundaryId);
+  }
   componentDidCatch(error, info) {
+    this.caughtError = { error, componentStack: info.componentStack ?? null };
+    getPreviewHealthActions()?.boundaryCaughtError(
+      this.boundaryId,
+      this.caughtError
+    );
     this.props.onError?.(error, info);
   }
   componentDidUpdate(previousProps, previousState) {
+    if (previousState.didCatch && !this.state.didCatch) {
+      this.caughtError = null;
+      getPreviewHealthActions()?.boundaryRendered(this.boundaryId);
+    }
     if (this.state.didCatch && previousState.didCatch && !Object.is(previousProps.resetKey, this.props.resetKey)) {
       this.setState({ didCatch: false });
     }

package/DocumentReadyBeacon.js

@@ -1,5 +1,9 @@
 import { jsx } from "react/jsx-runtime";
-const BEACON_SCRIPT = `if (window.parent !== window) { window.parent.postMessage({ type: "replo:preview:status", status: "ok", phase: "document", route: window.location.pathname }, "*"); }`;
+import {
+  PREVIEW_HEALTH_IFRAME_RPC_CHANNEL_ID,
+  PREVIEW_HEALTH_IFRAME_RPC_CHANNEL_VERSION
+} from "./_vendor/schemas/previewHealthIframeRpc.mjs";
+const BEACON_SCRIPT = `if (window.parent !== window) { window.parent.postMessage({ channelIdentifier: ${JSON.stringify(PREVIEW_HEALTH_IFRAME_RPC_CHANNEL_ID)}, version: ${PREVIEW_HEALTH_IFRAME_RPC_CHANNEL_VERSION}, type: "notify", method: "documentArrived", data: { route: window.location.pathname } }, "*"); }`;
 function DocumentReadyBeacon() {
   return /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: BEACON_SCRIPT } });
 }

package/_vendor/schemas/iframeRpcChannel.mjs

@@ -1,544 +1,6 @@
-import { randomUUID } from '../../chunk-LIPH4O4F.mjs';
-import { isNullish } from '../../chunk-PH3S6LJI.mjs';
+export { createIframeRpcChannel, createIframeRpcRemote, iframeRpcCallSchema } from '../../chunk-KRA4LUIR.mjs';
+import '../../chunk-LIPH4O4F.mjs';
+import '../../chunk-PH3S6LJI.mjs';
 import '../../chunk-FLYEIRFK.mjs';
 import '../../chunk-TESFJQID.mjs';
 import '../../chunk-G3S6ZNPF.mjs';
-import * as z from 'zod';
-
-var defaultLogger = {
-  info: console.log,
-  debug: console.debug,
-  error: console.error
-};
-
-var ReploError = class _ReploError extends Error {
-  config;
-  id;
-  constructor(config) {
-    super(config.message);
-    this.message = config.message ?? this.constructor.name;
-    this.config = config;
-    this.id = randomUUID();
-    const cause = config.cause;
-    if (cause) {
-      this.cause = cause;
-      if (cause instanceof _ReploError) {
-        this.config.additionalData = {
-          ...this.config.additionalData,
-          ...cause.config.additionalData
-        };
-      }
-    }
-  }
-};
-
-var errorUserFacingDetailsMessageSchema = z.object({
-  type: z.enum([
-    "toast",
-    "fullPageModal",
-    "shopifyStorePassword",
-    "billing.addPublishedElements",
-    "billing.addShopifyThemeProject",
-    "billing.addReploSite",
-    "agentBilling.shopifyThemeBuilder.publishedElements.exceeded",
-    "agentBilling.shopifyThemeBuilder.projects.exceeded",
-    "agentBilling.sites.exceeded",
-    "agentBilling.credits.exceeded",
-    "agentBilling.upgradeRequired"
-  ]),
-  message: z.string(),
-  isRecoverable: z.boolean().optional(),
-  detail: z.array(z.string()).or(z.string()).optional(),
-  key: z.string(),
-  details: z.record(z.string(), z.unknown()).optional(),
-  usage: z.object({
-    current: z.number(),
-    maximum: z.number()
-  }).optional(),
-  plan: z.string().optional(),
-  callToAction: z.discriminatedUnion("type", [
-    z.object({ type: z.literal("reload") }),
-    z.object({ type: z.literal("installApp") }),
-    z.object({ type: z.literal("goToHomepage") }),
-    z.object({ type: z.literal("navigateToProjectEditor") }),
-    z.object({ type: z.literal("closeModal") }),
-    z.object({
-      type: z.literal("navigateToLink"),
-      link: z.discriminatedUnion("type", [
-        z.object({ type: z.literal("errors.wrongJsonExtension") }),
-        z.object({ type: z.literal("errors.chunkingError") }),
-        z.object({ type: z.literal("errors.indexBackupError") }),
-        z.object({
-          type: z.literal("errors.shopifyIntegrationAlreadyAssigned")
-        }),
-        z.object({
-          type: z.literal("errors.shopifyIntegrationMissingAccessScopes"),
-          url: z.string()
-        }),
-        z.object({
-          type: z.literal("customLink"),
-          url: z.string()
-        }),
-        z.object({
-          type: z.literal(
-            "errors.projectConnectedToBillingIntegrationForShopifyWorkspace"
-          )
-        }),
-        z.object({ type: z.literal("errors.themeAssetSizeLimitExceeded") }),
-        z.object({ type: z.literal("errors.themeTotalSizeLimitExceeded") }),
-        z.object({
-          type: z.literal("errors.pageMetafieldDefinitionsChanged")
-        }),
-        z.object({ type: z.literal("settings.billing") })
-      ])
-    })
-  ]).optional()
-}).describe("ErrorUserFacingDetailsWithMessage");
-z.discriminatedUnion("type", [
-  errorUserFacingDetailsMessageSchema,
-  z.object({
-    type: z.literal("uncommon_none"),
-    key: z.string(),
-    usage: z.object({
-      current: z.number(),
-      maximum: z.number()
-    }).optional(),
-    message: z.string().optional(),
-    isRecoverable: z.boolean().optional(),
-    detail: z.array(z.string()).or(z.string()).optional()
-  })
-]).describe("ErrorUserFacingDetails");
-var IframeRpcChannelError = class extends ReploError {
-};
-var IframeRpcChannelTimeoutError = class extends IframeRpcChannelError {
-  constructor({ method, timeoutMs }) {
-    super({
-      message: `RPC method '${method}' timed out after ${timeoutMs}ms`,
-      additionalData: { method, timeoutMs }
-    });
-  }
-};
-var IframeRpcChannelTargetUnavailableError = class extends IframeRpcChannelError {
-  constructor({
-    callType,
-    method
-  }) {
-    super({
-      message: method ? `RPC target window was unavailable for '${method}'` : "RPC target window was unavailable for a response",
-      additionalData: { callType, method }
-    });
-  }
-};
-var IframeRpcChannelRemoteError = class extends IframeRpcChannelError {
-  constructor({ method, message }) {
-    super({
-      message: `RPC method '${method}' failed: ${message}`,
-      additionalData: { method }
-    });
-  }
-};
-var IframeRpcChannelUnsubscribedError = class extends IframeRpcChannelError {
-  constructor({ method }) {
-    super({
-      message: `RPC was unsubscribed while '${method}' was pending`,
-      additionalData: { method }
-    });
-  }
-};
-var IframeRpcChannelUnknownMethodError = class extends IframeRpcChannelError {
-  constructor({ method }) {
-    super({
-      message: `Unknown RPC method '${method}'`,
-      additionalData: { method }
-    });
-  }
-};
-var IframeRpcChannelConfigurationError = class extends IframeRpcChannelError {
-  constructor({ message }) {
-    super({ message });
-  }
-};
-var IframeRpcChannelInvalidInputError = class extends IframeRpcChannelError {
-  constructor({ method, cause }) {
-    super({
-      message: `Invalid RPC input for '${method}': ${cause.message}`,
-      cause,
-      additionalData: { method }
-    });
-  }
-};
-
-var iframeRpcCallResultSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("success"),
-    data: z.unknown()
-  }),
-  z.object({
-    type: z.literal("error"),
-    errorMessage: z.string()
-  })
-]);
-var iframeRpcCallSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("notify"),
-    method: z.string(),
-    data: z.unknown().optional()
-  }),
-  z.object({
-    type: z.literal("request"),
-    id: z.uuid(),
-    method: z.string(),
-    data: z.unknown().optional()
-  }),
-  z.object({
-    type: z.literal("response"),
-    id: z.uuid(),
-    result: iframeRpcCallResultSchema
-  })
-]);
-function isFireAndForgetOutputSchema(outputSchema) {
-  return outputSchema.type === "void" || outputSchema instanceof z.ZodVoid;
-}
-function isUndefinedInputSchema(inputSchema) {
-  return inputSchema.type === "undefined" || inputSchema instanceof z.ZodUndefined;
-}
-function coerceEmptyRpcInput({
-  input,
-  inputSchema
-}) {
-  if (isNullish(input) && isUndefinedInputSchema(inputSchema)) {
-    return void 0;
-  }
-  return input;
-}
-function createIframeRpcRemote(channelOrGetChannel, methods) {
-  const getChannel = typeof channelOrGetChannel === "function" ? channelOrGetChannel : () => channelOrGetChannel;
-  const outgoingMethods = methods ?? getChannel()?.outgoingMethods ?? null;
-  if (!outgoingMethods) {
-    throw new IframeRpcChannelConfigurationError({
-      message: "createIframeRpcRemote requires methods when the channel may be null"
-    });
-  }
-  return Object.fromEntries(
-    Object.keys(outgoingMethods).map(
-      (method) => {
-        return [
-          method,
-          (input) => {
-            const definition = outgoingMethods[method];
-            const channel = getChannel();
-            if (!channel) {
-              if (definition && isFireAndForgetOutputSchema(definition.outputSchema)) {
-                return void 0;
-              }
-              return Promise.reject(
-                new IframeRpcChannelUnsubscribedError({ method })
-              );
-            }
-            return channel.call({
-              method,
-              input
-            });
-          }
-        ];
-      }
-    )
-  );
-}
-function createIframeRpcChannel(options) {
-  const {
-    subscriberWindow,
-    channelIdentifier,
-    version,
-    getTargetWindow,
-    targetOrigin,
-    isExpectedMessage,
-    outgoingMethods,
-    incomingMethods,
-    handlers
-  } = options;
-  const pendingRequests = /* @__PURE__ */ new Map();
-  let subscriberCount = 0;
-  let handlerMeta;
-  const postMessage = (call2, targetWindow = getTargetWindow()) => {
-    targetWindow?.postMessage(
-      {
-        channelIdentifier,
-        version,
-        ...call2
-      },
-      targetOrigin
-    );
-  };
-  const respondWithError = ({
-    id,
-    errorMessage
-  }) => {
-    postMessage({
-      type: "response",
-      id,
-      result: { type: "error", errorMessage }
-    });
-  };
-  const handleRequest = async (message) => {
-    const definition = incomingMethods[message.method];
-    if (!definition || isFireAndForgetOutputSchema(definition.outputSchema)) {
-      respondWithError({
-        id: message.id,
-        errorMessage: `Unknown RPC method '${message.method}'`
-      });
-      return;
-    }
-    const parsedInput = definition.inputSchema.safeParse(
-      coerceEmptyRpcInput({
-        input: message.data,
-        inputSchema: definition.inputSchema
-      })
-    );
-    if (!parsedInput.success) {
-      respondWithError({
-        id: message.id,
-        errorMessage: `Invalid request payload for '${message.method}': ${parsedInput.error.message}`
-      });
-      return;
-    }
-    try {
-      const handler = handlers[
-        message.method
-      ];
-      const result = await handler(parsedInput.data, handlerMeta);
-      const parsedOutput = definition.outputSchema.safeParse(result);
-      if (!parsedOutput.success) {
-        respondWithError({
-          id: message.id,
-          errorMessage: `Invalid response payload for '${message.method}': ${parsedOutput.error.message}`
-        });
-        return;
-      }
-      postMessage({
-        type: "response",
-        id: message.id,
-        result: { type: "success", data: parsedOutput.data }
-      });
-    } catch (error) {
-      respondWithError({
-        id: message.id,
-        errorMessage: error instanceof Error ? error.message : String(error)
-      });
-    }
-  };
-  const handleNotification = (message) => {
-    const definition = incomingMethods[message.method];
-    if (!definition || !isFireAndForgetOutputSchema(definition.outputSchema)) {
-      return;
-    }
-    const parsedInput = definition.inputSchema.safeParse(
-      coerceEmptyRpcInput({
-        input: message.data,
-        inputSchema: definition.inputSchema
-      })
-    );
-    if (!parsedInput.success) {
-      defaultLogger.error(
-        `[iframeRpcChannel] Dropping invalid notify for '${message.method}': ${parsedInput.error.message}`
-      );
-      return;
-    }
-    const handler = handlers[
-      message.method
-    ];
-    handler(parsedInput.data, handlerMeta);
-  };
-  const handleResponse = (message) => {
-    const pendingRequest = pendingRequests.get(message.id);
-    if (!pendingRequest) {
-      return;
-    }
-    clearTimeout(pendingRequest.timeoutId);
-    pendingRequests.delete(message.id);
-    if (message.result.type === "error") {
-      pendingRequest.reject(
-        new IframeRpcChannelRemoteError({
-          method: pendingRequest.method,
-          message: message.result.errorMessage
-        })
-      );
-      return;
-    }
-    const definition = outgoingMethods[pendingRequest.method];
-    const parsedOutput = definition?.outputSchema.safeParse(
-      message.result.data
-    );
-    if (!parsedOutput?.success) {
-      pendingRequest.reject(
-        new IframeRpcChannelRemoteError({
-          method: pendingRequest.method,
-          message: `Invalid response payload: ${parsedOutput?.error.message ?? "unknown method"}`
-        })
-      );
-      return;
-    }
-    pendingRequest.resolve(parsedOutput.data);
-  };
-  const handleMessage = (event) => {
-    const parsedMetadata = z.object({
-      channelIdentifier: z.literal(channelIdentifier),
-      version: z.literal(version)
-    }).safeParse(event.data);
-    if (!parsedMetadata.success) {
-      return;
-    }
-    if (!isExpectedMessage(event)) {
-      const isSiblingFrame = typeof document !== "undefined" && Array.from(document.querySelectorAll("iframe")).some((frame) => {
-        return event.source !== null && frame.contentWindow === event.source;
-      });
-      if (isSiblingFrame) {
-        return;
-      }
-      defaultLogger.error("[iframeRpcChannel] Dropping unexpected message", {
-        channelIdentifier,
-        version,
-        origin: event.origin,
-        hasSource: Boolean(event.source)
-      });
-      return;
-    }
-    const parsedCall = iframeRpcCallSchema.safeParse(event.data);
-    if (!parsedCall.success) {
-      return;
-    }
-    const message = parsedCall.data;
-    if (message.type === "notify") {
-      handleNotification(message);
-      return;
-    }
-    if (message.type === "request") {
-      void handleRequest(message);
-      return;
-    }
-    handleResponse(message);
-  };
-  const rejectPendingRequests = () => {
-    for (const pendingRequest of pendingRequests.values()) {
-      clearTimeout(pendingRequest.timeoutId);
-      pendingRequest.reject(
-        new IframeRpcChannelUnsubscribedError({
-          method: pendingRequest.method
-        })
-      );
-    }
-    pendingRequests.clear();
-  };
-  const subscribe = () => {
-    subscriberCount += 1;
-    if (subscriberCount === 1) {
-      subscriberWindow.addEventListener("message", handleMessage);
-    }
-    let isActive = true;
-    return () => {
-      if (!isActive) {
-        return;
-      }
-      isActive = false;
-      subscriberCount -= 1;
-      if (subscriberCount === 0) {
-        subscriberWindow.removeEventListener("message", handleMessage);
-        rejectPendingRequests();
-      }
-    };
-  };
-  const call = ({
-    method,
-    input
-  }) => {
-    const definition = outgoingMethods[method];
-    if (!definition) {
-      return Promise.reject(
-        new IframeRpcChannelUnknownMethodError({ method })
-      );
-    }
-    const isFireAndForget = isFireAndForgetOutputSchema(
-      definition.outputSchema
-    );
-    const parsedInput = definition.inputSchema.safeParse(
-      coerceEmptyRpcInput({
-        input,
-        inputSchema: definition.inputSchema
-      })
-    );
-    if (!parsedInput.success) {
-      const error = new IframeRpcChannelInvalidInputError({
-        method,
-        cause: parsedInput.error
-      });
-      if (isFireAndForget) {
-        throw error;
-      }
-      return Promise.reject(error);
-    }
-    if (isFireAndForget) {
-      postMessage({
-        type: "notify",
-        method,
-        data: parsedInput.data
-      });
-      return void 0;
-    }
-    if (subscriberCount === 0) {
-      return Promise.reject(
-        new IframeRpcChannelUnsubscribedError({ method })
-      );
-    }
-    const targetWindow = getTargetWindow();
-    if (!targetWindow) {
-      return Promise.reject(
-        new IframeRpcChannelTargetUnavailableError({
-          callType: "request",
-          method
-        })
-      );
-    }
-    const id = randomUUID();
-    const timeoutMs = definition.timeoutMs ?? 3e4;
-    return new Promise(
-      (resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-          pendingRequests.delete(id);
-          reject(new IframeRpcChannelTimeoutError({ method, timeoutMs }));
-        }, timeoutMs);
-        pendingRequests.set(id, {
-          method,
-          resolve: (value) => {
-            resolve(value);
-          },
-          reject,
-          timeoutId
-        });
-        try {
-          postMessage(
-            {
-              type: "request",
-              id,
-              method,
-              data: parsedInput.data
-            },
-            targetWindow
-          );
-        } catch (error) {
-          clearTimeout(timeoutId);
-          pendingRequests.delete(id);
-          reject(error);
-        }
-      }
-    );
-  };
-  const channel = {
-    subscribe,
-    call,
-    outgoingMethods
-  };
-  handlerMeta = { channel: createIframeRpcRemote(channel) };
-  return channel;
-}
-
-export { createIframeRpcChannel, createIframeRpcRemote, iframeRpcCallSchema };