Enumeration lsTypesReadonly
Enumeration Members
LS_
LS_
This option lists both regular files and directories in the output. +You can also use other number types for alias, like:
+LS_A: 0b01 | 0o01 | 0x01 // Each equivalent to 1
+LS_
LS_
This option filters the output to include only directory entries. +You can also use other number types for alias, like:
+LS_D: 0b10 | 0o02 | 0x02 // Each equivalent to 2
+LS_
LS_
This option filters the output to include only regular files (non-directories). +You can also use other number types for alias, like:
+LS_F: 0b100 | 0o04 | 0x04 // Each equivalent to 4
+Generated using TypeDoc v0.25.12
+
+
+
Function ls
- ls(dirpath, options?, type?): Promise<LsResult>
Lists files and/or directories in a specified directory path, filtering by a +regular expression pattern.
+The returned entries are configurable using the additional options, +such as listing recursively to subdirectories, and filter specific file and/or +directory names using a regular expression.
+The additional
+optionscan be an object or a regex pattern to specify only +the LsOptions.match field. If passed as aRegExpobject, +the additional options for reading the directory will uses default options.If the
+optionsargument not specified (orundefined), then it uses the +default value:
+[LsOptions]: {
encoding: 'utf8',
recursive: false,
match: /.+/,
exclude: undefined
} +Parameters
- dirpath: string
The directory path to search.
+ Optionaloptions: RegExp | LsOptionsAdditional options for reading the directory.
+Optionaltype: lsTypes | (keyof LsTypes) | LsTypesValuesA type to specify the returned file system type to be included. + If not specified or set to
+0, then it will includes all types + (including regular files and directories). + See lsTypes to check all supported types.
Returns Promise<LsResult>
A promise that resolves with an array of string representing the + entries result or an empty array if any files and directories doesn't + match with the specified filter options.
+Throws
If there is an error occurred while reading a directory.
+Example
+// List all installed packages in 'node_modules' directory
ls('node_modules', { exclude: /\.bin/ }, lsTypes.LS_D)
.then((dirs) => console.log(dirs)); +Since
0.1.0
+See
-
+
- lsTypes +
- lsFiles +
- lsDirs +
- fs.readdir +
- dirpath: string
Generated using TypeDoc v0.25.12
+
+
+
Function lsDirs
- ls
Dirs(dirpath, options?): Promise<LsResult> Lists files in the specified directory path, filtering by a regular +expression pattern.
+The returned entries are configurable using the additional
+options, such as +listing recursively to subdirectories, and filter specific file and/or +directory names using a regular expression.The additional
+optionscan be an object or a regex pattern to specify only the +matchfield. If passed as aRegExpobject, the additional options for reading +the directory will uses default options.If the
+optionsargument not specified (orundefined), then it uses the +default value:
+[LsOptions]: {
encoding: 'utf8',
recursive: false,
match: /.+/,
exclude: undefined
} +Parameters
- dirpath: string
The directory path to search.
+ Optionaloptions: RegExp | LsOptionsAdditional options for reading the directory.
+
Returns Promise<LsResult>
A promise that resolves with an array of string representing the + entries result or an empty array if any directories doesn't match + with the specified filter options.
+Throws
If there is an error occurred while reading a directory.
+Example
+// Search and list directory named 'foo' in 'src' directory
lsDirs('src', {
recursive: false,
match: /[\/\\]\bfoo\b/,
}).then((files) => console.log(files)); +Since
0.1.0
+See
-
+
- ls +
- lsFiles +
- fs.readdir +
- dirpath: string
Generated using TypeDoc v0.25.12
+
+
+
Function lsFiles
- ls
Files(dirpath, options?): Promise<LsResult> Lists files in the specified directory path, filtering by a regular +expression pattern.
+The returned entries are configurable using the additional options, +such as listing recursively to subdirectories, and filter specific file and/or +directory names using a regular expression.
+The additional
+optionscan be an object or a regex pattern to specify only +the LsOptions.match field. If passed as aRegExpobject, +the additional options for reading the directory will uses default options.If the
+optionsargument not specified (orundefined), then it uses the +default value:
+[LsOptions]: {
encoding: 'utf8',
recursive: false,
match: /.+/,
exclude: undefined
} +Parameters
- dirpath: string
The directory path to search.
+ Optionaloptions: RegExp | LsOptionsAdditional options for reading the directory.
+
Returns Promise<LsResult>
A promise that resolves with an array of string representing the + entries result or an empty array if any files doesn't match with + the specified filter options.
+Throws
If there is an error occurred while reading a directory.
+Example
+// List all JavaScript files in current directory recursively,
// but excluding files from 'tests' directory
lsFiles('.', {
recursive: true,
match: /.+\.[cm]*js$/,
exclude: /[\/\\]\btests\b[\/\\]/
}).then((files) => console.log(files)); +Since
0.1.0
+See
-
+
- ls +
- lsDirs +
- fs.readdir +
- dirpath: string
Generated using TypeDoc v0.25.12
+
+
+
Function ls
- ls(dirpath, options?, type?): Promise<LsResult>
Parameters
- dirpath: string
Optionaloptions: RegExp | LsOptionsOptionaltype: LsTypes | (keyof LsTypes) | LsTypesValues
Returns Promise<LsResult>
Generated using TypeDoc v0.25.12
+
+
+
Generated using TypeDoc v0.25.12
+
+
+
Generated using TypeDoc v0.25.12
+
+
+
LSFND - v0.1.0
LSFND
+
LSFND, short for list (ls) files (f) and (n) directories (d), is a small +Node.js library designed to simplify file and directory listing tasks. It provides a +lightweight and efficient way to explore your file system and retrieve information +about files and directories with support filtering using regular expression.
+The primary benefit of this library is that all implemented APIs execute asynchronously, +therefore ensuring their execution will NOT block any other processes.
+++[!IMPORTANT]
+
Currently this project only focus on CommonJS (CJS) and ECMAScript Modules (ESM).
APIs
ls Function
async function ls(
dirpath: string,
options?: LsOptions | RegExp | undefined,
type?: lsTypes | LsTypesKeys | LsTypesValues | undefined
): Promise<LsResult>
+The ls function is an asynchronous function that retrieves a listing of files
+and/or directories within a specified directory path. It offers powerful customizable
+additional options used during listing the directory, filtering using regular
+expression and specify the type of returned results (i.e., regular files or directories,
+or includes both).
Parameters
-
+
+dirpath
The absolute or relative path to the directory you want to list.
+
+options(optional)
An optional object or regular expression used to configure the listing behavior.
+
+type(optional)
An optional parameter that specifies the type of entries you want to include +in the results. You can pass0(zero) as value which will be interpreted as +default behavior (i.e., include both regular files type and directories type). +Refer tolsTypesto see all supported types.
+
Return
Returns a promise that resolves to an array of string containing the entries result.
+It can be null if an error occurred while listing a directory, or returns a
+promise with an empty array if any files and directories doesn't match with the
+specified filter options.
++[!NOTE]
+
💡 Tip: You can combine options for more granular control. For example, +you can list files recursively while filtering by a specific extension.
+
+
+Example Usage (CJS)
+ +const { ls, lsTypes } = require('lsfnd');
(async () => {
// List all files and directories in the current directory
const allFiles = await ls('.');
console.log(allFiles);
// List only JavaScript files in the current directory recursively
const jsFiles = await ls('.', {
recursive: true,
match: /\.js$/
}, lsTypes.LS_F);
console.log(jsFiles);
})();
+
+
+
+Example Usage (ESM)
+ +import { ls, lsTypes } from 'lsfnd';
// List all files and directories in the current directory
const allFiles = await ls('.');
console.log(allFiles);
// List only JavaScript files in the current directory recursively
const jsFiles = await ls('.', {
recursive: true,
match: /\.js$/
}, lsTypes.LS_F);
console.log(jsFiles);
+lsFiles Function
async function lsFiles(
dirpath: string,
options?: LsOptions | RegExp | undefined
): Promise<LsResult>
+An asynchronous function that retrieves a listing of files within a specified
+directory path. This function behave the same as ls function,
+but this function only lists and retrieves the files type (i.e., excluding directories type).
This function is an alias for:
+// It uses LS_F to filter only the regular file type
ls(dirpath, options, lsTypes.LS_F);
+Parameters
-
+
+dirpath
The absolute or relative path to the directory you want to list.
+
+options(optional)
An optional object or regular expression used to configure the listing behavior.
+
Return
Returns a promise that resolves to an array of string containing the entries result.
+It can be null if an error occurred while listing a directory, or returns a
+promise with an empty array if any files doesn't match with the specified filter
+options.
++[!NOTE]
+
💡 Tip: You can combine options for more granular control. For example, +you can list files recursively while filtering by a specific extension.
+
+
+Example Usage (CJS)
+ +const { lsFiles } = require('lsfnd');
(async () => {
// Search and list LICENSE and README file in current directory
const files = await lsFiles('.', /(README|LICENSE)(\.md|\.txt)*$/);
console.log(files);
})();
+
+
+
+Example Usage (ESM)
+ +import { lsFiles } from 'lsfnd';
// Search and list LICENSE and README file in current directory
const files = await lsFiles('.', /(README|LICENSE)(\.md)*$/);
console.log(files);
+lsDirs Function
An asynchronous function that retrieves a listing of directories within a specified
+directory path. This function behave the same as ls function, but this
+function only lists and retrieves the directories type (i.e., excluding files type).
This function is an alias for:
+// It uses LS_D to filter only the directory type
ls(dirpath, options, lsTypes.LS_D);
+Parameters
-
+
+dirpath
The absolute or relative path to the directory you want to list.
+
+options(optional)
An optional object or regular expression used to configure the listing behavior.
+
Return
Returns a promise that resolves to an array of string containing the entries result.
+It can be null if an error occurred while listing a directory, or returns a
+promise with an empty array if any directories doesn't match with the specified
+filter options.
+
+
+Example Usage (CJS)
+ +const { lsDirs } = require('lsfnd');
(async () => {
// List all installed NPM packages in 'node_modules' directory
// excluding '.bin' directory and organization packages (prefixed with '@')
const npmPkgs = await lsDirs('node_modules', { exclude: /(\.bin|@.+)/ });
console.log(npmPkgs);
})();
+
+
+
+Example Usage (ESM)
+ +import { lsDirs } from 'lsfnd';
// List all installed NPM packages in 'node_modules' directory
// excluding '.bin' directory and organization packages (prefixed with '@')
const npmPkgs = await lsDirs('node_modules', { exclude: /(\.bin|@.+)/ });
console.log(npmPkgs);
+lsTypes Enum
An enumeration defines the different types of listings supported by the
+ls function. It specifies which file system entries should be
+included in the results.
Properties
| Name | +Description | +Value | +
|---|---|---|
LS_A |
+Represents an option to include all file types (i.e., including both regular files and directories). | +0b01 |
+
LS_D |
+Represents an option to include only the directory type. | +0b10 |
+
LS_F |
+Represents an option to include only the regular file type. | +0b100 |
+
License
This project is licensed under the terms of MIT license.
+Generated using TypeDoc v0.25.12
+
+
+
Interface BuildPropConfig
Interface representing the configuration options for the build process.
+Since
0.1.0
+interface BuildPropConfig {
    rootDir: string;
    outDir: string;
    tsconfig: string;
    minify: MinifyConfig;
}
    rootDir: string;
    outDir: string;
    tsconfig: string;
    minify: MinifyConfig;
}
Properties
root
root
The root directory of the project from where the build process starts. +This path should be a string representing a valid file system path.
+out
out
The output directory where the build process will place generated files. +This path should be a string representing a valid file system path.
+tsconfig
tsconfig: string
The path to the tsconfig.json file that will be used during the build process.
+This path should be a string representing a valid file system path relative
+to the rootDir.
minify
Configuration options for minification process.
+Generated using TypeDoc v0.25.12
+
+
+
Interface MinifyConfig
Interface representing the configuration options for minification within the +build process.
+Since
0.1.0
+ Index
Properties
files
+
Properties
files
files: string[]
A list of file paths (relative to the BuildPropConfig.rootDir) +to be included during minification. Each element in the array should be a +string representing a valid file system path.
+Generated using TypeDoc v0.25.12
+
+
+
Interface LsOptions
This interface defines the optional configuration options that can be passed
+to the ls* function. These options control the behavior of the file listing.
Since
0.1.0
+interface LsOptions {
    encoding?: BufferEncoding;
    recursive?: boolean;
    match?: string | RegExp;
    exclude?: string | RegExp;
}
    encoding?: BufferEncoding;
    recursive?: boolean;
    match?: string | RegExp;
    exclude?: string | RegExp;
}
Index
Properties
Properties
Optional encoding
encoding?: BufferEncoding
Specifies the character encoding to be used when reading a directory.
+Default Value
Defaults to 'utf8' if not provided.
Optional recursive
recursive?: boolean
A boolean flag indicating whether to include subdirectories in the listing.
+Default Value
Defaults to false if not provided.
Optional match
match?: string | RegExp
A regular expression or string pattern used to filter the listed entries. +Only entries matching the pattern will be included in the results.
+Default Value
/.+/ (match all files)
Optional exclude
exclude?: string | RegExp
A regular expression or string pattern used to exclude entries from the +listing. Any entries matching this pattern will be filtered out of the +results, even if they match the match pattern.
+Default Value
undefined
Generated using TypeDoc v0.25.12
+
+
+
Interface LsTypesReadonly
Interface defining the lsTypes enum with string literal keys +representing different file types and their corresponding numeric values.
+Since
0.1.0
+Properties
Readonly LS_
LS_
Represents an option to include all file types.
+Default Value
0b01 << 0b00 (0b01 | 0o01 | 0x01 | 1)
Readonly LS_
LS_
Represents an option to include only the directory type.
+Default Value
0b01 << 0b01 (0b10 | 0o02 | 0x02 | 2)
Readonly LS_
LS_
Represents an option to include only the file type.
+Default Value
0b01 << 0b10 (0b100 | 0o04 | 0x04 | 4)
Generated using TypeDoc v0.25.12
+
+
+
Module build.prop
Type definitions for build.prop.*js configuration file.
Project: lsfnd (https://github.com/mitsuki31/lsfnd.git)
Definitions by: Ryuu Mitsuki (https://github.com/mitsuki31)
Index
Interfaces
Generated using TypeDoc v0.25.12
+
+
+
Module lsfnd
A module that offers some functions to read and list files and/or directories +in a specified directory with support filtering using regular expression pattern.
+Copyright (c) 2024 Ryuu Mitsuki. +Licensed under the MIT license.
+Index
Enumerations
ls
Functions
Generated using TypeDoc v0.25.12
+
+
+
Module types
Type definitions for lsfnd package.
Project: lsfnd (https://github.com/mitsuki31/lsfnd.git)
Definitions by: Ryuu Mitsuki (https://github.com/mitsuki31)
Copyright (c) 2024 Ryuu Mitsuki. +Licensed under the MIT license.
+Index
Interfaces
Type Aliases
Variables
ls
Functions
Generated using TypeDoc v0.25.12
+
+
+
Type alias LsEntries
Ls
This type alias represents an array of strings. It is typically used to
+represent the list of file and/or directory entries returned by the ls* functions.
+Each string in the array represents the path of a file or directory within
+the listed directory.
Since
0.1.0
+Generated using TypeDoc v0.25.12
+
+
+
Generated using TypeDoc v0.25.12
+
+
+
Generated using TypeDoc v0.25.12
+
+
+
Generated using TypeDoc v0.25.12
+
+
+
Variable lsTypesConst
An enum representing different file types.
+Generated using TypeDoc v0.25.12
+
+
+
This enumeration defines the different types of listings supported by +the ls function. It specifies which file system entries should be +included in the results.
+Since
0.1.0
+See
ls
+