Utils

if (import.meta.path === Bun.main) {
	// this script is being directly executed
} else {
	// this file is being imported from another script
}

console.log('hello');
await Bun.sleep(1000);
console.log('hello one second later!');

const oneSecondInFuture = new Date(Date.now() + 1000);

console.log('hello');
await Bun.sleep(oneSecondInFuture);
console.log('hello one second later!');

console.log('hello');
Bun.sleepSync(1000); // blocks thread for one second
console.log('hello one second later!');

const ls = Bun.which('ls');
console.log(ls); // "/usr/bin/ls"

const ls = Bun.which('ls', {
	PATH: '/usr/local/bin:/usr/bin:/bin',
});
console.log(ls); // "/usr/bin/ls"

const ls = Bun.which('ls', {
	cwd: '/tmp',
	PATH: '',
});

console.log(ls); // null

import {randomUUIDv7} from 'bun';

const id = randomUUIDv7();
// => "0192ce11-26d5-7dc3-9305-1426de888c5a"

namespace Bun {
	function randomUUIDv7(
		encoding?: 'hex' | 'base64' | 'base64url' = 'hex',
		timestamp?: number = Date.now(),
	): string;
	/**
	 * If you pass "buffer", you get a 16-byte buffer instead of a string.
	 */
	function randomUUIDv7(encoding: 'buffer', timestamp?: number = Date.now()): Buffer;

	// If you only pass a timestamp, you get a hex string
	function randomUUIDv7(timestamp?: number = Date.now()): string;
}

import {peek} from 'bun';

const promise = Promise.resolve('hi');

// no await!
const result = peek(promise);
console.log(result); // "hi"

import {peek} from 'bun';
import {expect, test} from 'bun:test';

test('peek', () => {
	const promise = Promise.resolve(true);

	// no await necessary!
	expect(peek(promise)).toBe(true);

	// if we peek again, it returns the same value
	const again = peek(promise);
	expect(again).toBe(true);

	// if we peek a non-promise, it returns the value
	const value = peek(42);
	expect(value).toBe(42);

	// if we peek a pending promise, it returns the promise again
	const pending = new Promise(() => {});
	expect(peek(pending)).toBe(pending);

	// If we peek a rejected promise, it:
	// - returns the error
	// - does not mark the promise as handled
	const rejected = Promise.reject(new Error('Successfully tested promise rejection'));
	expect(peek(rejected).message).toBe('Successfully tested promise rejection');
});

import {peek} from 'bun';
import {expect, test} from 'bun:test';

test('peek.status', () => {
	const promise = Promise.resolve(true);
	expect(peek.status(promise)).toBe('fulfilled');

	const pending = new Promise(() => {});
	expect(peek.status(pending)).toBe('pending');

	const rejected = Promise.reject(new Error('oh nooo'));
	expect(peek.status(rejected)).toBe('rejected');
});

const currentFile = import.meta.url;
Bun.openInEditor(currentFile);

Bun.openInEditor(import.meta.url, {
	editor: 'vscode', // or "subl"
	line: 10,
	column: 5,
});

const foo = {a: 1, b: 2, c: {d: 3}};

// true
Bun.deepEquals(foo, {a: 1, b: 2, c: {d: 3}});

// false
Bun.deepEquals(foo, {a: 1, b: 2, c: {d: 4}});

const a = {entries: [1, 2]};
const b = {entries: [1, 2], extra: undefined};

Bun.deepEquals(a, b); // => true
Bun.deepEquals(a, b, true); // => false

// undefined values
Bun.deepEquals({}, {a: undefined}, true); // false

// undefined in arrays
Bun.deepEquals(['asdf'], ['asdf', undefined], true); // false

// sparse arrays
Bun.deepEquals([, 1], [undefined, 1], true); // false

// object literals vs instances w/ same properties
class Foo {
	a = 1;
}
Bun.deepEquals(new Foo(), {a: 1}, true); // false

Bun.stringWidth('hello'); // => 5
Bun.stringWidth('\u001b[31mhello\u001b[0m'); // => 5
Bun.stringWidth('\u001b[31mhello\u001b[0m', {countAnsiEscapeCodes: true}); // => 12

❯ bun string-width.mjs
cpu: 13th Gen Intel(R) Core(TM) i9-13900
runtime: bun 1.0.29 (x64-linux)

benchmark                                          time (avg)             (min … max)       p75       p99      p995
------------------------------------------------------------------------------------- -----------------------------
Bun.stringWidth     500 chars ascii              37.09 ns/iter   (36.77 ns … 41.11 ns)  37.07 ns  38.84 ns  38.99 ns

❯ node string-width.mjs

benchmark                                          time (avg)             (min … max)       p75       p99      p995
------------------------------------------------------------------------------------- -----------------------------
npm/string-width    500 chars ascii             249,710 ns/iter (239,970 ns … 293,180 ns) 250,930 ns  276,700 ns 281,450 ns

const path = Bun.fileURLToPath(new URL('file:///foo/bar.txt'));
console.log(path); // "/foo/bar.txt"

const url = Bun.pathToFileURL('/foo/bar.txt');
console.log(url); // "file:///foo/bar.txt"

const buf = Buffer.from('hello'.repeat(100)); // Buffer extends Uint8Array
const compressed = Bun.gzipSync(buf);

buf; // => Uint8Array(500)
compressed; // => Uint8Array(30)

const buf = Buffer.from('hello'.repeat(100)); // Buffer extends Uint8Array
const compressed = Bun.gzipSync(buf);

const dec = new TextDecoder();
const uncompressed = Bun.gunzipSync(compressed);
dec.decode(uncompressed);
// => "hellohellohello..."

const buf = Buffer.from('hello'.repeat(100));
const compressed = Bun.deflateSync(buf);

buf; // => Buffer(500)
compressed; // => Uint8Array(12)

const buf = Buffer.from('hello'.repeat(100));
const compressed = Bun.deflateSync(buf);

const dec = new TextDecoder();
const decompressed = Bun.inflateSync(compressed);
dec.decode(decompressed);
// => "hellohellohello..."

const buf = Buffer.from('hello'.repeat(100));

// Synchronous
const compressedSync = Bun.zstdCompressSync(buf);
// Asynchronous
const compressedAsync = await Bun.zstdCompress(buf);

// With compression level (1-22, default: 3)
const compressedLevel = Bun.zstdCompressSync(buf, {level: 6});

const buf = Buffer.from('hello'.repeat(100));
const compressed = Bun.zstdCompressSync(buf);

// Synchronous
const decompressedSync = Bun.zstdDecompressSync(compressed);
// Asynchronous
const decompressedAsync = await Bun.zstdDecompress(compressed);

const dec = new TextDecoder();
dec.decode(decompressedSync);
// => "hellohellohello..."

const obj = {foo: 'bar'};
const str = Bun.inspect(obj);
// => '{\nfoo: "bar" \n}'

const arr = new Uint8Array([1, 2, 3]);
const str = Bun.inspect(arr);
// => "Uint8Array(3) [ 1, 2, 3 ]"

class Foo {
	[Bun.inspect.custom]() {
		return 'foo';
	}
}

const foo = new Foo();
console.log(foo); // => "foo"

console.log(
	Bun.inspect.table([
		{a: 1, b: 2, c: 3},
		{a: 4, b: 5, c: 6},
		{a: 7, b: 8, c: 9},
	]),
);
//
// ┌───┬───┬───┬───┐
// │   │ a │ b │ c │
// ├───┼───┼───┼───┤
// │ 0 │ 1 │ 2 │ 3 │
// │ 1 │ 4 │ 5 │ 6 │
// │ 2 │ 7 │ 8 │ 9 │
// └───┴───┴───┴───┘

console.log(
	Bun.inspect.table(
		[
			{a: 1, b: 2, c: 3},
			{a: 4, b: 5, c: 6},
		],
		['a', 'c'],
	),
);
//
// ┌───┬───┬───┐
// │   │ a │ c │
// ├───┼───┼───┤
// │ 0 │ 1 │ 3 │
// │ 1 │ 4 │ 6 │
// └───┴───┴───┘

console.log(
	Bun.inspect.table(
		[
			{a: 1, b: 2, c: 3},
			{a: 4, b: 5, c: 6},
		],
		{
			colors: true,
		},
	),
);

Bun.nanoseconds();
// => 7288958

const stream = (await fetch('https://bun.com')).body;
stream; // => ReadableStream

await Bun.readableStreamToArrayBuffer(stream);
// => ArrayBuffer

await Bun.readableStreamToBytes(stream);
// => Uint8Array

await Bun.readableStreamToBlob(stream);
// => Blob

await Bun.readableStreamToJSON(stream);
// => object

await Bun.readableStreamToText(stream);
// => string

// returns all chunks as an array
await Bun.readableStreamToArray(stream);
// => unknown[]

// returns all chunks as a FormData object (encoded as x-www-form-urlencoded)
await Bun.readableStreamToFormData(stream);

// returns all chunks as a FormData object (encoded as multipart/form-data)
await Bun.readableStreamToFormData(stream, multipartFormBoundary);

Bun.resolveSync('./foo.ts', '/path/to/project');
// => "/path/to/project/foo.ts"

Bun.resolveSync('zod', '/path/to/project');
// => "/path/to/project/node_modules/zod/index.ts"

Bun.resolveSync('./foo.ts', process.cwd());
Bun.resolveSync('./foo.ts', '/path/to/project');

Bun.resolveSync('./foo.ts', import.meta.dir);

const coloredText = '\u001b[31mHello\u001b[0m \u001b[32mWorld\u001b[0m';
const plainText = Bun.stripANSI(coloredText);
console.log(plainText); // => "Hello World"

// Works with various ANSI codes
const formatted = '\u001b[1m\u001b[4mBold and underlined\u001b[0m';
console.log(Bun.stripANSI(formatted)); // => "Bold and underlined"

import {serialize, deserialize} from 'bun:jsc';

const buf = serialize({foo: 'bar'});
const obj = deserialize(buf);
console.log(obj); // => { foo: "bar" }

import {estimateShallowMemoryUsageOf} from 'bun:jsc';

const obj = {foo: 'bar'};
const usage = estimateShallowMemoryUsageOf(obj);
console.log(usage); // => 16

const buffer = Buffer.alloc(1024 * 1024);
estimateShallowMemoryUsageOf(buffer);
// => 1048624

const req = new Request('https://bun.com');
estimateShallowMemoryUsageOf(req);
// => 167

const array = Array(1024).fill({a: 1});
// Arrays are usually not stored contiguously in memory, so this will not return a useful value (which isn't a bug).
estimateShallowMemoryUsageOf(array);
// => 16