@visulima/fs 5.0.0-alpha.7 → 5.0.0-alpha.9

package/dist/size.d.ts

@@ -1,256 +1,12 @@
-import { Readable } from "node:stream";
-import { URL } from "node:url";
-import type { BrotliOptions, ZlibOptions } from "node:zlib";
-/**
- * Input type for size calculation functions.
- * Can be a Buffer, Readable stream, URL object, or string (file path or content).
- */
+import { Readable } from 'node:stream';
+import { URL } from 'node:url';
+import { BrotliOptions, ZlibOptions } from 'node:zlib';
 type SizeInput = Buffer | Readable | URL | string;
-/**
- * Input type for synchronous size calculation functions.
- * Can be a Buffer, URL object, or string (file path or content).
- */
 type SizeInputSync = Buffer | URL | string;
-/**
- * Asynchronously calculates the gzipped size of the given input.
- * The input can be a Buffer, a Readable stream, a URL object pointing to a file, or a string (file path or content).
- * Uses memory-efficient streaming for files and streams to avoid loading entire contents into memory.
- * @param input The input data to gzip and measure.
- * @param [options] Optional Zlib options for gzip compression.
- * @returns A promise that resolves with the gzipped size in bytes.
- * @example
- * ```javascript
- * import { gzipSize } from "@visulima/fs";
- * import { Readable } from "node:stream";
- * import { writeFile, unlink } from "node:fs/promises";
- * import { join } from "node:path";
- *
- * const text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
- * const filePath = join("temp-file.txt");
- *
- * async function main() {
- *   // From Buffer
- *   const buffer = Buffer.from(text);
- *   console.log(`Gzip size of buffer: ${await gzipSize(buffer)} bytes`);
- *
- *   // From string (content)
- *   console.log(`Gzip size of string content: ${await gzipSize(text)} bytes`);
- *
- *   // From file path
- *   await writeFile(filePath, text);
- *   console.log(`Gzip size of file: ${await gzipSize(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Gzip size of URL: ${await gzipSize(fileUrl)} bytes`);
- *
- *   // From Readable stream
- *   const stream = Readable.from(text);
- *   console.log(`Gzip size of stream: ${await gzipSize(stream)} bytes`);
- *
- *   await unlink(filePath); // Clean up temp file
- * }
- *
- * main().catch(console.error);
- * ```
- */
-export declare const gzipSize: (input: SizeInput, options?: ZlibOptions) => Promise<number>;
-/**
- * Asynchronously calculates the Brotli compressed size of the given input.
- * The input can be a Buffer, a Readable stream, a URL object pointing to a file, or a string (file path or content).
- * Uses memory-efficient streaming for files and streams to avoid loading entire contents into memory.
- * @param input The input data to compress with Brotli and measure.
- * @param [options] Optional Zlib options for Brotli compression.
- * @returns A promise that resolves with the Brotli compressed size in bytes.
- * @example
- * ```javascript
- * import { brotliSize } from "@visulima/fs";
- * import { Readable } from "node:stream";
- * import { writeFile, unlink } from "node:fs/promises";
- * import { join } from "node:path";
- *
- * const text = "This is a test string for Brotli compression efficiency.";
- * const filePath = join("temp-brotli-file.txt");
- *
- * async function main() {
- *   // From Buffer
- *   const buffer = Buffer.from(text);
- *   console.log(`Brotli size of buffer: ${await brotliSize(buffer)} bytes`);
- *
- *   // From string (content)
- *   console.log(`Brotli size of string content: ${await brotliSize(text)} bytes`);
- *
- *   // From file path
- *   await writeFile(filePath, text);
- *   console.log(`Brotli size of file: ${await brotliSize(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Brotli size of URL: ${await brotliSize(fileUrl)} bytes`);
- *
- *   // From Readable stream
- *   const stream = Readable.from(text);
- *   console.log(`Brotli size of stream: ${await brotliSize(stream)} bytes`);
- *
- *   await unlink(filePath); // Clean up temp file
- * }
- *
- * main().catch(console.error);
- * ```
- */
-export declare const brotliSize: (input: SizeInput, options?: BrotliOptions) => Promise<number>;
-/**
- * Asynchronously calculates the raw (uncompressed) size of the given input.
- * The input can be a Buffer, a Readable stream, a URL object pointing to a file, or a string (file path or content).
- * Uses memory-efficient streaming for files and streams to avoid loading entire contents into memory.
- * @param input The input data to measure.
- * @returns A promise that resolves with the raw size in bytes.
- * @example
- * ```javascript
- * import { rawSize } from "@visulima/fs";
- * import { Readable } from "node:stream";
- * import { writeFile, unlink } from "node:fs/promises";
- * import { join } from "node:path";
- *
- * const text = "Hello, World!";
- * const filePath = join("temp-raw-file.txt");
- *
- * async function main() {
- *   // From Buffer
- *   const buffer = Buffer.from(text);
- *   console.log(`Raw size of buffer: ${await rawSize(buffer)} bytes`);
- *
- *   // From string (content)
- *   console.log(`Raw size of string content: ${await rawSize(text)} bytes`);
- *
- *   // From file path
- *   await writeFile(filePath, text);
- *   console.log(`Raw size of file: ${await rawSize(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Raw size of URL: ${await rawSize(fileUrl)} bytes`);
- *
- *   // From Readable stream
- *   const stream = Readable.from(text);
- *   console.log(`Raw size of stream: ${await rawSize(stream)} bytes`);
- *
- *   await unlink(filePath); // Clean up temp file
- * }
- *
- * main().catch(console.error);
- * ```
- */
-export declare const rawSize: (input: SizeInput) => Promise<number>;
-/**
- * Synchronously calculates the gzipped size of the given input.
- * The input can be a Buffer, a URL object pointing to a file, or a string (file path or content).
- * Note: For Readable streams or very large files, consider using the asynchronous `gzipSize` function for better performance and to avoid blocking.
- * @param input The input data to gzip and measure.
- * @param [options] Optional Zlib options for gzip compression.
- * @returns The gzipped size in bytes.
- * @example
- * ```javascript
- * import { gzipSizeSync } from "@visulima/fs";
- * import { writeFileSync, unlinkSync } from "node:fs";
- * import { join } from "node:path";
- *
- * const text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
- * const filePath = join("temp-sync-file.txt");
- *
- * // From Buffer
- * const buffer = Buffer.from(text);
- * console.log(`Sync Gzip size of buffer: ${gzipSizeSync(buffer)} bytes`);
- *
- * // From string (content)
- * console.log(`Sync Gzip size of string content: ${gzipSizeSync(text)} bytes`);
- *
- * // From file path
- * try {
- *   writeFileSync(filePath, text);
- *   console.log(`Sync Gzip size of file: ${gzipSizeSync(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Sync Gzip size of URL: ${gzipSizeSync(fileUrl)} bytes`);
- * } finally {
- *   try { unlinkSync(filePath); } catch {} // Clean up temp file
- * }
- * ```
- */
-export declare const gzipSizeSync: (input: SizeInputSync, options?: ZlibOptions) => number;
-/**
- * Synchronously calculates the Brotli compressed size of the given input.
- * The input can be a Buffer, a URL object pointing to a file, or a string (file path or content).
- * Note: For Readable streams or very large files, consider using the asynchronous `brotliSize` function for better performance and to avoid blocking.
- * @param input The input data to compress with Brotli and measure.
- * @param [options] Optional Zlib options for Brotli compression.
- * @returns The Brotli compressed size in bytes.
- * @example
- * ```javascript
- * import { brotliSizeSync } from "@visulima/fs";
- * import { writeFileSync, unlinkSync } from "node:fs";
- * import { join } from "node:path";
- *
- * const text = "This is a test string for Brotli compression efficiency, synchronously.";
- * const filePath = join("temp-brotli-sync-file.txt");
- *
- * // From Buffer
- * const buffer = Buffer.from(text);
- * console.log(`Sync Brotli size of buffer: ${brotliSizeSync(buffer)} bytes`);
- *
- * // From string (content)
- * console.log(`Sync Brotli size of string content: ${brotliSizeSync(text)} bytes`);
- *
- * // From file path
- * try {
- *   writeFileSync(filePath, text);
- *   console.log(`Sync Brotli size of file: ${brotliSizeSync(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Sync Brotli size of URL: ${brotliSizeSync(fileUrl)} bytes`);
- * } finally {
- *   try { unlinkSync(filePath); } catch {} // Clean up temp file
- * }
- * ```
- */
-export declare const brotliSizeSync: (input: SizeInputSync, options?: BrotliOptions) => number;
-/**
- * Synchronously calculates the raw (uncompressed) size of the given input.
- * The input can be a Buffer, a URL object pointing to a file, or a string (file path or content).
- * For file paths, it uses `statSync` to get the file size.
- * Note: For Readable streams or very large files, consider using the asynchronous `rawSize` function for better performance and to avoid blocking.
- * @param input The input data to measure.
- * @returns The raw size in bytes.
- * @example
- * ```javascript
- * import { rawSizeSync } from "@visulima/fs";
- * import { writeFileSync, unlinkSync } from "node:fs";
- * import { join } from "node:path";
- *
- * const text = "Hello, Synchronous World!";
- * const filePath = join("temp-raw-sync-file.txt");
- *
- * // From Buffer
- * const buffer = Buffer.from(text);
- * console.log(`Sync Raw size of buffer: ${rawSizeSync(buffer)} bytes`);
- *
- * // From string (content)
- * console.log(`Sync Raw size of string content: ${rawSizeSync(text)} bytes`);
- *
- * // From file path
- * try {
- *   writeFileSync(filePath, text);
- *   console.log(`Sync Raw size of file: ${rawSizeSync(filePath)} bytes`);
- *
- *   // From URL
- *   const fileUrl = new URL(`file://${filePath}`);
- *   console.log(`Sync Raw size of URL: ${rawSizeSync(fileUrl)} bytes`);
- * } finally {
- *   try { unlinkSync(filePath); } catch {} // Clean up temp file
- * }
- * ```
- */
-export declare const rawSizeSync: (input: SizeInputSync) => number;
-export {};
+declare const gzipSize: (input: SizeInput, options?: ZlibOptions) => Promise<number>;
+declare const brotliSize: (input: SizeInput, options?: BrotliOptions) => Promise<number>;
+declare const rawSize: (input: SizeInput) => Promise<number>;
+declare const gzipSizeSync: (input: SizeInputSync, options?: ZlibOptions) => number;
+declare const brotliSizeSync: (input: SizeInputSync, options?: BrotliOptions) => number;
+declare const rawSizeSync: (input: SizeInputSync) => number;
+export { brotliSize, brotliSizeSync, gzipSize, gzipSizeSync, rawSize, rawSizeSync };

package/dist/toml.d.ts

@@ -0,0 +1,9 @@
+import { C as CompressionType, R as ReadTomlOptions, W as WriteTomlOptions } from "./packem_shared/types.d-dP-lAGNn.js";
+import 'node:fs';
+import 'tinyglobby';
+import './options';
+declare const readToml: <R = Record<string, unknown>>(path: URL | string, options?: ReadTomlOptions<CompressionType>) => Promise<R>;
+declare const readTomlSync: (path: URL | string, options?: ReadTomlOptions<CompressionType>) => Record<string, unknown>;
+declare const writeToml: (path: URL | string, data: Record<string, unknown>, options?: WriteTomlOptions) => Promise<void>;
+declare const writeTomlSync: (path: URL | string, data: Record<string, unknown>, options?: WriteTomlOptions) => void;
+export { type ReadTomlOptions, type WriteTomlOptions, readToml, readTomlSync, writeToml, writeTomlSync };

package/dist/toml.js

@@ -0,0 +1,4 @@
+export { default as readToml } from './packem_shared/readToml-B2MHaSes.js';
+export { default as readTomlSync } from './packem_shared/readTomlSync-DNbK8NEb.js';
+export { default as writeToml } from './packem_shared/writeToml-DgTW_-7F.js';
+export { default as writeTomlSync } from './packem_shared/writeTomlSync-DiBiE9ja.js';

package/dist/utils.d.ts

@@ -1,6 +1,15 @@
-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";
+export { J as JSONError } from "./packem_shared/json-error.d-DgKaeuIf.js";
+import { JsonValue } from 'type-fest';
+import { a as CodeFrameOptions, J as JsonReviver } from "./packem_shared/types.d-dP-lAGNn.js";
+export { toPath } from '@visulima/path/utils';
+import 'node:fs';
+import 'tinyglobby';
+import './options';
+declare const assertValidFileContents: (contents: any) => void;
+declare const assertValidFileOrDirectoryPath: (fileOrDirectoryPath: any) => void;
+declare function parseJson(string: string, filename?: string, options?: CodeFrameOptions): JsonValue;
+declare function parseJson(string: string, reviver: JsonReviver, fileName?: string, options?: CodeFrameOptions): JsonValue;
+declare const stripJsonComments: (jsonString: string, options?: {
+  whitespace?: boolean;
+}) => string;
+export { assertValidFileContents, assertValidFileOrDirectoryPath, parseJson, stripJsonComments };

package/dist/utils.js

@@ -1,6 +1,6 @@
 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-BedVi91S.js';
+export { default as parseJson } from './packem_shared/parseJson-BIp89Xjo.js';
 export { default as stripJsonComments } from './packem_shared/stripJsonComments-vo4k0mpF.js';
 export { toPath } from '@visulima/path/utils';

package/dist/yaml.d.ts

@@ -1,5 +1,14 @@
-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";
+import { C as CompressionType, m as ReadYamlOptions, Y as YamlReviver, n as WriteYamlOptions, o as JsonReplacer } from "./packem_shared/types.d-dP-lAGNn.js";
+export { type p as YamlReplacer } from "./packem_shared/types.d-dP-lAGNn.js";
+import 'node:fs';
+import 'tinyglobby';
+import './options';
+declare function readYaml<R = Record<string, unknown>>(path: URL | string, options?: ReadYamlOptions<CompressionType>): Promise<R>;
+declare function readYaml<R = Record<string, unknown>>(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<CompressionType>): Promise<R>;
+declare function readYamlSync(path: URL | string, options?: ReadYamlOptions<CompressionType>): Record<string, unknown>;
+declare function readYamlSync(path: URL | string, reviver?: YamlReviver, options?: ReadYamlOptions<CompressionType>): Record<string, unknown>;
+declare function writeYaml(path: URL | string, data: any, options?: WriteYamlOptions): Promise<void>;
+declare function writeYaml(path: URL | string, data: any, replacer?: JsonReplacer, 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?: JsonReplacer, options?: WriteYamlOptions | number | string): void;
+export { readYaml, readYamlSync, writeYaml, writeYamlSync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/fs",
-  "version": "5.0.0-alpha.7",
+  "version": "5.0.0-alpha.9",
   "description": "Human friendly file system utilities for Node.js",
   "keywords": [
     "anolilab",
@@ -49,6 +49,12 @@
     "write-file",
     "write-safe",
     "yaml",
+    "toml",
+    "jsonc",
+    "json5",
+    "ini",
+    "smol-toml",
+    "jsonc-parser",
     "size",
     "brotli",
     "gzip"
@@ -96,6 +102,22 @@
       "types": "./dist/yaml.d.ts",
       "default": "./dist/yaml.js"
     },
+    "./toml": {
+      "types": "./dist/toml.d.ts",
+      "default": "./dist/toml.js"
+    },
+    "./jsonc": {
+      "types": "./dist/jsonc.d.ts",
+      "default": "./dist/jsonc.js"
+    },
+    "./json5": {
+      "types": "./dist/json5.d.ts",
+      "default": "./dist/json5.js"
+    },
+    "./ini": {
+      "types": "./dist/ini.d.ts",
+      "default": "./dist/ini.js"
+    },
     "./size": {
       "types": "./dist/size.d.ts",
       "default": "./dist/size.js"
@@ -104,6 +126,22 @@
       "types": "./dist/eol.d.ts",
       "default": "./dist/eol.js"
     },
+    "./glob": {
+      "types": "./dist/glob.d.ts",
+      "default": "./dist/glob.js"
+    },
+    "./glob-parent": {
+      "types": "./dist/glob-parent.d.ts",
+      "default": "./dist/glob-parent.js"
+    },
+    "./is-glob": {
+      "types": "./dist/is-glob.d.ts",
+      "default": "./dist/is-glob.js"
+    },
+    "./match": {
+      "types": "./dist/match.d.ts",
+      "default": "./dist/match.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -113,19 +151,35 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@visulima/path": "3.0.0-alpha.8",
-    "type-fest": "5.5.0"
+    "@visulima/path": "3.0.0-alpha.9",
+    "type-fest": "5.6.0"
   },
   "peerDependencies": {
+    "ini": "^6.0.0",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "smol-toml": "^1.6.1",
     "yaml": "2.8.3"
   },
   "peerDependenciesMeta": {
+    "ini": {
+      "optional": true
+    },
+    "json5": {
+      "optional": true
+    },
+    "jsonc-parser": {
+      "optional": true
+    },
+    "smol-toml": {
+      "optional": true
+    },
     "yaml": {
       "optional": true
     }
   },
   "engines": {
-    "node": ">=22.13 <=25.x"
+    "node": "^22.14.0 || >=24.10.0"
   },
   "os": [
     "darwin",

package/dist/constants.d.ts

@@ -1,42 +0,0 @@
-/**
- * Constant to check if the path is visible to the calling process.
- * Corresponds to `node:fs.constants.F_OK`.
- */
-export declare const F_OK: number;
-/**
- * Constant to check if the path is readable to the calling process.
- * Corresponds to `node:fs.constants.R_OK`.
- */
-export declare const R_OK: number;
-/**
- * Constant to check if the path is writable to the calling process.
- * Corresponds to `node:fs.constants.W_OK`.
- */
-export declare const W_OK: number;
-/**
- * Constant to check if the path is executable by the calling process.
- * Corresponds to `node:fs.constants.X_OK`.
- */
-export declare const X_OK: number;
-/**
- * A special symbol that can be returned by the matcher function in `findUp` or `findUpSync`
- * to stop the search process prematurely.
- */
-export declare const FIND_UP_STOP: symbol;
-/**
- * Regular expression for stripping comments from JSON.
- * Matches:
- * 1. Quoted strings: "example \"escaped\" string"
- * 2. Single-line comments: // comment
- * 3. Multi-line comments: /* comment *\/
- * @example
- * const json = `{
- *   // comment
- *   "key": "value" // comment
- * }`;
- * json.replace(INTERNAL_STRIP_JSON_REGEX, (match) =>
- *   /^"/.test(match) ? match : ''
- * );
- * // Result: { "key": "value" }
- */
-export declare const INTERNAL_STRIP_JSON_REGEX: RegExp;

package/dist/ensure/ensure-dir-sync.d.ts

@@ -1,14 +0,0 @@
-/**
- * Ensures that the directory exists.
- * If the directory structure does not exist, it is created. Like mkdir -p.
- * @param directory The path to the directory to ensure exists.
- * @example
- * ```javascript
- * import ensureDirSync from "@visulima/fs/ensure/ensure-dir-sync";
- *
- * ensureDirSync("/tmp/foo/bar/baz");
- * // Creates the directory structure /tmp/foo/bar/baz if it doesn't exist
- * ```
- */
-declare const ensureDirSync: (directory: URL | string) => void;
-export default ensureDirSync;

package/dist/ensure/ensure-dir.d.ts

@@ -1,14 +0,0 @@
-/**
- * Ensures that the directory exists.
- * If the directory structure does not exist, it is created. Like mkdir -p.
- * @param directory The path to the directory to ensure exists.
- * @example
- * ```javascript
- * import ensureDir from "@visulima/fs/ensure/ensure-dir";
- *
- * await ensureDir("/tmp/foo/bar/baz");
- * // Creates the directory structure /tmp/foo/bar/baz if it doesn't exist
- * ```
- */
-declare const ensureDir: (directory: URL | string) => Promise<void>;
-export default ensureDir;

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

@@ -1,15 +0,0 @@
-/**
- * Ensures that the file exists.
- * If the file that is requested to be created is in directories that do not exist,
- * these directories are created. If the file already exists, it is NOT MODIFIED.
- * @param filePath The path to the file to ensure exists.
- * @example
- * ```javascript
- * import { ensureFileSync } from "@visulima/fs";
- *
- * ensureFileSync("/tmp/foo/bar/baz.txt");
- * // Creates the file /tmp/foo/bar/baz.txt and any missing parent directories if they don't exist
- * ```
- */
-declare const ensureFileSync: (filePath: URL | string) => void;
-export default ensureFileSync;

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

@@ -1,27 +0,0 @@
-/**
- * Asynchronously ensures that a file exists.
- * If the directory structure for the file does not exist, it is created.
- * If the file already exists, it is not modified.
- * @param filePath The path to the file. Can be a string or a URL object.
- * @returns A Promise that resolves when the file has been created or confirmed to exist.
- * @throws Will throw an error if the path exists and is not a file.
- * @throws Will throw an error if directory or file creation fails for reasons other than the path not existing initially.
- * @example
- * ```typescript
- * import { ensureFile } from "@visulima/fs";
- *
- * (async () => {
- *   try {
- *     await ensureFile("path/to/my/file.txt");
- *     console.log("File ensured!");
- *
- *     await ensureFile(new URL("file:///path/to/another/file.log"));
- *     console.log("Another file ensured!");
- *   } catch (error) {
- *     console.error("Failed to ensure file:", error);
- *   }
- * })();
- * ```
- */
-declare const ensureFile: (filePath: URL | string) => Promise<void>;
-export default ensureFile;

package/dist/ensure/ensure-link-sync.d.ts

@@ -1,16 +0,0 @@
-/**
- * Ensures that the hard link exists.
- * If the directory structure does not exist, it is created.
- * @param source The path to the source file or directory.
- * @param destination The path to the destination link.
- * @example
- * ```javascript
- * import { ensureLinkSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // ensure the link /tmp/foo/bar-link.txt points to /tmp/foo/bar.txt
- * ensureLinkSync(join("/tmp", "foo", "bar.txt"), join("/tmp", "foo", "bar-link.txt"));
- * ```
- */
-declare const ensureLinkSync: (source: URL | string, destination: URL | string) => void;
-export default ensureLinkSync;

package/dist/ensure/ensure-link.d.ts

@@ -1,16 +0,0 @@
-/**
- * Ensures that the hard link exists.
- * If the directory structure does not exist, it is created.
- * @param source The path to the source file or directory.
- * @param destination The path to the destination link.
- * @example
- * ```javascript
- * import { ensureLink } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // ensure the link /tmp/foo/bar-link.txt points to /tmp/foo/bar.txt
- * await ensureLink(join("/tmp", "foo", "bar.txt"), join("/tmp", "foo", "bar-link.txt"));
- * ```
- */
-declare const ensureLink: (source: URL | string, destination: URL | string) => Promise<void>;
-export default ensureLink;

package/dist/ensure/ensure-symlink-sync.d.ts

@@ -1,23 +0,0 @@
-import type { symlink } from "node:fs";
-/**
- * Ensures that the link exists, and points to a valid file.
- * If the directory structure does not exist, it is created.
- * If the link already exists, it is not modified but error is thrown if it is not point to the given target.
- * @param target the source file path
- * @param linkName the destination link path
- * @param type the type of the symlink, or null to use automatic detection
- * @returns A void.
- * @example
- * ```javascript
- * import { ensureSymlinkSync } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // Ensure a symlink /tmp/foo/link-to-bar.txt points to /tmp/foo/bar.txt
- * ensureSymlinkSync(join("/tmp", "foo", "bar.txt"), join("/tmp", "foo", "link-to-bar.txt"));
- *
- * // Ensure a directory symlink /tmp/foo/link-to-baz-dir points to /tmp/foo/baz-dir
- * ensureSymlinkSync(join("/tmp", "foo", "baz-dir"), join("/tmp", "foo", "link-to-baz-dir"), "dir");
- * ```
- */
-declare const ensureSymlinkSync: (target: URL | string, linkName: URL | string, type?: symlink.Type) => void;
-export default ensureSymlinkSync;

package/dist/ensure/ensure-symlink.d.ts

@@ -1,23 +0,0 @@
-import type { symlink as symlinkSync } from "node:fs";
-/**
- * Ensures that the link exists, and points to a valid file.
- * If the directory structure does not exist, it is created.
- * If the link already exists, it is not modified but error is thrown if it is not point to the given target.
- * @param target the source file path
- * @param linkName the destination link path
- * @param type the type of the symlink, or null to use automatic detection
- * @returns A void promise that resolves once the link exists.
- * @example
- * ```javascript
- * import { ensureSymlink } from "@visulima/fs";
- * import { join } from "node:path";
- *
- * // Ensure a symlink /tmp/foo/link-to-bar.txt points to /tmp/foo/bar.txt
- * await ensureSymlink(join("/tmp", "foo", "bar.txt"), join("/tmp", "foo", "link-to-bar.txt"));
- *
- * // Ensure a directory symlink /tmp/foo/link-to-baz-dir points to /tmp/foo/baz-dir
- * await ensureSymlink(join("/tmp", "foo", "baz-dir"), join("/tmp", "foo", "link-to-baz-dir"), "dir");
- * ```
- */
-declare const ensureSymlink: (target: URL | string, linkName: URL | string, type?: symlinkSync.Type) => Promise<void>;
-export default ensureSymlink;

package/dist/ensure/utils/get-file-info-type.d.ts

@@ -1,7 +0,0 @@
-import type { Stats } from "node:fs";
-export type PathType = "dir" | "file" | "symlink";
-/**
- * Get a human-readable file type string.
- * @param fileInfo A FileInfo describes a file and is returned by `stat`, `lstat`
- */
-export declare const getFileInfoType: (fileInfo: Stats) => PathType | undefined;

package/dist/ensure/utils/is-stats-identical.d.ts

@@ -1,3 +0,0 @@
-import type { Stats } from "node:fs";
-declare const isStatsIdentical: (sourceStat: Stats, destinationStat: Stats) => boolean;
-export default isStatsIdentical;