@godscene/playground-electron 1.7.11

package/dist/es/PlaygroundPreview.mjs

@@ -0,0 +1,29 @@
+import { jsx } from "react/jsx-runtime";
+import { PreviewRenderer } from "./PreviewRenderer.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = null != arguments[i] ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }));
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function PlaygroundPreview(props) {
+    return /*#__PURE__*/ jsx(PreviewRenderer, _object_spread({}, props));
+}
+export { PlaygroundPreview };

package/dist/es/PlaygroundThemeProvider.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { globalThemeConfig } from "@godscene/visualizer";
+import { ConfigProvider } from "antd";
+function PlaygroundThemeProvider({ children }) {
+    return /*#__PURE__*/ jsx(ConfigProvider, {
+        theme: globalThemeConfig(),
+        children: children
+    });
+}
+export { PlaygroundThemeProvider };

package/dist/es/PreviewRenderer.mjs

@@ -0,0 +1,270 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ScreenshotViewer } from "@godscene/visualizer";
+import { WebCodecsVideoDecoder } from "@yume-chan/scrcpy-decoder-webcodecs";
+import { Alert, Popover, message } from "antd";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { DeviceInteractionLayer } from "./DeviceInteractionLayer.mjs";
+import { ScrcpyPanel } from "./ScrcpyPanel.mjs";
+import { buildManualDragInteractPayload } from "./manual-interaction.mjs";
+import { resolvePreviewConnectionInfo } from "./runtime-info.mjs";
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(void 0);
+        });
+    };
+}
+function isNonLocalhostHttp() {
+    try {
+        const { protocol, hostname } = window.location;
+        if ('http:' !== protocol) return false;
+        return 'localhost' !== hostname && '127.0.0.1' !== hostname && '::1' !== hostname;
+    } catch (unused) {
+        return false;
+    }
+}
+function PreviewRenderer({ connectingOverlay, onScrcpyStatusChange, renderErrorOverlay, scrcpyViewportStyle, screenshotViewerMode, playgroundSDK, runtimeInfo, serverUrl, serverOnline, isUserOperating, manualControlEnabled = false, manualDragActionType = 'Swipe', manualKeyboardEnabled = false }) {
+    const previewConnection = resolvePreviewConnectionInfo(runtimeInfo, serverUrl);
+    const [deviceSize, setDeviceSize] = useState(null);
+    const manualControlQueueRef = useRef(Promise.resolve());
+    const enqueueManualControl = useCallback((task)=>{
+        const nextTask = manualControlQueueRef.current.then(task, task);
+        manualControlQueueRef.current = nextTask.catch(()=>void 0);
+        return nextTask;
+    }, []);
+    useEffect(()=>{
+        if (!manualControlEnabled || !serverOnline) return void setDeviceSize(null);
+        let cancelled = false;
+        const fetchSize = ()=>_async_to_generator(function*() {
+                var _result_size;
+                let result;
+                try {
+                    result = yield playgroundSDK.getInterfaceInfo();
+                } catch (unused) {
+                    return;
+                }
+                if (cancelled) return;
+                if ((null == result ? void 0 : null == (_result_size = result.size) ? void 0 : _result_size.width) && result.size.height) {
+                    const { size } = result;
+                    setDeviceSize((current)=>{
+                        if (current && current.width === size.width && current.height === size.height) return current;
+                        return {
+                            width: size.width,
+                            height: size.height
+                        };
+                    });
+                }
+            })();
+        fetchSize();
+        const timer = setInterval(fetchSize, 5000);
+        return ()=>{
+            cancelled = true;
+            clearInterval(timer);
+        };
+    }, [
+        manualControlEnabled,
+        playgroundSDK,
+        serverOnline
+    ]);
+    const showManualControlError = useCallback((fallback, error)=>{
+        message.open({
+            type: 'error',
+            content: error || fallback,
+            key: 'manual-control-error'
+        });
+    }, []);
+    const handleTap = useCallback((point)=>_async_to_generator(function*() {
+            const res = yield enqueueManualControl(()=>playgroundSDK.interact({
+                    actionType: 'Tap',
+                    x: point.x,
+                    y: point.y
+                }));
+            if (!res.ok) showManualControlError('Tap failed', res.error);
+        })(), [
+        enqueueManualControl,
+        playgroundSDK,
+        showManualControlError
+    ]);
+    const handleSwipe = useCallback((start, end, duration)=>_async_to_generator(function*() {
+            const res = yield enqueueManualControl(()=>playgroundSDK.interact(buildManualDragInteractPayload(manualDragActionType, start, end, duration)));
+            if (!res.ok) showManualControlError(`${manualDragActionType} failed`, res.error);
+        })(), [
+        enqueueManualControl,
+        manualDragActionType,
+        playgroundSDK,
+        showManualControlError
+    ]);
+    const handleTextInput = useCallback((text)=>_async_to_generator(function*() {
+            if (!text) return;
+            const res = yield enqueueManualControl(()=>playgroundSDK.interact({
+                    actionType: 'Input',
+                    value: text,
+                    mode: 'typeOnly'
+                }));
+            if (!res.ok) showManualControlError('Input failed', res.error);
+        })(), [
+        enqueueManualControl,
+        playgroundSDK,
+        showManualControlError
+    ]);
+    const handleKeyboardPress = useCallback((keyName)=>_async_to_generator(function*() {
+            if (!keyName) return;
+            const res = yield enqueueManualControl(()=>playgroundSDK.interact({
+                    actionType: 'KeyboardPress',
+                    keyName
+                }));
+            if (!res.ok) showManualControlError('Keyboard press failed', res.error);
+        })(), [
+        enqueueManualControl,
+        playgroundSDK,
+        showManualControlError
+    ]);
+    const scrcpyAvailable = 'scrcpy' === previewConnection.type && WebCodecsVideoDecoder.isSupported;
+    const useScreenshot = 'screenshot' === previewConnection.type || 'scrcpy' === previewConnection.type && !scrcpyAvailable;
+    const showInsecureContextHint = 'scrcpy' === previewConnection.type && !WebCodecsVideoDecoder.isSupported && isNonLocalhostHttp();
+    return /*#__PURE__*/ jsxs("div", {
+        style: {
+            flex: 1,
+            minHeight: 0,
+            height: '100%',
+            position: 'relative'
+        },
+        children: [
+            showInsecureContextHint && /*#__PURE__*/ jsx(Popover, {
+                content: /*#__PURE__*/ jsxs("div", {
+                    style: {
+                        maxWidth: 360
+                    },
+                    children: [
+                        /*#__PURE__*/ jsx("p", {
+                            style: {
+                                margin: '0 0 8px'
+                            },
+                            children: "Live scrcpy streaming is unavailable because WebCodecs API is disabled in non-secure (HTTP) contexts with non-localhost addresses."
+                        }),
+                        /*#__PURE__*/ jsx("p", {
+                            style: {
+                                margin: '0 0 8px'
+                            },
+                            children: "Currently using screenshot polling as fallback. To enable scrcpy streaming:"
+                        }),
+                        /*#__PURE__*/ jsxs("ol", {
+                            style: {
+                                margin: 0,
+                                paddingLeft: 18
+                            },
+                            children: [
+                                /*#__PURE__*/ jsxs("li", {
+                                    children: [
+                                        "Open",
+                                        ' ',
+                                        /*#__PURE__*/ jsx("code", {
+                                            children: "chrome://flags/#unsafely-treat-insecure-origin-as-secure"
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ jsxs("li", {
+                                    children: [
+                                        "Add ",
+                                        /*#__PURE__*/ jsx("code", {
+                                            children: window.location.origin
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ jsxs("li", {
+                                    children: [
+                                        "Set to ",
+                                        /*#__PURE__*/ jsx("b", {
+                                            children: "Enabled"
+                                        }),
+                                        " and relaunch Chrome"
+                                    ]
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                title: "Screenshot polling mode",
+                trigger: "click",
+                placement: "bottomRight",
+                children: /*#__PURE__*/ jsx("button", {
+                    type: "button",
+                    style: {
+                        position: 'absolute',
+                        top: 8,
+                        right: 8,
+                        zIndex: 10,
+                        background: '#faad14',
+                        border: 'none',
+                        borderRadius: '50%',
+                        width: 28,
+                        height: 28,
+                        display: 'flex',
+                        alignItems: 'center',
+                        justifyContent: 'center',
+                        cursor: 'pointer',
+                        boxShadow: '0 2px 6px rgba(0,0,0,0.2)'
+                    },
+                    children: /*#__PURE__*/ jsx("span", {
+                        style: {
+                            color: '#fff',
+                            fontSize: 14,
+                            fontWeight: 'bold',
+                            lineHeight: 1
+                        },
+                        children: "!"
+                    })
+                })
+            }),
+            'none' === previewConnection.type ? /*#__PURE__*/ jsx(Alert, {
+                type: "warning",
+                showIcon: true,
+                message: "Preview unavailable",
+                description: "This session did not expose a preview capability in runtime metadata."
+            }) : scrcpyAvailable ? /*#__PURE__*/ jsx(ScrcpyPanel, {
+                connectingOverlay: connectingOverlay,
+                deviceId: previewConnection.deviceId,
+                onStatusChange: onScrcpyStatusChange,
+                renderErrorOverlay: renderErrorOverlay,
+                serverUrl: previewConnection.scrcpyUrl,
+                viewportStyle: scrcpyViewportStyle
+            }) : /*#__PURE__*/ jsx(ScreenshotViewer, {
+                getScreenshot: ()=>useScreenshot ? playgroundSDK.getScreenshot() : Promise.resolve(null),
+                getInterfaceInfo: ()=>playgroundSDK.getInterfaceInfo(),
+                serverOnline: serverOnline,
+                isUserOperating: isUserOperating,
+                mjpegUrl: previewConnection.mjpegUrl,
+                mode: screenshotViewerMode
+            }),
+            /*#__PURE__*/ jsx(DeviceInteractionLayer, {
+                enabled: manualControlEnabled && serverOnline && 'none' !== previewConnection.type,
+                deviceSize: deviceSize,
+                onTap: handleTap,
+                onSwipe: handleSwipe,
+                keyboardEnabled: manualKeyboardEnabled,
+                onTextInput: handleTextInput,
+                onKeyboardPress: handleKeyboardPress
+            })
+        ]
+    });
+}
+export { PreviewRenderer };