From 40befd8770e90ef2cb74d65bb1e2ff9911e2a2f7 Mon Sep 17 00:00:00 2001 From: jhmaster <32803471+jhmaster2000@users.noreply.github.com> Date: Thu, 10 Aug 2023 16:17:39 -0300 Subject: Sync bun-polyfills branch (#4081) * bun-polyfills: initial impl. & baseline refactor * move @types/ws dep from root to /test/ * bun-types: remove ReadableStream.forEach method (this does not exist, probably added by mistake) * bun-polyfills: remove extraneous stream utils * bun-polyfills: add types syncing file * bun-polyfills: re-arrange global polyfills * bun-polyfills: fix FileBlob streams types again * bun-polyfills: sync all of @types/node * bun-polyfills: typeguard all current polyfills * bun-polyfills: fix import paths * bun-polyfills: switch to wasm impl. of farmhash * bun-polyfills: support default import of bun obj * bun-polyfills: transpiler placeholder file * bun-polyfills: loaderless import.meta polyfill * bun-polyfills: refactor import.meta polyfill * bun-polyfills: repl entrypoint & todo list index * bun-types: Add null to return type of Bun.which * bun-types: match Bun.sha with Bun.hash.SHA512_256 * bun-polyfills: new "repl" package.json script * bun-polyfills: full refactor of toplevel hashes * bun-polyfills: these are fixed * bun-types: NODE_ENV is optional * bun-polyfills: fix Bun.env types * bun-types+polyfills: fix HeapSnapshot.version type * bun-polyfills: fix some web streams type conflicts * bun-polyfills: update internal FileBlob.slice * bun-polyfills: fix subproc stdin conversions * bun-polyfills: better internal fileblob types * bun-polyfills: try to sync global performance type * bun-polyfills: working zig wasm polyfills setup * bun-polyfills: update scripts * bun-polyfills: fix wasm file location resolution * bun-polyfills: goodbye farmhash (replaced by zig) * bun-polyfills: move all Bun.hash polyfills to zig * bun-polyfills: reimpl. seeding of seeded hashes * bun-polyfills: impl. undocumented murmur32v2 * bun-polyfills: switch zighash from jsdoc to .d.ts * bun-types: partial fix of Hash types * bun-polyfills: documented Hash.murmur32v2 * bun-polyfills: misc updates * bun-polyfills: enable sourcemaps * bun-polyfills: handle empty inputs to hash funcs * bun-types: narrow down hash func types * bun-polyfills: remove unnecessary bigint casts * bun-polyfills: impl. Bun.isMainThread * bun-polyfills: impl. Bun.sleep and fix sleepSync * bun-polyfills: impl. indexOfLine * bun-polyfills: impl. Bun.peek.status * bun-types: fix hashing test --------- Co-authored-by: Jarred Sumner --- packages/bun-polyfills/.gitignore | 172 ++++++++ packages/bun-polyfills/README.md | 9 + packages/bun-polyfills/bun.lockb | Bin 0 -> 27871 bytes packages/bun-polyfills/lib/zighash/index.mjs | 95 ++++ packages/bun-polyfills/lib/zighash/package.json | 10 + packages/bun-polyfills/lib/zighash/src/main.zig | 58 +++ packages/bun-polyfills/lib/zighash/types.d.ts | 25 ++ packages/bun-polyfills/lib/zighash/zighash.wasm | Bin 0 -> 14943 bytes packages/bun-polyfills/package.json | 27 ++ packages/bun-polyfills/src/global/console.ts | 31 ++ packages/bun-polyfills/src/global/importmeta.ts | 34 ++ packages/bun-polyfills/src/global/index.ts | 45 ++ packages/bun-polyfills/src/global/process.ts | 19 + packages/bun-polyfills/src/index.ts | 3 + packages/bun-polyfills/src/modules/bun.ts | 489 +++++++++++++++++++++ .../src/modules/bun/arraybuffersink.ts | 67 +++ packages/bun-polyfills/src/modules/bun/dns.ts | 21 + packages/bun-polyfills/src/modules/bun/fileblob.ts | 195 ++++++++ packages/bun-polyfills/src/modules/bun/filesink.ts | 87 ++++ packages/bun-polyfills/src/modules/bun/hashes.ts | 185 ++++++++ .../bun-polyfills/src/modules/bun/transpiler.ts | 103 +++++ packages/bun-polyfills/src/repl.ts | 29 ++ packages/bun-polyfills/src/types/helpers.d.ts | 13 + packages/bun-polyfills/src/types/md4.d.ts | 72 +++ packages/bun-polyfills/src/types/sync.d.ts | 15 + .../bun-polyfills/src/types/v8heapsnapshot.d.ts | 24 + packages/bun-polyfills/src/utils/errors.ts | 221 ++++++++++ packages/bun-polyfills/src/utils/misc.ts | 36 ++ packages/bun-polyfills/tsconfig.json | 19 + packages/bun-types/bun.d.ts | 43 +- packages/bun-types/globals.d.ts | 4 - packages/bun-types/tests/hashing.test-d.ts | 2 +- 32 files changed, 2127 insertions(+), 26 deletions(-) create mode 100644 packages/bun-polyfills/.gitignore create mode 100644 packages/bun-polyfills/README.md create mode 100755 packages/bun-polyfills/bun.lockb create mode 100644 packages/bun-polyfills/lib/zighash/index.mjs create mode 100644 packages/bun-polyfills/lib/zighash/package.json create mode 100644 packages/bun-polyfills/lib/zighash/src/main.zig create mode 100644 packages/bun-polyfills/lib/zighash/types.d.ts create mode 100755 packages/bun-polyfills/lib/zighash/zighash.wasm create mode 100644 packages/bun-polyfills/package.json create mode 100644 packages/bun-polyfills/src/global/console.ts create mode 100644 packages/bun-polyfills/src/global/importmeta.ts create mode 100644 packages/bun-polyfills/src/global/index.ts create mode 100644 packages/bun-polyfills/src/global/process.ts create mode 100644 packages/bun-polyfills/src/index.ts create mode 100644 packages/bun-polyfills/src/modules/bun.ts create mode 100644 packages/bun-polyfills/src/modules/bun/arraybuffersink.ts create mode 100644 packages/bun-polyfills/src/modules/bun/dns.ts create mode 100644 packages/bun-polyfills/src/modules/bun/fileblob.ts create mode 100644 packages/bun-polyfills/src/modules/bun/filesink.ts create mode 100644 packages/bun-polyfills/src/modules/bun/hashes.ts create mode 100644 packages/bun-polyfills/src/modules/bun/transpiler.ts create mode 100644 packages/bun-polyfills/src/repl.ts create mode 100644 packages/bun-polyfills/src/types/helpers.d.ts create mode 100644 packages/bun-polyfills/src/types/md4.d.ts create mode 100644 packages/bun-polyfills/src/types/sync.d.ts create mode 100644 packages/bun-polyfills/src/types/v8heapsnapshot.d.ts create mode 100644 packages/bun-polyfills/src/utils/errors.ts create mode 100644 packages/bun-polyfills/src/utils/misc.ts create mode 100644 packages/bun-polyfills/tsconfig.json (limited to 'packages') diff --git a/packages/bun-polyfills/.gitignore b/packages/bun-polyfills/.gitignore new file mode 100644 index 000000000..7f4433ab4 --- /dev/null +++ b/packages/bun-polyfills/.gitignore @@ -0,0 +1,172 @@ +# Based on https://raw.githubusercontent.com/github/gitignore/main/Node.gitignore + +# Logs + +logs +_.log +npm-debug.log_ +yarn-debug.log* +yarn-error.log* +lerna-debug.log* +.pnpm-debug.log* + +# Diagnostic reports (https://nodejs.org/api/report.html) + +report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json + +# Runtime data + +pids +_.pid +_.seed +\*.pid.lock + +# Directory for instrumented libs generated by jscoverage/JSCover + +lib-cov + +# Coverage directory used by tools like istanbul + +coverage +\*.lcov + +# nyc test coverage + +.nyc_output + +# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) + +.grunt + +# Bower dependency directory (https://bower.io/) + +bower_components + +# node-waf configuration + +.lock-wscript + +# Dependency directories + +node_modules/ +jspm_packages/ + +# Snowpack dependency directory (https://snowpack.dev/) + +web_modules/ + +# TypeScript cache + +\*.tsbuildinfo + +# Optional npm cache directory + +.npm + +# Optional eslint cache + +.eslintcache + +# Optional stylelint cache + +.stylelintcache + +# Microbundle cache + +.rpt2_cache/ +.rts2_cache_cjs/ +.rts2_cache_es/ +.rts2_cache_umd/ + +# Optional REPL history + +.node_repl_history + +# Output of 'npm pack' + +\*.tgz + +# Yarn Integrity file + +.yarn-integrity + +# dotenv environment variable files + +.env +.env.development.local +.env.test.local +.env.production.local +.env.local + +# parcel-bundler cache (https://parceljs.org/) + +.cache +.parcel-cache + +# Next.js build output + +.next +out + +# Nuxt.js build / generate output + +.nuxt +dist + +# Gatsby files + +.cache/ + +# Comment in the public line in if your project uses Gatsby and not Next.js + +# https://nextjs.org/blog/next-9-1#public-directory-support + +# public + +# vuepress build output + +.vuepress/dist + +# vuepress v2.x temp and cache directory + +.temp +.cache + +# Docusaurus cache and generated files + +.docusaurus + +# Serverless directories + +.serverless/ + +# FuseBox cache + +.fusebox/ + +# DynamoDB Local files + +.dynamodb/ + +# TernJS port file + +.tern-port + +# Stores VSCode versions used for testing VSCode extensions + +.vscode-test + +# yarn v2 + +.yarn/cache +.yarn/unplugged +.yarn/build-state.yml +.yarn/install-state.gz +.pnp.\* + +# Misc + +_* +.old +.vscode +!build diff --git a/packages/bun-polyfills/README.md b/packages/bun-polyfills/README.md new file mode 100644 index 000000000..5d6a70042 --- /dev/null +++ b/packages/bun-polyfills/README.md @@ -0,0 +1,9 @@ +# Bun APIs Polyfills + +Polyfills for Bun's JavaScript runtime APIs for use in environments outside of Bun, such as Node.js or the browser¹. + +¹ **Note:** The current priority is Node.js, browser support will vary per polyfill. + +## Usage + +This is currently a work in progress and is not ready for general use. diff --git a/packages/bun-polyfills/bun.lockb b/packages/bun-polyfills/bun.lockb new file mode 100755 index 000000000..fdc201d28 Binary files /dev/null and b/packages/bun-polyfills/bun.lockb differ diff --git a/packages/bun-polyfills/lib/zighash/index.mjs b/packages/bun-polyfills/lib/zighash/index.mjs new file mode 100644 index 000000000..f92ffb6d0 --- /dev/null +++ b/packages/bun-polyfills/lib/zighash/index.mjs @@ -0,0 +1,95 @@ +// @ts-check +import fs from 'node:fs'; +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; + +const { instance } = /** @type {ZighashInstance} */( + await WebAssembly.instantiate( + fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), 'zighash.wasm')), + { + env: { + /** @param {any} x */ + print(x) { console.log(x); }, + }, + } + ) +); +const exports = instance.exports; +const mem = exports.memory; +const memview = { + get u8() { return new Uint8Array(mem.buffer); }, + get u16() { return new Uint16Array(mem.buffer); }, + get u32() { return new Uint32Array(mem.buffer); }, + get u64() { return new BigUint64Array(mem.buffer); }, + get i8() { return new Int8Array(mem.buffer); }, + get i16() { return new Int16Array(mem.buffer); }, + get i32() { return new Int32Array(mem.buffer); }, + get i64() { return new BigInt64Array(mem.buffer); }, + get f32() { return new Float32Array(mem.buffer); }, + get f64() { return new Float64Array(mem.buffer); }, +}; + +const nullptr = { ptr: -1, size: 0 }; +const encoder = new TextEncoder(); + +const allocBuffer = ( + /** @type {ArrayBufferView | ArrayBuffer | SharedArrayBuffer} */ buf, + /** @type {boolean=} */ nullTerminate = false, +) => { + const size = buf.byteLength + +nullTerminate; + if (size === 0) return nullptr; + const ptr = exports.alloc(size); + if (ptr === -1) throw new Error('WASM memory allocation failed'); + const u8heap = memview.u8; + u8heap.set(new Uint8Array(ArrayBuffer.isView(buf) ? buf.buffer : buf), ptr); + if (nullTerminate) u8heap[ptr + buf.byteLength] = 0; + return { ptr, size }; +}; +const allocString = ( + /** @type {string} */ str, + /** @type {boolean=} */ nullTerminate = true, +) => { + const strbuf = encoder.encode(str); + return allocBuffer(strbuf, nullTerminate); +}; + +/** @type {JSSeededHash64Function} */ +export function wyhash(input = '', seed = 0n) { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return BigInt.asUintN(64, exports.wyhash(ptr, size, seed)); +} +/** @type {JSHash32Function} */ +export function adler32(input = '') { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return exports.adler32(ptr, size) >>> 0; +} +/** @type {JSHash32Function} */ +export function crc32(input = '') { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return exports.crc32(ptr, size) >>> 0; +} +/** @type {JSHash32Function} */ +export function cityhash32(input = '') { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return exports.cityhash32(ptr, size) >>> 0; +} +/** @type {JSSeededHash64Function} */ +export function cityhash64(input = '', seed = 0n) { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return BigInt.asUintN(64, exports.cityhash64(ptr, size, seed)); +} +/** @type {JSSeededHash32Function} */ +export function murmur32v3(input = '', seed = 0) { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return exports.murmur32v3(ptr, size, seed); //! Bun doesn't unsigned-cast this one, likely unintended but for now we'll do the same +} +/** @type {JSSeededHash32Function} */ +export function murmur32v2(input = '', seed = 0) { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return exports.murmur32v2(ptr, size, seed); //! Bun doesn't unsigned-cast this one, likely unintended but for now we'll do the same +} +/** @type {JSSeededHash64Function} */ +export function murmur64v2(input = '', seed = 0n) { + const { ptr, size } = typeof input === 'string' ? allocString(input, false) : allocBuffer(input); + return BigInt.asUintN(64, exports.murmur64v2(ptr, size, seed)); +} diff --git a/packages/bun-polyfills/lib/zighash/package.json b/packages/bun-polyfills/lib/zighash/package.json new file mode 100644 index 000000000..cda5ce887 --- /dev/null +++ b/packages/bun-polyfills/lib/zighash/package.json @@ -0,0 +1,10 @@ +{ + "private": true, + "type": "module", + "name": "zighash-wasm", + "module": "index.mjs", + "scripts": { + "build": "bun run clean && zig build-lib src/main.zig --name zighash -target wasm32-freestanding -dynamic -rdynamic -OReleaseSmall", + "clean": "rm -f *.wasm *.o" + } +} diff --git a/packages/bun-polyfills/lib/zighash/src/main.zig b/packages/bun-polyfills/lib/zighash/src/main.zig new file mode 100644 index 000000000..820557b43 --- /dev/null +++ b/packages/bun-polyfills/lib/zighash/src/main.zig @@ -0,0 +1,58 @@ +const std = @import("std"); + +extern fn print(*const u8) void; + +comptime { + std.debug.assert(@alignOf(u16) >= 2); + std.debug.assert(@alignOf(u32) >= 4); + std.debug.assert(@alignOf(u64) >= 8); + std.debug.assert(@alignOf(i16) >= 2); + std.debug.assert(@alignOf(i32) >= 4); + std.debug.assert(@alignOf(i64) >= 8); +} + +export fn alloc(size: u32) [*]const u8 { + const slice = std.heap.wasm_allocator.alloc(u8, size) catch @panic("wasm failed to allocate memory"); + return slice.ptr; +} + +export fn wyhash(input_ptr: [*]const u8, input_size: u32, seed: u64) u64 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.Wyhash.hash(seed, input); +} +export fn adler32(input_ptr: [*]const u8, input_size: u32) u32 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.Adler32.hash(input); +} +export fn crc32(input_ptr: [*]const u8, input_size: u32) u32 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.Crc32.hash(input); +} +export fn cityhash32(input_ptr: [*]const u8, input_size: u32) u32 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.CityHash32.hash(input); +} +export fn cityhash64(input_ptr: [*]const u8, input_size: u32, seed: u64) u64 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.CityHash64.hashWithSeed(input, seed); +} +export fn murmur32v3(input_ptr: [*]const u8, input_size: u32, seed: u32) u32 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.Murmur3_32.hashWithSeed(input, seed); +} +export fn murmur32v2(input_ptr: [*]const u8, input_size: u32, seed: u32) u32 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.Murmur2_32.hashWithSeed(input, seed); +} +export fn murmur64v2(input_ptr: [*]const u8, input_size: u32, seed: u64) u64 { + const input: []const u8 = input_ptr[0..input_size]; + defer std.heap.wasm_allocator.free(input); + return std.hash.Murmur2_64.hashWithSeed(input, seed); +} diff --git a/packages/bun-polyfills/lib/zighash/types.d.ts b/packages/bun-polyfills/lib/zighash/types.d.ts new file mode 100644 index 000000000..f0704ac94 --- /dev/null +++ b/packages/bun-polyfills/lib/zighash/types.d.ts @@ -0,0 +1,25 @@ +type WasmHash32Function = (input_ptr: number, input_size: number) => number; +type WasmHash64Function = (input_ptr: number, input_size: number) => bigint; +type WasmSeededHash32Function = (input_ptr: number, input_size: number, seed: number) => number; +type WasmSeededHash64Function = (input_ptr: number, input_size: number, seed: bigint) => bigint; +type JSHash32Function = (input: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer) => number; +type JSHash64Function = (input: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer) => bigint; +type JSSeededHash32Function = (input: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, seed?: number) => number; +type JSSeededHash64Function = (input: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, seed?: bigint) => bigint; + +type ZighashInstance = WebAssembly.WebAssemblyInstantiatedSource & { + instance: { + exports: { + memory: WebAssembly.Memory, + alloc(size: number): number, + wyhash: WasmSeededHash64Function, + adler32: WasmHash32Function, + crc32: WasmHash32Function, + cityhash32: WasmHash32Function, + cityhash64: WasmSeededHash64Function, + murmur32v3: WasmSeededHash32Function, + murmur32v2: WasmSeededHash32Function, + murmur64v2: WasmSeededHash64Function, + }; + }; +} diff --git a/packages/bun-polyfills/lib/zighash/zighash.wasm b/packages/bun-polyfills/lib/zighash/zighash.wasm new file mode 100755 index 000000000..1c8603f32 Binary files /dev/null and b/packages/bun-polyfills/lib/zighash/zighash.wasm differ diff --git a/packages/bun-polyfills/package.json b/packages/bun-polyfills/package.json new file mode 100644 index 000000000..e1852eddc --- /dev/null +++ b/packages/bun-polyfills/package.json @@ -0,0 +1,27 @@ +{ + "type": "module", + "name": "bun-polyfills", + "module": "src/index.ts", + "devDependencies": { + "@types/node": "^20.4.5", + "@types/which": "^3.0.0", + "bun-types": "^0.7.0", + "copyfiles": "^2.4.1" + }, + "peerDependencies": { + "typescript": "^5.0.0" + }, + "scripts": { + "node": "node --enable-source-maps --import ./dist/src/repl.js", + "clean": "rm -rf dist", + "build": "bun run clean && bunx tsc && bunx copyfiles \"./**/*.wasm\" dist", + "build/wasm": "bun run build/zighash", + "build/zighash": "cd lib/zighash && bun run build && cd ../.." + }, + "dependencies": { + "js-md4": "^0.3.2", + "open-editor": "^4.0.0", + "supports-color": "^9.4.0", + "which": "^3.0.1" + } +} diff --git a/packages/bun-polyfills/src/global/console.ts b/packages/bun-polyfills/src/global/console.ts new file mode 100644 index 000000000..4576f5a70 --- /dev/null +++ b/packages/bun-polyfills/src/global/console.ts @@ -0,0 +1,31 @@ +//? Implements: Red colored console.error from Bun +//if (Bun.enableANSIColors) { +// const RED = '\x1B[31m' as const; +// const RESET = '\x1B[0m' as const; +// const consoleError = console.error; +// console.error = (...args) => { +// if (typeof args[0] === 'string') args[0] = RED + args[0]; +// consoleError(...args, RESET); +// }; +//} + +//? Implements: for await (const line of console) { ... } +console[Symbol.asyncIterator] = async function* () { + while (true) yield await new Promise(resolve => { + process.stdin.on('data', (data: Buffer | string) => { + const str = data.toString('utf-8').replaceAll(/[\r\n]+/g, ''); + resolve(str); + }); + }); +} satisfies Console[typeof Symbol.asyncIterator]; + +//? Implements: Bun-exclusive console function +console.write = ((...data) => { + const str = data.map(val => { + if (val instanceof ArrayBuffer) val = new TextDecoder('utf-8').decode(val); + else if (typeof val === 'object') val = new TextDecoder('utf-8').decode(val.buffer); + return val; + }).join(''); + process.stdout.write(str); + return new TextEncoder('utf-8').encode(str).byteLength; +}) satisfies Console['write']; diff --git a/packages/bun-polyfills/src/global/importmeta.ts b/packages/bun-polyfills/src/global/importmeta.ts new file mode 100644 index 000000000..ea8acad80 --- /dev/null +++ b/packages/bun-polyfills/src/global/importmeta.ts @@ -0,0 +1,34 @@ +import path from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { createRequire } from 'node:module'; + +// Without an ESM loader, this polyfill is impossible to apply automatically, +// due to the per-module nature of import.meta. In order to use this polyfill, +// you must import it in every module that uses import.meta, and call it with +// the import.meta object as the argument. When the polyfills are integrated +// with bun build, this could be done automatically by the build process at +// the top of every module file bundled. + +export default function polyfillImportMeta(metaIn: ImportMeta) { + const require2 = createRequire(metaIn.url); + const metapath = fileURLToPath(metaIn.url); + const meta: ImportMeta = { + url: metaIn.url, + main: metapath === process.argv[1], + path: metapath, + dir: path.dirname(metapath), + file: path.basename(metapath), + require: require2, + async resolve(id: string, parent?: string) { + return this.resolveSync(id, parent); + }, + resolveSync(id: string, parent?: string) { + return require2.resolve(id, { + paths: typeof parent === 'string' ? [ + path.resolve(parent.startsWith('file://') ? fileURLToPath(parent) : parent, '..') + ] : undefined, + }); + }, + }; + Object.assign(metaIn, meta); +} diff --git a/packages/bun-polyfills/src/global/index.ts b/packages/bun-polyfills/src/global/index.ts new file mode 100644 index 000000000..661a2c3c1 --- /dev/null +++ b/packages/bun-polyfills/src/global/index.ts @@ -0,0 +1,45 @@ +import { version } from '../modules/bun.js'; +import './console.js'; +import './process.js'; +import os from 'node:os'; + +//? NodeJS Blob doesn't implement Blob.json(), so we need to polyfill it. +Blob.prototype.json = async function json(this: Blob): Promise { + try { + return JSON.parse(await this.text()) as T; + } catch (err) { + Error.captureStackTrace(err as Error, json); + throw err; + } +}; + +//? navigator global object polyfill +Reflect.set(globalThis, 'navigator', { + userAgent: `Bun/${version}`, + hardwareConcurrency: os.cpus().length, +}); + +//? method only available in Bun +// this isn't quite accurate, but it shouldn't break anything and is currently here just for matching bun and node types +const ReadableStreamDefaultReaderPrototype = Object.getPrototypeOf(new ReadableStream().getReader()); +Reflect.set( + ReadableStreamDefaultReaderPrototype, 'readMany', + function readMany(this: ReadableStreamDefaultReader): Promise> { + return new Promise((resolve, reject) => { + const result: ReadableStreamDefaultReadManyResult = { + value: [], + size: 0, + done: true + }; + this.read().then(({ done, value }) => { + if (done) resolve(result); + else { + result.value.push(value); + result.size = value.length; + result.done = false; + resolve(result); + } + }, reject); + }); + } +); diff --git a/packages/bun-polyfills/src/global/process.ts b/packages/bun-polyfills/src/global/process.ts new file mode 100644 index 000000000..efc7d5cdd --- /dev/null +++ b/packages/bun-polyfills/src/global/process.ts @@ -0,0 +1,19 @@ + +if (typeof process === 'object' && process !== null) { + // process polyfills (node-only) + Reflect.set(process, 'isBun', 1 satisfies Process['isBun']); + Reflect.set(process, 'browser', false satisfies Process['browser']); + + const NULL_VERSION = '0'.repeat(39) + '1'; + process.versions.bun = '0.7.1' satisfies Process['versions'][string]; // TODO: This can probably be fetched from somewhere in the repo + process.versions.webkit = NULL_VERSION satisfies Process['versions'][string]; + process.versions.mimalloc = NULL_VERSION satisfies Process['versions'][string]; + process.versions.libarchive = NULL_VERSION satisfies Process['versions'][string]; + process.versions.picohttpparser = NULL_VERSION satisfies Process['versions'][string]; + process.versions.boringssl = NULL_VERSION satisfies Process['versions'][string]; + process.versions.zig = '0.10.0' satisfies Process['versions'][string]; + Reflect.set(process, 'revision', NULL_VERSION satisfies Process['revision']); + + // Doesn't work on Windows sadly + //Object.defineProperty(process, 'execPath', { value: path.resolve(root, 'cli.js') }); +} diff --git a/packages/bun-polyfills/src/index.ts b/packages/bun-polyfills/src/index.ts new file mode 100644 index 000000000..b48a9b772 --- /dev/null +++ b/packages/bun-polyfills/src/index.ts @@ -0,0 +1,3 @@ +export * from './modules/bun.js'; +export * as default from './modules/bun.js'; +import './global/index.js'; diff --git a/packages/bun-polyfills/src/modules/bun.ts b/packages/bun-polyfills/src/modules/bun.ts new file mode 100644 index 000000000..ce0f6f6be --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun.ts @@ -0,0 +1,489 @@ +import type { + BunPlugin, PluginConstraints, PluginBuilder, OnLoadCallback, OnResolveCallback, HeapSnapshot, + EditorOptions, SpawnOptions, Subprocess, SyncSubprocess, FileBlob as BunFileBlob, ArrayBufferView, Hash +} from 'bun'; +import { TextDecoderStream } from 'node:stream/web'; +import { NotImplementedError, type SystemError } from '../utils/errors.js'; +import { streamToBuffer, isArrayBufferView, isFileBlob, isOptions } from '../utils/misc.js'; +import dnsPolyfill from './bun/dns.js'; +import { FileSink } from './bun/filesink.js'; +import { + bunHash, bunHashProto, + MD4 as MD4Polyfill, MD5 as MD5Polyfill, + SHA1 as SHA1Polyfill, SHA224 as SHA224Polyfill, + SHA256 as SHA256Polyfill, SHA384 as SHA384Polyfill, + SHA512 as SHA512Polyfill, SHA512_256 as SHA512_256Polyfill +} from './bun/hashes.js'; +import { ArrayBufferSink as ArrayBufferSinkPolyfill } from './bun/arraybuffersink.js'; +import { FileBlob, NodeJSStreamFileBlob } from './bun/fileblob.js'; +import fs from 'node:fs'; +import v8 from 'node:v8'; +import path from 'node:path'; +import util from 'node:util'; +import zlib from 'node:zlib'; +import streams from 'node:stream'; +import workers from 'node:worker_threads'; +import chp, { type ChildProcess, type StdioOptions, type SpawnSyncReturns } from 'node:child_process'; +import { fileURLToPath as fileURLToPathNode, pathToFileURL as pathToFileURLNode } from 'node:url'; +import npm_which from 'which'; +import openEditor from 'open-editor'; + +export const main = path.resolve(process.cwd(), process.argv[1] ?? 'repl') satisfies typeof Bun.main; + +export const version = '0.7.1' satisfies typeof Bun.version; // TODO: This can probably be fetched from somewhere in the repo +export const revision = '0'.repeat(39) + '1' satisfies typeof Bun.revision; +//getter(bun, 'cwd', proc.cwd); //! Can't named export a getter +export const origin = '' satisfies typeof Bun.origin; +// @ts-expect-error --- +export const stdin = new NodeJSStreamFileBlob(process.stdin) satisfies typeof Bun.stdin; +// @ts-expect-error --- +export const stdout = new NodeJSStreamFileBlob(process.stdout) satisfies typeof Bun.stdout; +// @ts-expect-error --- +export const stderr = new NodeJSStreamFileBlob(process.stderr) satisfies typeof Bun.stderr; +export const argv = [process.argv0, ...process.execArgv, ...process.argv.slice(1)] satisfies typeof Bun.argv; +export const env = process.env satisfies typeof Bun.env; +Object.setPrototypeOf(env, { + toJSON(this: typeof env) { return { ...this }; } +}); +// @ts-expect-error supports-color types are unbelievably bad +export const enableANSIColors = (await import('supports-color')).createSupportsColor().hasBasic satisfies typeof Bun.enableANSIColors; + +export const hash = bunHash satisfies typeof Bun.hash; +Object.setPrototypeOf(hash, bunHashProto satisfies Hash); + +export const unsafe = { + gcAggressionLevel: () => 0, //! no-op + arrayBufferToString: (buf) => new TextDecoder().decode(buf), + segfault: () => { + const segfault = new Error(); + segfault.name = 'SegfaultTest'; + segfault.message = ''; + console.error(segfault); + process.exit(1); + } +} satisfies typeof Bun['unsafe']; + +export const SHA1 = SHA1Polyfill satisfies typeof Bun.SHA1; +export const MD5 = MD5Polyfill satisfies typeof Bun.MD5; +export const MD4 = MD4Polyfill satisfies typeof Bun.MD4; +export const SHA224 = SHA224Polyfill satisfies typeof Bun.SHA224; +export const SHA512 = SHA512Polyfill satisfies typeof Bun.SHA512; +export const SHA384 = SHA384Polyfill satisfies typeof Bun.SHA384; +export const SHA256 = SHA256Polyfill satisfies typeof Bun.SHA256; +export const SHA512_256 = SHA512_256Polyfill satisfies typeof Bun.SHA512_256; + +export const indexOfLine = ((data, offset) => { + if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) data = new Uint8Array(data); + if (data instanceof DataView || !(data instanceof Uint8Array)) data = new Uint8Array(data.buffer); + return data.indexOf(10, offset); +}) satisfies typeof Bun.indexOfLine; + +const peek_ = function peek(promise: Parameters[0]) { + throw new NotImplementedError('Bun.peek', peek); +}; +peek_.status = (promise => { + return util.inspect(promise).includes('') ? 'pending' + : util.inspect(promise).includes('') ? 'rejected' : 'fulfilled'; +}) satisfies typeof Bun.peek.status; +export const peek = peek_ satisfies typeof Bun.peek; + +export const sleep = (ms => { + return new Promise(r => setTimeout(r, ms instanceof Date ? ms.valueOf() - Date.now() : ms)); +}) satisfies typeof Bun.sleep; +export const sleepSync = (ms => { + if (ms < 0) throw new TypeError('argument to sleepSync must not be negative'); + Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); +}) satisfies typeof Bun.sleepSync; + +//? This is not 1:1 matching, but no one should be relying on the exact output of this function anyway. +//? To quote Node's inspect itself: "The output of util.inspect() may change at any time and should not be depended upon programmatically." +//? Of course in Node's case some didn't listen and relied on the output of util.inspect() anyway, but hopefully this won't happen with this one. +export const inspect = ((arg: any): string => util.inspect(arg, { + breakLength: Infinity, + colors: false, + compact: true, + customInspect: false, + depth: Infinity, + getters: true, + maxArrayLength: Infinity, + maxStringLength: Infinity, + showHidden: false, + showProxy: false, + sorted: false +})) satisfies typeof Bun.inspect; + +export const resolveSync = ((id: string, parent: string) => import.meta.resolveSync(id, parent)) satisfies typeof Bun.resolveSync; +export const resolve = (async (id: string, parent: string) => import.meta.resolve!(id, parent)) satisfies typeof Bun.resolve; + +//? Yes, this is faster than new Uint8Array(Buffer.allocUnsafe(size).buffer) by about 2.5x in Node.js +export const allocUnsafe = ((size: number) => new Uint8Array(size)) satisfies typeof Bun.allocUnsafe; + +export const generateHeapSnapshot = (async (): Promise => { + process.emitWarning('The polyfill for Bun.generateHeapShot is asynchronous, unlike the original which is synchronous.', { + type: 'BunPolyfillWarning', + code: 'BUN_POLYFILLS_ASYNC_GENERATE_HEAP_SNAPSHOT', + detail: 'This is due to v8.getHeapSnapshot() returning a stream in Node.js. This is not a bug, but a limitation of the polyfill.' + }); + const raw = (await streamToBuffer(v8.getHeapSnapshot())).toString('utf8'); + const json = JSON.parse(raw) as V8HeapSnapshot; + return { + version: 2, + type: 'Inspector', + nodes: json.nodes, + edges: json.edges, + edgeTypes: json.snapshot.meta.edge_types.flat(), + edgeNames: json.snapshot.meta.edge_fields.flat(), + nodeClassNames: json.snapshot.meta.node_types.flat(), + }; + // @ts-expect-error Refer to the above emitWarning call +}) satisfies typeof Bun.generateHeapSnapshot; + +//! This is a no-op in Node.js, as there is no way to shrink the V8 heap from JS as far as I know. +export const shrink = (() => void 0) satisfies typeof Bun.shrink; + +export const openInEditor = ((file: string, opts?: EditorOptions) => { + const target = [{ file: path.resolve(process.cwd(), file), line: opts?.line, column: opts?.column }] as const; + if (opts?.editor) openEditor(target, opts); + else openEditor(target, { editor: process.env.TERM_PROGRAM ?? process.env.VISUAL ?? process.env.EDITOR ?? 'vscode' }); +}) satisfies typeof Bun.openInEditor; + +export const serve = (() => { throw new NotImplementedError('Bun.serve', serve); }) satisfies typeof Bun.serve; + +export const file = ((path: string | URL | Uint8Array | ArrayBufferLike | number, options?: BlobPropertyBag): BunFileBlob => { + if (typeof path === 'object') throw new NotImplementedError('Bun.file with typed array', file); + return new FileBlob(path, options); +}) satisfies typeof Bun.file; + +export const write = (async (dest: BunFileBlob | PathLike, input: string | Blob | TypedArray | ArrayBufferLike | BlobPart[] | Response | BunFileBlob): ReturnType => { + if (!isFileBlob(dest)) { + let fd: number; + if (dest instanceof ArrayBuffer || dest instanceof SharedArrayBuffer) fd = fs.openSync(Buffer.from(dest), 'w'); + // bun-types thought it'd be funny to make their own URL definition which doesnt match with the correct URL definition... + else if (typeof dest === 'string' || dest instanceof URL) fd = fs.openSync(dest as import('url').URL, 'w'); + else fd = fs.openSync(Buffer.from(dest.buffer), 'w'); + + if (input instanceof Response || input instanceof Blob) { + const data = await input.text(); + return new Promise((resolve, reject) => { + fs.write(fd, data, (err, written) => err ? reject(err) : resolve(written)); + }); + } + if (Array.isArray(input)) { + const data = await new Blob(input).text(); + return new Promise((resolve, reject) => { + fs.write(fd, data, (err, written) => err ? reject(err) : resolve(written)); + }); + } + return new Promise((resolve, reject) => { + if (typeof input === 'string') return fs.write(fd, input, (err, written) => err ? reject(err) : resolve(written)); + if (input instanceof Uint8Array) return fs.write(fd, input, (err, written) => err ? reject(err) : resolve(written)); + if (input instanceof ArrayBuffer) return fs.write(fd, new Uint8Array(input), (err, written) => err ? reject(err) : resolve(written)); + if (input instanceof SharedArrayBuffer) return fs.write(fd, new Uint8Array(input), (err, written) => err ? reject(err) : resolve(written)); + return write(dest, String(input)); // if all else fails, it seems Bun tries to convert to string and write that. + }); + } else { + const writer = dest.writer(); + if (Array.isArray(input)) input = new Blob(input); + if (input instanceof Blob || input instanceof Response) return writer.write(await input.arrayBuffer()); + if (input instanceof ArrayBuffer || input instanceof SharedArrayBuffer || ArrayBuffer.isView(input)) return writer.write(input); + if (typeof input === 'string') return writer.write(input); + else return write(dest, String(input)); // if all else fails, it seems Bun tries to convert to string and write that. + } +}) satisfies typeof Bun.write; + +export const sha = SHA512_256.hash satisfies typeof Bun.sha; + +export const nanoseconds = (() => Math.trunc(performance.now() * 1000000)) satisfies typeof Bun.nanoseconds; + +//? This just prints out some debug stuff in console, and as the name implies no one should be using it. +//? But, just in case someone does, we'll make it a no-op function so at least the program doesn't crash trying to run the function. +export const DO_NOT_USE_OR_YOU_WILL_BE_FIRED_mimalloc_dump = (() => { + console.warn('DO_NOT_USE_OR_YOU_WILL_BE_FIRED_mimalloc_dump called.'); +}) satisfies unknown; /* undocumented */ + +export const gzipSync = zlib.gzipSync satisfies typeof Bun.gzipSync; +export const deflateSync = zlib.deflateSync satisfies typeof Bun.deflateSync; +export const gunzipSync = zlib.gunzipSync satisfies typeof Bun.gunzipSync; +export const inflateSync = zlib.inflateSync satisfies typeof Bun.inflateSync; + +export const which = ((cmd: string, options) => { + const opts: npm_which.Options = { all: false, nothrow: true }; + if (options?.PATH) opts.path = options.PATH; + const result = npm_which.sync(cmd, opts) as string | null; + if (!result || !options?.cwd) return result; + if (path.normalize(result).includes(path.normalize(options.cwd))) return result; + else return null; +}) satisfies typeof Bun.which; + +export const spawn = ((...args) => { + let cmd: string; + let argv: string[]; + let opts: SpawnOptions.OptionsObject; + + if (args[0] instanceof Array) { + cmd = args[0][0]; + argv = args[0].slice(1); + opts = isOptions(args[1]) ? args[1] : {}; + } else { + cmd = args[0].cmd[0]; + argv = args[0].cmd.slice(1); + opts = args[0]; + Reflect.deleteProperty(opts, 'cmd'); + } + + let stdio: StdioOptions = []; + opts.stdio ??= [undefined, undefined, undefined]; + if (opts.stdin) opts.stdio[0] = opts.stdin; + if (opts.stdout) opts.stdio[1] = opts.stdout; + if (opts.stderr) opts.stdio[2] = opts.stderr; + for (let i = 1; i < 3; i++) { // this intentionally skips stdin + let std = opts.stdio[i]; + if (isArrayBufferView(std)) stdio[i] = streams.Readable.fromWeb(new Blob([std]).stream()); + else if (std instanceof Blob || isFileBlob(std)) stdio[i] = streams.Readable.fromWeb(std.stream()); + else if (std instanceof ReadableStream) stdio[i] = streams.Readable.fromWeb(std); + else if (std instanceof Response || std instanceof Request) stdio[i] = streams.Readable.fromWeb(std.body!); + else stdio[i] = std; + } + let stdinSrc: typeof opts.stdio[0] = null; + if (opts.stdio[0] && typeof opts.stdio[0] !== 'string') { + stdinSrc = opts.stdio[0]; + stdio[0] = 'pipe'; + } + + const subp = chp.spawn(cmd, argv, { + cwd: opts.cwd ?? process.cwd(), + // why is this set to (string | number) on env values... + env: { ...(opts.env as Record ?? process.env) }, + stdio + }) as unknown as Subprocess; + const subpAsNode = subp as unknown as ChildProcess; + const stdstreams = [subpAsNode.stdin, subpAsNode.stdout, subpAsNode.stderr] as const; + if (subpAsNode.stdout) { + const rstream = streams.Readable.toWeb(subpAsNode.stdout) as ReadableStream; + Reflect.set(rstream, 'destroy', function (this: ReadableStream, err?: Error) { + void (err ? this.cancel(String(err)) : this.cancel()).catch(() => { /* if it fails its already closed */ }); + return this; + }); + (>subp).stdout = rstream; + } + if (subpAsNode.stderr) { + const rstream = streams.Readable.toWeb(subpAsNode.stderr) as ReadableStream; + Reflect.set(rstream, 'destroy', function (this: ReadableStream, err?: Error) { + void (err ? this.cancel(String(err)) : this.cancel()).catch(() => { /* if it fails its already closed */ }); + return this; + }); + (>subp).stderr = rstream; + } + let internalStdinStream: streams.Writable; + if (subpAsNode.stdin) { + const wstream = subpAsNode.stdin; + Reflect.set(wstream, 'destroy', function (this: NodeJS.WritableStream, err?: Error) { + void this.end(); /* if it fails its already closed */ + return this; + }); + internalStdinStream = wstream; + (>subp).stdin = new FileSink(wstream); + + } + Object.defineProperty(subp, 'readable', { get(this: Subprocess) { return this.stdout; } }); + Object.defineProperty(subp, 'exited', { + value: new Promise((resolve, reject) => { + subpAsNode.once('exit', (code) => { + stdstreams[0]?.destroy(); + stdstreams[1]?.destroy(); + stdstreams[2]?.destroy(); + subp.kill(); + subp.unref(); + subpAsNode.disconnect?.(); + subpAsNode.removeAllListeners(); + resolve(code); + }); + }) + }); + if (stdinSrc) subpAsNode.once('spawn', () => { + const stdinWeb = streams.Writable.toWeb(internalStdinStream); + if (isArrayBufferView(stdinSrc)) stdinSrc = new Blob([stdinSrc]); + if (stdinSrc instanceof Blob) void stdinSrc.stream().pipeTo(stdinWeb); + else if (stdinSrc instanceof Response || stdinSrc instanceof Request) void stdinSrc.body!.pipeTo(stdinWeb); + else if (typeof stdinSrc === 'number') void fs.createReadStream('', { fd: stdinSrc }).pipe(internalStdinStream); + else void stdinSrc; + }); + // change the error stack to point to the spawn() call instead of internal Node.js callback stuff + const here = new Error('§__PLACEHOLDER__§'); + Error.captureStackTrace(here, spawn); + if (!subpAsNode.pid) return subpAsNode.once('error', (err: SystemError) => { + err.message = (err.syscall ?? `spawn ${err.path ?? ''}`) + ' ' + (err.code ?? String(err.errno ?? '')); + err.stack = here.stack!.replace('§__PLACEHOLDER__§', err.message); + throw err; + }) as unknown as Subprocess; + return subp; +}) satisfies typeof Bun.spawn; +export const spawnSync = ((...args): SyncSubprocess => { + let cmd: string; + let argv: string[]; + let opts: SpawnOptions.OptionsObject; + if (args[0] instanceof Array) { + cmd = args[0][0]; + argv = args[0].slice(1); + opts = isOptions(args[1]) ? args[1] : {}; + } else { + cmd = args[0].cmd[0]; + argv = args[0].cmd.slice(1); + opts = args[0]; + Reflect.deleteProperty(opts, 'cmd'); + } + + let stdio: StdioOptions = []; + opts.stdio ??= [undefined, undefined, undefined]; + if (opts.stdin) opts.stdio[0] = opts.stdin; + if (opts.stdout) opts.stdio[1] = opts.stdout; + if (opts.stderr) opts.stdio[2] = opts.stderr; + for (let i = 1; i < 3; i++) { // this intentionally skips stdin + let std = opts.stdio[i]; + if (isArrayBufferView(std)) stdio[i] = streams.Readable.fromWeb(new Blob([std]).stream()); + else if (std instanceof Blob || isFileBlob(std)) stdio[i] = streams.Readable.fromWeb(std.stream()); + else if (std instanceof ReadableStream) stdio[i] = streams.Readable.fromWeb(std); + else if (std instanceof Response || std instanceof Request) stdio[i] = streams.Readable.fromWeb(std.body!); + else stdio[i] = std; + } + let input: ArrayBufferView | string | undefined; + if (opts.stdio[0] && typeof opts.stdio[0] !== 'string') { + stdio[0] = null; // will be overriden by chp.spawnSync "input" option + //! Due to the fully async nature of Blobs, Responses and Requests, + //! we can't synchronously get the data out of them here in userland. + if (opts.stdio[0] instanceof Blob) throw new NotImplementedError('Bun.spawnSync({ stdin: })', spawnSync); + else if (opts.stdio[0] instanceof Response || opts.stdio[0] instanceof Request) throw new NotImplementedError('Bun.spawnSync({ stdin: })', spawnSync); + else if (typeof opts.stdio[0] === 'number') input = fs.readFileSync(opts.stdio[0]); + else input = opts.stdio[0] as ArrayBufferView; + } + + const subp = chp.spawnSync(cmd, argv, { + cwd: opts.cwd ?? process.cwd(), + env: { ...(opts.env as Record ?? process.env) }, + stdio, input + }) as unknown as SyncSubprocess; + const subpAsNode = subp as unknown as SpawnSyncReturns; + if (subpAsNode.error) throw subpAsNode.error; + + subp.exitCode = subpAsNode.status ?? NaN; //! not sure what Bun would return here (child killed by signal) + subp.success = subp.exitCode === 0; + return subp; +}) satisfies typeof Bun.spawnSync; + +export const escapeHTML = ((input) => { + const str = String(input); + let out = ''; + for (let i = 0; i < str.length; i++) { + const char = str[i]; + switch (char) { + case '"': out += '"'; break; + case "'": out += '''; break; + case '&': out += '&'; break; + case '<': out += '<'; break; + case '>': out += '>'; break; + default: out += char; + } + } + return out; +}) satisfies typeof Bun.escapeHTML; + +export const readableStreamToArrayBuffer = ((stream: ReadableStream): ArrayBuffer | Promise => { + return (async () => { + const sink = new ArrayBufferSink(); + const reader = stream.getReader(); + while (true) { + const { done, value } = await reader.read(); + if (done) break; + sink.write(value); + } + return sink.end() as ArrayBuffer; + })(); +}) satisfies typeof Bun.readableStreamToArrayBuffer; +export const readableStreamToText = (async (stream: ReadableStream) => { + let result = ''; + const reader = stream.pipeThrough(new TextDecoderStream()).getReader(); ReadableStreamDefaultReader + while (true) { + const { done, value } = await reader.read(); + //! for some reason "done" isnt being set to true so this is just infinitely looping at the moment... sigh + if (done || !value || !value?.length) break; + result += value; + } + return result; +}) satisfies typeof Bun.readableStreamToText; +export const readableStreamToBlob = (async (stream: ReadableStream) => { + const parts = await readableStreamToArray(stream); + return new Blob(parts as BlobPart[]); +}) satisfies typeof Bun.readableStreamToBlob; +export const readableStreamToArray = (async (stream: ReadableStream) => { + const array = new Array(); + const reader = stream.getReader(); + while (true) { + const { done, value } = await reader.read(); + if (done || !value || !(value)?.length) break; + array.push(value as unknown as T); + } + return array; +}) satisfies typeof Bun.readableStreamToArray; +export const readableStreamToJSON = (async (stream: ReadableStream) => { + const text = await readableStreamToText(stream); + try { + return JSON.parse(text) as T; + } catch (err) { + Error.captureStackTrace(err as Error, readableStreamToJSON); + throw err; + } +}) satisfies typeof Bun.readableStreamToJSON; + +export const concatArrayBuffers = ((buffers) => { + let size = 0; + for (const chunk of buffers) size += chunk.byteLength; + const buffer = new ArrayBuffer(size); + const view = new Uint8Array(buffer); + let offset = 0; + for (const chunk of buffers) { + view.set(new Uint8Array(chunk instanceof ArrayBuffer || chunk instanceof SharedArrayBuffer ? chunk : chunk.buffer), offset); + offset += chunk.byteLength; + } + return buffer; +}) satisfies typeof Bun.concatArrayBuffers; + +export const ArrayBufferSink = ArrayBufferSinkPolyfill satisfies typeof Bun.ArrayBufferSink; + +export const pathToFileURL = pathToFileURLNode satisfies typeof Bun.pathToFileURL; +export const fileURLToPath = fileURLToPathNode satisfies typeof Bun.fileURLToPath; + +export const dns = dnsPolyfill satisfies typeof Bun.dns; + +export const isMainThread = workers.isMainThread satisfies typeof Bun.isMainThread; + +//! It may be possible to implement plugins with Node ESM loaders, but it would take some effort and have some caveats. +//! For now, we'll simply make all calls to Bun.plugin no-op, such that manual implementation of an external ESM loader is possible, +//! but without needing to strip out all Bun.plugin calls from the source code for running on Node. +const dummyPluginBuilder: PluginBuilder = ({ + onLoad(constraints: PluginConstraints, callback: OnLoadCallback): void { + return; // stubbed + }, + onResolve(constraints: PluginConstraints, callback: OnResolveCallback): void { + return; // stubbed + }, + config: { plugins: [], entrypoints: [] }, +}) satisfies PluginBuilder; +const bunPlugin = (options: T) => options?.setup?.(dummyPluginBuilder) as ReturnType; +bunPlugin.clearAll = () => void 0; +export const plugin = bunPlugin satisfies typeof Bun.plugin; +/*void plugin({ + name: 'test', + target: 'bun', + setup(builder) { + if (builder.target !== 'bun') return; + builder.onResolve({ namespace: 'sample', filter: /.+/ }, args => { + args.importer; + if (args.path === 'foo') return { namespace: 'redirect', path: 'bar' }; + else return; + }); + builder.onLoad({ namespace: 'sample', filter: /.+/ }, args => { + args.path; + return { loader: 'object', exports: { foo: 'bar' }, contents: 'void 0;' }; + }); + } +});*/ diff --git a/packages/bun-polyfills/src/modules/bun/arraybuffersink.ts b/packages/bun-polyfills/src/modules/bun/arraybuffersink.ts new file mode 100644 index 000000000..5144bafb9 --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun/arraybuffersink.ts @@ -0,0 +1,67 @@ +type BunArrayBufferSink = InstanceType; + +export class ArrayBufferSink implements BunArrayBufferSink { + #started: boolean = true; + #closed: boolean = false; + #offset: number = 0; + #stream: boolean = false; + #asUint8: boolean = false; + #buffer: Buffer = Buffer.allocUnsafe(8192); + + get sinkId(): number { return 0; } //? undocumented, seems to always return 0 + + #ASSERT_NOT_CLOSED(caller: AnyFunction): void { + if (!this.#closed) return; + const err = new TypeError('Expected Sink'); + Error.captureStackTrace(err, caller); + throw err; + } + + start({ asUint8Array = false, highWaterMark = 8192, stream = false }: Parameters[0] = {}): void { + this.#ASSERT_NOT_CLOSED(this.start); + this.#started = true; + this.#offset = 0; + this.#stream = stream; + this.#asUint8 = asUint8Array; + if (highWaterMark !== this.#buffer.byteLength) this.#buffer = Buffer.allocUnsafe(highWaterMark); + } + + write(data: string | ArrayBufferView | SharedArrayBuffer | ArrayBuffer): number { + this.#ASSERT_NOT_CLOSED(this.write); + if (typeof data === 'string') data = new TextEncoder().encode(data); + const writedata = (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength); + // this is very bad API design to not throw an error here, but it's what Bun does + if (!this.#started) return writedata.byteLength; + + if (this.#offset + writedata.byteLength > this.#buffer.byteLength) { + const newLength = Math.ceil((this.#offset + writedata.byteLength) / 1024) * 1024; + const newBuffer = Buffer.allocUnsafe(newLength); + newBuffer.set(this.#buffer); + this.#buffer = newBuffer; + } + this.#buffer.set(writedata, this.#offset); + this.#offset += writedata.byteLength; + return writedata.byteLength; + } + + flush(): number | Uint8Array | ArrayBuffer { + this.#ASSERT_NOT_CLOSED(this.flush); + if (!this.#stream) return 0; //! brokenly seems to always return 0 and do nothing + const flushed = new Uint8Array(this.#offset); + flushed.set(this.#buffer.subarray(0, this.#offset)); // faster than Buffer.copy or Uint8Array.slice + this.#offset = 0; + return this.#asUint8 ? flushed : flushed.buffer as ArrayBuffer; + } + + end(): Uint8Array | ArrayBuffer { + this.#ASSERT_NOT_CLOSED(this.end); + const stream = this.#stream; + this.#stream = true; // force flush() to return the data + const buffer = this.flush() as Uint8Array | ArrayBuffer; + this.#stream = stream; + this.#started = false; + return buffer; + } + + close(): void { this.#closed = true; } //? undocumented +} diff --git a/packages/bun-polyfills/src/modules/bun/dns.ts b/packages/bun-polyfills/src/modules/bun/dns.ts new file mode 100644 index 000000000..b87470f9c --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun/dns.ts @@ -0,0 +1,21 @@ +import dns from 'node:dns'; + +const dnsObj: typeof Bun.dns = { + async lookup(hostname, options) { + const opts = { verbatim: true, all: true } as dns.LookupOptions; + if (options?.family) { + if (options.family === 'IPv4') opts.family = 4; + else if (options.family === 'IPv6') opts.family = 6; + else if (options.family === 'any') opts.family = 0; + else opts.family = options.family; + } + if (options?.flags) opts.hints = options.flags; + const records = ((await dns.promises.resolveAny(hostname)) + .filter(r => r.type === 'A' || r.type === 'AAAA') as (dns.AnyARecord | dns.AnyAaaaRecord)[]) + .map(r => ({ address: r.address, family: r.type === 'A' ? 4 as const : 6 as const, ttl: r.ttl })); + return records; + }, + // This has more properties but they're not documented on bun-types yet, oh well. +}; + +export default dnsObj; diff --git a/packages/bun-polyfills/src/modules/bun/fileblob.ts b/packages/bun-polyfills/src/modules/bun/fileblob.ts new file mode 100644 index 000000000..abe2294da --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun/fileblob.ts @@ -0,0 +1,195 @@ +import fs from 'node:fs'; +import tty from 'node:tty'; +import streams from 'node:stream'; +import { ReadableStream as NodeWebReadableStream } from 'node:stream/web'; +import { FileSink } from './filesink.js'; +import { SystemError } from '../../utils/errors.js'; +import type { FileBlob as BunFileBlob, FileSink as BunFileSink } from 'bun'; + +type NodeJSStream = streams.Readable | streams.Writable; + +function NodeJSReadableStreamToBlob(stream: NodeJS.ReadableStream | NodeJS.ReadWriteStream, iostream: boolean = false, type?: string): Promise { + if (stream.isPaused()) stream.resume(); + return new Promise((resolve, reject) => { + const chunks: any[] = []; + const dataHandler = (chunk: any) => { chunks.push(chunk); if (iostream) end(); }; + const end = () => { + resolve(new Blob(chunks, type != null ? { type } : undefined)); + stream.off('data', dataHandler); + stream.off('end', end); + stream.pause(); + }; + stream.once('data', dataHandler).once('end', end); + //.once('error', reject); Bun waits to error on actual operations on the stream, therefore so will we. + }); +} + +export const NodeJSStreamFileBlob = class FileBlob extends Blob { + constructor(source: NodeJSStream, slice: [number?, number?] = [undefined, undefined], type = 'application/octet-stream') { + super(undefined, { type }); + Reflect.deleteProperty(this, 'size'); + if (source === process.stdout || source === process.stdin || source === process.stderr) { + this.#iostream = true; + } + this.#readable = source instanceof streams.Readable && !(source instanceof tty.WriteStream); + this.#source = source; + this.#slice = slice; + this.#size = Infinity; + } + readonly #iostream: boolean = false; + readonly #readable: boolean; + readonly #source: NodeJSStream; + readonly #slice: [number?, number?]; + #size: number; + + slice(begin?: number, end?: number, contentType?: string): Blob; + slice(begin?: number, contentType?: string): Blob; + slice(contentType?: string): Blob; + slice(beginOrType?: number | string, endOrType?: number | string, contentType: string = this.type): Blob { + if (typeof beginOrType === 'string') return new FileBlob(this.#source, this.#slice, beginOrType); + if (typeof endOrType === 'string') return new FileBlob(this.#source, [beginOrType, undefined], endOrType); + return new FileBlob(this.#source, [beginOrType, endOrType], contentType); + } + + override stream(): ReadableStream { + // This makes no sense but Bun does it so we will too + if (!this.#readable) return new ReadableStream(); + return streams.Readable.toWeb(this.#source as streams.Readable); + } + + #blobStackFn: AnyFunction = this.#getBlob; + + async #getBlob(): Promise { + if (!this.#readable) { + const err = new SystemError(-1, 'read'); + Error.captureStackTrace(err, this.#blobStackFn); + throw err; + } + const blob = (await NodeJSReadableStreamToBlob(this.#source as streams.Readable, this.#iostream)).slice(...this.#slice); + this.#size = blob.size; + return blob; + } + + override async text(): Promise { + if (this.#blobStackFn !== this.json) this.#blobStackFn = this.text; + return (await this.#getBlob()).text(); + } + override async arrayBuffer(): Promise { + this.#blobStackFn = this.arrayBuffer; + return (await this.#getBlob()).arrayBuffer(); + } + override async json(): Promise { + this.#blobStackFn = this.json; + return JSON.parse(await this.text()) as Promise; + } + + override get size(): number { return this.#size; } + override set size(_) { return; } +}; + +export class FileBlob extends Blob implements BunFileBlob { + constructor(fdOrPath: number | string, opts: BlobPropertyBag = {}) { + opts.type ??= 'application/octet-stream'; // TODO: Get MIME type from file extension + super(undefined, opts); + Reflect.deleteProperty(this, 'size'); + if (Reflect.get(opts, '__data')) this.#data = Reflect.get(opts, '__data') as Blob; + const slice = Reflect.get(opts, '__slice') as [number?, number?] | undefined; + if (slice) { + slice[0] &&= slice[0] | 0; // int cast + slice[1] &&= slice[1] | 0; // int cast + this.#slice = slice; + slice[0] ??= 0; + if (typeof slice[1] === 'undefined') { + if (slice[0] < 0) this.#sliceSize = -slice[0]; + } + else if (slice[0] < 0 && slice[1] < 0) this.#sliceSize = -(slice[0] - slice[1]); + else if (slice[0] >= 0 && slice[1] >= 0) this.#sliceSize = slice[1] - slice[0]; + } + if (typeof fdOrPath === 'string') try { + this.#fd = fs.openSync(fdOrPath, 'r+'); + } catch (err) { + this.#error = err as SystemError; + } + else { + this.#fd = fdOrPath; + this.#error = Reflect.get(opts, '__error') as SystemError | undefined; + } + if (!this.#error) { + const rstream = fs.createReadStream('', { fd: this.#fd, start: this.#slice[0], end: this.#slice[1] }); + this.#readable = streams.Readable.toWeb(rstream); + } + } + readonly #readable?: NodeWebReadableStream; + readonly #error?: SystemError; + readonly #slice: [number?, number?] = []; + readonly #sliceSize: number = 0; + readonly #fd: number = NaN; + #data?: Blob; + + #read() { + if (this.#error) throw this.#error; + const read = fs.readFileSync(this.#fd); + this.#data = new Blob([read.subarray(...this.#slice)], { type: this.type }); + } + + //! Bun 0.2 seems to return undefined for this, this might not be accurate or it's broken on Bun's side + get readable(): ReadableStream { + if (this.#error) throw this.#error; + return this.#readable! as ReadableStream; + } + + get lastModified(): number { + if (this.#error) throw this.#error; + return fs.fstatSync(this.#fd).mtimeMs; + } + + async exists(): Promise { + return !this.#error; + } + + writer(): BunFileSink { + if (this.#error) throw this.#error; + return new FileSink(this.#fd); + } + + // TODO: what's contentType? + override slice(begin?: number | string, end?: number | string, contentType?: string): FileBlob { + if (typeof begin === 'string') { + contentType = begin; + begin = undefined; + } + if (typeof end === 'string') { + contentType = end; + end = undefined; + } + return new FileBlob(this.#fd, { + __error: this.#error, + __slice: [begin, end], + __data: this.#data?.slice(begin, end), + } as BlobPropertyBag); + } + override arrayBuffer(): Promise { + if (!this.#data) this.#read(); + return new Blob([this.#data ?? '']).arrayBuffer(); + } + override text(): Promise { + if (!this.#data) this.#read(); + return new Blob([this.#data ?? '']).text(); + } + override json(): Promise; + override json(): Promise; + override json(): Promise | Promise { + if (!this.#data) this.#read(); + return new Blob([this.#data ?? '']).json(); + } + override stream(): NodeJS.ReadableStream; + override stream(): ReadableStream; + override stream(): ReadableStream | NodeJS.ReadableStream { + if (!this.#data) this.#read(); + return new Blob([this.#data ?? '']).stream(); + } + + override get size(): number { + return this.#data?.size ?? (this.#sliceSize || 0); + } +} diff --git a/packages/bun-polyfills/src/modules/bun/filesink.ts b/packages/bun-polyfills/src/modules/bun/filesink.ts new file mode 100644 index 000000000..4767814fd --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun/filesink.ts @@ -0,0 +1,87 @@ +import fs from 'node:fs'; +import { SystemError } from '../../utils/errors.js'; +import type { FileSink as BunFileSink } from 'bun'; + +export class FileSink implements BunFileSink { + constructor(fdOrPathOrStream: number | string | NodeJS.WritableStream) { + if (typeof fdOrPathOrStream === 'string') try { + this.#fd = fs.openSync(fdOrPathOrStream, 'a+'); + fs.ftruncateSync(this.#fd, 0); + } catch (err) { + throw err as SystemError; + } + else if (typeof fdOrPathOrStream === 'number') { + this.#fd = fdOrPathOrStream; // hope this fd is writable + fs.ftruncateSync(this.#fd, 0); + } + else { + this.#stream = fdOrPathOrStream; + } + } + #fd: number = NaN; + #stream: NodeJS.WritableStream | undefined; + #closed: boolean = false; + #writtenSinceFlush: number = 0; + #totalWritten: number = 0; + + start(options?: { highWaterMark?: number | undefined; } | undefined): void { + return; // TODO + } + + ref(): void { + return; // TODO + } + + unref(): void { + return; // TODO + } + + write(chunk: string | ArrayBufferView | SharedArrayBuffer | ArrayBuffer): number { + if (this.#closed) { + return typeof chunk === 'string' ? chunk.length : chunk.byteLength; + } + if (this.#stream) { + let data; + if (chunk instanceof ArrayBuffer || chunk instanceof SharedArrayBuffer) data = new Uint8Array(chunk); + else if (!(chunk instanceof Uint8Array) && typeof chunk !== 'string') data = new Uint8Array(chunk.buffer); + else data = chunk; + this.#stream.write(data); + const written = typeof data === 'string' ? data.length : data.byteLength; + this.#totalWritten += written; + return written; + } + if (typeof chunk === 'string') { + fs.appendFileSync(this.#fd, chunk, 'utf8'); + this.#writtenSinceFlush += chunk.length; + return chunk.length; + } + if (chunk instanceof ArrayBuffer || chunk instanceof SharedArrayBuffer) fs.appendFileSync(this.#fd, new Uint8Array(chunk)); + else fs.appendFileSync(this.#fd, new Uint8Array(chunk.buffer)); + this.#writtenSinceFlush += chunk.byteLength; + return chunk.byteLength; + } + + //! flushing after writing to a closed FileSink segfaults in Bun but I don't see the need to implement that behavior + flush(): number | Promise { + if (this.#closed) return 0; + // no-op because this is a synchronous implementation + const written = this.#writtenSinceFlush; + this.#writtenSinceFlush = 0; + return written; + } + + //! not sure what to do with this error + end(error?: Error): number | Promise { + if (this.#closed) return this.#totalWritten; + const flushed = this.flush(); + if (this.#stream) { + this.#stream.end(); + this.#closed = true; + return flushed; + } + this.#totalWritten = fs.fstatSync(this.#fd).size; + fs.closeSync(this.#fd); + this.#closed = true; + return flushed; + } +} diff --git a/packages/bun-polyfills/src/modules/bun/hashes.ts b/packages/bun-polyfills/src/modules/bun/hashes.ts new file mode 100644 index 000000000..ec254c03a --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun/hashes.ts @@ -0,0 +1,185 @@ +import type { CryptoHashInterface, DigestEncoding, Hash } from 'bun'; +import nodecrypto from 'node:crypto'; +import os from 'node:os'; +import md4, { Md4 } from 'js-md4'; +import { wyhash, adler32, crc32, cityhash32, cityhash64, murmur32v3, murmur64v2, murmur32v2 } from '../../../lib/zighash/index.mjs'; + +export const bunHash = ((data, seed = 0): bigint => wyhash(data, BigInt(seed))) as typeof Bun.hash; +export const bunHashProto: Hash = { + wyhash(data, seed = 0n) { return wyhash(data, seed); }, + adler32(data) { return adler32(data); }, + crc32(data) { return crc32(data); }, + cityHash32(data) { return cityhash32(data); }, + cityHash64(data, seed = 0n) { return cityhash64(data, seed); }, + murmur32v3(data, seed = 0) { return murmur32v3(data, seed); }, + murmur32v2(data, seed = 0) { return murmur32v2(data, seed); }, + murmur64v2(data, seed = 0n) { return murmur64v2(data, seed); }, +}; + +type HashImpl = { + digest(): Buffer; + digest(encoding: nodecrypto.BinaryToTextEncoding): string; + update(data: nodecrypto.BinaryLike): HashImpl; + update(data: string, inputEncoding: nodecrypto.Encoding): HashImpl; +}; +abstract class BaseHash implements CryptoHashInterface { + readonly #hash: HashImpl | null; + constructor(algorithm: string | HashImpl) { + if (typeof algorithm === 'string') this.#hash = nodecrypto.createHash(algorithm); + // If no preset algorithm is given, expect the subclass to fully implement its own. + else this.#hash = algorithm; + } + update(data: StringOrBuffer) { + if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) this.#hash!.update(new Uint8Array(data)); + else this.#hash!.update(data); + return this as unknown as T; // is there any good way to do this without asserting? + } + digest(encoding: DigestEncoding): string; + digest(hashInto?: TypedArray): TypedArray; + digest(encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + if (typeof encodingOrHashInto === 'string') { + const encoded = this.#hash!.digest(encodingOrHashInto); + // you'd think node would throw an error if the encoding is invalid, but nope! + // instead it silently returns as if you passed no encoding and gives a Buffer... + if (Buffer.isBuffer(encoded)) throw new TypeError(`Unknown encoding: "${encodingOrHashInto}"`); + else return encoded; + } + const digested = this.#hash!.digest(); + if (encodingOrHashInto === undefined) return new Uint8Array(digested.buffer, digested.byteOffset, digested.byteLength); + if (encodingOrHashInto.byteLength < this.byteLength) throw new TypeError(`TypedArray must be at least ${this.byteLength} bytes`); + if (encodingOrHashInto instanceof BigInt64Array || encodingOrHashInto instanceof BigUint64Array) { + // avoid checking endianness for every loop iteration + const endianAwareInsert = os.endianness() === 'LE' + ? (arr: string[], j: number, num: string) => arr[7 - j] = num + : (arr: string[], j: number, num: string) => arr[j] = num; + + for (let i = 0; i < digested.byteLength; i += 8) { + const bigintStrArr = ['', '', '', '', '', '', '', '']; + for (let j = 0; j < 8; j++) { + const byte = digested[i + j]; + if (byte === undefined) break; + endianAwareInsert(bigintStrArr, j, byte.toString(16).padStart(2, '0')); + } + encodingOrHashInto[i / 8] = BigInt(`0x${bigintStrArr.join('')}`); + } + } else { + const HashIntoTypedArray = encodingOrHashInto.constructor as TypedArrayConstructor; + // this will work as long as all hash classes have a byteLength that is a multiple of 4 bytes + encodingOrHashInto.set(new HashIntoTypedArray(digested.buffer, digested.byteOffset, digested.byteLength / HashIntoTypedArray.BYTES_PER_ELEMENT)); + } + return encodingOrHashInto; + } + static hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { return '' }; + static readonly byteLength: number; + abstract readonly byteLength: number; +} + +export class SHA1 extends BaseHash { + constructor() { super('sha1'); } + static override readonly byteLength = 20; + override readonly byteLength = 20; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class MD4 extends BaseHash { + constructor() { //! Not supported by nodecrypto + const hash = md4.create() as unknown as Omit & { _update: Md4['update'] }; + function digest(): Buffer; + function digest(encoding: nodecrypto.BinaryToTextEncoding): string; + function digest(encoding?: nodecrypto.BinaryToTextEncoding) { + const buf = Buffer.from(hash.arrayBuffer()); + if (encoding) return buf.toString(encoding); + else return buf; + } + function update(data: nodecrypto.BinaryLike) { + if (typeof data === 'string') hash._update(data); + else if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) hash._update(new Uint8Array(data)); + else hash._update(new Uint8Array(data.buffer)); + return hash as unknown as MD4HashImpl; + } + type MD4HashImpl = Omit & { digest: typeof digest, update: typeof update }; + // @ts-expect-error patches to reuse the BaseHash methods + hash.digest = digest; hash._update = hash.update; hash.update = update; + super(hash as unknown as MD4HashImpl); + } + static override readonly byteLength = 16; + override readonly byteLength = 16; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class MD5 extends BaseHash { + constructor() { super('md5'); } + static override readonly byteLength = 16; + override readonly byteLength = 16; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class SHA224 extends BaseHash { + constructor() { super('sha224'); } + static override readonly byteLength = 28; + override readonly byteLength = 28; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class SHA512 extends BaseHash { + constructor() { super('sha512'); } + static override readonly byteLength = 64; + override readonly byteLength = 64; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class SHA384 extends BaseHash { + constructor() { super('sha384'); } + static override readonly byteLength = 48; + override readonly byteLength = 48; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class SHA256 extends BaseHash { + constructor() { super('sha256'); } + static override readonly byteLength = 32; + override readonly byteLength = 32; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} +export class SHA512_256 extends BaseHash { + constructor() { super('sha512-256'); } + static override readonly byteLength = 32; + override readonly byteLength = 32; + static override hash(data: StringOrBuffer, encoding?: DigestEncoding): string; + static override hash(data: StringOrBuffer, hashInto?: TypedArray): TypedArray; + static override hash(data: StringOrBuffer, encodingOrHashInto?: DigestEncoding | TypedArray): string | TypedArray { + const instance = new this(); instance.update(data); + return instance.digest(encodingOrHashInto as DigestEncoding & TypedArray); + } +} diff --git a/packages/bun-polyfills/src/modules/bun/transpiler.ts b/packages/bun-polyfills/src/modules/bun/transpiler.ts new file mode 100644 index 000000000..b4b95dae1 --- /dev/null +++ b/packages/bun-polyfills/src/modules/bun/transpiler.ts @@ -0,0 +1,103 @@ +import type { JavaScriptLoader, TranspilerOptions, Transpiler as BunTranspiler, Import } from 'bun'; +import { NotImplementedError } from '../../utils/errors.js'; + +// TODO: Possible implementation with WASM builds of bun with just the transpiler? +// NOTE: This is possible to implement with something like SWC, and was previously done, +// but it has lots of quirks due to the differences between SWC and Bun, so the plan is +// to not do that unless there is actual demand for using Bun.Transpiler in Node.js before +// the WASM build is worked on. The signatures are here for now as a placeholder. + +export default class Transpiler implements BunTranspiler { + constructor(options?: TranspilerOptions) { + this.#options = options ?? {}; + } + + async transform(code: StringOrBuffer, loader: JavaScriptLoader): Promise { + if (typeof code !== 'string') code = new TextDecoder().decode(code); + throw new NotImplementedError('Bun.Transpiler', this.transform); + } + + transformSync(code: StringOrBuffer, ctx: object): string; + transformSync(code: StringOrBuffer, loader: JavaScriptLoader, ctx: object): string; + transformSync(code: StringOrBuffer, loader?: JavaScriptLoader | undefined): string; + transformSync(code: StringOrBuffer, loader?: JavaScriptLoader | object, ctx: object = {}): string { + if (typeof code !== 'string') code = new TextDecoder().decode(code); + if (typeof loader !== 'string') loader = 'js'; + throw new NotImplementedError('Bun.Transpiler', this.transformSync); + } + + scan(code: StringOrBuffer): { exports: string[]; imports: Import[]; } { + if (typeof code !== 'string') code = new TextDecoder().decode(code); + throw new NotImplementedError('Bun.Transpiler', this.scan); + //return { + // imports: this.scanImports(code), + // exports: this.#scanExports(code) + //}; + } + + scanImports(code: StringOrBuffer): { + kind: 'import-statement' | 'dynamic-import'; + path: string; + }[] { + if (typeof code !== 'string') code = new TextDecoder().decode(code); + throw new NotImplementedError('Bun.Transpiler', this.scanImports); + //const imports: { kind: 'import-statement' | 'dynamic-import', path: string }[] = []; + //this.#scanTopLevelImports(code).forEach(x => imports.push({ kind: 'import-statement', path: x })); + //this.#scanDynamicImports(code).forEach(x => imports.push({ kind: 'dynamic-import', path: x })); + //return imports; + } + + /*#scanDynamicImports(code: string): string[] { + return this.parseSync(code, { + syntax: this.#syntax, target: 'es2022', tsx: this.#options.loader === 'tsx' + }).body.filter(x => x.type === 'ExpressionStatement' && x.expression.type === 'CallExpression' && x.expression.callee.type === 'Import') + .map(i => (((i as swc.ExpressionStatement).expression as swc.CallExpression).arguments[0].expression as swc.StringLiteral).value); + }*/ + + /*#scanTopLevelImports(code: string): string[] { + return this.parseSync(code, { + syntax: this.#syntax, target: 'es2022', tsx: this.#options.loader === 'tsx' + }).body.filter(x => x.type === 'ImportDeclaration' || x.type === 'ExportAllDeclaration' || x.type === 'ExportNamedDeclaration') + .filter(i => !(i as swc.ImportDeclaration).typeOnly) + .map(i => (i as swc.ImportDeclaration).source.value); + }*/ + + /*#scanExports(code: string, includeDefault: boolean = false): string[] { + const parsed = this.parseSync(code, { + syntax: this.#syntax, target: 'es2022', tsx: this.#options.loader === 'tsx' + }).body; + const exports = []; + exports.push(parsed.filter(x => x.type === 'ExportDeclaration' && !x.declaration.declare) + .flatMap(i => ((i as swc.ExportDeclaration).declaration as swc.ClassDeclaration).identifier?.value ?? + ((i as swc.ExportDeclaration).declaration as swc.VariableDeclaration).declarations.map(d => (d.id as swc.Identifier).value) + ) + ); + exports.push(parsed.filter(x => x.type === 'ExportNamedDeclaration') + .flatMap(i => (i as swc.ExportNamedDeclaration).specifiers + .filter(s => s.type === 'ExportSpecifier' && !s.isTypeOnly) + .map(s => (s as swc.NamedExportSpecifier).exported?.value ?? (s as swc.NamedExportSpecifier).orig.value) + ) + ); + if (includeDefault) exports.push(this.#scanDefaultExport(code) ?? []); + return exports.flat(); + }*/ + + /*#scanDefaultExport(code: string): 'default' | undefined { + const parsed = this.parseSync(code, { + syntax: this.#syntax, target: 'es2022', tsx: this.#options.loader === 'tsx' + }).body; + + const defaultExportDecl = parsed.find(x => x.type === 'ExportDefaultDeclaration') as swc.ExportDefaultDeclaration | undefined; + if (!defaultExportDecl) { + const defaultExportExpr = parsed.find(x => x.type === 'ExportDefaultExpression') as swc.ExportDefaultExpression | undefined; + if (!defaultExportExpr) return undefined; + if (!defaultExportExpr.expression.type.startsWith('Ts')) return 'default'; + else return undefined; + } + + if (!defaultExportDecl.decl.type.startsWith('Ts') && !Reflect.get(defaultExportDecl.decl, 'declare')) return 'default'; + else return undefined; + }*/ + + #options: TranspilerOptions; +} diff --git a/packages/bun-polyfills/src/repl.ts b/packages/bun-polyfills/src/repl.ts new file mode 100644 index 000000000..5cf673701 --- /dev/null +++ b/packages/bun-polyfills/src/repl.ts @@ -0,0 +1,29 @@ +import bun from './index.js'; + +// This file serves two purposes: +// 1. It is the entry point for using the Bun global in the REPL. (--import this file) +// 2. It makes TypeScript check the full structural compatibility of the Bun global vs the polyfills object, +// which allows for the type assertion below to be used as a TODO list index. + +globalThis.Bun = bun as typeof bun & { + // TODO: Missing polyfills + readableStreamToFormData: typeof import('bun').readableStreamToFormData; + deepEquals: typeof import('bun').deepEquals; + deepMatch: typeof import('bun').deepMatch; + build: typeof import('bun').build; + mmap: typeof import('bun').mmap; + gc: typeof import('bun').gc; + connect: typeof import('bun').connect; + listen: typeof import('bun').listen; + Transpiler: typeof import('bun').Transpiler; + password: typeof import('bun').password; + CryptoHashInterface: typeof import('bun').CryptoHashInterface; + CryptoHasher: typeof import('bun').CryptoHasher; + FileSystemRouter: typeof import('bun').FileSystemRouter; + + //? Polyfilled but with broken types (See each one in ./src/modules/bun.ts for details) + generateHeapSnapshot: typeof import('bun').generateHeapSnapshot; + stdout: typeof import('bun').stdout; + stderr: typeof import('bun').stderr; + stdin: typeof import('bun').stdin; +}; diff --git a/packages/bun-polyfills/src/types/helpers.d.ts b/packages/bun-polyfills/src/types/helpers.d.ts new file mode 100644 index 000000000..83726dadd --- /dev/null +++ b/packages/bun-polyfills/src/types/helpers.d.ts @@ -0,0 +1,13 @@ +type AnyFunction = (...args: any[]) => any; +type AnyClass = new (...args: any[]) => any; +type AnyCallable = AnyFunction | AnyClass; + +type MapKeysType> = T extends Map ? K : never; +type MapValuesType> = T extends Map ? V : never; + +type Mutable = { -readonly [K in keyof T]: T[K] }; + +/** Excluding the BigInt typed arrays */ +type TypedArrayConstructor = + | typeof Uint8Array | typeof Uint16Array | typeof Uint32Array | typeof Uint8ClampedArray + | typeof Int8Array | typeof Int16Array | typeof Int32Array | typeof Float32Array | typeof Float64Array; diff --git a/packages/bun-polyfills/src/types/md4.d.ts b/packages/bun-polyfills/src/types/md4.d.ts new file mode 100644 index 000000000..30413396e --- /dev/null +++ b/packages/bun-polyfills/src/types/md4.d.ts @@ -0,0 +1,72 @@ +declare module 'js-md4' { + export type MD4Input = string | ArrayBuffer | Uint8Array | number[]; + + interface md4 { + /** + * # Broken, will throw an error. + * @deprecated Use {@link md4.hex} instead. + */ + (input: MD4Input): never; + /** Creates an `Md4` hasher instance. */ + create(): Md4; + /** Shortcut for `md4.create().update(...)` */ + update(message: MD4Input): Md4; + /** Hash `message` into a hex string. */ + hex(message: MD4Input): string; + /** Hash `message` into an Array. */ + array(message: MD4Input): number[]; + /** Identical to {@link md4.array}. */ + digest(message: MD4Input): number[]; + /** + * Identical to {@link md4.arrayBuffer}. + * @deprecated Use {@link md4.arrayBuffer} instead. + */ + buffer(message: MD4Input): ArrayBuffer; + /** Hash `message` into an ArrayBuffer. */ + arrayBuffer(message: MD4Input): ArrayBuffer; + } + + export type Md4 = Md4; + declare class Md4 { + private constructor(); + + private toString(): string; + private finalize(): void; + private hash(): void; + /** + * Append `message` to the internal hash source data. + * @returns A reference to `this` for chaining, or nothing if the instance has been finalized. + */ + update(message: MD4Input): this | void; + /** Hash into a hex string. Finalizes the hash. */ + hex(): string; + /** Hash into an Array. Finalizes the hash. */ + array(): number[]; + /** Identical to {@link Md4.array}. */ + digest(): number[]; + /** + * Identical to {@link Md4.arrayBuffer}. + * @deprecated Use {@link Md4.arrayBuffer} instead. + */ + buffer(): ArrayBuffer; + /** Hash into an ArrayBuffer. Finalizes the hash. */ + arrayBuffer(): ArrayBuffer; + + private buffer8: Uint8Array; + private blocks: Uint32Array; + private bytes: number; + private start: number; + private h3: number; + private h2: number; + private h1: number; + private h0: number; + readonly hashed: boolean; + /** If true, `update()` operations will silently fail. */ + readonly finalized: boolean; + readonly first: boolean; + private lastByteIndex?: number; + } + + const md4: md4; + export default md4; +} diff --git a/packages/bun-polyfills/src/types/sync.d.ts b/packages/bun-polyfills/src/types/sync.d.ts new file mode 100644 index 000000000..87e6794e0 --- /dev/null +++ b/packages/bun-polyfills/src/types/sync.d.ts @@ -0,0 +1,15 @@ +// This file explicitly redefines global types used in order to enforce the correct types, +// regardless of the arbitrary order in which TSC/TSServer decide to load the type libraries in. +// Annoyingly, even this file can sometimes break, so if your types are inverted, try restarting TSServer. + +import '@types/node'; + +declare module 'stream/web' { + interface ReadableStreamDefaultReader { + readMany(): Promise>; + } +} + +declare global { + var performance: typeof import('perf_hooks').performance; +} diff --git a/packages/bun-polyfills/src/types/v8heapsnapshot.d.ts b/packages/bun-polyfills/src/types/v8heapsnapshot.d.ts new file mode 100644 index 000000000..ed39cad06 --- /dev/null +++ b/packages/bun-polyfills/src/types/v8heapsnapshot.d.ts @@ -0,0 +1,24 @@ +interface V8HeapSnapshot { + snapshot: { + meta: { + node_fields: string[], + node_types: [string[], ...string[]], + edge_fields: string[], + edge_types: [string[], ...string[]], + trace_function_info_fields: string[], + trace_node_fields: string[], + sample_fields: string[], + location_fields: string[] + }, + node_count: number, + edge_count: number, + trace_function_count: number + }, + nodes: number[], + edges: number[], + trace_function_infos: unknown[], + trace_tree: unknown[], + samples: unknown[], + locations: number[], + strings: string[] +} diff --git a/packages/bun-polyfills/src/utils/errors.ts b/packages/bun-polyfills/src/utils/errors.ts new file mode 100644 index 000000000..cc82efdf0 --- /dev/null +++ b/packages/bun-polyfills/src/utils/errors.ts @@ -0,0 +1,221 @@ +type PosixErrNo = MapKeysType>; +type Win32ErrNo = MapKeysType>; + +export function getPosixSystemErrorMap() { + return new Map([ + [ -7, [ 'E2BIG', 'argument list too long' ] ], + [ -13, [ 'EACCES', 'permission denied' ] ], + [ -98, [ 'EADDRINUSE', 'address already in use' ] ], + [ -99, [ 'EADDRNOTAVAIL', 'address not available' ] ], + [ -97, [ 'EAFNOSUPPORT', 'address family not supported' ] ], + [ -11, [ 'EAGAIN', 'resource temporarily unavailable' ] ], + [ -3000, [ 'EAI_ADDRFAMILY', 'address family not supported' ] ], + [ -3001, [ 'EAI_AGAIN', 'temporary failure' ] ], + [ -3002, [ 'EAI_BADFLAGS', 'bad ai_flags value' ] ], + [ -3013, [ 'EAI_BADHINTS', 'invalid value for hints' ] ], + [ -3003, [ 'EAI_CANCELED', 'request canceled' ] ], + [ -3004, [ 'EAI_FAIL', 'permanent failure' ] ], + [ -3005, [ 'EAI_FAMILY', 'ai_family not supported' ] ], + [ -3006, [ 'EAI_MEMORY', 'out of memory' ] ], + [ -3007, [ 'EAI_NODATA', 'no address' ] ], + [ -3008, [ 'EAI_NONAME', 'unknown node or service' ] ], + [ -3009, [ 'EAI_OVERFLOW', 'argument buffer overflow' ] ], + [ -3014, [ 'EAI_PROTOCOL', 'resolved protocol is unknown' ] ], + [ -3010, [ 'EAI_SERVICE', 'service not available for socket type' ] ], + [ -3011, [ 'EAI_SOCKTYPE', 'socket type not supported' ] ], + [ -114, [ 'EALREADY', 'connection already in progress' ] ], + [ -9, [ 'EBADF', 'bad file descriptor' ] ], + [ -16, [ 'EBUSY', 'resource busy or locked' ] ], + [ -125, [ 'ECANCELED', 'operation canceled' ] ], + [ -4080, [ 'ECHARSET', 'invalid Unicode character' ] ], + [ -103, [ 'ECONNABORTED', 'software caused connection abort' ] ], + [ -111, [ 'ECONNREFUSED', 'connection refused' ] ], + [ -104, [ 'ECONNRESET', 'connection reset by peer' ] ], + [ -89, [ 'EDESTADDRREQ', 'destination address required' ] ], + [ -17, [ 'EEXIST', 'file already exists' ] ], + [ -14, [ 'EFAULT', 'bad address in system call argument' ] ], + [ -27, [ 'EFBIG', 'file too large' ] ], + [ -113, [ 'EHOSTUNREACH', 'host is unreachable' ] ], + [ -4, [ 'EINTR', 'interrupted system call' ] ], + [ -22, [ 'EINVAL', 'invalid argument' ] ], + [ -5, [ 'EIO', 'i/o error' ] ], + [ -106, [ 'EISCONN', 'socket is already connected' ] ], + [ -21, [ 'EISDIR', 'illegal operation on a directory' ] ], + [ -40, [ 'ELOOP', 'too many symbolic links encountered' ] ], + [ -24, [ 'EMFILE', 'too many open files' ] ], + [ -90, [ 'EMSGSIZE', 'message too long' ] ], + [ -36, [ 'ENAMETOOLONG', 'name too long' ] ], + [ -100, [ 'ENETDOWN', 'network is down' ] ], + [ -101, [ 'ENETUNREACH', 'network is unreachable' ] ], + [ -23, [ 'ENFILE', 'file table overflow' ] ], + [ -105, [ 'ENOBUFS', 'no buffer space available' ] ], + [ -19, [ 'ENODEV', 'no such device' ] ], + [ -2, [ 'ENOENT', 'no such file or directory' ] ], + [ -12, [ 'ENOMEM', 'not enough memory' ] ], + [ -64, [ 'ENONET', 'machine is not on the network' ] ], + [ -92, [ 'ENOPROTOOPT', 'protocol not available' ] ], + [ -28, [ 'ENOSPC', 'no space left on device' ] ], + [ -38, [ 'ENOSYS', 'function not implemented' ] ], + [ -107, [ 'ENOTCONN', 'socket is not connected' ] ], + [ -20, [ 'ENOTDIR', 'not a directory' ] ], + [ -39, [ 'ENOTEMPTY', 'directory not empty' ] ], + [ -88, [ 'ENOTSOCK', 'socket operation on non-socket' ] ], + [ -95, [ 'ENOTSUP', 'operation not supported on socket' ] ], + [ -75, [ 'EOVERFLOW', 'value too large for defined data type' ] ], + [ -1, [ 'EPERM', 'operation not permitted' ] ], + [ -32, [ 'EPIPE', 'broken pipe' ] ], + [ -71, [ 'EPROTO', 'protocol error' ] ], + [ -93, [ 'EPROTONOSUPPORT', 'protocol not supported' ] ], + [ -91, [ 'EPROTOTYPE', 'protocol wrong type for socket' ] ], + [ -34, [ 'ERANGE', 'result too large' ] ], + [ -30, [ 'EROFS', 'read-only file system' ] ], + [ -108, [ 'ESHUTDOWN', 'cannot send after transport endpoint shutdown' ] ], + [ -29, [ 'ESPIPE', 'invalid seek' ] ], + [ -3, [ 'ESRCH', 'no such process' ] ], + [ -110, [ 'ETIMEDOUT', 'connection timed out' ] ], + [ -26, [ 'ETXTBSY', 'text file is busy' ] ], + [ -18, [ 'EXDEV', 'cross-device link not permitted' ] ], + [ -4094, [ 'UNKNOWN', 'unknown error' ] ], + [ -4095, [ 'EOF', 'end of file' ] ], + [ -6, [ 'ENXIO', 'no such device or address' ] ], + [ -31, [ 'EMLINK', 'too many links' ] ], + [ -112, [ 'EHOSTDOWN', 'host is down' ] ], + [ -121, [ 'EREMOTEIO', 'remote I/O error' ] ], + [ -25, [ 'ENOTTY', 'inappropriate ioctl for device' ] ], + [ -4028, [ 'EFTYPE', 'inappropriate file type or format' ] ], + [ -84, [ 'EILSEQ', 'illegal byte sequence' ] ], + [ -94, [ 'ESOCKTNOSUPPORT', 'socket type not supported' ] ] + ] as const); +} + +export function getWin32SystemErrorMap() { + return new Map([ + [ -4093, [ 'E2BIG', 'argument list too long' ] ], + [ -4092, [ 'EACCES', 'permission denied' ] ], + [ -4091, [ 'EADDRINUSE', 'address already in use' ] ], + [ -4090, [ 'EADDRNOTAVAIL', 'address not available' ] ], + [ -4089, [ 'EAFNOSUPPORT', 'address family not supported' ] ], + [ -4088, [ 'EAGAIN', 'resource temporarily unavailable' ] ], + [ -3000, [ 'EAI_ADDRFAMILY', 'address family not supported' ] ], + [ -3001, [ 'EAI_AGAIN', 'temporary failure' ] ], + [ -3002, [ 'EAI_BADFLAGS', 'bad ai_flags value' ] ], + [ -3013, [ 'EAI_BADHINTS', 'invalid value for hints' ] ], + [ -3003, [ 'EAI_CANCELED', 'request canceled' ] ], + [ -3004, [ 'EAI_FAIL', 'permanent failure' ] ], + [ -3005, [ 'EAI_FAMILY', 'ai_family not supported' ] ], + [ -3006, [ 'EAI_MEMORY', 'out of memory' ] ], + [ -3007, [ 'EAI_NODATA', 'no address' ] ], + [ -3008, [ 'EAI_NONAME', 'unknown node or service' ] ], + [ -3009, [ 'EAI_OVERFLOW', 'argument buffer overflow' ] ], + [ -3014, [ 'EAI_PROTOCOL', 'resolved protocol is unknown' ] ], + [ -3010, [ 'EAI_SERVICE', 'service not available for socket type' ] ], + [ -3011, [ 'EAI_SOCKTYPE', 'socket type not supported' ] ], + [ -4084, [ 'EALREADY', 'connection already in progress' ] ], + [ -4083, [ 'EBADF', 'bad file descriptor' ] ], + [ -4082, [ 'EBUSY', 'resource busy or locked' ] ], + [ -4081, [ 'ECANCELED', 'operation canceled' ] ], + [ -4080, [ 'ECHARSET', 'invalid Unicode character' ] ], + [ -4079, [ 'ECONNABORTED', 'software caused connection abort' ] ], + [ -4078, [ 'ECONNREFUSED', 'connection refused' ] ], + [ -4077, [ 'ECONNRESET', 'connection reset by peer' ] ], + [ -4076, [ 'EDESTADDRREQ', 'destination address required' ] ], + [ -4075, [ 'EEXIST', 'file already exists' ] ], + [ -4074, [ 'EFAULT', 'bad address in system call argument' ] ], + [ -4036, [ 'EFBIG', 'file too large' ] ], + [ -4073, [ 'EHOSTUNREACH', 'host is unreachable' ] ], + [ -4072, [ 'EINTR', 'interrupted system call' ] ], + [ -4071, [ 'EINVAL', 'invalid argument' ] ], + [ -4070, [ 'EIO', 'i/o error' ] ], + [ -4069, [ 'EISCONN', 'socket is already connected' ] ], + [ -4068, [ 'EISDIR', 'illegal operation on a directory' ] ], + [ -4067, [ 'ELOOP', 'too many symbolic links encountered' ] ], + [ -4066, [ 'EMFILE', 'too many open files' ] ], + [ -4065, [ 'EMSGSIZE', 'message too long' ] ], + [ -4064, [ 'ENAMETOOLONG', 'name too long' ] ], + [ -4063, [ 'ENETDOWN', 'network is down' ] ], + [ -4062, [ 'ENETUNREACH', 'network is unreachable' ] ], + [ -4061, [ 'ENFILE', 'file table overflow' ] ], + [ -4060, [ 'ENOBUFS', 'no buffer space available' ] ], + [ -4059, [ 'ENODEV', 'no such device' ] ], + [ -4058, [ 'ENOENT', 'no such file or directory' ] ], + [ -4057, [ 'ENOMEM', 'not enough memory' ] ], + [ -4056, [ 'ENONET', 'machine is not on the network' ] ], + [ -4035, [ 'ENOPROTOOPT', 'protocol not available' ] ], + [ -4055, [ 'ENOSPC', 'no space left on device' ] ], + [ -4054, [ 'ENOSYS', 'function not implemented' ] ], + [ -4053, [ 'ENOTCONN', 'socket is not connected' ] ], + [ -4052, [ 'ENOTDIR', 'not a directory' ] ], + [ -4051, [ 'ENOTEMPTY', 'directory not empty' ] ], + [ -4050, [ 'ENOTSOCK', 'socket operation on non-socket' ] ], + [ -4049, [ 'ENOTSUP', 'operation not supported on socket' ] ], + [ -4026, [ 'EOVERFLOW', 'value too large for defined data type' ] ], + [ -4048, [ 'EPERM', 'operation not permitted' ] ], + [ -4047, [ 'EPIPE', 'broken pipe' ] ], + [ -4046, [ 'EPROTO', 'protocol error' ] ], + [ -4045, [ 'EPROTONOSUPPORT', 'protocol not supported' ] ], + [ -4044, [ 'EPROTOTYPE', 'protocol wrong type for socket' ] ], + [ -4034, [ 'ERANGE', 'result too large' ] ], + [ -4043, [ 'EROFS', 'read-only file system' ] ], + [ -4042, [ 'ESHUTDOWN', 'cannot send after transport endpoint shutdown' ] ], + [ -4041, [ 'ESPIPE', 'invalid seek' ] ], + [ -4040, [ 'ESRCH', 'no such process' ] ], + [ -4039, [ 'ETIMEDOUT', 'connection timed out' ] ], + [ -4038, [ 'ETXTBSY', 'text file is busy' ] ], + [ -4037, [ 'EXDEV', 'cross-device link not permitted' ] ], + [ -4094, [ 'UNKNOWN', 'unknown error' ] ], + [ -4095, [ 'EOF', 'end of file' ] ], + [ -4033, [ 'ENXIO', 'no such device or address' ] ], + [ -4032, [ 'EMLINK', 'too many links' ] ], + [ -4031, [ 'EHOSTDOWN', 'host is down' ] ], + [ -4030, [ 'EREMOTEIO', 'remote I/O error' ] ], + [ -4029, [ 'ENOTTY', 'inappropriate ioctl for device' ] ], + [ -4028, [ 'EFTYPE', 'inappropriate file type or format' ] ], + [ -4027, [ 'EILSEQ', 'illegal byte sequence' ] ], + [ -4025, [ 'ESOCKTNOSUPPORT', 'socket type not supported' ] ] + ] as const); +} + +export function getPosixToWin32SystemErrorMap() { + const posixEntries = [...getPosixSystemErrorMap().entries()]; + const win32Entries = [...getWin32SystemErrorMap().entries()]; + const map: Map = new Map(); + posixEntries.forEach(([code, val]) => { + const found = win32Entries.find(([_, v]) => v[0] === val[0]); + if (!found) console.error(val[0]); + else map.set(code, found[0]); + }); + return map; +} + +export function getPlatformSystemErrorFromPosix(posixErrNo: PosixErrNo) { + if (process.platform === 'win32') { + const win32errno = getPosixToWin32SystemErrorMap().get(posixErrNo)!; + return getWin32SystemErrorMap().get(win32errno); + } else { + return getPosixSystemErrorMap().get(posixErrNo); + } +} + +export class SystemError extends Error { + constructor(errno: PosixErrNo, syscall?: string, errpath?: string) { + const [errname, errmsg] = getPlatformSystemErrorFromPosix(errno) ?? ['SystemError', 'Unknown system error']; + super(errmsg); + this.name = errname; + this.code = errname; + this.errno = errno; + if (syscall) this.syscall = syscall; + if (errpath) this.path = errpath; + } + errno?: number | undefined; + code?: string | undefined; + path?: string | undefined; + syscall?: string | undefined; +} + +export class NotImplementedError extends Error { + constructor(thing: string, func: AnyCallable = NotImplementedError, overrideMsg: boolean = false) { + super(overrideMsg ? thing : `A polyfill for ${thing} is not yet implemented by bun-polyfills.`); + this.name = 'NotImplementedError'; + Error.captureStackTrace(this, func); + } +} diff --git a/packages/bun-polyfills/src/utils/misc.ts b/packages/bun-polyfills/src/utils/misc.ts new file mode 100644 index 000000000..74bb9aa01 --- /dev/null +++ b/packages/bun-polyfills/src/utils/misc.ts @@ -0,0 +1,36 @@ +import streams from 'node:stream'; +import type { SpawnOptions, FileBlob } from 'bun'; + +export const getter = (obj: T, key: string | symbol, get: () => any, enumerable = false, configurable = true): void => { + Object.defineProperty(obj, key, { get, configurable, enumerable }); +}; + +export const setter = (obj: T, key: string | symbol, set: () => any, enumerable = false, configurable = true): void => { + Object.defineProperty(obj, key, { set, configurable, enumerable }); +}; + +export const readonly = (obj: T, key: string | symbol, value: unknown, enumerable = false, configurable = true): void => { + Object.defineProperty(obj, key, { value, configurable, enumerable }); +}; + +export function streamToBuffer(stream: streams.Readable | streams.Duplex): Promise { + return new Promise((resolve, reject) => { + const buffers: Uint8Array[] = []; + stream.on("data", (chunk: Uint8Array) => buffers.push(chunk)); + stream.on("end", () => resolve(Buffer.concat(buffers))); + stream.on("error", (err: Error) => reject(err)); + }); +} + +export function isArrayBufferView(value: any): value is ArrayBufferView { + return value !== null && typeof value === 'object' && + value.buffer instanceof ArrayBuffer && typeof value.byteLength === 'number' && typeof value.byteOffset === 'number'; +} + +export function isOptions(options: any): options is SpawnOptions.OptionsObject { + return options !== null && typeof options === 'object'; +} + +export function isFileBlob(blob: any): blob is FileBlob { + return blob instanceof Blob && Reflect.get(blob, 'readable') instanceof ReadableStream && typeof Reflect.get(blob, 'writer') === 'function'; +} diff --git a/packages/bun-polyfills/tsconfig.json b/packages/bun-polyfills/tsconfig.json new file mode 100644 index 000000000..b00abe344 --- /dev/null +++ b/packages/bun-polyfills/tsconfig.json @@ -0,0 +1,19 @@ +{ + "compilerOptions": { + "lib": ["ESNext"], + "module": "esnext", + "target": "esnext", + "moduleResolution": "nodenext", + "moduleDetection": "force", + "strict": true, + "downlevelIteration": true, + "skipLibCheck": true, + "allowSyntheticDefaultImports": true, + "forceConsistentCasingInFileNames": true, + "inlineSourceMap": true, + "allowJs": true, + "outDir": "dist", + "types": ["node"] + }, + "include": [".", "../bun-types/index.d.ts"], +} diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts index 20f247d91..7e8102c87 100644 --- a/packages/bun-types/bun.d.ts +++ b/packages/bun-types/bun.d.ts @@ -24,7 +24,7 @@ declare module "bun" { import { Encoding as CryptoEncoding } from "crypto"; export interface Env extends Dict, NodeJS.ProcessEnv { - NODE_ENV: string; + NODE_ENV?: string; /** * The timezone used by Intl, Date, etc. @@ -68,7 +68,7 @@ declare module "bun" { export function which( command: string, options?: { PATH?: string; cwd?: string }, - ): string; + ): string | null; export type Serve = | ServeOptions @@ -752,39 +752,40 @@ declare module "bun" { */ export const hash: (( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - seed?: number, + seed?: number | bigint, ) => number | bigint) & Hash; interface Hash { wyhash: ( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - seed?: number, - ) => number | bigint; - crc32: ( - data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - seed?: number, - ) => number | bigint; + seed?: bigint, + ) => bigint; adler32: ( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - seed?: number, - ) => number | bigint; + ) => number; + crc32: ( + data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, + ) => number; cityHash32: ( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - seed?: number, - ) => number | bigint; + ) => number; cityHash64: ( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, - seed?: number, - ) => number | bigint; + seed?: bigint, + ) => bigint; murmur32v3: ( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, seed?: number, - ) => number | bigint; - murmur64v2: ( + ) => number; + murmur32v2: ( data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, seed?: number, - ) => number | bigint; + ) => number; + murmur64v2: ( + data: string | ArrayBufferView | ArrayBuffer | SharedArrayBuffer, + seed?: bigint, + ) => bigint; } export type JavaScriptLoader = "jsx" | "js" | "ts" | "tsx"; @@ -2428,8 +2429,8 @@ declare module "bun" { * If you have any ideas, please file an issue https://github.com/oven-sh/bun */ interface HeapSnapshot { - /** "2" */ - version: string; + /** 2 */ + version: number; /** "Inspector" */ type: string; @@ -2675,7 +2676,7 @@ declare module "bun" { * openssl sha512-256 /path/to/file *``` */ - export function sha(input: StringOrBuffer, hashInto?: Uint8Array): Uint8Array; + export function sha(input: StringOrBuffer, hashInto?: TypedArray): TypedArray; /** * diff --git a/packages/bun-types/globals.d.ts b/packages/bun-types/globals.d.ts index 71403eb80..1a10cc8e0 100644 --- a/packages/bun-types/globals.d.ts +++ b/packages/bun-types/globals.d.ts @@ -2648,10 +2648,6 @@ interface ReadableStream { options?: StreamPipeOptions, ): Promise; tee(): [ReadableStream, ReadableStream]; - forEach( - callbackfn: (value: any, key: number, parent: ReadableStream) => void, - thisArg?: any, - ): void; [Symbol.asyncIterator](): AsyncIterableIterator; values(options?: { preventCancel: boolean }): AsyncIterableIterator; } diff --git a/packages/bun-types/tests/hashing.test-d.ts b/packages/bun-types/tests/hashing.test-d.ts index bd9222541..16d65737d 100644 --- a/packages/bun-types/tests/hashing.test-d.ts +++ b/packages/bun-types/tests/hashing.test-d.ts @@ -1 +1 @@ -Bun.hash.wyhash("asdf", 1234); +const hash: bigint = Bun.hash.wyhash("asdf", 1234n); -- cgit v1.2.3