diff options
Diffstat (limited to 'src/js/out/modules_dev/node/fs.js')
| -rw-r--r-- | src/js/out/modules_dev/node/fs.js | 681 |
1 files changed, 681 insertions, 0 deletions
diff --git a/src/js/out/modules_dev/node/fs.js b/src/js/out/modules_dev/node/fs.js new file mode 100644 index 000000000..ffb8d1b8a --- /dev/null +++ b/src/js/out/modules_dev/node/fs.js @@ -0,0 +1,681 @@ +var callbackify = function(fsFunction, args) { + try { + const result = fsFunction.apply(fs, args.slice(0, args.length - 1)), callback = args[args.length - 1]; + if (typeof callback === "function") + queueMicrotask(() => callback(null, result)); + } catch (e) { + const callback = args[args.length - 1]; + if (typeof callback === "function") + queueMicrotask(() => callback(e)); + } +}; +function createReadStream(path, options) { + return new ReadStream(path, options); +} +function createWriteStream(path, options) { + return new WriteStream(path, options); +} +var { direct, isPromise, isCallable } = import.meta.primordials, promises = import.meta.require("node:fs/promises"), { Readable, NativeWritable, _getNativeReadableStreamPrototype, eos: eos_ } = import.meta.require("node:stream"), NativeReadable = _getNativeReadableStreamPrototype(2, Readable), fs = Bun.fs(), debug = process.env.DEBUG ? console.log : () => { +}, access = function access2(...args) { + callbackify(fs.accessSync, args); +}, appendFile = function appendFile2(...args) { + callbackify(fs.appendFileSync, args); +}, close = function close2(...args) { + callbackify(fs.closeSync, args); +}, rm = function rm2(...args) { + callbackify(fs.rmSync, args); +}, rmdir = function rmdir2(...args) { + callbackify(fs.rmdirSync, args); +}, copyFile = function copyFile2(...args) { + callbackify(fs.copyFileSync, args); +}, exists = function exists2(...args) { + callbackify(fs.existsSync, args); +}, chown = function chown2(...args) { + callbackify(fs.chownSync, args); +}, chmod = function chmod2(...args) { + callbackify(fs.chmodSync, args); +}, fchmod = function fchmod2(...args) { + callbackify(fs.fchmodSync, args); +}, fchown = function fchown2(...args) { + callbackify(fs.fchownSync, args); +}, fstat = function fstat2(...args) { + callbackify(fs.fstatSync, args); +}, fsync = function fsync2(...args) { + callbackify(fs.fsyncSync, args); +}, ftruncate = function ftruncate2(...args) { + callbackify(fs.ftruncateSync, args); +}, futimes = function futimes2(...args) { + callbackify(fs.futimesSync, args); +}, lchmod = function lchmod2(...args) { + callbackify(fs.lchmodSync, args); +}, lchown = function lchown2(...args) { + callbackify(fs.lchownSync, args); +}, link = function link2(...args) { + callbackify(fs.linkSync, args); +}, lstat = function lstat2(...args) { + callbackify(fs.lstatSync, args); +}, mkdir = function mkdir2(...args) { + callbackify(fs.mkdirSync, args); +}, mkdtemp = function mkdtemp2(...args) { + callbackify(fs.mkdtempSync, args); +}, open = function open2(...args) { + callbackify(fs.openSync, args); +}, read = function read2(...args) { + callbackify(fs.readSync, args); +}, write = function write2(...args) { + callbackify(fs.writeSync, args); +}, readdir = function readdir2(...args) { + callbackify(fs.readdirSync, args); +}, readFile = function readFile2(...args) { + callbackify(fs.readFileSync, args); +}, writeFile = function writeFile2(...args) { + callbackify(fs.writeFileSync, args); +}, readlink = function readlink2(...args) { + callbackify(fs.readlinkSync, args); +}, realpath = function realpath2(...args) { + callbackify(fs.realpathSync, args); +}, rename = function rename2(...args) { + callbackify(fs.renameSync, args); +}, stat = function stat2(...args) { + callbackify(fs.statSync, args); +}, symlink = function symlink2(...args) { + callbackify(fs.symlinkSync, args); +}, truncate = function truncate2(...args) { + callbackify(fs.truncateSync, args); +}, unlink = function unlink2(...args) { + callbackify(fs.unlinkSync, args); +}, utimes = function utimes2(...args) { + callbackify(fs.utimesSync, args); +}, lutimes = function lutimes2(...args) { + callbackify(fs.lutimesSync, args); +}, accessSync = fs.accessSync.bind(fs), appendFileSync = fs.appendFileSync.bind(fs), closeSync = fs.closeSync.bind(fs), copyFileSync = fs.copyFileSync.bind(fs), existsSync = fs.existsSync.bind(fs), chownSync = fs.chownSync.bind(fs), chmodSync = fs.chmodSync.bind(fs), fchmodSync = fs.fchmodSync.bind(fs), fchownSync = fs.fchownSync.bind(fs), fstatSync = fs.fstatSync.bind(fs), fsyncSync = fs.fsyncSync.bind(fs), ftruncateSync = fs.ftruncateSync.bind(fs), futimesSync = fs.futimesSync.bind(fs), lchmodSync = fs.lchmodSync.bind(fs), lchownSync = fs.lchownSync.bind(fs), linkSync = fs.linkSync.bind(fs), lstatSync = fs.lstatSync.bind(fs), mkdirSync = fs.mkdirSync.bind(fs), mkdtempSync = fs.mkdtempSync.bind(fs), openSync = fs.openSync.bind(fs), readSync = fs.readSync.bind(fs), writeSync = fs.writeSync.bind(fs), readdirSync = fs.readdirSync.bind(fs), readFileSync = fs.readFileSync.bind(fs), writeFileSync = fs.writeFileSync.bind(fs), readlinkSync = fs.readlinkSync.bind(fs), realpathSync = fs.realpathSync.bind(fs), renameSync = fs.renameSync.bind(fs), statSync = fs.statSync.bind(fs), symlinkSync = fs.symlinkSync.bind(fs), truncateSync = fs.truncateSync.bind(fs), unlinkSync = fs.unlinkSync.bind(fs), utimesSync = fs.utimesSync.bind(fs), lutimesSync = fs.lutimesSync.bind(fs), rmSync = fs.rmSync.bind(fs), rmdirSync = fs.rmdirSync.bind(fs), Dirent = fs.Dirent, Stats = fs.Stats, promises = import.meta.require("node:fs/promises"), readStreamPathFastPathSymbol = Symbol.for("Bun.Node.readStreamPathFastPath"), readStreamSymbol = Symbol.for("Bun.NodeReadStream"), readStreamPathOrFdSymbol = Symbol.for("Bun.NodeReadStreamPathOrFd"), writeStreamSymbol = Symbol.for("Bun.NodeWriteStream"), writeStreamPathFastPathSymbol = Symbol.for("Bun.NodeWriteStreamFastPath"), writeStreamPathFastPathCallSymbol = Symbol.for("Bun.NodeWriteStreamFastPathCall"), kIoDone = Symbol.for("kIoDone"), defaultReadStreamOptions = { + file: void 0, + fd: void 0, + flags: "r", + encoding: void 0, + mode: 438, + autoClose: !0, + emitClose: !0, + start: 0, + end: Infinity, + highWaterMark: 65536, + fs: { + read, + open: (path, flags, mode, cb) => { + var fd; + try { + fd = openSync(path, flags, mode); + } catch (e) { + cb(e); + return; + } + cb(null, fd); + }, + openSync, + close + }, + autoDestroy: !0 +}, ReadStreamClass, ReadStream = function(InternalReadStream) { + return ReadStreamClass = InternalReadStream, Object.defineProperty(ReadStreamClass.prototype, Symbol.toStringTag, { + value: "ReadStream", + enumerable: !1 + }), Object.defineProperty(function ReadStream(path, options) { + return new InternalReadStream(path, options); + }, Symbol.hasInstance, { + value(instance) { + return instance instanceof InternalReadStream; + } + }); +}(class ReadStream2 extends NativeReadable { + constructor(pathOrFd, options = defaultReadStreamOptions) { + if (typeof options !== "object" || !options) + throw new TypeError("Expected options to be an object"); + var { + flags = defaultReadStreamOptions.flags, + encoding = defaultReadStreamOptions.encoding, + mode = defaultReadStreamOptions.mode, + autoClose = defaultReadStreamOptions.autoClose, + emitClose = defaultReadStreamOptions.emitClose, + start = defaultReadStreamOptions.start, + end = defaultReadStreamOptions.end, + autoDestroy = defaultReadStreamOptions.autoClose, + fs: fs2 = defaultReadStreamOptions.fs, + highWaterMark = defaultReadStreamOptions.highWaterMark + } = options; + if (pathOrFd?.constructor?.name === "URL") + pathOrFd = Bun.fileURLToPath(pathOrFd); + var tempThis = {}; + if (typeof pathOrFd === "string") { + if (pathOrFd.startsWith("file://")) + pathOrFd = Bun.fileURLToPath(pathOrFd); + if (pathOrFd.length === 0) + throw new TypeError("Expected path to be a non-empty string"); + tempThis.path = tempThis.file = tempThis[readStreamPathOrFdSymbol] = pathOrFd; + } else if (typeof pathOrFd === "number") { + if (pathOrFd |= 0, pathOrFd < 0) + throw new TypeError("Expected fd to be a positive integer"); + tempThis.fd = tempThis[readStreamPathOrFdSymbol] = pathOrFd, tempThis.autoClose = !1; + } else + throw new TypeError("Expected a path or file descriptor"); + if (!tempThis.fd) + tempThis.fd = fs2.openSync(pathOrFd, flags, mode); + var fileRef = Bun.file(tempThis.fd), stream = fileRef.stream(), native = direct(stream); + if (!native) + throw debug("no native readable stream"), new Error("no native readable stream"); + var { stream: ptr } = native; + super(ptr, { + ...options, + encoding, + autoDestroy, + autoClose, + emitClose, + highWaterMark + }); + if (Object.assign(this, tempThis), this.#fileRef = fileRef, this.end = end, this._read = this.#internalRead, this.start = start, this.flags = flags, this.mode = mode, this.emitClose = emitClose, this[readStreamPathFastPathSymbol] = start === 0 && end === Infinity && autoClose && fs2 === defaultReadStreamOptions.fs && (encoding === "buffer" || encoding === "binary" || encoding == null || encoding === "utf-8" || encoding === "utf8"), this._readableState.autoClose = autoDestroy = autoClose, this._readableState.highWaterMark = highWaterMark, start !== void 0) + this.pos = start; + } + #fileRef; + #fs; + file; + path; + fd = null; + flags; + mode; + start; + end; + pos; + bytesRead = 0; + #fileSize = -1; + _read; + [readStreamSymbol] = !0; + [readStreamPathOrFdSymbol]; + [readStreamPathFastPathSymbol]; + _construct(callback) { + if (super._construct) + super._construct(callback); + else + callback(); + this.emit("open", this.fd), this.emit("ready"); + } + _destroy(err, cb) { + super._destroy(err, cb); + try { + var fd = this.fd; + if (this[readStreamPathFastPathSymbol] = !1, !fd) + cb(err); + else + this.#fs.close(fd, (er) => { + cb(er || err); + }), this.fd = null; + } catch (e) { + throw e; + } + } + close(cb) { + if (typeof cb === "function") + eos_()(this, cb); + this.destroy(); + } + push(chunk) { + var bytesRead = chunk?.length ?? 0; + if (bytesRead > 0) { + this.bytesRead += bytesRead; + var currPos = this.pos; + if (currPos !== void 0) { + if (this.bytesRead < currPos) + return !0; + if (currPos === this.start) { + var n = this.bytesRead - currPos; + chunk = chunk.slice(-n); + var [_, ...rest] = arguments; + if (this.pos = this.bytesRead, this.end && this.bytesRead >= this.end) + chunk = chunk.slice(0, this.end - this.start); + return super.push(chunk, ...rest); + } + var end = this.end; + if (end && this.bytesRead >= end) { + chunk = chunk.slice(0, end - currPos); + var [_, ...rest] = arguments; + return this.pos = this.bytesRead, super.push(chunk, ...rest); + } + this.pos = this.bytesRead; + } + } + return super.push(...arguments); + } + #internalRead(n) { + var { pos, end, bytesRead, fd, encoding } = this; + if (n = pos !== void 0 ? Math.min(end - pos + 1, n) : Math.min(end - bytesRead + 1, n), debug("n @ fs.ReadStream.#internalRead, after clamp", n), n <= 0) { + this.push(null); + return; + } + if (this.#fileSize === -1 && bytesRead === 0 && pos === void 0) { + var stat3 = fstatSync(fd); + if (this.#fileSize = stat3.size, this.#fileSize > 0 && n > this.#fileSize) + n = this.#fileSize + 1; + debug("fileSize", this.#fileSize); + } + this[kIoDone] = !1; + var res = super._read(n); + if (debug("res -- undefined? why?", res), isPromise(res)) { + var then = res?.then; + if (then && isCallable(then)) + then(() => { + if (this[kIoDone] = !0, this.destroyed) + this.emit(kIoDone); + }, (er) => { + this[kIoDone] = !0, this.#errorOrDestroy(er); + }); + } else if (this[kIoDone] = !0, this.destroyed) + this.emit(kIoDone), this.#errorOrDestroy(new Error("ERR_STREAM_PREMATURE_CLOSE")); + } + #errorOrDestroy(err, sync = null) { + var { + _readableState: r = { destroyed: !1, autoDestroy: !1 }, + _writableState: w = { destroyed: !1, autoDestroy: !1 } + } = this; + if (w?.destroyed || r?.destroyed) + return this; + if (r?.autoDestroy || w?.autoDestroy) + this.destroy(err); + else if (err) + this.emit("error", err); + } + pause() { + return this[readStreamPathFastPathSymbol] = !1, super.pause(); + } + resume() { + return this[readStreamPathFastPathSymbol] = !1, super.resume(); + } + unshift(...args) { + return this[readStreamPathFastPathSymbol] = !1, super.unshift(...args); + } + pipe(dest, pipeOpts) { + if (this[readStreamPathFastPathSymbol] && (pipeOpts?.end ?? !0) && this._readableState?.pipes?.length === 0) { + if ((writeStreamPathFastPathSymbol in dest) && dest[writeStreamPathFastPathSymbol]) { + if (dest[writeStreamPathFastPathCallSymbol](this, pipeOpts)) + return this; + } + } + return this[readStreamPathFastPathSymbol] = !1, super.pipe(dest, pipeOpts); + } +}), defaultWriteStreamOptions = { + fd: null, + start: void 0, + pos: void 0, + encoding: void 0, + flags: "w", + mode: 438, + fs: { + write, + close, + open, + openSync + } +}, WriteStreamClass, WriteStream = function(InternalWriteStream) { + return WriteStreamClass = InternalWriteStream, Object.defineProperty(WriteStreamClass.prototype, Symbol.toStringTag, { + value: "WritesStream", + enumerable: !1 + }), Object.defineProperty(function WriteStream(options) { + return new InternalWriteStream(options); + }, Symbol.hasInstance, { + value(instance) { + return instance instanceof InternalWriteStream; + } + }); +}(class WriteStream2 extends NativeWritable { + constructor(path, options = defaultWriteStreamOptions) { + if (!options) + throw new TypeError("Expected options to be an object"); + var { + fs: fs2 = defaultWriteStreamOptions.fs, + start = defaultWriteStreamOptions.start, + flags = defaultWriteStreamOptions.flags, + mode = defaultWriteStreamOptions.mode, + autoClose = !0, + emitClose = !1, + autoDestroy = autoClose, + encoding = defaultWriteStreamOptions.encoding, + fd = defaultWriteStreamOptions.fd, + pos = defaultWriteStreamOptions.pos + } = options, tempThis = {}; + if (typeof path === "string") { + if (path.length === 0) + throw new TypeError("Expected a non-empty path"); + if (path.startsWith("file:")) + path = Bun.fileURLToPath(path); + tempThis.path = path, tempThis.fd = null, tempThis[writeStreamPathFastPathSymbol] = autoClose && (start === void 0 || start === 0) && fs2.write === defaultWriteStreamOptions.fs.write && fs2.close === defaultWriteStreamOptions.fs.close; + } else + tempThis.fd = fd, tempThis[writeStreamPathFastPathSymbol] = !1; + if (!tempThis.fd) + tempThis.fd = fs2.openSync(path, flags, mode); + super(tempThis.fd, { + ...options, + decodeStrings: !1, + autoDestroy, + emitClose, + fd: tempThis + }); + if (Object.assign(this, tempThis), typeof fs2?.write !== "function") + throw new TypeError("Expected fs.write to be a function"); + if (typeof fs2?.close !== "function") + throw new TypeError("Expected fs.close to be a function"); + if (typeof fs2?.open !== "function") + throw new TypeError("Expected fs.open to be a function"); + if (typeof path === "object" && path) { + if (path instanceof URL) + path = Bun.fileURLToPath(path); + } + if (typeof path !== "string" && typeof fd !== "number") + throw new TypeError("Expected a path or file descriptor"); + if (this.start = start, this.#fs = fs2, this.flags = flags, this.mode = mode, this.start !== void 0) + this.pos = this.start; + if (encoding !== defaultWriteStreamOptions.encoding) { + if (this.setDefaultEncoding(encoding), encoding !== "buffer" && encoding !== "utf8" && encoding !== "utf-8" && encoding !== "binary") + this[writeStreamPathFastPathSymbol] = !1; + } + } + get autoClose() { + return this._writableState.autoDestroy; + } + set autoClose(val) { + this._writableState.autoDestroy = val; + } + destroySoon = this.end; + open() { + } + path; + fd; + flags; + mode; + #fs; + bytesWritten = 0; + pos; + [writeStreamPathFastPathSymbol]; + [writeStreamSymbol] = !0; + start; + [writeStreamPathFastPathCallSymbol](readStream, pipeOpts) { + if (!this[writeStreamPathFastPathSymbol]) + return !1; + if (this.fd !== null) + return this[writeStreamPathFastPathSymbol] = !1, !1; + return this[kIoDone] = !1, readStream[kIoDone] = !1, Bun.write(this[writeStreamPathFastPathSymbol], readStream[readStreamPathOrFdSymbol]).then((bytesWritten) => { + readStream[kIoDone] = this[kIoDone] = !0, this.bytesWritten += bytesWritten, readStream.bytesRead += bytesWritten, this.end(), readStream.close(); + }, (err) => { + readStream[kIoDone] = this[kIoDone] = !0, this.#errorOrDestroy(err), readStream.emit("error", err); + }); + } + isBunFastPathEnabled() { + return this[writeStreamPathFastPathSymbol]; + } + disableBunFastPath() { + this[writeStreamPathFastPathSymbol] = !1; + } + #handleWrite(er, bytes) { + if (er) + return this.#errorOrDestroy(er); + this.bytesWritten += bytes; + } + #internalClose(err, cb) { + this[writeStreamPathFastPathSymbol] = !1; + var fd = this.fd; + this.#fs.close(fd, (er) => { + this.fd = null, cb(err || er); + }); + } + _construct(callback) { + if (typeof this.fd === "number") { + callback(); + return; + } + callback(), this.emit("open", this.fd), this.emit("ready"); + } + _destroy(err, cb) { + if (this.fd === null) + return cb(err); + if (this[kIoDone]) { + this.once(kIoDone, () => this.#internalClose(err, cb)); + return; + } + this.#internalClose(err, cb); + } + [kIoDone] = !1; + close(cb) { + if (cb) { + if (this.closed) { + process.nextTick(cb); + return; + } + this.on("close", cb); + } + if (!this.autoClose) + this.on("finish", this.destroy); + this.end(); + } + write(chunk, encoding = this._writableState.defaultEncoding, cb) { + if (this[writeStreamPathFastPathSymbol] = !1, typeof chunk === "string") + chunk = Buffer.from(chunk, encoding); + var native = this.pos === void 0; + return this[kIoDone] = !0, super.write(chunk, encoding, native ? (err, bytes) => { + if (this[kIoDone] = !1, this.#handleWrite(err, bytes), this.emit(kIoDone), cb) + !err ? cb() : cb(err); + } : () => { + }, native); + } + #internalWriteSlow(chunk, encoding, cb) { + this.#fs.write(this.fd, chunk, 0, chunk.length, this.pos, (err, bytes) => { + this[kIoDone] = !1, this.#handleWrite(err, bytes), this.emit(kIoDone), !err ? cb() : cb(err); + }); + } + end(chunk, encoding, cb) { + var native = this.pos === void 0; + return super.end(chunk, encoding, cb, native); + } + _write = this.#internalWriteSlow; + _writev = void 0; + get pending() { + return this.fd === null; + } + _destroy(err, cb) { + this.close(err, cb); + } + #errorOrDestroy(err) { + var { + _readableState: r = { destroyed: !1, autoDestroy: !1 }, + _writableState: w = { destroyed: !1, autoDestroy: !1 } + } = this; + if (w?.destroyed || r?.destroyed) + return this; + if (r?.autoDestroy || w?.autoDestroy) + this.destroy(err); + else if (err) + this.emit("error", err); + } +}); +Object.defineProperties(fs, { + createReadStream: { + value: createReadStream + }, + createWriteStream: { + value: createWriteStream + }, + ReadStream: { + value: ReadStream + }, + WriteStream: { + value: WriteStream + } +}); +realpath.native = realpath; +realpathSync.native = realpathSync; +var fs_default = { + [Symbol.for("CommonJS")]: 0, + access, + accessSync, + appendFile, + appendFileSync, + chmod, + chmodSync, + chown, + chownSync, + close, + closeSync, + constants: promises.constants, + copyFile, + copyFileSync, + createReadStream, + createWriteStream, + Dirent, + exists, + existsSync, + fchmod, + fchmodSync, + fchown, + fchownSync, + fstat, + fstatSync, + fsync, + fsyncSync, + ftruncate, + ftruncateSync, + futimes, + futimesSync, + lchmod, + lchmodSync, + lchown, + lchownSync, + link, + linkSync, + lstat, + lstatSync, + lutimes, + lutimesSync, + mkdir, + mkdirSync, + mkdtemp, + mkdtempSync, + open, + openSync, + promises, + read, + readFile, + readFileSync, + readSync, + readdir, + readdirSync, + readlink, + readlinkSync, + realpath, + realpathSync, + rename, + renameSync, + rm, + rmSync, + rmdir, + rmdirSync, + stat, + statSync, + Stats, + symlink, + symlinkSync, + truncate, + truncateSync, + unlink, + unlinkSync, + utimes, + utimesSync, + write, + writeFile, + writeFileSync, + writeSync, + WriteStream, + ReadStream, + [Symbol.for("::bunternal::")]: { + ReadStreamClass, + WriteStreamClass + } +}; +export { + writeSync, + writeFileSync, + writeFile, + write, + utimesSync, + utimes, + unlinkSync, + unlink, + truncateSync, + truncate, + symlinkSync, + symlink, + statSync, + stat, + rmdirSync, + rmdir, + rmSync, + rm, + renameSync, + rename, + realpathSync, + realpath, + readlinkSync, + readlink, + readdirSync, + readdir, + readSync, + readFileSync, + readFile, + read, + promises, + openSync, + open, + mkdtempSync, + mkdtemp, + mkdirSync, + mkdir, + lutimesSync, + lutimes, + lstatSync, + lstat, + linkSync, + link, + lchownSync, + lchown, + lchmodSync, + lchmod, + futimesSync, + futimes, + ftruncateSync, + ftruncate, + fsyncSync, + fsync, + fstatSync, + fstat, + fchownSync, + fchown, + fchmodSync, + fchmod, + existsSync, + exists, + fs_default as default, + createWriteStream, + createReadStream, + copyFileSync, + copyFile, + closeSync, + close, + chownSync, + chown, + chmodSync, + chmod, + appendFileSync, + appendFile, + accessSync, + access, + WriteStream, + Stats, + ReadStream, + Dirent +}; + +//# debugId=C689C46EB67EB38664756e2164756e21 |