@electerm/electerm-react 1.34.30

package/client/entry/basic.js

@@ -0,0 +1,58 @@
+/**
+ * init app data then write main script to html body
+ */
+import '../css/basic.styl'
+import { get as _get } from 'lodash-es'
+import '../common/pre'
+
+const { isDev } = window.et
+const { version } = window.pre.packInfo
+
+async function loadWorker () {
+  return new Promise((resolve) => {
+    const url = !isDev ? `js/worker-${version}.js` : 'js/worker.js'
+    window.worker = new window.Worker(url)
+    function onInit (e) {
+      if (!e || !e.data) {
+        return false
+      }
+      const {
+        action
+      } = e.data
+      if (action === 'worker-init') {
+        window.worker.removeEventListener('message', onInit)
+        resolve(1)
+      }
+    }
+    window.worker.addEventListener('message', onInit)
+  })
+}
+
+async function load () {
+  window.capitalizeFirstLetter = (string) => {
+    return string.charAt(0).toUpperCase() + string.slice(1)
+  }
+  function loadScript () {
+    const rcs = document.createElement('script')
+    const url = !isDev ? `js/electerm-${version}.js` : 'js/electerm.js'
+    rcs.src = url
+    rcs.type = 'module'
+    document.body.appendChild(rcs)
+  }
+  window.getLang = (lang = window.store?.config.language || 'en_us') => {
+    return _get(window.langMap, `[${lang}].lang`)
+  }
+  window.prefix = prefix => {
+    return (id) => {
+      const lang = window.getLang()
+      const str = _get(lang, `[${prefix}][${id}]`) || id
+      return window.capitalizeFirstLetter(str)
+    }
+  }
+  await loadWorker()
+  loadScript()
+  document.body.removeChild(document.getElementById('content-loading'))
+}
+
+// window.addEventListener('load', load)
+load()

package/client/entry/index.jsx

@@ -0,0 +1,15 @@
+import { render } from 'react-dom'
+import '../../../node_modules/antd/dist/reset.css'
+import '../../../node_modules/xterm/css/xterm.css'
+import '../common/trzsz'
+import Main from '../components/main'
+import { notification } from 'antd'
+notification.config({
+  placement: 'bottomRight'
+})
+
+const rootElement = document.getElementById('container')
+render(
+  <Main />,
+  rootElement
+)

package/client/entry/worker.js

@@ -0,0 +1,137 @@
+/**
+ * web worker
+ */
+
+self.insts = {}
+
+function createWs (
+  type,
+  id,
+  sessionId = '',
+  sftpId = '',
+  config
+) {
+  // init gloabl ws
+  const { host, port, tokenElecterm } = config
+  const wsUrl = `ws://${host}:${port}/${type}/${id}?sessionId=${sessionId}&sftpId=${sftpId}&token=${tokenElecterm}`
+  const ws = new WebSocket(wsUrl)
+  ws.s = msg => {
+    ws.send(JSON.stringify(msg))
+  }
+  ws.id = id
+  ws.once = (callack, id) => {
+    const func = (evt) => {
+      const arg = JSON.parse(evt.data)
+      if (id === arg.id) {
+        callack(arg)
+        ws.removeEventListener('message', func)
+      }
+    }
+    ws.addEventListener('message', func)
+  }
+  ws.onclose = () => {
+    if (ws.dup) {
+      return
+    }
+    send({
+      id: ws.id,
+      action: 'close'
+    })
+    delete self.insts[ws.id]
+  }
+  return new Promise((resolve) => {
+    ws.onopen = () => {
+      if (self.insts[ws.id]) {
+        ws.dup = true
+        ws.close()
+        resolve(null)
+      } else {
+        resolve(ws)
+      }
+    }
+  })
+}
+
+function send (data) {
+  self.postMessage(data)
+}
+
+async function onMsg (e) {
+  const {
+    id,
+    wsId,
+    args,
+    action,
+    type,
+    persist
+  } = e.data
+  if (action === 'create') {
+    const inst = self.insts[id]
+    if (inst instanceof WebSocket) {
+      return send({
+        action,
+        id,
+        persist
+      }, '*')
+    } else if (inst) {
+      return false
+    } else {
+      const ws = await createWs(...args)
+      if (ws) {
+        self.insts[id] = ws
+      }
+    }
+    send({
+      action,
+      persist,
+      id
+    }, '*')
+  } else if (action === 'once') {
+    const ws = self.insts[wsId]
+    if (ws) {
+      const cb = (data) => {
+        send({
+          id,
+          wsId,
+          data
+        })
+      }
+      ws.once(cb, id)
+    }
+  } else if (action === 'close') {
+    const ws = self.insts[wsId]
+    if (ws) {
+      ws.close()
+    }
+  } else if (action === 's') {
+    const ws = self.insts[wsId]
+    if (ws) {
+      ws.s(...args)
+    }
+  } else if (action === 'addEventListener') {
+    const ws = self.insts[wsId]
+    if (ws) {
+      ws.cb = (e) => {
+        send({
+          wsId,
+          id,
+          data: {
+            data: e.data
+          }
+        })
+      }
+      ws.addEventListener(type, ws.cb)
+    }
+  } else if (action === 'removeEventListener') {
+    const ws = self.insts[wsId]
+    if (ws) {
+      ws.removeEventListener(type, ws.cb)
+      delete ws.cb
+    }
+  }
+}
+
+self.addEventListener('message', onMsg)
+send({
+  action: 'worker-init'
+})

package/client/store/address-bookmark.js

@@ -0,0 +1,25 @@
+function getType (item) {
+  return item.host
+    ? 'addressBookmarks'
+    : 'addressBookmarksLocal'
+}
+
+export default Store => {
+  Store.prototype.addAddressBookmark = (item) => {
+    return window.store.addItem(item, getType(item))
+  }
+
+  Store.prototype.delAddressBookmark = (item) => {
+    return window.store.delItem(item, getType(item))
+  }
+
+  Store.prototype.listAddressBookmark = () => {
+    const { store } = window
+    return [
+      ...store.addressBookmarksLocal,
+      ...store.addressBookmarks.sort((a, b) => {
+        return a.host > b.host ? 1 : -1
+      })
+    ]
+  }
+}

package/client/store/app-upgrade.js

@@ -0,0 +1,23 @@
+/**
+ * app upgrade
+ */
+
+import { commonActions } from '../common/constants'
+
+export default Store => {
+  Store.prototype.onCheckUpdate = () => {
+    window.postMessage({
+      action: commonActions.appUpdateCheck
+    }, '*')
+  }
+  Store.prototype.getProxySetting = function () {
+    const {
+      proxy,
+      enableGlobalProxy
+    } = window.store.config
+    if (!enableGlobalProxy) {
+      return ''
+    }
+    return typeof proxy !== 'string' ? '' : proxy
+  }
+}

package/client/store/batch-input-history.js

@@ -0,0 +1,26 @@
+/**
+ * batch input functions
+ */
+
+import copy from 'json-deep-copy'
+import { maxBatchInput, batchInputLsKey } from '../common/constants'
+import { uniq } from 'lodash-es'
+import * as ls from '../common/safe-local-storage'
+
+export default Store => {
+  Store.prototype.addBatchInput = function (str) {
+    let batchInputs = copy(window.store.batchInputs)
+    batchInputs.push(str)
+    batchInputs = uniq(batchInputs)
+    const len = batchInputs.length
+    if (len > maxBatchInput) {
+      batchInputs = batchInputs.slice(len - maxBatchInput)
+    }
+    ls.setItemJSON(batchInputLsKey, batchInputs)
+    window.store.batchInputs = batchInputs
+  }
+  Store.prototype.clearBatchInput = function () {
+    window.store.batchInputs = []
+    ls.setItemJSON(batchInputLsKey, [])
+  }
+}

package/client/store/bookmark-group.js

@@ -0,0 +1,128 @@
+/**
+ * bookmark group functions
+ */
+
+import { find, findIndex } from 'lodash-es'
+import {
+  defaultBookmarkGroupId,
+  settingMap,
+  terminalSshConfigType
+} from '../common/constants'
+
+export default Store => {
+  Store.prototype.getBookmarkGroups = function () {
+    return window.store.getItems(settingMap.bookmarkGroups)
+  }
+  Store.prototype.getBookmarkGroupsTotal = function () {
+    const { store } = window
+    return store.sshConfigItems.length
+      ? [
+          ...store.getBookmarkGroups(),
+          {
+            title: terminalSshConfigType,
+            id: terminalSshConfigType,
+            bookmarkIds: store.sshConfigItems.map(d => d.id)
+          }
+        ]
+      : store.getBookmarkGroups()
+  }
+
+  Store.prototype.setBookmarkGroups = function (items) {
+    return window.store.setItems('bookmarkGroups', items)
+  }
+
+  Store.prototype.addBookmarkGroup = async function (group) {
+    window.store.addItem(group, settingMap.bookmarkGroups)
+  }
+
+  Store.prototype.editBookmarkGroup = function (id, updates) {
+    window.store.editItem(id, updates, settingMap.bookmarkGroups)
+  }
+
+  Store.prototype.openAllBookmarkInCategory = function (item) {
+    const { store } = window
+    let ids = item.bookmarkIds
+    const gids = item.bookmarkGroupIds || []
+    const bookmarkGroups = store.getBookmarkGroups()
+    for (const gid of gids) {
+      const g = find(bookmarkGroups, g => g.id === gid)
+      if (g && g.bookmarkIds && g.bookmarkIds.length) {
+        ids = [
+          ...ids,
+          ...g.bookmarkIds
+        ]
+      }
+    }
+    for (const id of ids) {
+      store.onSelectBookmark(id)
+    }
+  }
+
+  Store.prototype.delBookmarkGroup = function ({ id }) {
+    const { store } = window
+    if (id === defaultBookmarkGroupId) {
+      return
+    }
+    let bookmarkGroups = store.getBookmarkGroups()
+    const tobeDel = find(bookmarkGroups, bg => bg.id === id)
+    if (!tobeDel) {
+      return
+    }
+    let groups = [tobeDel]
+    if (
+      tobeDel.level !== 2 &&
+      tobeDel.bookmarkGroupIds &&
+      tobeDel.bookmarkGroupIds.length > 0
+    ) {
+      const childs = bookmarkGroups.filter(
+        bg => tobeDel.bookmarkGroupIds.includes(bg.id)
+      )
+      groups = [
+        ...groups,
+        ...childs
+      ]
+    }
+    const groupIds = groups.map(g => g.id)
+    const updates = []
+    const defaultCatIndex = tobeDel.level !== 2
+      ? findIndex(
+        bookmarkGroups,
+        g => g.id === defaultBookmarkGroupId
+      )
+      : findIndex(
+        bookmarkGroups,
+        g => (g.bookmarkGroupIds || []).includes(tobeDel.id)
+      )
+    for (const g of groups) {
+      if (g.bookmarkIds.length) {
+        const def = bookmarkGroups[defaultCatIndex]
+        def.bookmarkIds = [
+          ...g.bookmarkIds,
+          ...def.bookmarkIds
+        ]
+        updates.push({
+          id: def.id,
+          db: 'bookmarkGroups',
+          upsert: false,
+          update: {
+            bookmarkIds: def.bookmarkIds
+          }
+        })
+      }
+    }
+    bookmarkGroups = bookmarkGroups.filter(t => {
+      return !groupIds.includes(t.id)
+    })
+    store.batchDbUpdate(updates)
+    store.batchDbDel(groupIds.map(id => {
+      return {
+        id,
+        db: 'bookmarkGroups'
+      }
+    }))
+    store.setBookmarkGroups(bookmarkGroups)
+    if (id === store.currentBookmarkGroupId) {
+      store.currentBookmarkGroupId = ''
+    }
+  }
+}

package/client/store/bookmark.js

@@ -0,0 +1,22 @@
+/**
+ * bookmark
+ */
+
+export default Store => {
+  Store.prototype.handleGetSerials = async function () {
+    const { store } = window
+    store.loaddingSerials = true
+    const res = await window.pre.runGlobalAsync('listSerialPorts')
+      .catch(store.onError)
+    if (res) {
+      store._serials = JSON.stringify(res)
+    }
+    store.loaddingSerials = false
+  }
+  Store.prototype.getBookmarks = function () {
+    return window.store.getItems('bookmarks')
+  }
+  Store.prototype.setBookmarks = function (items) {
+    return window.store.setItems('bookmarks', items)
+  }
+}

package/client/store/common.js

@@ -0,0 +1,140 @@
+/**
+ * common functions
+ */
+
+import handleError from '../common/error-handler'
+import { debounce } from 'lodash-es'
+import postMessage from '../common/post-msg'
+import {
+  commonActions,
+  tabActions,
+  modals
+} from '../common/constants'
+
+export default Store => {
+  Store.prototype.storeAssign = function (updates) {
+    Object.assign(this, updates)
+  }
+
+  Store.prototype.setOffline = function () {
+    postMessage({
+      action: tabActions.setAllTabOffline
+    })
+  }
+
+  Store.prototype.onError = function (e) {
+    handleError(e)
+  }
+
+  Store.prototype.updateConfig = function (ext) {
+    window.store.setConfig(ext)
+  }
+
+  Store.prototype.openFileInfoModal = function (data) {
+    postMessage({
+      data,
+      action: commonActions.showFileInfoModal
+    })
+  }
+
+  Store.prototype.openFileModeModal = function (data, file) {
+    postMessage({
+      data,
+      file,
+      action: commonActions.showFileModeModal
+    })
+  }
+
+  Store.prototype.onResize = debounce(async function () {
+    const { width, height } = await window.pre.runGlobalAsync('getScreenSize')
+    const isMaximized = window.pre.runSync('isMaximized')
+    const update = {
+      height: window.innerHeight,
+      innerWidth: window.innerWidth,
+      screenWidth: width,
+      screenHeight: height,
+      isMaximized
+    }
+    window.store.storeAssign(update)
+    window.pre.runGlobalAsync('setWindowSize', {
+      ...update,
+      height: window.outerHeight
+    })
+  }, 100, {
+    leading: true
+  })
+
+  Store.prototype.toggleTerminalSearch = function () {
+    const now = Date.now()
+    if (window.lastToggleTerminalSearch && now - window.lastToggleTerminalSearch < 300) {
+      return
+    }
+    window.lastToggleTerminalSearch = now
+    window.store.termSearchOpen = !window.store.termSearchOpen
+  }
+
+  Store.prototype.setState = function (name, value) {
+    window.store['_' + name] = JSON.stringify(value)
+  }
+
+  Store.prototype.toggleBatchOp = function () {
+    window.store.showModal = window.store.showModal === modals.batchOps ? modals.hide : modals.batchOps
+  }
+
+  Store.prototype.runBatchOp = function (path) {
+    window.store.showModal = modals.batchOps
+    function updateText () {
+      const text = window.pre.readFileSync(path).toString()
+      postMessage({
+        action: commonActions.batchOp,
+        batchOp: {
+          func: 'setState',
+          args: [
+            {
+              text
+            }
+          ]
+        }
+      })
+    }
+    function queue () {
+      postMessage({
+        action: commonActions.batchOp,
+        batchOp: {
+          func: 'handleClick',
+          args: []
+        }
+      })
+    }
+    function run () {
+      postMessage({
+        action: commonActions.batchOp,
+        batchOp: {
+          func: 'handleExec',
+          args: []
+        }
+      })
+    }
+    try {
+      setTimeout(updateText, 2000)
+      setTimeout(queue, 3000)
+      setTimeout(run, 4000)
+    } catch (e) {
+      log.error(e)
+    }
+  }
+
+  Store.prototype.setSettingItem = function (v) {
+    window.store.setState('settingItem', v)
+  }
+
+  Store.prototype.setTermSearchOption = function (update) {
+    const {
+      store
+    } = window
+    store.setState('termSearchOptions', {
+      ...JSON.parse(window.store._termSearchOptions),
+      ...update
+    })
+  }
+}

package/client/store/context-menu.js

@@ -0,0 +1,23 @@
+/**
+ * context menu related functions
+ */
+
+import postMessage from '../common/post-msg'
+import {
+  commonActions
+} from '../common/constants'
+
+export default Store => {
+  Store.prototype.openContextMenu = function (data) {
+    postMessage({
+      data,
+      type: commonActions.openContextMenu
+    })
+  }
+
+  Store.prototype.closeContextMenu = function () {
+    postMessage({
+      action: commonActions.closeContextMenu
+    })
+  }
+}

package/client/store/db-upgrade.js

@@ -0,0 +1,43 @@
+/**
+ * db upgrade
+ */
+
+import { Modal } from 'antd'
+import delay from '../common/wait'
+
+export default (Store) => {
+  Store.prototype.checkForDbUpgrade = async function () {
+    const { store } = window
+    if (store.isSencondInstance) {
+      return false
+    }
+    const shouldUpgrade = await window.pre.runGlobalAsync('checkDbUpgrade')
+    if (!shouldUpgrade) {
+      return false
+    }
+    const {
+      dbVersion,
+      packVersion
+    } = shouldUpgrade
+    const mod = Modal.info({
+      title: 'Upgrading database',
+      content: `Upgrading database... from v${dbVersion} to v${packVersion} please wait`,
+      keyboard: false,
+      okButtonProps: {
+        style: {
+          display: 'none'
+        }
+      }
+    })
+    await window.pre.runGlobalAsync('doUpgrade')
+    mod.update({
+      title: 'Done',
+      content: 'Database Upgraded',
+      okButtonProps: {}
+    })
+    await delay(3000)
+    mod.destroy()
+    await store.restart()
+    return true
+  }
+}