///|
/// Describes an extension that can be built separately for each app window.
struct InstalledExtension {
id : String
js_namespace : String
build : () -> Result[@core.Extension, String]
}
///|
/// Builds an installed-extension descriptor from one already-created extension.
fn InstalledExtension::from_extension(
extension : @core.Extension,
) -> InstalledExtension {
let id = extension.id()
let js_namespace = extension.js_namespace()
let mut consumed = false
InstalledExtension::{
id,
js_namespace,
build: fn() {
guard !consumed else { return Err(prebuilt_extension_reuse_error(id)) }
consumed = true
Ok(extension)
},
}
}
///|
fn prebuilt_extension_reuse_error(id : String) -> String {
"prebuilt extension " +
id +
" can only be installed on one app window; use App::install_extension_spec for multi-window apps"
}
///|
/// Builds an installed-extension descriptor from one declarative extension spec.
fn InstalledExtension::from_spec(
spec : @core.ExtensionSpec,
context : @core.ExtensionBuildContext,
) -> InstalledExtension {
InstalledExtension::{
id: spec.id(),
js_namespace: spec.js_namespace(),
build: fn() { spec.build_extension(context) },
}
}
///|
/// Returns the stable extension id used for duplicate detection.
fn InstalledExtension::id(self : InstalledExtension) -> String {
self.id
}
///|
/// Returns the JavaScript namespace used for duplicate detection.
fn InstalledExtension::js_namespace(self : InstalledExtension) -> String {
self.js_namespace
}
///|
/// Builds and validates one runtime extension instance.
fn InstalledExtension::build_extension(
self : InstalledExtension,
) -> Result[@core.Extension, String] {
match (self.build)() {
Err(error) => Err(error)
Ok(extension) => {
guard extension.id() == self.id else {
return Err(
"extension spec id mismatch: declared " +
self.id +
" but built " +
extension.id(),
)
}
guard extension.js_namespace() == self.js_namespace else {
return Err(
"extension spec namespace mismatch: declared " +
self.js_namespace +
" but built " +
extension.js_namespace(),
)
}
Ok(extension)
}
}
}
///|
/// Installs an extension builder across every currently registered app window.
fn install_app_extension_on_app(
app : App,
installed_extension : InstalledExtension,
) -> Result[Unit, String] {
let extension_id = installed_extension.id()
let extension_namespace = installed_extension.js_namespace()
let extension_ids = app.installed_extension_ids()
let extension_namespaces = app.installed_extension_namespaces()
guard extension_ids.get(extension_id) is None else {
return Err(
"App::install_extension: extension already installed: " + extension_id,
)
}
guard extension_namespaces.get(extension_namespace) is None else {
return Err(
"App::install_extension: extension namespace already installed: " +
extension_namespace,
)
}
guard !ipc_extension_namespace_is_installed(
app.installed_ipc_backends(),
extension_namespace,
) else {
return Err(
"App::install_extension: extension namespace already installed by IPC bridge: " +
extension_namespace,
)
}
let built_extensions : Array[(AppWindow, @core.Extension)] = []
for window in app.windows() {
match installed_extension.build_extension() {
Ok(extension) => built_extensions.push((window, extension))
Err(error) => return Err(error)
}
}
extension_ids.set(extension_id, true)
extension_namespaces.set(extension_namespace, true)
app.installed_extensions().push(installed_extension)
for item in built_extensions {
let (window, extension) = item
@core.install_extension(window.webview, extension)
}
Ok(())
}
///|
/// Broadcasts an extension event to every window owned by the app.
fn[Payload : ToJson] emit_app_extension(
app : App,
extension_namespace : String,
event_name : String,
payload : Payload,
) -> Unit {
for window in app.windows() {
@core.emit_extension(
window.webview,
extension_namespace,
event_name,
payload,
)
}
}
///|
/// Registers a newly created window and wires its destroy hook back into the app.
fn App::register_window(self : App, window : AppWindow) -> Unit {
self.windows.push(window)
window.webview.register_destroy_hook(
app_window_destroy_hook_name(window.id),
fn() { self.remove_window(window.id) },
)
}
///|
/// Removes a window from the app runtime after it has been destroyed.
fn App::remove_window(self : App, window_id : String) -> Unit {
self.windows = exclude_window(self.windows, window_id)
}
///|
/// Returns every window except the one identified by `window_id`.
fn exclude_window(
windows : Array[AppWindow],
window_id : String,
) -> Array[AppWindow] {
let remaining : Array[AppWindow] = []
for window in windows {
if window.id != window_id {
remaining.push(window)
}
}
remaining
}
///|
/// Returns the mutable array of extensions already installed on the app.
fn App::installed_extensions(self : App) -> Array[InstalledExtension] {
self.installed_extensions
}
///|
/// Returns the installed extension id set used for duplicate detection.
fn App::installed_extension_ids(self : App) -> Map[String, Bool] {
self.installed_extension_ids
}
///|
/// Returns the installed extension namespace set used for duplicate detection.
fn App::installed_extension_namespaces(self : App) -> Map[String, Bool] {
self.installed_extension_namespaces
}