pear-electron 1.5.2 → 1.7.0

package/README.md

@@ -814,6 +814,13 @@ Use `<script type="module" src="path/to/my-file.js">` to load a JavaScript Modul
 
 Use `<script src="path/to/my-file.js">` to load a JavaScript Script.
 
+
+## API Extension
+
+### `pear-electron/api`
+
+Function that takes an API class and extends it with pear-electron APIs
+
 ## Graphical User Interface Options
 
 GUI options for an application are set in the application `package.json` `pear.gui` field.

package/api.js

@@ -0,0 +1,359 @@
+/* globals Pear */
+'use strict'
+const streamx = require('streamx')
+const { EventEmitter } = require('events')
+
+module.exports = (api) => {
+  class API extends api {
+    static UI = Symbol('ui')
+    #ipc = null
+    #pipe = null
+
+    constructor (ipc, state, teardown, id) {
+      super(ipc, state, { teardown })
+      this.#ipc = ipc
+      const kGuiCtrl = Symbol('gui:ctrl')
+      const media = {
+        status: {
+          microphone: () => ipc.getMediaAccessStatus({ id, media: 'microphone' }),
+          camera: () => ipc.getMediaAccessStatus({ id, media: 'camera' }),
+          screen: () => ipc.getMediaAccessStatus({ id, media: 'screen' })
+        },
+        access: {
+          microphone: () => ipc.askForMediaAccess({ id, media: 'microphone' }),
+          camera: () => ipc.askForMediaAccess({ id, media: 'camera' }),
+          screen: () => ipc.askForMediaAccess({ id, media: 'screen' })
+        },
+        desktopSources: (options = {}) => ipc.desktopSources(options)
+      }
+
+      class Found extends streamx.Readable {
+        #id = null
+        #stream = null
+        #listener = (data) => {
+          this.push(data.result)
+        }
+
+        constructor (id) {
+          super()
+          this.#id = id
+          this.#stream = ipc.found(this.#id)
+          this.#stream.on('data', this.#listener)
+        }
+
+        proceed () {
+          return ipc.find({ id: this.#id, next: true })
+        }
+
+        clear () {
+          if (this.destroyed) throw Error('Nothing to clear, already destroyed')
+          return ipc.find({ id: this.#id, stop: 'clear' }).finally(() => this.destroy())
+        }
+
+        keep () {
+          if (this.destroyed) throw Error('Nothing to keep, already destroyed')
+          return ipc.find({ id: this.#id, stop: 'keep' }).finally(() => this.destroy())
+        }
+
+        activate () {
+          if (this.destroyed) throw Error('Nothing to activate, already destroyed')
+          return ipc.find({ id: this.#id, stop: 'activate' }).finally(() => this.destroy())
+        }
+
+        _destroy () {
+          this.#stream.destroy()
+          return this.clear()
+        }
+      }
+
+      class Parent extends EventEmitter {
+        constructor (id) {
+          super()
+          this.id = id
+          ipc.receiveFrom(id, (...args) => {
+            this.emit('message', ...args)
+          })
+        }
+
+        async find (options) {
+          const found = new Found(this.id)
+          await ipc.find({ id: this.id, options })
+          return found
+        }
+
+        send (...args) { return ipc.sendTo(this.id, ...args) }
+        focus (options = null) { return ipc.parent({ act: 'focus', id: this.id, options }) }
+        blur () { return ipc.parent({ act: 'blur', id: this.id }) }
+        show () { return ipc.parent({ act: 'show', id: this.id }) }
+        hide () { return ipc.parent({ act: 'hide', id: this.id }) }
+        minimize () { return ipc.parent({ act: 'minimize', id: this.id }) }
+        maximize () { return ipc.parent({ act: 'maximize', id: this.id }) }
+        fullscreen () { return ipc.parent({ act: 'fullscreen', id: this.id }) }
+        restore () { return ipc.parent({ act: 'restore', id: this.id }) }
+        dimensions (options = null) { return ipc.parent({ act: 'dimensions', id: this.id, options }) }
+        isVisible () { return ipc.parent({ act: 'isVisible', id: this.id }) }
+        isMinimized () { return ipc.parent({ act: 'isMinimized', id: this.id }) }
+        isMaximized () { return ipc.parent({ act: 'isMaximized', id: this.id }) }
+        isFullscreen () { return ipc.parent({ act: 'isFullscreen', id: this.id }) }
+        isClosed () { return ipc.parent({ act: 'isClosed', id: this.id }) }
+      }
+
+      class App {
+        id = null
+        #untray = null
+
+        get parent () {
+          const parentId = ipc.getParentId()
+          Object.defineProperty(this, 'parent', { value: new Parent(parentId) })
+          return this.parent
+        }
+
+        constructor (id) {
+          this.id = id
+          this.tray.scaleFactor = state.tray?.scaleFactor
+          this.tray.darkMode = state.tray?.darkMode
+
+          ipc.systemTheme().on('data', ({ mode }) => {
+            this.tray.darkMode = mode === 'dark'
+          })
+        }
+
+        find = (options) => {
+          const found = new Found(this.id)
+          ipc.find({ id: this.id, options })
+          return found
+        }
+
+        badge = (count) => {
+          if (!Number.isInteger(+count)) throw new Error('argument must be an integer')
+          return ipc.badge({ id: this.id, count })
+        }
+
+        tray = async (opts = {}, listener) => {
+          opts = {
+            ...opts,
+            menu: opts.menu ?? {
+              show: `Show ${state.name}`,
+              quit: 'Quit'
+            }
+          }
+          listener = listener ?? ((key) => {
+            if (key === 'click' || key === 'show') {
+              this.show()
+              this.focus({ steal: true })
+              return
+            }
+            if (key === 'quit') {
+              this.quit()
+            }
+          })
+
+          const untray = async () => {
+            if (this.#untray) {
+              await this.#untray()
+              this.#untray = null
+            }
+          }
+
+          await untray()
+          this.#untray = ipc.tray(opts, listener)
+          return untray
+        }
+
+        focus = (options = null) => { return ipc.focus({ id: this.id, options }) }
+        blur = () => { return ipc.blur({ id: this.id }) }
+        show = () => { return ipc.show({ id: this.id }) }
+        hide = () => { return ipc.hide({ id: this.id }) }
+        minimize = () => { return ipc.minimize({ id: this.id }) }
+        maximize = () => { return ipc.maximize({ id: this.id }) }
+        fullscreen = () => { return ipc.fullscreen({ id: this.id }) }
+        restore = () => { return ipc.restore({ id: this.id }) }
+        close = () => { return ipc.close({ id: this.id }) }
+        quit = () => { return ipc.quit({ id: this.id }) }
+        dimensions (options = null) { return ipc.dimensions({ id: this.id, options }) }
+        isVisible = () => { return ipc.isVisible({ id: this.id }) }
+        isMinimized = () => { return ipc.isMinimized({ id: this.id }) }
+        isMaximized = () => { return ipc.isMaximized({ id: this.id }) }
+        isFullscreen = () => { return ipc.isFullscreen({ id: this.id }) }
+        report = (rpt) => { return ipc.report(rpt) }
+      }
+
+      class GuiCtrl extends EventEmitter {
+        #listener = null
+        #unlisten = null
+
+        static get parent () {
+          console.warn('Pear.Window.parent & Pear.View.parent are deprecated use ui.app.parent')
+          return Pear[Pear.constructor.UI].app.parent
+        }
+
+        static get self () {
+          console.warn('Pear.Window.self & Pear.View.self are deprecated use ui.app')
+          return Pear[Pear.constructor.UI].app
+        }
+
+        constructor (entry, at, options = at) {
+          super()
+          if (options === at) {
+            if (typeof at === 'string') options = { at }
+          }
+          if (!entry) throw new Error(`No path provided, cannot open ${this.constructor[kGuiCtrl]}`)
+          this.entry = entry
+          this.options = options
+          this.id = null
+        }
+
+        #rxtx () {
+          this.#listener = (e, ...args) => this.emit('message', ...args)
+          this.#unlisten = ipc.receiveFrom(this.#listener)
+        }
+
+        #unrxtx () {
+          if (this.#unlisten === null) return
+          this.#unlisten()
+          this.#unlisten = null
+          this.#listener = null
+        }
+
+        find = async (options) => {
+          const found = new Found(this.id)
+          await ipc.find({ id: this.id, options })
+          return found
+        }
+
+        send (...args) { return ipc.sendTo(this.id, ...args) }
+
+        async open (opts) {
+          if (this.id === null) {
+            await new Promise(setImmediate) // needed for windows/views opening on app load
+            this.#rxtx()
+            this.id = await ipc.ctrl({
+              parentId: Pear[Pear.constructor.UI].app.id,
+              type: this.constructor[kGuiCtrl],
+              entry: this.entry,
+              options: this.options,
+              state,
+              openOptions: opts
+            })
+            return true
+          }
+          return await ipc.open({ id: this.id })
+        }
+
+        async close () {
+          const result = await ipc.close({ id: this.id })
+          this.#unrxtx()
+          this.id = null
+          return result
+        }
+
+        show () { return ipc.show({ id: this.id }) }
+        hide () { return ipc.hide({ id: this.id }) }
+        focus (options = null) { return ipc.focus({ id: this.id, options }) }
+        blur () { return ipc.blur({ id: this.id }) }
+
+        dimensions (options = null) { return ipc.dimensions({ id: this.id, options }) }
+        minimize () {
+          if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be minimized')
+          return ipc.minimize({ id: this.id })
+        }
+
+        maximize () {
+          if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be maximized')
+          return ipc.maximize({ id: this.id })
+        }
+
+        fullscreen () {
+          if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be fullscreened')
+          return ipc.fullscreen({ id: this.id })
+        }
+
+        restore () { return ipc.restore({ id: this.id }) }
+
+        isVisible () { return ipc.isVisible({ id: this.id }) }
+
+        isMinimized () {
+          if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be minimized')
+          return ipc.isMinimized({ id: this.id })
+        }
+
+        isMaximized () {
+          if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be maximized')
+          return ipc.isMaximized({ id: this.id })
+        }
+
+        isFullscreen () {
+          if (this.constructor[kGuiCtrl] === 'view') throw new Error('A View cannot be maximized')
+          return ipc.isFullscreen({ id: this.id })
+        }
+
+        isClosed () { return ipc.isClosed({ id: this.id }) }
+      }
+
+      class Window extends GuiCtrl {
+        static [kGuiCtrl] = 'window'
+      }
+
+      class View extends GuiCtrl { static [kGuiCtrl] = 'view' }
+
+      class PearElectron {
+        Window = Window
+        View = View
+        media = media
+        #app = null
+        get app () {
+          if (this.#app) return this.#app
+          this.#app = new App(ipc.getId())
+          return this.#app
+        }
+
+        warming () { return ipc.warming() }
+
+        async get (key) {
+          return Buffer.from(await ipc.get(key)).toString('utf-8')
+        }
+
+        constructor () {
+          if (state.isDecal) {
+            this.constructor.DECAL = {
+              ipc,
+              'hypercore-id-encoding': require('hypercore-id-encoding'),
+              'pear-api/constants': require('pear-api/constants')
+            }
+          }
+        }
+      }
+
+      this[this.constructor.UI] = new PearElectron()
+    }
+
+    get media () {
+      console.warn('Pear.media is deprecated use require(\'pear-electron\').media')
+      return this[this.constructor.UI].media
+    }
+
+    get Window () {
+      console.warn('Pear.Window is deprecated use require(\'pear-electron\').Window')
+      return this[this.constructor.UI].Window
+    }
+
+    get View () {
+      console.warn('Pear.View is deprecated use require(\'pear-electron\').View')
+      return this[this.constructor.UI].View
+    }
+
+    run (link, args = []) { return this.#ipc.run(link, args) }
+
+    get pipe () {
+      if (this.#pipe !== null) return this.#pipe
+      this.#pipe = this.#ipc.pipe()
+      return this.#pipe
+    }
+
+    exit = (code) => {
+      process.exitCode = code
+      this.ipc.processExit(code)
+    }
+  }
+  return API
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pear-electron",
-  "version": "1.5.2",
+  "version": "1.7.0",
   "description": "Pear User-Interface Library for Electron",
   "main": "index.js",
   "scripts": {
@@ -14,10 +14,21 @@
     "bootstrap.js",
     "index.js",
     "runtime.js",
-    "pre.js"
+    "pre.js",
+    "api.js"
   ],
   "pear": {
-    "bootstrap": "pear://0.2725.goowesg5dga9j1ryx47rsk9o4zms4541me4zerxsnbu8u99duh4o",
+    "assets": {
+      "ui": {
+        "link": "pear://0.2731.goowesg5dga9j1ryx47rsk9o4zms4541me4zerxsnbu8u99duh4o",
+        "name": "Pear Runtime",
+        "only": [
+          "/boot.bundle",
+          "/by-arch/%%HOST%%",
+          "/prebuilds/%%HOST%%"
+        ]
+      }
+    },
     "stage": {
       "skipWarmup": "true",
       "only": [
@@ -62,7 +73,7 @@
     "iambus": "^1.0.3",
     "localdrive": "^1.12.1",
     "paparam": "^1.6.1",
-    "pear-api": "^1.17.6",
+    "pear-api": "^1.17.7",
     "pear-ipc": "^6.3.0",
     "script-linker": "^2.5.3",
     "streamx": "^2.20.2",

package/pre.js

@@ -16,6 +16,9 @@ async function configure (options) {
   const entrypoints = srcs(html)
   stage.entrypoints = Array.isArray(stage.entrypoints) ? [...stage.entrypoints, ...entrypoints] : entrypoints
   options.stage = stage
+  const pkg = (options.assets?.ui && !options.assets.ui.only) ? null : JSON.parse(await drive.get('node_modules/pear-electron/package.json'))
+  options.assets = options.assets ?? pkg?.pear?.assets
+  options.assets.ui.only = options.assets?.ui?.only ?? pkg?.pear?.assets?.ui?.only
   return options
 }
 

package/runtime.js

@@ -12,24 +12,19 @@ const constants = require('pear-api/constants')
 const plink = require('pear-api/link')
 const Logger = require('pear-api/logger')
 const { ERR_INVALID_APPLING, ERR_INVALID_PROJECT_DIR } = require('pear-api/errors')
-const { ansi, byteSize, indicator, outputter } = require('pear-api/terminal')
+
 const run = require('pear-api/cmd/run')
 const pear = require('pear-api/cmd')
 const pkg = require('./package.json')
 
-const bin = (name = Pear.config.name) => {
-  const formatedName = name[0].toUpperCase() + name.slice(1)
-  const app = isMac ? formatedName + ' Runtime.app' : name + '-runtime-app'
-  const exe = isWindows ? formatedName + ' Runtime.exe' : (isMac ? 'Contents/MacOS/' + formatedName + ' Runtime' : name + '-runtime')
+const bin = (name) => {
+  const kebab = name.toLowerCase().split(' ').join('-')
+  const cased = kebab.split('-').map((w) => w[0].toUpperCase() + w.slice(1)).join(' ')
+  const app = isMac ? cased + '.app' : kebab + '-app'
+  const exe = isWindows ? cased + '.exe' : (isMac ? 'Contents/MacOS/' + cased : kebab)
   return isWindows ? 'bin\\' + app + '\\' + exe : (isMac ? 'bin/' + app + '/' + exe : 'bin/' + app + '/' + exe)
 }
 
-const BIN = isWindows
-  ? 'bin\\pear-runtime-app\\Pear Runtime.exe'
-  : isMac
-    ? 'bin/Pear Runtime.app/Contents/MacOS/Pear Runtime'
-    : 'bin/pear-runtime-app/pear-runtime'
-
 class PearElectron {
   constructor () {
     this.ipc = Pear[Pear.constructor.IPC]
@@ -38,54 +33,9 @@ class PearElectron {
     Pear.teardown(() => this.ipc.close())
   }
 
-  #outs () {
-    if (this.LOG.INF === false) {
-      return {
-        stats ({ upload, download, peers }) {
-          const dl = download.total + download.speed === 0 ? '' : `[${ansi.down} ${byteSize(download.total)} - ${byteSize(download.speed)}/s ] `
-          const ul = upload.total + upload.speed === 0 ? '' : `[${ansi.up} ${byteSize(upload.total)} - ${byteSize(upload.speed)}/s ] `
-          return {
-            output: 'status',
-            message: `Syncing Runtime [ Peers: ${peers} ] ${dl}${ul}`
-          }
-        },
-        final (asset) {
-          if (asset.forced === false && asset.inserted === false) return {}
-          return 'Synced\x1b[K'
-        }
-      }
-    }
-    return {
-      dumping: ({ link, dir }) => this.LOG.format('INF', 'Syncing runtime from peers\nfrom: ' + link + '\ninto: ' + dir + '\n'),
-      byteDiff: ({ type, sizes, message }) => {
-        sizes = sizes.map((size) => (size > 0 ? '+' : '') + byteSize(size)).join(', ')
-        return this.LOG.format('INF', indicator(type, 'diff') + ' ' + message + ' (' + sizes + ')')
-      },
-      file: ({ key }) => this.LOG.format('INF', key),
-      complete: () => this.LOG.format('INF', 'Asset fetch complete'),
-      error: (err) => this.LOG.format('INF', `Asset fetch Failure (code: ${err.code || 'none'}) ${err.stack}`)
-    }
-  }
-
-  async #asset (opts, force = false) {
-    const output = outputter('asset', this.#outs())
-    const json = false
-    const bootstrap = opts.bootstrap?.link ?? opts.bootstrap ?? pkg.pear.bootstrap
-    const executable = opts.bootstrap ? bin(opts.bootstrap.name) : BIN
-    const stream = Pear.asset(bootstrap, {
-      only: ['/boot.bundle', '/by-arch/' + require.addon.host, '/prebuilds/' + require.addon.host],
-      force
-    })
-    const asset = await output(json, stream)
-    if (asset === null || !asset?.path) throw new Error('Failed to determine runtime asset from sidecar')
-    return path.join(asset.path, 'by-arch', require.addon.host, executable)
-  }
-
   async start (opts = {}) {
     this.LOG.info('Fetching asset & determining bin path')
-    this.bin = await this.#asset(opts)
-    // if disk tampered then resync:
-    if (fs.existsSync(this.bin) === false) this.bin = await this.#asset(opts, true)
+    this.bin = path.join(Pear.config.assets.ui.path, 'by-arch', require.addon.host, bin(Pear.config.assets.ui.name))
     const parsed = pear(Pear.argv.slice(1))
     const cmd = command('run', ...run)
     let argv = parsed.rest