@neurodevs/node-tdd 1.0.6 → 1.0.7

package/src/workspace/keySelectChoices.ts

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

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

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

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

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

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

package/src/workspace/termKit.utility.ts

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

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

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

@@ -1,166 +0,0 @@
-import chokidar from 'chokidar'
-import { spawn } from 'child_process'
-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)
-    },
-    handleOpenTestFile: (filePath: string) => {
-        const fullPath = path.isAbsolute(filePath)
-            ? filePath
-            : path.join(cwd, 'src', '__tests__', filePath)
-        spawn('code', [fullPath], { detached: true, stdio: 'ignore' }).unref()
-    },
-})
-
-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

@@ -1,27 +0,0 @@
-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
-    scrollToTop(): void
-}

package/src/workspace/widget.utilities.ts

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