library-ts/browser/xhttp/Loader.ts

import { HTTPMethodType, HTTPMethodTypes } from "./HTTPMethodType";

export class Loader
{
  static async request<O,T>( url:string, input:T ):Promise<O>
  {
    let promise = new Promise<O>
    (
      ( resolve, reject ) =>
      {
        let xhr = new XMLHttpRequest();

        console.log( "loading", url );
        xhr.open( "POST", url, true );
        xhr.responseType = "text";
        xhr.onload= 
        () =>
        {
          console.log( xhr.responseURL, xhr.responseText );

          if ( xhr.status !== 200 || xhr.responseText.startsWith( "ERROR:" ) )
          {
            reject( xhr.responseText )
          }
          else
          {
            resolve( JSON.parse( xhr.responseText ) as O );
          } 
          
        };

        xhr.onerror=(e)=>
        {
          reject( e );
        }

        xhr.send( JSON.stringify( input ) );
      }
    );

    return promise;
  }

  static async readDataURL( blob:Blob ):Promise<FileReader>
  {
    let promise = new Promise<FileReader>
    (
      ( resolve, reject ) =>
      {
        let fileReader = new FileReader();

        fileReader.onload = ()=>
        {        
          resolve( fileReader );
        }

        fileReader.onerror = ()=>
        {
          reject();
        }

        fileReader.onabort = ()=>
        {
          reject();
        }

        fileReader.readAsDataURL( blob );

      }
    );

    return promise;
  }

  static async loadJSON<T>( url:string, method:HTTPMethodType = HTTPMethodTypes.GET):Promise<T>
  {
    let promise = new Promise<T>
    (
      ( resolve, reject )=>
      {
        let xhr = new XMLHttpRequest();

        xhr.open( method, url, true );
        xhr.responseType = "json";

        // console.log( "xhr", url, method );

        xhr.onload=()=>
        {
          console.log( "onload" );
          let value = null;

          try 
          {
            value = xhr.response;
          }
          catch ( e )
          {
            reject( e );
          }

          resolve( value as T );
        };

        xhr.onerror = ( e ) =>
        {
          console.log( "onerror", e );
          reject( e );
        }

        xhr.send();
      }
    );

    return promise;
  }

  
  static loadText( url:string, method:"GET"|"POST" = "GET" ):Promise<string>
  {
    let promise = new Promise<string>
    (
      ( resolve, reject ) =>
      {
        let xhr = new XMLHttpRequest();
        xhr.open( method, url, true );

        xhr.responseType = "text";

        xhr.onload = () =>
        {
          // console.log( "load", url, xhr );

          if ( xhr.status !== 200 )
          {
            reject( xhr.response )
          }
          else
          {
            resolve( xhr.responseText );
          }
          
        };

        xhr.onerror = ( e )=>
        {
          console.log( "error", url, xhr );

          reject( e );
        }

        xhr.send();
      }
    );

    return promise;
  }

  static loadXML( url:string ):Promise<Document>
  {
    let promise = new Promise<Document>
    (
      (resolve,reject)=>
      {
        let xhr = new XMLHttpRequest();
        xhr.open("GET",url,true);
        xhr.responseType = "document";
        xhr.onload=()=>
        {
          resolve(xhr.responseXML);
        };

        xhr.onerror=(e)=>
        {
          reject(e);
        }

        xhr.send();
      }
    );

    return promise;
  }


  static loadImage( url:string ):Promise<HTMLImageElement>
  {
    let promise = new Promise<HTMLImageElement>
    (
      (resolve,reject)=>
      {
        let img = new Image();
      
        img.onload = () =>
        {
          resolve( img );
        };

        img.onerror = ( e ) =>
        {
          reject( e );
        }

        img.src = url;
      }
    );

    return promise;
  }
  

  
}