index.js

let hyperlayout

// Resolves an array, to find deepest cild. [[[1]]] -> 1
const resolveArray = a => a instanceof Array ? resolveArray(a[0]) : a

// Walk through modes – WINDOW -> TAB -> HORIZONTAL -> VERTICAL -> HORIZONTAL -> ...
const nextMode = mode => {
	switch (mode) {
		case 'TAB':
		case 'VERTICAL':
			return 'HORIZONTAL'
		case 'PANE':
		case 'HORIZONTAL':
			return 'VERTICAL'
		case 'WINDOW':
			return 'TAB'
		default:
			return 'WINDOW'
	}
}

// Generate Command queue from converted Config
function generateQueue(converted, mode = 'TAB', initial) {
	mode = (mode === 'PANE') ? 'HORIZONTAL' : mode

	let q = []

	if (converted instanceof Array) {
		converted.forEach((item, i) => {
			if (i > 0) {
				q.push({
					action: 'split',
					mode,
					pane: resolveArray(item)
				})
			} else {
				q.push({
					action: 'jump',
					pane: resolveArray(item)
				})
			}
			if (initial || i > 0) {
				q.push({
					action: 'cmd',
					pane: resolveArray(item)
				})
			}
		})
		converted.forEach(item => {
			q = q.concat(generateQueue(item, nextMode(mode)))
		})
	}
	// Jump back to initial pane
	q.push({
		action: 'jump',
		pane: resolveArray(converted)
	})
	return q
}

// Hyperlayout instance
class Hyperlayout {
	constructor({config, cwd}, store) {
		this.cwd = cwd
		this.store = store
		this.panes = []
		this.lastIndex = 0
		this.knownUids = []

		const converted = this.convertConfig(config.layout)
		const entry = (config.entry || 'tab').toUpperCase()
		this.queue = generateQueue(converted, entry, true)
		this.work()
	}
	work() {
		const {sessions} = this.store.getState()
		const {lastIndex, cwd} = this
		const {activeUid} = sessions
		const pane = this.panes[lastIndex]

		if (this.queue.length > 0) {
			const item = this.queue.shift()
			const {index} = item.pane

			if (!pane.uid) {
				this.panes[lastIndex].uid = activeUid
			}

			this.lastIndex = index
			this.lastUid = activeUid
			switch (item.action) {
				case 'split':
					requestSession(cwd, item.mode)
					break
				case 'cmd':
					runCommand(activeUid, pane.cmd)
					this.work()
					break
				case 'jump':
				default: {
					const jumpTo = this.panes[index].uid
					if (jumpTo) {
						focusUid(this.store, jumpTo)
					}
					this.work()
				}
			}
		}
	}
	convertConfig(item) {
		if (item instanceof Array) {
			return item.map(this.convertConfig.bind(this))
		} else if (typeof item === 'string') {
			const pane = {cmd: item, index: this.panes.length}
			this.panes.push(pane)
			return pane
		}
		console.error('Wrong type:', item)
	}
}

// Request new Session (Tab, Pane)
function requestSession(cwd, mode) {
	const payload = {cwd}
	switch (mode) {
		case 'HORIZONTAL':
		case 'VERTICAL':
			payload.splitDirection = mode
			break
		default:
			break
	}
	window.rpc.emit('new', payload)
}

// Runs command in given `uid`
function runCommand(uid, cmd) {
	if (cmd) {
		window.rpc.emit('data', {
			uid,
			data: ` ${cmd}\n\r`
		})
	}
}

// Focuses given `uid` – useful for pane operations
function focusUid({dispatch}, uid) {
	dispatch({
		type: 'SESSION_SET_ACTIVE',
		uid
	})
}

let autoLayout = true

// Listens for cli commands and sessions
exports.middleware = store => next => action => {
	const {type, data, uid} = action

	// Quick hack for auto-layout on startup.
	if (autoLayout && uid) {
		autoLayout = false
		setTimeout(() => {
			runCommand(uid, 'hyperlayout')
		})
	}

	// Check for hyperlayout config
	if (type === 'SESSION_ADD_DATA') {
		const testedData = /^\[hyperlayout config]:(.*)/.exec(data)
		if (testedData && testedData[1]) {
			// Quick fix to clean up data.
			const d = testedData[1]
			const config = JSON.parse(d.substring(0, d.lastIndexOf('}') + 1))
			hyperlayout = new Hyperlayout(config, store)
			return
		}
	}

	// Check for sessions
	if (type === 'SESSION_ADD' && hyperlayout) {
		// Check if it's a new session
		if (!hyperlayout.knownUids.includes(uid)) {
			hyperlayout.knownUids.push(uid)
			setTimeout(() => {
				hyperlayout.work()
			}, 0)
		}
	}
	next(action)
}