Tauri 2.0 Path API Working with File Paths

// Frontend: Access system directories
import {
  appDataDir,
  appConfigDir,
  appCacheDir,
  appLogDir,
  audioDir,
  cacheDir,
  configDir,
  dataDir,
  desktopDir,
  documentDir,
  downloadDir,
  executableDir,
  fontDir,
  homeDir,
  localDataDir,
  pictureDir,
  publicDir,
  runtimeDir,
  templateDir,
  videoDir,
  resourceDir,
  tempDir,
} from '@tauri-apps/api/path';

// Get common directories
async function getCommonPaths() {
  const paths = {
    appData: await appDataDir(),      // App-specific data
    appConfig: await appConfigDir(),  // App configuration
    appCache: await appCacheDir(),    // App cache
    appLog: await appLogDir(),        // App logs
    home: await homeDir(),            // User home
    documents: await documentDir(),   // User documents
    downloads: await downloadDir(),   // Downloads folder
    desktop: await desktopDir(),      // Desktop folder
    pictures: await pictureDir(),     // Pictures folder
    videos: await videoDir(),         // Videos folder
    temp: await tempDir(),            // Temporary files
    resources: await resourceDir(),   // Bundled resources
  };

  console.log('System paths:', paths);
  return paths;
}

// Example paths on different platforms:
// Windows:
//   appData: C:\Users\Username\AppData\Roaming\com.myapp.app
//   appConfig: C:\Users\Username\AppData\Roaming\com.myapp.app
//   documents: C:\Users\Username\Documents
//   temp: C:\Users\Username\AppData\Local\Temp

// macOS:
//   appData: /Users/username/Library/Application Support/com.myapp.app
//   appConfig: /Users/username/Library/Application Support/com.myapp.app
//   documents: /Users/username/Documents
//   temp: /var/folders/...

// Linux:
//   appData: /home/username/.local/share/com.myapp.app
//   appConfig: /home/username/.config/com.myapp.app
//   documents: /home/username/Documents
//   temp: /tmp

// Save application settings
import { appConfigDir } from '@tauri-apps/api/path';
import { writeTextFile, readTextFile } from '@tauri-apps/api/fs';
import { join } from '@tauri-apps/api/path';

interface AppSettings {
  theme: string;
  language: string;
  fontSize: number;
}

class SettingsManager {
  private settingsPath: string | null = null;

  async init() {
    const configDir = await appConfigDir();
    this.settingsPath = await join(configDir, 'settings.json');
  }

  async save(settings: AppSettings): Promise<void> {
    if (!this.settingsPath) await this.init();
    await writeTextFile(this.settingsPath!, JSON.stringify(settings, null, 2));
  }

  async load(): Promise<AppSettings | null> {
    try {
      if (!this.settingsPath) await this.init();
      const content = await readTextFile(this.settingsPath!);
      return JSON.parse(content);
    } catch (error) {
      console.log('No settings file found, using defaults');
      return null;
    }
  }
}

// Usage
const settings = new SettingsManager();
await settings.save({ theme: 'dark', language: 'en', fontSize: 14 });
const loaded = await settings.load();

// React component using paths
import React, { useEffect, useState } from 'react';

const PathInfo: React.FC = () => {
  const [paths, setPaths] = useState<Record<string, string>>({});

  useEffect(() => {
    loadPaths();
  }, []);

  const loadPaths = async () => {
    setPaths({
      'App Data': await appDataDir(),
      'App Config': await appConfigDir(),
      'Documents': await documentDir(),
      'Downloads': await downloadDir(),
      'Desktop': await desktopDir(),
      'Pictures': await pictureDir(),
      'Home': await homeDir(),
    });
  };

  return (
    <div className="path-info">
      <h2>System Directories</h2>
      <table>
        <thead>
          <tr>
            <th>Directory</th>
            <th>Path</th>
          </tr>
        </thead>
        <tbody>
          {Object.entries(paths).map(([name, path]) => (
            <tr key={name}>
              <td>{name}</td>
              <td><code>{path}</code></td>
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  );
};

// Path manipulation utilities
import { join, resolve, normalize, basename, dirname, extname } from '@tauri-apps/api/path';

// Join path segments
const fullPath = await join('path', 'to', 'file.txt');
// Windows: path\to\file.txt
// Unix: path/to/file.txt

// Resolve absolute path
const absolutePath = await resolve('relative', 'path', 'file.txt');

// Normalize path (remove redundant separators)
const normalized = await normalize('path//to///file.txt');
// Result: path/to/file.txt

// Get filename from path
const filename = await basename('/path/to/document.pdf');
// Result: document.pdf

// Get directory from path
const directory = await dirname('/path/to/document.pdf');
// Result: /path/to

// Get file extension
const extension = await extname('document.pdf');
// Result: .pdf

// Complete path handling example
import { appDataDir, join } from '@tauri-apps/api/path';
import { createDir, exists, writeTextFile } from '@tauri-apps/api/fs';

class FileManager {
  private baseDir: string | null = null;

  async init() {
    this.baseDir = await appDataDir();
  }

  async ensureDirectory(subPath: string): Promise<string> {
    if (!this.baseDir) await this.init();
    
    const fullPath = await join(this.baseDir!, subPath);
    
    if (!(await exists(fullPath))) {
      await createDir(fullPath, { recursive: true });
    }
    
    return fullPath;
  }

  async getFilePath(category: string, filename: string): Promise<string> {
    const categoryDir = await this.ensureDirectory(category);
    return await join(categoryDir, filename);
  }

  async saveFile(category: string, filename: string, content: string) {
    const filePath = await this.getFilePath(category, filename);
    await writeTextFile(filePath, content);
    return filePath;
  }
}

// Usage
const fileManager = new FileManager();
await fileManager.init();

// Save files in organized directories
await fileManager.saveFile('logs', 'app.log', 'Log content');
await fileManager.saveFile('data', 'user-data.json', JSON.stringify({ name: 'John' }));
await fileManager.saveFile('cache', 'temp.txt', 'Cached data');

// Cross-platform path builder
class PathBuilder {
  private segments: string[] = [];

  add(...parts: string[]): PathBuilder {
    this.segments.push(...parts);
    return this;
  }

  async build(): Promise<string> {
    return await join(...this.segments);
  }

  reset(): PathBuilder {
    this.segments = [];
    return this;
  }
}

// Usage
const builder = new PathBuilder();
const path1 = await builder.add('users', 'john', 'documents').build();
const path2 = await builder.reset().add('images', '2024', 'photo.jpg').build();

// Rust: Backend path operations
use std::path::{Path, PathBuf};
use tauri::api::path::{app_data_dir, app_config_dir};

#[tauri::command]
async fn get_app_file_path(
    config: tauri::Config,
    filename: String,
) -> Result<String, String> {
    let app_data = app_data_dir(&config)
        .ok_or("Could not determine app data directory")?;

    let file_path = app_data.join(filename);
    
    Ok(file_path.to_string_lossy().to_string())
}

#[tauri::command]
async fn join_paths(
    base: String,
    segments: Vec<String>,
) -> Result<String, String> {
    let mut path = PathBuf::from(base);
    
    for segment in segments {
        path.push(segment);
    }
    
    Ok(path.to_string_lossy().to_string())
}

#[tauri::command]
async fn get_path_info(path: String) -> Result<PathInfo, String> {
    let path_obj = Path::new(&path);
    
    Ok(PathInfo {
        filename: path_obj.file_name()
            .and_then(|n| n.to_str())
            .unwrap_or("")
            .to_string(),
        directory: path_obj.parent()
            .and_then(|p| p.to_str())
            .unwrap_or("")
            .to_string(),
        extension: path_obj.extension()
            .and_then(|e| e.to_str())
            .unwrap_or("")
            .to_string(),
        is_absolute: path_obj.is_absolute(),
    })
}

#[derive(serde::Serialize)]
struct PathInfo {
    filename: String,
    directory: String,
    extension: String,
    is_absolute: bool,
}

// Access bundled resources
import { resourceDir, join } from '@tauri-apps/api/path';
import { readTextFile, readBinaryFile } from '@tauri-apps/api/fs';
import { convertFileSrc } from '@tauri-apps/api/tauri';

// Resource manager
class ResourceManager {
  private resourcePath: string | null = null;

  async init() {
    this.resourcePath = await resourceDir();
  }

  async getResourcePath(relativePath: string): Promise<string> {
    if (!this.resourcePath) await this.init();
    return await join(this.resourcePath!, relativePath);
  }

  async loadTextResource(path: string): Promise<string> {
    const fullPath = await this.getResourcePath(path);
    return await readTextFile(fullPath);
  }

  async loadBinaryResource(path: string): Promise<Uint8Array> {
    const fullPath = await this.getResourcePath(path);
    return await readBinaryFile(fullPath);
  }

  async getAssetUrl(path: string): Promise<string> {
    const fullPath = await this.getResourcePath(path);
    return convertFileSrc(fullPath);
  }
}

// Usage
const resources = new ResourceManager();
await resources.init();

// Load text file
const readme = await resources.loadTextResource('README.txt');
console.log(readme);

// Load image for display
const imageUrl = await resources.getAssetUrl('images/logo.png');
// Use in img tag: <img src={imageUrl} />

// React component for resource images
import React, { useState, useEffect } from 'react';

interface ResourceImageProps {
  path: string;
  alt: string;
}

const ResourceImage: React.FC<ResourceImageProps> = ({ path, alt }) => {
  const [src, setSrc] = useState<string>('');

  useEffect(() => {
    loadImage();
  }, [path]);

  const loadImage = async () => {
    const resources = new ResourceManager();
    const url = await resources.getAssetUrl(path);
    setSrc(url);
  };

  return src ? <img src={src} alt={alt} /> : <div>Loading...</div>;
};

// Configuration file loader
class ConfigLoader {
  async loadAppConfig(): Promise<any> {
    try {
      const resources = new ResourceManager();
      const configText = await resources.loadTextResource('config.json');
      return JSON.parse(configText);
    } catch (error) {
      console.error('Failed to load config:', error);
      return {};
    }
  }

  async loadLanguageFile(locale: string): Promise<Record<string, string>> {
    try {
      const resources = new ResourceManager();
      const langFile = `locales/${locale}.json`;
      const content = await resources.loadTextResource(langFile);
      return JSON.parse(content);
    } catch (error) {
      console.error(`Failed to load language file for ${locale}:`, error);
      return {};
    }
  }
}

// Usage
const configLoader = new ConfigLoader();
const appConfig = await configLoader.loadAppConfig();
const translations = await configLoader.loadLanguageFile('en');