Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
async.spec.ts	6.62 KB	-rw-r--r--
async.ts	3.13 KB	-rw-r--r--
common.spec.ts	3.3 KB	-rw-r--r--
common.ts	852 B	-rw-r--r--
reader.spec.ts	762 B	-rw-r--r--
reader.ts	287 B	-rw-r--r--
sync.spec.ts	3.97 KB	-rw-r--r--
sync.ts	1.74 KB	-rw-r--r--

Code Editor : async.ts

import { EventEmitter } from 'events';

import * as fsScandir from '@nodelib/fs.scandir';
import * as fastq from 'fastq';

import Settings from '../settings';
import { Entry, Errno, QueueItem } from '../types';
import * as common from './common';
import Reader from './reader';

type EntryEventCallback = (entry: Entry) => void;
type ErrorEventCallback = (error: Errno) => void;
type EndEventCallback = () => void;

export default class AsyncReader extends Reader {
	protected readonly _scandir: typeof fsScandir.scandir = fsScandir.scandir;
	protected readonly _emitter: EventEmitter = new EventEmitter();

private readonly _queue: fastq.queue = fastq(this._worker.bind(this), this._settings.concurrency);
	private _isFatalError: boolean = false;
	private _isDestroyed: boolean = false;

constructor(_root: string, protected readonly _settings: Settings) {
		super(_root, _settings);

this._queue.drain = () => {
			if (!this._isFatalError) {
				this._emitter.emit('end');
			}
		};
	}

public read(): EventEmitter {
		this._isFatalError = false;
		this._isDestroyed = false;

setImmediate(() => {
			this._pushToQueue(this._root, this._settings.basePath);
		});

return this._emitter;
	}

public get isDestroyed(): boolean {
		return this._isDestroyed;
	}

public destroy(): void {
		if (this._isDestroyed) {
			throw new Error('The reader is already destroyed');
		}

this._isDestroyed = true;
		this._queue.killAndDrain();
	}

public onEntry(callback: EntryEventCallback): void {
		this._emitter.on('entry', callback);
	}

public onError(callback: ErrorEventCallback): void {
		this._emitter.once('error', callback);
	}

public onEnd(callback: EndEventCallback): void {
		this._emitter.once('end', callback);
	}

private _pushToQueue(directory: string, base?: string): void {
		const queueItem: QueueItem = { directory, base };

this._queue.push(queueItem, (error: Error | null) => {
			if (error !== null) {
				this._handleError(error);
			}
		});
	}

private _worker(item: QueueItem, done: fastq.done): void {
		this._scandir(item.directory, this._settings.fsScandirSettings, (error: NodeJS.ErrnoException | null, entries) => {
			if (error !== null) {
				return done(error, undefined);
			}

for (const entry of entries) {
				this._handleEntry(entry, item.base);
			}

done(null as unknown as Error, undefined);
		});
	}

private _handleError(error: Error): void {
		if (this._isDestroyed || !common.isFatalError(this._settings, error)) {
			return;
		}

this._isFatalError = true;
		this._isDestroyed = true;
		this._emitter.emit('error', error);
	}

private _handleEntry(entry: Entry, base?: string): void {
		if (this._isDestroyed || this._isFatalError) {
			return;
		}

const fullpath = entry.path;

if (base !== undefined) {
			entry.path = common.joinPathSegments(base, entry.name, this._settings.pathSegmentSeparator);
		}

if (common.isAppliedFilter(this._settings.entryFilter, entry)) {
			this._emitEntry(entry);
		}

if (entry.dirent.isDirectory() && common.isAppliedFilter(this._settings.deepFilter, entry)) {
			this._pushToQueue(fullpath, entry.path);
		}
	}

private _emitEntry(entry: Entry): void {
		this._emitter.emit('entry', entry);
	}
}

${this.title}

Code Editor : async.ts