CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-tarojs--taro-rn

React Native implementation layer for the Taro cross-platform framework, providing React Native-specific APIs and utilities.

—

Pending
Overview
Eval results
Files

file-system.mddocs/

File System APIs

File management operations for reading, writing, and managing local files in Taro React Native applications.

Capabilities

File System Manager

Get a file system manager instance for comprehensive file operations.

/**
 * Get file system manager instance
 * @returns FileSystemManager instance
 */
function getFileSystemManager(): FileSystemManager;

interface FileSystemManager {
  /**
   * Read file content
   * @param options Read file options
   */
  readFile(options: {
    filePath: string;
    encoding?: 'ascii' | 'base64' | 'binary' | 'hex' | 'ucs2' | 'ucs-2' | 'utf16le' | 'utf-16le' | 'utf8' | 'utf-8' | 'latin1';
    position?: number;
    length?: number;
    success?: (res: { data: string | ArrayBuffer }) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: any) => void;
  }): Promise<{ data: string | ArrayBuffer }>;

  /**
   * Write file content
   * @param options Write file options
   */
  writeFile(options: {
    filePath: string;
    data: string | ArrayBuffer;
    encoding?: 'ascii' | 'base64' | 'binary' | 'hex' | 'ucs2' | 'ucs-2' | 'utf16le' | 'utf-16le' | 'utf8' | 'utf-8' | 'latin1';
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;

  /**
   * Copy file
   * @param options Copy file options
   */
  copyFile(options: {
    srcPath: string;
    destPath: string;
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;

  /**
   * Move/rename file
   * @param options Rename file options
   */
  rename(options: {
    oldPath: string;
    newPath: string;
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;

  /**
   * Delete file
   * @param options Unlink file options
   */
  unlink(options: {
    filePath: string;
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;

  /**
   * Get file stats
   * @param options Get file stats options
   */
  stat(options: {
    path: string;
    recursive?: boolean;
    success?: (res: {
      stats: Stats | Record<string, Stats>;
    }) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: any) => void;
  }): Promise<{ stats: Stats | Record<string, Stats> }>;

  /**
   * Create directory
   * @param options Make directory options
   */
  mkdir(options: {
    dirPath: string;
    recursive?: boolean;
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;

  /**
   * Remove directory
   * @param options Remove directory options
   */
  rmdir(options: {
    dirPath: string;
    recursive?: boolean;
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;

  /**
   * Read directory contents
   * @param options Read directory options
   */
  readdir(options: {
    dirPath: string;
    success?: (res: { files: string[] }) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: any) => void;
  }): Promise<{ files: string[] }>;

  /**
   * Check if file/directory exists
   * @param options Access check options
   */
  access(options: {
    path: string;
    success?: (res: TaroGeneral.CallbackResult) => void;
    fail?: (res: TaroGeneral.CallbackResult) => void;
    complete?: (res: TaroGeneral.CallbackResult) => void;
  }): Promise<TaroGeneral.CallbackResult>;
}

interface Stats {
  mode: number;
  size: number;
  lastAccessedTime: number;
  lastModifiedTime: number;
  isDirectory(): boolean;
  isFile(): boolean;
}

Usage Examples:

import { getFileSystemManager } from "@tarojs/taro-rn";

const fs = getFileSystemManager();

// Write text file
await fs.writeFile({
  filePath: '/data/user_data.txt',
  data: 'Hello, World!',
  encoding: 'utf8'
});

// Read text file
const textResult = await fs.readFile({
  filePath: '/data/user_data.txt',
  encoding: 'utf8'
});
console.log('File content:', textResult.data);

// Write binary file
const binaryData = new ArrayBuffer(1024);
await fs.writeFile({
  filePath: '/data/binary_file.bin',
  data: binaryData
});

// Create directory
await fs.mkdir({
  dirPath: '/data/images',
  recursive: true
});

// Copy file
await fs.copyFile({
  srcPath: '/data/user_data.txt',
  destPath: '/data/backup/user_data_backup.txt'
});

// Get file info
const statResult = await fs.stat({
  path: '/data/user_data.txt'
});

const stats = statResult.stats as Stats;
console.log('File size:', stats.size);
console.log('Is file:', stats.isFile());
console.log('Last modified:', new Date(stats.lastModifiedTime));

Saved File Management

Manage saved files with metadata and persistent storage.

/**
 * Save file to persistent storage
 * @param options Save file options
 */
function saveFile(options: {
  tempFilePath: string;
  filePath?: string;
  success?: (res: {
    savedFilePath: string;
  }) => void;
  fail?: (res: TaroGeneral.CallbackResult) => void;
  complete?: (res: any) => void;
}): Promise<{
  savedFilePath: string;
}>;

/**
 * Get list of saved files
 * @param options Get saved file list options
 */
function getSavedFileList(options?: {
  success?: (res: {
    fileList: {
      filePath: string;
      createTime: number;
      size: number;
    }[];
  }) => void;
  fail?: (res: TaroGeneral.CallbackResult) => void;
  complete?: (res: any) => void;
}): Promise<{
  fileList: {
    filePath: string;
    createTime: number;
    size: number;
  }[];
}>;

/**
 * Get saved file information
 * @param options Get saved file info options
 */
function getSavedFileInfo(options: {
  filePath: string;
  success?: (res: {
    createTime: number;
    size: number;
  }) => void;
  fail?: (res: TaroGeneral.CallbackResult) => void;
  complete?: (res: any) => void;
}): Promise<{
  createTime: number;
  size: number;
}>;

/**
 * Remove saved file
 * @param options Remove saved file options
 */
function removeSavedFile(options: {
  filePath: string;
  success?: (res: TaroGeneral.CallbackResult) => void;
  fail?: (res: TaroGeneral.CallbackResult) => void;
  complete?: (res: TaroGeneral.CallbackResult) => void;
}): Promise<TaroGeneral.CallbackResult>;

File Information

Get detailed file information and metadata.

/**
 * Get file information
 * @param options Get file info options
 */
function getFileInfo(options: {
  filePath: string;
  digestAlgorithm?: 'md5' | 'sha1';
  success?: (res: {
    size: number;
    digest?: string;
  }) => void;
  fail?: (res: TaroGeneral.CallbackResult) => void;
  complete?: (res: any) => void;
}): Promise<{
  size: number;
  digest?: string;
}>;

URL Operations

Open URLs and external applications.

/**
 * Open URL in external browser or application
 * @param options Open URL options
 */
function openUrl(options: {
  url: string;
  success?: (res: TaroGeneral.CallbackResult) => void;
  fail?: (res: TaroGeneral.CallbackResult) => void;
  complete?: (res: TaroGeneral.CallbackResult) => void;
}): Promise<TaroGeneral.CallbackResult>;

Usage Examples:

import { 
  saveFile, 
  getSavedFileList, 
  getSavedFileInfo,
  removeSavedFile,
  getFileInfo,
  openUrl
} from "@tarojs/taro-rn";

// Save a temporary file permanently
const saveResult = await saveFile({
  tempFilePath: '/tmp/photo_12345.jpg'
});
console.log('File saved to:', saveResult.savedFilePath);

// Get all saved files
const savedFiles = await getSavedFileList();
console.log('Saved files:', savedFiles.fileList);

// Get info for specific saved file
const fileInfo = await getSavedFileInfo({
  filePath: saveResult.savedFilePath
});
console.log('File created:', new Date(fileInfo.createTime));
console.log('File size:', fileInfo.size);

// Get file info with digest
const detailedInfo = await getFileInfo({
  filePath: saveResult.savedFilePath,
  digestAlgorithm: 'md5'
});
console.log('File MD5:', detailedInfo.digest);

// Remove saved file
await removeSavedFile({
  filePath: saveResult.savedFilePath
});

// Open external URL
await openUrl({
  url: 'https://www.example.com'
});

// Open native app
await openUrl({
  url: 'mailto:user@example.com?subject=Hello'
});

File Management Patterns

Directory Operations

import { getFileSystemManager } from "@tarojs/taro-rn";

const fs = getFileSystemManager();

// Create nested directory structure
async function createDirectoryStructure() {
  await fs.mkdir({ dirPath: '/data/app/cache', recursive: true });
  await fs.mkdir({ dirPath: '/data/app/logs', recursive: true });
  await fs.mkdir({ dirPath: '/data/app/temp', recursive: true });
}

// List directory contents recursively
async function listDirectoryRecursive(dirPath: string): Promise<string[]> {
  const result = await fs.readdir({ dirPath });
  const allFiles: string[] = [];
  
  for (const file of result.files) {
    const fullPath = `${dirPath}/${file}`;
    const stats = await fs.stat({ path: fullPath });
    
    if ((stats.stats as Stats).isDirectory()) {
      const subFiles = await listDirectoryRecursive(fullPath);
      allFiles.push(...subFiles);
    } else {
      allFiles.push(fullPath);
    }
  }
  
  return allFiles;
}

// Clean up old files
async function cleanupOldFiles(dirPath: string, maxAge: number) {
  const files = await listDirectoryRecursive(dirPath);
  const now = Date.now();
  
  for (const filePath of files) {
    try {
      const stats = await fs.stat({ path: filePath });
      const fileStats = stats.stats as Stats;
      
      if (now - fileStats.lastModifiedTime > maxAge) {
        await fs.unlink({ filePath });
        console.log('Deleted old file:', filePath);
      }
    } catch (error) {
      console.warn('Failed to process file:', filePath, error);
    }
  }
}

Data Serialization

import { getFileSystemManager } from "@tarojs/taro-rn";

const fs = getFileSystemManager();

// Save JSON data
async function saveJsonData(filePath: string, data: any) {
  const jsonString = JSON.stringify(data, null, 2);
  await fs.writeFile({
    filePath,
    data: jsonString,
    encoding: 'utf8'
  });
}

// Load JSON data
async function loadJsonData(filePath: string): Promise<any> {
  try {
    const result = await fs.readFile({
      filePath,
      encoding: 'utf8'
    });
    return JSON.parse(result.data as string);
  } catch (error) {
    console.warn('Failed to load JSON data:', error);
    return null;
  }
}

// Save binary data with metadata
async function saveBinaryWithMetadata(filePath: string, data: ArrayBuffer, metadata: any) {
  // Save binary data
  await fs.writeFile({ filePath, data });
  
  // Save metadata as JSON
  const metadataPath = filePath + '.meta';
  await saveJsonData(metadataPath, {
    ...metadata,
    size: data.byteLength,
    createdAt: Date.now()
  });
}

// Usage
const userData = { id: 123, name: 'John', preferences: { theme: 'dark' } };
await saveJsonData('/data/user.json', userData);

const loadedData = await loadJsonData('/data/user.json');
console.log('Loaded user data:', loadedData);

Install with Tessl CLI

npx tessl i tessl/npm-tarojs--taro-rn

docs

device-system.md

file-system.md

hooks.md

index.md

location-sensors.md

media.md

navigation.md

network.md

storage.md

ui-apis.md

tile.json