node-hitomi/distribution/cjs/platform/node.cjs

Hitomi.la API for Node.js

'use strict';

const https = require('https');
const zlib = require('zlib');
const crypto = require('crypto');
const constants = require('../internal/constants.cjs');
const error = require('../structures/error.cjs');

const agent = new https.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'
			}, constants.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) {
		https.request(context.options, function (response) {
			switch(response.statusCode) {
				case 200:
				case 206: {
					response.on('error', reject);
					break;
				}
				default: {
					response.resume();
					return reject(error.HitomiError.unexpectedResponseStatus(context.host, context.path, response.statusCode));
				}
			}
			const chunks = [];
			let length = 0;
			if(response.headers['content-encoding']) {
				response = response.pipe(zlib.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(crypto.createHash('sha256').update(text).digest().subarray(0, 4));
}
function toString(buffer) {
	return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength).toString();
}

exports.createContext = createContext;
exports.hashTerm = hashTerm;
exports.request = request;
exports.toString = toString;