@neurodevs/node-tdd 1.0.5 → 1.0.7

package/src/workspace/TkMenuBarWidget.ts

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

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

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

@@ -1,167 +0,0 @@
-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]
-
-        this.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,
-        })
-
-        if (this.text.scrollable) {
-            this.text.scrollTo(null, this.text.scrollY)
-        } else {
-            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 scrollToTop() {
-        this.text.scrollTo(null, 0)
-    }
-
-    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

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

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

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

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

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

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