arx-convert/dist/bin/helpers.js

Converts various Arx Fatalis formats to JSON or YAML and back

import fs from 'node:fs';
import path from 'node:path';
import process from 'node:process';
import { fileURLToPath } from 'node:url';
import { SUPPORTED_ARX_FORMATS, SUPPORTED_DATA_FORMATS, SUPPORTED_FORMATS, } from './constants.js';
import { concatArrayBuffers } from '../common/helpers.js';
function pathToPackageJson() {
    const filename = fileURLToPath(import.meta.url);
    const dirname = path.dirname(filename);
    return path.resolve(dirname, '../../package.json');
}
export async function getPackageVersion() {
    try {
        const rawIn = await fs.promises.readFile(pathToPackageJson(), 'utf8');
        const { version } = JSON.parse(rawIn);
        return version;
    }
    catch {
        return 'unknown';
    }
}
async function fileExists(filename) {
    try {
        await fs.promises.access(filename, fs.constants.R_OK);
        return true;
    }
    catch {
        return false;
    }
}
export async function streamToBuffer(input) {
    return new Promise((resolve, reject) => {
        const chunks = [];
        input.on('data', (chunk) => {
            chunks.push(chunk.buffer);
        });
        input.on('end', () => {
            resolve(concatArrayBuffers(chunks));
        });
        input.on('error', (e) => {
            if (e instanceof Error) {
                reject(e);
            }
            else {
                reject(new Error('unknown error happened while converting stream to buffer'));
            }
        });
    });
}
export function stringifyJSON(json, prettify = false) {
    if (prettify) {
        return JSON.stringify(json, null, '\t');
    }
    return JSON.stringify(json);
}
export async function stringifyYAML(json) {
    const YAML = await import('yaml');
    return YAML.stringify(json);
}
function sliceBuffer(buffer, start = 0, end) {
    return buffer.slice(start, end);
}
/**
 * @example
 * ```js
 * quotientAndRemainder(20, 3) -> [6, 2]
 * ```
 */
export function quotientAndRemainder(dividend, divisor) {
    return [Math.floor(dividend / divisor), dividend % divisor];
}
export function outputInChunks(buffer, stream, chunkSize = 1024) {
    let sizeOfBuffer;
    if (typeof buffer === 'string') {
        const [numberOfWholeChunks, leftoverChunkSize] = quotientAndRemainder(chunkSize, buffer.length);
        for (let i = 0; i < numberOfWholeChunks; i++) {
            stream.write(sliceBuffer(buffer, i * chunkSize, (i + 1) * chunkSize));
        }
        if (leftoverChunkSize > 0) {
            stream.write(sliceBuffer(buffer, numberOfWholeChunks * chunkSize));
        }
    }
    else {
        const [numberOfWholeChunks, leftoverChunkSize] = quotientAndRemainder(chunkSize, buffer.byteLength);
        for (let i = 0; i < numberOfWholeChunks; i++) {
            stream.write(new Uint8Array(sliceBuffer(buffer, i * chunkSize, (i + 1) * chunkSize)));
        }
        if (leftoverChunkSize > 0) {
            stream.write(new Uint8Array(sliceBuffer(buffer, numberOfWholeChunks * chunkSize)));
        }
    }
    stream.end();
}
export function isValidFormat(arg) {
    for (const SUPPORTED_FORMAT of SUPPORTED_FORMATS) {
        if (SUPPORTED_FORMAT === arg) {
            return true;
        }
    }
    return false;
}
export function isArxFormat(arg) {
    for (const SUPPORTED_ARX_FORMAT of SUPPORTED_ARX_FORMATS) {
        if (SUPPORTED_ARX_FORMAT === arg) {
            return true;
        }
    }
    return false;
}
export function isDataFormat(arg) {
    for (const SUPPORTED_DATA_FORMAT of SUPPORTED_DATA_FORMATS) {
        if (SUPPORTED_DATA_FORMAT === arg) {
            return true;
        }
    }
    return false;
}
export async function getInputStream(filename) {
    if (filename === undefined) {
        process.stdin.resume();
        return process.stdin;
    }
    if (await fileExists(filename)) {
        return fs.createReadStream(filename);
    }
    throw new Error('input file does not exist');
}
export async function getOutputStream(filename) {
    if (filename === undefined) {
        return process.stdout;
    }
    return fs.createWriteStream(filename);
}
//# sourceMappingURL=helpers.js.map