@neurodevs/node-tdd 0.2.5 → 1.0.0

package/src/workspace/keySelectChoices.ts

@@ -0,0 +1,134 @@
+type KeySelectChoices = [
+    { label: 'ESCAPE'; value: 'ESCAPE' },
+    { label: 'SPACE'; value: ' ' },
+    { label: 'TAB'; value: 'TAB' },
+    { label: 'ENTER'; value: 'ENTER' },
+    { label: 'SHIFT_TAB'; value: 'SHIFT_TAB' },
+    { label: 'ALT_TAB'; value: 'ALT_TAB' },
+    { label: 'ALT_ENTER'; value: 'ALT_ENTER' },
+    { label: 'UP'; value: 'UP' },
+    { label: 'DOWN'; value: 'DOWN' },
+    { label: 'RIGHT'; value: 'RIGHT' },
+    { label: 'LEFT'; value: 'LEFT' },
+    { label: 'SHIFT_UP'; value: 'SHIFT_UP' },
+    { label: 'SHIFT_DOWN'; value: 'SHIFT_DOWN' },
+    { label: 'SHIFT_RIGHT'; value: 'SHIFT_RIGHT' },
+    { label: 'SHIFT_LEFT'; value: 'SHIFT_LEFT' },
+    { label: 'ALT_UP'; value: 'ALT_UP' },
+    { label: 'ALT_DOWN'; value: 'ALT_DOWN' },
+    { label: 'ALT_RIGHT'; value: 'ALT_RIGHT' },
+    { label: 'ALT_LEFT'; value: 'ALT_LEFT' },
+    { label: 'CTRL_UP'; value: 'CTRL_UP' },
+    { label: 'CTRL_DOWN'; value: 'CTRL_DOWN' },
+    { label: 'CTRL_RIGHT'; value: 'CTRL_RIGHT' },
+    { label: 'CTRL_LEFT'; value: 'CTRL_LEFT' },
+    { label: 'BACKSPACE'; value: 'BACKSPACE' },
+    { label: 'INSERT'; value: 'INSERT' },
+    { label: 'DELETE'; value: 'DELETE' },
+    { label: 'HOME'; value: 'HOME' },
+    { label: 'END'; value: 'END' },
+    { label: 'PAGE_UP'; value: 'PAGE_UP' },
+    { label: 'PAGE_DOWN'; value: 'PAGE_DOWN' },
+    { label: 'CTRL_INSERT'; value: 'CTRL_INSERT' },
+    { label: 'CTRL_DELETE'; value: 'CTRL_DELETE' },
+    { label: 'CTRL_HOME'; value: 'CTRL_HOME' },
+    { label: 'CTRL_END'; value: 'CTRL_END' },
+    { label: 'CTRL_PAGE_UP'; value: 'CTRL_PAGE_UP' },
+    { label: 'CTRL_PAGE_DOWN'; value: 'CTRL_PAGE_DOWN' },
+    { label: 'SHIFT_INSERT'; value: 'SHIFT_INSERT' },
+    { label: 'SHIFT_DELETE'; value: 'SHIFT_DELETE' },
+    { label: 'SHIFT_HOME'; value: 'SHIFT_HOME' },
+    { label: 'SHIFT_END'; value: 'SHIFT_END' },
+    { label: 'SHIFT_PAGE_UP'; value: 'SHIFT_PAGE_UP' },
+    { label: 'SHIFT_PAGE_DOWN'; value: 'SHIFT_PAGE_DOWN' },
+    { label: 'ALT_BACKSPACE'; value: 'ALT_BACKSPACE' },
+    { label: 'ALT_INSERT'; value: 'ALT_INSERT' },
+    { label: 'ALT_DELETE'; value: 'ALT_DELETE' },
+    { label: 'ALT_HOME'; value: 'ALT_HOME' },
+    { label: 'ALT_END'; value: 'ALT_END' },
+    { label: 'ALT_PAGE_UP'; value: 'ALT_PAGE_UP' },
+    { label: 'ALT_PAGE_DOWN'; value: 'ALT_PAGE_DOWN' },
+    { label: 'KP_NUMLOCK'; value: 'KP_NUMLOCK' },
+    { label: 'KP_DIVIDE'; value: 'KP_DIVIDE' },
+    { label: 'KP_MULTIPLY'; value: 'KP_MULTIPLY' },
+    { label: 'KP_MINUS'; value: 'KP_MINUS' },
+    { label: 'KP_0'; value: 'KP_0' },
+    { label: 'KP_1'; value: 'KP_1' },
+    { label: 'KP_2'; value: 'KP_2' },
+    { label: 'KP_3'; value: 'KP_3' },
+    { label: 'KP_4'; value: 'KP_4' },
+    { label: 'KP_5'; value: 'KP_5' },
+    { label: 'KP_6'; value: 'KP_6' },
+    { label: 'KP_7'; value: 'KP_7' },
+    { label: 'KP_8'; value: 'KP_8' },
+    { label: 'KP_9'; value: 'KP_9' },
+    { label: 'KP_PLUS'; value: 'KP_PLUS' },
+    { label: 'KP_DELETE'; value: 'KP_DELETE' },
+    { label: 'KP_ENTER'; value: 'KP_ENTER' },
+    { label: 'F1'; value: 'F1' },
+    { label: 'F2'; value: 'F2' },
+    { label: 'F3'; value: 'F3' },
+    { label: 'F4'; value: 'F4' },
+    { label: 'F5'; value: 'F5' },
+    { label: 'F6'; value: 'F6' },
+    { label: 'F7'; value: 'F7' },
+    { label: 'F8'; value: 'F8' },
+    { label: 'F9'; value: 'F9' },
+    { label: 'F10'; value: 'F10' },
+    { label: 'F11'; value: 'F11' },
+    { label: 'F12'; value: 'F12' },
+    { label: 'SHIFT_F1'; value: 'SHIFT_F1' },
+    { label: 'SHIFT_F2'; value: 'SHIFT_F2' },
+    { label: 'SHIFT_F3'; value: 'SHIFT_F3' },
+    { label: 'SHIFT_F4'; value: 'SHIFT_F4' },
+    { label: 'SHIFT_F5'; value: 'SHIFT_F5' },
+    { label: 'SHIFT_F6'; value: 'SHIFT_F6' },
+    { label: 'SHIFT_F7'; value: 'SHIFT_F7' },
+    { label: 'SHIFT_F8'; value: 'SHIFT_F8' },
+    { label: 'SHIFT_F9'; value: 'SHIFT_F9' },
+    { label: 'SHIFT_F10'; value: 'SHIFT_F10' },
+    { label: 'SHIFT_F11'; value: 'SHIFT_F11' },
+    { label: 'SHIFT_F12'; value: 'SHIFT_F12' },
+    { label: 'CTRL_F1'; value: 'CTRL_F1' },
+    { label: 'CTRL_F2'; value: 'CTRL_F2' },
+    { label: 'CTRL_F3'; value: 'CTRL_F3' },
+    { label: 'CTRL_F4'; value: 'CTRL_F4' },
+    { label: 'CTRL_F5'; value: 'CTRL_F5' },
+    { label: 'CTRL_F6'; value: 'CTRL_F6' },
+    { label: 'CTRL_F7'; value: 'CTRL_F7' },
+    { label: 'CTRL_F8'; value: 'CTRL_F8' },
+    { label: 'CTRL_F9'; value: 'CTRL_F9' },
+    { label: 'CTRL_F10'; value: 'CTRL_F10' },
+    { label: 'CTRL_F11'; value: 'CTRL_F11' },
+    { label: 'CTRL_F12'; value: 'CTRL_F12' },
+    { label: 'CTRL_SHIFT_F1'; value: 'CTRL_SHIFT_F1' },
+    { label: 'CTRL_SHIFT_F2'; value: 'CTRL_SHIFT_F2' },
+    { label: 'CTRL_SHIFT_F3'; value: 'CTRL_SHIFT_F3' },
+    { label: 'CTRL_SHIFT_F4'; value: 'CTRL_SHIFT_F4' },
+    { label: 'CTRL_SHIFT_F5'; value: 'CTRL_SHIFT_F5' },
+    { label: 'CTRL_SHIFT_F6'; value: 'CTRL_SHIFT_F6' },
+    { label: 'CTRL_SHIFT_F7'; value: 'CTRL_SHIFT_F7' },
+    { label: 'CTRL_SHIFT_F8'; value: 'CTRL_SHIFT_F8' },
+    { label: 'CTRL_SHIFT_F9'; value: 'CTRL_SHIFT_F9' },
+    { label: 'CTRL_SHIFT_F10'; value: 'CTRL_SHIFT_F10' },
+    { label: 'CTRL_SHIFT_F11'; value: 'CTRL_SHIFT_F11' },
+    { label: 'CTRL_SHIFT_F12'; value: 'CTRL_SHIFT_F12' },
+    { label: 'NUL'; value: 'NUL' },
+    { label: 'ALT_SPACE'; value: 'ALT_SPACE' },
+    { label: 'CTRL_ALT_SPACE'; value: 'CTRL_ALT_SPACE' },
+    { label: 'CURSOR_LOCATION'; value: 'CURSOR_LOCATION' },
+    { label: 'SCREEN_SIZE'; value: 'SCREEN_SIZE' },
+    { label: 'COLOR_REGISTER'; value: 'COLOR_REGISTER' },
+    { label: 'FOCUS_IN'; value: 'FOCUS_IN' },
+    { label: 'FOCUS_OUT'; value: 'FOCUS_OUT' },
+    { label: 'CLIPBOARD'; value: 'CLIPBOARD' },
+    { label: 'MOUSE'; value: 'MOUSE' },
+    { label: 'CTRL_C'; value: 'CTRL_C' },
+    { label: 'CTRL_A'; value: 'CTRL_A' },
+    { label: 'A'; value: 'A' },
+    { label: 'a'; value: 'a' },
+]
+
+export type Key = string
+
+export default [] as unknown as KeySelectChoices

package/src/workspace/layout.types.ts

@@ -0,0 +1,40 @@
+import { WidgetFrameAttribute, BaseWidget } from './widgets.types.js'
+
+// ** Layout Widget ** //
+
+export interface LayoutWidgetOptions {
+    rows: LayoutRow[]
+}
+
+export interface LayoutRow {
+    id?: string
+    columns: LayoutColumn[]
+    height?: WidgetFrameAttribute
+}
+
+export interface LayoutColumn {
+    id: string
+    width?: WidgetFrameAttribute
+}
+
+export interface LayoutWidget extends BaseWidget {
+    readonly type: 'layout'
+    getRows(): any[]
+    addRow(row: LayoutRow): void
+    addColumn(rowIdx: number, colunm: LayoutColumn): void
+    removeRow(rowIdx: number): void
+    removeColumn(rowIdx: number, columnIdx: number): void
+    setRowHeight(rowIdx: number, height: WidgetFrameAttribute): void
+    setColumnWidth(options: {
+        rowIdx: number
+        columnIdx: number
+        width: WidgetFrameAttribute
+    }): void
+    updateLayout(): void
+}
+
+export interface LayoutCellWidgetOptions {}
+
+export interface LayoutCellWidget extends BaseWidget {
+    readonly type: 'layoutCell'
+}

package/src/workspace/menuBar.types.ts

@@ -0,0 +1,24 @@
+import { BaseWidget } from './widgets.types.js'
+
+export const menuBarEventContract = {
+    eventSignatures: {
+        select: {},
+    },
+}
+
+export type MenuBarEventContract = typeof menuBarEventContract
+
+export interface MenuBarWidgetOptions {
+    items: MenuBarWidgetItem[]
+}
+
+export interface MenuBarWidgetItem {
+    label: string
+    value: string
+    items?: MenuBarWidgetItem[]
+}
+
+export interface MenuBarWidget extends BaseWidget<MenuBarEventContract> {
+    setTextForItem(value: string, text: string): void
+    readonly type: 'menuBar'
+}

package/src/workspace/popup.types.ts

@@ -0,0 +1,17 @@
+import { BaseWidget } from './widgets.types.js'
+
+export const popupEventContract = {
+    eventSignatures: {
+        close: {},
+    },
+}
+
+export type PopupEventContract = typeof popupEventContract
+
+export interface PopupWidgetOptions {
+    title?: string
+}
+
+export interface PopupWidget extends BaseWidget<PopupEventContract> {
+    readonly type: 'popup'
+}

package/src/workspace/progressBar.types.ts

@@ -0,0 +1,13 @@
+import { BaseWidget } from './widgets.types.js'
+
+export interface ProgressBarWidgetOptions {
+    label?: string
+    progress: number
+}
+
+export interface ProgressBarWidget extends BaseWidget {
+    readonly type: 'progressBar'
+
+    setLabel(label?: string): void
+    setProgress(progress: number): void
+}

package/src/workspace/table.types.ts

@@ -0,0 +1,9 @@
+import { BaseWidget } from './widgets.types.js'
+
+// ** Table Widget **//
+
+export interface TableWidgetOptions {}
+
+export interface TableWidget extends BaseWidget {
+    type: 'table'
+}

package/src/workspace/termKit.utility.ts

@@ -0,0 +1,130 @@
+import { isObject } from 'lodash-es'
+import { BaseWidget, WidgetFrame } from './widgets.types.js'
+import widgetUtil from './widget.utilities.js'
+
+const termKitUtil = {
+    buildFrame(frame: Partial<WidgetFrame>, parent?: BaseWidget | null) {
+        const calculated = widgetUtil.buildFrame(frame, parent)
+        return {
+            x: calculated.left,
+            y: calculated.top,
+            width: calculated.width,
+            height: calculated.height,
+        }
+    },
+
+    mapWidgetOptionsToTermKitOptions(options: Record<string, any>) {
+        const mapped: Record<string, any> = {}
+        const keys = Object.keys(options)
+        const ignores = [
+            'shouldLockHeightWithParent',
+            'shouldLockWidthWithParent',
+            'shouldLockBottomWithParent',
+            'term',
+        ]
+
+        if (options.backgroundColor) {
+            mapped.attr = {
+                ...mapped.attr,
+                bgColor: options.backgroundColor,
+            }
+        }
+
+        if (options.foregroundColor) {
+            mapped.attr = {
+                ...mapped.attr,
+                color: options.foregroundColor,
+            }
+        }
+
+        for (const key of keys) {
+            const item = options[key]
+            if (Array.isArray(item)) {
+                mapped[key] = []
+                for (const i of item) {
+                    mapped[key].push(this.mapWidgetOptionsToTermKitOptions(i))
+                }
+            } else {
+                switch (key) {
+                    case 'left':
+                        mapped.x = item
+                        break
+                    case 'top':
+                        mapped.y = item
+                        break
+                    case 'width':
+                        if (typeof item === 'string') {
+                            mapped.widthPercent = parseInt(item)
+                        } else {
+                            mapped.width = item
+                        }
+                        break
+                    case 'height':
+                        if (typeof item === 'string') {
+                            mapped.heightPercent = parseInt(item)
+                        } else {
+                            mapped.height = item
+                        }
+                        break
+                    case 'parent':
+                        mapped.parent = item.getTermKitElement()
+                        break
+                    default:
+                        if (ignores.indexOf(key) > -1) {
+                            break
+                        }
+                        if (typeof item !== 'function' && isObject(item)) {
+                            mapped[key] =
+                                this.mapWidgetOptionsToTermKitOptions(item)
+                        } else {
+                            mapped[key] = item
+                        }
+                }
+            }
+        }
+        return mapped
+    },
+
+    mapTermKitOptionsToWidgetOptions(options: Record<string, any>) {
+        const mapped: Record<string, any> = {}
+        const keys = Object.keys(options)
+
+        for (const key of keys) {
+            const item = options[key]
+            if (Array.isArray(item)) {
+                mapped[key] = []
+                for (const i of item) {
+                    mapped[key].push(this.mapTermKitOptionsToWidgetOptions(i))
+                }
+            } else {
+                switch (key) {
+                    case 'left':
+                        mapped.x = item
+                        break
+                    case 'top':
+                        mapped.y = item
+                        break
+                    case 'widthPercent':
+                        mapped.width = `${item}%`
+                        break
+                    case 'heightPercent':
+                        mapped.height = `${item}%`
+                        break
+                    case 'parent':
+                        mapped.parent = item.getTermKitElement()
+                        break
+                    default:
+                        if (typeof item !== 'function' && isObject(item)) {
+                            mapped[key] =
+                                this.mapTermKitOptionsToWidgetOptions(item)
+                        } else {
+                            mapped[key] = item
+                        }
+                }
+            }
+        }
+        return mapped
+    },
+}
+
+export default termKitUtil

package/src/workspace/terminal-kit.d.ts

@@ -0,0 +1,28 @@
+declare module 'terminal-kit' {
+    export interface Terminal {
+        (text?: string, ...args: any[]): Terminal
+        hideCursor(hide?: boolean): void
+        windowTitle(title: string): void
+        styleReset(): void
+        grabInput(state: boolean, extra?: boolean): Promise<void>
+        clear(): void
+        on(event: string, listener: (...args: any[]) => void): this
+        removeAllListeners(event?: string): this
+        createDocument(options?: any): any
+        [key: string]: any
+    }
+
+    const terminal: Terminal
+
+    export { terminal }
+    export default { terminal } & Record<string, any>
+
+    export class Palette {}
+    export class Button {}
+    export class DropDownMenu {}
+    export class InlineInput {}
+    export class Layout {}
+    export class Bar {}
+    export class TextBox {}
+    export class Window {}
+}

package/src/workspace/test.types.ts

@@ -0,0 +1,34 @@
+export type TestResultStatus = 'running' | 'passed' | 'failed'
+export type TestRunnerStatus = 'running' | 'stopped' | 'ready'
+
+export interface TestFileTest {
+    name: string
+    status:
+        | 'passed'
+        | 'failed'
+        | 'skipped'
+        | 'pending'
+        | 'todo'
+        | 'disabled'
+        | 'focused'
+    errorMessages?: string[]
+    duration: number
+}
+
+export interface SpruceTestFile {
+    path: string
+    status: TestResultStatus
+    tests?: TestFileTest[]
+    errorMessage?: string
+}
+
+export interface TestResults {
+    totalTests?: number
+    totalPassed?: number
+    totalFailed?: number
+    totalSkipped?: number
+    totalTodo?: number
+    totalTestFiles: number
+    totalTestFilesComplete?: number
+    testFiles?: SpruceTestFile[]
+}

package/src/workspace/testRunner.cli.ts

@@ -0,0 +1,159 @@
+import chokidar from 'chokidar'
+import path from 'path'
+import CommandServiceImpl from './CommandService.js'
+import TestReporter from './TestReporter.js'
+import TestRunner from './TestRunner.js'
+
+const args = process.argv.slice(2)
+const get = (flag: string) => {
+    const i = args.indexOf(flag)
+    return i !== -1 ? args[i + 1] : undefined
+}
+const has = (flag: string) => args.includes(flag)
+
+const pattern = get('--pattern') ?? null
+const watchMode = (get('--watchMode') ?? 'off') as 'off' | 'standard' | 'smart'
+const inspectPort = parseInt(get('--inspect') ?? '0', 10) || null
+const cwd = process.cwd()
+
+let currentPattern = pattern
+let isDebugging = inspectPort !== null
+let currentWatchMode = watchMode
+let runner: TestRunner | null = null
+let running = false
+
+const reporter = new TestReporter({
+    cwd,
+    filterPattern: pattern ?? undefined,
+    watchMode,
+    isDebugging,
+    status: has('--shouldHoldAtStart') ? 'stopped' : 'ready',
+    handleStartStop: () => {
+        if (running) {
+            runner?.kill()
+        } else {
+            runTests()
+        }
+    },
+    handleRestart: () => {
+        runner?.kill()
+        setTimeout(runTests, 100)
+    },
+    handleQuit: () => {
+        runner?.kill()
+        process.exit(0)
+    },
+    handleFilterPatternChange: (p?: string) => {
+        currentPattern = p ?? null
+        if (running) {
+            runner?.kill()
+            setTimeout(runTests, 100)
+        } else {
+            runTests()
+        }
+    },
+    handleToggleDebug: () => {
+        isDebugging = !isDebugging
+        reporter.setIsDebugging(isDebugging)
+    },
+    handletoggleStandardWatch: () => {
+        currentWatchMode = currentWatchMode === 'standard' ? 'off' : 'standard'
+        reporter.setWatchMode(currentWatchMode)
+    },
+    handleToggleSmartWatch: () => {
+        currentWatchMode = currentWatchMode === 'smart' ? 'off' : 'smart'
+        reporter.setWatchMode(currentWatchMode)
+    },
+})
+
+async function runTests() {
+    if (running) {
+        return
+    }
+    running = true
+
+    try {
+        reporter.setStatus('running')
+    } catch (err) {
+        running = false
+        reporter.appendError(`setStatus error: ${err}`)
+        return
+    }
+
+    const commandSvc = new CommandServiceImpl(cwd)
+    runner = new TestRunner({ cwd, commandService: commandSvc })
+
+    runner.on('did-update', ({ results }) => {
+        try {
+            reporter.updateResults(results)
+        } catch (err) {
+            reporter.appendError(`updateResults error: ${err}`)
+        }
+    })
+
+    runner.on('did-error', ({ message }) => {
+        reporter.appendError(message)
+    })
+
+    try {
+        await runner.run({
+            pattern: currentPattern,
+            debugPort: isDebugging ? (inspectPort ?? 5200) : null,
+        })
+    } catch (err) {
+        reporter.appendError(`Test run failed: ${err}`)
+    } finally {
+        running = false
+        reporter.setStatus('stopped')
+    }
+}
+
+let debounceTimer: ReturnType<typeof setTimeout> | null = null
+
+function scheduleRerun(changedFile?: string) {
+    if (debounceTimer) {
+        clearTimeout(debounceTimer)
+    }
+
+    if (currentWatchMode === 'smart' && changedFile) {
+        const rel = path.relative(cwd, changedFile)
+        const base = path.basename(rel, path.extname(rel))
+        reporter.startCountdownTimer(2)
+        debounceTimer = setTimeout(() => {
+            currentPattern = base
+            reporter.setFilterPattern(base)
+            runner?.kill()
+            setTimeout(runTests, 100)
+        }, 2000)
+    } else if (currentWatchMode === 'standard') {
+        reporter.startCountdownTimer(2)
+        debounceTimer = setTimeout(() => {
+            runner?.kill()
+            setTimeout(runTests, 100)
+        }, 2000)
+    }
+}
+
+async function main() {
+    await reporter.start()
+
+    await new Promise((r) => setTimeout(r, 50))
+
+    if (!has('--shouldHoldAtStart')) {
+        runTests()
+    }
+
+    if (currentWatchMode !== 'off') {
+        const watcher = chokidar.watch(path.join(cwd, 'src'), {
+            ignored: /node_modules/,
+            ignoreInitial: true,
+        })
+        watcher.on('change', scheduleRerun)
+        watcher.on('add', scheduleRerun)
+    }
+}
+
+main().catch((err) => {
+    console.error(err)
+    process.exit(1)
+})

package/src/workspace/text.types.ts

@@ -0,0 +1,26 @@
+import { BaseWidget } from './widgets.types.js'
+
+// ** Text Widget ** //
+
+export const textEventContract = {
+    eventSignatures: {
+        click: {},
+    },
+}
+
+export type TextEventContract = typeof textEventContract
+
+export interface TextWidgetOptions {
+    isScrollEnabled?: boolean
+    shouldAutoScrollWhenAppendingContent?: boolean
+    wordWrap?: boolean
+    text?: string
+}
+
+export interface TextWidget extends BaseWidget<TextEventContract> {
+    readonly type: 'text'
+    getText(): string
+    setText(content: string): void
+    getScrollX(): number
+    getScrollY(): number
+}

package/src/workspace/widget.utilities.ts

@@ -0,0 +1,35 @@
+import {
+    BaseWidget,
+    WidgetFrame,
+    WidgetFrameCalculated,
+} from './widgets.types.js'
+
+const widgetUtil = {
+    buildFrame(frame?: Partial<WidgetFrame>, parent?: BaseWidget | null) {
+        let { left, top, height, width } = frame || {}
+
+        if (typeof width === 'string') {
+            if (!parent) {
+                throw new Error(
+                    'I can only calculate percentage sizes if a parent is passed.'
+                )
+            }
+
+            width = parent.getFrame().width * (parseInt(width, 10) / 100)
+        }
+
+        if (typeof height === 'string') {
+            if (!parent) {
+                throw new Error(
+                    'I can only calculate percentage sizes if a parent is passed.'
+                )
+            }
+
+            height = parent.getFrame().height * (parseInt(height, 10) / 100)
+        }
+
+        return { left, top, height, width } as Partial<WidgetFrameCalculated>
+    },
+}
+
+export default widgetUtil