bun-types 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-types",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "license": "MIT",
   "description": "Type definitions for Bun, an incredibly fast JavaScript runtime",
   "types": "types.d.ts",

package/types.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bun 1.0.21
+// Type definitions for bun 1.0.23
 // Project: https://github.com/oven-sh/bun
 // Definitions by: Jarred Sumner <https://github.com/Jarred-Sumner>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -597,6 +597,12 @@ interface ImportMeta {
    * ```
    */
   readonly main: boolean;
+
+  /** Alias of `import.meta.dir`. Exists for Node.js compatibility */
+  readonly dirname: string;
+
+  /** Alias of `import.meta.path`. Exists for Node.js compatibility */
+  readonly filename: string;
 }
 
 /**
@@ -707,7 +713,7 @@ declare namespace Bun {
      * but the values will be available on the global `Bun.argv` as if they
      * were passed as CLI options to the script.
      */
-    // argv?: any[] | undefined;
+    argv?: any[] | undefined;
 
     /** If `true` and the first argument is a string, interpret the first argument to the constructor as a script that is executed once the worker is online. */
     // eval?: boolean | undefined;
@@ -717,7 +723,7 @@ declare namespace Bun {
      */
     env?:
       | Record<string, string>
-      | typeof import("node:worker_threads")["SHARE_ENV"]
+      | (typeof import("node:worker_threads"))["SHARE_ENV"]
       | undefined;
 
     /**
@@ -3555,8 +3561,8 @@ declare module "bun:ffi" {
   type ToFFIType<T extends FFITypeOrString> = T extends FFIType
     ? T
     : T extends string
-    ? FFITypeStringToType[T]
-    : never;
+      ? FFITypeStringToType[T]
+      : never;
 
   // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
   type _Narrow<T, U> = [U] extends [T] ? U : Extract<T, U>;
@@ -3576,9 +3582,9 @@ declare module "bun:ffi" {
       ...args: Fns[K]["args"] extends infer A extends readonly FFITypeOrString[]
         ? { [L in keyof A]: FFITypeToArgsType[ToFFIType<A[L]>] }
         : // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
-        [unknown] extends [Fns[K]["args"]]
-        ? []
-        : never
+          [unknown] extends [Fns[K]["args"]]
+          ? []
+          : never
     ) => // eslint-disable-next-line @definitelytyped/no-single-element-tuple-type
     [unknown] extends [Fns[K]["returns"]]
       ? undefined
@@ -8877,8 +8883,8 @@ declare module "bun" {
     type ReadableToIO<X extends Readable> = X extends "pipe" | undefined
       ? ReadableStream<Uint8Array>
       : X extends BunFile | ArrayBufferView | number
-      ? number
-      : undefined;
+        ? number
+        : undefined;
 
     type ReadableToSyncIO<X extends Readable> = X extends "pipe" | undefined
       ? Buffer
@@ -8889,8 +8895,8 @@ declare module "bun" {
     type WritableToIO<X extends Writable> = X extends "pipe"
       ? FileSink
       : X extends BunFile | ArrayBufferView | Blob | Request | Response | number
-      ? number
-      : undefined;
+        ? number
+        : undefined;
   }
 
   interface ResourceUsage {
@@ -10704,6 +10710,31 @@ declare module "bun:test" {
      * @param expected the expected value
      */
     toContainKey(expected: unknown): void;
+    /**
+     * Asserts that an `object` contains at least one of the provided keys.
+     * Asserts that an `object` contains all the provided keys.
+     *
+     * The value must be an object
+     *
+     * @example
+     * expect({ a: 'hello', b: 'world' }).toContainAnyKeys(['a']);
+     * expect({ a: 'hello', b: 'world' }).toContainAnyKeys(['b']);
+     * expect({ a: 'hello', b: 'world' }).toContainAnyKeys(['b', 'c']);
+     * expect({ a: 'hello', b: 'world' }).not.toContainAnyKeys(['c']);
+     *
+     * @param expected the expected value
+     */
+    toContainAnyKeys(expected: unknown): void;
+
+    /**
+     * Asserts that an `object` contains all the provided keys.
+     * expect({ a: 'foo', b: 'bar', c: 'baz' }).toContainKeys(['a', 'b']);
+     * expect({ a: 'foo', b: 'bar', c: 'baz' }).toContainKeys(['a', 'b', 'c']);
+     * expect({ a: 'foo', b: 'bar', c: 'baz' }).not.toContainKeys(['a', 'b', 'e']);
+     *
+     * @param expected the expected value
+     */
+    toContainKeys(expected: unknown): void;
     /**
      * Asserts that a value contains and equals what is expected.
      *
@@ -10934,6 +10965,14 @@ declare module "bun:test" {
      * expect(new Set()).toBeEmpty();
      */
     toBeEmpty(): void;
+    /**
+     * Asserts that a value is an empty `object`.
+     *
+     * @example
+     * expect({}).toBeEmptyObject();
+     * expect({ a: 'hello' }).not.toBeEmptyObject();
+     */
+    toBeEmptyObject(): void;
     /**
      * Asserts that a value is `null` or `undefined`.
      *
@@ -11639,8 +11678,8 @@ declare namespace JestMock {
   export type Spied<T extends ClassLike | FunctionLike> = T extends ClassLike
     ? SpiedClass<T>
     : T extends FunctionLike
-    ? SpiedFunction<T>
-    : never;
+      ? SpiedFunction<T>
+      : never;
 
   export type SpiedClass<T extends ClassLike = UnknownClass> = MockInstance<
     (...args: ConstructorParameters<T>) => InstanceType<T>
@@ -11681,8 +11720,8 @@ declare namespace JestMock {
     ): A extends "get"
       ? SpiedGetter<V>
       : A extends "set"
-      ? SpiedSetter<V>
-      : never;
+        ? SpiedSetter<V>
+        : never;
     <
       T_1 extends object,
       K_5 extends