@neurodevs/node-tdd 0.2.5 → 1.0.0

package/src/workspace/TkMenuBarWidget.ts

@@ -0,0 +1,95 @@
+import terminal_kit from 'terminal-kit'
+const termKit = terminal_kit as any
+import {
+    MenuBarWidget,
+    MenuBarWidgetItem,
+    MenuBarWidgetOptions,
+} from './menuBar.types.js'
+import termKitUtil from './termKit.utility.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+
+export default class TkMenuBarWidget
+    extends TkBaseWidget
+    implements MenuBarWidget
+{
+    public readonly type = 'menuBar'
+
+    private menu: any
+
+    public constructor(options: TkWidgetOptions & MenuBarWidgetOptions) {
+        super(options)
+
+        const frame = termKitUtil.buildFrame(options, options.parent)
+        const items = this.mapItemsToTkItems(options.items)
+
+        this.menu = new termKit.DropDownMenu({
+            parent: options.parent.getTermKitElement(),
+            separator: '|',
+            items,
+            backgroundAttr: { bgColor: 'black', color: 'white' },
+            buttonBlurAttr: { bgColor: 'black', color: 'yellow' },
+            buttonFocusAttr: { bgColor: 'yellow', color: 'black' },
+            separatorAttr: { bgColor: 'black', color: 'yellow' },
+            ...frame,
+        })
+
+        this.calculateSizeLockDeltas()
+
+        this.menu.__widget = this
+        this.menu.on('submit', this.handleMenuSubmit.bind(this))
+    }
+
+    public setTextForItem(value: string, text: string): void {
+        let buttonItem = this.getButtonByValue(value, this.menu.buttons)
+
+        if (!buttonItem) {
+            for (const item of this.menu.itemsDef) {
+                for (const subItem of item.items ?? []) {
+                    if (subItem.value === value) {
+                        subItem.content = this.buildItemText(text)
+                        return
+                    }
+                }
+            }
+        }
+
+        if (!buttonItem) {
+            throw new Error(`No menu item with value of ${value}`)
+        }
+
+        buttonItem.setContent(this.buildItemText(text), true)
+    }
+
+    private getButtonByValue(value: string, buttons: any[]) {
+        let button: any
+        for (const button of buttons) {
+            if (button.def.value === value) {
+                return button
+            }
+        }
+
+        return button
+    }
+
+    private handleMenuSubmit(value: string) {
+        this.menu.clearColumnMenu()
+        void (this as MenuBarWidget).emit('select', { value })
+    }
+
+    public getTermKitElement() {
+        return this.menu
+    }
+
+    private mapItemsToTkItems(items: MenuBarWidgetItem[]): any {
+        return items.map((item) => ({
+            value: item.value,
+            content: this.buildItemText(item.label),
+            topSubmit: !item.items || item.items.length === 0,
+            items: item.items ? this.mapItemsToTkItems(item.items) : undefined,
+        }))
+    }
+
+    private buildItemText(text: string): string {
+        return ` ${text} `
+    }
+}

package/src/workspace/TkPopupWidget.ts

@@ -0,0 +1,47 @@
+import terminal_kit from 'terminal-kit'
+import { PopupWidget, PopupWidgetOptions } from './popup.types.js'
+import termKitUtil from './termKit.utility.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+const termKit = terminal_kit as any
+
+export default class TkPopupWidget extends TkBaseWidget implements PopupWidget {
+    private popup: any
+
+    public readonly type = 'popup'
+
+    public constructor(
+        options: TkWidgetOptions & PopupWidgetOptions & { termKitElement: any }
+    ) {
+        super({
+            shouldLockHeightWithParent: true,
+            shouldLockWidthWithParent: true,
+            ...options,
+        })
+
+        const { parent, ...rest } = options
+
+        const frame = termKitUtil.buildFrame(options, parent)
+
+        this.popup = new termKit.Window({
+            parent: parent ? parent.getTermKitElement() : undefined,
+            movable: true,
+            ...rest,
+            ...frame,
+        })
+
+        this.popup.__widget = this
+    }
+
+    public getTermKitElement() {
+        return this.popup
+    }
+
+    public getFrame() {
+        return {
+            left: this.popup.outputDst.x,
+            top: this.popup.outputDst.y,
+            width: this.popup.inputWidth,
+            height: this.popup.inputHeight,
+        }
+    }
+}

package/src/workspace/TkProgressBarWidget.ts

@@ -0,0 +1,54 @@
+import terminal_kit from 'terminal-kit'
+import {
+    ProgressBarWidget,
+    ProgressBarWidgetOptions,
+} from './progressBar.types.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+const termKit = terminal_kit as any
+
+export default class TkProgressBarWidget
+    extends TkBaseWidget
+    implements ProgressBarWidget
+{
+    public readonly type = 'progressBar'
+
+    private bar: any
+
+    public constructor(options: TkWidgetOptions & ProgressBarWidgetOptions) {
+        super(options)
+
+        const { parent, label, left, top, progress, ...barOptions } = options
+
+        this.bar = new termKit.Bar({
+            parent: parent?.getTermKitElement(),
+            content: label ? ` ${label}` : undefined,
+            x: left,
+            y: top,
+            barChars: 'solid',
+            bodyAttr: { bgColor: 'yellow', dim: false, color: 'yellow' },
+            overTextFullAttr: { bgColor: 'yellow', color: 'black', dim: false },
+            overTextEmptyAttr: {
+                bgColor: 'yellow',
+                color: 'black',
+                dim: false,
+            },
+            value: progress,
+            ...barOptions,
+        })
+
+        this.bar.__widget = this
+        this.calculateSizeLockDeltas()
+    }
+
+    public setProgress(progress: number): void {
+        this.bar.setValue(progress)
+    }
+
+    public setLabel(label?: string): void {
+        this.bar.setContent(label ? ` ${label}` : '')
+    }
+
+    public getTermKitElement() {
+        return this.bar
+    }
+}

package/src/workspace/TkTextWidget.ts

@@ -0,0 +1,158 @@
+import terminal_kit from 'terminal-kit'
+import { TextWidget, TextWidgetOptions } from './text.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 TkTextWidget extends TkBaseWidget implements TextWidget {
+    public readonly type = 'text'
+
+    private text: any
+    private shouldAutoScrollWhenAppendingContent: boolean
+
+    public constructor(options: TkWidgetOptions & TextWidgetOptions) {
+        super(options)
+
+        const {
+            parent,
+            text,
+            isScrollEnabled: enableScroll = false,
+            shouldAutoScrollWhenAppendingContent = true,
+            ...rest
+        } = options
+
+        this.shouldAutoScrollWhenAppendingContent =
+            shouldAutoScrollWhenAppendingContent
+
+        const frame = termKitUtil.buildFrame(options, parent)
+
+        this.text = new termKit.TextBox({
+            parent: parent ? parent.getTermKitElement() : undefined,
+            scrollable: enableScroll,
+            vScrollBar: enableScroll,
+            hScrollBar: enableScroll && !rest.wordWrap,
+            content: text,
+            wordWrap: true,
+            ...termKitUtil.mapWidgetOptionsToTermKitOptions(rest),
+            ...frame,
+        })
+
+        this.calculateSizeLockDeltas()
+
+        this.text.__widget = this
+        this.text.on('click', this.handleMouseDown.bind(this))
+    }
+
+    private async handleMouseDown(position: { x: number; y: number }) {
+        const { x, y } = position
+
+        const line = this.text.content.split('\n')[y]
+
+        await (this as TextWidget).emit('click', {
+            text: line,
+            row: y,
+            column: x,
+        })
+    }
+
+    public getTermKitElement() {
+        return this.text
+    }
+
+    public setFrame(frame: WidgetFrame) {
+        const oldFrame = this.getFrame()
+        const newFrame = widgetUtil.buildFrame(frame, this.parent)
+
+        this.text.setSizeAndPosition({
+            x: newFrame.left ?? oldFrame.left,
+            y: newFrame.top ?? oldFrame.top,
+            width: newFrame.width ?? oldFrame.width,
+            height: newFrame.height ?? oldFrame.height,
+        })
+        this.text.draw()
+    }
+
+    public getText(): string {
+        return this.text.content
+    }
+
+    private isLogScrolledAllTheWay() {
+        const scrollDistance = this.getScrollY() * -1
+        const contentHeight = this.text.textBuffer.cy
+        const visibleHeight = this.text.textAreaHeight
+        const maxScrollDistance =
+            Math.max(contentHeight, visibleHeight) - visibleHeight
+        const isScrolledAllTheWay = scrollDistance >= maxScrollDistance
+
+        return isScrolledAllTheWay
+    }
+
+    public getScrollY() {
+        return this.text.scrollY
+    }
+
+    public getScrollX() {
+        return this.text.scrollX
+    }
+
+    public setText(content: string): void {
+        if (this.getText() === content) {
+            return
+        }
+
+        const isScrolledAllTheWay = this.isLogScrolledAllTheWay()
+        const markupType = this.markupType(content)
+        const normalizedContent =
+            markupType === 'ansi' ? this.padAnsiSegments(content) : content
+
+        this.text.setContent(normalizedContent, markupType)
+
+        if (this.shouldAutoScrollWhenAppendingContent && isScrolledAllTheWay) {
+            this.text.scrollToBottom()
+        }
+    }
+
+    private markupType(content: string) {
+        const match = /\x1b\[[0-9;]+m/.exec(content)
+        const markupType = match ? 'ansi' : true
+        return markupType
+    }
+
+    private padAnsiSegments(content: string): string {
+        const sgrPattern = /\[[0-9;]+m/g
+        let result = ''
+        let lastIndex = 0
+
+        let match: RegExpExecArray | null
+
+        while ((match = sgrPattern.exec(content))) {
+            const segment = content.slice(lastIndex, match.index)
+            if (segment) {
+                result += this.padSegment(segment)
+            }
+
+            result += match[0]
+            lastIndex = match.index + match[0].length
+        }
+
+        if (lastIndex < content.length) {
+            result += this.padSegment(content.slice(lastIndex))
+        }
+
+        return result
+    }
+
+    private padSegment(segment: string): string {
+        if (segment.length !== 1) {
+            return segment
+        }
+
+        if (segment.trim().length > 0) {
+            return `${segment}​`
+        }
+
+        return segment
+    }
+}

package/src/workspace/TkWindowWidget.ts

@@ -0,0 +1,122 @@
+import terminal_kit from 'terminal-kit'
+import { Key } from './keySelectChoices.js'
+import { BaseWidget } from './widgets.types.js'
+import { WindowWidget, WindowWidgetOptions } from './window.types.js'
+import TkBaseWidget, { TkWidgetOptions } from './TkBaseWidget.js'
+const termKit = terminal_kit as any
+
+export default class TkWindowWidget
+    extends TkBaseWidget
+    implements WindowWidget
+{
+    public readonly type = 'window'
+
+    private document: any
+
+    public constructor(options: TkWidgetOptions & WindowWidgetOptions) {
+        super(options)
+
+        //@ts-ignore
+        this.document = this.term.createDocument({
+            palette: new termKit.Palette(),
+        })
+
+        this.document.eventSource.on('resize', async () => {
+            this.handleParentResize()
+            const frame = this.getFrame()
+            await (this as WindowWidget).emit('resize', {
+                width: frame.width,
+                height: frame.height,
+            })
+        })
+
+        this.document.__widget = this
+
+        options.term.on('key', this.handleKeyPress.bind(this))
+
+        process.on('exit', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('SIGQUIT', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('kill' as any, (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('SIGINT', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('SIGTERM', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('SIGUSR1', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('SIGUSR2', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+
+        process.on('uncaughtException', (code: number) => {
+            void (this as WindowWidget).emit('kill', { code })
+        })
+    }
+
+    public getFocusedWidget(): BaseWidget<any> | null {
+        return this.document.focusElement.__widget
+    }
+
+    private async handleKeyPress(key: Key) {
+        await (this as WindowWidget).emit('key', { key })
+    }
+
+    protected handleParentResize() {
+        this.sizeLockedChildren()
+    }
+
+    public setTitle(title: string) {
+        this.term.windowTitle(title)
+    }
+
+    public hideCursor() {
+        this.term.hideCursor(true)
+    }
+
+    public showCursor() {
+        this.term.hideCursor(false)
+    }
+
+    public getFrame() {
+        return {
+            left: 0,
+            top: 0,
+            width: this.document.inputWidth,
+            height: this.document.inputHeight,
+        }
+    }
+
+    public getTermKitElement() {
+        return this.document
+    }
+
+    public async destroy() {
+        this.showCursor()
+        //@ts-ignore
+        this.term.removeAllListeners()
+
+        this.term.styleReset()
+
+        await this.term.grabInput(false, true)
+
+        this.document.destroy()
+
+        this.term.clear()
+
+        this.term(`\n`)
+    }
+}

package/src/workspace/WidgetFactory.ts

@@ -0,0 +1,33 @@
+import terminal_kit, { Terminal } from 'terminal-kit'
+import {
+    contractRegistry,
+    FactoryOptions,
+    widgetRegistry,
+    WidgetRegistry,
+    WidgetType,
+} from './factory.types.js'
+const termKit = terminal_kit as any
+
+export default class WidgetFactory {
+    private term: Terminal
+    public constructor() {
+        this.term = termKit.terminal
+    }
+
+    public Widget<T extends WidgetType>(
+        type: T,
+        options: FactoryOptions<T>
+    ): WidgetRegistry[T] {
+        const Class = widgetRegistry[type]
+
+        //@ts-ignore
+        const instance = new Class({
+            ...options,
+            term: this.term,
+            eventContract: contractRegistry[type] as any,
+        })
+
+        //@ts-ignore
+        return instance
+    }
+}

package/src/workspace/button.types.ts

@@ -0,0 +1,19 @@
+import { BaseWidget } from './widgets.types.js'
+
+export const buttonEventContract = {
+    eventSignatures: {
+        click: {},
+    },
+}
+
+export type ButtonEventContract = typeof buttonEventContract
+
+export interface ButtonWidgetOptions {
+    text?: string
+}
+
+export interface ButtonWidget extends BaseWidget<ButtonEventContract> {
+    readonly type: 'button'
+    getText(): string
+    setText(content: string): void
+}

package/src/workspace/duration.utility.ts

@@ -0,0 +1,34 @@
+const durationUtil = {
+    msToFriendly(duration: number): string {
+        let milliseconds = duration % 1000,
+            seconds = Math.floor((duration / 1000) % 60),
+            minutes = Math.floor((duration / (1000 * 60)) % 60),
+            hours = Math.floor((duration / (1000 * 60 * 60)) % 24)
+
+        let durationStr = ''
+
+        if (hours > 0) {
+            durationStr += `${hours}h `
+        }
+
+        if (hours > 0 || minutes > 0) {
+            durationStr += `${minutes}m `
+        }
+
+        if (durationStr.length > 0 || seconds > 0) {
+            durationStr += `${seconds}s `
+        }
+
+        if (hours === 0 && minutes === 0) {
+            if (seconds > 0) {
+                durationStr = `${seconds}.${milliseconds}s`
+            } else {
+                durationStr += `${milliseconds}ms`
+            }
+        }
+
+        return durationStr.trim()
+    },
+}
+
+export default durationUtil

package/src/workspace/factory.types.ts

@@ -0,0 +1,101 @@
+import TKButtonWidget from './TKButtonWidget.js'
+import TkInputWidget from './TkInputWidget.js'
+import TkLayoutCellWidget from './TkLayoutCellWidget.js'
+import TkLayoutWidget from './TkLayoutWidget.js'
+import TkMenuBarWidget from './TkMenuBarWidget.js'
+import TkPopupWidget from './TkPopupWidget.js'
+import TkProgressBarWidget from './TkProgressBarWidget.js'
+import TkTextWidget from './TkTextWidget.js'
+import TkWindowWidget from './TkWindowWidget.js'
+import {
+    buttonEventContract,
+    ButtonWidget,
+    ButtonWidgetOptions,
+} from './button.types.js'
+import {
+    inputEventContract,
+    InputWidget,
+    InputWidgetOptions,
+} from './input.types.js'
+import {
+    LayoutWidgetOptions,
+    LayoutWidget,
+    LayoutCellWidgetOptions,
+    LayoutCellWidget,
+} from './layout.types.js'
+import {
+    MenuBarWidgetOptions,
+    MenuBarWidget,
+    menuBarEventContract,
+} from './menuBar.types.js'
+import { PopupWidget, PopupWidgetOptions } from './popup.types.js'
+import {
+    ProgressBarWidgetOptions,
+    ProgressBarWidget,
+} from './progressBar.types.js'
+import {
+    TextWidgetOptions,
+    TextWidget,
+    textEventContract,
+} from './text.types.js'
+import { UniversalWidgetOptions } from './widgets.types.js'
+import {
+    WindowWidgetOptions,
+    WindowWidget,
+    windowEventContract,
+} from './window.types.js'
+
+export type WidgetType = keyof WidgetRegistry
+
+export type Widget<T extends WidgetType = WidgetType> = WidgetRegistry[T]
+
+export type FactoryOptions<T extends WidgetType> = UniversalWidgetOptions &
+    OptionsMap[T]
+
+interface OptionsMap {
+    text: TextWidgetOptions
+    window: WindowWidgetOptions
+    layout: LayoutWidgetOptions
+    layoutCell: LayoutCellWidgetOptions
+    progressBar: ProgressBarWidgetOptions
+    menuBar: MenuBarWidgetOptions
+    popup: PopupWidgetOptions
+    button: ButtonWidgetOptions
+    input: InputWidgetOptions
+}
+
+export interface WidgetRegistry {
+    text: TextWidget
+    window: WindowWidget
+    layout: LayoutWidget
+    layoutCell: LayoutCellWidget
+    progressBar: ProgressBarWidget
+    menuBar: MenuBarWidget
+    popup: PopupWidget
+    button: ButtonWidget
+    input: InputWidget
+}
+
+export const widgetRegistry = {
+    window: TkWindowWidget,
+    text: TkTextWidget,
+    layout: TkLayoutWidget,
+    layoutCell: TkLayoutCellWidget,
+    progressBar: TkProgressBarWidget,
+    menuBar: TkMenuBarWidget,
+    popup: TkPopupWidget,
+    button: TKButtonWidget,
+    input: TkInputWidget,
+}
+
+export const contractRegistry = {
+    window: windowEventContract,
+    text: textEventContract,
+    layout: null,
+    layoutCell: null,
+    progressBar: null,
+    menuBar: menuBarEventContract,
+    popup: null,
+    button: buttonEventContract,
+    input: inputEventContract,
+}

package/src/workspace/input.types.ts

@@ -0,0 +1,22 @@
+import { BaseWidget } from './widgets.types.js'
+
+export const inputEventContract = {
+    eventSignatures: {
+        submit: {},
+        cancel: {},
+    },
+}
+
+export type InputEventContract = typeof inputEventContract
+
+export interface InputWidgetOptions {
+    value?: string
+    label?: string
+    placeholder?: string
+}
+
+export interface InputWidget extends BaseWidget<InputEventContract> {
+    readonly type: 'input'
+    getValue(): string | undefined
+    setValue(value: string): void
+}