fix types

Author: severo

packages/utils/src/dataframe.ts

@@ -8,12 +8,12 @@ type WrappedPromise<T> = Promise<T> & {
  * The promise must be wrapped with `wrapPromise` so that HighTable can render
  * the state synchronously.
  */
-export type AsyncRow = Record<string, WrappedPromise<any>>
+export type AsyncRow = Record<string, WrappedPromise<unknown>>
 
 /**
  * A row where each cell is a resolved value.
  */
-export type Row = Record<string, any>
+export type Row = Record<string, unknown>
 
 /**
  * Streamable row data
@@ -26,8 +26,8 @@ export interface DataFrame {
   sortable?: boolean
 }
 
-export function resolvableRow(header: string[]): { [key: string]: ResolvablePromise<any> } {
-  return Object.fromEntries(header.map(key => [key, resolvablePromise<any>()]))
+export function resolvableRow(header: string[]): Record<string, ResolvablePromise<unknown>> {
+  return Object.fromEntries(header.map(key => [key, resolvablePromise<unknown>()]))
 }
 
 /**
@@ -38,7 +38,7 @@ export function resolvableRow(header: string[]): { [key: string]: ResolvableProm
 export function asyncRows(rows: AsyncRow[] | Promise<Row[]>, numRows: number, header: string[]): AsyncRow[] {
   if (Array.isArray(rows)) return rows
   // Make grid of resolvable promises
-  const wrapped = new Array(numRows).fill(null).map(_ => resolvableRow(header))
+  const wrapped = new Array(numRows).fill(null).map(() => resolvableRow(header))
   rows.then(rows => {
     if (rows.length !== numRows) {
       console.warn(`Expected ${numRows} rows, got ${rows.length}`)
@@ -49,11 +49,12 @@ export function asyncRows(rows: AsyncRow[] | Promise<Row[]>, numRows: number, he
         wrapped[i][key].resolve(row[key])
       }
     }
-  }).catch(error => {
+  }).catch((error: unknown) => {
+    const rejected = error instanceof Error ? error : new Error(String(error))
     // Reject all promises on error
     for (let i = 0; i < numRows; i++) {
       for (const key of header) {
-        wrapped[i][key].reject(error)
+        wrapped[i][key].reject(rejected)
       }
     }
   })
@@ -71,9 +72,9 @@ export function wrapPromise<T>(promise: Promise<T> | T): WrappedPromise<T> {
   const wrapped: WrappedPromise<T> = promise.then(resolved => {
     wrapped.resolved = resolved
     return resolved
-  }).catch(rejected => {
-    wrapped.rejected = rejected
-    throw rejected
+  }).catch((error: unknown) => {
+    wrapped.rejected = error instanceof Error ? error : new Error(String(error))
+    throw error
   })
   return wrapped
 }
@@ -105,7 +106,7 @@ export function resolvablePromise<T>(): ResolvablePromise<T> {
 export function sortableDataFrame(data: DataFrame): DataFrame {
   if (data.sortable) return data // already sortable
   // Fetch all rows and add __index__ column
-  let all: Promise<Row[]>
+  let all: Promise<Row[]> | undefined
   return {
     ...data,
     rows(start: number, end: number, orderBy?: string): AsyncRow[] | Promise<Row[]> {

packages/utils/src/index.ts

@@ -5,5 +5,5 @@ export type { FileKey, FolderKey, ParsedKey, UrlKey } from './key.js'
 export { parquetDataFrame } from './tableProvider.js'
 export { asyncBufferFrom, cn } from './utils.js'
 export { parquetQueryWorker } from './workers/parquetWorkerClient.js'
-export type { AsyncBufferFrom, Row } from './workers/types.js'
+export type { AsyncBufferFrom } from './workers/types.js'
 

packages/utils/src/workers/types.ts

@@ -1,4 +1,5 @@
 import { ColumnData, FileMetaData, ParquetReadOptions } from 'hyparquet'
+import type { Row } from '../dataframe.js'
 
 // Serializable constructors for AsyncBuffers
 interface AsyncBufferFromFile {
@@ -17,8 +18,6 @@ export interface ParquetReadWorkerOptions extends Omit<ParquetReadOptions, 'file
   orderBy?: string
   sortIndex?: boolean
 }
-// Row is defined in hightable, but not exported + we change any to unknown
-export type Row = Record<string, unknown> ;
 
 interface Message {
   queryId: number

packages/utils/test/dataframe.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect, it } from 'vitest'
 import {
-  DataFrame, Row, arrayDataFrame, awaitRows, resolvablePromise, sortableDataFrame, wrapPromise,
+  AsyncRow,
+  DataFrame,
+  arrayDataFrame, awaitRows, resolvablePromise, sortableDataFrame, wrapPromise,
 } from '../src/dataframe.js'
 
-function wrapObject(obj: Record<string, any>): Row {
+function wrapObject(obj: Record<string, unknown>): AsyncRow {
   return Object.fromEntries(
-    Object.entries(obj).map(([key, value]) => [key, wrapPromise(value)])
+    Object.entries(obj).map(([key, value]) => [key, wrapPromise(value)]),
   )
 }
 
@@ -41,7 +43,7 @@ describe('sortableDataFrame', () => {
   const dataFrame: DataFrame = {
     header: ['id', 'name', 'age'],
     numRows: data.length,
-    rows(start: number, end: number): Row[] {
+    rows(start: number, end: number): AsyncRow[] {
       // Return the slice of data between start and end indices
       return data.slice(start, end).map(wrapObject)
     },
@@ -110,11 +112,12 @@ describe('arrayDataFrame', () => {
     expect(df.numRows).toBe(3)
   })
 
-  it('should handle empty data array', () => {
+  it('should handle empty data array', async () => {
     const df = arrayDataFrame([])
     expect(df.header).toEqual([])
     expect(df.numRows).toBe(0)
-    expect(df.rows(0, 1)).resolves.toEqual([])
+    const rows = await df.rows(0, 1)
+    expect(rows).toEqual([])
   })
 
   it('should return correct rows for given range', async () => {