@reliverse/relifso 1.1.3 → 1.2.0

package/bin/impl/array-polyfill.d.ts

@@ -1,15 +0,0 @@
-// https://github.com/microsoft/TypeScript/issues/50803
-interface ArrayConstructor {
-  fromAsync<T>(
-    iterableOrArrayLike:
-      | AsyncIterable<T>
-      | Iterable<T | Promise<T>>
-      | ArrayLike<T | Promise<T>>,
-  ): Promise<T[]>;
-
-  fromAsync<T, U>(
-    iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>,
-    mapFn: (value: Awaited<T>) => U,
-    thisArg?: any,
-  ): Promise<Awaited<U>[]>;
-}

package/bin/impl/external/path-is-inside.d.ts

@@ -1 +0,0 @@
-export default function (thePath: string, potentialParent: string): boolean;

package/bin/impl/external/path-is-inside.js

@@ -1,16 +0,0 @@
-import { sep } from "node:path";
-export default function(thePath, potentialParent) {
-  thePath = stripTrailingSep(thePath);
-  potentialParent = stripTrailingSep(potentialParent);
-  if (process.platform === "win32") {
-    thePath = thePath.toLowerCase();
-    potentialParent = potentialParent.toLowerCase();
-  }
-  return thePath.lastIndexOf(potentialParent, 0) === 0 && (thePath[potentialParent.length] === sep || thePath[potentialParent.length] === void 0);
-}
-function stripTrailingSep(thePath) {
-  if (thePath[thePath.length - 1] === sep) {
-    return thePath.slice(0, -1);
-  }
-  return thePath;
-}

package/bin/impl/external/vacuum.d.ts

@@ -1,26 +0,0 @@
-import type { VacuumOptions, ErrorCallback } from "../../types.js";
-/**
- * Remove the empty branches of a directory tree, optionally up to (but not including) a specified base directory.
- * Optionally nukes the leaf directory.
- * @param directory Leaf node to remove. **Must be a directory, symlink, or file.**
- * @param options Options for `fs-vacuum`.
- * @param callback Function to call once vacuuming is complete.
- * @example ```
- * var logger = require("npmlog");
- * var vacuum = require("fs-vacuum");
- *
- * var options = {
- *   base  : "/path/to/my/tree/root",
- *   purge : true,
- *   log   : logger.silly.bind(logger, "myCleanup")
- * };
- *
- * // Assuming there are no other files or directories in "out", "to", or "my",
- * // the final path will just be "/path/to/my/tree/root".
- * vacuum("/path/to/my/tree/root/out/to/my/files", function (error) {
- *   if (error) console.error("Unable to cleanly vacuum:", error.message);
- * });
- * ```
- */
-export default function vacuum(directory: string, options?: VacuumOptions): Promise<void>;
-export default function vacuum(directory: string, options?: VacuumOptions, callback?: ErrorCallback): void;

package/bin/impl/external/vacuum.js

@@ -1,95 +0,0 @@
-import { lstat, readdir, unlink, rm, rmdir } from "graceful-fs";
-import assert from "node:assert";
-import { dirname } from "node:path";
-import { resolve } from "node:path";
-import isInside from "./path-is-inside.js";
-const noop = () => {
-};
-export default function vacuum(leaf, options = {}, cb) {
-  if (cb === void 0) {
-    return new Promise((resolve2, reject) => {
-      vacuum(leaf, options, (err) => err ? reject(err) : resolve2());
-    });
-  }
-  assert(typeof leaf === "string", "must pass in path to remove");
-  assert(typeof options === "object", "options must be an object");
-  assert(typeof cb === "function", "must pass in callback");
-  const log = options.log ?? noop;
-  leaf = leaf && resolve(leaf);
-  const base = options.base && resolve(options.base);
-  if (base && !isInside(leaf, base)) {
-    return cb(new Error(`${leaf} is not a child of ${base}`));
-  }
-  lstat(leaf, (error, stat) => {
-    if (error) {
-      if (error.code === "ENOENT") return cb(null);
-      log(error.stack);
-      return cb(error);
-    }
-    if (!(stat && (stat.isDirectory() || stat.isSymbolicLink() || stat.isFile()))) {
-      log(`${leaf} is not a directory, file, or link`);
-      return cb(new Error(`${leaf} is not a directory, file, or link`));
-    }
-    if (options.purge) {
-      log("purging", leaf);
-      rm(leaf, { recursive: true, force: true }, (error2) => {
-        if (error2) return cb(error2);
-        next(dirname(leaf));
-      });
-    } else if (!stat.isDirectory()) {
-      log("removing", leaf);
-      unlink(leaf, (error2) => {
-        if (error2) return cb(error2);
-        next(dirname(leaf));
-      });
-    } else {
-      next(leaf);
-    }
-  });
-  function next(branch) {
-    branch = branch && resolve(branch);
-    if (base && branch === base || branch === dirname(branch)) {
-      log("finished vacuuming up to", branch);
-      return cb(null);
-    }
-    readdir(branch, (error, files) => {
-      if (error) {
-        if (error.code === "ENOENT") return cb(null);
-        log("unable to check directory", branch, "due to", error.message);
-        return cb(error);
-      }
-      if (files.length > 0) {
-        log("quitting because other entries in", branch);
-        return cb(null);
-      }
-      if (branch === process.env.HOME) {
-        log("quitting because cannot remove home directory", branch);
-        return cb(null);
-      }
-      log("removing", branch);
-      lstat(branch, (error2, stat) => {
-        if (error2) {
-          if (error2.code === "ENOENT") return cb(null);
-          log("unable to lstat", branch, "due to", error2.message);
-          return cb(error2);
-        }
-        const remove = stat.isDirectory() ? rmdir : unlink;
-        remove(branch, (error3) => {
-          if (error3) {
-            if (error3.code === "ENOENT") {
-              log("quitting because lost the race to remove", branch);
-              return cb(null);
-            }
-            if (error3.code === "ENOTEMPTY" || error3.code === "EEXIST") {
-              log("quitting because new (racy) entries in", branch);
-              return cb(null);
-            }
-            log("unable to remove", branch, "due to", error3.message);
-            return cb(error3);
-          }
-          next(dirname(branch));
-        });
-      });
-    });
-  }
-}

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

@@ -1,8 +0,0 @@
-import type { DiveActionCallback, DiveActionPromise, DiveOptions } from '../../types.js';
-import * as fs from './index.js';
-export declare function _diveWorker(directory: string, options?: DiveOptions): AsyncGenerator<[file: string, stat: fs.Stats]>;
-export declare function dive(directory: string, options: DiveOptions, action: DiveActionCallback, complete: () => void): void;
-export declare function dive(directory: string, options: DiveOptions, action: DiveActionPromise): Promise<void>;
-export declare function dive(directory: string, action: DiveActionCallback, complete: () => void): void;
-export declare function dive(directory: string, action: DiveActionPromise): Promise<void>;
-export declare function diveSync(directory: string, options?: DiveOptions): string[];

package/bin/impl/fs/dive.js

@@ -1,91 +0,0 @@
-import { resolve as pathResolve } from "node:path";
-import * as fs from "./index.js";
-const DEFAULT_OPTS = { recursive: true, all: true, files: true };
-const matches = (str, test) => test ? typeof test === "string" ? str.includes(test) : test.test(str) : false;
-export async function* _diveWorker(directory, options = {}) {
-  const opts = { ...DEFAULT_OPTS, ...options };
-  const children = await fs.readdir(directory, { withFileTypes: true });
-  if (children.length === 0 && opts.directories) {
-    yield [directory, await fs.stat(directory)];
-  }
-  for (const dirent of children) {
-    if (!opts.all && dirent.name.startsWith(".")) continue;
-    const path = pathResolve(dirent.path ?? directory, dirent.name);
-    if (opts.ignore && matches(path, opts.ignore)) continue;
-    if (dirent.isDirectory()) {
-      if (opts.recursive) {
-        yield* _diveWorker(path, opts);
-      } else if (opts.directories) {
-        yield [path, await fs.stat(path)];
-      }
-    } else if (opts.files) {
-      yield [path, await fs.stat(path)];
-    }
-  }
-}
-async function _diveHelper(directory, action, options = {}) {
-  for await (const [file, stat] of _diveWorker(directory, options)) {
-    await action(file, stat);
-  }
-}
-async function _diveWorkerCallback(directory, action, options = {}) {
-  let children;
-  try {
-    children = await fs.readdir(directory, { withFileTypes: true });
-  } catch (err) {
-    action(err);
-    return;
-  }
-  if (children.length === 0 && options.directories) {
-    action(null, directory, await fs.stat(directory));
-  }
-  for (const dirent of children) {
-    if (!options.all && dirent.name.startsWith(".")) continue;
-    const path = pathResolve(dirent.path ?? directory, dirent.name);
-    if (options.ignore && matches(path, options.ignore)) continue;
-    try {
-      if (dirent.isDirectory()) {
-        if (options.recursive) {
-          await _diveWorkerCallback(path, action, options);
-        } else if (options.directories) {
-          action(null, path, await fs.stat(path));
-        }
-      } else if (options.files) {
-        action(null, path, await fs.stat(path));
-      }
-    } catch (err) {
-      action(err);
-    }
-  }
-}
-export function dive(directory, o1, o2, o3) {
-  const options = (typeof o1 === "object" ? o1 : void 0) ?? {};
-  const action = options === o1 ? o2 : o1;
-  const complete = options === o1 ? o3 : o2;
-  const opts = { ...DEFAULT_OPTS, ...options };
-  if (!complete) {
-    return _diveHelper(directory, action, opts);
-  }
-  void _diveWorkerCallback(directory, action, opts).finally(
-    complete
-  );
-}
-function* _diveSyncWorker(directory, options = {}) {
-  const opts = { ...DEFAULT_OPTS, ...options };
-  const children = fs.readdirSync(directory, { withFileTypes: true });
-  if (children.length === 0 && opts.directories) yield directory;
-  for (const dirent of children) {
-    if (!opts.all && dirent.name.startsWith(".")) continue;
-    const path = pathResolve(dirent.path ?? directory, dirent.name);
-    if (opts.ignore && matches(path, opts.ignore)) continue;
-    if (dirent.isDirectory()) {
-      if (opts.recursive) yield* _diveSyncWorker(path, opts);
-      else if (opts.directories) yield path;
-    } else if (opts.files) {
-      yield path;
-    }
-  }
-}
-export function diveSync(directory, options = {}) {
-  return [..._diveSyncWorker(directory, options)];
-}

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

@@ -1,31 +0,0 @@
-/**
- * Test whether or not the given path exists by checking with the file system. Like
- * [`fs.exists`](https://nodejs.org/api/fs.html#fs_fs_exists_path_callback), but with a normal
- * callback signature (err, exists). Uses `fs.access` under the hood.
- *
- * @example
- * import * as fs from 'fs-extra'
- *
- * const file = '/tmp/this/path/does/not/exist/file.txt'
- *
- * // With a callback:
- * fs.pathExists(file, (err, exists) => {
- *   console.log(err) // => null
- *   console.log(exists) // => false
- * })
- *
- * // Promise usage:
- * fs.pathExists(file)
- *   .then(exists => console.log(exists)) // => false
- *
- * // With async/await:
- * async function asyncAwait () {
- *   const exists = await fs.pathExists(file)
- *
- *   console.log(exists) // => false
- * }
- *
- * asyncAwait()
- */
-export declare function exists(path: string): Promise<boolean>;
-export declare function exists(path: string, callback: (err: NodeJS.ErrnoException | null, exists: boolean) => void): void;

package/bin/impl/fs/exists.js

@@ -1,10 +0,0 @@
-import { access } from "./index.js";
-export function exists(path, callback) {
-  if (callback) {
-    return access(path, (err) => callback(null, !err));
-  }
-  return access(path).then(
-    () => true,
-    () => false
-  );
-}

package/bin/impl/fs/for-each-child.d.ts

@@ -1,34 +0,0 @@
-import type { ErrorCallback } from "../../types.js";
-/**
- * Iterate through every child of a folder, asynchronously. This function will not recurse into subdirectories.
- * @param path folder path to iterate through
- * @param options options to pass through to [[readdir]]
- * @param func iterate function, called for every child
- * @param callback function to call after the operation finishes
- */
-export declare function forEachChild(path: string, options: {
-    encoding: BufferEncoding | null;
-} | BufferEncoding | null | undefined | Record<string, never>, func: (filename: string) => void | Promise<void>): Promise<void>;
-export declare function forEachChild(path: string, options: {
-    encoding: "buffer";
-} | "buffer", func: (filename: Buffer) => void | Promise<void>): Promise<void>;
-export declare function forEachChild(path: string, func: (filename: string) => void | Promise<void>): Promise<void>;
-export declare function forEachChild(path: string, options: {
-    encoding: BufferEncoding | null;
-} | BufferEncoding | null | undefined | Record<string, never>, func: (filename: string) => void, callback: ErrorCallback): void;
-export declare function forEachChild(path: string, options: {
-    encoding: "buffer";
-} | "buffer", func: (filename: Buffer) => void, callback: ErrorCallback): void;
-export declare function forEachChild(path: string, func: (filename: string) => void, callback: ErrorCallback): void;
-/**
- * Iterate through every child of a folder, synchronously. This function will not recurse into subdirectories.
- * @param path folder path to iterate through
- * @param func iterate function, called for every child
- * @param options options to pass through to [[readdirSync]]
- */
-export declare function forEachChildSync(path: string, func: (filename: string) => void, options: {
-    encoding: BufferEncoding | null;
-} | BufferEncoding | null | undefined | Record<string, never>): void;
-export declare function forEachChildSync(path: string, func: (filename: Buffer) => void, options?: {
-    encoding: "buffer";
-} | "buffer"): void;

package/bin/impl/fs/for-each-child.js

@@ -1,37 +0,0 @@
-import * as fs from "./index.js";
-async function _forEachChildHelper(path, options, func) {
-  const children = await fs.readdir(path, options);
-  for (const child of children) {
-    const ret = func(child);
-    if (ret instanceof Promise) {
-      await ret;
-    }
-  }
-}
-export function forEachChild(path, o1, o2, o3) {
-  const options = typeof o1 == "object" ? o1 : void 0;
-  const func = !options ? o1 : o2;
-  const callback = !options ? o2 : o3;
-  if (!callback) {
-    return _forEachChildHelper(path, options, func);
-  }
-  fs.readdir(path, options, (err, children) => {
-    if (err) {
-      callback(err);
-    } else {
-      for (const child of children) {
-        func(child);
-      }
-      callback();
-    }
-  });
-}
-export function forEachChildSync(path, func, options) {
-  const children = fs.readdirSync(
-    path,
-    options
-  );
-  for (const child of children) {
-    func(child);
-  }
-}