@electerm/electerm-react 1.34.30

package/client/store/load-data.js

@@ -0,0 +1,198 @@
+/**
+ * load data from db
+ */
+
+import { dbNames, update, getData, fetchInitData, insert, remove } from '../common/db'
+import initWatch from './watch'
+import parseInt10 from '../common/parse-int10'
+import { infoTabs, statusMap, defaultEnvLang } from '../common/constants'
+import fs from '../common/fs'
+import generate from '../common/uid'
+import defaultSettings from '../../app/common/default-setting'
+import encodes from '../components/bookmark-form/encodes'
+import runIdle from '../common/run-idle'
+import { initWsCommon } from '../common/fetch-from-server'
+
+function getHost (argv, opts) {
+  const arr = argv
+  let i = arr.length - 1
+  const reg = /^(?:([\w\d-_]+)@)?([\w\d-_]+\.[\w\d-_.]+)(?::([\d]+))?$/
+  for (; i >= 0; i--) {
+    const str = arr[i]
+    const mt = str.match(reg)
+    if (mt) {
+      const port = mt[3]
+      const user = mt[1]
+      return {
+        host: mt[2],
+        username: user,
+        port: port ? parseInt10(port) : 22
+      }
+    }
+  }
+  return {}
+}
+
+export async function addTabFromCommandLine (store, opts) {
+  log.debug('command line params', opts)
+  if (!opts) {
+    return false
+  }
+  const {
+    isHelp,
+    helpInfo,
+    options,
+    argv
+  } = opts
+  store.commandLineHelp = helpInfo
+  if (isHelp) {
+    return store.openAbout(infoTabs.cmd)
+  }
+  const conf = getHost(argv, options)
+  const update = {
+    passphrase: options.passphrase,
+    password: options.password,
+    // port: options.port ? parseInt(options.port, 10) : 22,
+    type: 'remote',
+    status: statusMap.processing,
+    id: generate(),
+    encode: encodes[0],
+    envLang: defaultEnvLang,
+    enableSsh: !options.sftpOnly,
+    authType: 'password',
+    pane: 'terminal',
+    term: defaultSettings.terminalType
+  }
+  if (options.setEnv) {
+    update.setEnv = options.setEnv
+  }
+  if (options.title) {
+    update.title = options.title
+  }
+  if (options.user) {
+    update.username = options.user
+  }
+  if (options.port && parseInt10(options.port)) {
+    update.port = parseInt10(options.port)
+  }
+  Object.assign(conf, update)
+  if (options.privateKeyPath) {
+    conf.privateKey = await fs.readFile(options.privateKeyPath)
+  }
+  log.debug('command line opts', conf)
+  if (conf.username && conf.host) {
+    store.addTab(conf)
+  }
+  if (options && options.batchOp) {
+    window.store.runBatchOp(options.batchOp)
+  }
+}
+
+export default (Store) => {
+  Store.prototype.batchDbUpdate = async function (updates) {
+    runIdle(() => {
+      for (const u of updates) {
+        update(u.id, u.update, u.db, u.upsert)
+      }
+    })
+  }
+  Store.prototype.batchDbAdd = async function (adds) {
+    runIdle(() => {
+      for (const u of adds) {
+        insert(u.db, u.obj)
+      }
+    })
+  }
+  Store.prototype.batchDbDel = async function (dels) {
+    runIdle(() => {
+      for (const u of dels) {
+        remove(u.db, u.id)
+      }
+    })
+  }
+  Store.prototype.openInitSessions = function () {
+    const { store } = window
+    const arr = store.config.onStartSessions || []
+    for (const s of arr) {
+      store.onSelectBookmark(s)
+    }
+    if (!arr.length && store.config.initDefaultTabOnStart) {
+      store.initFirstTab()
+    }
+    setTimeout(store.confirmLoad, 1300)
+    const { initTime, loadTime } = window.pre.runSync('getLoadTime')
+    if (loadTime) {
+      store.loadTime = loadTime
+    } else {
+      const finishLoadTime = Date.now()
+      store.loadTime = finishLoadTime - initTime
+      window.pre.runSync('setLoadTime', store.loadTime)
+    }
+  }
+  Store.prototype.fetchSshConfigItems = async function () {
+    const arr = await window.pre.runGlobalAsync('loadSshConfig')
+      .catch((err) => {
+        console.log('fetchSshConfigItems error', err)
+        return []
+      })
+    window.store._sshConfigItems = JSON.stringify(arr)
+  }
+  Store.prototype.confirmLoad = function () {
+    window.store.configLoaded = true
+  }
+  Store.prototype.initApp = async function () {
+    const { store } = window
+    const globs = await window.pre.runGlobalAsync('init')
+    window.langMap = globs.langMap
+    store.installSrc = globs.installSrc
+    store.appPath = globs.appPath
+    store.exePath = globs.exePath
+    store.isPortable = globs.isPortable
+    store._config = JSON.stringify(
+      globs.config
+    )
+    store._langs = JSON.stringify(
+      globs.langs
+    )
+    store.zoom(store.config.zoom, false, true)
+    initWsCommon()
+  }
+  Store.prototype.initData = async function () {
+    const { store } = window
+    await store.initApp()
+    const ext = {}
+    const all = dbNames.map(async name => {
+      const data = await fetchInitData(name)
+      return {
+        name,
+        data
+      }
+    })
+    await Promise.all(all)
+      .then(arr => {
+        for (const { name, data } of arr) {
+          ext['_' + name] = data
+        }
+      })
+    ext.lastDataUpdateTime = await getData('lastDataUpdateTime') || 0
+    Object.assign(store, ext)
+
+    store.checkDefaultTheme()
+    store.loadFontList()
+    store.fetchItermThemes()
+    store.openInitSessions()
+    store.fetchSshConfigItems()
+    initWatch(store)
+    store.initCommandLine().catch(store.onError)
+    if (store.config.checkUpdateOnStart) {
+      store.onCheckUpdate()
+    }
+  }
+  Store.prototype.initCommandLine = async function () {
+    const opts = await window.pre.runGlobalAsync('initCommandLine')
+    addTabFromCommandLine(window.store, opts)
+  }
+  Store.prototype.addTabFromCommandLine = (event, opts) => {
+    addTabFromCommandLine(window.store, opts)
+  }
+}

package/client/store/quick-command.js

@@ -0,0 +1,43 @@
+/**
+ * quick command related functions
+ */
+
+import {
+  settingMap,
+  terminalActions
+} from '../common/constants'
+import postMessage from '../common/post-msg'
+
+export default Store => {
+  Store.prototype.getQuickCommands = function () {
+    return window.store.getItems(settingMap.quickCommands)
+  }
+
+  Store.prototype.setQuickCommands = function (list) {
+    return window.store.setItems(settingMap.quickCommands, list)
+  }
+
+  Store.prototype.addQuickCommand = function (
+    qm
+  ) {
+    window.store.addItem(qm, settingMap.quickCommands)
+  }
+
+  Store.prototype.editQuickCommand = function (id, update) {
+    window.store.editItem(id, update, settingMap.quickCommands)
+  }
+
+  Store.prototype.delQuickCommand = function ({ id }) {
+    window.store.delItem({ id }, settingMap.quickCommands)
+  }
+
+  Store.prototype.runQuickCommand = function (cmd, inputOnly = false) {
+    const { activeTerminalId } = window.store
+    postMessage({
+      action: terminalActions.quickCommand,
+      cmd,
+      inputOnly,
+      activeSplitId: activeTerminalId
+    })
+  }
+}

package/client/store/session.js

@@ -0,0 +1,54 @@
+/**
+ * sessions not proper closed related functions
+ */
+
+import { isMac, terminalActions } from '../common/constants'
+import { debounce } from 'lodash-es'
+import postMsg from '../common/post-msg'
+
+export default Store => {
+  Store.prototype.onMouseWheel = function (event) {
+    if (
+      (isMac && event.metaKey) ||
+      (!isMac && event.ctrlKey)
+    ) {
+      event.stopPropagation()
+      if (window.store.inActiveTerminal) {
+        window.store.zoomTerminal(event.wheelDeltaY)
+      } else {
+        const plus = event.wheelDeltaY > 0 ? 0.2 : -0.2
+        window.store.zoom(plus, true)
+      }
+    }
+  }
+
+  Store.prototype.onKeyDown = function (event) {
+    if (
+      event.key === '=' &&
+      (
+        (isMac && event.metaKey) ||
+        (!isMac && event.ctrlKey)
+      )
+    ) {
+      event.stopPropagation()
+      window.store.zoom(0.25, true)
+    } else if (
+      event.key === '-' &&
+      (
+        (isMac && event.metaKey) ||
+        (!isMac && event.ctrlKey)
+      )
+    ) {
+      event.stopPropagation()
+      window.store.zoom(-0.25, true)
+    }
+  }
+
+  Store.prototype.zoomTerminal = debounce(function (delta) {
+    postMsg({
+      action: terminalActions.zoom,
+      zoomValue: delta > 0 ? 1 : -1,
+      activeSplitId: window.store.activeTerminalId
+    })
+  }, 500)
+}

package/client/store/setting.js

@@ -0,0 +1,208 @@
+/**
+ * setting modal
+ */
+
+import { find, isEqual, pick, without, findIndex } from 'lodash-es'
+import {
+  message
+} from 'antd'
+import generate from '../common/uid'
+import copy from 'json-deep-copy'
+import {
+  settingMap,
+  settingCommonId,
+  modals
+} from '../common/constants'
+import { buildNewTheme } from '../common/terminal-theme'
+import getInitItem from '../common/init-setting-item'
+import newTerm from '../common/new-terminal'
+
+const { prefix } = window
+const m = prefix('menu')
+
+export default Store => {
+  Store.prototype.setConfig = function (conf) {
+    const { store } = window
+    store._config = JSON.stringify(
+      {
+        ...store.config,
+        ...conf
+      }
+    )
+  }
+  Store.prototype.setSftpSortSetting = function (conf) {
+    const { store } = window
+    const base = copy(store.sftpSortSetting)
+    store._sftpSortSetting = JSON.stringify(
+      {
+        ...base,
+        ...conf
+      }
+    )
+  }
+  Store.prototype.handleEditHistory = function () {
+    const { store } = window
+    const all = store.getItems('history')
+    store.storeAssign({
+      settingTab: settingMap.history,
+      autofocustrigger: Date.now()
+    })
+    store.setSettingItem(all[0] || getInitItem([], settingMap.history))
+    store.openSettingModal()
+  }
+
+  Store.prototype.openBookmarkEdit = function (item) {
+    const { store } = window
+    store.storeAssign({
+      settingTab: settingMap.bookmarks,
+      autofocustrigger: Date.now()
+    })
+    store.setSettingItem(item)
+    store.openSettingModal()
+  }
+
+  Store.prototype.handleOpenQuickCommandsSetting = function () {
+    const { store } = window
+    store.storeAssign({
+      settingTab: settingMap.quickCommands,
+      autofocustrigger: Date.now()
+    })
+    store.setSettingItem(getInitItem([], settingMap.quickCommands))
+    store.openSettingModal()
+  }
+
+  Store.prototype.onSelectHistory = function (id) {
+    const { store } = window
+    const history = store.getItems('history')
+    const item = find(history, it => it.id === id)
+    store.addTab({
+      ...copy(item),
+      from: 'history',
+      srcId: item.id,
+      ...newTerm(true)
+    })
+  }
+
+  Store.prototype.onSelectBookmark = function (id) {
+    const { store } = window
+    const history = store.getItems('history')
+    const bookmarks = store.getBookmarks()
+    const item = copy(
+      find(bookmarks, it => it.id === id) ||
+      find(store.sshConfigItems, it => it.id === id)
+    )
+    if (!item) {
+      return
+    }
+    store.addTab({
+      ...item,
+      from: 'bookmarks',
+      srcId: item.id,
+      ...newTerm(true)
+    })
+    item.id = generate()
+    if (store.config.disableSshHistory) {
+      return
+    }
+    const existItem = find(history, j => {
+      const keysj = Object.keys(j)
+      const keysi = Object.keys(item)
+      return isEqual(
+        pick(item, without(keysi, 'id')),
+        pick(j, without(keysj, 'id'))
+      )
+    })
+    if (!existItem) {
+      store.addItem(item, settingMap.history)
+    } else {
+      const index = findIndex(history, f => f.id === existItem.id)
+      history.splice(index, 1)
+      history.unshift(existItem)
+      store.setItems('history', history)
+    }
+  }
+
+  Store.prototype.openSetting = function () {
+    const { store } = window
+    if (
+      store.settingTab === settingMap.setting &&
+      store.settingItem.id === settingCommonId &&
+      store.showModal === modals.setting
+    ) {
+      return store.hideSettingModal()
+    }
+    store.storeAssign({
+      settingTab: settingMap.setting
+    })
+    store.setSettingItem(getInitItem([], settingMap.setting))
+    store.openSettingModal()
+  }
+
+  Store.prototype.openSettingSync = function () {
+    const { store } = window
+    if (
+      store.settingTab === settingMap.setting &&
+      store.settingItem.id === store.setting[0].id &&
+      store.showModal === modals.setting
+    ) {
+      return store.hideSettingModal()
+    }
+    store.storeAssign({
+      settingTab: settingMap.setting
+    })
+    store.setSettingItem(copy(store.setting[0]))
+    store.openSettingModal()
+  }
+
+  Store.prototype.openTerminalThemes = function () {
+    const { store } = window
+    if (
+      store.settingTab === settingMap.terminalThemes &&
+      store.settingItem.id === ''
+    ) {
+      return store.hideSettingModal()
+    }
+    store.storeAssign({
+      settingTab: settingMap.terminalThemes,
+      autofocustrigger: Date.now()
+    })
+    store.setSettingItem(buildNewTheme())
+    store.openSettingModal()
+  }
+
+  Store.prototype.openSettingModal = function () {
+    const { store } = window
+    if (store.isSencondInstance) {
+      return message.warning(
+        m('sencondInstanceTip')
+      )
+    }
+    store.showModal = modals.setting
+  }
+
+  Store.prototype.hideSettingModal = function () {
+    const { store } = window
+    store.showModal = modals.hide
+    store.setSettingItem({})
+  }
+
+  Store.prototype.loadFontList = async function () {
+    const fonts = await window.pre.runGlobalAsync('loadFontList')
+      .catch(err => {
+        console.log('loadFontList error', err)
+        return []
+      })
+    window.store._fonts = JSON.stringify(fonts)
+  }
+
+  Store.prototype.handleChangeSettingTab = function (settingTab) {
+    const { store } = window
+    const arr = store.getItems(settingTab)
+    const item = getInitItem(arr, settingTab)
+    store.storeAssign({
+      autofocustrigger: Date.now(),
+      settingTab
+    })
+    store.setSettingItem(item)
+  }
+}

package/client/store/sidebar.js

@@ -0,0 +1,48 @@
+/**
+ * sidebar
+ */
+
+import {
+  settingMap,
+  openedSidebarKey,
+  sidebarPinnedKey
+} from '../common/constants'
+import * as ls from '../common/safe-local-storage'
+
+export default Store => {
+  Store.prototype.expandBookmarks = function () {
+    const { store } = window
+    window.store.setState(
+      'expandedKeys',
+      store.getBookmarkGroupsTotal().map(g => g.id)
+    )
+  }
+
+  Store.prototype.collapseBookmarks = function () {
+    const { store } = window
+    store.setState(
+      'expandedKeys',
+      []
+    )
+  }
+
+  Store.prototype.setOpenedSideBar = function (bar) {
+    ls.setItem(openedSidebarKey, bar)
+    window.store.openedSideBar = bar
+  }
+
+  Store.prototype.handlePin = function (pinned) {
+    const { store } = window
+    const current = !store.pinned
+    ls.setItem(sidebarPinnedKey, current + '')
+    store.pinned = current
+  }
+
+  Store.prototype.onClickBookmark = function () {
+    window.store.onNewSsh()
+  }
+
+  Store.prototype.onClickHistory = function () {
+    window.store.handleChangeSettingTab(settingMap.history)
+  }
+}