FM / readers

/var/www/cobraambalaj/node_modules/@nodelib/fs.walk/src/readers/

/var/www/cobraambalaj/node_modules/@nodelib/fs.walk/src/readers

Name	Size	Mode	Actions
async.spec.ts	6779	0644	edit dl rm
async.ts	3209	0644	edit dl rm
common.spec.ts	3379	0644	edit dl rm
common.ts	852	0644	edit dl rm
reader.spec.ts	762	0644	edit dl rm
reader.ts	287	0644	edit dl rm
sync.spec.ts	4065	0644	edit dl rm
sync.ts	1778	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/@nodelib/fs.walk/src/readers/async.ts (3209B)

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);
	}
}

cmd: