source: trip-planner-front/node_modules/globby/index.js@ eed0bf8

'use strict';
const fs = require('fs');
const arrayUnion = require('array-union');
const merge2 = require('merge2');
const fastGlob = require('fast-glob');
const dirGlob = require('dir-glob');
const gitignore = require('./gitignore');
const {FilterStream, UniqueStream} = require('./stream-utils');

const DEFAULT_FILTER = () => false;

const isNegative = pattern => pattern[0] === '!';

const assertPatternsInput = patterns => {
        if (!patterns.every(pattern => typeof pattern === 'string')) {
                throw new TypeError('Patterns must be a string or an array of strings');
        }
};

const checkCwdOption = (options = {}) => {
        if (!options.cwd) {
                return;
        }

        let stat;
        try {
                stat = fs.statSync(options.cwd);
        } catch {
                return;
        }

        if (!stat.isDirectory()) {
                throw new Error('The `cwd` option must be a path to a directory');
        }
};

const getPathString = p => p.stats instanceof fs.Stats ? p.path : p;

const generateGlobTasks = (patterns, taskOptions) => {
        patterns = arrayUnion([].concat(patterns));
        assertPatternsInput(patterns);
        checkCwdOption(taskOptions);

        const globTasks = [];

        taskOptions = {
                ignore: [],
                expandDirectories: true,
                ...taskOptions
        };

        for (const [index, pattern] of patterns.entries()) {
                if (isNegative(pattern)) {
                        continue;
                }

                const ignore = patterns
                        .slice(index)
                        .filter(pattern => isNegative(pattern))
                        .map(pattern => pattern.slice(1));

                const options = {
                        ...taskOptions,
                        ignore: taskOptions.ignore.concat(ignore)
                };

                globTasks.push({pattern, options});
        }

        return globTasks;
};

const globDirs = (task, fn) => {
        let options = {};
        if (task.options.cwd) {
                options.cwd = task.options.cwd;
        }

        if (Array.isArray(task.options.expandDirectories)) {
                options = {
                        ...options,
                        files: task.options.expandDirectories
                };
        } else if (typeof task.options.expandDirectories === 'object') {
                options = {
                        ...options,
                        ...task.options.expandDirectories
                };
        }

        return fn(task.pattern, options);
};

const getPattern = (task, fn) => task.options.expandDirectories ? globDirs(task, fn) : [task.pattern];

const getFilterSync = options => {
        return options && options.gitignore ?
                gitignore.sync({cwd: options.cwd, ignore: options.ignore}) :
                DEFAULT_FILTER;
};

const globToTask = task => glob => {
        const {options} = task;
        if (options.ignore && Array.isArray(options.ignore) && options.expandDirectories) {
                options.ignore = dirGlob.sync(options.ignore);
        }

        return {
                pattern: glob,
                options
        };
};

module.exports = async (patterns, options) => {
        const globTasks = generateGlobTasks(patterns, options);

        const getFilter = async () => {
                return options && options.gitignore ?
                        gitignore({cwd: options.cwd, ignore: options.ignore}) :
                        DEFAULT_FILTER;
        };

        const getTasks = async () => {
                const tasks = await Promise.all(globTasks.map(async task => {
                        const globs = await getPattern(task, dirGlob);
                        return Promise.all(globs.map(globToTask(task)));
                }));

                return arrayUnion(...tasks);
        };

        const [filter, tasks] = await Promise.all([getFilter(), getTasks()]);
        const paths = await Promise.all(tasks.map(task => fastGlob(task.pattern, task.options)));

        return arrayUnion(...paths).filter(path_ => !filter(getPathString(path_)));
};

module.exports.sync = (patterns, options) => {
        const globTasks = generateGlobTasks(patterns, options);

        const tasks = [];
        for (const task of globTasks) {
                const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
                tasks.push(...newTask);
        }

        const filter = getFilterSync(options);

        let matches = [];
        for (const task of tasks) {
                matches = arrayUnion(matches, fastGlob.sync(task.pattern, task.options));
        }

        return matches.filter(path_ => !filter(path_));
};

module.exports.stream = (patterns, options) => {
        const globTasks = generateGlobTasks(patterns, options);

        const tasks = [];
        for (const task of globTasks) {
                const newTask = getPattern(task, dirGlob.sync).map(globToTask(task));
                tasks.push(...newTask);
        }

        const filter = getFilterSync(options);
        const filterStream = new FilterStream(p => !filter(p));
        const uniqueStream = new UniqueStream();

        return merge2(tasks.map(task => fastGlob.stream(task.pattern, task.options)))
                .pipe(filterStream)
                .pipe(uniqueStream);
};

module.exports.generateGlobTasks = generateGlobTasks;

module.exports.hasMagic = (patterns, options) => []
        .concat(patterns)
        .some(pattern => fastGlob.isDynamicPattern(pattern, options));

module.exports.gitignore = gitignore;