@webspatial/platform-visionos 0.1.23 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webspatial/platform-visionos",
-  "version": "0.1.23",
+  "version": "1.0.0",
   "description": "Used to publish WebSpatial projects to Apple Vision Pro",
   "type": "commonjs",
   "engines": {

package/web-spatial/libs/Utils/CommandManager.swift

@@ -617,6 +617,7 @@ class CommandManager {
             // Update scene state
             var cfg = WindowContainerPlainDefaultValues()
             cfg.defaultSize = CGSize(width: resolution.width, height: resolution.height)
+            // TODO: need set resizeRange?
             WindowContainerMgr.Instance.updateWindowContainerPlainDefaultValues(cfg)
             return
         }

package/web-spatial/libs/Utils/WindowContainerMgr.swift

@@ -16,6 +16,10 @@ struct WindowContainerData: Decodable, Hashable, Encodable {
     let windowContainerID: String
 }
 
+struct WindowContainerResizability: Decodable, Encodable {
+    let resizeRange: ResizeRange?
+}
+
 enum LoadingMethod: String, Decodable, Encodable, Hashable {
     case show
     case hide
@@ -29,6 +33,7 @@ struct LoadingWindowContainerData: Decodable, Hashable, Encodable {
 struct WindowContainerPlainDefaultValues {
     var defaultSize: CGSize?
     var windowResizability: WindowResizability?
+    var resizeRange: ResizeRange?
 }
 
 // support WindowContainerOptions => WindowContainerPlainDefaultValues
@@ -38,19 +43,28 @@ extension WindowContainerPlainDefaultValues {
             width: options.defaultSize?.width ?? DefaultPlainWindowContainerSize.width,
             height: options.defaultSize?.height ?? DefaultPlainWindowContainerSize.height
         )
-        windowResizability = getWindowResizability(options.resizability)
+        windowResizability = getWindowResizability(nil)
+        resizeRange = options.resizability
     }
 }
 
+struct ResizeRange: Codable {
+    var minWidth: Double?
+    var minHeight: Double?
+    var maxWidth: Double?
+    var maxHeight: Double?
+}
+
 // incomming JSB data
 struct WindowContainerOptions: Codable {
     // windowContainer
     let defaultSize: Size?
-    let resizability: String?
     struct Size: Codable {
         var width: Double
         var height: Double
     }
+
+    let resizability: ResizeRange?
 }
 
 func getWindowResizability(_ windowResizability: String?) -> WindowResizability {
@@ -79,7 +93,8 @@ class WindowContainerMgr: ObservableObject {
 
     private var wgSetting: WindowContainerPlainDefaultValues = .init(
         defaultSize: CGSize(width: 1080, height: 720 + (pwaManager.display != .fullscreen ? NavView.navHeight : 0)),
-        windowResizability: .automatic
+        windowResizability: .automatic,
+        resizeRange: nil
     )
 
     func getValue() -> WindowContainerPlainDefaultValues {
@@ -100,5 +115,8 @@ class WindowContainerMgr: ObservableObject {
         if let newResizability = data.windowResizability {
             wgSetting.windowResizability = newResizability
         }
+        if let newResizeRange = data.resizeRange {
+            wgSetting.resizeRange = newResizeRange
+        }
     }
 }

package/web-spatial/libs/webView/backend/NativeWebView.swift

@@ -125,7 +125,6 @@ class Coordinator: NSObject, WKNavigationDelegate, WKScriptMessageHandler, WKUID
                 // backward/forward
                 webViewRef?.didNavBackForward()
             }
-            webViewRef?.navInfo.url = resource
             decisionHandler(.allow)
         } else {
             decisionHandler(.cancel)
@@ -211,6 +210,34 @@ class Coordinator: NSObject, WKNavigationDelegate, WKScriptMessageHandler, WKUID
             wg.updateFrame = !(wg.updateFrame)
         }
     }
+
+    private var isObserving = false
+    func startObserving(webView: WKWebView) {
+        guard !isObserving else { return }
+        webView.addObserver(self, forKeyPath: #keyPath(WKWebView.url), options: .new, context: nil)
+        isObserving = true
+    }
+
+    func stopObserving(webView: WKWebView) {
+        guard isObserving else { return }
+        webView.removeObserver(self, forKeyPath: #keyPath(WKWebView.url))
+        isObserving = false
+    }
+
+    override func observeValue(
+        forKeyPath keyPath: String?,
+        of object: Any?,
+        change: [NSKeyValueChangeKey: Any]?,
+        context: UnsafeMutableRawPointer?
+    ) {
+        if keyPath == #keyPath(WKWebView.url),
+           let url = (object as? WKWebView)?.url?.absoluteString
+        {
+            DispatchQueue.main.async {
+                self.webViewRef?.navInfo.url = url
+            }
+        }
+    }
 }
 
 struct WebViewNative: UIViewRepresentable {
@@ -250,6 +277,7 @@ struct WebViewNative: UIViewRepresentable {
                 myConfig.setURLSchemeHandler(webViewHolder.webViewCoordinator, forURLScheme: "file")
             }
             webViewHolder.appleWebView = WKWebView(frame: .zero, configuration: myConfig)
+            webViewHolder.webViewCoordinator!.startObserving(webView: webViewHolder.appleWebView!)
             let configUA = myConfig.applicationNameForUserAgent as? String ?? ""
 
             // change webview ua
@@ -284,6 +312,10 @@ struct WebViewNative: UIViewRepresentable {
     func updateUIView(_ webView: WKWebView, context: Context) {
         initialLoad()
     }
+
+    static func dismantleUIView(_ uiView: WKWebView, coordinator: Coordinator) {
+        coordinator.stopObserving(webView: uiView)
+    }
 }
 
 // extend webview to support file://

package/web-spatial/libs/webView/manifest.swift

@@ -21,7 +21,7 @@ struct PWAManager: Codable {
             width: 1280,
             height: 720
         ),
-        resizability: "automatic"
+        resizability: nil
     )
     var useMainScene: Bool = true
     private var version: String = "PACKAGE_VERSION"

package/web-spatial/views/PlainWindowContainerView.swift

@@ -9,7 +9,38 @@ struct PlainWindowContainerView: View {
     @State private var timer: Timer?
 
     private func setSize(size: CGSize) {
-        sceneDelegate.window?.windowScene?.requestGeometryUpdate(.Vision(size: size))
+        sceneDelegate.window?.windowScene?
+            .requestGeometryUpdate(
+                .Vision(
+                    size: size
+                )
+            )
+    }
+
+    private func setResizibility(resizingRestrictions: UIWindowScene.ResizingRestrictions) {
+        sceneDelegate.window?.windowScene?
+            .requestGeometryUpdate(
+                .Vision(
+                    resizingRestrictions: resizingRestrictions
+                )
+            )
+    }
+
+    private func setResizeRange(resizeRange: ResizeRange) {
+        sceneDelegate.window?.windowScene?
+            .requestGeometryUpdate(
+                .Vision(
+                    minimumSize: CGSize(
+                        width: resizeRange.minWidth ?? 0,
+                        height: resizeRange
+                            .minHeight ?? 0
+                    ),
+                    maximumSize: CGSize(
+                        width: resizeRange.maxWidth ?? .infinity,
+                        height: resizeRange.maxHeight ?? .infinity
+                    )
+                )
+            )
     }
 
     var body: some View {
@@ -59,6 +90,17 @@ struct PlainWindowContainerView: View {
             .onReceive(windowContainerContent.setSize) { newSize in
                 setSize(size: newSize)
             }
+            .onAppear {
+                let wd = WindowContainerMgr.Instance.getValue()
+                if let range = wd.resizeRange {
+                    self.setResizeRange(resizeRange: range)
+                    if (range.minWidth != nil || range.minWidth != nil) && range.minWidth == range.maxWidth && range.minHeight == range.maxHeight {
+                        self.setResizibility(resizingRestrictions: .none)
+                    } else {
+                        self.setResizibility(resizingRestrictions: .freeform)
+                    }
+                }
+            }
             .onChange(of: proxy3D.size) {
                 // WkWebview has an issue where it doesn't resize while the swift window is resized
                 // Treid to call didMoveToWindow to force redraw to occur but that seemed to cause rendering artifacts so that solution was rejected