@electerm/electerm-react 1.34.30

package/client/common/pre.js

@@ -0,0 +1,156 @@
+const {
+  runSync,
+  ipcOnEvent,
+  ipcOffEvent,
+  runGlobalAsync,
+  getZoomFactor,
+  setZoomFactor
+} = window.api
+
+const props = runSync('getConstants')
+
+props.env = JSON.parse(props.env)
+props.versions = JSON.parse(props.versions)
+
+// Encoding function
+function encodeUint8Array (uint8Array) {
+  let str = ''
+  const len = uint8Array.byteLength
+
+  for (let i = 0; i < len; i++) {
+    str += String.fromCharCode(uint8Array[i])
+  }
+
+  return btoa(str)
+}
+
+// Decoding function
+function decodeBase64String (base64String) {
+  const str = atob(base64String)
+  const len = str.length
+
+  const uint8Array = new Uint8Array(len)
+
+  for (let i = 0; i < len; i++) {
+    uint8Array[i] = str.charCodeAt(i)
+  }
+
+  return uint8Array
+}
+
+window.log = {
+  debug: (...args) => runSync('debug', ...args),
+  log: (...args) => runSync('log', ...args),
+  error: (...args) => runSync('error', ...args),
+  info: (...args) => runSync('info', ...args)
+}
+
+window.pre = {
+  readClipboard: () => {
+    return runSync('readClipboard')
+  },
+
+  writeClipboard: str => {
+    return runSync('writeClipboard', str)
+  },
+
+  resolve: (...args) => runSync('resolve', ...args),
+  join: (...args) => runSync('join', ...args),
+  basename: (...args) => runSync('basename', ...args),
+  showItemInFolder: (href) => runSync('showItemInFolder', href),
+  ...props,
+  ipcOnEvent,
+  ipcOffEvent,
+
+  getZoomFactor,
+  setZoomFactor,
+  openExternal: (url) => runSync('openExternal', url),
+
+  osInfo: () => runSync('osInfo'),
+  runGlobalAsync,
+  runSync
+}
+
+const path = {
+  resolve: window.pre.resolve,
+  join: window.pre.join,
+  basename: window.pre.basename
+}
+
+const fs = {
+  stat: (path, cb) => {
+    window.fs.statCustom(path)
+      .catch(err => cb(err))
+      .then(obj => {
+        obj.isDirectory = () => obj.isD
+        obj.isFile = () => obj.isF
+        cb(undefined, obj)
+      })
+  },
+  access: (...args) => {
+    const cb = args.pop()
+    window.fs.access(...args)
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  open: (...args) => {
+    const cb = args.pop()
+    window.fs.openCustom(...args)
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  read: (p1, arr, ...args) => {
+    const cb = args.pop()
+    window.fs.readCustom(
+      p1,
+      encodeUint8Array(arr),
+      ...args
+    )
+      .then((data) => {
+        const { n, newArr } = data
+        const newArr1 = decodeBase64String(newArr)
+        cb(undefined, n, newArr1)
+      })
+      .catch(err => cb(err))
+  },
+  close: (fd, cb) => {
+    window.fs.closeCustom(fd)
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  readdir: (p, cb) => {
+    window.fs.readdir(p)
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  mkdir: (...args) => {
+    const cb = args.pop()
+    window.fs.mkdir(...args)
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  write: (p1, buf, cb) => {
+    window.fs.writeCustom(p1, encodeUint8Array(buf))
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  realpath: (p, cb) => {
+    window.fs.realpath(p)
+      .then((data) => cb(undefined, data))
+      .catch((err) => cb(err))
+  },
+  constants: runSync('getFsContants')
+}
+
+window.reqs = {
+  path,
+  fs
+}
+
+function require (name) {
+  return window.reqs[name]
+}
+
+require.resolve = name => name
+
+window.require = require

package/client/common/promise-timeout.js

@@ -0,0 +1,27 @@
+/**
+ * Promise support timeout
+ */
+
+export class NewPromise extends Promise {
+  constructor (executor, timeout = 30000) {
+    let timeoutId
+
+    super((resolve, reject) => {
+      const wrappedResolve = (value) => {
+        clearTimeout(timeoutId)
+        resolve(value)
+      }
+
+      const wrappedReject = (reason) => {
+        clearTimeout(timeoutId)
+        reject(reason)
+      }
+
+      timeoutId = setTimeout(() => {
+        wrappedReject(new Error('Promise timed out'))
+      }, timeout)
+
+      executor(wrappedResolve, wrappedReject)
+    })
+  }
+}

package/client/common/resolve.js

@@ -0,0 +1,31 @@
+/**
+ * smart resolve function
+ * @param {String} basePath
+ * @param {String} nameOrDot
+ * @return {String}
+ */
+
+export default (basePath, nameOrDot) => {
+  const sep = basePath.includes('\\') || basePath.includes(':')
+    ? '\\'
+    : '/'
+  if (nameOrDot === '..') {
+    const arr = basePath.split(sep)
+    const { length } = arr
+    if (length === 1) {
+      return '/'
+    }
+    const res = arr.slice(0, length - 1).join(sep)
+    return res || '/'
+  }
+  const pre = nameOrDot.includes(':') && basePath === '/'
+    ? ''
+    : basePath
+  return pre +
+    (basePath.endsWith(sep) ? '' : sep) +
+    nameOrDot
+}
+
+export const osResolve = (...args) => {
+  return window.pre.resolve(...args)
+}

package/client/common/run-idle.js

@@ -0,0 +1 @@
+export default (...args) => window.requestIdleCallback(...args)

package/client/common/safe-local-storage.js

@@ -0,0 +1,35 @@
+import { termLSPrefix } from './constants'
+
+function clear () {
+  const keys = Object.keys(window.localStorage)
+  for (const key of keys) {
+    if (key.startsWith(termLSPrefix)) {
+      window.localStorage.removeItem(key)
+    }
+  }
+}
+
+export function setItem (id, str) {
+  try {
+    window.localStorage.setItem(id, str)
+  } catch (e) {
+    console.log(e)
+    console.log('maybe local storage full, lets reset')
+    clear()
+    window.localStorage.setItem(id, str)
+  }
+}
+
+export function getItem (id) {
+  return window.localStorage.getItem(id) || ''
+}
+
+export function getItemJSON (id, defaultValue) {
+  const str = window.localStorage.getItem(id) || ''
+  return str ? JSON.parse(str) : defaultValue
+}
+
+export function setItemJSON (id, obj) {
+  const str = JSON.stringify(obj)
+  return setItem(id, str)
+}

package/client/common/safe-name.js

@@ -0,0 +1,19 @@
+/**
+ * convert string to safe name
+ * from https://github.com/Jaliborc/safe-filename/blob/master/index.js
+ */
+
+export default (name) => {
+  return name
+    .replace(/\.$/, '')
+    .replace('?', '❓')
+    .replace('\\', ' ⃥')
+    .replace('/', '⟋')
+    .replace('|', '│')
+    .replace(':', '꞉')
+    .replace('<', 'ᐸ')
+    .replace('>', 'ᐳ')
+    .replace('>', 'ᐳ')
+    .replace('"', 'ᐦ')
+    .replace('*', '꘎')
+}

package/client/common/sftp.js

@@ -0,0 +1,74 @@
+/**
+ * sftp through ws
+ */
+
+import generate from './uid'
+import Transfer from './transfer'
+import { transferTypeMap } from './constants'
+import initWs from './ws'
+import { instSftpKeys as keys } from '../../app/common/constants'
+
+const transferKeys = Object.keys(transferTypeMap)
+
+class Sftp {
+  async init (sessionId) {
+    const id = generate()
+    const ws = await initWs('sftp', id, sessionId)
+    this.ws = ws
+    this.id = id
+    this.sessionId = sessionId
+    ws.s({
+      action: 'sftp-new',
+      id,
+      sessionId
+    })
+    const th = this
+    this.ws = ws
+    keys.forEach(func => {
+      th[func] = async (...args) => {
+        if (transferKeys.includes(func)) {
+          return Transfer({
+            sftpId: id,
+            ...args[0],
+            sessionId,
+            type: func
+          })
+        }
+        const uid = func + ':' + id
+        // let ws = await initWs()
+        return new Promise((resolve, reject) => {
+          ws.s({
+            action: 'sftp-func',
+            id,
+            func,
+            args,
+            sessionId
+          })
+          ws.once((arg) => {
+            if (arg.error) {
+              log.debug('sftp error', arg.error.message)
+              return reject(new Error(arg.error.message))
+            }
+            resolve(arg.data)
+          }, uid)
+        })
+      }
+    })
+  }
+
+  async destroy () {
+    const { ws } = this
+    ws.s({
+      action: 'sftp-destroy',
+      id: this.id,
+      sessionId: this.sessionId
+    })
+    ws.close()
+  }
+}
+
+export default async (sessionId) => {
+  const sftp = new Sftp()
+  await sftp.init(sessionId)
+  return sftp
+}

package/client/common/terminal-theme.js

@@ -0,0 +1,158 @@
+/**
+ * theme control
+ */
+
+import { defaultTheme, settingMap } from '../common/constants'
+import download from '../common/download'
+import copy from 'json-deep-copy'
+const { prefix } = window
+const t = prefix('terminalThemes')
+const terminalPrefix = 'terminal:'
+export const requiredThemeProps = [
+  'main',
+  'main-dark',
+  'main-light',
+  'text',
+  'text-light',
+  'text-dark',
+  'text-disabled',
+  'primary',
+  'info',
+  'success',
+  'error',
+  'warn',
+  'terminal:foreground',
+  'terminal:background',
+  'terminal:cursor',
+  'terminal:cursorAccent',
+  'terminal:selectionBackground',
+  'terminal:black',
+  'terminal:red',
+  'terminal:green',
+  'terminal:yellow',
+  'terminal:blue',
+  'terminal:magenta',
+  'terminal:cyan',
+  'terminal:white',
+  'terminal:brightBlack',
+  'terminal:brightRed',
+  'terminal:brightGreen',
+  'terminal:brightYellow',
+  'terminal:brightBlue',
+  'terminal:brightMagenta',
+  'terminal:brightCyan',
+  'terminal:brightWhite'
+]
+export const validThemeProps = [
+  ...requiredThemeProps,
+  'name'
+]
+/**
+ * build default themes
+ */
+export const buildDefaultThemes = () => {
+  return {
+    [defaultTheme.id]: defaultTheme
+  }
+}
+
+/**
+ * build new theme
+ */
+export const buildNewTheme = (theme = defaultTheme) => {
+  return Object.assign(
+    copy(theme),
+    {
+      id: '',
+      name: t('newTheme')
+    }
+  )
+}
+
+/**
+ * convert theme object to themeText
+ * @param {object} themeObj
+ * @param {boolean} withName
+ * @return {string}
+ */
+export const convertThemeToText = (themeObj = {}, withName = false) => {
+  const theme = themeObj || {}
+  const { themeConfig = {}, name, uiThemeConfig = {} } = theme
+  const begin = withName
+    ? `themeName=${name}\n`
+    : ''
+  const res = Object.keys(uiThemeConfig).reduce((prev, key) => {
+    return prev +
+      (prev ? '\n' : '') +
+      key + '=' + uiThemeConfig[key]
+  }, begin)
+  return Object.keys(themeConfig).reduce((prev, key) => {
+    return prev +
+      (prev ? '\n' : '') + terminalPrefix +
+      key + '=' + themeConfig[key]
+  }, res)
+}
+
+/**
+ * convert themeText to themeConfig object
+ * @param {string} themeTxt
+ * @return {object}
+ */
+export const convertTheme = (themeTxt) => {
+  return themeTxt.split('\n').reduce((prev, line) => {
+    let [key = '', value = ''] = line.split('=')
+    key = key.trim()
+    value = value.trim()
+    if (!key || !value) {
+      return prev
+    }
+    if (key === 'themeName') {
+      prev.name = value.slice(0, 50)
+    } else {
+      const isTerminal = key.startsWith(terminalPrefix)
+      key = key.replace(terminalPrefix, '')
+      if (key.includes('selection')) {
+        key = 'selectionBackground'
+      }
+      if (isTerminal) {
+        prev.themeConfig[key] = value
+      } else {
+        prev.uiThemeConfig[key] = value
+      }
+    }
+    return prev
+  }, {
+    themeConfig: {},
+    uiThemeConfig: {}
+  })
+}
+
+/**
+ * verify theme config
+ * @param {object} themeConfig
+ * @return {array} extra keys
+ */
+export const verifyTheme = (themeConfig) => {
+  const keysRight = Object.keys(defaultTheme.themeConfig)
+  const keys = Object.keys(themeConfig)
+  const extraKeys = keys.filter(k => !keysRight.includes(k))
+  return extraKeys
+}
+
+/**
+ * export theme as txt
+ * @param {string} themeId
+ */
+export const exportTheme = (themeId) => {
+  const themes = window.store.getSidebarList(settingMap.terminalThemes)
+  const theme = themes.find(d => d.id === themeId)
+  if (!theme) {
+    log.error('export error', themeId)
+    return
+  }
+  const text = convertThemeToText(theme, true)
+  download(
+    `${theme.name}.txt`,
+    text
+  )
+}

package/client/common/test-connection.js

@@ -0,0 +1,12 @@
+/**
+ * test connection
+ */
+
+import fetch from './fetch-from-server'
+
+export default (body) => {
+  return fetch({
+    body,
+    action: 'test-terminal'
+  })
+}

package/client/common/time.js

@@ -0,0 +1,30 @@
+/**
+ * time formatter
+ */
+
+function prefix (n) {
+  const str = '' + n
+  if (str.length < 2) {
+    return '0' + str
+  }
+  return str
+}
+
+export default (
+  time = new Date(),
+  format = 'YYYY-MM-DD HH:mm:ss'
+) => {
+  const t = new Date(time)
+  const d = t.getDate()
+  const y = t.getFullYear()
+  const m = t.getMonth()
+  const h = t.getHours()
+  const mm = t.getMinutes()
+  const s = t.getSeconds()
+  return format.replace('YYYY', prefix(y))
+    .replace('MM', prefix(m + 1))
+    .replace('DD', prefix(d))
+    .replace('HH', prefix(h))
+    .replace('mm', prefix(mm))
+    .replace('ss', prefix(s))
+}

package/client/common/to-simple-obj.js

@@ -0,0 +1,5 @@
+import { cloneDeep } from 'lodash-es'
+
+export default (obj) => {
+  return cloneDeep(obj)
+}

package/client/common/track.js

@@ -0,0 +1,7 @@
+export default (eventName, value) => {
+  if (!window.gtag) {
+    return
+  }
+  log.debug('track data', eventName, value)
+  window.gtag('event', eventName, value)
+}

package/client/common/transfer.js

@@ -0,0 +1,76 @@
+/**
+ * transfer through ws
+ */
+
+import generate from './uid'
+import initWs from './ws'
+
+const keys = window.pre.transferKeys
+
+class Transfer {
+  async init ({
+    onData,
+    onEnd,
+    onError,
+    ...rest
+  }) {
+    const id = generate()
+    this.id = id
+    const th = this
+    const {
+      sessionId,
+      sftpId
+    } = rest
+    const ws = await initWs('transfer', id, sessionId, sftpId)
+    ws.s({
+      action: 'transfer-new',
+      ...rest,
+      id
+    })
+    keys.forEach(func => {
+      th[func] = (...args) => {
+        ws.s({
+          action: 'transfer-func',
+          id: th.id,
+          func,
+          sessionId,
+          sftpId,
+          args
+        })
+        if (func === 'destroy') {
+          th.onDestroy(ws)
+        }
+      }
+    })
+
+    const did = 'transfer:data:' + id
+    this.onData = (evt) => {
+      const arg = JSON.parse(evt.data)
+      if (did === arg.id) {
+        onData(arg.data)
+      }
+    }
+    ws.addEventListener('message', this.onData)
+    ws.once((arg) => {
+      onEnd(arg)
+      th.onDestroy(ws)
+    }, 'transfer:end:' + id)
+    ws.once((arg) => {
+      log.debug('sftp transfer error')
+      log.debug(arg.error.stack)
+      onError(new Error(arg.error.message))
+      th.onDestroy(ws)
+    }, 'transfer:err:' + id)
+  }
+
+  onDestroy (ws) {
+    ws.removeEventListener('message', this.onData)
+    ws.close()
+  }
+}
+
+export default async (props) => {
+  const transfer = new Transfer()
+  await transfer.init(props)
+  return transfer
+}

package/client/common/trzsz.js

@@ -0,0 +1,62 @@
+import { TrzszFilter } from 'trzsz'
+
+const {
+  openDialog
+} = window.api
+
+window.newTrzsz = function (
+  writeToTerminal,
+  sendToServer,
+  terminalColumns,
+  isWindowsShell
+) {
+  // create a trzsz filter
+  return new TrzszFilter({
+    // write the server output to the terminal
+    writeToTerminal,
+    // send the user input to the server
+    sendToServer,
+    // choose some files to be sent to the server
+    chooseSendFiles: async (directory) => {
+      const properties = [
+        'openFile',
+        'multiSelections',
+        'showHiddenFiles',
+        'noResolveAliases',
+        'treatPackageAsDirectory',
+        'dontAddToRecent'
+      ]
+      if (directory) {
+        properties.push('openDirectory')
+      }
+      return openDialog({
+        title: 'Choose some files to send',
+        message: 'Choose some files to send',
+        properties
+      })
+    },
+    // choose a directory to save the received files
+    chooseSaveDirectory: async () => {
+      const savePaths = await openDialog({
+        title: 'Choose a folder to save file(s)',
+        message: 'Choose a folder to save file(s)',
+        properties: [
+          'openDirectory',
+          'showHiddenFiles',
+          'createDirectory',
+          'noResolveAliases',
+          'treatPackageAsDirectory',
+          'dontAddToRecent'
+        ]
+      })
+      if (!savePaths || !savePaths.length) {
+        return undefined
+      }
+      return savePaths[0]
+    },
+    // the terminal columns
+    terminalColumns,
+    // there is a windows shell
+    isWindowsShell
+  })
+}