@swan-io/lake 2.2.1 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swan-io/lake",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "engines": {
     "node": ">=18.0.0",
     "yarn": "^1.22.0"

package/src/components/ErrorBoundary.d.ts

@@ -0,0 +1,20 @@
+import { Component, ErrorInfo, ReactElement, ReactNode } from "react";
+type Props = {
+    children: ReactNode;
+    fallback: (data: {
+        error: Error;
+        resetError: () => void;
+    }) => ReactElement;
+    onError?: (error: Error, componentStack: ErrorInfo["componentStack"]) => void;
+};
+type State = {
+    error: Error | null;
+};
+export declare class ErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, { componentStack }: ErrorInfo): void;
+    resetError: () => void;
+    render(): ReactNode;
+}
+export {};

package/src/components/ErrorBoundary.js

@@ -0,0 +1,67 @@
+// https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary
+// https://github.com/getsentry/sentry-javascript/blob/7.56.0/packages/react/src/errorboundary.tsx
+import { Component, isValidElement } from "react";
+const isError = (value) => {
+    const string = Object.prototype.toString.call(value);
+    if (string === "[object Error]" ||
+        string === "[object Exception]" ||
+        string === "[object DOMException]") {
+        return true;
+    }
+    try {
+        return value instanceof Error;
+    }
+    catch {
+        return false;
+    }
+};
+const setCause = (error, cause) => {
+    const seen = new WeakMap();
+    const recurse = (error, cause) => {
+        if (seen.has(error)) {
+            return; // Prevent a stack overflow caused by a possible recursive loop
+        }
+        if (error.cause != null) {
+            seen.set(error, true);
+            return recurse(error.cause, cause);
+        }
+        error.cause = cause;
+    };
+    recurse(error, cause);
+};
+const initialState = {
+    error: null,
+};
+export class ErrorBoundary extends Component {
+    state = initialState;
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(error, { componentStack }) {
+        const { onError } = this.props;
+        if (isError(error)) {
+            const cause = new Error(error.message);
+            cause.name = `ErrorBoundary ${cause.name}`;
+            cause.stack = componentStack;
+            setCause(error, cause);
+        }
+        if (onError != null) {
+            onError(error, componentStack);
+        }
+    }
+    resetError = () => {
+        const { error } = this.state;
+        if (error !== null) {
+            this.setState(initialState);
+        }
+    };
+    render() {
+        const { children, fallback } = this.props;
+        const { error } = this.state;
+        if (error === null) {
+            return children;
+        }
+        const element = fallback({ error, resetError: this.resetError });
+        return isValidElement(element) ? element : null;
+    }
+}