tabular-data-differ/dist/streams.js

A very efficient library for diffing two sorted streams of tabular data, such as CSV files.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FileOutputStream = exports.FileTextWriter = exports.ConsoleOutputStream = exports.ConsoleTextWriter = exports.NullOutputStream = exports.NullTextWriter = exports.ArrayTextReader = exports.ArrayInputStream = exports.FileInputStream = exports.FileTextReader = void 0;
exports.getOrCreateInputStream = getOrCreateInputStream;
exports.getOrCreateOutputStream = getOrCreateOutputStream;
const promises_1 = __importDefault(require("fs/promises"));
class FileTextReader {
    constructor(iterator) {
        this.iterator = iterator;
    }
    async readLine() {
        if (!this.iterator) {
            throw new Error(`FileTextReader is closed`);
        }
        while (true) {
            const result = await this.iterator.next();
            if (result.done) {
                this.iterator = undefined;
                return undefined;
            }
            const line = result.value.trim();
            // ignore empty lines
            if (line.length > 0) {
                return line;
            }
        }
    }
    async close() {
        if (this.iterator) {
            if (this.iterator.return) {
                await this.iterator.return();
            }
            this.iterator = undefined;
        }
    }
}
exports.FileTextReader = FileTextReader;
class FileInputStream {
    constructor(path) {
        this.path = path;
    }
    async open() {
        if (this.file !== undefined) {
            throw new Error(`file "${this.path}" is already open!`);
        }
        this.file = await promises_1.default.open(this.path, 'r');
    }
    read(options) {
        if (!this.file) {
            throw new Error(`file "${this.path}" is not open!`);
        }
        return this.file.read(options);
    }
    createTextReader(options) {
        if (!this.file) {
            throw new Error(`file "${this.path}" is not open!`);
        }
        return new FileTextReader(this.file.readLines(options)[Symbol.asyncIterator]());
    }
    async close() {
        if (this.file !== undefined) {
            await this.file.close();
            this.file = undefined;
        }
    }
}
exports.FileInputStream = FileInputStream;
class ArrayInputStream {
    constructor(lines) {
        this.lines = lines;
    }
    open() {
        return Promise.resolve();
    }
    createTextReader(options) {
        return new ArrayTextReader(this.lines);
    }
    read(options) {
        throw new Error('Method not implemented.');
    }
    close() {
        return Promise.resolve();
    }
}
exports.ArrayInputStream = ArrayInputStream;
class ArrayTextReader {
    constructor(lines) {
        this.lines = lines;
        this.currentIndex = 0;
    }
    readLine() {
        if (this.currentIndex < this.lines.length) {
            const result = this.lines[this.currentIndex];
            this.currentIndex++;
            return Promise.resolve(result);
        }
        return Promise.resolve(undefined);
    }
    close() {
        return Promise.resolve();
    }
}
exports.ArrayTextReader = ArrayTextReader;
class NullTextWriter {
    writeLine(line) {
        return Promise.resolve();
    }
    close() {
        return Promise.resolve();
    }
}
exports.NullTextWriter = NullTextWriter;
class NullOutputStream {
    open() {
        return Promise.resolve();
    }
    createTextWriter(options) {
        return new NullTextWriter();
    }
    write(options) {
        const buffer = options.buffer;
        const len = options.length ?? buffer.length;
        const start = options.offset ?? 0;
        const end = start + len;
        const bytesWritten = Math.min(buffer.length, end) - start;
        return Promise.resolve({ bytesWritten, buffer });
    }
    close() {
        return Promise.resolve();
    }
}
exports.NullOutputStream = NullOutputStream;
class ConsoleTextWriter {
    writeLine(line) {
        console.log(line);
        return Promise.resolve();
    }
    close() {
        return Promise.resolve();
    }
}
exports.ConsoleTextWriter = ConsoleTextWriter;
class ConsoleOutputStream {
    createTextWriter(options) {
        return new ConsoleTextWriter();
    }
    open() {
        return Promise.resolve();
    }
    write(options) {
        throw new Error('Cannot write to the console. Use a TextWriter instead.');
    }
    close() {
        return Promise.resolve();
    }
}
exports.ConsoleOutputStream = ConsoleOutputStream;
class FileTextWriter {
    constructor(file) {
        this.file = file;
    }
    async writeLine(line) {
        await this.file.write(Buffer.from(line + '\n'));
    }
    close() {
        return Promise.resolve();
    }
}
exports.FileTextWriter = FileTextWriter;
class FileOutputStream {
    constructor(path) {
        this.path = path;
    }
    async open() {
        if (this.file !== undefined) {
            throw new Error(`file "${this.path}" is already open!`);
        }
        this.file = await promises_1.default.open(this.path, 'w');
    }
    createTextWriter(options) {
        if (this.file === undefined) {
            throw new Error(`file "${this.path}" is not open!`);
        }
        return new FileTextWriter(this.file);
    }
    async write(options) {
        if (this.file === undefined) {
            throw new Error(`file "${this.path}" is not open!`);
        }
        return await this.file.write(options.buffer, options.offset, options.length);
    }
    async close() {
        if (this.file !== undefined) {
            await this.file.close();
            this.file = undefined;
        }
    }
}
exports.FileOutputStream = FileOutputStream;
function getOrCreateInputStream(stream) {
    if (typeof stream === 'string' || stream instanceof URL) {
        return new FileInputStream(stream);
    }
    return stream;
}
function getOrCreateOutputStream(stream) {
    if (stream === 'console') {
        return new ConsoleOutputStream();
    }
    if (stream === 'null') {
        return new NullOutputStream();
    }
    if (typeof stream === 'string' || stream instanceof URL) {
        return new FileOutputStream(stream);
    }
    return stream;
}
//# sourceMappingURL=streams.js.map