récupérer en morceaux

récupérer des morceaux

Un utilitaire permettant de récupérer des fichiers volumineux en morceaux avec prise en charge des téléchargements parallèles, du suivi des progrès et des demandes d'avortement.

Installation

Installez le package à l'aide de npm :

npm install fetch-in-chunks

Usage

Importation du module

 import fetchInChunks from 'fetch-in-chunks' ;

Signature de fonction

 async function fetchInChunks ( url , options = { } ) 

Paramètres

• url ( string ) : L'URL du fichier à télécharger.
• options ( object , facultatif) : un objet contenant des options supplémentaires.
  • options.chunkSize ( number , par défaut : 5 * 1024 * 1024 ) : la taille de chaque morceau à télécharger en octets.
  • options.maxParallelRequests ( number , par défaut : 1 ) : le nombre de morceaux à télécharger en parallèle.
  • options.progressCallback ( function , facultatif) : Une fonction de rappel qui sera appelée avec le nombre d'octets téléchargés et la taille totale du fichier.
  • options.signal ( AbortSignal , facultatif) : un objet AbortSignal qui peut être utilisé pour abandonner le téléchargement.

Retours

• Promise : Une promesse qui se résout en un Blob contenant le fichier téléchargé.

Exemple

Utilisation de base

 import fetchInChunks from 'fetch-in-chunks' ;

async function downloadFile ( ) {
  try {
    const blob = await fetchInChunks ( 'https://example.com/largefile.zip' ) ;
    return blob ;
  } catch ( error ) {
    console . error ( 'Error fetching file:' , error ) ;
  }
}

downloadFile ( ) ;

Avec rappel de progression

 import fetchInChunks from 'fetch-in-chunks' ;

async function downloadFileWithProgress ( ) {
  try {
    const blob = await fetchInChunks ( 'https://example.com/largefile.zip' , {
      progressCallback : ( downloaded , total ) => {
        console . log ( `Downloaded ${ ( ( downloaded / total ) * 100 ) . toFixed ( 2 ) } %` ) ;
      } ,
    } ) ;
    return blob ;
  } catch ( error ) {
    console . error ( 'Error fetching file:' , error ) ;
  }
}

downloadFileWithProgress ( ) ;

Avec AbortController

 import fetchInChunks from 'fetch-in-chunks' ;

async function downloadFileWithAbort ( ) {
  const controller = new AbortController ( ) ;
  const signal = controller . signal ;

  try {
    const blob = await fetchInChunks ( 'https://example.com/largefile.zip' , {
      signal ,
    } ) ;
    return blob ;
  } catch ( error ) {
    if ( error . name === 'AbortError' ) {
      console . log ( 'Download aborted' ) ;
    } else {
      console . error ( 'Error fetching file:' , error ) ;
    }
  }

  // To abort the download at any time
  controller . abort ( ) ;
} 

Licence

Ce projet est sous licence Apache 2.0. Voir le fichier LICENSE pour plus de détails.