@visulima/fs 4.0.3 → 4.0.5

package/dist/types.d.ts

@@ -0,0 +1,299 @@
+import type { Dirent, PathLike } from "node:fs";
+import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from "yaml";
+import type { FIND_UP_STOP } from "./constants.d.ts";
+type ColorizeMethod = (value: string) => string;
+/**
+ * Options for the `walk` and `walkSync` functions.
+ */
+export interface WalkOptions {
+    /**
+     * List of file extensions used to filter entries.
+     * If specified, entries without the file extension specified by this option are excluded.
+     * @default {undefined}
+     */
+    extensions?: string[];
+    /**
+     * Indicates whether symlinks should be resolved or not.
+     * @default {false}
+     */
+    followSymlinks?: boolean;
+    /**
+     * Indicates whether directory entries should be included or not.
+     * @default {true}
+     */
+    includeDirs?: boolean;
+    /**
+     * Indicates whether file entries should be included or not.
+     * @default {true}
+     */
+    includeFiles?: boolean;
+    /**
+     * Indicates whether symlink entries should be included or not.
+     * This option is meaningful only if `followSymlinks` is set to `false`.
+     * @default {true}
+     */
+    includeSymlinks?: boolean;
+    /**
+     * List of regular expression or glob patterns used to filter entries.
+     * If specified, entries that do not match the patterns specified by this option are excluded.
+     * @default {undefined}
+     */
+    match?: (RegExp | string)[];
+    /**
+     * The maximum depth of the file tree to be walked recursively.
+     * @default {Infinity}
+     */
+    maxDepth?: number;
+    /**
+     * List of regular expression or glob patterns used to filter entries.
+     * If specified, entries matching the patterns specified by this option are excluded.
+     * @default {undefined}
+     */
+    skip?: (RegExp | string)[];
+}
+/**
+ * Represents an entry found by `walk` or `walkSync`.
+ */
+export interface WalkEntry extends Pick<Dirent, "isDirectory" | "isFile" | "isSymbolicLink" | "name"> {
+    /** The full path to the entry. */
+    path: string;
+}
+/**
+ * Supported file encodings for reading files.
+ */
+export type ReadFileEncoding = "ascii" | "base64" | "base64url" | "hex" | "latin1" | "ucs-2" | "ucs2" | "utf-8" | "utf-16le" | "utf8" | "utf16le";
+/**
+ * Options for reading files.
+ * @template C - The type of compression used.
+ */
+export type ReadFileOptions<C> = {
+    /**
+     * Return content as a Buffer. Default: `false`
+     */
+    buffer?: boolean;
+    /**
+     * Compression method to decompress the file against. Default: `none`
+     */
+    compression?: C;
+    /**
+     * The encoding to use. Default: `utf8`
+     * @see https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
+     */
+    encoding?: ReadFileEncoding | undefined;
+    /**
+     * The flag used to open the file. Default: `r`
+     */
+    flag?: number | string | undefined;
+};
+/**
+ * Represents the content type of a read file, which can be a Buffer or a string based on options.
+ * @template O - The ReadFileOptions type.
+ */
+export type ContentType<O = undefined> = O extends {
+    buffer: true;
+} ? Buffer : string;
+/**
+ * Type for the `reviver` parameter of `JSON.parse()`.
+ * A function that transforms the results. This function is called for each member of the object.
+ * If a member contains nested objects, the nested objects are transformed before the parent object is.
+ */
+export type JsonReviver = Parameters<(typeof JSON)["parse"]>["1"];
+/**
+ * Specifies a location (line and column) in a file for code frame generation.
+ */
+export type CodeFrameLocation = {
+    /** The column number. */
+    column?: number;
+    /** The line number. */
+    line: number;
+};
+/**
+ * Options for customizing the appearance of code frames.
+ */
+export type CodeFrameOptions = {
+    /** Colorization methods for different parts of the code frame. */
+    color?: {
+        /** Color for the gutter (line numbers). */
+        gutter?: ColorizeMethod;
+        /** Color for the marker (pointing to the error). */
+        marker?: ColorizeMethod;
+        /** Color for the message. */
+        message?: ColorizeMethod;
+    };
+};
+/**
+ * Options for reading and parsing JSON files.
+ * Extends {@link CodeFrameOptions}.
+ */
+export type ReadJsonOptions = CodeFrameOptions & {
+    /**
+     * A function to transform the string content before parsing.
+     * @param source The raw string content of the file.
+     * @returns The transformed string content.
+     */
+    beforeParse?: (source: string) => string;
+};
+/**
+ * Options for writing files.
+ */
+export type WriteFileOptions = {
+    /**
+     * The group and user ID used to set the file ownership. Default: `undefined`
+     */
+    chown?: {
+        gid: number;
+        uid: number;
+    };
+    /**
+     * The encoding to use. Default: `utf8`
+     */
+    encoding?: BufferEncoding | null | undefined;
+    /**
+     * The flag used to write the file. Default: `w`
+     */
+    flag?: string | undefined;
+    /**
+     * The file mode (permission and sticky bits). Default: `0o666`
+     */
+    mode?: number;
+    /**
+     * Indicates whether the file should be overwritten if it already exists. Default: `false`
+     */
+    overwrite?: boolean;
+    /**
+     * Recursively create parent directories if needed. Default: `true`
+     */
+    recursive?: boolean;
+};
+/**
+ * Type for the `replacer` parameter of `JSON.stringify()`.
+ * Can be a function that alters the behavior of the stringification process,
+ * or an array of strings and numbers that acts as a whitelist for selecting
+ * the properties of the value object to be included in the JSON string.
+ * If this value is null or not provided, all properties of the object are included in the resulting JSON string.
+ */
+export type JsonReplacer = (number | string)[] | ((this: unknown, key: string, value: unknown) => unknown) | null;
+/**
+ * Type for the `replacer` parameter used in YAML serialization, similar to `JSON.stringify`'s replacer.
+ */
+export type YamlReplacer = JsonReplacer;
+/**
+ * Options for writing JSON files.
+ * Extends {@link WriteFileOptions}.
+ */
+export type WriteJsonOptions = WriteFileOptions & {
+    /**
+     * Detect indentation automatically if the file exists. Default: `false`
+     */
+    detectIndent?: boolean;
+    /**
+     * The space used for pretty-printing.
+     *
+     * Pass in `undefined` for no formatting.
+     */
+    indent?: number | string | undefined;
+    /**
+     * Passed into `JSON.stringify`.
+     */
+    replacer?: JsonReplacer;
+    /**
+     * Override the default `JSON.stringify` method.
+     */
+    stringify?: (data: unknown, replacer: JsonReplacer, space: number | string | undefined) => string;
+};
+/**
+ * Options for the `findUp` and `findUpSync` functions.
+ */
+export type FindUpOptions = {
+    /**
+     * Whether to follow symbolic links.
+     * @default undefined (behaves like `true` for `findUp`, `false` for `findUpSync` due to `fs.stat` vs `fs.lstat`)
+     */
+    allowSymlinks?: boolean;
+    /**
+     * The current working directory.
+     * @default process.cwd()
+     */
+    cwd?: URL | string;
+    /**
+     * The directory to stop searching at.
+     * @default path.parse(cwd).root
+     */
+    stopAt?: URL | string;
+    /**
+     * The type of path to find.
+     * @default "file"
+     */
+    type?: "directory" | "file";
+};
+/**
+ * The result type for the name matcher function used in `findUp`.
+ * It can be a `PathLike` (string, Buffer, or URL), a Promise resolving to `PathLike` or `FIND_UP_STOP`,
+ * `FIND_UP_STOP` to stop the search, or `undefined` to continue.
+ */
+export type FindUpNameFnResult = PathLike | Promise<PathLike | typeof FIND_UP_STOP> | typeof FIND_UP_STOP | undefined;
+/**
+ * Specifies the name(s) of the file or directory to search for in `findUp`.
+ * Can be a single name, an array of names, or a function that returns a name or `FIND_UP_STOP`.
+ */
+export type FindUpName = string[] | string | ((directory: string) => FindUpNameFnResult);
+/**
+ * The result type for the name matcher function used in `findUpSync`.
+ * It can be a `PathLike` (string, Buffer, or URL), `FIND_UP_STOP` to stop the search,
+ * or `undefined` to continue.
+ */
+export type FindUpNameSyncFnResult = PathLike | typeof FIND_UP_STOP | undefined;
+/**
+ * Specifies the name(s) of the file or directory to search for in `findUpSync`.
+ * Can be a single name, an array of names, or a function that returns a name or `FIND_UP_STOP`.
+ */
+export type FindUpNameSync = string[] | string | ((directory: string) => FindUpNameSyncFnResult);
+/**
+ * Options for operations that might require retries, like `emptyDir` or `remove`.
+ */
+export type RetryOptions = {
+    /**
+     * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+     * `EPERM` error is encountered, Node.js will retry the operation with a linear
+     * backoff wait of `retryDelay` ms longer on each try. This option represents the
+     * number of retries. This option is ignored if the `recursive` option is not
+     * `true` for operations that support it (like `rm`).
+     * @default 0
+     */
+    maxRetries?: number | undefined;
+    /**
+     * The amount of time in milliseconds to wait between retries.
+     * This option is ignored if the `recursive` option is not `true` for operations that support it.
+     * @default 100
+     */
+    retryDelay?: number | undefined;
+};
+/**
+ * Options for reading YAML files.
+ * Combines options from `yaml` library (DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions)
+ * and custom {@link ReadFileOptions}.
+ * @template C - The type of compression used.
+ */
+export type ReadYamlOptions<C> = DocumentOptions & ParseOptions & ReadFileOptions<C> & SchemaOptions & ToJSOptions;
+/**
+ * Type for the `reviver` parameter used in YAML deserialization, similar to `JSON.parse`'s reviver.
+ * A function that transforms the results. This function is called for each member of the object.
+ * If a member contains nested objects, the nested objects are transformed before the parent object is.
+ */
+export type YamlReviver = (key: unknown, value: unknown) => unknown;
+/**
+ * Options for writing YAML files.
+ * Extends {@link WriteFileOptions} and includes options from the `yaml` library for stringification.
+ */
+export type WriteYamlOptions = CreateNodeOptions & DocumentOptions & ParseOptions & SchemaOptions & ToStringOptions & WriteFileOptions & {
+    /**
+     * Passed into `yaml.stringify` as the replacer argument.
+     */
+    replacer?: YamlReplacer;
+    /**
+     * Passed into `yaml.stringify` as the space argument for indentation.
+     * Can be a number of spaces or a string (e.g., a tab character).
+     */
+    space?: number | string;
+};
+export {};

package/dist/utils/assert-valid-file-contents.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Asserts that the provided contents are valid for writing to a file.
+ * Valid contents can be a string, an ArrayBuffer, or an ArrayBuffer view (e.g., Uint8Array).
+ * @param contents The file contents to validate.
+ * @throws {TypeError} If the contents are not a string, ArrayBuffer, or ArrayBuffer view.
+ * @example
+ * ```javascript
+ * import { assertValidFileContents } from "@visulima/fs"; // Assuming this util is exported
+ *
+ * try {
+ *   assertValidFileContents("Hello, world!");
+ *   assertValidFileContents(new Uint8Array([72, 101, 108, 108, 111])); // "Hello"
+ *   assertValidFileContents(new ArrayBuffer(8));
+ *   console.log("File contents are valid.");
+ * } catch (error) {
+ *   console.error(error.message); // File contents must be a string, ArrayBuffer, or ArrayBuffer view.
+ * }
+ *
+ * try {
+ *   assertValidFileContents(123); // Invalid content type
+ * } catch (error) {
+ *   console.error(error.message); // File contents must be a string, ArrayBuffer, or ArrayBuffer view.
+ * }
+ * ```
+ */
+declare const assertValidFileContents: (contents: any) => void;
+export default assertValidFileContents;

package/dist/utils/assert-valid-file-or-directory-path.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Asserts that the provided path is a valid file or directory path.
+ * A valid path must be a non-empty string or a URL instance.
+ * @param fileOrDirectoryPath The path to validate.
+ * @throws {TypeError} If the path is not a non-empty string or a URL.
+ * @example
+ * ```javascript
+ * import { assertValidFileOrDirectoryPath } from "@visulima/fs"; // Assuming this util is exported
+ *
+ * try {
+ *   assertValidFileOrDirectoryPath("/path/to/file.txt");
+ *   assertValidFileOrDirectoryPath(new URL("file:///path/to/file.txt"));
+ *   console.log("Path is valid.");
+ * } catch (error) {
+ *   console.error(error.message); // Path must be a non-empty string or URL.
+ * }
+ *
+ * try {
+ *   assertValidFileOrDirectoryPath(""); // Invalid path
+ * } catch (error) {
+ *   console.error(error.message); // Path must be a non-empty string or URL.
+ * }
+ * ```
+ */
+declare const assertValidFileOrDirectoryPath: (fileOrDirectoryPath: any) => void;
+export default assertValidFileOrDirectoryPath;

package/dist/utils/parse-json.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from "type-fest";
+import type { CodeFrameOptions, JsonReviver } from "../types.d.ts";
+declare function parseJson<T = JsonValue>(string: string, filename?: string, options?: CodeFrameOptions): T;
+declare function parseJson<T = JsonValue>(string: string, reviver: JsonReviver, fileName?: string, options?: CodeFrameOptions): T;
+export default parseJson;

package/dist/utils/strip-json-comments.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Strips comments from a JSON string.
+ * Handles both single-line (//) and multi-line (/* ... */) comments.
+ * @param jsonString The JSON string possibly containing comments.
+ * @param [options] Optional configuration for stripping comments.
+ * @param [options.whitespace] If `true` (default), comments are replaced with whitespace to preserve line numbers and character positions. If `false`, comments are removed entirely.
+ * @returns The JSON string with comments stripped.
+ * @example
+ * ```javascript
+ * import { stripJsonComments } from "@visulima/fs"; // Assuming this util is exported
+ *
+ * const jsonWithComments = `{
+ *   // This is a single-line comment
+ *   "name": "John Doe",
+ *   "age": 30, /* This is a
+ *   multi-line comment */
+ *   "city": "New York"
+ * }`;
+ *
+ * const stripped = stripJsonComments(jsonWithComments);
+ * console.log(stripped);
+ * // Output (with whitespace=true):
+ * // {
+ * //
+ * //   "name": "John Doe",
+ * //   "age": 30, /*
+ * //
+ * //   "city": "New York"
+ * // }
+ *
+ * const strippedWithoutWhitespace = stripJsonComments(jsonWithComments, { whitespace: false });
+ * console.log(strippedWithoutWhitespace);
+ * // Output (with whitespace=false):
+ * // {
+ * //   "name": "John Doe",
+ * //   "age": 30,
+ * //   "city": "New York"
+ * // }
+ * ```
+ */
+declare const stripJsonComments: (jsonString: string, options?: {
+    whitespace?: boolean;
+}) => string;
+export default stripJsonComments;

package/dist/utils.d.ts

@@ -1,19 +1,6 @@
-export { J as JSONError } from './packem_shared/json-error-ZPgZIXcg.js';
-import { JsonValue } from 'type-fest';
-import { m as CodeFrameOptions, J as JsonReviver } from './packem_shared/types-T308NKwz.js';
-export { toPath } from '@visulima/path/utils';
-import 'node:fs';
-import 'yaml';
-
-declare const assertValidFileContents: (contents: any) => void;
-
-declare const assertValidFileOrDirectoryPath: (fileOrDirectoryPath: any) => void;
-
-declare function parseJson<T = JsonValue>(string: string, filename?: string, options?: CodeFrameOptions): T;
-declare function parseJson<T = JsonValue>(string: string, reviver: JsonReviver, fileName?: string, options?: CodeFrameOptions): T;
-
-declare const stripJsonComments: (jsonString: string, { whitespace }?: {
-    whitespace?: boolean | undefined;
-}) => string;
-
-export { assertValidFileContents, assertValidFileOrDirectoryPath, parseJson, stripJsonComments };
+export { default as JSONError } from "./error/json-error.d.ts";
+export { default as assertValidFileContents } from "./utils/assert-valid-file-contents.d.ts";
+export { default as assertValidFileOrDirectoryPath } from "./utils/assert-valid-file-or-directory-path.d.ts";
+export { default as parseJson } from "./utils/parse-json.d.ts";
+export { default as stripJsonComments } from "./utils/strip-json-comments.d.ts";
+export { toPath } from "@visulima/path/utils";

package/dist/utils.js

@@ -1 +1,6 @@
-import{default as e}from"./packem_shared/JSONError-D7h6PNWc.js";import{default as a}from"./packem_shared/assertValidFileContents-BZFnXa7K.js";import{default as f}from"./packem_shared/assertValidFileOrDirectoryPath-DgPIPmZT.js";import{default as m}from"./packem_shared/parseJson-Cj4v3qzl.js";import{default as d}from"./packem_shared/stripJsonComments-DbMjL4qv.js";import{toPath as x}from"@visulima/path/utils";export{e as JSONError,a as assertValidFileContents,f as assertValidFileOrDirectoryPath,m as parseJson,d as stripJsonComments,x as toPath};
+export { default as JSONError } from './packem_shared/JSONError-BkHRnInH.js';
+export { default as assertValidFileContents } from './packem_shared/assertValidFileContents-BmcLtsGd.js';
+export { default as assertValidFileOrDirectoryPath } from './packem_shared/assertValidFileOrDirectoryPath-8HANmVjk.js';
+export { default as parseJson } from './packem_shared/parseJson-CqUuRguZ.js';
+export { default as stripJsonComments } from './packem_shared/stripJsonComments-21XWVDwP.js';
+export { toPath } from '@visulima/path/utils';

package/dist/write/utils/to-uint-8-array.d.ts

@@ -0,0 +1,2 @@
+declare const toUint8Array: (contents: any) => Uint8Array;
+export default toUint8Array;

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

@@ -0,0 +1,30 @@
+import type { WriteFileOptions } from "../types.d.ts";
+/**
+ * Synchronously writes data to a file, replacing the file if it already exists.
+ * This function includes safeguards like writing to a temporary file first and then renaming, and handling permissions.
+ * @param path The path to the file to write. Can be a file URL or a string path.
+ * @param content The data to write. Can be a string, Buffer, ArrayBuffer, or ArrayBufferView.
+ * @param options Optional configuration for writing the file. See {@link WriteFileOptions}.
+ * @returns void
+ * @example
+ * ```javascript
+ * import { writeFileSync } from "@visulima/fs";
+ * import { join } from "node:path";
+ *
+ * const writeMyFileSync = () => {
+ *   try {
+ *     writeFileSync(join("/tmp", "my-new-file-sync.txt"), "Hello World Synchronously!");
+ *     console.log("File written successfully (sync).");
+ *
+ *     writeFileSync(join("/tmp", "another-file-sync.txt"), "Some other sync content", { encoding: 'utf16le', mode: 0o600 });
+ *     console.log("Another file written with specific options (sync).");
+ *   } catch (error) {
+ *     console.error("Failed to write file (sync):", error);
+ *   }
+ * };
+ *
+ * writeMyFileSync();
+ * ```
+ */
+declare const writeFileSync: (path: URL | string, content: ArrayBuffer | ArrayBufferView | string, options?: WriteFileOptions) => void;
+export default writeFileSync;

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

@@ -0,0 +1,30 @@
+import type { WriteFileOptions } from "../types.d.ts";
+/**
+ * Asynchronously writes data to a file, replacing the file if it already exists.
+ * This function includes safeguards like writing to a temporary file first and then renaming, and handling permissions.
+ * @param path The path to the file to write. Can be a file URL or a string path.
+ * @param content The data to write. Can be a string, Buffer, ArrayBuffer, or ArrayBufferView.
+ * @param options Optional configuration for writing the file. See {@link WriteFileOptions}.
+ * @returns A promise that resolves when the file has been written.
+ * @example
+ * ```javascript
+ * import { writeFile } from "@visulima/fs";
+ * import { join } from "node:path";
+ *
+ * const writeMyFile = async () => {
+ *   try {
+ *     await writeFile(join("/tmp", "my-new-file.txt"), "Hello World!");
+ *     console.log("File written successfully.");
+ *
+ *     await writeFile(join("/tmp", "another-file.txt"), "Some other content", { encoding: 'utf16le', mode: 0o600 });
+ *     console.log("Another file written with specific options.");
+ *   } catch (error) {
+ *     console.error("Failed to write file:", error);
+ *   }
+ * };
+ *
+ * writeMyFile();
+ * ```
+ */
+declare const writeFile: (path: URL | string, content: ArrayBuffer | ArrayBufferView | string, options?: WriteFileOptions) => Promise<void>;
+export default writeFile;

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

@@ -0,0 +1,30 @@
+import type { WriteJsonOptions } from "../types.d.ts";
+/**
+ * Synchronously writes an object to a JSON file.
+ * Handles indentation detection, custom stringifiers, and gracefully manages existing files.
+ * @param path The path to the JSON file to write. Can be a file URL or a string path.
+ * @param data The data to serialize and write. Can be any JavaScript value that can be stringified by `JSON.stringify` or a custom stringifier.
+ * @param options Optional configuration for writing the JSON file. See {@link WriteJsonOptions}.
+ * @returns void
+ * @example
+ * ```javascript
+ * import { writeJsonSync } from "@visulima/fs";
+ * import { join } from "node:path";
+ *
+ * const writeMyJsonSync = () => {
+ *   try {
+ *     writeJsonSync(join("/tmp", "my-config-sync.json"), { setting: "enabled", value: 456 });
+ *     console.log("JSON file written successfully (sync).");
+ *
+ *     writeJsonSync(join("/tmp", "another-config-sync.json"), { user: "testSync", id: "def" }, { indent: 4, replacer: ["id"] });
+ *     console.log("Another JSON file written with specific options (sync, indent 4, only 'id' key).");
+ *   } catch (error) {
+ *     console.error("Failed to write JSON file (sync):", error);
+ *   }
+ * };
+ *
+ * writeMyJsonSync();
+ * ```
+ */
+declare const writeJsonSync: (path: URL | string, data: unknown, options?: WriteJsonOptions) => void;
+export default writeJsonSync;

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

@@ -0,0 +1,30 @@
+import type { WriteJsonOptions } from "../types.d.ts";
+/**
+ * Asynchronously writes an object to a JSON file.
+ * Handles indentation detection, custom stringifiers, and gracefully manages existing files.
+ * @param path The path to the JSON file to write. Can be a file URL or a string path.
+ * @param data The data to serialize and write. Can be any JavaScript value that can be stringified by `JSON.stringify` or a custom stringifier.
+ * @param options Optional configuration for writing the JSON file. See {@link WriteJsonOptions}.
+ * @returns A promise that resolves when the JSON file has been written.
+ * @example
+ * ```javascript
+ * import { writeJson } from "@visulima/fs";
+ * import { join } from "node:path";
+ *
+ * const writeMyJson = async () => {
+ *   try {
+ *     await writeJson(join("/tmp", "my-config.json"), { setting: "enabled", value: 123 });
+ *     console.log("JSON file written successfully.");
+ *
+ *     await writeJson(join("/tmp", "another-config.json"), { user: "test", id: "abc" }, { indent: 2, replacer: ["user"] });
+ *     console.log("Another JSON file written with specific options (indent 2, only 'user' key).");
+ *   } catch (error) {
+ *     console.error("Failed to write JSON file:", error);
+ *   }
+ * };
+ *
+ * writeMyJson();
+ * ```
+ */
+declare const writeJson: (path: URL | string, data: unknown, options?: WriteJsonOptions) => Promise<void>;
+export default writeJson;

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

@@ -0,0 +1,4 @@
+import type { WriteYamlOptions, YamlReplacer } from "../types.d.ts";
+declare function writeYamlSync(path: URL | string, data: any, options?: WriteYamlOptions): void;
+declare function writeYamlSync(path: URL | string, data: any, replacer?: YamlReplacer, options?: WriteYamlOptions | number | string): void;
+export default writeYamlSync;

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

@@ -0,0 +1,4 @@
+import type { WriteYamlOptions, YamlReplacer } from "../types.d.ts";
+declare function writeYaml(path: URL | string, data: any, options?: WriteYamlOptions): Promise<void>;
+declare function writeYaml(path: URL | string, data: any, replacer?: YamlReplacer, options?: WriteYamlOptions | number | string): Promise<void>;
+export default writeYaml;

package/dist/yaml.d.ts

@@ -1,17 +1,5 @@
-import { r as ReadYamlOptions, Y as YamlReviver, s as WriteYamlOptions, t as YamlReplacer } from './packem_shared/types-T308NKwz.js';
-import 'node:fs';
-import 'yaml';
-
-declare function readYaml<R = Record<string, unknown>>(path: URL | string, options?: ReadYamlOptions<"brotli" | "gzip" | "none">): Promise<R>;
-declare function readYaml<R = Record<string, unknown>>(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<"brotli" | "gzip" | "none">): Promise<R>;
-
-declare function readYamlSync<R = Record<string, unknown>>(path: URL | string, options?: ReadYamlOptions<"brotli" | "gzip" | "none">): R;
-declare function readYamlSync<R = Record<string, unknown>>(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<"brotli" | "gzip" | "none">): R;
-
-declare function writeYaml(path: URL | string, data: any, options?: WriteYamlOptions): Promise<void>;
-declare function writeYaml(path: URL | string, data: any, replacer?: YamlReplacer, options?: WriteYamlOptions | number | string): Promise<void>;
-
-declare function writeYamlSync(path: URL | string, data: any, options?: WriteYamlOptions): void;
-declare function writeYamlSync(path: URL | string, data: any, replacer?: YamlReplacer, options?: WriteYamlOptions | number | string): void;
-
-export { YamlReplacer, readYaml, readYamlSync, writeYaml, writeYamlSync };
+export { default as readYaml } from "./read/read-yaml.d.ts";
+export { default as readYamlSync } from "./read/read-yaml-sync.d.ts";
+export type { YamlReplacer } from "./types.d.ts";
+export { default as writeYaml } from "./write/write-yaml.d.ts";
+export { default as writeYamlSync } from "./write/write-yaml-sync.d.ts";

package/dist/yaml.js

@@ -1 +1,4 @@
-import{default as r}from"./packem_shared/readYaml-D5mtfANg.js";import{default as f}from"./packem_shared/readYamlSync-D0igCVDE.js";import{default as m}from"./packem_shared/writeYaml-BJeyUpyY.js";import{default as d}from"./packem_shared/writeYamlSync-D87XCS7Y.js";export{r as readYaml,f as readYamlSync,m as writeYaml,d as writeYamlSync};
+export { default as readYaml } from './packem_shared/readYaml-Bu1nsexB.js';
+export { default as readYamlSync } from './packem_shared/readYamlSync-Di88aMME.js';
+export { default as writeYaml } from './packem_shared/writeYaml-BMY0kOPf.js';
+export { default as writeYamlSync } from './packem_shared/writeYamlSync-DqPu8cCd.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/fs",
-  "version": "4.0.3",
+  "version": "4.0.5",
   "description": "Human friendly file system utilities for Node.js",
   "keywords": [
     "anolilab",
@@ -113,8 +113,7 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@visulima/path": "2.0.2",
-    "type-fest": "^5.2.0"
+    "@visulima/path": "2.0.4"
   },
   "peerDependencies": {
     "yaml": "^2.7.1"

package/dist/packem_shared/AlreadyExistsError-CEu6_Tjb.js

@@ -1 +0,0 @@
-var o=Object.defineProperty;var t=(e,r)=>o(e,"name",{value:r,configurable:!0});var a=Object.defineProperty,n=t((e,r)=>a(e,"name",{value:r,configurable:!0}),"t");class E extends Error{static{t(this,"n")}static{n(this,"AlreadyExistsError")}constructor(r){super(`EEXIST: ${r}`)}get code(){return"EEXIST"}set code(r){throw new Error("Cannot overwrite code EEXIST")}get name(){return"AlreadyExistsError"}set name(r){throw new Error("Cannot overwrite name of AlreadyExistsError")}}export{E as default};

package/dist/packem_shared/DirectoryError-ddlbUV8C.js

@@ -1 +0,0 @@
-var t=Object.defineProperty;var o=(e,r)=>t(e,"name",{value:r,configurable:!0});var n=Object.defineProperty,a=o((e,r)=>n(e,"name",{value:r,configurable:!0}),"o");class i extends Error{static{o(this,"n")}static{a(this,"DirectoryError")}constructor(r){super(`EISDIR: Illegal operation on a directory, ${r}`)}get code(){return"EISDIR"}set code(r){throw new Error("Cannot overwrite code EISDIR")}get name(){return"DirectoryError"}set name(r){throw new Error("Cannot overwrite name of DirectoryError")}}export{i as default};

package/dist/packem_shared/F_OK-CAwY1qU7.js

@@ -1 +0,0 @@
-const _=0,O=4,S=2,o=1,K=Symbol("findUpStop"),N=/"(?:[^"\\]|\\.)*"|\/\/[^\r\n]*|\/\*[\s\S]*?\*\//g;export{K as FIND_UP_STOP,_ as F_OK,N as INTERNAL_STRIP_JSON_REGEX,O as R_OK,S as W_OK,o as X_OK};

package/dist/packem_shared/JSONError-D7h6PNWc.js

@@ -1,4 +0,0 @@
-var s=Object.defineProperty;var t=(r,e)=>s(r,"name",{value:e,configurable:!0});var a=Object.defineProperty,i=t((r,e)=>a(r,"name",{value:e,configurable:!0}),"i");class m extends Error{static{t(this,"t")}static{i(this,"JSONError")}fileName;codeFrame;name="JSONError";#e;constructor(e){super(),this.#e=e}get message(){return`${this.#e}${this.fileName?` in ${this.fileName}`:""}${this.codeFrame?`
-
-${this.codeFrame}
-`:""}`}set message(e){this.#e=e}}export{m as default};

package/dist/packem_shared/NotEmptyError-DMh1o7UL.js

@@ -1 +0,0 @@
-var o=Object.defineProperty;var t=(e,r)=>o(e,"name",{value:r,configurable:!0});var n=Object.defineProperty,E=t((e,r)=>n(e,"name",{value:r,configurable:!0}),"t");class c extends Error{static{t(this,"n")}static{E(this,"NotEmptyError")}constructor(r){super(`ENOTEMPTY: Directory not empty, ${r}`)}get code(){return"ENOTEMPTY"}set code(r){throw new Error("Cannot overwrite code ENOTEMPTY")}get name(){return"NotEmptyError"}set name(r){throw new Error("Cannot overwrite name of NotEmptyError")}}export{c as default};