@visulima/fs 4.0.4 → 4.0.5

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/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,4 +1,4 @@
-export { FIND_UP_STOP, F_OK, R_OK, W_OK, X_OK } from './packem_shared/F_OK-MldBaGxb.js';
+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';
@@ -10,23 +10,23 @@ export { default as ensureSymlinkSync } from './packem_shared/ensureSymlinkSync-
 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-BSnyGqer.js';
-export { default as findUpSync } from './packem_shared/findUpSync-jRHbSCMV.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-DuVrTNFV.js';
-export { default as isAccessibleSync } from './packem_shared/isAccessibleSync-DI8mM0fA.js';
-export { move, moveSync, rename, renameSync } from './packem_shared/move-DbpW5_vA.js';
-export { default as readFile } from './packem_shared/readFile-iHOVXeH-.js';
-export { default as readFileSync } from './packem_shared/readFileSync-BkEj9BQY.js';
-export { default as readJson } from './packem_shared/readJson-pdfQBWDR.js';
-export { default as readJsonSync } from './packem_shared/readJsonSync-BZqGcA5d.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-DSHERs0Z.js';
-export { default as writeFileSync } from './packem_shared/writeFileSync-CJp1kXQR.js';
-export { default as writeJson } from './packem_shared/writeJson-C0OfLDbe.js';
-export { default as writeJsonSync } from './packem_shared/writeJsonSync-Cs21FE7v.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;

package/dist/move/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ * @returns Nothing is returned.
+ * @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.
+ * @returns A `Promise` that resolves when the file has been renamed.
+ * @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

@@ -0,0 +1,38 @@
+type FilePermissions = number;
+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?: FilePermissions;
+    /**
+     * 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;
+};
+export {};