You can use this to get base64 image

async function getBase64ImageFromUrl(imageUrl) {
  var res = await fetch(imageUrl);
  var blob = await res.blob();

  return new Promise((resolve, reject) => {
    var reader  = new FileReader();
    reader.addEventListener("load", function () {
        resolve(reader.result);
    }, false);

    reader.onerror = () => {
      return reject(this);
    };
    reader.readAsDataURL(blob);
  })
}

Then call it like this

getBase64ImageFromUrl('your url')
    .then(result => testImage.src = result)
    .catch(err => console.error(err));

Not really sure what exactly are you trying to achieve here by doing this.

But FileReader accepts blobs, as an argument to readAsDataURL. So you'll have to read it from the URL using HttpClient's get method specifying responseType as blob. The onload method on the reader can then be used to get the Base 64 url for the image.

Here, give this a try:

import { Component } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Component({
  selector: 'my-app',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  name = 'Angular';

  constructor(private http: HttpClient) { }

  ngOnInit() {
    this.http.get('https://avatars0.githubusercontent.com/u/5053266?s=460&v=4', { responseType: 'blob' })
      .subscribe(blob => {
        const reader = new FileReader();
        const binaryString = reader.readAsDataURL(blob);
        reader.onload = (event: any) => {
          console.log('Image in Base64: ', event.target.result);
        };

        reader.onerror = (event: any) => {
          console.log("File could not be read: " + event.target.error.code);
        };

      });
  }
}

Here's a Working Sample StackBlitz for your ref.

This worked for me:

TS FILE
base64ImageString;

async getBase64ImageFromUrl(imageUrl) {
    var res = await fetch(imageUrl);
    var blob = await res.blob();
    return new Promise((resolve, reject) => {
      var reader  = new FileReader();
      reader.addEventListener("load", function () {
          resolve(reader.result);
      }, false);
      reader.onerror = () => {
        return reject(this);
      };
      reader.readAsDataURL(blob);
    })
  }


ngOnInit() {
   this.getBase64ImageFromUrl(this.userData.organization_logo).then(base64 => {
      this.base64ImageString = base64;
    })
}

HTML

  <img src='{{ base64ImageString }}' class="logo" />

You can create a Node script as the following:

const fs = require('fs');
const base64Img = require('base64-img');

fs.readFile('my/file/path', 'utf8', (err, data) => {
  if (err) {
    return console.error(err);
  }
  const matches = data.match(/assets\/.*?(svg|png)/g);
  matches.forEach(match => {
    try {
      if (fs.existsSync(match)) {
        const convertedImage = base64Img.base64Sync(match);
        data = data.replace(match, `${convertedImage}`);
      }
    } catch (err) {
      console.error('Error: File not found', match);
    }
  });

  fs.writeFile('my/destination/file', data, 'utf8', (err) => {
    if (err) {
      return console.error(err);
    }
  });
});

In this way, it will get the file that you need to replace the files, search for the assets, then convert the images to base64 and replace them. The last step is to write the result to a new file.

To run this, you need to install base64-img library: npm i base64-img --save-dev. Afterwards, you can build the project and then run node include-images.js.

To make it easier, you can also add a script in your package.json, something like:

"replace-images": "ng build && node include-images.js"

This can be run using: npm run replace-images

Please note that I don't prefer converting the images into base64 and include it in the bundle as it will make the bundle / bundles much bigger and will decrease your website performance.

Answer from here https://stackoverflow.com/a/24880314/625189

I would recommend you to use https://github.com/ninjatronic/angular-base64.

After following instructions for using this library, you can simply call:

var imageData=$base64.encode(image);

Don't forget to inject in your module:

.module('myApp', ['base64'])

You need to use readAsDataUrl():

function getBase64(event) {
   let me = this;
   let file = event.target.files[0];
   let reader = new FileReader();
   reader.readAsDataURL(file);
   reader.onload = function () {
     //me.modelvalue = reader.result;
     console.log(reader.result);
   };
   reader.onerror = function (error) {
     console.log('Error: ', error);
   };
}

Try this:

/**
 * Convert image 
 * to a base64 data uri
 * @param  {String}   url         
 * @param  {Function} callback    
 * @param  {String}   [outputFormat=image/png]           
 */
function convertImageToDataURI(url, callback, outputFormat) {
    var img = new Image();
    img.crossOrigin = 'Anonymous';
    img.onload = function(){
        var canvas = document.createElement('CANVAS'),
        ctx = canvas.getContext('2d'), dataURL;
        canvas.height = this.height;
        canvas.width = this.width;
        ctx.drawImage(this, 0, 0);
        dataURL = canvas.toDataURL(outputFormat);
        callback(dataURL);
        canvas = null; 
    };
    img.src = url;
}

Usage

convertImageToDataURI('ImageLink', function(base64Decoded){
    // Base64DataURI
});

Supported input formats

image/png, image/jpeg, image/jpg, image/gif, image/bmp, image/tiff, image/x-icon, image/svg+xml, image/webp, image/xxx
Supported output formats

image/png,image/jpeg,image/webp (chrome)

Demo:

fiddle

Test: toDataUrl mime type

http://kangax.github.io/jstests/toDataUrl_mime_type_test/

Browser Support (so far I know)

• http://caniuse.com/#feat=canvas

• IE10 (IE10 just works with same origin images)

Images from the local file system

If you want to convert images from the users file system you need to take a different approach. Use the FileReader API (Check out this fiddle).