index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.StreamLineReader = void 0;
const events_1 = require("events");
const types_1 = require("./types");
const fs_1 = require("fs");
const readline_1 = require("readline");
// import myDebug = require('debug');
// const debug = myDebug('text-file-diff');
class StreamLineReader {
    constructor() {
        this.value = '';
        this.nextValue = '';
        this.lineNumber = -1;
        this.eof = -1;
    }
    async init(readStream) {
        const rl = (0, readline_1.createInterface)({
            input: readStream,
            crlfDelay: Number.POSITIVE_INFINITY
        });
        this.it = rl[Symbol.asyncIterator]();
        // move to first line
        await this.moveNext();
        await this.moveNext();
        return this;
    }
    async moveNext() {
        this.value = this.nextValue;
        const nextResult = await this.it.next();
        if (nextResult.done) {
            this.eof++;
            nextResult.value = '';
        }
        this.nextValue = nextResult.value;
        this.lineNumber++;
        return this.value;
    }
}
exports.StreamLineReader = StreamLineReader;
/**
 * line by line diff of two files
 */
class TextFileDiff extends events_1.EventEmitter {
    constructor(options) {
        super();
        this.options = new types_1.TextFileDiffOption();
        Object.assign(this.options, options);
    }
    /**
     * run diff
     * @param  String file1 path to file 1
     * @param  String file2 path to file 2
     * @return Object         self
     */
    async diff(file1, file2) {
        const stream1 = (0, fs_1.createReadStream)(file1);
        const stream2 = (0, fs_1.createReadStream)(file2);
        return this.diffStream(stream1, stream2);
    }
    /**
     * run diffStream
     * @param  Readable stream1
     * @param  Readable stream2
     * @return Object         self
     */
    async diffStream(stream1, stream2) {
        const lineReader1 = await (new StreamLineReader()).init(stream1);
        const lineReader2 = await (new StreamLineReader()).init(stream2);
        if (this.options.skipHeader) {
            await lineReader1.moveNext();
            await lineReader2.moveNext();
        }
        /* eslint-disable no-await-in-loop */
        // while both files has valid val, check eof counter
        while (lineReader1.eof < 2 && lineReader2.eof < 2) {
            await this.doCompareLineReader(lineReader1, lineReader2);
        }
        /* eslint-enable no-await-in-loop */
        return this;
    }
    async doCompareLineReader(lineReader1, lineReader2) {
        // forEach line in File1, compare to line in File2
        const line1 = lineReader1.value;
        const line2 = lineReader2.value;
        const cmpar = this.options.compareFn(line1, line2);
        // debug(line1, line1, cmpar);
        // debug(lineReader1.nextValue, lineReader2.nextValue, 'next', lineReader1.eof, lineReader2.eof);
        // emit on compared
        this.emit('compared', line1, line2, cmpar, lineReader1, lineReader2);
        if (cmpar > 0) {
            // line1 > line2: new line detected
            // if file2 ended before file1, then file2 lost line1
            // else file2 has new line
            if (lineReader2.eof > lineReader1.eof) {
                this.emit('-', line1, lineReader1, lineReader2);
            }
            else {
                this.emit('+', line2, lineReader1, lineReader2);
            }
            // incr File2 to next line
            await lineReader2.moveNext();
        }
        else if (cmpar < 0) {
            // line1 < line2: deleted line
            // if file1 ended before file2, then file2 has new line
            // else file1 lost a line
            if (lineReader1.eof > lineReader2.eof) {
                this.emit('+', line2, lineReader1, lineReader2);
            }
            else {
                this.emit('-', line1, lineReader1, lineReader2);
            }
            // incr File1 to next line
            await lineReader1.moveNext();
        }
        else {
            // equals: 0 incr both files to next line
            await lineReader1.moveNext();
            await lineReader2.moveNext();
        }
    }
}
exports.default = TextFileDiff;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter} from 'events';\nimport {TextFileDiffOption} from './types';\nimport {PathLike, createReadStream} from 'fs';\nimport {Interface, createInterface} from 'readline';\nimport stream from 'stream';\n\n// import myDebug = require('debug');\n// const debug = myDebug('text-file-diff');\n\nexport class StreamLineReader {\n  value: string = '';\n  nextValue: string = '';\n  lineNumber: number = -1;\n  it?: AsyncIterableIterator<string>;\n  eof: number = -1;\n  async init(readStream: stream.Readable): Promise<StreamLineReader> {\n    const rl = createInterface({\n      input: readStream,\n      crlfDelay: Number.POSITIVE_INFINITY\n    });\n    this.it = rl[Symbol.asyncIterator]();\n\n    // move to first line\n    await this.moveNext();\n    await this.moveNext();\n\n    return this;\n  }\n\n  async moveNext(): Promise<string> {\n    this.value = this.nextValue;\n\n    const nextResult = await this.it.next();\n\n    if (nextResult.done) {\n      this.eof++;\n      nextResult.value = '';\n    }\n\n    this.nextValue = nextResult.value;\n    this.lineNumber++;\n    return this.value;\n  }\n}\n\n/**\n * line by line diff of two files\n */\nexport default class TextFileDiff extends EventEmitter {\n  options: TextFileDiffOption;\n\n  constructor(options?: TextFileDiffOption) {\n    super();\n    this.options = new TextFileDiffOption();\n    Object.assign(this.options, options);\n  }\n\n  /**\n   * run diff\n   * @param  String file1 path to file 1\n   * @param  String file2 path to file 2\n   * @return Object         self\n   */\n  async diff(file1: string, file2: string) {\n    const stream1 = createReadStream(file1);\n    const stream2 = createReadStream(file2);\n    return this.diffStream(stream1, stream2);\n  }\n\n  /**\n   * run diffStream\n   * @param  Readable stream1\n   * @param  Readable stream2\n   * @return Object         self\n   */\n  async diffStream(stream1: stream.Readable, stream2: stream.Readable) {\n    const lineReader1 = await (new StreamLineReader()).init(stream1);\n    const lineReader2 = await (new StreamLineReader()).init(stream2);\n\n    if (this.options.skipHeader) {\n      await lineReader1.moveNext();\n      await lineReader2.moveNext();\n    }\n\n    /* eslint-disable no-await-in-loop */\n    // while both files has valid val, check eof counter\n    while (lineReader1.eof < 2 && lineReader2.eof < 2) {\n      await this.doCompareLineReader(lineReader1, lineReader2);\n    }\n    /* eslint-enable no-await-in-loop */\n\n    return this;\n  }\n\n  async doCompareLineReader(lineReader1: StreamLineReader, lineReader2: StreamLineReader) {\n    // forEach line in File1, compare to line in File2\n    const line1 = lineReader1.value;\n    const line2 = lineReader2.value;\n    const cmpar = this.options.compareFn(line1, line2);\n\n    // debug(line1, line1, cmpar);\n    // debug(lineReader1.nextValue, lineReader2.nextValue, 'next', lineReader1.eof, lineReader2.eof);\n    // emit on compared\n    this.emit('compared', line1, line2, cmpar, lineReader1, lineReader2);\n\n    if (cmpar > 0) {\n      // line1 > line2: new line detected\n      // if file2 ended before file1, then file2 lost line1\n      // else file2 has new line\n      if (lineReader2.eof > lineReader1.eof) {\n        this.emit('-', line1, lineReader1, lineReader2);\n      } else {\n        this.emit('+', line2, lineReader1, lineReader2);\n      }\n\n      // incr File2 to next line\n      await lineReader2.moveNext();\n    } else if (cmpar < 0) {\n      // line1 < line2: deleted line\n      // if file1 ended before file2, then file2 has new line\n      // else file1 lost a line\n      if (lineReader1.eof > lineReader2.eof) {\n        this.emit('+', line2, lineReader1, lineReader2);\n      } else {\n        this.emit('-', line1, lineReader1, lineReader2);\n      }\n\n      // incr File1 to next line\n      await lineReader1.moveNext();\n    } else {\n      // equals: 0 incr both files to next line\n      await lineReader1.moveNext();\n      await lineReader2.moveNext();\n    }\n  }\n}\n"]}