🥮 mooncakes.io

    moonview

    Direct native WebView embedding for MoonBit.

    webview
    webview2
    webkitgtk
    windows
    macos
    linux
    openharmony
    arkweb
    desktop
    Download zip
    Version
    0.1.0-beta.11
    License
    Apache-2.0
    Repository
    Last updated
    11 hours ago
    Downloads
    483

    Dependencies

    #moonview

    moonview embeds a native platform WebView into a MoonBit application's existing window. It does not create a top-level window or run an event loop. The host owns those responsibilities; moonview owns the child WebView.

    During a PageMessage callback, view.page_message_source() returns the native main-frame source URL on Windows and macOS. It returns None outside that callback or when provenance is unavailable (currently Linux and OpenHarmony). Do not substitute the current or pending navigation URL when authorizing IPC.

    #Install

    Add the preview package to a native MoonBit module:

    moon add Nanaloveyuki/moonview@0.1.0-beta.11

    Add the package import in the consumer's moon.pkg, then refer to it as @moonview:

    import {
      "Nanaloveyuki/moonview",
    }

    The package-level reference is src/README.mbt.md.

    #Host Contract

    Create the WebView on the UI thread that owns its native parent, keep that platform's event loop running, resize it with the parent, and destroy it before the parent is destroyed. Every command, including destroy, must run on that same UI thread; Moonview does not provide a cross-thread dispatcher.

    Platformparent_handle passed to WebView::create
    WindowsA caller-owned HWND on an STA UI thread
    macOSA caller-owned NSView* on the main thread
    LinuxA caller-owned GtkFixed* on the GTK UI thread
    OpenHarmonyAn ArkUI-owned Web component identified by webTag

    This raw-handle boundary is intentional so a window-management library can own native window creation and event dispatch. Popup and window.open requests are denied by default. A host can instead redirect an individual request into the existing WebView; Moonview never creates a top-level window for page content.

    #Create A WebView

    Use Ready before issuing work that requires a loaded native view. initial_html takes precedence when both initial-content fields are set.

    let options = @moonview.WebViewOptions::new(
      bounds=@moonview.Rect::new(x=0, y=0, width=800, height=600),
      initial_url="https://example.com",
      initialization_script="console.log('moonview initialized')",
      on_event=event => match event {
        @moonview.WebViewEvent::Ready => println("webview ready")
        @moonview.WebViewEvent::CreationFailed(_error) => println("create failed")
        @moonview.WebViewEvent::ProcessFailed(_error) => println("browser process failed")
        _ => ()
      },
      on_navigation=_url => @moonview.NavigationDecision::Allow,
      on_new_window=_url => @moonview.NewWindowDecision::Deny,
    )

    match @moonview.WebView::create(parent_handle, options) {
      Ok(view) => ignore(view.set_visible(true))
      Err(_error) => abort("WebView creation rejected")
    }

    Resize the child with the host window and dispose it during host teardown:

    ignore(view.set_bounds(@moonview.Rect::new(x=0, y=0, width=1024, height=768)))
    ignore(view.navigate("https://example.com/docs"))
    ignore(view.destroy())

    Control methods return Ok(()) only when the native backend accepts or queues the command for a live view. Page navigation and JavaScript execution remain asynchronous; observe their final outcomes through WebViewEvent.

    ProcessFailed is terminal. The current desktop event adapters report it for WebView2 on Windows; macOS and Linux do not expose an equivalent process termination event yet. Destroy a failed WebView on its owner UI thread, then create a replacement explicitly. Moonview does not recreate browser processes in the background.

    #Browser Data Contexts

    The default WebView::create uses the shared persistent context. Reuse a WebContext when multiple views must share browser data, and pass it to create_in_context:

    let context = @moonview.WebContext::persistent(data_directory="F:/app-data/moonview")
    match @moonview.WebView::create_in_context(context, parent_handle, options) {
      Ok(view) => ignore(view.set_visible(true))
      Err(_error) => abort("WebView creation rejected")
    }

    Custom data directories are supported on Windows and Linux. Ephemeral contexts are supported on macOS and Linux. Unsupported combinations return Unsupported instead of falling back to another browser profile.

    #OpenHarmony ArkWeb (Experimental)

    OpenHarmony does not expose native creation of an arbitrary child WebView. The ArkUI host creates the Web component, selects its source and permissions, and then attaches Moonview using that component's stable webTag on the ArkUI UI thread:

    let options = @moonview.OhosAttachOptions::new(
      on_event=event => match event {
        @moonview.WebViewEvent::Ready => println("ArkWeb controller attached")
        _ => ()
      },
    )

    match @moonview.WebView::attach_ohos("main-web", options) {
      Ok(view) => {
        ignore(view.reload())
        // API 12 executes this without a ScriptResult callback.
        ignore(view.eval("console.log('from MoonBit')", "startup"))
      }
      Err(_error) => abort("ArkWeb attach rejected")
    }

    This first adapter targets OpenHarmony API 12 and supports attach, reload, fire-and-forget eval, and detachment through destroy. ArkUI retains source, layout, visibility, focus, and media-permission ownership. Navigation, HTML loading, init scripts, history, zoom, page messaging, custom schemes, and script-result callbacks return Unsupported until their thread-safe native adapters are implemented. destroy detaches Moonview only; it never destroys the ArkUI component. If ArkUI destroys the component first, view.lifecycle() reports Destroyed; call destroy() afterward to release Moonview's registration.

    #Page Communication

    The injected page bridge exposes window.moonview.postMessage(string). Handle PageMessage in on_event, and send data to the page with post_message. Payloads are UTF-8 strings; applications define their own JSON or RPC protocol. When native code posts to the page, window.moonview.onmessage receives an object with the UTF-8 payload in event.data on every desktop backend.

    match event {
      @moonview.WebViewEvent::PageMessage(message) => println("page: \{message}")
      @moonview.WebViewEvent::ScriptResult(id, value) => println("\{id}: \{value}")
      _ => ()
    }

    ignore(view.post_message("host-ready"))
    ignore(view.eval("document.title", "document-title"))

    window.moonview.onmessage = event => {
  console.log(event.data)
}

    eval reports JSON text through ScriptResult; JavaScript undefined is reported as null.

    #Resource Limits

    Each desktop WebView defaults to a 4 MiB custom-scheme request body limit. Windows also defaults to 256 commands queued before readiness and 4 MiB of queued command storage. Pass WebViewResourceLimits through WebViewOptions to configure these values; 0 disables an individual limit and negative values reject creation with NativeFailure. The protocol body limit applies on Windows, macOS, and Linux; the pending-command limits currently apply only on Windows.

    let limits = @moonview.WebViewResourceLimits::new(
      max_pending_commands=64,
      max_pending_command_bytes=1024 * 1024,
      max_protocol_request_body_bytes=1024 * 1024,
    )
    let options = @moonview.WebViewOptions::new(
      bounds=@moonview.Rect::new(x=0, y=0, width=800, height=600),
      resource_limits=limits,
    )

    #Serve Application Resources

    Register application-owned schemes before the first WebView::create. Native backends emit ProtocolRequest events containing the method, URI, headers, and binary body. Retain the owning WebView in the callback state, then answer the request with respond_protocol before its 30-second deadline.

    ignore(@moonview.register_custom_scheme("app"))

    let response = @moonview.ProtocolResponse::new(
      status=200,
      headers=[@moonview.HttpHeader::new(name="Content-Type", value="text/html")],
      body=b"<!doctype html><title>moonview</title>",
    )

    // In the WebView event callback:
    // @moonview.WebViewEvent::ProtocolRequest(request) =>
    //   ignore(view.respond_protocol(request.id, response))

    Use URLs such as app://ui/index.html. Windows and WebKitGTK register custom schemes as secure origins; WKWebView uses its public URL-scheme handler. Unanswered or cancelled requests emit ProtocolCancelled. Requests whose body exceeds the configured limit receive HTTP 413 locally and do not produce a ProtocolRequest event.

    #Permissions And Diagnostics

    Camera and microphone requests are denied by default. Supply on_media_permission only when the application can make a synchronous policy decision for the requesting origin. Other browser permission categories are not part of the cross-platform API.

    open_devtools is available on Windows and Linux; WKWebView returns Unsupported. open_print_dialog uses the platform print UI and may be unsupported on older platform runtimes.

    #Native File Dialogs

    WebView::show_file_dialog presents a platform-native dialog from the owning UI thread. Windows supports file open, multi-file open, save, and directory selection. Other backends currently return Unsupported explicitly.

    match view.show_file_dialog(
      @moonview.FileDialogOptions::new(
        kind=@moonview.FileDialogKind::OpenFile,
        title=Some("Open document"),
        filters=[
          @moonview.FileDialogFilter::new(
            name="Text files",
            extensions=["txt", "md"],
          ),
        ],
      ),
    ) {
      Ok(@moonview.FileDialogResult::Cancelled) => ()
      Ok(@moonview.FileDialogResult::Selected(paths)) => println(paths)
      Err(error) => println(error)
    }

    The selected paths are native host data. Frameworks embedding MoonView should apply their own capability policy before forwarding a selection to page code. For an interactive Windows verification in this checkout, run:

    $env:MOONVIEW_FILE_DIALOG_SMOKE = "1"
moon run src/examples/windows_smoke

    Cancel the dialog or select a MoonBit source file; either normal outcome lets the smoke contract complete. Omit the environment variable in CI.

    #Platform Prerequisites

    • Windows: Visual Studio Build Tools and the Edge WebView2 Runtime. On the first native build, Moonview downloads the official Microsoft WebView2 SDK 1.0.4078.44, verifies its pinned SHA-256 digest, and atomically extracts it under %LOCALAPPDATA%\moonview\webview2\1.0.4078.44. Parallel builds share a directory lock. Set MOONVIEW_WEBVIEW2_CACHE_DIR to move the cache, or set MOONVIEW_WEBVIEW2_SDK_DIR to use an existing SDK without downloading. MOONVIEW_WEBVIEW2_INCLUDE and MOONVIEW_WEBVIEW2_LOADER_LIB remain the most specific overrides. Set MOONVIEW_WEBVIEW2_ARCH to x64, x86, or arm64; it defaults to x64. Automatic extraction uses tar from PATH.
    • macOS: Xcode Command Line Tools. WKWebView is supplied by the operating system.
    • Linux: GTK 3 and the webkit2gtk-4.1 development package available through pkg-config. The Linux smoke also works through WSLg.
    • OpenHarmony: an app manifest declaring SystemCapability.Web.Webview.Core and the user-supplied ArkWeb NDK. Set MOONVIEW_OHOS_ARKWEB_SDK_DIR (or MOONVIEW_OHOS_NDK_HOME) to a directory containing arkweb_interface.h and libohweb.so; alternatively set both MOONVIEW_OHOS_ARKWEB_INCLUDE and MOONVIEW_OHOS_ARKWEB_LIB. Moonview does not vendor or read SDK files from ref/.
    • Android (experimental): import Nanaloveyuki/moonview/android, which depends only on the optional Nanaloveyuki/ajni/webview feature. Attach ajni's Kotlin host to an Activity-owned FrameLayout before creating a view, and set MOONVIEW_NATIVE_BACKEND=android for the MoonBit build. The adapter provides a single HTTPS asset origin, document-start scripts, structured page messages, asynchronous asset responses, operation-correlated errors, and resource limits. See src/android/README.mbt.md for CMake integration and usage.

    #Verify A Checkout

    moon fmt --check
moon check --target native
moon test --target native
node --test tests/build.test.js
.\scripts\test-windows.ps1
.\scripts\test-windows.ps1 -WebView2Sdk F:\path\to\Microsoft.Web.WebView2.1.0.x

    macOS and Fedora native smoke coverage runs in GitHub Actions.

    #Contributing

    See CONTRIBUTING.md for development setup, validation, and pull request requirements.

    #Preview Compatibility

    0.1.0-beta.9 is an API preview. Compatibility may change before stable 0.1.0, particularly once a concrete window-host integration contract exists.

    #moonview

    moonview is the native-only package for embedding a platform WebView in a caller-owned native container. The host supplies the parent handle, owns the UI thread and event loop, resizes the child, and destroys the child before its parent. Every WebView command must run on that owner UI thread; Moonview does not provide cross-thread dispatch.

    #Minimal Use

    let options = WebViewOptions::new(
      bounds=Rect::new(x=0, y=0, width=800, height=600),
      initial_html="<!doctype html><title>moonview</title>",
      on_event=event => match event {
        WebViewEvent::Ready => println("ready")
        WebViewEvent::CreationFailed(_error) => println("failed")
        WebViewEvent::ProcessFailed(_error) => println("browser process failed")
        _ => ()
      },
    )

    match WebView::create(parent_handle, options) {
      Ok(view) => ignore(view.post_message("host-ready"))
      Err(_error) => abort("create rejected")
    }

    Control methods return Ok(()) only after the native backend accepts or queues the command for a live view. Navigation and JavaScript outcomes remain asynchronous and are reported through WebViewEvent.

    ProcessFailed is terminal. The current desktop event adapters report it for WebView2 on Windows; macOS and Linux do not expose an equivalent process termination event yet. On Windows runtime failures, Moonview stops accepting commands for that view. Destroy it on its owner UI thread, then create a replacement explicitly; Moonview never attempts background recovery.

    #Resource Limits

    Each desktop WebView has a 4 MiB custom-scheme request body limit. Windows also limits each WebView to 256 commands queued before readiness and 4 MiB of queued command storage. Configure or disable individual limits with WebViewResourceLimits; 0 disables one limit, while negative values cause WebView::create to return NativeFailure. The protocol body limit applies to Windows, macOS, and Linux; the pending-command limits currently apply only on Windows.

    ///|
    let options = WebViewOptions::new(
      bounds=Rect::new(x=0, y=0, width=800, height=600),
      resource_limits=WebViewResourceLimits::new(
        max_pending_commands=64,
        max_pending_command_bytes=1024 * 1024,
        max_protocol_request_body_bytes=1024 * 1024,
      ),
    )

    Use WebViewEvent::Ready before relying on a loaded document. Page code sends UTF-8 strings with window.moonview.postMessage(...); native code receives PageMessage and sends strings with WebView::post_message(...). Page-side window.moonview.onmessage receives an object whose data property contains the UTF-8 message on every desktop backend.

    #Browser Data Contexts

    WebView::create uses the shared persistent context. Reuse a WebContext when multiple views must share browser data:

    let context = @moonview.WebContext::persistent(data_directory="F:/app-data/moonview")
    match @moonview.WebView::create_in_context(context, parent_handle, options) {
      Ok(view) => ignore(view.set_visible(true))
      Err(_error) => abort("WebView creation rejected")
    }

    Custom data directories are supported on Windows and Linux. Ephemeral contexts are supported on macOS and Linux. Unsupported combinations return Unsupported rather than selecting another browser profile.

    #OpenHarmony ArkWeb

    OpenHarmony hosts Web in ArkUI rather than accepting an arbitrary native parent handle. Create that component in ArkUI, then attach on its UI thread by its stable webTag:

    let options = OhosAttachOptions::new(
      on_event=event => match event {
        WebViewEvent::Ready => println("ArkWeb attached")
        _ => ()
      },
    )

    match WebView::attach_ohos("main-web", options) {
      Ok(view) => {
        ignore(view.reload())
        ignore(view.eval("console.log('moonview')", "startup"))
      }
      Err(_error) => abort("ArkWeb attach rejected")
    }

    The experimental API 12 adapter supports attach, reload, fire-and-forget eval, and detachment. ArkUI owns source, layout, visibility, and permissions; the remaining desktop-style controls return Unsupported. destroy detaches Moonview and does not destroy the ArkUI Web component. If ArkUI destroys the component first, WebView::lifecycle() reports Destroyed; call destroy() afterward to release Moonview's registration.

    #Application Resources

    Call register_custom_scheme(...) before the first WebView::create, then respond to each ProtocolRequest with WebView::respond_protocol(...). The request callback carries method, URI, headers, and binary body data; unanswered requests are cancelled after 30 seconds. Oversized request bodies are answered with HTTP 413 locally and are not dispatched to MoonBit.

    #Permissions

    Camera and microphone requests are denied unless on_media_permission returns MediaPermissionDecision::Allow. Other browser permission kinds are not part of this cross-platform package API.

    #Native File Dialogs

    WebView::show_file_dialog presents a platform-native dialog from the owning UI thread. Windows supports file open, multi-file open, save, and directory selection. Other backends currently return Unsupported explicitly.

    match view.show_file_dialog(
      FileDialogOptions::new(
        kind=FileDialogKind::OpenFile,
        title=Some("Open document"),
        filters=[
          FileDialogFilter::new(
            name="Text files",
            extensions=["txt", "md"],
          ),
        ],
      ),
    ) {
      Ok(FileDialogResult::Cancelled) => ()
      Ok(FileDialogResult::Selected(paths)) => println(paths)
      Err(error) => println(error)
    }

    The selected paths are native host data. Frameworks embedding MoonView should apply their own capability policy before forwarding a selection to page code.

    #Main Entry Points

    • WebViewOptions::new(...) configures creation callbacks and initial content.
    • on_new_window denies page-created windows by default, or can return NewWindowDecision::NavigateCurrent to redirect the requesting WebView.
    • WebView::create(...) embeds an asynchronously-created native child view.
    • WebView::set_bounds(...), navigate(...), eval(...), and post_message(...) control a live view.
    • WebView::show_file_dialog(...) presents a native file or directory dialog.
    • WebView::destroy(...) releases the native child before the host parent.
    • register_custom_scheme(...) and WebView::respond_protocol(...) serve application-owned resources.

    See the repository README for platform prerequisites and host-handle details.

    FileDialogFilter

    source
    pub(all) struct FileDialogFilter {
      name : String
      extensions : Array[String]
    } derive(Eq, 
    Debug    )

    A user-facing name and the extensions accepted by a file dialog. Extensions do not include a leading dot or wildcard.

    FileDialogFilter::new

    source
    fn FileDialogFilter::new(name~ : String, extensions~ : Array[String]) -> FileDialogFilter

    FileDialogKind

    source
    pub(all) enum FileDialogKind {
      OpenFile
      OpenFiles
      SaveFile
      PickDirectory
    } derive(Eq, 
    Debug    )

    The native dialog operation to present for a WebView.

    FileDialogOptions

    source
    pub(all) struct FileDialogOptions {
      kind : FileDialogKind
      title : String?
      filters : Array[FileDialogFilter]
      default_name : String?
      initial_directory : String?
    } derive(Eq, 
    Debug    )

    Options for a native file dialog owned by a WebView's native container.

    FileDialogOptions::new

    source
    fn FileDialogOptions::new(kind~ : FileDialogKind, title? : String?, filters? : Array[FileDialogFilter], default_name? : String?, initial_directory? : String?) -> FileDialogOptions

    FileDialogResult

    source
    pub(all) enum FileDialogResult {
      Cancelled
      Selected(Array[String])
    } derive(Eq, 
    Debug    )

    The outcome of a native file dialog. Cancelled is a normal user action.

    HttpHeader

    source
    pub(all) struct HttpHeader {
      name : String
      value : String
    } derive(Eq, 
    Debug    )

    A single HTTP header in a custom-scheme request or response.

    HttpHeader::new

    source
    fn HttpHeader::new(name~ : String, value~ : String) -> HttpHeader

    MediaPermissionDecision

    source
    pub(all) enum MediaPermissionDecision {
      Allow
      Deny
    } derive(Eq, 
    Debug    )

    The decision synchronously returned to a native media-permission callback.

    MediaPermissionKind

    source
    pub(all) enum MediaPermissionKind {
      Camera
      Microphone
      CameraAndMicrophone
      Unknown(Int)
    } derive(Eq, 
    Debug    )

    A media capture category requested by page content.

    MediaPermissionRequest

    source
    pub(all) struct MediaPermissionRequest {
      kind : MediaPermissionKind
      origin : String
    } derive(Eq, 
    Debug    )

    A synchronous request to access local media devices from an origin.
    pub(all) enum NavigationDecision {
      Allow
      Deny
    } derive(Eq, 
    Debug    )

    The decision synchronously returned to a native navigation callback.
    pub(all) struct NavigationState {
      url : String
      can_go_back : Bool
      can_go_forward : Bool
    } derive(Eq, 
    Debug    )

    The most recently observed document URL and history availability.
    fn NavigationState::new(url? : String, can_go_back? : Bool, can_go_forward? : Bool) -> NavigationState

    NewWindowDecision

    source
    pub(all) enum NewWindowDecision {
      Deny
      NavigateCurrent
    } derive(Eq, 
    Debug    )

    The decision synchronously returned when page content requests a new browser window. Moonview never creates a top-level native window itself.

    OhosAttachOptions

    source
    pub(all) struct OhosAttachOptions {
      on_event : (WebViewEvent) -> Unit
    }

    Configuration for attaching to an ArkUI-owned OpenHarmony Web component.

    The ArkUI host owns the component's source, layout, visibility, and browser permissions. This API is separate from WebViewOptions so unsupported creation settings cannot be silently ignored.

    OhosAttachOptions::new

    source
    fn OhosAttachOptions::new(on_event? : (WebViewEvent) -> Unit) -> OhosAttachOptions

    ProtocolRequest

    source
    pub(all) struct ProtocolRequest {
      id : String
      scheme : String
      http_method : String
      uri : String
      headers : Array[HttpHeader]
      body : Bytes
    } derive(Eq, 
    Debug    )

    A pending custom-scheme request. body is unmodified binary request data.

    ProtocolResponse

    source
    pub(all) struct ProtocolResponse {
      status : Int
      headers : Array[HttpHeader]
      body : Bytes
    } derive(Eq, 
    Debug    )

    A response to a pending custom-scheme request.

    ProtocolResponse::new

    source
    fn ProtocolResponse::new(status~ : Int, headers? : Array[HttpHeader], body? : Bytes) -> ProtocolResponse

    Rect

    source
    pub(all) struct Rect {
      x : Int
      y : Int
      width : Int
      height : Int
    } derive(Eq, 
    Debug    )

    A pixel rectangle relative to the caller-owned native parent container.

    Rect::new

    source
    fn Rect::new(x~ : Int, y~ : Int, width~ : Int, height~ : Int) -> Rect

    WebContext

    source
    pub(all) struct WebContext {
      // private fields
    } derive(Eq, 
    Debug    )

    A browser-data context that can be shared by multiple WebViews.

    WebContext::ephemeral

    source
    fn WebContext::ephemeral() -> WebContext

    Creates an isolated, non-persistent context.

    This is supported by WKWebView and WebKitGTK. WebView2 currently rejects this mode because it does not expose a compatible cross-platform profile.

    WebContext::persistent

    source
    fn WebContext::persistent(data_directory? : String) -> WebContext

    Creates a persistent context. A non-empty data_directory is supported on Windows and Linux; macOS rejects it rather than silently using another path.

    WebContextStorage

    source
    pub(all) enum WebContextStorage {
      Persistent
      Ephemeral
    } derive(Eq, 
    Debug    )

    The persistence policy for browser data owned by a WebContext.

    WebView

    source
    pub struct WebView {
      // private fields
    }

    An embedded platform WebView associated with a caller-owned native container.

    WebView::add_init_script

    source
    fn WebView::add_init_script(self : WebView, script : String) -> Result[Unit, WebViewError]

    WebView::attach_ohos

    source
    fn WebView::attach_ohos(web_tag : String, options : OhosAttachOptions) -> Result[WebView, WebViewError]

    Attaches Moonview to an ArkUI-owned OpenHarmony Web component.

    Call this on the ArkUI UI thread after the host has created the component with the same stable web_tag. The host remains responsible for its source, layout, visibility, and permission policy. The API is experimental and currently supports only reload, fire-and-forget eval, and destroy.

    WebView::create

    source
    fn WebView::create(parent_handle : UInt64, options : WebViewOptions) -> Result[WebView, WebViewError]

    Starts asynchronous creation of a WebView child view in parent_handle.

    The caller must keep the native parent container alive and run its UI event loop until the listener receives WebViewEvent::Ready or CreationFailed. A later ProcessFailed is terminal: destroy the view and create a new one explicitly after the host has handled the failure. On Windows, this is an HWND; on macOS, an NSView*; and on Linux, a GtkFixed*. Every later command, including destroy, must use this same UI thread.

    WebView::create_in_context

    source
    fn WebView::create_in_context(context : WebContext, parent_handle : UInt64, options : WebViewOptions) -> Result[WebView, WebViewError]

    Starts asynchronous creation in a browser-data context shared by one or more WebViews.

    WebView::destroy

    source
    fn WebView::destroy(self : WebView) -> Result[Unit, WebViewError]

    Destroys the native child view. Repeated calls are harmless.

    WebView::eval

    source
    fn WebView::eval(self : WebView, script : String, request_id : String) -> Result[Unit, WebViewError]

    WebView::focus

    source
    fn WebView::focus(self : WebView) -> Result[Unit, WebViewError]

    WebView::go_back

    source
    fn WebView::go_back(self : WebView) -> Result[Unit, WebViewError]

    WebView::go_forward

    source
    fn WebView::go_forward(self : WebView) -> Result[Unit, WebViewError]

    WebView::lifecycle

    source
    fn WebView::lifecycle(self : WebView) -> WebViewLifecycle

    WebView::load_html

    source
    fn WebView::load_html(self : WebView, html : String) -> Result[Unit, WebViewError]

    WebView::navigate

    source
    fn WebView::navigate(self : WebView, url : String) -> Result[Unit, WebViewError]

    WebView::navigation_state

    source
    fn WebView::navigation_state(self : WebView) -> NavigationState

    Returns the last document URL and history state reported by the native backend. The value is updated asynchronously through navigation events.

    WebView::open_devtools

    source
    fn WebView::open_devtools(self : WebView) -> Result[Unit, WebViewError]

    Opens the platform developer tools for this WebView.

    This is supported by the Windows and Linux backends. macOS does not expose a supported public API for programmatically opening WKWebView inspector.

    WebView::open_print_dialog

    source
    fn WebView::open_print_dialog(self : WebView) -> Result[Unit, WebViewError]

    Opens the platform print dialog for the current document.

    The dialog is available after Ready. Older WebView2 runtimes and macOS releases before 11 return Unsupported.

    WebView::page_message_source

    source
    fn WebView::page_message_source(self : WebView) -> String?

    Returns the native source URL during a main-frame PageMessage callback. Returns None outside the callback, on the wrong thread, or when the backend cannot attest the source (currently WebKitGTK and ArkWeb). Never substitute navigation_state().url for missing message provenance.

    WebView::post_message

    source
    fn WebView::post_message(self : WebView, message : String) -> Result[Unit, WebViewError]

    Posts an application-defined UTF-8 message to window.moonview in the page.

    WebView::reload

    source
    fn WebView::reload(self : WebView) -> Result[Unit, WebViewError]

    WebView::respond_protocol

    source
    fn WebView::respond_protocol(self : WebView, request_id : String, response : ProtocolResponse) -> Result[Unit, WebViewError]

    Completes a pending custom-scheme request. The request ID is valid only until the native backend's 30-second response deadline expires.

    WebView::set_bounds

    source
    fn WebView::set_bounds(self : WebView, bounds : Rect) -> Result[Unit, WebViewError]

    WebView::set_visible

    source
    fn WebView::set_visible(self : WebView, visible : Bool) -> Result[Unit, WebViewError]

    WebView::set_zoom_factor

    source
    fn WebView::set_zoom_factor(self : WebView, factor : Double) -> Result[Unit, WebViewError]

    Sets the page zoom factor. Values must be greater than zero.

    WebView::show_file_dialog

    source
    fn WebView::show_file_dialog(self : WebView, options : FileDialogOptions) -> Result[FileDialogResult, WebViewError]

    Shows a native file dialog owned by this WebView's native container.

    The method must run on the WebView creation thread. A user cancellation is returned as FileDialogResult::Cancelled; backend and native failures are returned as WebViewError values.

    WebView::stop

    source
    fn WebView::stop(self : WebView) -> Result[Unit, WebViewError]

    WebViewError

    source
    pub(all) enum WebViewError {
      Unavailable
      Unsupported(String)
      ConfigurationLocked
      CreateRejected
      WrongThread
      Destroyed
      NativeFailure(Int, String)
    } derive(Eq, 
    Debug    )

    Failures reported before or during native WebView creation, after disposal, or when a command is issued outside the owner UI thread.

    WebViewEvent

    source
    pub(all) enum WebViewEvent {
      Ready
      CreationFailed(WebViewError)
      ProcessFailed(WebViewError)
      PageMessage(String)
      NavigationStarting(String)
      SourceChanged(String)
      NavigationCompleted(String)
      NavigationFailed(String, WebViewError)
      TitleChanged(String)
      HistoryChanged(Bool, Bool)
      ScriptResult(String, String)
      ScriptFailed(String, WebViewError)
      ProtocolRequest(ProtocolRequest)
      ProtocolCancelled(String)
    } derive(Eq, 
    Debug    )

    Events emitted on the native UI thread that owns the parent container.

    ScriptResult and ScriptFailed preserve the request identifier supplied to WebView::eval. ScriptResult is JSON text; an undefined JavaScript result is represented as null. Page messages are UTF-8 strings without an imposed protocol.

    WebViewLifecycle

    source
    pub(all) enum WebViewLifecycle {
      Creating
      Ready
      Failed(WebViewError)
      Destroyed
    } derive(Eq, 
    Debug    )

    State reported by an asynchronously-created native WebView.

    WebViewOptions

    source
    pub(all) struct WebViewOptions {
      context : WebContext
      bounds : Rect
      resource_limits : WebViewResourceLimits
      initial_url : String
      initial_html : String
      initialization_script : String
      user_agent : String
      visible : Bool
      on_event : (WebViewEvent) -> Unit
      on_navigation : (String) -> NavigationDecision
      on_new_window : (String) -> NewWindowDecision
      on_media_permission : (MediaPermissionRequest) -> MediaPermissionDecision
    }

    Configuration passed while the native WebView is being created.

    If both initial content fields are non-empty, initial_html takes precedence. Treat the WebView as usable only after its Ready event.

    WebViewOptions::new

    source
    fn WebViewOptions::new(bounds~ : Rect, context? : WebContext, resource_limits? : WebViewResourceLimits, initial_url? : String, initial_html? : String, initialization_script? : String, user_agent? : String, visible? : Bool, on_event? : (WebViewEvent) -> Unit, on_navigation? : (String) -> NavigationDecision, on_new_window? : (String) -> NewWindowDecision, on_media_permission? : (MediaPermissionRequest) -> MediaPermissionDecision) -> WebViewOptions

    WebViewResourceLimits

    source
    pub(all) struct WebViewResourceLimits {
      max_pending_commands : Int
      max_pending_command_bytes : Int
      max_protocol_request_body_bytes : Int
    } derive(Eq, 
    Debug    )

    Per-WebView resource limits for desktop native backends. The pending-command limits are enforced by Windows; the protocol request body limit is enforced by Windows, macOS, and Linux.

    A value of 0 disables the corresponding limit. Negative values are rejected by WebView::create.

    WebViewResourceLimits::new

    source
    fn WebViewResourceLimits::new(max_pending_commands? : Int, max_pending_command_bytes? : Int, max_protocol_request_body_bytes? : Int) -> WebViewResourceLimits

    available

    source
    fn available() -> Bool

    Returns whether the native backend is available on the current host.

    register_custom_scheme

    source
    fn register_custom_scheme(name : String) -> Result[Unit, WebViewError]

    Registers an application-owned custom URL scheme for the process.

    Call this before the first successful WebView::create. Native handlers have a 30-second response deadline; unanswered requests are cancelled by the backend and reported as ProtocolCancelled.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io