vscode#FileSystemError TypeScript Examples

/**
 * Given a list of file names, try to find one of them in the provided path,
 * then step up one folder at a time and repeat the search until we find something
 * or run out of parents.
 *
 * If no file is found, we return [[FileSystemError.FileNotFound]].
 *
 * If `uri` points to a file, we immediately return [[FileSystemError.FileNotADirectory]].
 *
 * Returns either the [[Uri]] of the first file found, or [[None]].
 */
export async function lookUpwards(
    uri: Uri,
    files: string[]
): Promise<Result<Uri, FileSystemError>> {
    const path = new Path(uri);
    if (!(await path.isDir())) {
        return Err(FileSystemError.FileNotADirectory(uri));
    }
    while (true) {
        for (const file of files) {
            let filePath = path.append(file);
            if (await filePath.isFile()) {
                return Ok(filePath.uri);
            }
        }
        if (path.pop().isNone()) {
            return Err(FileSystemError.FileNotFound());
        }
    }
}

async writeFile(
    uri: Uri,
    content: Uint8Array,
    options: { create: boolean; overwrite: boolean },
  ): Promise<void> {
    const path = fromUtopiaURI(uri)
    if (!options.create || !options.overwrite) {
      const fileExists = await exists(path)
      if (!fileExists && !options.create) {
        throw FileSystemError.FileNotFound(uri)
      } else if (fileExists && !options.overwrite) {
        throw FileSystemError.FileExists(uri)
      }
    }

    await writeFileSavedContent(path, content)
  }

async rename(oldUri: Uri, newUri: Uri, options: { overwrite: boolean }): Promise<void> {
    const oldPath = fromUtopiaURI(oldUri)
    const newPath = fromUtopiaURI(newUri)

    if (!options.overwrite) {
      const fileExists = await exists(newPath)
      if (fileExists) {
        throw FileSystemError.FileExists(newUri)
      }
    }

    await rename(oldPath, newPath)
  }

async copy(source: Uri, destination: Uri, options: { overwrite: boolean }): Promise<void> {
    // It's not clear where this will ever be called from, but it seems to be from the side bar
    // that isn't available in Utopia, so this implementation is "just in case"
    const sourcePath = fromUtopiaURI(source)
    const destinationPath = fromUtopiaURI(destination)
    const destinationParentDir = dirname(destinationPath)
    const destinationParentDirExists = await exists(destinationParentDir)

    if (!destinationParentDirExists) {
      throw FileSystemError.FileNotFound(toUtopiaURI(this.projectID, destinationParentDir))
    }

    if (!options.overwrite) {
      const destinationExists = await exists(destinationPath)
      if (destinationExists && !options.overwrite) {
        throw FileSystemError.FileExists(destination)
      }
    }

    const { content, unsavedContent } = await readFile(sourcePath)
    await writeFile(destinationPath, content, unsavedContent)
  }

private async cleanInstallDir(): Promise<void> {
    const installPath = this.getInstallationPath();
    this.writeStatus(`deleting previous Dafny installation at ${installPath.fsPath}`);
    try {
      await workspace.fs.delete(
        installPath,
        {
          recursive: true,
          useTrash: false
        }
      );
    } catch(error: unknown) {
      if(!(error instanceof FileSystemError) || error.code !== 'FileNotFound') {
        throw error;
      }
    }
  }

public async remove(useTrash = false): Promise<FileItem> {
    try {
      await workspace.fs.delete(this.path, { recursive: true, useTrash });
    } catch (err) {
      if (useTrash === true && err instanceof FileSystemError) {
        return this.remove(false);
      }
      throw err;
    }
    return this;
  }