@godscene/playground-electron 1.7.11

package/dist/lib/PlaygroundPreview.js

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PlaygroundPreview: ()=>PlaygroundPreview
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_PreviewRenderer_js_namespaceObject = require("./PreviewRenderer.js");
+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__*/ (0, jsx_runtime_namespaceObject.jsx)(external_PreviewRenderer_js_namespaceObject.PreviewRenderer, _object_spread({}, props));
+}
+exports.PlaygroundPreview = __webpack_exports__.PlaygroundPreview;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PlaygroundPreview"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/PlaygroundThemeProvider.js

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PlaygroundThemeProvider: ()=>PlaygroundThemeProvider
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const visualizer_namespaceObject = require("@godscene/visualizer");
+const external_antd_namespaceObject = require("antd");
+function PlaygroundThemeProvider({ children }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_antd_namespaceObject.ConfigProvider, {
+        theme: (0, visualizer_namespaceObject.globalThemeConfig)(),
+        children: children
+    });
+}
+exports.PlaygroundThemeProvider = __webpack_exports__.PlaygroundThemeProvider;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PlaygroundThemeProvider"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/PreviewRenderer.js

@@ -0,0 +1,304 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PreviewRenderer: ()=>PreviewRenderer
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const visualizer_namespaceObject = require("@godscene/visualizer");
+const scrcpy_decoder_webcodecs_namespaceObject = require("@yume-chan/scrcpy-decoder-webcodecs");
+const external_antd_namespaceObject = require("antd");
+const external_react_namespaceObject = require("react");
+const external_DeviceInteractionLayer_js_namespaceObject = require("./DeviceInteractionLayer.js");
+const external_ScrcpyPanel_js_namespaceObject = require("./ScrcpyPanel.js");
+const external_manual_interaction_js_namespaceObject = require("./manual-interaction.js");
+const external_runtime_info_js_namespaceObject = require("./runtime-info.js");
+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 = (0, external_runtime_info_js_namespaceObject.resolvePreviewConnectionInfo)(runtimeInfo, serverUrl);
+    const [deviceSize, setDeviceSize] = (0, external_react_namespaceObject.useState)(null);
+    const manualControlQueueRef = (0, external_react_namespaceObject.useRef)(Promise.resolve());
+    const enqueueManualControl = (0, external_react_namespaceObject.useCallback)((task)=>{
+        const nextTask = manualControlQueueRef.current.then(task, task);
+        manualControlQueueRef.current = nextTask.catch(()=>void 0);
+        return nextTask;
+    }, []);
+    (0, external_react_namespaceObject.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 = (0, external_react_namespaceObject.useCallback)((fallback, error)=>{
+        external_antd_namespaceObject.message.open({
+            type: 'error',
+            content: error || fallback,
+            key: 'manual-control-error'
+        });
+    }, []);
+    const handleTap = (0, external_react_namespaceObject.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 = (0, external_react_namespaceObject.useCallback)((start, end, duration)=>_async_to_generator(function*() {
+            const res = yield enqueueManualControl(()=>playgroundSDK.interact((0, external_manual_interaction_js_namespaceObject.buildManualDragInteractPayload)(manualDragActionType, start, end, duration)));
+            if (!res.ok) showManualControlError(`${manualDragActionType} failed`, res.error);
+        })(), [
+        enqueueManualControl,
+        manualDragActionType,
+        playgroundSDK,
+        showManualControlError
+    ]);
+    const handleTextInput = (0, external_react_namespaceObject.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 = (0, external_react_namespaceObject.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 && scrcpy_decoder_webcodecs_namespaceObject.WebCodecsVideoDecoder.isSupported;
+    const useScreenshot = 'screenshot' === previewConnection.type || 'scrcpy' === previewConnection.type && !scrcpyAvailable;
+    const showInsecureContextHint = 'scrcpy' === previewConnection.type && !scrcpy_decoder_webcodecs_namespaceObject.WebCodecsVideoDecoder.isSupported && isNonLocalhostHttp();
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+        style: {
+            flex: 1,
+            minHeight: 0,
+            height: '100%',
+            position: 'relative'
+        },
+        children: [
+            showInsecureContextHint && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_antd_namespaceObject.Popover, {
+                content: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+                    style: {
+                        maxWidth: 360
+                    },
+                    children: [
+                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)("p", {
+                            style: {
+                                margin: '0 0 8px'
+                            },
+                            children: "Currently using screenshot polling as fallback. To enable scrcpy streaming:"
+                        }),
+                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("ol", {
+                            style: {
+                                margin: 0,
+                                paddingLeft: 18
+                            },
+                            children: [
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("li", {
+                                    children: [
+                                        "Open",
+                                        ' ',
+                                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("code", {
+                                            children: "chrome://flags/#unsafely-treat-insecure-origin-as-secure"
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("li", {
+                                    children: [
+                                        "Add ",
+                                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("code", {
+                                            children: window.location.origin
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("li", {
+                                    children: [
+                                        "Set to ",
+                                        /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("b", {
+                                            children: "Enabled"
+                                        }),
+                                        " and relaunch Chrome"
+                                    ]
+                                })
+                            ]
+                        })
+                    ]
+                }),
+                title: "Screenshot polling mode",
+                trigger: "click",
+                placement: "bottomRight",
+                children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)("span", {
+                        style: {
+                            color: '#fff',
+                            fontSize: 14,
+                            fontWeight: 'bold',
+                            lineHeight: 1
+                        },
+                        children: "!"
+                    })
+                })
+            }),
+            'none' === previewConnection.type ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_antd_namespaceObject.Alert, {
+                type: "warning",
+                showIcon: true,
+                message: "Preview unavailable",
+                description: "This session did not expose a preview capability in runtime metadata."
+            }) : scrcpyAvailable ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_ScrcpyPanel_js_namespaceObject.ScrcpyPanel, {
+                connectingOverlay: connectingOverlay,
+                deviceId: previewConnection.deviceId,
+                onStatusChange: onScrcpyStatusChange,
+                renderErrorOverlay: renderErrorOverlay,
+                serverUrl: previewConnection.scrcpyUrl,
+                viewportStyle: scrcpyViewportStyle
+            }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(visualizer_namespaceObject.ScreenshotViewer, {
+                getScreenshot: ()=>useScreenshot ? playgroundSDK.getScreenshot() : Promise.resolve(null),
+                getInterfaceInfo: ()=>playgroundSDK.getInterfaceInfo(),
+                serverOnline: serverOnline,
+                isUserOperating: isUserOperating,
+                mjpegUrl: previewConnection.mjpegUrl,
+                mode: screenshotViewerMode
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_DeviceInteractionLayer_js_namespaceObject.DeviceInteractionLayer, {
+                enabled: manualControlEnabled && serverOnline && 'none' !== previewConnection.type,
+                deviceSize: deviceSize,
+                onTap: handleTap,
+                onSwipe: handleSwipe,
+                keyboardEnabled: manualKeyboardEnabled,
+                onTextInput: handleTextInput,
+                onKeyboardPress: handleKeyboardPress
+            })
+        ]
+    });
+}
+exports.PreviewRenderer = __webpack_exports__.PreviewRenderer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PreviewRenderer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});