@visulima/fs 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/find/collect-sync.d.ts

@@ -1,31 +0,0 @@
-import type { WalkOptions } from "../types.d.ts";
-/**
- * Synchronously collects all file paths within a directory that match the specified criteria.
- * By default, it searches for JavaScript and TypeScript file extensions.
- * @param directory The root directory to start collecting files from.
- * @param options Optional configuration to control the collection process. See {@link WalkOptions}.
- * @returns An array of absolute file paths.
- * @example
- * ```javascript
- * import { collectSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // Collect all .txt and .md files in /tmp/docs, up to 2 levels deep
- * const files = collectSync(join("/tmp", "docs"), {
- *   extensions: ["txt", "md"],
- *   maxDepth: 2,
- *   includeDirs: false, // Only collect files
- * });
- * console.log(files);
- * // Example output: ['/tmp/docs/file1.txt', '/tmp/docs/subdir/report.md']
- *
- * // Collect all .js files, excluding anything in node_modules
- * const jsFiles = collectSync(join("/tmp", "project"), {
- *   extensions: ["js"],
- *   skip: [/node_modules/],
- * });
- * console.log(jsFiles);
- * ```
- */
-declare const collectSync: (directory: string, options?: WalkOptions) => string[];
-export default collectSync;

package/dist/find/collect.d.ts

@@ -1,35 +0,0 @@
-import type { WalkOptions } from "../types.d.ts";
-/**
- * Asynchronously collects all file paths within a directory that match the specified criteria.
- * By default, it searches for JavaScript and TypeScript file extensions.
- * @param directory The root directory to start collecting files from.
- * @param options Optional configuration to control the collection process. See {@link WalkOptions}.
- * @returns A promise that resolves to an array of absolute file paths.
- * @example
- * ```javascript
- * import { collect } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * const collectFiles = async () => {
- *   // Collect all .txt and .md files in /tmp/docs, up to 2 levels deep
- *   const files = await collect(join("/tmp", "docs"), {
- *     extensions: ["txt", "md"],
- *     maxDepth: 2,
- *     includeDirs: false, // Only collect files
- *   });
- *   console.log(files);
- *   // Example output: ['/tmp/docs/file1.txt', '/tmp/docs/subdir/report.md']
- *
- *   // Collect all .js files, excluding anything in node_modules
- *   const jsFiles = await collect(join("/tmp", "project"), {
- *     extensions: ["js"],
- *     skip: [/node_modules/],
- *   });
- *   console.log(jsFiles);
- * };
- *
- * collectFiles();
- * ```
- */
-declare const collect: (directory: string, options?: WalkOptions) => Promise<string[]>;
-export default collect;

package/dist/find/find-up-sync.d.ts

@@ -1,42 +0,0 @@
-import type { FindUpNameSync, FindUpOptions } from "../types.d.ts";
-/**
- * Synchronously finds a file or directory by walking up parent directories.
- * @param name The name(s) of the file or directory to find. Can be a string, an array of strings, or a function that returns a name or `FIND_UP_STOP`.
- * @param options Optional configuration for the search. See {@link FindUpOptions}.
- * @returns The absolute path of the first found file/directory, or `undefined` if not found.
- * @example
- * ```javascript
- * import { findUpSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // Find the closest package.json, starting from /tmp/foo/bar/baz
- * const projectRoot = findUpSync("package.json", {
- *   cwd: join("/tmp", "foo", "bar", "baz"),
- *   type: "file",
- * });
- * console.log(projectRoot); // e.g., /tmp/foo/package.json or undefined
- *
- * // Find the closest .git directory or a README.md file
- * const gitDirOrReadme = findUpSync([".git", "README.md"], {
- *   cwd: join("/tmp", "foo", "bar"),
- * });
- * console.log(gitDirOrReadme);
- *
- * // Find using a custom function, stopping at /tmp
- * const customFound = findUpSync(
- *   (directory) => {
- *     if (directory === join("/tmp", "foo")) {
- *       return "found-it-here.txt"; // Pretend this file exists in /tmp/foo
- *     }
- *     return undefined;
- *   },
- *   {
- *     cwd: join("/tmp", "foo", "bar", "baz"),
- *     stopAt: join("/tmp"),
- *   }
- * );
- * console.log(customFound);
- * ```
- */
-declare const findUpSync: (name: FindUpNameSync, options?: FindUpOptions) => string | undefined;
-export default findUpSync;

package/dist/find/find-up.d.ts

@@ -1,46 +0,0 @@
-import type { FindUpName, FindUpOptions } from "../types.d.ts";
-/**
- * Asynchronously finds a file or directory by walking up parent directories.
- * @param name The name(s) of the file or directory to find. Can be a string, an array of strings, or a function that returns a name or `FIND_UP_STOP`.
- * @param options Optional configuration for the search. See {@link FindUpOptions}.
- * @returns A promise that resolves to the absolute path of the first found file/directory, or `undefined` if not found.
- * @example
- * ```javascript
- * import { findUp } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * const findProjectRoot = async () => {
- *   // Find the closest package.json, starting from /tmp/foo/bar/baz
- *   const projectRoot = await findUp("package.json", {
- *     cwd: join("/tmp", "foo", "bar", "baz"),
- *     type: "file",
- *   });
- *   console.log(projectRoot); // e.g., /tmp/foo/package.json or undefined
- *
- *   // Find the closest .git directory or a README.md file
- *   const gitDirOrReadme = await findUp([".git", "README.md"], {
- *     cwd: join("/tmp", "foo", "bar"),
- *   });
- *   console.log(gitDirOrReadme);
- *
- *   // Find using a custom function, stopping at /tmp
- *   const customFound = await findUp(
- *     (directory) => {
- *       if (directory === join("/tmp", "foo")) {
- *         return "found-it-here.txt"; // Pretend this file exists in /tmp/foo
- *       }
- *       return undefined;
- *     },
- *     {
- *       cwd: join("/tmp", "foo", "bar", "baz"),
- *       stopAt: join("/tmp"),
- *     }
- *   );
- *   console.log(customFound);
- * };
- *
- * findProjectRoot();
- * ```
- */
-declare const findUp: (name: FindUpName, options?: FindUpOptions) => Promise<string | undefined>;
-export default findUp;

package/dist/find/utils/glob-to-regexp.d.ts

@@ -1,2 +0,0 @@
-declare const globToRegExp: (glob: string) => RegExp;
-export default globToRegExp;

package/dist/find/utils/walk-include.d.ts

@@ -1,2 +0,0 @@
-declare const walkInclude: (path: string, extensions?: string[], match?: RegExp[], skip?: RegExp[]) => boolean;
-export default walkInclude;

package/dist/find/walk-sync.d.ts

@@ -1,34 +0,0 @@
-import type { WalkEntry, WalkOptions } from "../types.d.ts";
-/**
- * Synchronously walks the file tree rooted at `directory`, yielding each file or directory that matches the criteria specified in `options`.
- * This is the synchronous version of the {@linkcode walk} function.
- * @param directory The root directory to start walking from.
- * @param options Optional configuration to control the walking process. See {@link WalkOptions}.
- * @param options.extensions List of file extensions used to filter entries.
- * @param options.followSymlinks Indicates whether symlinks should be resolved or not.
- * @param options.includeDirs Indicates whether directory entries should be included or not.
- * @param options.includeFiles Indicates whether file entries should be included or not.
- * @param options.includeSymlinks Indicates whether symlink entries should be included or not.
- * @param options.match List of regular expression or glob patterns used to filter entries.
- * @param options.maxDepth Maximum depth to walk. Defaults to infinity.
- * @param options.skip List of regular expression or glob patterns used to skip entries.
- * @returns An iterable iterator yielding {@link WalkEntry} objects for each matching file or directory.
- * @example
- * ```javascript
- * import { walkSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // Walk through /tmp/my-project, looking for .ts files, max depth 2
- * for (const entry of walkSync(join("/tmp", "my-project"), { extensions: ["ts"], maxDepth: 2 })) {
- *   console.log(`Found: ${entry.path} (Type: ${entry.isFile() ? 'file' : 'directory'})`);
- * }
- *
- * // Walk, including only directories, and skip any node_modules folders
- * for (const entry of walkSync(join("/tmp", "another-project"), { includeFiles: false, skip: [/node_modules/] })) {
- *   if (entry.isDirectory()) {
- *      console.log(`Directory: ${entry.path}`);
- *   }
- * }
- * ```
- */
-export default function walkSync(directory: URL | string, { extensions, followSymlinks, includeDirs: includeDirectories, includeFiles, includeSymlinks, match, maxDepth, skip, }?: WalkOptions): IterableIterator<WalkEntry>;

package/dist/find/walk.d.ts

@@ -1,37 +0,0 @@
-import type { WalkEntry, WalkOptions } from "../types.d.ts";
-/**
- * Asynchronously walks the file tree rooted at `directory`, yielding each file or directory that matches the criteria specified in `options`.
- * @param directory The root directory to start walking from.
- * @param options Optional configuration to control the walking process. See {@link WalkOptions}.
- * @param options.extensions List of file extensions used to filter entries.
- * @param options.followSymlinks Indicates whether symlinks should be resolved or not.
- * @param options.includeDirs Indicates whether directory entries should be included or not.
- * @param options.includeFiles Indicates whether file entries should be included or not.
- * @param options.includeSymlinks Indicates whether symlink entries should be included or not.
- * @param options.match List of regular expression or glob patterns used to filter entries.
- * @param options.maxDepth Maximum depth to walk. Defaults to infinity.
- * @param options.skip List of regular expression or glob patterns used to skip entries.
- * @returns An async iterable iterator yielding {@link WalkEntry} objects for each matching file or directory.
- * @example
- * ```javascript
- * import { walk } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * const printEntries = async () => {
- *   // Walk through /tmp/my-project, looking for .ts files, max depth 2
- *   for await (const entry of walk(join("/tmp", "my-project"), { extensions: ["ts"], maxDepth: 2 })) {
- *     console.log(`Found: ${entry.path} (Type: ${entry.isFile() ? 'file' : 'directory'})`);
- *   }
- *
- *   // Walk, including only directories, and skip any node_modules folders
- *   for await (const entry of walk(join("/tmp", "another-project"), { includeFiles: false, skip: [/node_modules/] })) {
- *     if (entry.isDirectory()) {
- *        console.log(`Directory: ${entry.path}`);
- *     }
- *   }
- * };
- *
- * printEntries();
- * ```
- */
-export default function walk(directory: URL | string, { extensions, followSymlinks, includeDirs: includeDirectories, includeFiles, includeSymlinks, match, maxDepth, skip, }?: WalkOptions): AsyncIterableIterator<WalkEntry>;

package/dist/is-accessible-sync.d.ts

@@ -1,3 +0,0 @@
-/** Returns a boolean indicating if the path is accessible or not. */
-declare function isAccessibleSync(path: URL | string, mode?: number): boolean;
-export default isAccessibleSync;

package/dist/is-accessible.d.ts

@@ -1,29 +0,0 @@
-/**
- * Asynchronously tests a user's permissions for the file or directory specified by path.
- * Returns a Promise that resolves to `true` if the accessibility check is successful, `false` otherwise.
- * @param path The path to the file or directory. Can be a string or a URL object.
- * @param mode The accessibility checks to perform. Defaults to `F_OK` (check for existence).
- * Other possible values include `R_OK` (check for read access), `W_OK` (check for write access),
- * and `X_OK` (check for execute/search access). Multiple modes can be combined using bitwise OR.
- * @returns A Promise that resolves to a boolean indicating if the path is accessible with the specified mode.
- * @example
- * ```typescript
- * import { isAccessible, F_OK, R_OK } from "@visulima/fs";
- *
- * (async () => {
- *   if (await isAccessible("myFile.txt")) {
- *     console.log("myFile.txt exists");
- *   }
- *
- *   if (await isAccessible("myFile.txt", R_OK)) {
- *     console.log("myFile.txt is readable");
- *   }
- *
- *   if (await isAccessible("myDirectory", F_OK | R_OK | W_OK)) {
- *     console.log("myDirectory exists, is readable and writable");
- *   }
- * })();
- * ```
- */
-declare function isAccessible(path: URL | string, mode?: number): Promise<boolean>;
-export default isAccessible;

package/dist/move/index.d.ts

@@ -1,68 +0,0 @@
-/**
- * Modified functions from https://github.com/sindresorhus/move-file
- *
- * The original functions are licensed under the MIT License:
- *
- * MIT License
- *
- * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
- */
-import type { Options } from './types.d.ts';
-/**
- * Move a file asynchronously.
- * @param sourcePath The file you want to move.
- * @param destinationPath Where you want the file moved.
- * @param options Configuration options.
- * @returns A `Promise` that resolves when the file has been moved.
- * @example
- * ```
- * import { move } from '@visulima/fs';
- *
- * await move('source/test.png', 'destination/test.png');
- * console.log('The file has been moved');
- * ```
- */
-export declare const move: (sourcePath: string, destinationPath: string, options?: Options) => Promise<void>;
-/**
- * Move a file synchronously.
- * @param sourcePath The file you want to move.
- * @param destinationPath Where you want the file moved.
- * @param options Configuration options.
- * @example
- * ```
- * import { moveSync } from '@visulima/fs';
- *
- * moveSync('source/test.png', 'destination/test.png');
- * console.log('The file has been moved');
- * ```
- */
-export declare const moveSync: (sourcePath: string, destinationPath: string, options?: Options) => void;
-/**
- * Rename a file asynchronously.
- * @param source The file you want to rename.
- * @param destination The name of the renamed file.
- * @param options Configuration options.
- * @returns A `Promise` that resolves when the file has been renamed.
- * @example
- * ```
- * import { rename } from '@visulima/fs';
- *
- * await rename('test.png', 'tests.png', {cwd: 'source'});
- * console.log('The file has been renamed');
- * ```
- */
-export declare const rename: (source: string, destination: string, options?: Options) => Promise<void>;
-/**
- * Rename a file synchronously.
- * @param source The file you want to rename.
- * @param destination The name of the renamed file.
- * @param options Configuration options.
- * @example
- * ```
- * import { renameSync } from '@visulima/fs';
- *
- * renameSync('test.png', 'tests.png', {cwd: 'source'});
- * console.log('The file has been renamed');
- * ```
- */
-export declare const renameSync: (source: string, destination: string, options?: Options) => void;

package/dist/move/types.d.ts

@@ -1,36 +0,0 @@
-export type Options = {
-    /**
-     * The working directory to find source files.
-     * The source and destination path are relative to this.
-     * @default process.cwd()
-     */
-    cwd?: URL | string;
-    /**
-     * [Permissions](https://en.wikipedia.org/wiki/File-system_permissions#Numeric_notation) for created directories.
-     *
-     * It has no effect on Windows.
-     * @default 0o777
-     */
-    readonly directoryMode?: number;
-    /**
-     * Overwrite existing destination file.
-     * @default true
-     */
-    readonly overwrite?: boolean;
-};
-/**
- * Internal options used by the move/rename implementation.
- * Extends the public Options type with additional internal properties.
- */
-export type InternalOptions = Options & {
-    /**
-     * Resolved working directory path.
-     * URLs from the Options type are converted to string paths.
-     */
-    cwd: string;
-    /**
-     * Whether to validate the directory structure before operation.
-     * @internal
-     */
-    validateDirectory?: boolean;
-};

package/dist/move/utils/internal-move-file-sync.d.ts

@@ -1,3 +0,0 @@
-import type { InternalOptions } from "../types.d.ts";
-declare const internalMoveFileSync: (sourcePath: string, destinationPath: string, { cwd, directoryMode, overwrite, validateDirectory }: InternalOptions) => void;
-export default internalMoveFileSync;

package/dist/move/utils/internal-move-file.d.ts

@@ -1,3 +0,0 @@
-import type { InternalOptions } from "../types.d.ts";
-declare const internalMoveFile: (sourcePath: string, destinationPath: string, { cwd, directoryMode, overwrite, validateDirectory }: InternalOptions) => Promise<void>;
-export default internalMoveFile;

package/dist/move/utils/validate-same-directory.d.ts

@@ -1,2 +0,0 @@
-declare const validateSameDirectory: (source: string, destination: string) => void;
-export default validateSameDirectory;

package/dist/read/read-file-sync.d.ts

@@ -1,37 +0,0 @@
-import type { ContentType, ReadFileOptions } from "../types.d.ts";
-type DecompressionMethod = (buffer: Buffer, callback: (error: Error | null, result: Buffer) => void) => void;
-declare const decompressionMethods: Record<string, DecompressionMethod>;
-/**
- * Synchronously reads the entire contents of a file.
- * It can also decompress the file content if a `compression` option is provided.
- * @template O - The type of the options object, extending {@link ReadFileOptions}.
- * @param path The path to the file to read. Can be a file URL or a string path.
- * @param options Optional configuration for reading the file. See {@link ReadFileOptions}.
- * Available `compression` methods: "brotli", "gzip", "none" (default).
- * @returns The file content. The type of the content (string or Buffer)
- * depends on the `buffer` option (defaults to string if `buffer` is false or not set).
- * @example
- * ```javascript
- * import { readFileSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * try {
- *   // Read a regular text file
- *   const content = readFileSync(join("path", "to", "my-file.txt"));
- *   console.log("File content:", content);
- *
- *   // Read a file as a Buffer
- *   const bufferContent = readFileSync(join("path", "to", "another-file.bin"), { buffer: true });
- *   console.log("Buffer length:", bufferContent.length);
- *
- *   // Read and decompress a gzipped file
- *   // Assume my-archive.txt.gz exists
- *   // const decompressedContent = readFileSync(join("path", "to", "my-archive.txt.gz"), { compression: "gzip", encoding: "utf8" });
- *   // console.log("Decompressed content:", decompressedContent);
- * } catch (error) {
- *   console.error("Failed to read file:", error);
- * }
- * ```
- */
-declare const readFileSync: <O extends ReadFileOptions<keyof typeof decompressionMethods> | undefined = undefined>(path: URL | string, options?: O) => ContentType<O>;
-export default readFileSync;

package/dist/read/read-file.d.ts

@@ -1,41 +0,0 @@
-import type { ContentType, ReadFileOptions } from "../types.d.ts";
-type DecompressionMethod = (buffer: Buffer, callback: (error: Error | null, result: Buffer) => void) => void;
-declare const decompressionMethods: Record<string, DecompressionMethod>;
-/**
- * Asynchronously reads the entire contents of a file.
- * It can also decompress the file content if a `compression` option is provided.
- * @template O - The type of the options object, extending {@link ReadFileOptions}.
- * @param path The path to the file to read. Can be a file URL or a string path.
- * @param options Optional configuration for reading the file. See {@link ReadFileOptions}.
- * Available `compression` methods: "brotli", "gzip", "none" (default).
- * @returns A promise that resolves with the file content. The type of the content (string or Buffer)
- * depends on the `buffer` option (defaults to string if `buffer` is false or not set).
- * @example
- * ```javascript
- * import { readFile } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * const readMyFile = async () => {
- *   try {
- *     // Read a regular text file
- *     const content = await readFile(join("path", "to", "my-file.txt"));
- *     console.log("File content:", content);
- *
- *     // Read a file as a Buffer
- *     const bufferContent = await readFile(join("path", "to", "another-file.bin"), { buffer: true });
- *     console.log("Buffer length:", bufferContent.length);
- *
- *     // Read and decompress a gzipped file
- *     // Assume my-archive.txt.gz exists
- *     // const decompressedContent = await readFile(join("path", "to", "my-archive.txt.gz"), { compression: "gzip", encoding: "utf8" });
- *     // console.log("Decompressed content:", decompressedContent);
- *   } catch (error) {
- *     console.error("Failed to read file:", error);
- *   }
- * };
- *
- * readMyFile();
- * ```
- */
-declare const readFile: <O extends ReadFileOptions<keyof typeof decompressionMethods> | undefined = undefined>(path: URL | string, options?: O) => Promise<ContentType<O>>;
-export default readFile;

package/dist/read/read-json-sync.d.ts

@@ -1,5 +0,0 @@
-import type { JsonValue } from "type-fest";
-import type { JsonReviver, ReadJsonOptions } from "../types.d.ts";
-declare function readJsonSync<T extends JsonValue>(path: URL | string, options?: ReadJsonOptions): T;
-declare function readJsonSync<T extends JsonValue>(path: URL | string, reviver: JsonReviver, options?: ReadJsonOptions): T;
-export default readJsonSync;

package/dist/read/read-json.d.ts

@@ -1,5 +0,0 @@
-import type { JsonValue } from "type-fest";
-import type { JsonReviver, ReadJsonOptions } from "../types.d.ts";
-declare function readJson<T extends JsonValue>(path: URL | string, options?: ReadJsonOptions): Promise<T>;
-declare function readJson<T extends JsonValue>(path: URL | string, reviver: JsonReviver, options?: ReadJsonOptions): Promise<T>;
-export default readJson;

package/dist/read/read-yaml-sync.d.ts

@@ -1,4 +0,0 @@
-import type { CompressionType, ReadYamlOptions, YamlReviver } from "../types.d.ts";
-declare function readYamlSync<R = Record<string, unknown>>(path: URL | string, options?: ReadYamlOptions<CompressionType>): R;
-declare function readYamlSync<R = Record<string, unknown>>(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<CompressionType>): R;
-export default readYamlSync;

package/dist/read/read-yaml.d.ts

@@ -1,4 +0,0 @@
-import type { CompressionType, ReadYamlOptions, YamlReviver } from "../types.d.ts";
-declare function readYaml<R = Record<string, unknown>>(path: URL | string, options?: ReadYamlOptions<CompressionType>): Promise<R>;
-declare function readYaml<R = Record<string, unknown>>(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<CompressionType>): Promise<R>;
-export default readYaml;

package/dist/remove/empty-dir-sync.d.ts

@@ -1,23 +0,0 @@
-import type { RetryOptions } from "../types.d.ts";
-/**
- * Ensures that a directory is empty.
- * Deletes directory contents if the directory is not empty.
- * If the directory does not exist, it is created.
- * The directory itself is not deleted.
- * @param dir The path to the directory to empty.
- * @param options Optional configuration for the operation. See {@link RetryOptions}.
- * @example
- * ```javascript
- * import { emptyDirSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * try {
- *   emptyDirSync(join("/tmp", "my-app-temp"));
- *   console.log("Temporary directory emptied or created.");
- * } catch (error) {
- *   console.error("Failed to empty directory:", error);
- * }
- * ```
- */
-declare const emptyDirSync: (dir: URL | string, options?: RetryOptions) => void;
-export default emptyDirSync;

package/dist/remove/empty-dir.d.ts

@@ -1,28 +0,0 @@
-import type { RetryOptions } from "../types.d.ts";
-/**
- * Ensures that a directory is empty.
- * Deletes directory contents if the directory is not empty.
- * If the directory does not exist, it is created.
- * The directory itself is not deleted.
- * @param dir The path to the directory to empty.
- * @param options Optional configuration for the operation. See {@link RetryOptions}.
- * @returns A promise that resolves when the directory is empty.
- * @example
- * ```javascript
- * import { emptyDir } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * const clearTempDir = async () => {
- *   try {
- *     await emptyDir(join("/tmp", "my-app-temp"));
- *     console.log("Temporary directory emptied or created.");
- *   } catch (error) {
- *     console.error("Failed to empty directory:", error);
- *   }
- * };
- *
- * clearTempDir();
- * ```
- */
-declare const emptyDir: (dir: URL | string, options?: RetryOptions) => Promise<void>;
-export default emptyDir;

package/dist/remove/remove-sync.d.ts

@@ -1,27 +0,0 @@
-import type { RetryOptions } from "../types.d.ts";
-/**
- * Synchronously removes a file or directory (recursively).
- * If the path does not exist, it does nothing.
- * @param path The path to the file or directory to remove.
- * @param options Optional configuration for the operation. See {@link RetryOptions}.
- * @example
- * ```javascript
- * import { removeSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * try {
- *   removeSync(join("/tmp", "my-file.txt"));
- *   console.log("File /tmp/my-file.txt removed.");
- *
- *   removeSync(join("/tmp", "my-empty-dir"));
- *   console.log("Directory /tmp/my-empty-dir removed.");
- *
- *   removeSync(join("/tmp", "my-dir-with-contents"));
- *   console.log("Directory /tmp/my-dir-with-contents and its contents removed.");
- * } catch (error) {
- *   console.error("Failed to remove path:", error);
- * }
- * ```
- */
-declare const removeSync: (path: URL | string, options?: RetryOptions) => void;
-export default removeSync;

package/dist/remove/remove.d.ts

@@ -1,32 +0,0 @@
-import type { RetryOptions } from "../types.d.ts";
-/**
- * Asynchronously removes a file or directory (recursively).
- * If the path does not exist, it does nothing.
- * @param path The path to the file or directory to remove.
- * @param options Optional configuration for the operation. See {@link RetryOptions}.
- * @returns A promise that resolves when the path has been removed.
- * @example
- * ```javascript
- * import { remove } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * const deleteFileOrDir = async () => {
- *   try {
- *     await remove(join("/tmp", "my-file.txt"));
- *     console.log("File /tmp/my-file.txt removed.");
- *
- *     await remove(join("/tmp", "my-empty-dir"));
- *     console.log("Directory /tmp/my-empty-dir removed.");
- *
- *     await remove(join("/tmp", "my-dir-with-contents"));
- *     console.log("Directory /tmp/my-dir-with-contents and its contents removed.");
- *   } catch (error) {
- *     console.error("Failed to remove path:", error);
- *   }
- * };
- *
- * deleteFileOrDir();
- * ```
- */
-declare const remove: (path: URL | string, options?: RetryOptions) => Promise<void>;
-export default remove;

package/dist/sanitize.d.ts

@@ -1,31 +0,0 @@
-/**
- * Supported filesystem types
- */
-export type FileSystemType = "win32" | "unix" | "darwin" | "fat32" | "auto";
-/**
- * Options for the sanitize function
- */
-export interface SanitizeOptions {
-    /**
-     * Target filesystem type for sanitization rules
-     * - "win32": Windows filesystem rules (reserved names, Windows forbidden chars, no trailing periods/spaces)
-     * - "unix": Unix/Linux filesystem rules (only / and null forbidden)
-     * - "darwin": macOS filesystem rules (same as unix)
-     * - "fat32": FAT32 filesystem rules (Windows rules + no leading/trailing spaces/periods in name part)
-     * - "auto": Automatically detect from process.platform
-     * @default "auto"
-     */
-    filesystem?: FileSystemType;
-    /**
-     * Maximum length of the sanitized name
-     * @default 128
-     */
-    maxLength?: number;
-}
-/**
- * Sanitizes a filename by removing or replacing forbidden characters.
- * @param name The filename to sanitize.
- * @param options Optional configuration.
- * @returns The sanitized filename, or "unnamed" if the result would be empty.
- */
-export declare const sanitize: (name: string, options?: Partial<SanitizeOptions>) => string;