@reset-framework/sdk 0.2.0 → 1.0.1

package/src/client.js

@@ -1,53 +1,656 @@
-import { ResetRuntimeUnavailableError } from "./errors.js"
+import {
+  createResetTransport,
+  getResetRuntime,
+  invoke,
+  invokeRaw,
+  isResetRuntimeAvailable
+} from "./transport.js"
+import { createEventApi } from "./events.js"
+import { ResetProtocolError } from "./errors.js"
 
-function getDefaultWindowTarget() {
-  if (typeof window === "undefined") {
-    return undefined
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function requireObject(value, command) {
+  if (!isObjectLike(value)) {
+    throw new ResetProtocolError(
+      `Reset runtime returned an invalid payload for '${command}'.`,
+      { command }
+    )
   }
 
-  return window
+  return value
 }
 
-export function isResetRuntimeAvailable(target = getDefaultWindowTarget()) {
-  return Boolean(
-    target &&
-      target.reset &&
-      typeof target.reset.invoke === "function"
-  )
-}
+function requireStringField(record, field, command) {
+  const value = record[field]
 
-export function getResetRuntime(target = getDefaultWindowTarget()) {
-  if (!isResetRuntimeAvailable(target)) {
-    throw new ResetRuntimeUnavailableError()
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new ResetProtocolError(
+      `Reset runtime returned an invalid '${field}' field for '${command}'.`,
+      { command }
+    )
   }
 
-  return target.reset
+  return value
 }
 
-export async function invokeRaw(command, payload = {}, target = getDefaultWindowTarget()) {
-  return getResetRuntime(target).invoke(command, payload)
+function requireBooleanField(record, field, command) {
+  const value = record[field]
+
+  if (typeof value !== "boolean") {
+    throw new ResetProtocolError(
+      `Reset runtime returned an invalid '${field}' field for '${command}'.`,
+      { command }
+    )
+  }
+
+  return value
 }
 
-export async function invoke(command, payload = {}, target = getDefaultWindowTarget()) {
-  const response = await invokeRaw(command, payload, target)
+function requireNumberField(record, field, command) {
+  const value = record[field]
 
-  if (!response.ok) {
-    throw new Error(response.error)
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new ResetProtocolError(
+      `Reset runtime returned an invalid '${field}' field for '${command}'.`,
+      { command }
+    )
   }
 
-  return response.result
+  return value
 }
 
-export function createResetClient(target = getDefaultWindowTarget()) {
-  return {
-    isAvailable() {
-      return isResetRuntimeAvailable(target)
-    },
+function normalizeAppInfo(payload, command) {
+  const record = requireObject(payload, command)
+
+  return Object.freeze({
+    id: requireStringField(record, "id", command),
+    name: requireStringField(record, "name", command),
+    slug: requireStringField(record, "slug", command),
+    version: requireStringField(record, "version", command),
+    windowTitle: requireStringField(record, "windowTitle", command)
+  })
+}
+
+function normalizeRuntimeInfo(payload, command) {
+  const record = requireObject(payload, command)
+
+  return Object.freeze({
+    platform: requireStringField(record, "platform", command),
+    arch: requireStringField(record, "arch", command),
+    frameworkVersion: requireStringField(record, "frameworkVersion", command),
+    bridgeVersion: requireStringField(record, "bridgeVersion", command),
+    debug: requireBooleanField(record, "debug", command)
+  })
+}
+
+function normalizeCapabilities(payload, command) {
+  const record = requireObject(payload, command)
+  const commands = Array.isArray(record.commands) ? record.commands : []
+  const permissions = Array.isArray(record.permissions) ? record.permissions : []
+
+  return Object.freeze({
+    commands: Object.freeze(commands.map((entry) => Object.freeze({ ...entry }))),
+    permissions: Object.freeze([...permissions])
+  })
+}
+
+function createCommandApi(transport) {
+  return Object.freeze({
     invoke(command, payload = {}) {
-      return invoke(command, payload, target)
+      return transport.invoke(command, payload)
     },
     invokeRaw(command, payload = {}) {
-      return invokeRaw(command, payload, target)
+      return transport.invokeRaw(command, payload)
     }
-  }
+  })
+}
+
+function createAppApi(transport) {
+  return Object.freeze({
+    async getId() {
+      const payload = requireObject(await transport.invoke("app.getId"), "app.getId")
+      return requireStringField(payload, "id", "app.getId")
+    },
+    async getName() {
+      const payload = requireObject(await transport.invoke("app.getName"), "app.getName")
+      return requireStringField(payload, "name", "app.getName")
+    },
+    async getSlug() {
+      const payload = requireObject(await transport.invoke("app.getSlug"), "app.getSlug")
+      return requireStringField(payload, "slug", "app.getSlug")
+    },
+    async getVersion() {
+      const payload = requireObject(await transport.invoke("app.getVersion"), "app.getVersion")
+      return requireStringField(payload, "version", "app.getVersion")
+    },
+    async getInfo() {
+      return normalizeAppInfo(await transport.invoke("app.getInfo"), "app.getInfo")
+    },
+    show() {
+      return transport.invoke("app.show")
+    },
+    hide() {
+      return transport.invoke("app.hide")
+    },
+    quit() {
+      return transport.invoke("app.quit")
+    },
+    relaunch() {
+      return transport.invoke("app.relaunch")
+    }
+  })
+}
+
+function createRuntimeApi(transport) {
+  return Object.freeze({
+    async getPlatform() {
+      const payload = requireObject(await transport.invoke("runtime.getPlatform"), "runtime.getPlatform")
+      return requireStringField(payload, "platform", "runtime.getPlatform")
+    },
+    async getArchitecture() {
+      const payload = requireObject(await transport.invoke("runtime.getArchitecture"), "runtime.getArchitecture")
+      return requireStringField(payload, "arch", "runtime.getArchitecture")
+    },
+    async getFrameworkVersion() {
+      const payload = requireObject(
+        await transport.invoke("runtime.getFrameworkVersion"),
+        "runtime.getFrameworkVersion"
+      )
+      return requireStringField(payload, "version", "runtime.getFrameworkVersion")
+    },
+    async getBridgeVersion() {
+      const payload = requireObject(
+        await transport.invoke("runtime.getBridgeVersion"),
+        "runtime.getBridgeVersion"
+      )
+      return requireStringField(payload, "version", "runtime.getBridgeVersion")
+    },
+    async getInfo() {
+      return normalizeRuntimeInfo(await transport.invoke("runtime.getInfo"), "runtime.getInfo")
+    },
+    async getCapabilities() {
+      return normalizeCapabilities(
+        await transport.invoke("runtime.getCapabilities"),
+        "runtime.getCapabilities"
+      )
+    }
+  })
+}
+
+function createWindowApi(transport) {
+  return Object.freeze({
+    getCurrent() {
+      return transport.invoke("window.getCurrent")
+    },
+    getInfo() {
+      return transport.invoke("window.getInfo")
+    },
+    list() {
+      return transport.invoke("window.list")
+    },
+    show() {
+      return transport.invoke("window.show")
+    },
+    hide() {
+      return transport.invoke("window.hide")
+    },
+    focus() {
+      return transport.invoke("window.focus")
+    },
+    close() {
+      return transport.invoke("window.close")
+    },
+    minimize() {
+      return transport.invoke("window.minimize")
+    },
+    maximize() {
+      return transport.invoke("window.maximize")
+    },
+    center() {
+      return transport.invoke("window.center")
+    },
+    setTitle(title) {
+      return transport.invoke("window.setTitle", { title })
+    },
+    setSize(width, height) {
+      return transport.invoke("window.setSize", { width, height })
+    },
+    setResizable(resizable) {
+      return transport.invoke("window.setResizable", { resizable })
+    }
+  })
+}
+
+function createDialogApi(transport) {
+  return Object.freeze({
+    openFile(options = {}) {
+      return transport.invoke("dialog.openFile", options)
+    },
+    saveFile(options = {}) {
+      return transport.invoke("dialog.saveFile", options)
+    },
+    message(title, message) {
+      return transport.invoke("dialog.message", { title, message })
+    },
+    confirm(title, message) {
+      return transport.invoke("dialog.confirm", { title, message })
+    }
+  })
+}
+
+function createFsApi(transport) {
+  return Object.freeze({
+    async readTextFile(path) {
+      const payload = requireObject(await transport.invoke("fs.readTextFile", { path }), "fs.readTextFile")
+      return requireStringField(payload, "text", "fs.readTextFile")
+    },
+    writeTextFile(path, text, options = {}) {
+      return transport.invoke("fs.writeTextFile", {
+        path,
+        text,
+        ...options
+      })
+    },
+    async exists(path) {
+      const payload = requireObject(await transport.invoke("fs.exists", { path }), "fs.exists")
+      return requireBooleanField(payload, "exists", "fs.exists")
+    },
+    mkdir(path, options = {}) {
+      return transport.invoke("fs.mkdir", {
+        path,
+        ...options
+      })
+    },
+    remove(path, options = {}) {
+      return transport.invoke("fs.remove", {
+        path,
+        ...options
+      })
+    },
+    rename(from, to) {
+      return transport.invoke("fs.rename", { from, to })
+    },
+    async readDir(path) {
+      const payload = requireObject(await transport.invoke("fs.readDir", { path }), "fs.readDir")
+      return Array.isArray(payload.entries) ? payload.entries : []
+    }
+  })
+}
+
+function createPathApi(transport) {
+  return Object.freeze({
+    async join(...segments) {
+      const payload = requireObject(await transport.invoke("path.join", { segments }), "path.join")
+      return requireStringField(payload, "path", "path.join")
+    },
+    async basename(path) {
+      const payload = requireObject(await transport.invoke("path.basename", { path }), "path.basename")
+      return requireStringField(payload, "name", "path.basename")
+    },
+    async dirname(path) {
+      const payload = requireObject(await transport.invoke("path.dirname", { path }), "path.dirname")
+      return requireStringField(payload, "path", "path.dirname")
+    },
+    async resolve(path, base) {
+      const payload = requireObject(await transport.invoke("path.resolve", { path, base }), "path.resolve")
+      return requireStringField(payload, "path", "path.resolve")
+    },
+    async getHomeDir() {
+      const payload = requireObject(await transport.invoke("path.getHomeDir"), "path.getHomeDir")
+      return requireStringField(payload, "path", "path.getHomeDir")
+    },
+    async getTempDir() {
+      const payload = requireObject(await transport.invoke("path.getTempDir"), "path.getTempDir")
+      return requireStringField(payload, "path", "path.getTempDir")
+    },
+    async getAppDataDir() {
+      const payload = requireObject(await transport.invoke("path.getAppDataDir"), "path.getAppDataDir")
+      return requireStringField(payload, "path", "path.getAppDataDir")
+    },
+    async getAppConfigDir() {
+      const payload = requireObject(await transport.invoke("path.getAppConfigDir"), "path.getAppConfigDir")
+      return requireStringField(payload, "path", "path.getAppConfigDir")
+    },
+    async getCacheDir() {
+      const payload = requireObject(await transport.invoke("path.getCacheDir"), "path.getCacheDir")
+      return requireStringField(payload, "path", "path.getCacheDir")
+    },
+    getInfo() {
+      return transport.invoke("path.getInfo")
+    }
+  })
+}
+
+function createShellApi(transport) {
+  return Object.freeze({
+    openExternal(url) {
+      return transport.invoke("shell.openExternal", { url })
+    },
+    openPath(path) {
+      return transport.invoke("shell.openPath", { path })
+    },
+    showItemInFolder(path) {
+      return transport.invoke("shell.showItemInFolder", { path })
+    }
+  })
 }
+
+function createClipboardApi(transport) {
+  return Object.freeze({
+    async readText() {
+      const payload = requireObject(await transport.invoke("clipboard.readText"), "clipboard.readText")
+      return requireStringField(payload, "text", "clipboard.readText")
+    },
+    writeText(text) {
+      return transport.invoke("clipboard.writeText", { text })
+    }
+  })
+}
+
+function createNotificationApi(transport) {
+  return Object.freeze({
+    async isSupported() {
+      const payload = requireObject(
+        await transport.invoke("notification.isSupported"),
+        "notification.isSupported"
+      )
+      return requireBooleanField(payload, "supported", "notification.isSupported")
+    },
+    requestPermission() {
+      return transport.invoke("notification.requestPermission")
+    },
+    show(options) {
+      return transport.invoke("notification.show", options)
+    }
+  })
+}
+
+function createScreenApi(transport) {
+  return Object.freeze({
+    getCursorPosition() {
+      return transport.invoke("screen.getCursorPosition")
+    },
+    getPrimaryDisplay() {
+      return transport.invoke("screen.getPrimaryDisplay")
+    },
+    async getDisplays() {
+      const payload = requireObject(await transport.invoke("screen.getDisplays"), "screen.getDisplays")
+      return Array.isArray(payload.displays) ? payload.displays : []
+    }
+  })
+}
+
+function createStorageApi(transport) {
+  return Object.freeze({
+    async get(key) {
+      const payload = requireObject(await transport.invoke("storage.get", { key }), "storage.get")
+      return payload.value
+    },
+    set(key, value) {
+      return transport.invoke("storage.set", { key, value })
+    },
+    remove(key) {
+      return transport.invoke("storage.remove", { key })
+    },
+    clear() {
+      return transport.invoke("storage.clear")
+    },
+    async getAll() {
+      const payload = requireObject(await transport.invoke("storage.getAll"), "storage.getAll")
+      return requireObject(payload.entries ?? {}, "storage.getAll")
+    }
+  })
+}
+
+function createWebViewApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("webview.getInfo")
+    },
+    reload() {
+      return transport.invoke("webview.reload")
+    },
+    goBack() {
+      return transport.invoke("webview.goBack")
+    },
+    goForward() {
+      return transport.invoke("webview.goForward")
+    },
+    navigate(options) {
+      return transport.invoke("webview.navigate", options)
+    },
+    setZoomFactor(factor) {
+      return transport.invoke("webview.setZoomFactor", { factor })
+    }
+  })
+}
+
+function createCryptoApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("crypto.getInfo")
+    },
+    randomBytes(size, options = {}) {
+      return transport.invoke("crypto.randomBytes", {
+        size,
+        encoding: options.encoding
+      })
+    },
+    async randomUuid() {
+      const payload = requireObject(await transport.invoke("crypto.randomUuid"), "crypto.randomUuid")
+      return requireStringField(payload, "uuid", "crypto.randomUuid")
+    }
+  })
+}
+
+function createProcessApi(transport) {
+  return Object.freeze({
+    async getPid() {
+      const payload = requireObject(await transport.invoke("process.getPid"), "process.getPid")
+      return requireNumberField(payload, "pid", "process.getPid")
+    },
+    async getCwd() {
+      const payload = requireObject(await transport.invoke("process.getCwd"), "process.getCwd")
+      return requireStringField(payload, "path", "process.getCwd")
+    },
+    getInfo() {
+      return transport.invoke("process.getInfo")
+    }
+  })
+}
+
+function createPowerApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("power.getInfo")
+    }
+  })
+}
+
+function createMenuApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("menu.getInfo")
+    },
+    setApplicationMenu(items) {
+      return transport.invoke("menu.setApplicationMenu", { items })
+    },
+    clearApplicationMenu() {
+      return transport.invoke("menu.clearApplicationMenu")
+    }
+  })
+}
+
+function createTrayApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("tray.getInfo")
+    },
+    create(options = {}) {
+      return transport.invoke("tray.create", options)
+    },
+    setTitle(title) {
+      return transport.invoke("tray.setTitle", { title })
+    },
+    setTooltip(tooltip) {
+      return transport.invoke("tray.setTooltip", { tooltip })
+    },
+    setMenu(items) {
+      return transport.invoke("tray.setMenu", { items })
+    },
+    destroy() {
+      return transport.invoke("tray.destroy")
+    }
+  })
+}
+
+function createShortcutApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("shortcut.getInfo")
+    },
+    register(accelerator) {
+      return transport.invoke("shortcut.register", { accelerator })
+    },
+    unregister(accelerator) {
+      return transport.invoke("shortcut.unregister", { accelerator })
+    },
+    unregisterAll() {
+      return transport.invoke("shortcut.unregisterAll")
+    }
+  })
+}
+
+function createProtocolApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("protocol.getInfo")
+    },
+    register(options = {}) {
+      return transport.invoke("protocol.register", options)
+    },
+    unregister(options = {}) {
+      return transport.invoke("protocol.unregister", options)
+    }
+  })
+}
+
+function createUpdaterApi(transport) {
+  return Object.freeze({
+    getInfo() {
+      return transport.invoke("updater.getInfo")
+    },
+    check(options = {}) {
+      return transport.invoke("updater.check", options)
+    },
+    download(options = {}) {
+      return transport.invoke("updater.download", options)
+    },
+    install(options = {}) {
+      return transport.invoke("updater.install", options)
+    }
+  })
+}
+
+function createNetApi(transport) {
+  return Object.freeze({
+    request(options) {
+      return transport.invoke("net.request", options)
+    }
+  })
+}
+
+export function createResetClient(source) {
+  const transport = createResetTransport(source)
+  const commands = createCommandApi(transport)
+  const app = createAppApi(transport)
+  const runtime = createRuntimeApi(transport)
+  const events = createEventApi(transport)
+  const window = createWindowApi(transport)
+  const dialog = createDialogApi(transport)
+  const fs = createFsApi(transport)
+  const path = createPathApi(transport)
+  const shell = createShellApi(transport)
+  const clipboard = createClipboardApi(transport)
+  const notification = createNotificationApi(transport)
+  const screen = createScreenApi(transport)
+  const storage = createStorageApi(transport)
+  const webview = createWebViewApi(transport)
+  const crypto = createCryptoApi(transport)
+  const process = createProcessApi(transport)
+  const power = createPowerApi(transport)
+  const menu = createMenuApi(transport)
+  const tray = createTrayApi(transport)
+  const shortcut = createShortcutApi(transport)
+  const protocol = createProtocolApi(transport)
+  const updater = createUpdaterApi(transport)
+  const net = createNetApi(transport)
+
+  return Object.freeze({
+    isAvailable() {
+      return transport.isAvailable()
+    },
+    getRuntime() {
+      return transport.getRuntime()
+    },
+    commands,
+    app,
+    runtime,
+    events,
+    window,
+    dialog,
+    fs,
+    path,
+    shell,
+    clipboard,
+    notification,
+    screen,
+    storage,
+    webview,
+    crypto,
+    process,
+    power,
+    menu,
+    tray,
+    shortcut,
+    protocol,
+    updater,
+    net
+  })
+}
+
+export {
+  createResetTransport,
+  getResetRuntime,
+  invoke,
+  invokeRaw,
+  isResetRuntimeAvailable
+} from "./transport.js"
+
+export const reset = createResetClient()
+export const commands = reset.commands
+export const app = reset.app
+export const runtime = reset.runtime
+export const events = reset.events
+export const window = reset.window
+export const dialog = reset.dialog
+export const fs = reset.fs
+export const path = reset.path
+export const shell = reset.shell
+export const clipboard = reset.clipboard
+export const notification = reset.notification
+export const screen = reset.screen
+export const storage = reset.storage
+export const webview = reset.webview
+export const crypto = reset.crypto
+export const process = reset.process
+export const power = reset.power
+export const menu = reset.menu
+export const tray = reset.tray
+export const shortcut = reset.shortcut
+export const protocol = reset.protocol
+export const updater = reset.updater
+export const net = reset.net