globby

Functions

• convertPathToPattern()
• generateGlobTasks()
• generateGlobTasksSync()
• globby()
• globbyStream()
• globbySync()
• isDynamicPattern()
• isGitIgnored()
• isGitIgnoredSync()
• isIgnoredByIgnoreFiles()
• isIgnoredByIgnoreFilesSync()

Type Aliases

• AsyncIterableReadable
• ExpandDirectoriesOption
• FastGlobOptionsWithoutCwd
• GitignoreOptions
• GlobbyEntryStream
• GlobbyFilterFunction
• GlobbyStream
• GlobEntry
• GlobTask
• Options

function convertPathToPattern

convertPathToPattern: (source: string) => FastGlob.Pattern;

function generateGlobTasks

generateGlobTasks: (
    patterns: string | readonly string[],
    options?: Options
) => Promise<GlobTask[]>;

• Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.

  Returns

  An object in the format {pattern: string, options: object}, which can be passed as arguments to [fast-glob](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.

function generateGlobTasksSync

generateGlobTasksSync: (
    patterns: string | readonly string[],
    options?: Options
) => GlobTask[];

• Returns

  An object in the format {pattern: string, options: object}, which can be passed as arguments to [fast-glob](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.

  See Also

  • generateGlobTasks

function globby

globby: {
    (
        patterns: string | readonly string[],
        options: Options & { objectMode: true }
    ): Promise<GlobEntry[]>;
    (patterns: string | readonly string[], options?: Options): Promise<string[]>;
};

• Find files and directories using glob patterns.

  Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use path.posix.join() instead of path.join().

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.

  Returns

  The matching paths.

  Example 1

  import {globby} from 'globby';
  
  const paths = await globby(['*', '!cake']);
  
  console.log(paths);
  //=> ['unicorn', 'rainbow']

function globbyStream

globbyStream: {
    (
        patterns: string | readonly string[],
        options: Options & { objectMode: true }
    ): GlobbyEntryStream;
    (patterns: string | readonly string[], options?: Options): GlobbyStream;
};

• Find files and directories using glob patterns.

  Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use path.posix.join() instead of path.join().

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.

  Returns

  The stream of matching paths.

  Example 1

  import {globbyStream} from 'globby';
  
  for await (const path of globbyStream('*.tmp')) {
  	console.log(path);
  }

function globbySync

globbySync: {
    (
        patterns: string | readonly string[],
        options: Options & { objectMode: true }
    ): GlobEntry[];
    (patterns: string | readonly string[], options?: Options): string[];
};

• Find files and directories using glob patterns.

  Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use path.posix.join() instead of path.join().

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.

  Returns

  The matching paths.

function isDynamicPattern

isDynamicPattern: (
    patterns: string | readonly string[],
    options?: FastGlobOptionsWithoutCwd & { readonly cwd?: URL | string }
) => boolean;

• Note that the options affect the results.

  This function is backed by [fast-glob](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3).

  Returns

  Whether there are any special glob characters in the patterns.

function isGitIgnored

isGitIgnored: (options?: GitignoreOptions) => Promise<GlobbyFilterFunction>;

• .gitignore files matched by the ignore config are not used for the resulting filter function.

  Returns

  A filter function indicating whether a given path is ignored via a .gitignore file.

  Example 1

  import {isGitIgnored} from 'globby';
  
  const isIgnored = await isGitIgnored();
  
  console.log(isIgnored('some/file'));

function isGitIgnoredSync

isGitIgnoredSync: (options?: GitignoreOptions) => GlobbyFilterFunction;

• Returns

  A filter function indicating whether a given path is ignored via a .gitignore file.

  See Also

  • isGitIgnored

function isIgnoredByIgnoreFiles

isIgnoredByIgnoreFiles: (
    patterns: string | readonly string[],
    options?: Options
) => Promise<GlobbyFilterFunction>;

• Check if a path is ignored by the ignore files.

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.

  Returns

  A filter function indicating whether a given path is ignored via the ignore files.

  This is a more generic form of the isGitIgnored function, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's .babelignore, Prettier's .prettierignore, or ESLint's .eslintignore files.

  Example 1

  import {isIgnoredByIgnoreFiles} from 'globby';
  
  const isIgnored = await isIgnoredByIgnoreFiles('**\/.gitignore');
  
  console.log(isIgnored('some/file'));

function isIgnoredByIgnoreFilesSync

isIgnoredByIgnoreFilesSync: (
    patterns: string | readonly string[],
    options?: Options
) => GlobbyFilterFunction;

• Check if a path is ignored by the ignore files.

  Parameter patterns

  See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).

  Parameter options

  See the [fast-glob options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.

  Returns

  A filter function indicating whether a given path is ignored via the ignore files.

  This is a more generic form of the isGitIgnored function, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's .babelignore, Prettier's .prettierignore, or ESLint's .eslintignore files.

  Example 1

  import {isIgnoredByIgnoreFilesSync} from 'globby';
  
  const isIgnored = isIgnoredByIgnoreFilesSync('**\/.gitignore');
  
  console.log(isIgnored('some/file'));

  See Also

  • isIgnoredByIgnoreFiles

type AsyncIterableReadable

type AsyncIterableReadable<Value> = Omit<
    NodeJS.ReadableStream,
    typeof Symbol.asyncIterator
> & {
    [Symbol.asyncIterator](): NodeJS.AsyncIterator<Value>;
};

type ExpandDirectoriesOption

type ExpandDirectoriesOption =
    | boolean
    | readonly string[]
    | { files?: readonly string[]; extensions?: readonly string[] };

type FastGlobOptionsWithoutCwd

type FastGlobOptionsWithoutCwd = Omit<FastGlob.Options, 'cwd'>;

type GitignoreOptions

type GitignoreOptions = {
    readonly cwd?: URL | string;
};

type GlobbyEntryStream

type GlobbyEntryStream = AsyncIterableReadable<GlobEntry>;

• A readable stream that yields GlobEntry objects from glob patterns when objectMode is enabled.

type GlobbyFilterFunction

type GlobbyFilterFunction = (path: URL | string) => boolean;

type GlobbyStream

type GlobbyStream = AsyncIterableReadable<string>;

• A readable stream that yields string paths from glob patterns.

type GlobEntry

type GlobEntry = FastGlob.Entry;

type GlobTask

type GlobTask = {
    readonly patterns: string[];
    readonly options: Options;
};

type Options

type Options = {
    /**
	If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.

	Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.

	@default true

	@example
	```
	import {globby} from 'globby';

	const paths = await globby('images', {
		expandDirectories: {
			files: ['cat', 'unicorn', '*.jpg'],
			extensions: ['png']
		}
	});

	console.log(paths);
	//=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
	```
	*/
    readonly expandDirectories?: ExpandDirectoriesOption;

    /**
	Respect ignore patterns in `.gitignore` files that apply to the globbed files.

	Performance note: This option searches for all `.gitignore` files in the entire directory tree before globbing, which can be slow. For better performance, use `ignoreFiles: '.gitignore'` to only respect the root `.gitignore` file.

	@default false
	*/
    readonly gitignore?: boolean;

    /**
	Glob patterns to look for ignore files, which are then used to ignore globbed files.

	This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.

	Performance tip: Using a specific path like `'.gitignore'` is much faster than recursive patterns.

	@default undefined
	*/
    readonly ignoreFiles?: string | readonly string[];

    /**
	The current working directory in which to search.

	@default process.cwd()
	*/
    readonly cwd?: URL | string;
} & FastGlobOptionsWithoutCwd;