@neurodevs/node-tdd 0.2.5 → 1.0.0

package/src/workspace/TestRunner.ts

@@ -0,0 +1,128 @@
+import fs from 'fs'
+import pathUtil from 'path'
+import { EventEmitter } from 'events'
+import CommandServiceImpl from './CommandService.js'
+import JestJsonParser from './JestJsonParser.js'
+import { TestResults } from './test.types.js'
+
+export default class TestRunner extends EventEmitter {
+    private cwd: string
+    private commandService: CommandServiceImpl
+    private wasKilled = false
+    private testResults: TestResults = { totalTestFiles: 0 }
+
+    public constructor(options: {
+        cwd: string
+        commandService: CommandServiceImpl
+    }) {
+        super()
+        this.cwd = options.cwd
+        this.commandService = options.commandService
+    }
+
+    public async run(options?: {
+        pattern?: string | null
+        debugPort?: number | null
+    }): Promise<TestResults & { wasKilled: boolean }> {
+        this.wasKilled = false
+
+        const jestPath = this.resolvePathToJest()
+        const debugArgs =
+            (options?.debugPort ?? 0) > 0
+                ? `--inspect=${options?.debugPort}`
+                : ``
+        const pattern = options?.pattern ?? ''
+        const escapeShell = function (cmd: string) {
+            return (
+                '--testPathPatterns="' +
+                cmd.replace(/(["\s'$`\\])/g, '\\$1') +
+                '"'
+            )
+        }
+        const command = `node --experimental-vm-modules --unhandled-rejections=strict ${debugArgs} ${jestPath} --reporters="@sprucelabs/jest-json-reporter" --testRunner="jest-circus/runner" --passWithNoTests ${
+            pattern ? escapeShell(pattern) : ''
+        }`
+
+        const parser = new JestJsonParser()
+
+        this.testResults = {
+            totalTestFiles: 0,
+        }
+
+        try {
+            await this.commandService.execute(command, {
+                forceColor: true,
+                env: { NODE_NO_WARNINGS: '1' },
+                onError: async (data) => {
+                    const isDebugMessaging = this.isDebugMessage(data)
+
+                    if (!isDebugMessaging) {
+                        this.emit('did-error', { message: data })
+                    }
+                },
+                onData: async (data) => {
+                    try {
+                        parser.write(data)
+                        this.testResults = parser.getResults()
+                        this.emit('did-update', { results: this.testResults })
+                    } catch (err) {
+                        this.emit('did-error', {
+                            message: `Parser error: ${err}`,
+                        })
+                    }
+                },
+            })
+        } catch (err) {
+            if (!this.testResults.totalTestFiles) {
+                throw err
+            }
+        }
+
+        return { ...this.testResults, wasKilled: this.wasKilled }
+    }
+
+    private isDebugMessage(data: string) {
+        return (
+            data.search(/^ attached/i) === 0 ||
+            data.search(/^ listening/i) === 0 ||
+            data.search(/^waiting for the /i) === 0
+        )
+    }
+
+    public hasFailedTests() {
+        return (this.testResults.totalFailed ?? 0) > 0
+    }
+
+    public hasSkippedTests() {
+        return (this.testResults.totalSkipped ?? 0) > 0
+    }
+
+    public kill() {
+        this.wasKilled = true
+        this.commandService.kill()
+    }
+
+    private resolvePathToJest() {
+        const jestBin = pathUtil.join('node_modules', '.bin', 'jest')
+        const fullCwd = pathUtil.resolve(this.cwd)
+        const pathParts = fullCwd.split(pathUtil.sep).filter(Boolean)
+
+        while (pathParts.length > 0) {
+            const candidate =
+                pathUtil.sep +
+                pathUtil.join(...pathParts) +
+                pathUtil.sep +
+                jestBin
+
+            if (fs.existsSync(candidate)) {
+                return candidate
+            }
+
+            pathParts.pop()
+        }
+
+        throw new Error(
+            `Could not find jest binary. Make sure jest is installed in ${this.cwd}`
+        )
+    }
+}

package/src/workspace/TkBaseWidget.ts

@@ -0,0 +1,249 @@
+import { EventEmitter } from 'events'
+import { Terminal } from 'terminal-kit'
+import {
+    BaseWidget,
+    EventContract,
+    UniversalWidgetOptions,
+    WidgetFrame,
+    WidgetFrameCalculated,
+    WidgetPadding,
+} from './widgets.types.js'
+
+export type BaseWidgetWithTermKitAddons = BaseWidget & {
+    getTermKitElement: () => any | null
+}
+
+export type TkWidgetOptions = UniversalWidgetOptions & {
+    term: Terminal
+    parent: BaseWidgetWithTermKitAddons
+}
+
+export default abstract class TkBaseWidget<Contract extends EventContract = any>
+    extends EventEmitter
+    implements BaseWidget<Contract>
+{
+    public type = 'abstract'
+    protected parent: BaseWidgetWithTermKitAddons | null
+    protected term: Terminal
+    private id: string | null
+    private children: BaseWidget[] = []
+    protected shouldLockWidthWithParent = false
+    protected shouldLockHeightWithParent = false
+    protected shouldLockRightWithParent = false
+    protected shouldLockBottomWithParent = false
+    protected padding: WidgetPadding = {}
+    private frameLockDeltas: {
+        leftDelta: number
+        widthDelta: number
+        topDelta: number
+        heightDelta: number
+        rightDelta: number
+        bottomDelta: number
+    } = {
+        leftDelta: 0,
+        widthDelta: 0,
+        topDelta: 0,
+        heightDelta: 0,
+        rightDelta: 0,
+        bottomDelta: 0,
+    }
+
+    public constructor(options: TkWidgetOptions) {
+        super()
+
+        this.parent = options.parent ?? null
+        this.term = options.term
+        this.id = options.id ?? null
+        this.shouldLockHeightWithParent =
+            options.shouldLockHeightWithParent ?? false
+        this.shouldLockWidthWithParent =
+            options.shouldLockWidthWithParent ?? false
+        this.shouldLockRightWithParent =
+            options.shouldLockRightWithParent ?? false
+        this.shouldLockBottomWithParent =
+            options.shouldLockBottomWithParent ?? false
+
+        this.padding = {
+            left: 0,
+            top: 0,
+            right: 0,
+            bottom: 0,
+            ...options.padding,
+        }
+
+        if (this.parent) {
+            this.parent.addChild(this as TkBaseWidget)
+        }
+    }
+
+    public getChildren(): BaseWidget[] {
+        return this.children
+    }
+
+    public addChild(child: BaseWidget): void {
+        this.children.push(child)
+    }
+
+    public getId(): string | null {
+        return this.id
+    }
+
+    public getParent(): BaseWidget | null {
+        return this.parent
+    }
+
+    public getFrame(): WidgetFrameCalculated {
+        const element = this.getTermKitElement()
+        if (element) {
+            return {
+                left: element.outputX,
+                top: element.outputY,
+                width: element.outputWidth,
+                height: element.outputHeight,
+            }
+        }
+        throw new Error(
+            element
+                ? `${this.type} does not implement getFrame()`
+                : `${this.type} does not implement getTermKitElement()`
+        )
+    }
+
+    public setFrame(frame: Partial<WidgetFrame>): void {
+        const element = this.getTermKitElement()
+
+        if (element) {
+            if (element.resize) {
+                element.resize({
+                    x: frame.left,
+                    y: frame.top,
+                    width: frame.width,
+                    height: frame.height,
+                })
+            } else {
+                element.outputX = frame.left ?? element.outputX
+                element.outputY = frame.top ?? element.outputY
+                element.outputWidth = frame.width ?? element.outputWidth
+                element.outputHeight = frame.height ?? element.outputHeight
+            }
+
+            this.sizeLockedChildren()
+
+            element.draw()
+
+            return
+        }
+
+        throw new Error(`${this.type} does not implement getTermKitElement()`)
+    }
+
+    protected sizeLockedChildren() {
+        const newFrame = this.getFrame()
+        for (const child of this.children as TkBaseWidget[]) {
+            child.handleParentResize(newFrame)
+        }
+    }
+
+    public getChildById(id?: string): BaseWidget | null {
+        for (const child of this.getChildren()) {
+            if (child.getId() === id) {
+                return child
+            }
+        }
+
+        return null
+    }
+
+    public removeChild(child: BaseWidget) {
+        this.children = this.children.filter((c) => c !== child)
+    }
+
+    protected handleParentResize(parentFrame: WidgetFrameCalculated): void {
+        const updatedFrame = this.getFrame()
+        let shouldSetFrame = false
+
+        if (this.shouldLockHeightWithParent) {
+            shouldSetFrame = true
+            updatedFrame.height =
+                parentFrame.height - this.frameLockDeltas.heightDelta
+        }
+
+        if (this.shouldLockWidthWithParent) {
+            shouldSetFrame = true
+            updatedFrame.width =
+                parentFrame.width - this.frameLockDeltas.widthDelta
+        }
+
+        if (this.shouldLockRightWithParent) {
+            shouldSetFrame = true
+            updatedFrame.left =
+                parentFrame.width -
+                this.frameLockDeltas.rightDelta -
+                updatedFrame.width
+        }
+
+        if (this.shouldLockBottomWithParent) {
+            shouldSetFrame = true
+            updatedFrame.top =
+                parentFrame.height -
+                updatedFrame.height -
+                this.frameLockDeltas.bottomDelta
+        }
+
+        if (shouldSetFrame) {
+            this.setFrame(updatedFrame)
+        }
+    }
+
+    public async destroy() {
+        this.getTermKitElement()?.destroy()
+        this.getParent()?.removeChild(this as BaseWidget)
+    }
+
+    public getTermKitElement(): any | null {
+        return null
+    }
+
+    protected calculateSizeLockDeltas() {
+        const frame = this.getFrame()
+        const parentFrame = this.getParent()?.getFrame()
+
+        if (!parentFrame) {
+            return
+        }
+
+        let leftDelta = 0
+        let widthDelta = 0
+        let topDelta = 0
+        let heightDelta = 0
+        let rightDelta = 0
+        let bottomDelta = 0
+
+        if (this.shouldLockWidthWithParent) {
+            leftDelta = frame.left
+            widthDelta = parentFrame.width - frame.width
+        }
+
+        if (this.shouldLockHeightWithParent) {
+            topDelta = frame.top
+            heightDelta = parentFrame.height - frame.height
+        }
+
+        if (this.shouldLockRightWithParent) {
+            rightDelta = frame.left + frame.width - parentFrame.width
+        }
+
+        if (this.shouldLockBottomWithParent) {
+            bottomDelta = parentFrame.height - (frame.top + frame.height)
+        }
+
+        this.frameLockDeltas = {
+            leftDelta,
+            widthDelta,
+            topDelta,
+            heightDelta,
+            rightDelta,
+            bottomDelta,
+        }
+    }
+}

package/src/workspace/TkInputWidget.ts

@@ -0,0 +1,83 @@
+import chalk from 'chalk'
+import terminal_kit from 'terminal-kit'
+import { InputWidget, InputWidgetOptions } from './input.types.js'
+import { WidgetFrame } from './widgets.types.js'
+import widgetUtil from './widget.utilities.js'
+import termKitUtil from './termKit.utility.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+const termKit = terminal_kit as any
+
+export default class TkInputWidget extends TkBaseWidget implements InputWidget {
+    public readonly type = 'input'
+
+    private input: any
+
+    public constructor(
+        options: TkWidgetOptions & InputWidgetOptions & { termKitElement: any }
+    ) {
+        super(options)
+
+        const frame = termKitUtil.buildFrame(options, options.parent)
+
+        const { parent, ...rest } = options
+
+        this.input = new termKit.InlineInput({
+            parent: parent ? parent.getTermKitElement() : undefined,
+            textAttr: { bgColor: 'black', color: 'yellow' },
+            voidAttr: { bgColor: 'black', color: 'yellow' },
+            placeholder: options.placeholder
+                ? chalk.italic.black(options.placeholder)
+                : undefined,
+            placeholderHasMarkup: true,
+            prompt: {
+                content: options.label ? `${options.label} > ` : undefined,
+                contentHasMarkup: true,
+            },
+            cancelable: true,
+            ...rest,
+            ...frame,
+        })
+
+        this.input.__widget = this
+        this.input.on('submit', this.handleSubmit.bind(this))
+        this.input.on('cancel', this.handleCancel.bind(this))
+
+        this.calculateSizeLockDeltas()
+    }
+
+    public setFrame(frame: WidgetFrame) {
+        const oldFrame = this.getFrame()
+        const newFrame = widgetUtil.buildFrame(frame, this.parent)
+
+        this.input.setSizeAndPosition({
+            x: newFrame.left ?? oldFrame.left,
+            y: newFrame.top ?? oldFrame.top,
+            width: newFrame.width ?? oldFrame.width,
+            height: newFrame.height ?? oldFrame.height,
+        })
+
+        this.input.draw()
+    }
+
+    private async handleCancel() {
+        await (this as InputWidget).emit('cancel')
+    }
+
+    private async handleSubmit() {
+        await (this as InputWidget).emit('submit', {
+            value: this.getValue(),
+        })
+    }
+
+    public getValue(): string | undefined {
+        return this.input.getValue()
+    }
+
+    public setValue(value: string): void {
+        this.input.setContent(value)
+    }
+
+    public getTermKitElement() {
+        return this.input
+    }
+}

package/src/workspace/TkLayoutCellWidget.ts

@@ -0,0 +1,46 @@
+import { LayoutCellWidget, LayoutCellWidgetOptions } from './layout.types.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+
+export default class TkLayoutCellWidget
+    extends TkBaseWidget
+    implements LayoutCellWidget
+{
+    public readonly type = 'layoutCell'
+
+    private cell: any
+
+    public constructor(
+        options: TkWidgetOptions &
+            LayoutCellWidgetOptions & { termKitElement: any }
+    ) {
+        super({
+            shouldLockHeightWithParent: true,
+            shouldLockWidthWithParent: true,
+            ...options,
+        })
+
+        this.cell = options.termKitElement
+        this.cell.__widget = this
+    }
+
+    public getId() {
+        return this.cell.id
+    }
+
+    public getTermKitElement() {
+        return this.cell
+    }
+
+    public getFrame() {
+        return {
+            left: this.cell.outputDst.x,
+            top: this.cell.outputDst.y,
+            width: this.cell.inputWidth,
+            height: this.cell.inputHeight,
+        }
+    }
+
+    public setFrame() {
+        this.sizeLockedChildren()
+    }
+}

package/src/workspace/TkLayoutWidget.ts

@@ -0,0 +1,181 @@
+import terminal_kit from 'terminal-kit'
+import {
+    LayoutColumn,
+    LayoutRow,
+    LayoutWidget,
+    LayoutWidgetOptions,
+} from './layout.types.js'
+import { WidgetFrameAttribute, WidgetFrame } from './widgets.types.js'
+import termKitUtil from './termKit.utility.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+import TkLayoutCellWidget from './TkLayoutCellWidget.js'
+const termKit = terminal_kit as any
+
+export default class TkLayoutWidget
+    extends TkBaseWidget
+    implements LayoutWidget
+{
+    public readonly type = 'layout'
+
+    private layout: any
+
+    public constructor(options: TkWidgetOptions & LayoutWidgetOptions) {
+        super(options)
+
+        const mappedOptions =
+            termKitUtil.mapWidgetOptionsToTermKitOptions(options)
+
+        const { parent, ...layout } = mappedOptions
+
+        if (!parent) {
+            throw new Error('Missing required parameter: parent')
+        }
+
+        this.layout = new termKit.Layout({
+            parent,
+            layout,
+        })
+
+        this.layout.__widget = this
+        this.layout.off('parentResize', this.layout.onParentResize)
+
+        this.calculateSizeLockDeltas()
+    }
+
+    public getChildren() {
+        return this.layout.zChildren.map((child: any) => {
+            return new TkLayoutCellWidget({
+                term: this.term,
+                termKitElement: child,
+                parent: this,
+            })
+        })
+    }
+
+    public getTermKitElement() {
+        return this.layout
+    }
+
+    public getFrame() {
+        return {
+            left: this.layout.computed.xmin,
+            top: this.layout.computed.ymin,
+            width: this.layout.computed.width,
+            height: this.layout.computed.height,
+        }
+    }
+
+    public async destroy() {
+        this.layout.destroy()
+    }
+
+    public setFrame(frame: Partial<WidgetFrame>) {
+        const calculated = termKitUtil.buildFrame(frame, this.parent)
+        const def = this.layout.layoutDef
+
+        delete def.height
+        delete def.heightPercent
+
+        this.layout.layoutDef.height = calculated.height
+
+        this.handleResize()
+    }
+
+    private handleResize() {
+        this.layout.computeBoundingBoxes()
+        this.layout.draw()
+
+        this.sizeLockedChildren()
+    }
+
+    public getRows(): LayoutRow[] {
+        const rows = this.layout.layoutDef.rows
+        const layoutRows = this.termKitRowsToLayoutRows(rows)
+
+        return layoutRows
+    }
+
+    private termKitRowsToLayoutRows(rows: any): LayoutRow[] {
+        return rows.map((row: any) => ({
+            ...termKitUtil.mapTermKitOptionsToWidgetOptions(row),
+            columns: this.termKitColumnsToLayoutColumns(row.columns),
+        }))
+    }
+
+    private termKitColumnsToLayoutColumns(columns: any) {
+        return columns.map((col: any) =>
+            termKitUtil.mapTermKitOptionsToWidgetOptions(col)
+        )
+    }
+
+    public addRow(row: LayoutRow): void {
+        this.layout.layoutDef.rows.push({
+            ...termKitUtil.mapWidgetOptionsToTermKitOptions(row),
+            columns: this.widgetColumnsToTermKitColumns(row.columns),
+        })
+    }
+
+    public removeRow(rowIdx: number): void {
+        this.layout.layoutDef.rows.splice(rowIdx, 1)
+    }
+
+    public removeColumn(rowIdx: number, columnIdx: number): void {
+        const row = this.layout.layoutDef.rows[rowIdx]
+        if (row) {
+            row.columns.splice(columnIdx, 1)
+        } else {
+            throw new Error(
+                `Can't add remove column because row at index ${rowIdx} does not exist.`
+            )
+        }
+    }
+
+    public addColumn(rowIdx: number, column: LayoutColumn): void {
+        if (this.layout.layoutDef.rows[rowIdx]) {
+            this.layout.layoutDef.rows[rowIdx].columns.push({
+                ...termKitUtil.mapWidgetOptionsToTermKitOptions(column),
+            })
+        } else {
+            throw new Error(
+                `Can't add column because row at index ${rowIdx} does not exist.`
+            )
+        }
+    }
+
+    public setColumnWidth(options: {
+        rowIdx: number
+        columnIdx: number
+        width: WidgetFrameAttribute
+    }): void {
+        const { rowIdx, columnIdx, width } = options
+
+        const col = this.layout.layoutDef.rows[rowIdx]?.columns[columnIdx]
+        if (col) {
+            this.layout.layoutDef.rows[rowIdx].columns[columnIdx] = {
+                ...col,
+                ...termKitUtil.mapWidgetOptionsToTermKitOptions({ width }),
+            }
+        } else {
+            throw new Error(
+                `Can't add set column width because column ${columnIdx} at row ${rowIdx} does not exist.`
+            )
+        }
+    }
+
+    private widgetColumnsToTermKitColumns(columns: LayoutColumn[]) {
+        return columns.map((column) => ({
+            ...termKitUtil.mapWidgetOptionsToTermKitOptions(column),
+        }))
+    }
+
+    public setRowHeight(rowIdx: number, height: WidgetFrameAttribute): void {
+        this.layout.layoutDef.rows[rowIdx] = {
+            ...this.layout.layoutDef.rows[rowIdx],
+            ...termKitUtil.mapWidgetOptionsToTermKitOptions({ height }),
+        }
+    }
+
+    public updateLayout() {
+        this.handleResize()
+    }
+}