@neurodevs/node-tdd 1.0.6 → 1.0.7

package/src/workspace/TestRunner.ts

@@ -1,128 +0,0 @@
-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

@@ -1,249 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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()
-    }
-}