style: 💄 use interface for types

Author: lrodrigues-newstore

biome.json

@@ -22,16 +22,17 @@
   "linter": {
     "rules": {
       "style": {
+        "noInferrableTypes": "error",
         "noParameterAssign": "error",
+        "noUnusedTemplateLiteral": "error",
+        "noUselessElse": "error",
         "useAsConstAssertion": "error",
+        "useConsistentTypeDefinitions": "error",
         "useDefaultParameterLast": "error",
         "useEnumInitializers": "error",
-        "useSelfClosingElements": "error",
-        "useSingleVarDeclarator": "error",
-        "noUnusedTemplateLiteral": "error",
         "useNumberNamespace": "error",
-        "noInferrableTypes": "error",
-        "noUselessElse": "error"
+        "useSelfClosingElements": "error",
+        "useSingleVarDeclarator": "error"
       }
     }
   }

packages/bloom-filter/src/bloom-filter.ts

@@ -55,7 +55,7 @@ export class BloomFilter<T extends { toString(): string }> {
   }
 }
 
-export type SerialisedBloomFilter = {
+export interface SerialisedBloomFilter {
   readonly size: number
   readonly hashes: number
   readonly seed: number

packages/bloom-filter/src/counting-bloom-filter.ts

@@ -63,7 +63,7 @@ export class CountingBloomFilter<T extends { toString(): string }> {
   }
 }
 
-export type SerialisedCountingBloomFilter = {
+export interface SerialisedCountingBloomFilter {
   readonly size: number
   readonly hashes: number
   readonly seed: number

packages/bloom-search/src/index.ts

@@ -2,10 +2,10 @@ import { range, unique, windowed } from '@pacote/array'
 import { BloomFilter, optimal } from '@pacote/bloom-filter'
 import { memoize } from '@pacote/memoize'
 import type { U64 } from '@pacote/u64'
-import { type XXHash, xxh64 } from '@pacote/xxhash'
+import { xxh64, type XXHash } from '@pacote/xxhash'
 import { findLast } from './array'
 import { entries, keys, pick } from './object'
-import { EXCLUDE, PHRASE, REQUIRE, queryTerms } from './query'
+import { EXCLUDE, PHRASE, queryTerms, REQUIRE } from './query'
 import { countIdf } from './tf-idf'
 
 export type PreprocessFunction<Document, Field extends keyof Document> = (
@@ -23,7 +23,10 @@ export type TokenizerFunction = (token: string, language?: string) => string[]
  * @template Document     The type of document being indexed.
  * @template SummaryField The document keys that can be returned in search results.
  */
-export type IndexedDocument<Document, SummaryField extends keyof Document> = {
+export interface IndexedDocument<
+  Document,
+  SummaryField extends keyof Document,
+> {
   /**
    * Summary fields for the document. These are preserved as-is.
    */
@@ -35,7 +38,7 @@ export type IndexedDocument<Document, SummaryField extends keyof Document> = {
   readonly signatures: Record<number, BloomFilter<string>>
 }
 
-export type Index<Document, SummaryField extends keyof Document> = {
+export interface Index<Document, SummaryField extends keyof Document> {
   version: number
   documents: Record<string, IndexedDocument<Document, SummaryField>>
 }
@@ -47,11 +50,11 @@ export type Index<Document, SummaryField extends keyof Document> = {
  * @template SummaryField The document keys that can be returned in search results.
  * @template IndexField   The document keys to be indexed for searching.
  */
-export type Options<
+export interface Options<
   Document extends Record<string, unknown>,
   SummaryField extends keyof Document = keyof Document,
   IndexField extends keyof Document = keyof Document,
-> = {
+> {
   /**
    * The fields to index, provided as an array or as a record of field keys and
    * weight values.
@@ -117,13 +120,13 @@ export type Options<
   tokenizer?: TokenizerFunction
 }
 
-type SearchTokens = {
+interface SearchTokens {
   required: string[]
   included: string[]
   excluded: string[]
 }
 
-type Result<Document, SummaryField extends keyof Document> = {
+interface Result<Document, SummaryField extends keyof Document> {
   readonly summary: Pick<Document, SummaryField>
   readonly score: number
 }

packages/emitter/src/index.ts

@@ -1,5 +1,7 @@
 interface Events {
-  [name: string]: (...args: unknown[]) => void
+  // Allow event maps with specific parameter lists to satisfy the constraint.
+  // biome-ignore lint/suspicious/noExplicitAny: any argument
+  [name: string]: (...args: any[]) => void
 }
 
 interface Emitter<E extends Events> {

packages/emitter/test/index.spec.ts

@@ -1,3 +1,5 @@
+/** biome-ignore-all lint/style/useConsistentTypeDefinitions: tests require type */
+
 import { expect, test, vi } from 'vitest'
 import { createEmitter } from '../src'
 

packages/ffetch/src/index.ts

@@ -1,17 +1,6 @@
 import { pipe } from 'fp-ts/function'
-import {
-  type TaskEither,
-  chain,
-  chainW,
-  left,
-  tryCatch,
-} from 'fp-ts/lib/TaskEither'
-import {
-  type FetchError,
-  NetworkError,
-  ParserError,
-  StatusError,
-} from './errors'
+import { chain, chainW, left, type TaskEither, tryCatch } from 'fp-ts/lib/TaskEither'
+import { type FetchError, NetworkError, ParserError, StatusError } from './errors'
 
 type Fetch<E, T> = (
   input: Request | string,

packages/immutable/test/immutable.spec.ts

@@ -4,7 +4,9 @@ import type { Immutable } from '../src/index'
 describe('Immutable', () => {
   it('marks nested object properties as readonly', () => {
     type Actual = Immutable<{ foo: { bar: string } }>
-    type Expected = { readonly foo: { readonly bar: string } }
+    interface Expected {
+      readonly foo: { readonly bar: string }
+    }
     expectTypeOf<Actual>().toEqualTypeOf<Expected>()
   })
 

packages/jest-either/src/toMatchRight.ts

@@ -6,7 +6,7 @@ import {
   isAsymmetricMatcher,
   matchObject,
   matchString,
-  rightPredicate
+  rightPredicate,
 } from './shared/predicates'
 import { printReceivedRight } from './shared/print'
 import type { MatcherResult } from './shared/types'

packages/linked-list/src/core.ts

@@ -1,12 +1,16 @@
 import { None, type Option, Some } from '@pacote/option'
 
-type Empty = undefined
-type Cons<T> = readonly [value: T, next: Cons<T> | Empty]
+export type Empty = undefined
+export type Cons<T> = readonly [value: T, next: Cons<T> | Empty]
 export type LinkedList<T> = Cons<T> | Empty
 
-type CallbackArgs<T> = [value: T, index: number, collection: LinkedList<T>]
-type MapCallback<T, R> = (...args: CallbackArgs<T>) => R
-type ReduceCallback<T, R> = (acc: R, ...args: CallbackArgs<T>) => R
+export type CallbackArgs<T> = [
+  value: T,
+  index: number,
+  collection: LinkedList<T>,
+]
+export type MapCallback<T, R> = (...args: CallbackArgs<T>) => R
+export type ReduceCallback<T, R> = (acc: R, ...args: CallbackArgs<T>) => R
 export type PredicateFunction<T> = MapCallback<T, boolean>
 
 export function car<T>(cons: Cons<T>): T {