@tauri-apps/plugin-fs

{
  "permissions": [
    {
      "identifier": "fs:scope",
      "allow": [{ "path": "$APPDATA/databases/*" }]
    }
  ]
}

{
  "permissions": [
    {
      "identifier": "fs:allow-exists",
      "allow": [{ "path": "$APPDATA/databases/*" }]
    }
  ]
}

AppCache: 16;

AppConfig: 13;

AppData: 14;

AppLocalData: 15;

AppLog: 17;

Audio: 1;

Cache: 2;

Config: 3;

Data: 4;

Desktop: 18;

Document: 6;

Download: 7;

Executable: 19;

Font: 20;

Home: 21;

LocalData: 5;

Picture: 8;

Public: 9;

Resource: 11;

Runtime: 22;

Temp: 12;

Template: 23;

Video: 10;

Current: 1;

End: 2;

Start: 0;

new FileHandle(rid): FileHandle

get rid(): number

close(): Promise<void>

read(buffer): Promise<null | number>

import { open, BaseDirectory } from "@tauri-apps/plugin-fs"
// if "$APPCONFIG/foo/bar.txt" contains the text "hello world":
const file = await open("foo/bar.txt", { baseDir: BaseDirectory.AppConfig });
const buf = new Uint8Array(100);
const numberOfBytesRead = await file.read(buf); // 11 bytes
const text = new TextDecoder().decode(buf);  // "hello world"
await file.close();

seek(offset, whence): Promise<number>

import { open, SeekMode, BaseDirectory } from '@tauri-apps/plugin-fs';

    
// Given hello.txt pointing to file with "Hello world", which is 11 bytes long:
const file = await open('hello.txt', { read: true, write: true, truncate: true, create: true, baseDir: BaseDirectory.AppLocalData });
await file.write(new TextEncoder().encode("Hello world"));

    
// Seek 6 bytes from the start of the file
console.log(await file.seek(6, SeekMode.Start)); // "6"
// Seek 2 more bytes from the current position
console.log(await file.seek(2, SeekMode.Current)); // "8"
// Seek backwards 2 bytes from the end of the file
console.log(await file.seek(-2, SeekMode.End)); // "9" (e.g. 11-2)

    
await file.close();

stat(): Promise<FileInfo>

import { open, BaseDirectory } from '@tauri-apps/plugin-fs';
const file = await open("file.txt", { read: true, baseDir: BaseDirectory.AppLocalData });
const fileInfo = await file.stat();
console.log(fileInfo.isFile); // true
await file.close();

truncate(len?): Promise<void>

import { open, BaseDirectory } from '@tauri-apps/plugin-fs';

    
// truncate the entire file
const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData });
await file.truncate();

    
// truncate part of the file
const file = await open("my_file.txt", { read: true, write: true, create: true, baseDir: BaseDirectory.AppLocalData });
await file.write(new TextEncoder().encode("Hello World"));
await file.truncate(7);
const data = new Uint8Array(32);
await file.read(data);
console.log(new TextDecoder().decode(data)); // Hello W
await file.close();

write(data): Promise<number>

import { open, write, BaseDirectory } from '@tauri-apps/plugin-fs';
const encoder = new TextEncoder();
const data = encoder.encode("Hello world");
const file = await open("bar.txt", { write: true, baseDir: BaseDirectory.AppLocalData });
const bytesWritten = await file.write(data); // 11
await file.close();

type UnwatchFn: () => void;

type WatchEventKind:
  | "any"
  | object
  | object
  | object
  | object
  | "other";

type WatchEventKindAccess: object | object | object | object;

type WatchEventKindCreate: object | object | object | object;

type WatchEventKindModify:
  | object
  | object
  | object
  | object
  | object;

type WatchEventKindRemove: object | object | object | object;

function copyFile(
   fromPath,
   toPath,
options?): Promise<void>

import { copyFile, BaseDirectory } from '@tauri-apps/plugin-fs';
await copyFile('app.conf', 'app.conf.bk', { fromPathBaseDir: BaseDirectory.AppConfig, toPathBaseDir: BaseDirectory.AppConfig });

function create(path, options?): Promise<FileHandle>

import { create, BaseDirectory } from "@tauri-apps/plugin-fs"
const file = await create("foo/bar.txt", { baseDir: BaseDirectory.AppConfig });
await file.write(new TextEncoder().encode("Hello world"));
await file.close();

function exists(path, options?): Promise<boolean>

import { exists, BaseDirectory } from '@tauri-apps/plugin-fs';
// Check if the `$APPDATA/avatar.png` file exists
await exists('avatar.png', { baseDir: BaseDirectory.AppData });

function lstat(path, options?): Promise<FileInfo>

import { lstat, BaseDirectory } from '@tauri-apps/plugin-fs';
const fileInfo = await lstat("hello.txt", { baseDir: BaseDirectory.AppLocalData });
console.log(fileInfo.isFile); // true

function mkdir(path, options?): Promise<void>

import { mkdir, BaseDirectory } from '@tauri-apps/plugin-fs';
await mkdir('users', { baseDir: BaseDirectory.AppLocalData });

function open(path, options?): Promise<FileHandle>

import { open, BaseDirectory } from "@tauri-apps/plugin-fs"
const file = await open("foo/bar.txt", { read: true, write: true, baseDir: BaseDirectory.AppLocalData });
// Do work with file
await file.close();

function readDir(path, options?): Promise<DirEntry[]>

import { readDir, BaseDirectory } from '@tauri-apps/plugin-fs';
import { join } from '@tauri-apps/api/path';
const dir = "users"
const entries = await readDir('users', { baseDir: BaseDirectory.AppLocalData });
processEntriesRecursively(dir, entries);
async function processEntriesRecursively(parent, entries) {
  for (const entry of entries) {
    console.log(`Entry: ${entry.name}`);
    if (entry.isDirectory) {
       const dir = await join(parent, entry.name);
      processEntriesRecursively(dir, await readDir(dir, { baseDir: BaseDirectory.AppLocalData }))
    }
  }
}

function readFile(path, options?): Promise<Uint8Array>

import { readFile, BaseDirectory } from '@tauri-apps/plugin-fs';
const contents = await readFile('avatar.png', { baseDir: BaseDirectory.Resource });

function readTextFile(path, options?): Promise<string>

import { readTextFile, BaseDirectory } from '@tauri-apps/plugin-fs';
const contents = await readTextFile('app.conf', { baseDir: BaseDirectory.AppConfig });

function readTextFileLines(path, options?): Promise<AsyncIterableIterator<string>>

import { readTextFileLines, BaseDirectory } from '@tauri-apps/plugin-fs';
const lines = await readTextFileLines('app.conf', { baseDir: BaseDirectory.AppConfig });
for await (const line of lines) {
  console.log(line);
}

function remove(path, options?): Promise<void>

import { remove, BaseDirectory } from '@tauri-apps/plugin-fs';
await remove('users/file.txt', { baseDir: BaseDirectory.AppLocalData });
await remove('users', { baseDir: BaseDirectory.AppLocalData });

function rename(
   oldPath,
   newPath,
options?): Promise<void>

import { rename, BaseDirectory } from '@tauri-apps/plugin-fs';
await rename('avatar.png', 'deleted.png', { oldPathBaseDir: BaseDirectory.App, newPathBaseDir: BaseDirectory.AppLocalData });

function size(path): Promise<number>

import { size, BaseDirectory } from '@tauri-apps/plugin-fs';
// Get the size of the `$APPDATA/tauri` directory.
const dirSize = await size('tauri', { baseDir: BaseDirectory.AppData });
console.log(dirSize); // 1024

function stat(path, options?): Promise<FileInfo>

import { stat, BaseDirectory } from '@tauri-apps/plugin-fs';
const fileInfo = await stat("hello.txt", { baseDir: BaseDirectory.AppLocalData });
console.log(fileInfo.isFile); // true

function truncate(
   path,
   len?,
options?): Promise<void>

import { truncate, readTextFile, writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs';
// truncate the entire file
await truncate("my_file.txt", 0, { baseDir: BaseDirectory.AppLocalData });

    
// truncate part of the file
const filePath = "file.txt";
await writeTextFile(filePath, "Hello World", { baseDir: BaseDirectory.AppLocalData });
await truncate(filePath, 7, { baseDir: BaseDirectory.AppLocalData });
const data = await readTextFile(filePath, { baseDir: BaseDirectory.AppLocalData });
console.log(data);  // "Hello W"

function watch(
   paths,
   cb,
options?): Promise<UnwatchFn>

function watchImmediate(
   paths,
   cb,
options?): Promise<UnwatchFn>

function writeFile(
   path,
   data,
options?): Promise<void>

import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs';

    
let encoder = new TextEncoder();
let data = encoder.encode("Hello World");
await writeFile('file.txt', data, { baseDir: BaseDirectory.AppLocalData });

function writeTextFile(
   path,
   data,
options?): Promise<void>

import { writeTextFile, BaseDirectory } from '@tauri-apps/plugin-fs';

    
await writeTextFile('file.txt', "Hello world", { baseDir: BaseDirectory.AppLocalData });