123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
/** Options for {@linkcode exists} and {@linkcode existsSync.} */export interface ExistsOptions {  /**   * When `true`, will check if the path is readable by the user as well.   *   * @default {false}   */  isReadable?: boolean;  /**   * When `true`, will check if the path is a directory as well. Directory   * symlinks are included.   *   * @default {false}   */  isDirectory?: boolean;  /**   * When `true`, will check if the path is a file as well. File symlinks are   * included.   *   * @default {false}   */  isFile?: boolean;}
/** * Asynchronously test whether or not the given path exists by checking with * the file system. * * Note: Do not use this function if performing a check before another operation * on that file. Doing so creates a race condition. Instead, perform the actual * file operation directly. This function is not recommended for this use case. * See the recommended method below. * * @see https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use * * @param path The path to the file or directory, as a string or URL. * @param options Additional options for the check. * @returns A promise that resolves with `true` if the path exists, `false` * otherwise. * * @example Recommended method * ```ts * // Notice no use of exists * try { *   await Deno.remove("./foo", { recursive: true }); * } catch (error) { *   if (!(error instanceof Deno.errors.NotFound)) { *     throw error; *   } *   // Do nothing... * } * ``` * * Notice that `exists()` is not used in the above example. Doing so avoids a * possible race condition. See the above section for details. * * @example Basic usage * ```ts * import { exists } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * await exists("./exists"); // true * await exists("./does_not_exist"); // false * ``` * * @example Check if a path is readable * ```ts * import { exists } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * await exists("./readable", { isReadable: true }); // true * await exists("./not_readable", { isReadable: true }); // false * ``` * * @example Check if a path is a directory * ```ts * import { exists } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * await exists("./directory", { isDirectory: true }); // true * await exists("./file", { isDirectory: true }); // false * ``` * * @example Check if a path is a file * ```ts * import { exists } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * await exists("./file", { isFile: true }); // true * await exists("./directory", { isFile: true }); // false * ``` * * @example Check if a path is a readable directory * ```ts * import { exists } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * await exists("./readable_directory", { isReadable: true, isDirectory: true }); // true * await exists("./not_readable_directory", { isReadable: true, isDirectory: true }); // false * ``` * * @example Check if a path is a readable file * ```ts * import { exists } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * await exists("./readable_file", { isReadable: true, isFile: true }); // true * await exists("./not_readable_file", { isReadable: true, isFile: true }); // false * ``` */export async function exists(  path: string | URL,  options?: ExistsOptions,): Promise<boolean> {  try {    const stat = await Deno.stat(path);    if (      options &&      (options.isReadable || options.isDirectory || options.isFile)    ) {      if (options.isDirectory && options.isFile) {        throw new TypeError(          "ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together.",        );      }      if (        (options.isDirectory && !stat.isDirectory) ||        (options.isFile && !stat.isFile)      ) {        return false;      }      if (options.isReadable) {        if (stat.mode === null) {          return true; // Exclusive on Non-POSIX systems        }        if (Deno.uid() === stat.uid) {          return (stat.mode & 0o400) === 0o400; // User is owner and can read?        } else if (Deno.gid() === stat.gid) {          return (stat.mode & 0o040) === 0o040; // User group is owner and can read?        }        return (stat.mode & 0o004) === 0o004; // Others can read?      }    }    return true;  } catch (error) {    if (error instanceof Deno.errors.NotFound) {      return false;    }    if (error instanceof Deno.errors.PermissionDenied) {      if (        (await Deno.permissions.query({ name: "read", path })).state ===          "granted"      ) {        // --allow-read not missing        return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read      }    }    throw error;  }}
/** * Synchronously test whether or not the given path exists by checking with * the file system. * * Note: Do not use this function if performing a check before another operation * on that file. Doing so creates a race condition. Instead, perform the actual * file operation directly. This function is not recommended for this use case. * See the recommended method below. * * @see https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use * * @param path The path to the file or directory, as a string or URL. * @param options Additional options for the check. * @returns `true` if the path exists, `false` otherwise. * * @example Recommended method * ```ts * // Notice no use of exists * try { *   Deno.removeSync("./foo", { recursive: true }); * } catch (error) { *   if (!(error instanceof Deno.errors.NotFound)) { *     throw error; *   } *   // Do nothing... * } * ``` * * Notice that `existsSync()` is not used in the above example. Doing so avoids * a possible race condition. See the above section for details. * * @example Basic usage * ```ts * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * existsSync("./exists"); // true * existsSync("./does_not_exist"); // false * ``` * * @example Check if a path is readable * ```ts * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * existsSync("./readable", { isReadable: true }); // true * existsSync("./not_readable", { isReadable: true }); // false * ``` * * @example Check if a path is a directory * ```ts * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * existsSync("./directory", { isDirectory: true }); // true * existsSync("./file", { isDirectory: true }); // false * ``` * * @example Check if a path is a file * ```ts * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * existsSync("./file", { isFile: true }); // true * existsSync("./directory", { isFile: true }); // false * ``` * * @example Check if a path is a readable directory * ```ts * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * existsSync("./readable_directory", { isReadable: true, isDirectory: true }); // true * existsSync("./not_readable_directory", { isReadable: true, isDirectory: true }); // false * ``` * * @example Check if a path is a readable file * ```ts * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/exists.ts"; * * existsSync("./readable_file", { isReadable: true, isFile: true }); // true * existsSync("./not_readable_file", { isReadable: true, isFile: true }); // false * ``` */export function existsSync(  path: string | URL,  options?: ExistsOptions,): boolean {  try {    const stat = Deno.statSync(path);    if (      options &&      (options.isReadable || options.isDirectory || options.isFile)    ) {      if (options.isDirectory && options.isFile) {        throw new TypeError(          "ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together.",        );      }      if (        (options.isDirectory && !stat.isDirectory) ||        (options.isFile && !stat.isFile)      ) {        return false;      }      if (options.isReadable) {        if (stat.mode === null) {          return true; // Exclusive on Non-POSIX systems        }        if (Deno.uid() === stat.uid) {          return (stat.mode & 0o400) === 0o400; // User is owner and can read?        } else if (Deno.gid() === stat.gid) {          return (stat.mode & 0o040) === 0o040; // User group is owner and can read?        }        return (stat.mode & 0o004) === 0o004; // Others can read?      }    }    return true;  } catch (error) {    if (error instanceof Deno.errors.NotFound) {      return false;    }    if (error instanceof Deno.errors.PermissionDenied) {      if (        Deno.permissions.querySync({ name: "read", path }).state === "granted"      ) {        // --allow-read not missing        return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read      }    }    throw error;  }}