@visulima/fs 4.0.3 → 4.0.5

package/dist/error/walk-error.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Error thrown in {@linkcode walk} or {@linkcode walkSync} during iteration.
+ * @example
+ * ```javascript
+ * import { WalkError } from "@visulima/fs/error";
+ * import { walk } from "@visulima/fs";
+ * import { join } from "node:path";
+ *
+ * const processDirectory = async () => {
+ *   const dirToWalk = join("/tmp", "non-existent-or-permission-denied-dir");
+ *   try {
+ *     // Forcing the scenario: walk might throw a WalkError if it encounters an issue
+ *     // like a directory it cannot read during the walk process.
+ *     const simulateWalkError = async (rootDir) => {
+ *       // Let's say readdir inside walk fails for a subdirectory.
+ *       const underlyingError = new Error("Permission denied reading subdirectory");
+ *       throw new WalkError(underlyingError, rootDir);
+ *     }
+ *     // This is conceptual. In a real scenario, 'walk' itself would throw.
+ *     // for await (const entry of walk(dirToWalk)) {
+ *     //   console.log(entry.path);
+ *     // }
+ *     await simulateWalkError(dirToWalk);
+ *   } catch (error) {
+ *     if (error instanceof WalkError) {
+ *       console.error(`Error during directory walk of "${error.root}": ${error.message}`);
+ *       if (error.cause) {
+ *         console.error(`Underlying cause: ${error.cause}`);
+ *       }
+ *     } else {
+ *       console.error("An unexpected error occurred:", error);
+ *     }
+ *   }
+ * };
+ *
+ * processDirectory();
+ * ```
+ */
+declare class WalkError extends Error {
+    /** File path of the root that's being walked. */
+    root: string;
+    /**
+     * Constructs a new instance.
+     * @param cause The underlying error or reason for the walk failure.
+     * @param root The root directory path where the walk operation started or encountered the error.
+     */
+    constructor(cause: unknown, root: string);
+    get name(): string;
+    set name(_name: string);
+}
+export default WalkError;

package/dist/error.d.ts

@@ -1,50 +1,7 @@
-export { J as JSONError } from './packem_shared/json-error-ZPgZIXcg.js';
-
-declare class AlreadyExistsError extends Error {
-    constructor(message: string);
-    get code(): string;
-    set code(_name: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-declare class DirectoryError extends Error {
-    constructor(message: string);
-    get code(): string;
-    set code(_name: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-declare class NotEmptyError extends Error {
-    constructor(message: string);
-    get code(): string;
-    set code(_name: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-declare class NotFoundError extends Error {
-    constructor(message: string);
-    get code(): string;
-    set code(_name: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-declare class PermissionError extends Error {
-    constructor(message: string);
-    get code(): string;
-    set code(_name: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-declare class WalkError extends Error {
-    root: string;
-    constructor(cause: unknown, root: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-export { AlreadyExistsError, DirectoryError, NotEmptyError, NotFoundError, PermissionError, WalkError };
+export { default as AlreadyExistsError } from "./error/already-exists-error.d.ts";
+export { default as DirectoryError } from "./error/directory-error.d.ts";
+export { default as JSONError } from "./error/json-error.d.ts";
+export { default as NotEmptyError } from "./error/not-empty-error.d.ts";
+export { default as NotFoundError } from "./error/not-found-error.d.ts";
+export { default as PermissionError } from "./error/permission-error.d.ts";
+export { default as WalkError } from "./error/walk-error.d.ts";

package/dist/error.js

@@ -1 +1,7 @@
-import{default as t}from"./packem_shared/AlreadyExistsError-CEu6_Tjb.js";import{default as a}from"./packem_shared/DirectoryError-ddlbUV8C.js";import{default as s}from"./packem_shared/JSONError-D7h6PNWc.js";import{default as l}from"./packem_shared/NotEmptyError-DMh1o7UL.js";import{default as E}from"./packem_shared/NotFoundError-BPiW0icm.js";import{default as u}from"./packem_shared/PermissionError-B1Emi5a9.js";import{default as i}from"./packem_shared/WalkError-BsngoIKJ.js";export{t as AlreadyExistsError,a as DirectoryError,s as JSONError,l as NotEmptyError,E as NotFoundError,u as PermissionError,i as WalkError};
+export { default as AlreadyExistsError } from './packem_shared/AlreadyExistsError-D5BGeeNR.js';
+export { default as DirectoryError } from './packem_shared/DirectoryError-CaUV2Pbk.js';
+export { default as JSONError } from './packem_shared/JSONError-BkHRnInH.js';
+export { default as NotEmptyError } from './packem_shared/NotEmptyError-mOHWXE0m.js';
+export { default as NotFoundError } from './packem_shared/NotFoundError-D4llRgRs.js';
+export { default as PermissionError } from './packem_shared/PermissionError-1qs0skfo.js';
+export { default as WalkError } from './packem_shared/WalkError-DUdQd6FT.js';

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,46 @@
+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-regex.d.ts

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

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

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

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

@@ -0,0 +1,26 @@
+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 {@link walk} function.
+ * @param directory The root directory to start walking from.
+ * @param options Optional configuration to control the walking process. See {@link WalkOptions}.
+ * @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

@@ -0,0 +1,29 @@
+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}.
+ * @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/index.d.ts

@@ -1,136 +1,34 @@
-import { W as WalkOptions, F as FindUpName, a as FindUpOptions, b as FindUpNameSync, c as WalkEntry, R as ReadFileOptions, C as ContentType, d as ReadJsonOptions, J as JsonReviver, e as RetryOptions, f as WriteFileOptions, g as WriteJsonOptions } from './packem_shared/types-T308NKwz.js';
-export { l as CodeFrameLocation, m as CodeFrameOptions, i as FIND_UP_STOP, h as F_OK, n as FindUpNameFnResult, o as FindUpNameSyncFnResult, p as JsonReplacer, j as R_OK, q as ReadFileEncoding, k as W_OK, X as X_OK } from './packem_shared/types-T308NKwz.js';
-import { symlink } from 'node:fs';
-export { CRLF, EOL, LF, detect, format } from './eol.js';
-import { brotliDecompress, unzip, brotliDecompressSync, unzipSync } from 'node:zlib';
-import { JsonValue } from 'type-fest';
-import fs from 'fs';
-import 'yaml';
-
-declare const ensureDir: (directory: URL | string) => Promise<void>;
-
-declare const ensureDirSync: (directory: URL | string) => void;
-
-declare const ensureFile: (filePath: URL | string) => Promise<void>;
-
-declare const ensureFileSync: (filePath: URL | string) => void;
-
-declare const ensureLink: (source: URL | string, destination: URL | string) => Promise<void>;
-
-declare const ensureLinkSync: (source: URL | string, destination: URL | string) => void;
-
-declare const ensureSymlink: (target: URL | string, linkName: URL | string, type?: symlink.Type) => Promise<void>;
-
-declare const ensureSymlinkSync: (target: URL | string, linkName: URL | string, type?: symlink.Type) => void;
-
-declare const collect: (directory: string, options?: WalkOptions) => Promise<string[]>;
-
-declare const collectSync: (directory: string, options?: WalkOptions) => string[];
-
-declare const findUp: (name: FindUpName, options?: FindUpOptions) => Promise<string | undefined>;
-
-declare const findUpSync: (name: FindUpNameSync, options?: FindUpOptions) => string | undefined;
-
-declare function walk(directory: URL | string, { extensions, followSymlinks, includeDirs: includeDirectories, includeFiles, includeSymlinks, match, maxDepth, skip, }?: WalkOptions): AsyncIterableIterator<WalkEntry>;
-
-declare function walkSync(directory: URL | string, { extensions, followSymlinks, includeDirs: includeDirectories, includeFiles, includeSymlinks, match, maxDepth, skip, }?: WalkOptions): IterableIterator<WalkEntry>;
-
-declare function isAccessible(path: URL | string, mode?: number): Promise<boolean>;
-
-declare function isAccessibleSync(path: URL | string, mode?: number): boolean;
-
-type FilePermissions = number;
-type Options = {
-    cwd?: URL | string;
-    readonly directoryMode?: FilePermissions;
-    readonly overwrite?: boolean;
-};
-
-declare const move: (sourcePath: string, destinationPath: string, options?: Options) => Promise<void>;
-declare const moveSync: (sourcePath: string, destinationPath: string, options?: Options) => void;
-declare const rename: (source: string, destination: string, options?: Options) => Promise<void>;
-declare const renameSync: (source: string, destination: string, options?: Options) => void;
-
-declare const decompressionMethods$1: {
-    readonly brotli: typeof brotliDecompress;
-    readonly gzip: typeof unzip;
-    readonly none: (buffer: Buffer, callback: (error: Error | null, result: Buffer) => void) => void;
-};
-declare const readFile: <O extends ReadFileOptions<keyof typeof decompressionMethods$1> | undefined = undefined>(path: URL | string, options?: O) => Promise<ContentType<O>>;
-
-declare const decompressionMethods: {
-    readonly brotli: typeof brotliDecompressSync;
-    readonly gzip: typeof unzipSync;
-    readonly none: (buffer: Buffer) => Buffer<ArrayBufferLike>;
-};
-declare const readFileSync: <O extends ReadFileOptions<keyof typeof decompressionMethods> | undefined = undefined>(path: URL | string, options?: O) => ContentType<O>;
-
-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>;
-
-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;
-
-declare const emptyDir: (dir: URL | string, options?: RetryOptions) => Promise<void>;
-
-declare const emptyDirSync: (dir: URL | string, options?: RetryOptions) => void;
-
-declare const remove: (path: URL | string, options?: RetryOptions) => Promise<void>;
-
-declare const removeSync: (path: URL | string, options?: RetryOptions) => void;
-
-declare const writeFile: (path: URL | string, content: ArrayBuffer | ArrayBufferView | string, options?: WriteFileOptions) => Promise<void>;
-
-declare const writeFileSync: (path: URL | string, content: ArrayBuffer | ArrayBufferView | string, options?: WriteFileOptions) => void;
-
-declare const writeJson: (path: URL | string, data: unknown, options?: WriteJsonOptions) => Promise<void>;
-
-declare const writeJsonSync: (path: URL | string, data: unknown, options?: WriteJsonOptions) => void;
-
-/**
- * Subset of Node.js fs module methods required for case-sensitivity detection.
- * This allows custom fs implementations to be passed for testing purposes.
- */
-type FsSubset = {
-    existsSync: typeof fs.existsSync;
-    writeFileSync: typeof fs.writeFileSync;
-    unlinkSync: typeof fs.unlinkSync;
-};
-/**
- * Detects whether the filesystem is case-sensitive.
- *
- * Uses a fast, I/O-free primary method that checks if the specified directory
- * path can be accessed with inverted case. Falls back to writing a temporary
- * file if the primary method is inconclusive.
- *
- * Different mount points can have different case-sensitivity settings, so this
- * function checks the filesystem where the specified directory resides.
- *
- * @param directoryPath - The directory path to check. Defaults to
- * `process.cwd()`. Different mount points can have different case-sensitivity.
- * @param fsInstance - Custom filesystem implementation (primarily for
- * testing). Defaults to Node.js `fs` module.
- * @param useCache - Whether to cache the result per directory. Defaults to
- * `true`. When enabled, subsequent calls for the same directory return
- * instantly without re-checking.
- * @returns `true` if the filesystem is case-sensitive, `false` otherwise
- *
- * @example
- * ```ts
- * import { isFsCaseSensitive } from 'is-fs-case-sensitive'
- *
- * // Check current working directory's filesystem
- * if (isFsCaseSensitive()) {
- *   console.log('Case-sensitive filesystem (likely Linux)')
- * } else {
- *   console.log('Case-insensitive filesystem (likely macOS/Windows)')
- * }
- *
- * // Check specific directory
- * const isHomeCaseSensitive = isFsCaseSensitive('/home/user')
- * ```
- */
-declare const isFsCaseSensitive: (directoryPath?: string, fsInstance?: FsSubset, useCache?: boolean) => boolean;
-
-export { ContentType, FindUpName, FindUpNameSync, FindUpOptions, JsonReviver, ReadFileOptions, ReadJsonOptions, WalkEntry, WalkOptions, WriteFileOptions, WriteJsonOptions, collect, collectSync, emptyDir, emptyDirSync, ensureDir, ensureDirSync, ensureFile, ensureFileSync, ensureLink, ensureLinkSync, ensureSymlink, ensureSymlinkSync, findUp, findUpSync, isAccessible, isAccessibleSync, isFsCaseSensitive, move, moveSync, readFile, readFileSync, readJson, readJsonSync, remove, removeSync, rename, renameSync, walk, walkSync, writeFile, writeFileSync, writeJson, writeJsonSync };
-export type { Options as MoveOptions };
+export { F_OK, FIND_UP_STOP, R_OK, W_OK, X_OK } from "./constants.d.ts";
+export { default as ensureDir } from "./ensure/ensure-dir.d.ts";
+export { default as ensureDirSync } from "./ensure/ensure-dir-sync.d.ts";
+export { default as ensureFile } from "./ensure/ensure-file.d.ts";
+export { default as ensureFileSync } from "./ensure/ensure-file-sync.d.ts";
+export { default as ensureLink } from "./ensure/ensure-link.d.ts";
+export { default as ensureLinkSync } from "./ensure/ensure-link-sync.d.ts";
+export { default as ensureSymlink } from "./ensure/ensure-symlink.d.ts";
+export { default as ensureSymlinkSync } from "./ensure/ensure-symlink-sync.d.ts";
+export { CRLF, detect, EOL, format, LF } from "./eol.d.ts";
+export { default as collect } from "./find/collect.d.ts";
+export { default as collectSync } from "./find/collect-sync.d.ts";
+export { default as findUp } from "./find/find-up.d.ts";
+export { default as findUpSync } from "./find/find-up-sync.d.ts";
+export { default as walk } from "./find/walk.d.ts";
+export { default as walkSync } from "./find/walk-sync.d.ts";
+export { default as isAccessible } from "./is-accessible.d.ts";
+export { default as isAccessibleSync } from "./is-accessible-sync.d.ts";
+export { move, moveSync, rename, renameSync } from "./move/index.d.ts";
+export type { Options as MoveOptions } from "./move/types.d.ts";
+export { default as readFile } from "./read/read-file.d.ts";
+export { default as readFileSync } from "./read/read-file-sync.d.ts";
+export { default as readJson } from "./read/read-json.d.ts";
+export { default as readJsonSync } from "./read/read-json-sync.d.ts";
+export { default as emptyDir } from "./remove/empty-dir.d.ts";
+export { default as emptyDirSync } from "./remove/empty-dir-sync.d.ts";
+export { default as remove } from "./remove/remove.d.ts";
+export { default as removeSync } from "./remove/remove-sync.d.ts";
+export type { CodeFrameLocation, CodeFrameOptions, ContentType, FindUpName, FindUpNameFnResult, FindUpNameSync, FindUpNameSyncFnResult, FindUpOptions, JsonReplacer, JsonReviver, ReadFileEncoding, ReadFileOptions, ReadJsonOptions, WalkEntry, WalkOptions, WriteFileOptions, WriteJsonOptions, } from "./types.d.ts";
+export { default as writeFile } from "./write/write-file.d.ts";
+export { default as writeFileSync } from "./write/write-file-sync.d.ts";
+export { default as writeJson } from "./write/write-json.d.ts";
+export { default as writeJsonSync } from "./write/write-json-sync.d.ts";
+export { isFsCaseSensitive } from "is-fs-case-sensitive";

package/dist/index.js

@@ -1 +1,32 @@
-import{FIND_UP_STOP as o,F_OK as t,R_OK as a,W_OK as f,X_OK as s}from"./packem_shared/F_OK-CAwY1qU7.js";import{default as m}from"./packem_shared/ensureDir-CwcwvbZ0.js";import{default as p}from"./packem_shared/ensureDirSync-DsFhH5oQ.js";import{default as d}from"./packem_shared/ensureFile-DwcEQVDX.js";import{default as i}from"./packem_shared/ensureFileSync-KnrH51Ox.js";import{default as y}from"./packem_shared/ensureLink-5rjQGEBb.js";import{default as F}from"./packem_shared/ensureLinkSync-CYXpscf2.js";import{default as w}from"./packem_shared/ensureSymlink-GATTbE5c.js";import{default as _}from"./packem_shared/ensureSymlinkSync-CvXgTFrl.js";import{CRLF as D,EOL as L,LF as J,detect as K,format as U}from"./eol.js";import{default as A}from"./packem_shared/collect-DO31RsLs.js";import{default as P}from"./packem_shared/collectSync-Cy7ULmjZ.js";import{default as E}from"./packem_shared/findUp-Di7Az07S.js";import{default as N}from"./packem_shared/findUpSync-iV97v14Q.js";import{default as W}from"./packem_shared/walk-ZrZngpc4.js";import{default as g}from"./packem_shared/walkSync-BQa4NKSG.js";import{default as j}from"./packem_shared/isAccessible-CDFxsAAo.js";import{default as z}from"./packem_shared/isAccessibleSync-5nzZWgin.js";import{move as G,moveSync as H,rename as M,renameSync as Q}from"./packem_shared/move-Bz4gSIjp.js";import{default as Y}from"./packem_shared/readFile-CbxFM_zp.js";import{default as $}from"./packem_shared/readFileSync-B9iv2Sb8.js";import{default as re}from"./packem_shared/readJson-BgC3msx-.js";import{default as te}from"./packem_shared/readJsonSync-DHO1vjAG.js";import{default as fe}from"./packem_shared/emptyDir-zBLHyPsJ.js";import{default as le}from"./packem_shared/emptyDirSync-DZ8nTo6g.js";import{default as ne}from"./packem_shared/remove-BUqZUj1W.js";import{default as ue}from"./packem_shared/removeSync-BbT4vmDi.js";import{default as xe}from"./packem_shared/writeFile-D5OYEMHu.js";import{default as ce}from"./packem_shared/writeFileSync-CO4ySqUn.js";import{default as Se}from"./packem_shared/writeJson-DfmgiY_s.js";import{default as ke}from"./packem_shared/writeJsonSync-Ck1pmmj_.js";import{isFsCaseSensitive as Oe}from"./packem_shared/isFsCaseSensitive-Drl8fHLV.js";export{D as CRLF,L as EOL,o as FIND_UP_STOP,t as F_OK,J as LF,a as R_OK,f as W_OK,s as X_OK,A as collect,P as collectSync,K as detect,fe as emptyDir,le as emptyDirSync,m as ensureDir,p as ensureDirSync,d as ensureFile,i as ensureFileSync,y as ensureLink,F as ensureLinkSync,w as ensureSymlink,_ as ensureSymlinkSync,E as findUp,N as findUpSync,U as format,j as isAccessible,z as isAccessibleSync,Oe as isFsCaseSensitive,G as move,H as moveSync,Y as readFile,$ as readFileSync,re as readJson,te as readJsonSync,ne as remove,ue as removeSync,M as rename,Q as renameSync,W as walk,g as walkSync,xe as writeFile,ce as writeFileSync,Se as writeJson,ke as writeJsonSync};
+export { FIND_UP_STOP, F_OK, R_OK, W_OK, X_OK } from './packem_shared/F_OK-BalxCn9n.js';
+export { default as ensureDir } from './packem_shared/ensureDir-C_kuQ5Ik.js';
+export { default as ensureDirSync } from './packem_shared/ensureDirSync-CI5g-uBI.js';
+export { default as ensureFile } from './packem_shared/ensureFile-BUtXGlGT.js';
+export { default as ensureFileSync } from './packem_shared/ensureFileSync-C8hASR-1.js';
+export { default as ensureLink } from './packem_shared/ensureLink-BPnAG5-P.js';
+export { default as ensureLinkSync } from './packem_shared/ensureLinkSync-B-Z7X0ub.js';
+export { default as ensureSymlink } from './packem_shared/ensureSymlink-BGz6W-Wa.js';
+export { default as ensureSymlinkSync } from './packem_shared/ensureSymlinkSync-C5Gk8QYi.js';
+export { CRLF, EOL, LF, detect, format } from './eol.js';
+export { default as collect } from './packem_shared/collect-DcBwsYYd.js';
+export { default as collectSync } from './packem_shared/collectSync-Bkjf9Dbm.js';
+export { default as findUp } from './packem_shared/findUp-Lv9mZCIQ.js';
+export { default as findUpSync } from './packem_shared/findUpSync-BsK4Nrrq.js';
+export { default as walk } from './packem_shared/walk-BhTbpr3y.js';
+export { default as walkSync } from './packem_shared/walkSync-DDBq95s8.js';
+export { default as isAccessible } from './packem_shared/isAccessible-iOp0Bou6.js';
+export { default as isAccessibleSync } from './packem_shared/isAccessibleSync-38BmiIcx.js';
+export { move, moveSync, rename, renameSync } from './packem_shared/move-BD6JbYSu.js';
+export { default as readFile } from './packem_shared/readFile-XVOjAw8r.js';
+export { default as readFileSync } from './packem_shared/readFileSync-B9Zg5PSF.js';
+export { default as readJson } from './packem_shared/readJson-Dra2m6s-.js';
+export { default as readJsonSync } from './packem_shared/readJsonSync-B6Dl1I_6.js';
+export { default as emptyDir } from './packem_shared/emptyDir-CYB5Tict.js';
+export { default as emptyDirSync } from './packem_shared/emptyDirSync-BD8-1Ytl.js';
+export { default as remove } from './packem_shared/remove-_oDY3uKo.js';
+export { default as removeSync } from './packem_shared/removeSync-DETRj7Qn.js';
+export { default as writeFile } from './packem_shared/writeFile-NT1fLEEe.js';
+export { default as writeFileSync } from './packem_shared/writeFileSync-Bj5UDSf0.js';
+export { default as writeJson } from './packem_shared/writeJson-DQLdAi0d.js';
+export { default as writeJsonSync } from './packem_shared/writeJsonSync-DvTCjVUi.js';
+export { isFsCaseSensitive } from './packem_shared/isFsCaseSensitive-D-ayleCy.js';

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

@@ -0,0 +1,3 @@
+/** 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

@@ -0,0 +1,29 @@
+/**
+ * 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;