@reliverse/relifso 1.1.2 → 1.2.0

package/bin/impl/fs/index.js

@@ -1,66 +0,0 @@
-import * as gfs from "graceful-fs";
-export * from "graceful-fs";
-import rfs from "node:fs";
-import { universalify } from "./universalify.js";
-export const rename = universalify(gfs.rename);
-export const truncate = universalify(gfs.truncate);
-export const ftruncate = universalify(gfs.ftruncate);
-export const chown = universalify(gfs.chown);
-export const fchown = universalify(gfs.fchown);
-export const lchown = universalify(gfs.lchown);
-export const lutimes = universalify(gfs.lutimes);
-export const chmod = universalify(gfs.chmod);
-export const fchmod = universalify(gfs.fchmod);
-export const lchmod = universalify(gfs.lchmod);
-export const stat = universalify(
-  gfs.stat
-);
-export const fstat = universalify(gfs.fstat);
-export const lstat = universalify(gfs.lstat);
-export const statfs = universalify(gfs.statfs);
-export const link = universalify(
-  gfs.link
-);
-export const symlink = universalify(gfs.symlink);
-export const readlink = universalify(gfs.readlink);
-export const realpath = universalify(gfs.realpath);
-export const unlink = universalify(gfs.unlink);
-export const rmdir = universalify(gfs.rmdir);
-export const rm = universalify(
-  gfs.rm
-);
-export const mkdir = universalify(gfs.mkdir);
-export const mkdtemp = universalify(gfs.mkdtemp);
-export const readdir = universalify(gfs.readdir);
-export const close = universalify(gfs.close);
-export const open = universalify(
-  gfs.open
-);
-export const utimes = universalify(gfs.utimes);
-export const futimes = universalify(gfs.futimes);
-export const write = universalify(gfs.write, (bytesWritten, buffer) => ({ bytesWritten, buffer }));
-export const read = universalify(
-  gfs.read,
-  (bytesRead, buffer) => ({ bytesRead, buffer })
-);
-export const readFile = universalify(gfs.readFile);
-export const writeFile = universalify(gfs.writeFile);
-export const appendFile = universalify(gfs.appendFile);
-export const access = universalify(gfs.access);
-export const copyFile = universalify(gfs.copyFile);
-export const writev = universalify(gfs.writev, (bytesWritten, buffers) => ({
-  bytesWritten,
-  buffers
-}));
-export const readv = universalify(gfs.readv, (bytesRead, buffers) => ({ bytesRead, buffers }));
-export const opendir = universalify(gfs.opendir);
-export const cp = universalify(gfs.cp);
-if (typeof rfs.realpath.native === "function") {
-  realpath.native = universalify(rfs.realpath.native);
-} else {
-  process.emitWarning(
-    "fs.realpath.native is not a function. Is fs being monkey-patched?",
-    "Warning",
-    "fs-extra-WARN0003"
-  );
-}

package/bin/impl/fs/is-directory.d.ts

@@ -1,14 +0,0 @@
-/**
- * Check if the file at a path is a directory.
- * @param path the path to the file to check
- * @param callback callback function to call with whether or not the file is a directory, or a value for `err` if the
- * operation fails
- */
-export declare function isDirectory(path: string, callback: (err: NodeJS.ErrnoException | null, text?: boolean) => void): void;
-export declare function isDirectory(path: string): Promise<boolean>;
-/**
- * Check if the file at a path is a directory.
- * @param path the path to the file to check
- * @returns whether or not the file is a directory
- */
-export declare function isDirectorySync(path: string): boolean;

package/bin/impl/fs/is-directory.js

@@ -1,16 +0,0 @@
-import * as fs from "./index.js";
-async function _isDirectoryHelper(path) {
-  return (await fs.stat(path)).isDirectory();
-}
-export function isDirectory(path, callback) {
-  if (!callback) {
-    return _isDirectoryHelper(path);
-  }
-  fs.stat(path, (err, stats) => {
-    if (err) return callback(err);
-    callback(null, stats.isDirectory());
-  });
-}
-export function isDirectorySync(path) {
-  return fs.statSync(path).isDirectory();
-}

package/bin/impl/fs/map-children.d.ts

@@ -1,17 +0,0 @@
-import type { MapChildrenFunction } from "../../types.js";
-import * as fs from "./index.js";
-/**
- * Iterate through every file child of a folder, call a mapper function with each file's contents and write the returned
- * value of the mapper to the files. This will not recurse into subdirectories.
- * @param path folder path to iterate through
- * @param mapper mapping function to call on each file
- * @param readOptions options to pass to [[readFile]]
- * @param writeOptions options to pass to [[writeFile]]
- * @returns a [[Promise]] resolving to an array of the children files, once the mapping is finished.
- */
-export declare function mapChildren(path: string, mapper: MapChildrenFunction<string>, readOptions: {
-    encoding: BufferEncoding;
-} | BufferEncoding, writeOptions?: fs.WriteFileOptions | BufferEncoding): Promise<string[]>;
-export declare function mapChildren(path: string, mapper: MapChildrenFunction<Buffer>, readOptions?: {
-    encoding?: null | "buffer";
-} | "buffer" | null, writeOptions?: fs.WriteFileOptions | BufferEncoding): Promise<string[]>;

package/bin/impl/fs/map-children.js

@@ -1,31 +0,0 @@
-import { Array_fromAsync } from "../helpers.js";
-import * as fs from "./index.js";
-import { isDirectory } from "./is-directory.js";
-async function* _asyncFilter(iterable, condition) {
-  let i = 0;
-  for (const value of iterable) {
-    if (await condition(value, i++, iterable)) {
-      yield value;
-    }
-  }
-}
-export async function mapChildren(path, mapper, readOptions, writeOptions) {
-  const children = await Array_fromAsync(
-    _asyncFilter(
-      (await fs.readdir(path)).map((child) => path + "/" + child),
-      async (e) => !await isDirectory(e)
-    )
-  );
-  for (const e of children) {
-    const contents = await fs.readFile(e, readOptions);
-    const filename = e.slice(e.lastIndexOf("/") + 1);
-    let result = mapper(contents, filename, path, e);
-    if (result instanceof Promise) {
-      result = await result;
-    }
-    if (result != contents) {
-      await fs.writeFile(e, result, writeOptions);
-    }
-  }
-  return children;
-}

package/bin/impl/fs/map-structure.d.ts

@@ -1,35 +0,0 @@
-import type { MapStructureResult, MapStructureFunction } from "../../types.js";
-import * as fs from "./index.js";
-/**
- * Iterate through every file child of a folder recursively, call a mapper function with each file's contents and write
- * the returned value of the mapper to the files. **when passing [[MapStructureFunctionAsync]] as a parameter,
- * operations are done in parallel; to avoid running out of file handles, or to maintain the order (as provided by
- * `dive`), use [[mapStructureOrdered]].**
- * @param path folder path to iterate through
- * @param mapper mapping function to call on each file
- * @param readOptions options to pass to [[readFile]]
- * @param writeOptions options to pass to [[writeFile]]
- * @returns a [[Promise]] resolving to an array of all processed files
- */
-export declare function mapStructure(path: string, mapper: MapStructureFunction<string>, readOptions: {
-    encoding: BufferEncoding;
-} | BufferEncoding, writeOptions?: fs.WriteFileOptions | BufferEncoding): Promise<MapStructureResult[]>;
-export declare function mapStructure(path: string, mapper: MapStructureFunction<Buffer>, readOptions?: {
-    encoding?: null | "buffer";
-} | "buffer" | null, writeOptions?: fs.WriteFileOptions | BufferEncoding): Promise<MapStructureResult[]>;
-/**
- * Iterate through every file child of a folder recursively, call a mapper function with each file's contents and write
- * the returned value of the mapper to the files. **Mapper functions are invoked one at a time; to run them all at once,
- * use [[mapStructure]].**
- * @param path folder path to iterate through
- * @param mapper mapping function to call on each file
- * @param readOptions options to pass to [[readFile]]
- * @param writeOptions options to pass to [[writeFile]]
- * @returns a [[Promise]] resolving to an array of all processed files
- */
-export declare function mapStructureOrdered(path: string, mapper: MapStructureFunction<string>, readOptions: {
-    encoding: BufferEncoding;
-} | BufferEncoding, writeOptions?: fs.WriteFileOptions | BufferEncoding): Promise<MapStructureResult[]>;
-export declare function mapStructureOrdered(path: string, mapper: MapStructureFunction<Buffer>, readOptions?: {
-    encoding?: null | "buffer";
-} | "buffer" | null, writeOptions?: fs.WriteFileOptions | BufferEncoding): Promise<MapStructureResult[]>;

package/bin/impl/fs/map-structure.js

@@ -1,44 +0,0 @@
-import { _diveWorker, dive } from "./dive.js";
-import * as fs from "./index.js";
-async function _mapStructureProcessFile(file, stat, mapper, readOptions, writeOptions) {
-  const contents = await fs.readFile(file, readOptions);
-  let result = mapper(contents, file, stat);
-  if (result instanceof Promise) {
-    result = await result;
-  }
-  if (result != contents) {
-    await fs.writeFile(file, result, writeOptions);
-  }
-}
-export async function mapStructure(path, mapper, readOptions, writeOptions) {
-  const promiseArr = [];
-  const results = [];
-  await dive(path, { all: true }, (file, stat) => {
-    promiseArr.push(
-      _mapStructureProcessFile(
-        file,
-        stat,
-        mapper,
-        readOptions,
-        writeOptions
-      )
-    );
-    results.push({ file, stat });
-  });
-  await Promise.all(promiseArr);
-  return results;
-}
-export async function mapStructureOrdered(path, mapper, readOptions, writeOptions) {
-  const entries = [];
-  for await (const [file, stat] of _diveWorker(path)) {
-    entries.push({ file, stat });
-    await _mapStructureProcessFile(
-      file,
-      stat,
-      mapper,
-      readOptions,
-      writeOptions
-    );
-  }
-  return entries;
-}

package/bin/impl/fs/read-lines.d.ts

@@ -1,16 +0,0 @@
-/**
- * Read a file into a string array of its lines.
- * @param path the path to the file to read
- * @param encoding the encoding to use to read the file
- * @param callback callback function to call with the file's lines, or a value for `err` if the operation fails
- */
-export declare function readLines(path: string, encoding: BufferEncoding, callback: (err: NodeJS.ErrnoException | null, lines?: string[]) => void): void;
-export declare function readLines(path: string, callback: (err: NodeJS.ErrnoException | null, lines?: string[]) => void): void;
-export declare function readLines(path: string, encoding?: BufferEncoding): Promise<string[]>;
-/**
- * Synchronously read a file into a string array of its lines.
- * @param path the path to the file to read
- * @param encoding the encoding to use to read the file, default is UTF-8
- * @returns the file's lines
- */
-export declare function readLinesSync(path: string, encoding?: BufferEncoding): string[];

package/bin/impl/fs/read-lines.js

@@ -1,32 +0,0 @@
-import * as fs from "./index.js";
-function _readLinesHelper(path, encoding, resolve, reject) {
-  fs.readFile(path, encoding, (err, data) => {
-    if (err) {
-      reject(err);
-    } else if (data.indexOf("\r\n") > -1) {
-      resolve(data.split("\r\n"));
-    } else if (data.indexOf("\n") > -1) {
-      resolve(data.split("\n"));
-    } else resolve([data]);
-  });
-}
-export function readLines(path, o1, o2) {
-  const encoding = typeof o1 == "string" ? o1 : "utf8";
-  const callback = typeof o1 == "string" ? o2 : o1;
-  if (!callback) {
-    return new Promise((resolve, reject) => {
-      _readLinesHelper(path, encoding, resolve, reject);
-    });
-  }
-  _readLinesHelper(path, encoding, (e) => callback(null, e), callback);
-}
-export function readLinesSync(path, encoding = "utf8") {
-  const data = fs.readFileSync(path, encoding);
-  if (data.indexOf("\r\n") > -1) {
-    return data.split("\r\n");
-  }
-  if (data.indexOf("\n") > -1) {
-    return data.split("\n");
-  }
-  return [data];
-}

package/bin/impl/fs/read-text.d.ts

@@ -1,13 +0,0 @@
-/**
- * Shorter version of [[readFile]] where the encoding is UTF-8.
- * @param path the path to the file to read
- * @param callback callback function to call with the file's text contents, or a value for `err` if the operation fails
- */
-export declare function readText(path: string, callback: (err: NodeJS.ErrnoException | null, text: string) => void): void;
-export declare function readText(path: string): Promise<string>;
-/**
- * Shorter version of [[readFileSync]] where the encoding is UTF-8.
- * @param path the path to the file to read
- * @returns the file's text contents
- */
-export declare function readTextSync(path: string): string;

package/bin/impl/fs/read-text.js

@@ -1,10 +0,0 @@
-import * as fs from "./index.js";
-export function readText(path, callback) {
-  if (!callback) {
-    return fs.readFile(path, "utf8");
-  }
-  fs.readFile(path, "utf8", callback);
-}
-export function readTextSync(path) {
-  return fs.readFileSync(path, "utf8");
-}

package/bin/impl/fs/universalify.d.ts

@@ -1,18 +0,0 @@
-import { type CustomPromisify } from "node:util";
-type LastElement<Arr extends any[]> = Arr extends [...any[], infer B] ? B : never;
-type CallbackArgs<T extends (...args: any) => any> = LastElement<Parameters<T>> extends (err: any, ...cbArgs: infer CbArgs) => void ? CbArgs : never;
-export declare function universalify<TFunction extends CustomPromisify<TCustom> & ((...args: any) => any), TCustom extends (...args: any) => any>(fn: TFunction & CustomPromisify<TCustom>, fallbackMultiResultObjectCreator: (...args: CallbackArgs<TFunction>) => Awaited<ReturnType<TCustom>>): TFunction & TCustom;
-export declare function universalify<A extends unknown[], X extends (...args: any[]) => any, R extends any[], F>(fn: X & ((...args: [...A, (err: any, ...cbArgs: R) => void]) => void), fallbackMultiResultObjectCreator: (...args: R) => F): {
-    (...args: Parameters<X>): void;
-    (...args: A): Promise<F>;
-};
-export declare function universalify<TFunction extends CustomPromisify<TCustom>, TCustom extends (...args: any) => any>(fn: TFunction & CustomPromisify<TCustom>): TFunction & TCustom;
-export declare function universalify<A extends unknown[], X extends (...args: any[]) => any, R>(fn: X & ((...args: [...A, (err: any, result: R) => void]) => void)): {
-    (...args: Parameters<X>): void;
-    (...args: A): Promise<R>;
-};
-export declare function universalify<A extends unknown[], X extends (...args: any[]) => any, R>(fn: X & ((...args: [...A, (err?: any) => void]) => void)): {
-    (...args: Parameters<X>): void;
-    (...args: A): Promise<void>;
-};
-export {};

package/bin/impl/fs/universalify.js

@@ -1,38 +0,0 @@
-import { promisify } from "node:util";
-const universalifiedSymbol = Symbol();
-export function universalify(fn, fallbackMultiResultObjectCreator) {
-  if (!fn) return fn;
-  if (universalifiedSymbol in fn) {
-    return fn[universalifiedSymbol];
-  }
-  const promisified = fallbackMultiResultObjectCreator ? promisifyFallback(fn, fallbackMultiResultObjectCreator) : promisify(fn);
-  const f = (...args) => {
-    const cb = args[args.length - 1];
-    if (typeof cb === "function") {
-      return fn(...args);
-    }
-    return promisified(...args);
-  };
-  const attr = {
-    value: f,
-    enumerable: false,
-    writable: false,
-    configurable: true
-  };
-  Object.defineProperty(fn, universalifiedSymbol, attr);
-  Object.defineProperty(f, universalifiedSymbol, attr);
-  return f;
-}
-function promisifyFallback(fn, fallbackObjectCreator) {
-  if ("__promisify__" in fn || promisify.custom in fn) {
-    return promisify(fn);
-  }
-  return (...args) => {
-    return new Promise((resolve, reject) => {
-      fn(...args, (err, ...results) => {
-        if (err) reject(err);
-        resolve(fallbackObjectCreator(...results));
-      });
-    });
-  };
-}

package/bin/impl/fs/write-file.d.ts

@@ -1,93 +0,0 @@
-import type * as streamWeb from "node:stream/web";
-import type * as fs from "./index.js";
-/**
- * When `file` is a filename, asynchronously writes data to the file, replacing the
- * file if it already exists. `data` can be a string or a buffer.
- *
- * When `file` is a file descriptor, the behavior is similar to calling`fs.write()` directly (which is recommended). See the notes below on using
- * a file descriptor.
- *
- * The `encoding` option is ignored if `data` is a buffer.
- *
- * The `mode` option only affects the newly created file. See {@link open} for more details.
- *
- * ```js
- * import { writeFile } from 'node:fs';
- * import { Buffer } from 'node:buffer';
- *
- * const data = new Uint8Array(Buffer.from('Hello Node.js'));
- * writeFile('message.txt', data, (err) => {
- *   if (err) throw err;
- *   console.log('The file has been saved!');
- * });
- * ```
- *
- * If `options` is a string, then it specifies the encoding:
- *
- * ```js
- * import { writeFile } from 'node:fs';
- *
- * writeFile('message.txt', 'Hello Node.js', 'utf8', callback);
- * ```
- *
- * It is unsafe to use `fs.writeFile()` multiple times on the same file without
- * waiting for the callback. For this scenario, {@link createWriteStream} is
- * recommended.
- *
- * Similarly to `fs.readFile` \- `fs.writeFile` is a convenience method that
- * performs multiple `write` calls internally to write the buffer passed to it.
- * For performance sensitive code consider using {@link createWriteStream}.
- *
- * It is possible to use an `AbortSignal` to cancel an `fs.writeFile()`.
- * Cancelation is "best effort", and some amount of data is likely still
- * to be written.
- *
- * ```js
- * import { writeFile } from 'node:fs';
- * import { Buffer } from 'node:buffer';
- *
- * const controller = new AbortController();
- * const { signal } = controller;
- * const data = new Uint8Array(Buffer.from('Hello Node.js'));
- * writeFile('message.txt', data, { signal }, (err) => {
- *   // When a request is aborted - the callback is called with an AbortError
- * });
- * // When the request should be aborted
- * controller.abort();
- * ```
- *
- * Aborting an ongoing request does not abort individual operating
- * system requests but rather the internal buffering `fs.writeFile` performs.
- * @since v0.1.29
- * @param file filename or file descriptor
- * @param data The data to write. If a stream is provided, it will be read to completion.
- * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
- * If `encoding` is not supplied, the default of `'utf8'` is used.
- * If `mode` is not supplied, the default of `0o666` is used.
- * If `mode` is a string, it is parsed as an octal integer.
- * If `flag` is not supplied, the default of `'w'` is used.
- * @since Web Streams API support since Node v17.0.0
- */
-export declare function writeFile(file: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer | NodeJS.ReadableStream | streamWeb.ReadableStream, options: fs.WriteFileOptions, callback: fs.NoParamCallback): void;
-/**
- * Asynchronously writes data to a file, replacing the file if it already exists.
- * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
- * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
- * @param data The data to write. If a stream is provided, it will be read to completion.
- * @since Web Streams API support since Node v17.0.0
- */
-export declare function writeFile(path: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer | NodeJS.ReadableStream | streamWeb.ReadableStream, callback: fs.NoParamCallback): void;
-/**
- * Asynchronously writes data to a file, replacing the file if it already exists.
- * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
- * URL support is _experimental_.
- * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
- * @param data The data to write. If a stream is provided, it will be read to completion.
- * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
- * If `encoding` is not supplied, the default of `'utf8'` is used.
- * If `mode` is not supplied, the default of `0o666` is used.
- * If `mode` is a string, it is parsed as an octal integer.
- * If `flag` is not supplied, the default of `'w'` is used.
- * @since Web Streams API support since Node v17.0.0
- */
-export declare function writeFile(path: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer | NodeJS.ReadableStream | streamWeb.ReadableStream, options?: fs.WriteFileOptions): Promise<void>;

package/bin/impl/fs/write-file.js

@@ -1,47 +0,0 @@
-import { createWriteStream, writeFile as _writeFile } from "graceful-fs";
-import { Readable, isReadable } from "node:stream";
-import { finished } from "node:stream/promises";
-import { ReadableStream } from "node:stream/web";
-import { fromPromise } from "universalify";
-import { universalify } from "./universalify.js";
-const backingWriteFile = universalify(_writeFile);
-const _writeFileStreamHelper = fromPromise(
-  async (path, data, options) => {
-    function getOptions(options2) {
-      return options2 ? typeof options2 === "string" ? { encoding: options2 } : {
-        encoding: options2.encoding || void 0,
-        mode: typeof options2.mode === "string" ? Number.parseInt(options2.mode, 8) : options2.mode,
-        flush: options2.flush
-      } : void 0;
-    }
-    let stream;
-    if (typeof path === "number") {
-      stream = createWriteStream("", { ...getOptions(options), fd: path });
-    } else {
-      stream = createWriteStream(path, getOptions(options));
-    }
-    await finished(data.pipe(stream));
-  }
-);
-export function writeFile(path, data, optionsOrCallback, optionalCallback) {
-  const options = typeof optionsOrCallback !== "function" ? optionsOrCallback : void 0;
-  const callback = optionalCallback ?? (typeof optionsOrCallback === "function" ? optionsOrCallback : void 0);
-  if (data instanceof ReadableStream) {
-    data = Readable.fromWeb(data);
-  }
-  if (isNodeReadableStream(data)) {
-    return _writeFileStreamHelper(path, data, options, callback);
-  }
-  if (data instanceof SharedArrayBuffer || data instanceof ArrayBuffer) {
-    data = new Uint8Array(data);
-  }
-  return backingWriteFile(
-    path,
-    data,
-    optionsOrCallback,
-    optionalCallback
-  );
-}
-function isNodeReadableStream(stream) {
-  return typeof stream === "object" && "readable" in stream && isReadable(stream);
-}

package/bin/impl/helpers.d.ts

@@ -1 +0,0 @@
-export declare const Array_fromAsync: any;

package/bin/impl/helpers.js

@@ -1,37 +0,0 @@
-export const Array_fromAsync = Array.fromAsync ?? async function fromAsync(iterableOrArrayLike, mapperFn) {
-  const items = [];
-  if (mapperFn) {
-    if (Symbol.asyncIterator in iterableOrArrayLike) {
-      for await (const item of iterableOrArrayLike) {
-        items.push(await mapperFn(item));
-      }
-    } else if (Symbol.iterator in iterableOrArrayLike) {
-      for (const item of iterableOrArrayLike) {
-        items.push(await mapperFn(await item));
-      }
-    } else {
-      const length = iterableOrArrayLike.length;
-      for (let i = 0; i < length; i++) {
-        const item = await iterableOrArrayLike[i];
-        items.push(await mapperFn(item));
-      }
-    }
-  } else {
-    if (Symbol.asyncIterator in iterableOrArrayLike) {
-      for await (const item of iterableOrArrayLike) {
-        items.push(item);
-      }
-    } else if (Symbol.iterator in iterableOrArrayLike) {
-      for (const item of iterableOrArrayLike) {
-        items.push(await item);
-      }
-    } else {
-      const length = iterableOrArrayLike.length;
-      for (let i = 0; i < length; i++) {
-        const item = await iterableOrArrayLike[i];
-        items.push(item);
-      }
-    }
-  }
-  return items;
-};

package/bin/impl/json.d.ts

@@ -1,16 +0,0 @@
-import type { JsonOutputOptions } from 'fs-extra';
-import type { ReadCallback, WriteCallback } from 'jsonfile';
-import type { JsonReadOptions, JsonWriteOptions } from '../types.js';
-import * as fs from './fs/index.js';
-export declare function readJson(file: fs.PathOrFileDescriptor, options: JsonReadOptions, callback: ReadCallback): void;
-export declare function readJson(file: fs.PathOrFileDescriptor, callback: ReadCallback): void;
-export declare function readJson<T>(file: fs.PathOrFileDescriptor, options?: JsonReadOptions): Promise<T>;
-export declare function readJsonSync<T = any>(file: fs.PathOrFileDescriptor, options?: JsonReadOptions): T | null;
-export declare function writeJson(file: fs.PathOrFileDescriptor, obj: unknown, options: JsonWriteOptions, callback: WriteCallback): void;
-export declare function writeJson(file: fs.PathOrFileDescriptor, obj: unknown, callback: WriteCallback): void;
-export declare function writeJson(file: fs.PathOrFileDescriptor, obj: unknown, options?: JsonWriteOptions): Promise<void>;
-export declare function writeJsonSync(file: fs.PathOrFileDescriptor, obj: unknown, options?: JsonWriteOptions): void;
-export declare function outputJson(file: string, data: unknown, options?: JsonOutputOptions): Promise<void>;
-export declare function outputJson(file: string, data: unknown, options: JsonOutputOptions, callback: fs.NoParamCallback): void;
-export declare function outputJson(file: string, data: unknown, callback: fs.NoParamCallback): void;
-export declare function outputJsonSync(file: string, data: unknown, options?: JsonOutputOptions): void;

package/bin/impl/json.js

@@ -1,90 +0,0 @@
-import { readFileSync, writeFileSync } from "graceful-fs";
-import * as fs from "./fs/index.js";
-import { universalify } from "./fs/universalify.js";
-import { outputFile, outputFileSync } from "./lib/output-file/index.js";
-const stripBom = (content) => Buffer.isBuffer(content) ? content.toString("utf8").replace(/^\uFEFF/, "") : content.replace(/^\uFEFF/, "");
-const stringify = (obj, {
-  EOL = "\n",
-  finalEOL = true,
-  replacer,
-  spaces
-}) => {
-  const eof = finalEOL ? EOL : "";
-  return JSON.stringify(obj, replacer, spaces).replace(/\n/g, EOL) + eof;
-};
-async function _readJson(file, options = {}) {
-  if (typeof options === "string") options = { encoding: options };
-  const read = options.fs?.readFile ? universalify(options.fs.readFile) : fs.readFile;
-  const data = stripBom(await read(file, options));
-  try {
-    return JSON.parse(data, options.reviver);
-  } catch (err) {
-    if (options.throws ?? true) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      e.message = `${file}: ${e.message}`;
-      throw e;
-    }
-    return null;
-  }
-}
-export function readJson(file, o1, o2) {
-  const options = typeof o1 === "object" ? o1 : void 0;
-  const cb = typeof o1 === "function" ? o1 : o2;
-  if (!cb) return _readJson(file, options);
-  void _readJson(file, options).then(
-    (res) => cb(null, res),
-    (err) => cb(err, void 0)
-  );
-}
-export function readJsonSync(file, options = {}) {
-  if (typeof options === "string") options = { encoding: options };
-  const read = options.fs?.readFileSync ?? readFileSync;
-  try {
-    const data = stripBom(read(file, options));
-    return JSON.parse(data, options.reviver);
-  } catch (err) {
-    if (options.throws ?? true) {
-      const e = err instanceof Error ? err : new Error(String(err));
-      e.message = `${file}: ${e.message}`;
-      throw e;
-    }
-    return null;
-  }
-}
-async function _writeJson(file, obj, options = {}) {
-  if (typeof options === "string") options = { encoding: options };
-  const write = options.fs?.writeFile ? universalify(options.fs.writeFile) : fs.writeFile;
-  await write(file, stringify(obj, options), options);
-}
-export function writeJson(file, obj, o1, o2) {
-  const options = typeof o1 === "object" ? o1 : void 0;
-  const cb = typeof o1 === "function" ? o1 : o2;
-  if (!cb) return _writeJson(file, obj, options);
-  void _writeJson(file, obj, options).then(
-    () => cb(null),
-    (err) => cb(err)
-  );
-}
-export function writeJsonSync(file, obj, options = {}) {
-  if (typeof options === "string") options = { encoding: options };
-  const write = options.fs?.writeFileSync ?? writeFileSync;
-  write(file, stringify(obj, options), options);
-}
-export function outputJson(file, data, o1, o2) {
-  const options = typeof o1 === "object" ? o1 : {};
-  const cb = typeof o1 === "function" ? o1 : o2;
-  if (cb) {
-    return outputFile(file, stringify(data, options), options, cb);
-  }
-  return new Promise((res, rej) => {
-    outputFile(
-      file,
-      stringify(data, options),
-      options,
-      (err) => err ? rej(err) : res()
-    );
-  });
-}
-export function outputJsonSync(file, data, options = {}) {
-  outputFileSync(file, stringify(data, options), options);
-}