@react-native-harness/runtime 1.0.0-alpha.15 → 1.0.0-alpha.17

package/dist/render/ErrorBoundary.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { View, Text, StyleSheet, ScrollView } from 'react-native';
+export class ErrorBoundary extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false, error: null };
+    }
+    static getDerivedStateFromError(error) {
+        return { hasError: true, error };
+    }
+    componentDidCatch(error, errorInfo) {
+        console.error('Error caught by ErrorBoundary:', error, errorInfo);
+    }
+    componentDidUpdate(prevProps) {
+        // Reset error state when children change (new component rendered)
+        if (prevProps.children !== this.props.children && this.state.hasError) {
+            this.setState({ hasError: false, error: null });
+        }
+    }
+    render() {
+        if (this.state.hasError && this.state.error) {
+            return (_jsx(View, { style: styles.errorContainer, children: _jsxs(View, { style: styles.errorContent, children: [_jsx(Text, { style: styles.errorTitle, children: "Component Error" }), _jsx(Text, { style: styles.errorSubtitle, children: "The rendered component threw an error:" }), _jsxs(ScrollView, { style: styles.errorScrollView, children: [_jsx(Text, { style: styles.errorMessage, children: this.state.error.message }), this.state.error.stack && (_jsx(Text, { style: styles.errorStack, children: this.state.error.stack }))] })] }) }));
+        }
+        return this.props.children;
+    }
+}
+const styles = StyleSheet.create({
+    errorContainer: {
+        flex: 1,
+        backgroundColor: 'rgba(220, 38, 38, 0.1)',
+        justifyContent: 'center',
+        alignItems: 'center',
+        padding: 20,
+    },
+    errorContent: {
+        backgroundColor: '#1f2937',
+        borderRadius: 12,
+        padding: 20,
+        maxWidth: 500,
+        width: '100%',
+        maxHeight: '80%',
+        borderWidth: 2,
+        borderColor: '#dc2626',
+    },
+    errorTitle: {
+        fontSize: 24,
+        fontWeight: '700',
+        color: '#dc2626',
+        marginBottom: 8,
+    },
+    errorSubtitle: {
+        fontSize: 14,
+        color: '#9ca3af',
+        marginBottom: 16,
+    },
+    errorScrollView: {
+        maxHeight: 400,
+    },
+    errorMessage: {
+        fontSize: 16,
+        fontWeight: '600',
+        color: '#fca5a5',
+        marginBottom: 12,
+        fontFamily: 'Courier',
+    },
+    errorStack: {
+        fontSize: 12,
+        color: '#d1d5db',
+        fontFamily: 'Courier',
+        lineHeight: 18,
+    },
+});

package/dist/render/TestComponentOverlay.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare const TestComponentOverlay: () => React.ReactElement | null;
+//# sourceMappingURL=TestComponentOverlay.d.ts.map

package/dist/render/TestComponentOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestComponentOverlay.d.ts","sourceRoot":"","sources":["../../src/render/TestComponentOverlay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoB,MAAM,OAAO,CAAC;AAMzC,eAAO,MAAM,oBAAoB,QAAO,KAAK,CAAC,YAAY,GAAG,IAgC5D,CAAC"}

package/dist/render/TestComponentOverlay.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { View, StyleSheet } from 'react-native';
+import { useRenderedElement } from '../ui/state.js';
+import { store } from '../ui/state.js';
+import { ErrorBoundary } from './ErrorBoundary.js';
+export const TestComponentOverlay = () => {
+    const { element, key } = useRenderedElement();
+    useEffect(() => {
+        // Call onRenderCallback when element changes
+        const callback = store.getState().onRenderCallback;
+        if (callback) {
+            callback();
+            store.getState().setOnRenderCallback(null);
+        }
+    }, [element]);
+    if (!element) {
+        return null;
+    }
+    const handleLayout = () => {
+        const callback = store.getState().onLayoutCallback;
+        if (callback) {
+            callback();
+            // Clear the callback after calling it
+            store.getState().setOnLayoutCallback(null);
+        }
+    };
+    return (_jsx(View, { style: styles.overlay, onLayout: handleLayout, children: _jsx(ErrorBoundary, { children: element }) }, key));
+};
+const styles = StyleSheet.create({
+    overlay: {
+        ...StyleSheet.absoluteFillObject,
+        backgroundColor: '#0a1628',
+        zIndex: 1000,
+    },
+});

package/dist/render/cleanup.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanup: () => void;
+//# sourceMappingURL=cleanup.d.ts.map

package/dist/render/cleanup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../src/render/cleanup.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,QAAO,IAI1B,CAAC"}

package/dist/render/cleanup.js

@@ -0,0 +1,6 @@
+import { store } from '../ui/state.js';
+export const cleanup = () => {
+    store.getState().setRenderedElement(null);
+    store.getState().setOnLayoutCallback(null);
+    store.getState().setOnRenderCallback(null);
+};

package/dist/render/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { RenderResult, RenderOptions } from './types.js';
+export declare const render: (element: React.ReactElement, options?: RenderOptions) => Promise<RenderResult>;
+export { cleanup } from './cleanup.js';
+export type { RenderResult, RenderOptions } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/render/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/render/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAY9D,eAAO,MAAM,MAAM,GACjB,SAAS,KAAK,CAAC,YAAY,EAC3B,UAAS,aAAkB,KAC1B,OAAO,CAAC,YAAY,CA2EtB,CAAC;AAEF,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC"}

package/dist/render/index.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { store } from '../ui/state.js';
+const wrapElement = (element, wrapper) => {
+    if (!wrapper) {
+        return element;
+    }
+    return React.createElement(wrapper, { children: element });
+};
+export const render = async (element, options = {}) => {
+    const { timeout = 1000, wrapper } = options;
+    // If an element is already rendered, unmount it first
+    if (store.getState().renderedElement !== null) {
+        store.getState().setRenderedElement(null);
+        store.getState().setOnLayoutCallback(null);
+        store.getState().setOnRenderCallback(null);
+    }
+    // Create a promise that resolves when the element is laid out
+    const layoutPromise = new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            store.getState().setOnLayoutCallback(null);
+            reject(new Error(`Render timeout: Element did not mount within ${timeout}ms`));
+        }, timeout);
+        store.getState().setOnLayoutCallback(() => {
+            clearTimeout(timeoutId);
+            resolve();
+        });
+    });
+    // Wrap and set the element in state (key is generated automatically)
+    const wrappedElement = wrapElement(element, wrapper);
+    store.getState().setRenderedElement(wrappedElement);
+    // Wait for layout
+    await layoutPromise;
+    const rerender = async (newElement) => {
+        if (store.getState().renderedElement === null) {
+            throw new Error('No element is currently rendered. Call render() first.');
+        }
+        // Create a promise that resolves when the element is re-rendered
+        const renderPromise = new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                store.getState().setOnRenderCallback(null);
+                reject(new Error(`Rerender timeout: Element did not update within ${timeout}ms`));
+            }, timeout);
+            store.getState().setOnRenderCallback(() => {
+                clearTimeout(timeoutId);
+                resolve();
+            });
+        });
+        const wrappedNewElement = wrapElement(newElement, wrapper);
+        store.getState().updateRenderedElement(wrappedNewElement);
+        // Wait for render
+        await renderPromise;
+    };
+    const unmount = () => {
+        if (store.getState().renderedElement === null) {
+            return;
+        }
+        store.getState().setRenderedElement(null);
+        store.getState().setOnLayoutCallback(null);
+        store.getState().setOnRenderCallback(null);
+    };
+    return {
+        rerender,
+        unmount,
+    };
+};
+export { cleanup } from './cleanup.js';

package/dist/render/setup.d.ts

@@ -0,0 +1,2 @@
+export declare const setup: () => void;
+//# sourceMappingURL=setup.d.ts.map

package/dist/render/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/render/setup.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK,YAIjB,CAAC"}

package/dist/render/setup.js

@@ -0,0 +1,7 @@
+import { afterEach } from '../collector/functions.js';
+import { cleanup } from './cleanup.js';
+export const setup = () => {
+    afterEach(() => {
+        cleanup();
+    });
+};

package/dist/render/types.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+export type RenderResult = {
+    rerender: (element: React.ReactElement) => Promise<void>;
+    unmount: () => void;
+};
+export type RenderOptions = {
+    timeout?: number;
+    wrapper?: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/render/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/render/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAC;CAC9D,CAAC"}

package/dist/render/types.js

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

package/dist/runner/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/runner/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,eAAO,MAAM,aAAa,QAAO,UAehC,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/runner/factory.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,eAAO,MAAM,aAAa,QAAO,UAsBhC,CAAC"}

package/dist/runner/factory.js

@@ -5,10 +5,15 @@ export const getTestRunner = () => {
     return {
         events,
         run: async (testSuite, testFilePath) => {
-            return runSuite(testSuite, {
+            const result = await runSuite(testSuite, {
                 events,
                 testFilePath,
             });
+            // If coverage is enabled, there will be a global variable called __coverage__
+            if ('__coverage__' in global && !!global.__coverage__) {
+                result.coverage = global.__coverage__;
+            }
+            return result;
         },
         dispose: () => {
             events.clearAllListeners();