Application

Provides Application level methods

Example usage:

import { createWindow } from 'socket:application'

createWindow(opts)

Creates a new window and returns an instance of ApplicationWindow.

getScreenSize()

Returns the current screen size.

getWindows(indices)

Returns the ApplicationWindow instances for the given indices or all windows if no indices are provided.

getWindow(index)

Returns the ApplicationWindow instance for the given index

getCurrentWindow()

Returns the ApplicationWindow instance for the current window.

exit(code)

Quits the backend process and then quits the render process, the exit code used is the final exit code to the OS.

setSystemMenu(options)

Set the native menu for the app.

Socket Runtime provides a minimalist DSL that makes it easy to create cross platform native system and context menus.

Menus are created at run time. They can be created from either the Main or Render process. The can be recreated instantly by calling the setSystemMenu method.

The method takes a string. Here's an example of a menu. The semi colon is significant indicates the end of the menu. Use an underscore when there is no accelerator key. Modifiers are optional. And well known OS menu options like the edit menu will automatically get accelerators you dont need to specify them.

socket.application.setSystemMenu({ index: 0, value: `
  App:
    Foo: f;

  Edit:
    Cut: x
    Copy: c
    Paste: v
    Delete: _
    Select All: a;

  Other:
    Apple: _
    Another Test: T
    !Im Disabled: I
    Some Thing: S + Meta
    ---
    Bazz: s + Meta, Control, Alt;
`)

Separators

To create a separator, use three dashes ---.

Accelerator Modifiers

Accelerator modifiers are used as visual indicators but don't have a material impact as the actual key binding is done in the event listener.

A capital letter implies that the accelerator is modified by the Shift key.

Additional accelerators are Meta, Control, Option, each separated by commas. If one is not applicable for a platform, it will just be ignored.

On MacOS Meta is the same as Command.

Disabled Items

If you want to disable a menu item just prefix the item with the ! character. This will cause the item to appear disabled when the system menu renders.

Submenus

We feel like nested menus are an anti-pattern. We don't use them. If you have a strong argument for them and a very simple pull request that makes them work we may consider them.

Event Handling

When a menu item is activated, it raises the menuItemSelected event in the front end code, you can then communicate with your backend code if you want from there.

For example, if the Apple item is selected from the Other menu...

window.addEventListener('menuItemSelected', event => {
  assert(event.detail.parent === 'Other')
  assert(event.detail.title === 'Apple')
})

setSystemMenuItemEnabled(value)

Set the enabled state of the system menu.

runtimeVersion

Socket Runtime version.

debug

Runtime debug flag.

config

Application configuration.

backend

The application's backend instance.

open(opts)

close()

Bluetooth

A high-level, cross-platform API for Bluetooth Pub-Sub

Example usage:

import { Bluetooth } from 'socket:bluetooth'

Bluetooth (extends EventEmitter)

Create an instance of a Bluetooth service.

constructor(serviceId)

constructor is an example property that is set to true Creates a new service with key-value pairs

start()

Start the Bluetooth service.

subscribe(id)

Start scanning for published values that correspond to a well-known UUID. Once subscribed to a UUID, events that correspond to that UUID will be emitted. To receive these events you can add an event listener, for example...

const ble = new Bluetooth(id)
ble.subscribe(uuid)
ble.on(uuid, (data, details) => {
  // ...do something interesting
})

publish(id, value)

Start advertising a new value for a well-known UUID

Buffer

Buffer module is a third party vendor module provided by Feross Aboukhadijeh and other contributors (MIT License).

External docs: https://nodejs.org/api/buffer.html

Crypto

Some high-level methods around the crypto.subtle API for getting random bytes and hashing.

Example usage:

import { randomBytes } from 'socket:crypto'

webcrypto

External docs: https://developer.mozilla.org/en-US/docs/Web/API/Crypto WebCrypto API

ready

A promise that resolves when all internals to be loaded/ready.

getRandomValues(buffer)

External docs: https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues Generate cryptographically strong random values into the buffer

rand64()

Generate a random 64-bit number.

RANDOM_BYTES_QUOTA

Maximum total size of random bytes per page

MAX_RANDOM_BYTES

Maximum total size for random bytes.

MAX_RANDOM_BYTES_PAGES

Maximum total amount of allocated per page of bytes (max/quota)

randomBytes(size)

Generate size random bytes.

createDigest(algorithm, message)

murmur3(value, seed)

A murmur3 hash implementation based on https://github.com/jwerle/murmurhash.c that works on strings and ArrayBuffer views (typed arrays)

DNS

This module enables name resolution. For example, use it to look up IP addresses of host names. Although named for the Domain Name System (DNS), it does not always use the DNS protocol for lookups. dns.lookup() uses the operating system facilities to perform name resolution. It may not need to perform any network communication. To perform name resolution the way other applications on the same system do, use dns.lookup().

Example usage:

import { lookup } from 'socket:dns'

lookup(hostname, options, cb)

External docs: https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback Resolves a host name (e.g. example.org) into the first found A (IPv4) or AAAA (IPv6) record. All option properties are optional. If options is an integer, then it must be 4 or 6 – if options is 0 or not provided, then IPv4 and IPv6 addresses are both returned if found.

From the node.js website...

With the all option set to true, the arguments for callback change to (err, addresses), with addresses being an array of objects with the properties address and family.

On error, err is an Error object, where err.code is the error code. Keep in mind that err.code will be set to 'ENOTFOUND' not only when the host name does not exist but also when the lookup fails in other ways such as no available file descriptors. dns.lookup() does not necessarily have anything to do with the DNS protocol. The implementation uses an operating system facility that can associate names with addresses and vice versa. This implementation can have subtle but important consequences on the behavior of any Node.js program. Please take some time to consult the Implementation considerations section before using dns.lookup().

DNS.promises

This module enables name resolution. For example, use it to look up IP addresses of host names. Although named for the Domain Name System (DNS), it does not always use the DNS protocol for lookups. dns.lookup() uses the operating system facilities to perform name resolution. It may not need to perform any network communication. To perform name resolution the way other applications on the same system do, use dns.lookup().

Example usage:

import { lookup } from 'socket:dns/promises'

lookup(hostname, opts)

External docs: https://nodejs.org/api/dns.html#dnspromiseslookuphostname-options

Dgram

This module provides an implementation of UDP datagram sockets. It does not (yet) provide any of the multicast methods or properties.

Example usage:

import { createSocket } from 'socket:dgram'

createSocket(options, callback)

Creates a Socket instance.

Socket (extends EventEmitter)

New instances of dgram.Socket are created using dgram.createSocket(). The new keyword is not to be used to create dgram.Socket instances.

bind(port, address, callback)

External docs: https://nodejs.org/api/dgram.html#socketbindport-address-callback Listen for datagram messages on a named port and optional address If the address is not specified, the operating system will attempt to listen on all addresses. Once the binding is complete, a 'listening' event is emitted and the optional callback function is called.

If binding fails, an 'error' event is emitted.

connect(port, host, connectListener)

External docs: https://nodejs.org/api/dgram.html#socketconnectport-address-callback Associates the dgram.Socket to a remote address and port. Every message sent by this handle is automatically sent to that destination. Also, the socket will only receive messages from that remote peer. Trying to call connect() on an already connected socket will result in an ERR_SOCKET_DGRAM_IS_CONNECTED exception. If the address is not provided, '0.0.0.0' (for udp4 sockets) or '::1' (for udp6 sockets) will be used by default. Once the connection is complete, a 'connect' event is emitted and the optional callback function is called. In case of failure, the callback is called or, failing this, an 'error' event is emitted.

disconnect()

External docs: https://nodejs.org/api/dgram.html#socketdisconnect A synchronous function that disassociates a connected dgram.Socket from its remote address. Trying to call disconnect() on an unbound or already disconnected socket will result in an ERR_SOCKET_DGRAM_NOT_CONNECTED exception.

send(msg, offset, length, port, address, callback)

External docs: https://nodejs.org/api/dgram.html#socketsendmsg-offset-length-port-address-callback Broadcasts a datagram on the socket. For connectionless sockets, the destination port and address must be specified. Connected sockets, on the other hand, will use their associated remote endpoint, so the port and address arguments must not be set.

The msg argument contains the message to be sent. Depending on its type, different behavior can apply. If msg is a Buffer, any TypedArray, or a DataView, the offset and length specify the offset within the Buffer where the message begins and the number of bytes in the message, respectively. If msg is a String, then it is automatically converted to a Buffer with 'utf8' encoding. With messages that contain multi-byte characters, offset, and length will be calculated with respect to byte length and not the character position. If msg is an array, offset and length must not be specified.

The address argument is a string. If the value of the address is a hostname, DNS will be used to resolve the address of the host. If the address is not provided or otherwise nullish, '0.0.0.0' (for udp4 sockets) or '::1' (for udp6 sockets) will be used by default.

If the socket has not been previously bound with a call to bind, the socket is assigned a random port number and is bound to the "all interfaces" address ('0.0.0.0' for udp4 sockets, '::1' for udp6 sockets.)

An optional callback function may be specified as a way of reporting DNS errors or for determining when it is safe to reuse the buf object. DNS lookups delay the time to send for at least one tick of the Node.js event loop.

The only way to know for sure that the datagram has been sent is by using a callback. If an error occurs and a callback is given, the error will be passed as the first argument to the callback. If a callback is not given, the error is emitted as an 'error' event on the socket object.

Offset and length are optional but both must be set if either is used. They are supported only when the first argument is a Buffer, a TypedArray, or a DataView.

close(callback)

External docs: https://nodejs.org/api/dgram.html#socketclosecallback Close the underlying socket and stop listening for data on it. If a callback is provided, it is added as a listener for the 'close' event.

address()

External docs: https://nodejs.org/api/dgram.html#socketaddress Returns an object containing the address information for a socket. For UDP sockets, this object will contain address, family, and port properties.

This method throws EBADF if called on an unbound socket.

remoteAddress()

External docs: https://nodejs.org/api/dgram.html#socketremoteaddress Returns an object containing the address, family, and port of the remote endpoint. This method throws an ERR_SOCKET_DGRAM_NOT_CONNECTED exception if the socket is not connected.

setRecvBufferSize(size)

External docs: https://nodejs.org/api/dgram.html#socketsetrecvbuffersizesize Sets the SO_RCVBUF socket option. Sets the maximum socket receive buffer in bytes.

setSendBufferSize(size)

External docs: https://nodejs.org/api/dgram.html#socketsetsendbuffersizesize Sets the SO_SNDBUF socket option. Sets the maximum socket send buffer in bytes.

getRecvBufferSize()

External docs: https://nodejs.org/api/dgram.html#socketgetrecvbuffersize

getSendBufferSize()

External docs: https://nodejs.org/api/dgram.html#socketgetsendbuffersize

code()

ERR_SOCKET_ALREADY_BOUND (extends SocketError)

Thrown when a socket is already bound.

ERR_SOCKET_DGRAM_IS_CONNECTED (extends SocketError)

Thrown when the socket is already connected.

ERR_SOCKET_DGRAM_NOT_CONNECTED (extends SocketError)

Thrown when the socket is not connected.

ERR_SOCKET_DGRAM_NOT_RUNNING (extends SocketError)

Thrown when the socket is not running (not bound or connected).

ERR_SOCKET_BAD_TYPE (extends TypeError)

Thrown when a bad socket type is used in an argument.

ERR_SOCKET_BAD_PORT (extends RangeError)

Thrown when a bad port is given.

Events

Events module is a third party module provided by Browserify and Node.js contributors (MIT License).

External docs: https://nodejs.org/api/events.html

FS

This module enables interacting with the file system in a way modeled on standard POSIX functions.

The Application Sandbox restricts access to the file system.

iOS Application Sandboxing has a set of rules that limits access to the file system. Apps can only access files in their own sandboxed home directory.

Example usage:

import * as fs from 'socket:fs';

access(path, mode, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsopenpath-flags-mode-callback Asynchronously check access a file for a given mode calling callback upon success or error.

chmod(path, mode, callback)

External docs: https://nodejs.org/api/fs.html#fschmodpath-mode-callback Asynchronously changes the permissions of a file. No arguments other than a possible exception are given to the completion callback

chown(path, uid, gid, callback)

Changes ownership of file or directory at path with uid and gid.

close(fd, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsclosefd-callback Asynchronously close a file descriptor calling callback upon success or error.

copyFile(src, dest, flags, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fscopyfilesrc-dest-mode-callback Asynchronously copies src to dest calling callback upon success or error.

createReadStream(path, options)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fscreatewritestreampath-options

createWriteStream(path, options)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fscreatewritestreampath-options

fstat(fd, options, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsfstatfd-options-callback Invokes the callback with the <fs.Stats> for the file descriptor. See the POSIX fstat(2) documentation for more detail.

fsync(fd, callback)

Request that all data for the open file descriptor is flushed to the storage device.

ftruncate(fd, offset, callback)

Truncates the file up to offset bytes.

lchown(path, uid, gid, callback)

Chages ownership of link at path with uid and `gid.

link(src, dest, )

Creates a link to dest from src.

open(path, flags, mode, options, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsopenpath-flags-mode-callback Asynchronously open a file calling callback upon success or error.

opendir(path, options, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsreaddirpath-options-callback Asynchronously open a directory calling callback upon success or error.

read(fd, buffer, offset, length, position, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsreadfd-buffer-offset-length-position-callback Asynchronously read from an open file descriptor.

readdir(path, options, callback)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fsreaddirpath-options-callback Asynchronously read all entries in a directory.

readFile(path, options, callback)

readlink(path, callback)

Reads link at path

realpath(path, callback)

Computes real path for path

rename(src, dest, callback)

Renames file or directory at src to dest.

rmdir(path, callback)

Removes directory at path.

stat(path, options, callback)

symlink(src, dest)

Creates a symlink of src at dest.

unlink(path, callback)

Unlinks (removes) file at path.

writeFile(path, data, options, callback)

watch(, options, callback)

Watch for changes at path calling callback

FS.promises

• This module enables interacting with the file system in a way modeled on standard POSIX functions.

The Application Sandbox restricts access to the file system.

iOS Application Sandboxing has a set of rules that limits access to the file system. Apps can only access files in their own sandboxed home directory.

Example usage:

import fs from 'socket:fs/promises'

access(path, mode, options)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fspromisesaccesspath-mode Asynchronously check access a file.

chmod(path, mode)

External docs: https://nodejs.org/api/fs.html#fspromiseschmodpath-mode

chown(path, uid, gid)

Changes ownership of file or directory at path with uid and gid.

copyFile(src, dest, flags)

Asynchronously copies src to dest calling callback upon success or error.

lchown(path, uid, gid)

Chages ownership of link at path with uid and `gid.

link(src, dest)

Creates a link to dest from dest.

mkdir(path, options)

Asynchronously creates a directory.

open(path, flags, mode)

External docs: https://nodejs.org/api/fs.html#fspromisesopenpath-flags-mode Asynchronously open a file.

opendir(path, options)

External docs: https://nodejs.org/api/fs.html#fspromisesopendirpath-options

readdir(path, options)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fspromisesreaddirpath-options

readFile(path, options)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fspromisesreadfilepath-options

readlink(path)

Reads link at path

realpath(path)

Computes real path for path

rename(src, dest)

Renames file or directory at src to dest.

rmdir(path)

Removes directory at path.

stat(path, options)

External docs: https://nodejs.org/api/fs.html#fspromisesstatpath-options

symlink(src, dest)

Creates a symlink of src at dest.

unlink(path)

Unlinks (removes) file at path.

writeFile(path, data, options)

External docs: https://nodejs.org/dist/latest-v20.x/docs/api/fs.html#fspromiseswritefilefile-data-options

watch(, options)

Watch for changes at path calling callback

IPC

This is a low-level API that you don't need unless you are implementing a library on top of Socket SDK. A Socket SDK app has two or three processes.

When you need to send a message to another window or to the backend, you should use the application module to get a reference to the window and use the send method to send a message.

• The Render process, is the UI where the HTML, CSS, and JS are run.
• The Bridge process, is the thin layer of code that manages everything.
• The Main process, is for apps that need to run heavier compute jobs. And unlike electron it's optional.

The Bridge process manages the Render and Main process, it may also broker data between them.

The Binding process uses standard input and output as a way to communicate. Data written to the write-end of the pipe is buffered by the OS until it is read from the read-end of the pipe.

The IPC protocol uses a simple URI-like scheme. Data is passed as ArrayBuffers.

ipc://command?key1=value1&key2=value2...

Example usage:

import { send } from 'socket:ipc'

emit(name, value, target, options)

Emit event to be dispatched on window object.

send(command, value, options)

Sends an async IPC command request with parameters.

Network

External docs: https://socketsupply.co/guides/#p2p-guide

Provides a higher level API over the stream-relay protocol.

OS

This module provides normalized system information from all the major operating systems.

Example usage:

import { arch, platform } from 'socket:os'

arch()

Returns the operating system CPU architecture for which Socket was compiled.

cpus()

External docs: https://nodejs.org/api/os.html#os_os_cpus Returns an array of objects containing information about each CPU/core. The properties of the objects are:

• model <string> - CPU model name.
• speed <number> - CPU clock speed (in MHz).
• times <object> - An object containing the fields user, nice, sys, idle, irq representing the number of milliseconds the CPU has spent in each mode.
  • user <number> - Time spent by this CPU or core in user mode.
  • nice <number> - Time spent by this CPU or core in user mode with low priority (nice).
  • sys <number> - Time spent by this CPU or core in system mode.
  • idle <number> - Time spent by this CPU or core in idle mode.
  • irq <number> - Time spent by this CPU or core in IRQ mode.

networkInterfaces()

External docs: https://nodejs.org/api/os.html#os_os_networkinterfaces Returns an object containing network interfaces that have been assigned a network address. Each key on the returned object identifies a network interface. The associated value is an array of objects that each describe an assigned network address. The properties available on the assigned network address object include:

• address <string> - The assigned IPv4 or IPv6 address.
• netmask <string> - The IPv4 or IPv6 network mask.
• family <string> - The address family ('IPv4' or 'IPv6').
• mac <string> - The MAC address of the network interface.
• internal <boolean> - Indicates whether the network interface is a loopback interface.
• scopeid <number> - The numeric scope ID (only specified when family is 'IPv6').
• cidr <string> - The CIDR notation of the interface.

platform()

External docs: https://nodejs.org/api/os.html#os_os_platform Returns the operating system platform. The returned value is equivalent to process.platform.

type()

External docs: https://nodejs.org/api/os.html#os_os_type Returns the operating system name.

isWindows()

tmpdir()

EOL

The operating system's end-of-line marker. '\r\n' on Windows and '\n' on POSIX.

rusage()

Get resource usage.

uptime()

Returns the system uptime in seconds.

uname()

Returns the operating system name.

Path

Example usage:

import { Path } from 'socket:path'

resolve()

External docs: https://nodejs.org/api/path.html#path_path_resolve_paths The path.resolve() method resolves a sequence of paths or path segments into an absolute path.

cwd(opts)

Computes current working directory for a path

origin()

Computed location origin. Defaults to socket:/// if not available.

relative(options, from, to)

Computes the relative path from from to to.

join(options, components)

Joins path components. This function may not return an absolute path.

dirname(options, components)

Computes directory name of path.

basename(options, components)

Computes base name of path.

extname(options, path)

Computes extension name of path.

normalize(options, path)

Computes normalized path

format(options, path)

Formats Path object into a string.

parse(path)

Parses input path into a Path instance.

Path

A container for a parsed Path.

from(input, cwd)

Creates a Path instance from input and optional cwd.

constructor(pathname, cwd)

Path class constructor.

isRelative()

true if the path is relative, otherwise `false.

value()

The working value of this path.

source()

The original source, unresolved.

parent()

Computed parent path.

root()

Computed root in path.

dir()

Computed directory name in path.

base()

Computed base name in path.

name()

Computed base name in path without path extension.

ext()

Computed extension name in path.

drive()

The computed drive, if given in the path.

toURL()

toString()

Converts this Path instance to a string.

Process

Example usage:

import process from 'socket:process'

nextTick(callback)

Adds callback to the 'nextTick' queue.

homedir()

hrtime(time)

Computed high resolution time as a BigInt.

exit(code)

memoryUsage()

Returns an object describing the memory usage of the Node.js process measured in bytes.

Test

Provides a test runner for Socket Runtime.

Example usage:

import { test } from 'socket:test'

test('test name', async t => {
  t.equal(1, 1)
})

getDefaultTestRunnerTimeout()

Test

constructor(name, fn, runner)

comment(msg)

plan(n)

Plan the number of assertions.

deepEqual(actual, expected, msg)

notDeepEqual(actual, expected, msg)

equal(actual, expected, msg)

notEqual(actual, expected, msg)

fail(msg)

ok(actual, msg)

pass(msg)

ifError(err, msg)

throws(fn, expected, message)

sleep(ms, msg)

Sleep for ms with an optional msg

await t.sleep(100)

requestAnimationFrame(msg)

Request animation frame with an optional msg. Falls back to a 0ms setTimeout when tests are run headlessly.

await t.requestAnimationFrame()

click(selector, msg)

Dispatch the `click`` method on an element specified by selector.

await t.click('.class button', 'Click a button')

eventClick(selector, msg)

Dispatch the click window.MouseEvent on an element specified by selector.

await t.eventClick('.class button', 'Click a button with an event')

dispatchEvent(event, target, msg)

Dispatch an event on the target.

await t.dispatchEvent('my-event', '#my-div', 'Fire the my-event event')

focus(selector, msg)

Call the focus method on element specified by selector.

await t.focus('#my-div')

blur(selector, msg)

Call the blur method on element specified by selector.

await t.blur('#my-div')

type(selector, str, msg)

Consecutively set the str value of the element specified by selector to simulate typing.

await t.typeValue('#my-div', 'Hello World', 'Type "Hello World" into #my-div')

appendChild(parentSelector, el, msg)

appendChild an element el to a parent selector element.

const myElement = createElement('div')
await t.appendChild('#parent-selector', myElement, 'Append myElement into #parent-selector')

removeElement(selector, msg)

Remove an element from the DOM.

await t.removeElement('#dom-selector', 'Remove #dom-selector')

elementVisible(selector, msg)

Test if an element is visible

await t.elementVisible('#dom-selector','Element is visible')

elementInvisible(selector, msg)

Test if an element is invisible

await t.elementInvisible('#dom-selector','Element is invisible')

waitFor(querySelectorOrFn, opts, msg)

Test if an element is invisible

await t.waitFor('#dom-selector', { visible: true },'#dom-selector is on the page and visible')

waitForText(selector, opts, msg)

Test if an element is invisible

await t.waitForText('#dom-selector', 'Text to wait for')

await t.waitForText('#dom-selector', /hello/i)

await t.waitForText('#dom-selector', {
  text: 'Text to wait for',
  multipleTags: true
})

querySelector(selector, msg)

Run a querySelector as an assert and also get the results

const element = await t.querySelector('#dom-selector')

querySelectorAll(selector, msg)

Run a querySelectorAll as an assert and also get the results

const elements = await t.querySelectorAll('#dom-selector', '')

getComputedStyle(selector, msg)

Retrieves the computed styles for a given element.

// Using CSS selector
const style = getComputedStyle('.my-element', 'Custom success message');

// Using Element object
const el = document.querySelector('.my-element');
const style = getComputedStyle(el);

run()

pass: number, fail: number }>}

TestRunner

constructor(report)

nextId()

add(name, fn, only)

run()

onFinish())

only(name, fn)

skip(_name, _fn)

setStrict(strict)

Window

Provides ApplicationWindow class and methods

Don't use this module directly, get instances of ApplicationWindow with socket:application methods like getCurrentWindow, createWindow, getWindow, and getWindows.

ApplicationWindow

Represents a window in the application

index()

Get the index of the window

getSize()

Get the size of the window

getTitle()

Get the title of the window

getStatus()

Get the status of the window

close()

Close the window

show()

Shows the window

hide()

Hides the window

setTitle(title)

Sets the title of the window

setSize(opts)

Sets the size of the window

navigate(path)

Navigate the window to a given path

showInspector()

Opens the Web Inspector for the window

setBackgroundColor(opts)

Sets the background color of the window

setContextMenu(options)

Opens a native context menu.

showOpenFilePicker(options)

Shows a native open file dialog.

showSaveFilePicker(options)

Shows a native save file dialog.

showDirectoryFilePicker(options)

Shows a native directory dialog.

send(options)

This is a high-level API that you should use instead of ipc.send when you want to send a message to another window or to the backend.

openExternal(options)

Opens an URL in the default browser.

addListener(event, cb)

Adds a listener to the window.

on(event, cb)

Adds a listener to the window. An alias for addListener.

once(event, cb)

Adds a listener to the window. The listener is removed after the first call.

removeListener(event, cb)

Removes a listener from the window.

removeAllListeners(event)

Removes all listeners from the window.

off(event, cb)

Removes a listener from the window. An alias for removeListener.