fast-glob-fast 0.2.0

package/out/providers/provider.d.ts

@@ -0,0 +1,19 @@
+import DeepFilter from './filters/deep';
+import EntryFilter from './filters/entry';
+import ErrorFilter from './filters/error';
+import EntryTransformer from './transformers/entry';
+import type Settings from '../settings';
+import type { MicromatchOptions, ReaderOptions } from '../types';
+import type { Task } from '../managers/tasks';
+export declare abstract class Provider<T> {
+    #private;
+    readonly errorFilter: ErrorFilter;
+    readonly entryFilter: EntryFilter;
+    readonly deepFilter: DeepFilter;
+    readonly entryTransformer: EntryTransformer;
+    constructor(settings: Settings);
+    abstract read(_task: Task): T;
+    protected _getRootDirectory(task: Task): string;
+    protected _getReaderOptions(task: Task): ReaderOptions;
+    protected _getMicromatchOptions(): MicromatchOptions;
+}

package/out/providers/provider.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = void 0;
+const path = require("node:path");
+const deep_1 = require("./filters/deep");
+const entry_1 = require("./filters/entry");
+const error_1 = require("./filters/error");
+const entry_2 = require("./transformers/entry");
+class Provider {
+    errorFilter;
+    entryFilter;
+    deepFilter;
+    entryTransformer;
+    #settings;
+    constructor(settings) {
+        this.#settings = settings;
+        const micromatchOptions = this._getMicromatchOptions();
+        this.errorFilter = new error_1.default(settings);
+        this.entryFilter = new entry_1.default(settings, micromatchOptions);
+        this.deepFilter = new deep_1.default(settings, micromatchOptions);
+        this.entryTransformer = new entry_2.default(settings);
+    }
+    _getRootDirectory(task) {
+        return path.resolve(this.#settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+        const basePath = task.base === '.' ? '' : task.base;
+        return {
+            basePath,
+            pathSegmentSeparator: '/',
+            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+            errorFilter: this.errorFilter.getFilter(),
+            followSymbolicLinks: this.#settings.followSymbolicLinks,
+            fs: this.#settings.fs,
+            stats: this.#settings.stats,
+            throwErrorOnBrokenSymbolicLink: this.#settings.throwErrorOnBrokenSymbolicLink,
+            transform: this.entryTransformer.getTransformer(),
+            signal: this.#settings.signal,
+        };
+    }
+    _getMicromatchOptions() {
+        return {
+            dot: this.#settings.dot,
+            matchBase: this.#settings.baseNameMatch,
+            nobrace: !this.#settings.braceExpansion,
+            nocase: !this.#settings.caseSensitiveMatch,
+            noext: !this.#settings.extglob,
+            noglobstar: !this.#settings.globstar,
+            posix: true,
+            strictSlashes: false,
+        };
+    }
+}
+exports.Provider = Provider;

package/out/providers/stream.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'node:stream';
+import { Provider } from './provider';
+import type { IReaderStream } from '../readers';
+import type Settings from '../settings';
+import type { Task } from '../managers/tasks';
+import type { ReaderOptions } from '../types';
+export declare class ProviderStream extends Provider<Readable> {
+    #private;
+    constructor(reader: IReaderStream, settings: Settings);
+    read(task: Task): Readable;
+    api(root: string, task: Task, options: ReaderOptions): Readable;
+}

package/out/providers/stream.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderStream = void 0;
+const node_stream_1 = require("node:stream");
+const provider_1 = require("./provider");
+class ProviderStream extends provider_1.Provider {
+    #reader;
+    constructor(reader, settings) {
+        super(settings);
+        this.#reader = reader;
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const source = this.api(root, task, options);
+        const destination = new node_stream_1.Readable({ objectMode: true, read: () => { } });
+        source
+            .once('error', (error) => destination.emit('error', error))
+            .on('data', (entry) => destination.emit('data', options.transform(entry)))
+            .once('end', () => destination.emit('end'));
+        destination
+            .once('close', () => source.destroy());
+        return destination;
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this.#reader.dynamic(root, options);
+        }
+        return this.#reader.static(task.patterns, options);
+    }
+}
+exports.ProviderStream = ProviderStream;

package/out/providers/sync.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from './provider';
+import type { IReaderSync } from '../readers';
+import type Settings from '../settings';
+import type { Task } from '../managers/tasks';
+import type { Entry, EntryItem, ReaderOptions } from '../types';
+export declare class ProviderSync extends Provider<EntryItem[]> {
+    #private;
+    constructor(reader: IReaderSync, settings: Settings);
+    read(task: Task): EntryItem[];
+    api(root: string, task: Task, options: ReaderOptions): Entry[];
+}

package/out/providers/sync.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderSync = void 0;
+const provider_1 = require("./provider");
+class ProviderSync extends provider_1.Provider {
+    #reader;
+    constructor(reader, settings) {
+        super(settings);
+        this.#reader = reader;
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = this.api(root, task, options);
+        return entries.map((entry) => options.transform(entry));
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this.#reader.dynamic(root, options);
+        }
+        return this.#reader.static(task.patterns, options);
+    }
+}
+exports.ProviderSync = ProviderSync;

package/out/providers/transformers/entry.d.ts

@@ -0,0 +1,7 @@
+import type Settings from '../../settings';
+import type { EntryTransformerFunction } from '../../types';
+export default class EntryTransformer {
+    #private;
+    constructor(settings: Settings);
+    getTransformer(): EntryTransformerFunction;
+}

package/out/providers/transformers/entry.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("node:path");
+const utils = require("../../utils");
+class EntryTransformer {
+    #settings;
+    #pathSeparatorSymbol;
+    constructor(settings) {
+        this.#settings = settings;
+        this.#pathSeparatorSymbol = this.#getPathSeparatorSymbol();
+    }
+    getTransformer() {
+        return (entry) => this.#transform(entry);
+    }
+    #transform(entry) {
+        let filepath = entry.path;
+        if (this.#settings.absolute) {
+            filepath = utils.path.makeAbsolute(this.#settings.cwd, filepath);
+            filepath = utils.string.flatHeavilyConcatenatedString(filepath);
+        }
+        if (this.#settings.markDirectories && entry.dirent.isDirectory()) {
+            filepath += this.#pathSeparatorSymbol;
+        }
+        if (!this.#settings.objectMode) {
+            return filepath;
+        }
+        return {
+            ...entry,
+            path: filepath,
+        };
+    }
+    #getPathSeparatorSymbol() {
+        return this.#settings.absolute ? path.sep : '/';
+    }
+}
+exports.default = EntryTransformer;

package/out/readers/async.d.ts

@@ -0,0 +1,16 @@
+import * as fsWalk from '@nodelib/fs.walk';
+import { Reader } from './reader';
+import { ReaderStream } from './stream';
+import type Settings from '../settings';
+import type { Entry, ReaderOptions, Pattern } from '../types';
+export interface IReaderAsync {
+    dynamic: (root: string, options: ReaderOptions) => Promise<Entry[]>;
+    static: (patterns: Pattern[], options: ReaderOptions) => Promise<Entry[]>;
+}
+export declare class ReaderAsync extends Reader<Promise<Entry[]>> implements IReaderAsync {
+    protected _walkAsync: typeof fsWalk.walk;
+    protected _readerStream: ReaderStream;
+    constructor(settings: Settings);
+    dynamic(root: string, options: ReaderOptions): Promise<Entry[]>;
+    static(patterns: Pattern[], options: ReaderOptions): Promise<Entry[]>;
+}

package/out/readers/async.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaderAsync = void 0;
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+const stream_1 = require("./stream");
+class ReaderAsync extends reader_1.Reader {
+    _walkAsync = fsWalk.walk;
+    _readerStream;
+    constructor(settings) {
+        super(settings);
+        this._readerStream = new stream_1.ReaderStream(settings);
+    }
+    dynamic(root, options) {
+        return new Promise((resolve, reject) => {
+            this._walkAsync(root, options, (error, entries) => {
+                if (error === null) {
+                    resolve(entries);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async static(patterns, options) {
+        const entries = [];
+        for await (const entry of this._readerStream.static(patterns, options)) {
+            entries.push(entry);
+        }
+        return entries;
+    }
+}
+exports.ReaderAsync = ReaderAsync;

package/out/readers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './async';
+export * from './stream';
+export * from './sync';

package/out/readers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./async"), exports);
+__exportStar(require("./stream"), exports);
+__exportStar(require("./sync"), exports);

package/out/readers/reader.d.ts

@@ -0,0 +1,13 @@
+import * as fsStat from '@nodelib/fs.stat';
+import type Settings from '../settings';
+import type { Entry, ErrnoException, FsStats, Pattern, ReaderOptions } from '../types';
+export declare abstract class Reader<T> {
+    #private;
+    protected readonly _fsStatSettings: fsStat.Settings;
+    constructor(settings: Settings);
+    abstract dynamic(root: string, options: ReaderOptions): T;
+    abstract static(patterns: Pattern[], options: ReaderOptions): T;
+    protected _getFullEntryPath(filepath: string): string;
+    protected _makeEntry(stats: FsStats, pattern: Pattern): Entry;
+    protected _isFatalError(error: ErrnoException): boolean;
+}

package/out/readers/reader.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reader = void 0;
+const path = require("node:path");
+const fsStat = require("@nodelib/fs.stat");
+const utils = require("../utils");
+class Reader {
+    _fsStatSettings;
+    #settings;
+    constructor(settings) {
+        this.#settings = settings;
+        this._fsStatSettings = new fsStat.Settings({
+            followSymbolicLink: settings.followSymbolicLinks,
+            fs: settings.fs,
+            throwErrorOnBrokenSymbolicLink: settings.throwErrorOnBrokenSymbolicLink,
+        });
+    }
+    _getFullEntryPath(filepath) {
+        return path.resolve(this.#settings.cwd, filepath);
+    }
+    _makeEntry(stats, pattern) {
+        const entry = {
+            name: pattern,
+            path: pattern,
+            dirent: utils.fs.createDirentFromStats(pattern, stats),
+        };
+        if (this.#settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    }
+    _isFatalError(error) {
+        return !utils.errno.isEnoentCodeError(error) && !this.#settings.suppressErrors;
+    }
+}
+exports.Reader = Reader;

package/out/readers/stream.d.ts

@@ -0,0 +1,16 @@
+import * as fsStat from '@nodelib/fs.stat';
+import * as fsWalk from '@nodelib/fs.walk';
+import { Reader } from './reader';
+import type { Pattern, ReaderOptions } from '../types';
+import type { Readable } from 'node:stream';
+export interface IReaderStream {
+    dynamic: (root: string, options: ReaderOptions) => Readable;
+    static: (patterns: Pattern[], options: ReaderOptions) => Readable;
+}
+export declare class ReaderStream extends Reader<Readable> implements IReaderStream {
+    #private;
+    protected _walkStream: typeof fsWalk.walkStream;
+    protected _stat: typeof fsStat.stat;
+    dynamic(root: string, options: ReaderOptions): Readable;
+    static(patterns: Pattern[], options: ReaderOptions): Readable;
+}

package/out/readers/stream.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaderStream = void 0;
+const node_stream_1 = require("node:stream");
+const fsStat = require("@nodelib/fs.stat");
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+class ReaderStream extends reader_1.Reader {
+    _walkStream = fsWalk.walkStream;
+    _stat = fsStat.stat;
+    dynamic(root, options) {
+        return this._walkStream(root, options);
+    }
+    static(patterns, options) {
+        const filepaths = patterns.map((pattern) => this._getFullEntryPath(pattern));
+        const stream = new node_stream_1.PassThrough({ objectMode: true, signal: options.signal });
+        stream._write = (index, _enc, done) => {
+            this.#getEntry(filepaths[index], patterns[index], options)
+                .then((entry) => {
+                if (entry !== null && options.entryFilter(entry)) {
+                    stream.push(entry);
+                }
+                if (index === filepaths.length - 1) {
+                    stream.end();
+                }
+                done();
+            })
+                .catch(done);
+        };
+        for (let index = 0; index < filepaths.length; index++) {
+            stream.write(index);
+        }
+        return stream;
+    }
+    #getEntry(filepath, pattern, options) {
+        return this.#getStat(filepath)
+            .then((stats) => this._makeEntry(stats, pattern))
+            .catch((error) => {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        });
+    }
+    #getStat(filepath) {
+        return new Promise((resolve, reject) => {
+            this._stat(filepath, this._fsStatSettings, (error, stats) => {
+                if (error === null) {
+                    resolve(stats);
+                }
+                else {
+                    reject(error);
+                }
+            });
+        });
+    }
+}
+exports.ReaderStream = ReaderStream;

package/out/readers/sync.d.ts

@@ -0,0 +1,15 @@
+import * as fsStat from '@nodelib/fs.stat';
+import * as fsWalk from '@nodelib/fs.walk';
+import { Reader } from './reader';
+import type { Entry, Pattern, ReaderOptions } from '../types';
+export interface IReaderSync {
+    dynamic: (root: string, options: ReaderOptions) => Entry[];
+    static: (patterns: Pattern[], options: ReaderOptions) => Entry[];
+}
+export declare class ReaderSync extends Reader<Entry[]> implements IReaderSync {
+    #private;
+    protected _walkSync: typeof fsWalk.walkSync;
+    protected _statSync: typeof fsStat.statSync;
+    dynamic(root: string, options: ReaderOptions): Entry[];
+    static(patterns: Pattern[], options: ReaderOptions): Entry[];
+}

package/out/readers/sync.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaderSync = void 0;
+const fsStat = require("@nodelib/fs.stat");
+const fsWalk = require("@nodelib/fs.walk");
+const reader_1 = require("./reader");
+class ReaderSync extends reader_1.Reader {
+    _walkSync = fsWalk.walkSync;
+    _statSync = fsStat.statSync;
+    dynamic(root, options) {
+        return this._walkSync(root, options);
+    }
+    static(patterns, options) {
+        const entries = [];
+        for (const pattern of patterns) {
+            const filepath = this._getFullEntryPath(pattern);
+            const entry = this.#getEntry(filepath, pattern, options);
+            if (entry === null || !options.entryFilter(entry)) {
+                continue;
+            }
+            entries.push(entry);
+        }
+        return entries;
+    }
+    #getEntry(filepath, pattern, options) {
+        try {
+            const stats = this.#getStat(filepath);
+            return this._makeEntry(stats, pattern);
+        }
+        catch (error) {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    #getStat(filepath) {
+        return this._statSync(filepath, this._fsStatSettings);
+    }
+}
+exports.ReaderSync = ReaderSync;

package/out/settings.d.ts

@@ -0,0 +1,162 @@
+import type { FileSystemAdapter, Pattern } from './types';
+export declare const DEFAULT_FILE_SYSTEM_ADAPTER: FileSystemAdapter;
+export interface Options {
+    /**
+     * Return the absolute path for entries.
+     *
+     * @default false
+     */
+    absolute?: boolean;
+    /**
+     * If set to `true`, then patterns without slashes will be matched against
+     * the basename of the path if it contains slashes.
+     *
+     * @default false
+     */
+    baseNameMatch?: boolean;
+    /**
+     * Enables Bash-like brace expansion.
+     *
+     * @default true
+     */
+    braceExpansion?: boolean;
+    /**
+     * Enables a case-sensitive mode for matching files.
+     *
+     * @default true
+     */
+    caseSensitiveMatch?: boolean;
+    /**
+     * The current working directory in which to search.
+     *
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Specifies the maximum depth of a read directory relative to the start
+     * directory.
+     *
+     * @default Infinity
+     */
+    deep?: number;
+    /**
+     * Allow patterns to match entries that begin with a period (`.`).
+     *
+     * @default false
+     */
+    dot?: boolean;
+    /**
+     * Enables Bash-like `extglob` functionality.
+     *
+     * @default true
+     */
+    extglob?: boolean;
+    /**
+     * Indicates whether to traverse descendants of symbolic link directories.
+     *
+     * @default true
+     */
+    followSymbolicLinks?: boolean;
+    /**
+     * Custom implementation of methods for working with the file system.
+     *
+     * @default fs.*
+     */
+    fs?: Partial<FileSystemAdapter>;
+    /**
+     * Enables recursively repeats a pattern containing `**`.
+     * If `false`, `**` behaves exactly like `*`.
+     *
+     * @default true
+     */
+    globstar?: boolean;
+    /**
+     * An array of glob patterns to exclude matches.
+     * This is an alternative way to use negative patterns.
+     *
+     * @default []
+     */
+    ignore?: readonly Pattern[];
+    /**
+     * Mark the directory path with the final slash.
+     *
+     * @default false
+     */
+    markDirectories?: boolean;
+    /**
+     * Returns objects (instead of strings) describing entries.
+     *
+     * @default false
+     */
+    objectMode?: boolean;
+    /**
+     * Return only directories.
+     *
+     * @default false
+     */
+    onlyDirectories?: boolean;
+    /**
+     * Return only files.
+     *
+     * @default true
+     */
+    onlyFiles?: boolean;
+    /**
+     * Enables an object mode (`objectMode`) with an additional `stats` field.
+     *
+     * @default false
+     */
+    stats?: boolean;
+    /**
+     * By default this package suppress only `ENOENT` errors.
+     * Set to `true` to suppress any error.
+     *
+     * @default false
+     */
+    suppressErrors?: boolean;
+    /**
+     * Throw an error when symbolic link is broken if `true` or safely
+     * return `lstat` call if `false`.
+     *
+     * @default false
+     */
+    throwErrorOnBrokenSymbolicLink?: boolean;
+    /**
+     * Ensures that the returned entries are unique.
+     *
+     * @default true
+     */
+    unique?: boolean;
+    /**
+     * A signal to abort searching for entries on the file system.
+     * Works only with asynchronous methods for dynamic and static patterns.
+     *
+     * @default undefined
+     */
+    signal?: AbortSignal;
+}
+export default class Settings {
+    #private;
+    readonly absolute: boolean;
+    readonly baseNameMatch: boolean;
+    readonly braceExpansion: boolean;
+    readonly caseSensitiveMatch: boolean;
+    readonly cwd: string;
+    readonly deep: number;
+    readonly dot: boolean;
+    readonly extglob: boolean;
+    readonly followSymbolicLinks: boolean;
+    readonly fs: FileSystemAdapter;
+    readonly globstar: boolean;
+    readonly ignore: readonly Pattern[];
+    readonly markDirectories: boolean;
+    readonly objectMode: boolean;
+    readonly onlyDirectories: boolean;
+    readonly onlyFiles: boolean;
+    readonly stats: boolean;
+    readonly suppressErrors: boolean;
+    readonly throwErrorOnBrokenSymbolicLink: boolean;
+    readonly unique: boolean;
+    readonly signal?: AbortSignal;
+    constructor(options?: Options);
+}