echogarden 1.8.6 → 2.0.0

package/src/utilities/BinaryUtilities.ts

@@ -0,0 +1,138 @@
+/////////////////////////////////////////////////////////////////////////////////////
+// Unsigned operations
+/////////////////////////////////////////////////////////////////////////////////////
+export function readUint8(buffer: Uint8Array, offset: number) {
+	return buffer[offset]
+}
+
+export function writeUint8(buffer: Uint8Array, value: number, offset: number) {
+	if (value < 0 || value > 255) {
+		throw new Error(`Value ${value} is outside the range of an 8-bit unsigned integer`)
+	}
+
+	buffer[offset] = value
+}
+
+export function readUint16LE(buffer: Uint8Array, offset: number) {
+	return (buffer[offset]) | (buffer[offset + 1] << 8)
+}
+
+export function writeUint16LE(buffer: Uint8Array, value: number, offset: number) {
+	if (value < 0 || value > 65535) {
+		throw new Error(`Value ${value} is outside the range of a 16-bit unsigned integer`)
+	}
+
+	buffer[offset] = value & 0xff
+	buffer[offset + 1] = (value >>> 8) & 0xff
+}
+
+export function readUint32LE(buffer: Uint8Array, offset: number) {
+	return readInt32LE(buffer, offset) >>> 0
+}
+
+export function writeUint32LE(buffer: Uint8Array, value: number, offset: number) {
+	if (value < 0 || value > 4294967295) {
+		throw new Error(`Value ${value} is outside the range of a 32-bit unsigned integer`)
+	}
+
+	buffer[offset] = value & 0xff
+	buffer[offset + 1] = (value >>> 8) & 0xff
+	buffer[offset + 2] = (value >>> 16) & 0xff
+	buffer[offset + 3] = (value >>> 24) & 0xff
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Signed operations
+/////////////////////////////////////////////////////////////////////////////////////
+export function readInt8(buffer: Uint8Array, offset: number) {
+	const unsignedValue = buffer[offset]
+
+	if (unsignedValue < 128) {
+		return unsignedValue
+	} else {
+		return unsignedValue - 256
+	}
+}
+
+export function writeInt8(buffer: Uint8Array, value: number, offset: number) {
+	if (value < -128 || value > 127) {
+		throw new Error(`Value ${value} is outside the range of an 8-bit signed integer`)
+	}
+
+	let unsignedValue: number
+
+	if (value >= 0) {
+		unsignedValue = value
+	} else {
+		unsignedValue = value + 256
+	}
+
+	buffer[offset] = unsignedValue
+}
+
+export function readInt16LE(buffer: Uint8Array, offset: number) {
+	const unsignedValue = readUint16LE(buffer, offset)
+
+	if (unsignedValue < 32768) {
+		return unsignedValue
+	} else {
+		return unsignedValue - 65536
+	}
+}
+
+export function writeInt16LE(buffer: Uint8Array, value: number, offset: number) {
+	if (value < -32768 || value > 32767) {
+		throw new Error(`Value ${value} is outside the range of a 16-bit signed integer`)
+	}
+
+	let unsignedValue: number
+
+	if (value >= 0) {
+		unsignedValue = value
+	} else {
+		unsignedValue = value + 65536
+	}
+
+	writeUint16LE(buffer, unsignedValue, offset)
+}
+
+export function readInt32LE(buffer: Uint8Array, offset: number) {
+	const value =
+		(buffer[offset]) |
+		(buffer[offset + 1] << 8) |
+		(buffer[offset + 2] << 16) |
+		(buffer[offset + 3] << 24)
+
+	return value
+}
+
+export function writeInt32LE(buffer: Uint8Array, value: number, offset: number) {
+	if (value < -2147483648 || value > 2147483647) {
+		throw new Error(`Value ${value} is outside the range of a 32-bit signed integer`)
+	}
+
+	buffer[offset] = value & 0xff
+	buffer[offset + 1] = (value >> 8) & 0xff
+	buffer[offset + 2] = (value >> 16) & 0xff
+	buffer[offset + 3] = (value >> 24) & 0xff
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+// Misc operations
+/////////////////////////////////////////////////////////////////////////////////////
+export function writeAscii(buffer: Uint8Array, asciiString: string, writeStartOffset: number) {
+	const writeEndOffset = Math.min(writeStartOffset + asciiString.length, buffer.length)
+
+	let readOffset = 0
+	let writeOffset = writeStartOffset
+
+	while (writeOffset < writeEndOffset) {
+		const charCode = asciiString.charCodeAt(readOffset++)
+
+		if (charCode >= 128) {
+			throw new Error(`Character '${asciiString[readOffset]}' (code: ${charCode}) can't be encoded as ASCII`)
+		}
+
+		buffer[writeOffset++] = charCode
+	}
+}

package/src/utilities/Compression.ts

@@ -1,6 +1,7 @@
-import path from 'node:path'
 import { Logger } from './Logger.js'
 import { readdir, stat } from './FileSystem.js'
+import { encodeUtf8 } from '../encodings/Utf8.js'
+import { getBaseName, getDirName } from './PathUtilities.js'
 
 export async function createTarball(filePath: string, outputFile: string, prefixPath = '') {
 	const pathStat = await stat(filePath)
@@ -15,7 +16,7 @@ export async function createTarball(filePath: string, outputFile: string, prefix
 export async function createTarballForFile(filePath: string, outputFile: string, prefixPath = '') {
 	const logger = new Logger()
 
-	logger.start(`Creating ${prefixPath || path.basename(outputFile)}`)
+	logger.start(`Creating ${prefixPath || getBaseName(outputFile)}`)
 
 	const { create } = await import('tar')
 
@@ -25,8 +26,8 @@ export async function createTarballForFile(filePath: string, outputFile: string,
 		throw new Error(`${filePath} is not a file`)
 	}
 
-	const filename = path.basename(filePath)
-	const dirname = path.dirname(filePath)
+	const filename = getBaseName(filePath)
+	const dirname = getDirName(filePath)
 
 	await create({
 		gzip: { level: 9 },
@@ -51,7 +52,7 @@ export async function createTarballForFile(filePath: string, outputFile: string,
 export async function createTarballForDir(inputDir: string, outputFile: string, prefixPath = '') {
 	const logger = new Logger()
 
-	logger.start(`Creating ${prefixPath || path.basename(outputFile)}`)
+	logger.start(`Creating ${prefixPath || getBaseName(outputFile)}`)
 
 	const { create } = await import('tar')
 
@@ -98,7 +99,7 @@ export async function getDeflateCompressionMetricsForString(str: string) {
 	const zlib = await import('node:zlib')
 	const { promisify } = await import('node:util')
 
-	const originalStringBytes = Buffer.from(str, 'utf-8')
+	const originalStringBytes = encodeUtf8(str)
 
 	const deflateRaw = promisify(zlib.deflateRaw)
 

package/src/utilities/FileDownloader.ts

@@ -1,22 +1,22 @@
 import { GaxiosOptions, request } from 'gaxios'
 import { Readable } from 'stream'
 import { getRandomHexString, writeToStderr } from './Utilities.js'
-import { OpenPromise } from './OpenPromise.js'
 
 import { Timer } from './Timer.js'
 import { Logger } from './Logger.js'
-import path from 'node:path'
 import { extractTarball } from './Compression.js'
-import { createWriteStream, move, remove, readdir, ensureDir } from './FileSystem.js'
+import { move, remove, readdir, ensureDir } from './FileSystem.js'
 import chalk from 'chalk'
 import { logLevelGreaterOrEqualTo } from '../api/GlobalOptions.js'
+import { FileWriter } from './FileWriter.js'
+import { joinPath } from './PathUtilities.js'
 
 export async function downloadAndExtractTarball(options: GaxiosOptions, targetDir: string, baseTempPath: string, displayName = 'archive') {
 	const logger = new Logger()
 
 	const randomID = getRandomHexString(16).toLowerCase()
-	const tempTarballPath = path.join(baseTempPath, `/${randomID}.tarball`)
-	const tempDirPath = path.join(baseTempPath, `/${randomID}`)
+	const tempTarballPath = joinPath(baseTempPath, `/${randomID}.tarball`)
+	const tempDirPath = joinPath(baseTempPath, `/${randomID}`)
 	await ensureDir(tempDirPath)
 
 	logger.end()
@@ -32,8 +32,8 @@ export async function downloadAndExtractTarball(options: GaxiosOptions, targetDi
 	await remove(tempTarballPath)
 
 	for (const filename of await readdir(tempDirPath)) {
-		const sourceFilePath = path.join(tempDirPath, filename)
-		const targetFilePath = path.join(targetDir, filename)
+		const sourceFilePath = joinPath(tempDirPath, filename)
+		const targetFilePath = joinPath(targetDir, filename)
 
 		await move(sourceFilePath, targetFilePath)
 	}
@@ -46,8 +46,6 @@ export async function downloadAndExtractTarball(options: GaxiosOptions, targetDi
 export async function downloadFile(options: GaxiosOptions, targetFilePath: string, prompt = 'Downloading') {
 	const write = logLevelGreaterOrEqualTo('info') ? writeToStderr : () => {}
 
-	const downloadPromise = new OpenPromise<void>()
-
 	const timer = new Timer()
 
 	options.responseType = 'stream'
@@ -143,63 +141,40 @@ export async function downloadFile(options: GaxiosOptions, targetFilePath: strin
 		}
 	}
 
+	const contentLengthString = response.headers['content-length']
+	totalBytes = contentLengthString != undefined ? parseInt(contentLengthString) : undefined
+
 	const partialFilePath = `${targetFilePath}.${getRandomHexString(16)}.partial`
-	const fileWriteStream = createWriteStream(partialFilePath, { encoding: 'binary', autoClose: true })
+	const fileWriter = new FileWriter(partialFilePath)
 
 	let statusInterval = setInterval(() => {
 		updateStatus()
 	}, statusUpdateInterval)
 
-	response.data.on('data', (chunk: Uint8Array) => {
-		try {
-			const contentLengthString = response.headers['content-length']
-
-			totalBytes = contentLengthString != undefined ? parseInt(contentLengthString) : undefined
-
-			const chunkLength = chunk.length
-
-			fileWriteStream.write(chunk)
-
-			downloadedBytes += chunkLength
-
-			if (downloadStarted == false) {
+	try {
+		for await (const chunk of response.data) {
+			if (downloadStarted === false) {
 				downloadStarted = true
 			}
-		} catch (err) {
-			clearInterval(statusInterval)
 
-			downloadPromise.reject(err)
-		}
-	})
-
-	response.data.on('end', async () => {
-		try {
-			clearInterval(statusInterval)
-			updateStatus()
+			downloadedBytes += chunk.length
 
-			fileWriteStream.end()
+			await fileWriter.write(chunk)
+		}
+	} catch (e) {
+		clearInterval(statusInterval)
 
-			write('\n')
+		await fileWriter.dispose()
 
-			await move(partialFilePath, targetFilePath)
+		throw e
+	}
 
-			downloadPromise.resolve()
-		} catch (err) {
-			clearInterval(statusInterval)
-			downloadPromise.reject(err)
-		}
-	})
+	clearInterval(statusInterval)
+	updateStatus()
 
-	response.data.on('error', async (err: any) => {
-		try {
-			clearInterval(statusInterval)
+	await fileWriter.dispose()
 
-			fileWriteStream.end()
-			await remove(partialFilePath)
-		} finally {
-			downloadPromise.reject(err)
-		}
-	})
+	write('\n')
 
-	return downloadPromise.promise
+	await move(partialFilePath, targetFilePath)
 }

package/src/utilities/FileReader.ts

@@ -0,0 +1,89 @@
+import { open, close, read } from "./FileSystem.js"
+
+export class FileReader {
+	private fileHandle?: number
+	private finished = false
+	private disposed = false
+	private readOffset = 0
+
+	constructor(public readonly filePath: string) {
+	}
+
+	async readChunk(buffer: Uint8Array): Promise<Uint8Array> {
+		if (this.isDisposed) {
+			throw new Error(`FileReader has been disposed`)
+		}
+
+		await this.openIfNeeded()
+
+		let bufferWriteOffset = 0
+
+		while (bufferWriteOffset < buffer.length) {
+			const remainingSizeInBuffer = buffer.length - bufferWriteOffset
+
+			let bytesRead: number
+
+			try {
+				({ bytesRead } = await read(this.fileHandle!, buffer, bufferWriteOffset, remainingSizeInBuffer, this.readOffset))
+			} catch (e) {
+				await this.dispose()
+
+				throw e
+			}
+
+			if (bytesRead === 0) {
+				this.finished = true
+
+				await this.dispose()
+
+				break
+			}
+
+			bufferWriteOffset += bytesRead
+			this.readOffset += bytesRead
+		}
+
+		return buffer.subarray(0, bufferWriteOffset)
+	}
+
+	private async openIfNeeded() {
+		if (this.isDisposed) {
+			throw new Error(`FileWriter has been disposed`)
+		}
+
+		if (this.isOpened) {
+			return
+		}
+
+		this.fileHandle = await open(this.filePath, 'r')
+	}
+
+	async dispose() {
+		if (this.isDisposed) {
+			return
+		}
+
+		if (this.isOpened) {
+			try {
+				await close(this.fileHandle!)
+			} catch (e) {
+			}
+		}
+
+		this.disposed = true
+		this.readOffset = 0
+		this.fileHandle = undefined
+	}
+
+	get isOpened() {
+		return this.fileHandle !== undefined
+	}
+
+	get isDisposed() {
+		return this.disposed
+	}
+
+	get isFinished() {
+		return this.finished
+	}
+}