File System Operations

/**
 * Base class for file system entities (files and folders)
 */
class FileSystemEntity {
  // Properties
  readonly name: string;
  readonly path: string;
  readonly parent: Folder;
  readonly lastModified: Date;
  readonly size: number;
  readonly isLocked: boolean;
  
  // Methods
  remove(): Promise<void>;
  removeSync(): void;
  rename(newName: string): Promise<void>;
  renameSync(newName: string): void;
  
  // Static factory methods
  static fromPath(path: string): FileSystemEntity;
}

/**
 * File representation with read/write operations
 */
class File extends FileSystemEntity {
  // Static factory methods
  static fromPath(path: string): File;
  static exists(path: string): boolean;
  
  // Text operations (async)
  readText(encoding?: string): Promise<string>;
  writeText(content: string, encoding?: string): Promise<void>;
  
  // Text operations (sync)
  readTextSync(encoding?: string): string;
  writeTextSync(content: string, encoding?: string): void;
  
  // Binary operations (async)
  read(): Promise<any>;
  write(data: any): Promise<void>;
  
  // Binary operations (sync)
  readSync(): any;
  writeSync(data: any): void;
  
  // File-specific properties
  readonly extension: string;
  readonly isTextFile: boolean;
}

import { File, knownFolders } from "tns-core-modules";

// Create file reference
const documentsFolder = knownFolders.documents();
const file = documentsFolder.getFile("mydata.txt");

// Async text operations
async function handleTextFile() {
  // Write text to file
  await file.writeText("Hello, NativeScript!");
  
  // Read text from file
  const content = await file.readText();
  console.log("File content:", content);
  
  // Append text
  const existingContent = await file.readText();
  await file.writeText(existingContent + "\nNew line added");
}

// Sync text operations
function handleTextFileSync() {
  // Write and read synchronously
  file.writeTextSync("Synchronous content");
  const content = file.readTextSync();
  console.log("Sync content:", content);
}

// Check if file exists
const configFile = File.fromPath("~/config.json");
if (File.exists(configFile.path)) {
  const config = JSON.parse(configFile.readTextSync());
}

// Binary file operations
async function handleBinaryFile() {
  const imageFile = documentsFolder.getFile("image.png");
  const binaryData = await imageFile.read();
  
  // Process binary data
  const newFile = documentsFolder.getFile("copy.png");
  await newFile.write(binaryData);
}

/**
 * Folder representation with directory operations
 */
class Folder extends FileSystemEntity {
  // Static factory methods
  static fromPath(path: string): Folder;
  static exists(path: string): boolean;
  
  // Content access
  getFile(name: string): File;
  getFolder(name: string): Folder;
  
  // Enumeration (async)
  getEntities(): Promise<FileSystemEntity[]>;
  eachEntity(onEntity: (entity: FileSystemEntity) => boolean): Promise<void>;
  
  // Enumeration (sync)  
  getEntitiesSync(): FileSystemEntity[];
  eachEntitySync(onEntity: (entity: FileSystemEntity) => boolean): void;
  
  // Directory operations
  clear(): Promise<void>;
  clearSync(): void;
  
  // Properties
  readonly isKnown: boolean;
}

import { Folder, knownFolders, File } from "tns-core-modules";

// Access known folders
const documents = knownFolders.documents();
const temp = knownFolders.temp();
const currentApp = knownFolders.currentApp();

// Create subfolder
const dataFolder = documents.getFolder("appData");

// List folder contents (async)
async function listFolderContents(folder: Folder) {
  const entities = await folder.getEntities();
  
  entities.forEach(entity => {
    if (entity instanceof File) {
      console.log(`File: ${entity.name} (${entity.size} bytes)`);
    } else if (entity instanceof Folder) {
      console.log(`Folder: ${entity.name}`);
    }
  });
}

// Iterate through entities (async)
async function processAllFiles(folder: Folder) {
  await folder.eachEntity((entity) => {
    if (entity instanceof File && entity.extension === ".txt") {
      console.log(`Processing: ${entity.name}`);
      // Process text file
      return true; // continue iteration
    }
    return true;
  });
}

// Sync folder operations
function syncFolderOperations() {
  const folder = documents.getFolder("logs");
  const entities = folder.getEntitiesSync();
  
  // Process each entity synchronously
  entities.forEach(entity => {
    console.log(`Entity: ${entity.name}, Modified: ${entity.lastModified}`);
  });
  
  // Clear folder contents
  folder.clearSync();
}

/**
 * Known system folders namespace
 */
namespace knownFolders {
  /**
   * Application documents folder (user data storage)
   */
  function documents(): Folder;
  
  /**
   * Temporary files folder (cleared on app restart)
   */
  function temp(): Folder;
  
  /**
   * Current application folder (app bundle/installation)
   */
  function currentApp(): Folder;
  
  /**
   * iOS-specific folders
   */
  namespace ios {
    function library(): Folder;
    function developer(): Folder;
    function desktop(): Folder;
    function downloads(): Folder;
    function movies(): Folder;
    function music(): Folder;
    function pictures(): Folder;
  }
  
  /**
   * Android-specific folders
   */
  namespace android {
    function externalStorage(): Folder;
    function externalCacheDir(): Folder;
    function externalFilesDir(): Folder;
  }
}

/**
 * Path utilities namespace
 */
namespace path {
  /**
   * Path separator for current platform
   */
  const separator: string;
  
  /**
   * Normalize path separators for current platform
   */
  function normalize(path: string): string;
  
  /**
   * Join path segments with proper separators
   */
  function join(...paths: string[]): string;
  
  /**
   * Get directory name from path
   */
  function dirname(path: string): string;
  
  /**
   * Get filename from path
   */
  function basename(path: string): string;
  
  /**
   * Get file extension from path
   */
  function extname(path: string): string;
  
  /**
   * Check if path is absolute
   */
  function isAbsolute(path: string): boolean;
  
  /**
   * Resolve relative path to absolute
   */
  function resolve(...paths: string[]): string;
}

import { path, knownFolders } from "tns-core-modules";

// Path manipulation
const filePath = path.join("documents", "data", "config.json");
console.log("Joined path:", filePath);

const normalized = path.normalize("/documents//data/./config.json");
console.log("Normalized:", normalized);

// Path information
const fullPath = "/app/documents/data/config.json";
console.log("Directory:", path.dirname(fullPath));     // "/app/documents/data"
console.log("Filename:", path.basename(fullPath));     // "config.json"
console.log("Extension:", path.extname(fullPath));     // ".json"

// Platform-specific separators
const platformPath = path.join("folder", "subfolder", "file.txt");
// Windows: "folder\\subfolder\\file.txt"
// Unix/iOS/Android: "folder/subfolder/file.txt"

// Resolve relative paths
const documentsPath = knownFolders.documents().path;
const configPath = path.resolve(documentsPath, "config", "app.json");
console.log("Resolved path:", configPath);

/**
 * File system utilities for advanced operations
 */
namespace FileSystem {
  // File type detection
  function isTextFile(path: string): boolean;
  function isBinaryFile(path: string): boolean;
  
  // File comparison
  function compareFiles(path1: string, path2: string): Promise<boolean>;
  function compareFilesSync(path1: string, path2: string): boolean;
  
  // Directory operations
  function createDirectory(path: string): Promise<void>;
  function createDirectorySync(path: string): void;
  function copyDirectory(source: string, destination: string): Promise<void>;
  function moveDirectory(source: string, destination: string): Promise<void>;
  
  // File operations
  function copyFile(source: string, destination: string): Promise<void>;
  function moveFile(source: string, destination: string): Promise<void>;
  
  // Disk space
  function getAvailableSpace(): Promise<number>;
  function getTotalSpace(): Promise<number>;
}

import { File, Folder, knownFolders, path } from "tns-core-modules";

class FileManager {
  private documentsFolder: Folder;
  
  constructor() {
    this.documentsFolder = knownFolders.documents();
  }
  
  async saveUserData(data: any): Promise<void> {
    const dataFolder = this.documentsFolder.getFolder("userData");
    const file = dataFolder.getFile("profile.json");
    
    await file.writeText(JSON.stringify(data, null, 2));
  }
  
  async loadUserData(): Promise<any> {
    const dataFolder = this.documentsFolder.getFolder("userData");
    const file = dataFolder.getFile("profile.json");
    
    if (File.exists(file.path)) {
      const content = await file.readText();
      return JSON.parse(content);
    }
    return null;
  }
  
  async backup(): Promise<void> {
    const backupFolder = this.documentsFolder.getFolder("backups");
    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
    const backupFile = backupFolder.getFile(`backup-${timestamp}.json`);
    
    const userData = await this.loadUserData();
    if (userData) {
      await backupFile.writeText(JSON.stringify(userData));
    }
  }
  
  async listBackups(): Promise<string[]> {
    const backupFolder = this.documentsFolder.getFolder("backups");
    const entities = await backupFolder.getEntities();
    
    return entities
      .filter(entity => entity instanceof File && entity.name.startsWith("backup-"))
      .map(file => file.name);
  }
}