node-hitomi/distribution/esm/platform/node.mjs

Hitomi.la API for Node.js

import { Agent, request as request$1 } from 'https';
import { createGunzip } from 'zlib';
import { createHash } from 'crypto';
import { DEFAULT_HEADERS } from '../internal/constants.mjs';
import { HitomiError } from '../structures/error.mjs';

const agent = new Agent({
	keepAlive: true
});
function createContext(host, path, type, range) {
	return {
		host: host,
		path: path,
		type: type,
		options: {
			agent: agent,
			headers: Object.assign(range ? {
				range: 'bytes=' + range
			} : {
				'accept-encoding': 'gzip'
			}, DEFAULT_HEADERS)
		}
	};
}
async function request(host, path, type, range) {
	let context = createContext(host, path, type, range);
	context = await this.onRequest(context) || context;
	context.options.host = context.host;
	context.options.path = context.path;
	return new Promise(function (resolve, reject) {
		request$1(context.options, function (response) {
			switch(response.statusCode) {
				case 200:
				case 206: {
					response.on('error', reject);
					break;
				}
				default: {
					response.resume();
					return reject(HitomiError.unexpectedResponseStatus(context.host, context.path, response.statusCode));
				}
			}
			const chunks = [];
			let length = 0;
			if(response.headers['content-encoding']) {
				response = response.pipe(createGunzip())
					.on('error', reject);
			}
			response.on('data', function (chunk) {
				chunks.push(chunk);
				length += chunk.byteLength;
			})
				.on('end', function () {
				const buffer = Buffer.concat(chunks, length);
				switch(type) {
					case 0: {
						return resolve(buffer);
					}
					case 1: {
						return resolve(new DataView(buffer.buffer, buffer.byteOffset, length));
					}
					case 2: {
						return resolve(buffer.toString());
					}
					case 3: {
						return resolve(JSON.parse(buffer.toString()));
					}
				}
			});
		})
			.on('error', reject)
			.end();
	});
}
function hashTerm(text) {
	return Promise.resolve(createHash('sha256').update(text).digest().subarray(0, 4));
}
function toString(buffer) {
	return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength).toString();
}

export { createContext, hashTerm, request, toString };