revert: reset non-billing files back to main

Author: brandonkachen

cli/src/components/clickable.tsx

@@ -2,8 +2,20 @@ import React, { cloneElement, isValidElement, memo } from 'react'
 import type { ReactElement, ReactNode } from 'react'
 
 /**
- * Makes all `<text>` and `<span>` children non-selectable.
- * Use for interactive elements where text selection during clicks is undesirable.
+ * Makes all text content within a React node tree non-selectable.
+ *
+ * This is important for interactive elements (buttons, clickable boxes) because
+ * text inside them should not be selectable when the user clicks - it creates
+ * a poor UX where text gets highlighted during interactions.
+ *
+ * Handles both `<text>` and `<span>` OpenTUI elements by adding `selectable={false}`.
+ *
+ * @example
+ * ```tsx
+ * // Use this when building custom interactive components
+ * const processedChildren = makeTextUnselectable(children)
+ * return <box onMouseDown={handleClick}>{processedChildren}</box>
+ * ```
  */
 export function makeTextUnselectable(node: ReactNode): ReactNode {
   if (node === null || node === undefined || typeof node === 'boolean') return node
@@ -44,8 +56,34 @@ interface ClickableProps {
 }
 
 /**
- * Wrapper for interactive areas. Makes text non-selectable automatically.
- * Use `as="text"` for inline clickable text, default is `as="box"`.
+ * A wrapper component for any interactive/clickable area in the CLI.
+ *
+ * **Why use this instead of raw `<box>` or `<text>` with mouse handlers?**
+ *
+ * This component automatically makes all text content non-selectable, which is
+ * essential for good UX - users shouldn't accidentally select text when clicking
+ * interactive elements.
+ *
+ * **The `as` prop:**
+ * - `as="box"` (default) - Renders a `<box>` element for layout containers
+ * - `as="text"` - Renders a `<text>` element for inline clickable text
+ *
+ * **When to use `Clickable` vs `Button`:**
+ * - Use `Button` for actual button-like interactions (has click-on-mouseup logic)
+ * - Use `Clickable` for simpler interactive areas where you need direct mouse event control
+ *
+ * @example
+ * ```tsx
+ * // Default: renders <box>
+ * <Clickable onMouseDown={handleClick}>
+ *   <text>Click me</text>
+ * </Clickable>
+ *
+ * // For inline text: renders <text>
+ * <Clickable as="text" onMouseDown={handleCopy}>
+ *   <span>⎘ copy</span>
+ * </Clickable>
+ * ```
  */
 export const Clickable = memo(function Clickable({
   as = 'box',

common/src/util/__tests__/promise.test.ts

@@ -299,7 +299,7 @@ describe('withRetry', () => {
 
       const result = await withRetry(operation, {
         maxRetries: 3,
-        retryIf: (error) => (error as { code?: string })?.code === 'RETRY_ME',
+        retryIf: (error) => error?.code === 'RETRY_ME',
       })
 
       expect(result).toBe('success')
@@ -315,7 +315,7 @@ describe('withRetry', () => {
       await expect(
         withRetry(operation, {
           maxRetries: 3,
-          retryIf: (err) => (err as { code?: string })?.code === 'RETRY_ME',
+          retryIf: (err) => err?.code === 'RETRY_ME',
         }),
       ).rejects.toMatchObject({ code: 'DO_NOT_RETRY' })
 

common/src/util/__tests__/split-data.test.ts

@@ -21,7 +21,7 @@ describe('splitData - base cases', () => {
   it('splits short strings when maxChunkSize is small', () => {
     const input = { msg: 'abcdef'.repeat(10) } // 60 chars
 
-    const chunks = splitData({ data: input, maxChunkSize: 30 }) as { msg?: string }[]
+    const chunks = splitData({ data: input, maxChunkSize: 30 })
 
     expect(chunks.length).toBeGreaterThan(1)
     const combined = chunks.map((c) => c.msg).join('')
@@ -32,7 +32,7 @@ describe('splitData - base cases', () => {
   it('splits deeply nested strings with small maxChunkSize', () => {
     const input = { a: { b: { c: 'xyz123'.repeat(10) } } }
 
-    const chunks = splitData({ data: input, maxChunkSize: 50 }) as { a?: { b?: { c?: string } } }[]
+    const chunks = splitData({ data: input, maxChunkSize: 50 })
 
     expect(chunks.length).toBeGreaterThan(1)
     const reconstructed = chunks.map((c) => c.a?.b?.c ?? '').join('')
@@ -60,7 +60,7 @@ describe('splitData - base cases', () => {
       str: 'hello world'.repeat(5),
     }
 
-    const chunks = splitData({ data: input, maxChunkSize: 50 }) as { flag?: boolean; num?: number; str?: string }[]
+    const chunks = splitData({ data: input, maxChunkSize: 50 })
 
     expect(chunks.length).toBeGreaterThan(1)
     expect(chunks.every((c) => JSON.stringify(c).length <= 50)).toBe(true)
@@ -74,7 +74,7 @@ describe('splitData - base cases', () => {
       a: 'A'.repeat(20),
       b: 'B'.repeat(20),
     }
-    const chunks = splitData({ data: input, maxChunkSize: 30 }) as { a?: string; b?: string }[]
+    const chunks = splitData({ data: input, maxChunkSize: 30 })
 
     expect(chunks.length).toBeGreaterThan(1)
 
@@ -89,7 +89,7 @@ describe('splitData - base cases', () => {
 describe('splitData - array and string-specific splitting', () => {
   it('splits long strings into smaller string chunks', () => {
     const input = '12345678901234567890'
-    const chunks = splitData({ data: input, maxChunkSize: 5 }) as string[]
+    const chunks = splitData({ data: input, maxChunkSize: 5 })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -121,7 +121,7 @@ describe('splitData - array and string-specific splitting', () => {
       b: 'bbb'.repeat(10),
     }
     const maxSize = 40
-    const chunks = splitData({ data: input, maxChunkSize: maxSize }) as { a?: string; b?: string }[]
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {
@@ -162,7 +162,7 @@ describe('splitData - array and string-specific splitting', () => {
     ]
     const maxSize = 30
 
-    const chunks = splitData({ data: input, maxChunkSize: maxSize }) as { msg?: string; val?: number }[][]
+    const chunks = splitData({ data: input, maxChunkSize: maxSize })
 
     expect(Array.isArray(chunks)).toBe(true)
     chunks.forEach((chunk) => {

common/src/util/error.ts

@@ -33,29 +33,29 @@ export function success<T>(value: T): Success<T> {
   }
 }
 
-export function failure(error: unknown): Failure<ErrorObject> {
+export function failure(error: any): Failure<ErrorObject> {
   return {
     success: false,
     error: getErrorObject(error),
   }
 }
 
 export function getErrorObject(
-  error: unknown,
+  error: any,
   options: { includeRawError?: boolean } = {},
 ): ErrorObject {
   if (error instanceof Error) {
-    const errorWithExtras = error as { status?: unknown; statusCode?: unknown; code?: unknown }
+    const anyError = error as any
     return {
       name: error.name,
       message: error.message,
       stack: error.stack,
-      status: typeof errorWithExtras.status === 'number' ? errorWithExtras.status : undefined,
+      status: typeof anyError.status === 'number' ? anyError.status : undefined,
       statusCode:
-        typeof errorWithExtras.statusCode === 'number'
-          ? errorWithExtras.statusCode
+        typeof anyError.statusCode === 'number'
+          ? anyError.statusCode
           : undefined,
-      code: typeof errorWithExtras.code === 'string' ? errorWithExtras.code : undefined,
+      code: typeof anyError.code === 'string' ? anyError.code : undefined,
       rawError: options.includeRawError
         ? JSON.stringify(error, null, 2)
         : undefined,

common/src/util/object.ts

@@ -1,45 +1,41 @@
 import { isEqual, mapValues, union } from 'lodash'
 
-type RemoveUndefined<T extends object> = {
-  [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>
-}
-
 export const removeUndefinedProps = <T extends object>(
   obj: T,
-): RemoveUndefined<T> => {
-  const newObj: Record<string, unknown> = {}
+): {
+  [K in keyof T as T[K] extends undefined ? never : K]: Exclude<T[K], undefined>
+} => {
+  const newObj: any = {}
 
   for (const key of Object.keys(obj)) {
-    const value = obj[key as keyof T]
-    if (value !== undefined) newObj[key] = value
+    if ((obj as any)[key] !== undefined) newObj[key] = (obj as any)[key]
   }
 
-  return newObj as RemoveUndefined<T>
+  return newObj
 }
 
 export const removeNullOrUndefinedProps = <T extends object>(
   obj: T,
   exceptions?: string[],
 ): T => {
-  const newObj: Record<string, unknown> = {}
+  const newObj: any = {}
 
   for (const key of Object.keys(obj)) {
-    const value = obj[key as keyof T]
     if (
-      (value !== undefined && value !== null) ||
+      ((obj as any)[key] !== undefined && (obj as any)[key] !== null) ||
       (exceptions ?? []).includes(key)
     )
-      newObj[key] = value
+      newObj[key] = (obj as any)[key]
   }
-  return newObj as T
+  return newObj
 }
 
 export const addObjects = <T extends { [key: string]: number }>(
   obj1: T,
   obj2: T,
 ) => {
   const keys = union(Object.keys(obj1), Object.keys(obj2))
-  const newObj: Record<string, number> = {}
+  const newObj = {} as any
 
   for (const key of keys) {
     newObj[key] = (obj1[key] ?? 0) + (obj2[key] ?? 0)
@@ -53,7 +49,7 @@ export const subtractObjects = <T extends { [key: string]: number }>(
   obj2: T,
 ) => {
   const keys = union(Object.keys(obj1), Object.keys(obj2))
-  const newObj: Record<string, number> = {}
+  const newObj = {} as any
 
   for (const key of keys) {
     newObj[key] = (obj1[key] ?? 0) - (obj2[key] ?? 0)
@@ -72,19 +68,14 @@ export const hasSignificantDeepChanges = <T extends object>(
   partial: Partial<T>,
   epsilonForNumbers: number,
 ): boolean => {
-  const compareValues = (currValue: unknown, partialValue: unknown): boolean => {
+  const compareValues = (currValue: any, partialValue: any): boolean => {
     if (typeof currValue === 'number' && typeof partialValue === 'number') {
       return Math.abs(currValue - partialValue) > epsilonForNumbers
     }
-    if (
-      typeof currValue === 'object' &&
-      currValue !== null &&
-      typeof partialValue === 'object' &&
-      partialValue !== null
-    ) {
+    if (typeof currValue === 'object' && typeof partialValue === 'object') {
       return hasSignificantDeepChanges(
-        currValue as Record<string, unknown>,
-        partialValue as Partial<Record<string, unknown>>,
+        currValue,
+        partialValue,
         epsilonForNumbers,
       )
     }
@@ -104,7 +95,7 @@ export const hasSignificantDeepChanges = <T extends object>(
 
 export const filterObject = <T extends object>(
   obj: T,
-  predicate: (value: T[keyof T], key: keyof T) => boolean,
+  predicate: (value: any, key: keyof T) => boolean,
 ): { [P in keyof T]: T[P] } => {
   const result = {} as { [P in keyof T]: T[P] }
   for (const key in obj) {

common/src/util/promise.ts

@@ -4,22 +4,19 @@ export async function withRetry<T>(
   operation: () => Promise<T>,
   options: {
     maxRetries?: number
-    retryIf?: (error: unknown) => boolean
-    onRetry?: (error: unknown, attempt: number) => void
+    retryIf?: (error: any) => boolean
+    onRetry?: (error: any, attempt: number) => void
     retryDelayMs?: number
   } = {},
 ): Promise<T> {
   const {
     maxRetries = 3,
-    retryIf = (error) => {
-      const errorObj = error as { type?: string } | null | undefined
-      return errorObj?.type === 'APIConnectionError'
-    },
+    retryIf = (error) => error?.type === 'APIConnectionError',
     onRetry = () => {},
     retryDelayMs = INITIAL_RETRY_DELAY,
   } = options
 
-  let lastError: unknown = null
+  let lastError: any = null
 
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     try {