282 lines
9.0 KiB
JavaScript
282 lines
9.0 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.getWriteSyncArgs = exports.getWriteArgs = exports.bufToUint8 = void 0;
|
|
exports.promisify = promisify;
|
|
exports.validateCallback = validateCallback;
|
|
exports.modeToNumber = modeToNumber;
|
|
exports.nullCheck = nullCheck;
|
|
exports.pathToFilename = pathToFilename;
|
|
exports.createError = createError;
|
|
exports.genRndStr6 = genRndStr6;
|
|
exports.flagsToNumber = flagsToNumber;
|
|
exports.streamToBuffer = streamToBuffer;
|
|
exports.bufferToEncoding = bufferToEncoding;
|
|
exports.isReadableStream = isReadableStream;
|
|
const constants_1 = require("./constants");
|
|
const errors = require("../internal/errors");
|
|
const buffer_1 = require("../internal/buffer");
|
|
const buffer_2 = require("../internal/buffer");
|
|
const queueMicrotask_1 = require("../queueMicrotask");
|
|
const util_1 = require("../core/util");
|
|
function promisify(fs, fn, getResult = input => input) {
|
|
return (...args) => new Promise((resolve, reject) => {
|
|
fs[fn].bind(fs)(...args, (error, result) => {
|
|
if (error)
|
|
return reject(error);
|
|
return resolve(getResult(result));
|
|
});
|
|
});
|
|
}
|
|
function validateCallback(callback) {
|
|
if (typeof callback !== 'function')
|
|
throw TypeError(constants_1.ERRSTR.CB);
|
|
return callback;
|
|
}
|
|
function _modeToNumber(mode, def) {
|
|
if (typeof mode === 'number')
|
|
return mode;
|
|
if (typeof mode === 'string')
|
|
return parseInt(mode, 8);
|
|
if (def)
|
|
return modeToNumber(def);
|
|
return undefined;
|
|
}
|
|
function modeToNumber(mode, def) {
|
|
const result = _modeToNumber(mode, def);
|
|
if (typeof result !== 'number' || isNaN(result))
|
|
throw new TypeError(constants_1.ERRSTR.MODE_INT);
|
|
return result;
|
|
}
|
|
function nullCheck(path, callback) {
|
|
if (('' + path).indexOf('\u0000') !== -1) {
|
|
const er = new Error('Path must be a string without null bytes');
|
|
er.code = 'ENOENT';
|
|
if (typeof callback !== 'function')
|
|
throw er;
|
|
(0, queueMicrotask_1.default)(() => {
|
|
callback(er);
|
|
});
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
function getPathFromURLPosix(url) {
|
|
if (url.hostname !== '') {
|
|
throw new errors.TypeError('ERR_INVALID_FILE_URL_HOST', process.platform);
|
|
}
|
|
const pathname = url.pathname;
|
|
for (let n = 0; n < pathname.length; n++) {
|
|
if (pathname[n] === '%') {
|
|
const third = pathname.codePointAt(n + 2) | 0x20;
|
|
if (pathname[n + 1] === '2' && third === 102) {
|
|
throw new errors.TypeError('ERR_INVALID_FILE_URL_PATH', 'must not include encoded / characters');
|
|
}
|
|
}
|
|
}
|
|
return decodeURIComponent(pathname);
|
|
}
|
|
function pathToFilename(path) {
|
|
if (path instanceof Uint8Array) {
|
|
path = (0, buffer_2.bufferFrom)(path);
|
|
}
|
|
if (typeof path !== 'string' && !buffer_1.Buffer.isBuffer(path)) {
|
|
try {
|
|
if (!(path instanceof require('url').URL))
|
|
throw new TypeError(constants_1.ERRSTR.PATH_STR);
|
|
}
|
|
catch (err) {
|
|
throw new TypeError(constants_1.ERRSTR.PATH_STR);
|
|
}
|
|
path = getPathFromURLPosix(path);
|
|
}
|
|
const pathString = String(path);
|
|
nullCheck(pathString);
|
|
// return slash(pathString);
|
|
return pathString;
|
|
}
|
|
const ENOENT = 'ENOENT';
|
|
const EBADF = 'EBADF';
|
|
const EINVAL = 'EINVAL';
|
|
const EPERM = 'EPERM';
|
|
const EPROTO = 'EPROTO';
|
|
const EEXIST = 'EEXIST';
|
|
const ENOTDIR = 'ENOTDIR';
|
|
const EMFILE = 'EMFILE';
|
|
const EACCES = 'EACCES';
|
|
const EISDIR = 'EISDIR';
|
|
const ENOTEMPTY = 'ENOTEMPTY';
|
|
const ENOSYS = 'ENOSYS';
|
|
const ERR_FS_EISDIR = 'ERR_FS_EISDIR';
|
|
const ERR_OUT_OF_RANGE = 'ERR_OUT_OF_RANGE';
|
|
function formatError(errorCode, func = '', path = '', path2 = '') {
|
|
let pathFormatted = '';
|
|
if (path)
|
|
pathFormatted = ` '${path}'`;
|
|
if (path2)
|
|
pathFormatted += ` -> '${path2}'`;
|
|
switch (errorCode) {
|
|
case ENOENT:
|
|
return `ENOENT: no such file or directory, ${func}${pathFormatted}`;
|
|
case EBADF:
|
|
return `EBADF: bad file descriptor, ${func}${pathFormatted}`;
|
|
case EINVAL:
|
|
return `EINVAL: invalid argument, ${func}${pathFormatted}`;
|
|
case EPERM:
|
|
return `EPERM: operation not permitted, ${func}${pathFormatted}`;
|
|
case EPROTO:
|
|
return `EPROTO: protocol error, ${func}${pathFormatted}`;
|
|
case EEXIST:
|
|
return `EEXIST: file already exists, ${func}${pathFormatted}`;
|
|
case ENOTDIR:
|
|
return `ENOTDIR: not a directory, ${func}${pathFormatted}`;
|
|
case EISDIR:
|
|
return `EISDIR: illegal operation on a directory, ${func}${pathFormatted}`;
|
|
case EACCES:
|
|
return `EACCES: permission denied, ${func}${pathFormatted}`;
|
|
case ENOTEMPTY:
|
|
return `ENOTEMPTY: directory not empty, ${func}${pathFormatted}`;
|
|
case EMFILE:
|
|
return `EMFILE: too many open files, ${func}${pathFormatted}`;
|
|
case ENOSYS:
|
|
return `ENOSYS: function not implemented, ${func}${pathFormatted}`;
|
|
case ERR_FS_EISDIR:
|
|
return `[ERR_FS_EISDIR]: Path is a directory: ${func} returned EISDIR (is a directory) ${path}`;
|
|
case ERR_OUT_OF_RANGE:
|
|
return `[ERR_OUT_OF_RANGE]: value out of range, ${func}${pathFormatted}`;
|
|
default:
|
|
return `${errorCode}: error occurred, ${func}${pathFormatted}`;
|
|
}
|
|
}
|
|
function createError(errorCode, func = '', path = '', path2 = '', Constructor = Error) {
|
|
const error = new Constructor(formatError(errorCode, func, path, path2));
|
|
error.code = errorCode;
|
|
if (path) {
|
|
error.path = path;
|
|
}
|
|
return error;
|
|
}
|
|
function genRndStr6() {
|
|
return Math.random().toString(36).slice(2, 8).padEnd(6, '0');
|
|
}
|
|
function flagsToNumber(flags) {
|
|
if (typeof flags === 'number')
|
|
return flags;
|
|
if (typeof flags === 'string') {
|
|
const flagsNum = constants_1.FLAGS[flags];
|
|
if (typeof flagsNum !== 'undefined')
|
|
return flagsNum;
|
|
}
|
|
// throw new TypeError(formatError(ERRSTR_FLAG(flags)));
|
|
throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'flags', flags);
|
|
}
|
|
function streamToBuffer(stream) {
|
|
const chunks = [];
|
|
return new Promise((resolve, reject) => {
|
|
stream.on('data', chunk => chunks.push(chunk));
|
|
stream.on('end', () => resolve(buffer_1.Buffer.concat(chunks)));
|
|
stream.on('error', reject);
|
|
});
|
|
}
|
|
const bufToUint8 = (buf) => new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
|
|
exports.bufToUint8 = bufToUint8;
|
|
const getWriteArgs = (fd, a, b, c, d, e) => {
|
|
(0, util_1.validateFd)(fd);
|
|
let offset = 0;
|
|
let length;
|
|
let position = null;
|
|
let encoding;
|
|
let callback;
|
|
const tipa = typeof a;
|
|
const tipb = typeof b;
|
|
const tipc = typeof c;
|
|
const tipd = typeof d;
|
|
if (tipa !== 'string') {
|
|
if (tipb === 'function') {
|
|
callback = b;
|
|
}
|
|
else if (tipc === 'function') {
|
|
offset = b | 0;
|
|
callback = c;
|
|
}
|
|
else if (tipd === 'function') {
|
|
offset = b | 0;
|
|
length = c;
|
|
callback = d;
|
|
}
|
|
else {
|
|
offset = b | 0;
|
|
length = c;
|
|
position = d;
|
|
callback = e;
|
|
}
|
|
}
|
|
else {
|
|
if (tipb === 'function') {
|
|
callback = b;
|
|
}
|
|
else if (tipc === 'function') {
|
|
position = b;
|
|
callback = c;
|
|
}
|
|
else if (tipd === 'function') {
|
|
position = b;
|
|
encoding = c;
|
|
callback = d;
|
|
}
|
|
}
|
|
const buf = (0, util_1.dataToBuffer)(a, encoding);
|
|
if (tipa !== 'string') {
|
|
if (typeof length === 'undefined')
|
|
length = buf.length;
|
|
}
|
|
else {
|
|
offset = 0;
|
|
length = buf.length;
|
|
}
|
|
const cb = validateCallback(callback);
|
|
return [fd, tipa === 'string', buf, offset, length, position, cb];
|
|
};
|
|
exports.getWriteArgs = getWriteArgs;
|
|
const getWriteSyncArgs = (fd, a, b, c, d) => {
|
|
(0, util_1.validateFd)(fd);
|
|
let encoding;
|
|
let offset;
|
|
let length;
|
|
let position;
|
|
const isBuffer = typeof a !== 'string';
|
|
if (isBuffer) {
|
|
offset = (b || 0) | 0;
|
|
length = c;
|
|
position = d;
|
|
}
|
|
else {
|
|
position = b;
|
|
encoding = c;
|
|
}
|
|
const buf = (0, util_1.dataToBuffer)(a, encoding);
|
|
if (isBuffer) {
|
|
if (typeof length === 'undefined') {
|
|
length = buf.length;
|
|
}
|
|
}
|
|
else {
|
|
offset = 0;
|
|
length = buf.length;
|
|
}
|
|
return [fd, buf, offset || 0, length, position];
|
|
};
|
|
exports.getWriteSyncArgs = getWriteSyncArgs;
|
|
function bufferToEncoding(buffer, encoding) {
|
|
if (!encoding || encoding === 'buffer')
|
|
return buffer;
|
|
else
|
|
return buffer.toString(encoding);
|
|
}
|
|
function isReadableStream(stream) {
|
|
return (stream !== null &&
|
|
typeof stream === 'object' &&
|
|
typeof stream.pipe === 'function' &&
|
|
typeof stream.on === 'function' &&
|
|
stream.readable === true);
|
|
}
|
|
//# sourceMappingURL=util.js.map
|