Export getCachedImageFilePath

[mattvot]

Exposing these methods allows us to take a set of URLs, generate the appropriate filepaths for each URL and compare against a list of cached files for a synchronisation function.

getCachedImagePath stats each file individually. We hope to implement a function in our code to list all the files in the cache directory, thus avoiding the erroneous stats.

For example something like this:

import RNFetchBlob from 'react-native-fetch-blob';
import CachedImage from 'react-native-cached-image';
import R from 'ramda';

const {fs} = RNFetchBlob;
const ImageCacheProvider = CachedImage.ImageCacheProvider;

function discardFile(path: string) {
  return fs.unlink(path).catch(() => Promise.resolve());
}

function discardFiles(paths: string[]) {
  let chain = Promise.resolve();

  for (let i = 0, c = paths.length; i < c; i += 1) {
    chain = chain.then(() => discardFile(paths[i]));
  }

  return chain;
}

function sync(imageUrls: string[]) {
  let cachedImagesToRemove;
  let imagesToBeCached;

  return ImageCacheProvider.getCacheInfo()
    .then(info => info.files.map(f => f.path))
    .then(previouslyCachedImagePaths => {
      const previouslyCachedImages = previouslyCachedImagePaths.map(path => ({
        url: undefined,
        path,
      }));

      const currentImagesToBeCached = imageUrls.map(url => ({
        url,
        path: ImageCacheProvider.getCachedImageFilePath(url, {}),
      }));

      cachedImagesToRemove = R.differenceWith(
        (p, c) => p.path === c.path,
        previouslyCachedImages,
        currentImagesToBeCached
      );

      imagesToBeCached = R.differenceWith((c, p) => c.path === p.path, currentImagesToBeCached, previouslyCachedImages);
    })
    .then(() => discardFiles(cachedImagesToRemove.map(f => f.path)))
    .then(() => ImageCacheProvider.cacheMultipleImages(imagesToBeCached.map(f => f.url)));
}

export default sync;

[kfiroo]

@mattvot I see no harm in exporting this method.
But keep in mind, I would rather not expose the underlying cache layer to the user as it's an implementation detail.
When dealing with urls only it becomes a lot easier to reason about the data (either this specific url is cached or not, without having to translate it)