uilib-native 5.0.0 → 5.1.0-snapshot.7630

package/ios/reactnativeuilib/keyboardtrackingview/KeyboardTrackingViewTempManager.m

@@ -207,7 +207,9 @@ typedef NS_ENUM(NSUInteger, KeyboardTrackingScrollBehavior) {
         {
             if(_scrollViewToManage == nil)
             {
-                if ([NSStringFromClass([subview class]) isEqualToString:@"RCTScrollViewComponentView"]) {
+                if ([NSStringFromClass([subview class]) isEqualToString:@"RCTScrollViewComponentView"] &&
+                    subview.superview != self) {
+                    
                     UIScrollView *scrollView = [self extractUIScrollView:subview];
                     
                     if ([scrollView isKindOfClass:[UIScrollView class]])
@@ -434,9 +436,7 @@ typedef NS_ENUM(NSUInteger, KeyboardTrackingScrollBehavior) {
 
 - (void)_updateScrollViewInsets
 {
-    // Because our view is now being transformed inside it's superview (from RN77 it inherited a RCTLegacyViewManagerInteropComponentView as superview) we no longer need the scrollview to also update because it's inside our view
-    return;
-    /*if(self.scrollViewToManage != nil)
+    if(self.scrollViewToManage != nil)
     {
         UIEdgeInsets insets = self.scrollViewToManage.contentInset;
         CGFloat bottomSafeArea = [self getBottomSafeArea];
@@ -483,7 +483,7 @@ typedef NS_ENUM(NSUInteger, KeyboardTrackingScrollBehavior) {
             insets.bottom = bottomInset;
         }
         self.scrollViewToManage.scrollIndicatorInsets = insets;
-    }*/
+    }
 }
 
 #pragma mark - bottom view

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uilib-native",
-  "version": "5.0.0",
+  "version": "5.1.0-snapshot.7630",
   "homepage": "https://github.com/wix/react-native-ui-lib",
   "description": "uilib native components (separated from js components)",
   "main": "components/index",
@@ -10,14 +10,13 @@
   "author": "Ethan Sharabi <ethan.shar@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "lodash": "^4.17.21",
-    "prop-types": "^15.5.10"
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
     "shell-utils": "^1.0.10"
   },
   "peerDependencies": {
-    "react": ">=18.3.1",
-    "react-native": ">=0.77.3"
+    "react": ">=19.0.0",
+    "react-native": ">=0.78.3"
   }
 }

package/components/DynamicFonts/FontDownloader.d.ts

@@ -1,41 +0,0 @@
-import { FontExtension } from './FontLoader';
-export type FontDownloaderProps = {
-    /**
-     * Should be In the following convention: '/NAME'
-     */
-    dynamicFontsFolder?: string;
-    downloadErrorMessage?: string;
-    /**
-     * Enable debug mode to print extra logs
-     */
-    debug?: boolean;
-};
-export default class FontDownloader {
-    private readonly props;
-    private readonly fs;
-    constructor(props: FontDownloaderProps);
-    private log;
-    private getPrivateFolder;
-    private getPrivateFilePath;
-    private getFileName;
-    private _isFontDownloaded;
-    private createPrivateFolderIfNeeded;
-    private getDownloadFontOptions;
-    /**
-     * Download the font
-     * @param fontUri the remote location of the font
-     * @param fontName the full name of the font
-     * @param fontExtension the extension of the font, i.e. '.ttf' or '.otf'
-     * @param timeout a timeout for the download to fail after
-     * @returns the full path of the download
-     */
-    downloadFont(fontUri: string, fontName: string, fontExtension: FontExtension, timeout: number): Promise<string>;
-    /**
-     * Is the font cached (already downloaded)
-     * @param {*} fontName the full name of the font
-     * @param {*} fontExtension the extension of the font, i.e. '.ttf' or '.otf'
-     */
-    isFontDownloaded(fontName: string, fontExtension: FontExtension): Promise<boolean>;
-    readFontFromDisk(fontName: string, fontExtension: FontExtension): Promise<string | void>;
-    deleteFontFromDisk(fontFullName: string): Promise<void>;
-}

package/components/DynamicFonts/FontDownloader.js

@@ -1,140 +0,0 @@
-import { Platform } from 'react-native';
-import RNFS from "./RNFSPackage";
-const DEFAULT_DYNAMIC_FONTS_FOLDER = '/dynamicFonts';
-const DEFAULT_DOWNLOAD_ERROR_MESSAGE = 'An error occurred downloading the file:';
-// TODO: this can probably be a more general "downloader" if we so choose
-export default class FontDownloader {
-  constructor(props) {
-    this.props = {
-      dynamicFontsFolder: DEFAULT_DYNAMIC_FONTS_FOLDER,
-      downloadErrorMessage: DEFAULT_DOWNLOAD_ERROR_MESSAGE,
-      ...props
-    };
-    if (!RNFS) {
-      throw new Error(`RNUILib FontDownloader requires installing "react-native-fs" dependency`);
-    }
-    this.fs = RNFS;
-  }
-  log(message, ...optionalParams) {
-    const {
-      debug
-    } = this.props;
-    if (debug) {
-      console.log(message, optionalParams);
-    }
-  }
-  getPrivateFolder() {
-    const {
-      dynamicFontsFolder
-    } = this.props;
-    return (Platform.OS === 'android' ? this.fs.ExternalDirectoryPath : this.fs.DocumentDirectoryPath) + dynamicFontsFolder;
-  }
-  getPrivateFilePath(fileName) {
-    return this.getPrivateFolder() + '/' + fileName;
-  }
-  getFileName(fontName, fontExtension) {
-    return fontName + '.' + fontExtension;
-  }
-  async _isFontDownloaded(fileName) {
-    const privateFilePath = this.getPrivateFilePath(fileName);
-    return await this.fs.exists(privateFilePath);
-  }
-  async createPrivateFolderIfNeeded() {
-    const privateFolder = this.getPrivateFolder();
-    if (!(await this.fs.exists(privateFolder))) {
-      await this.fs.mkdir(privateFolder);
-    }
-  }
-  getDownloadFontOptions(fontUri, downloadLocation, readTimeout) {
-    const platformSpecificOptions = Platform.OS === 'ios' ? {
-      background: false,
-      discretionary: true,
-      cacheable: false
-    } : {
-      connectionTimeout: readTimeout
-    };
-    return {
-      fromUrl: fontUri,
-      toFile: downloadLocation,
-      // TODO: It is possible to add a better progress, maybe for slower networks
-      // progress: ({bytesWritten, contentLength}: {bytesWritten: number; contentLength: number}) => {},
-      ...platformSpecificOptions,
-      fileCache: false,
-      readTimeout
-    };
-  }
-
-  /**
-   * Download the font
-   * @param fontUri the remote location of the font
-   * @param fontName the full name of the font
-   * @param fontExtension the extension of the font, i.e. '.ttf' or '.otf'
-   * @param timeout a timeout for the download to fail after
-   * @returns the full path of the download
-   */
-  async downloadFont(fontUri, fontName, fontExtension, timeout) {
-    const {
-      downloadErrorMessage
-    } = this.props;
-    await this.createPrivateFolderIfNeeded();
-    const fileName = this.getFileName(fontName, fontExtension);
-    const downloadLocation = this.getPrivateFilePath(fileName);
-    try {
-      this.log(fontName, 'Starting to download');
-      const result = await this.fs.downloadFile(this.getDownloadFontOptions(fontUri, downloadLocation, timeout)).promise;
-      if (result.statusCode === 200) {
-        this.log(fontName, 'Finished downloading');
-        return downloadLocation;
-      } else {
-        this.log(fontName, 'Error downloading statusCode:', result.statusCode);
-        return Promise.reject({
-          source: 'uilib:FontDownloader:downloadFont',
-          message: `${downloadErrorMessage} fontName: ${fontName} statusCode: ${result.statusCode}`
-        });
-      }
-    } catch (error) {
-      this.log(fontName, 'Error downloading error:', error);
-      return Promise.reject({
-        source: 'uilib:FontDownloader:downloadFont',
-        message: `${downloadErrorMessage} fontName: ${fontName} error: ${JSON.stringify(error)}`
-      });
-    }
-  }
-
-  /**
-   * Is the font cached (already downloaded)
-   * @param {*} fontName the full name of the font
-   * @param {*} fontExtension the extension of the font, i.e. '.ttf' or '.otf'
-   */
-  async isFontDownloaded(fontName, fontExtension) {
-    const fileName = this.getFileName(fontName, fontExtension);
-    return await this._isFontDownloaded(fileName);
-  }
-  async readFontFromDisk(fontName, fontExtension) {
-    let base64FontString;
-    const fileName = this.getFileName(fontName, fontExtension);
-    const privateFilePath = this.getPrivateFilePath(fileName);
-    if (await this.fs.exists(privateFilePath)) {
-      this.log(fontName, 'Starting to read from disk');
-      base64FontString = await this.fs.readFile(privateFilePath, 'base64').catch(err => {
-        this.log(fontName, 'Failed reading from disk:', err);
-      });
-      this.log(fontName, 'Finished reading from disk');
-    } else {
-      this.log(fontName, 'File does not exist (read)');
-    }
-    return base64FontString;
-  }
-  async deleteFontFromDisk(fontFullName) {
-    const privateFilePath = this.getPrivateFilePath(fontFullName);
-    if (await this.fs.exists(privateFilePath)) {
-      this.log(fontFullName, 'Starting to delete');
-      await this.fs.unlink(privateFilePath).catch(err => {
-        this.log(fontFullName, 'Failed deleting:', err);
-      });
-      this.log(fontFullName, 'Finished deleting');
-    } else {
-      this.log(fontFullName, 'File does not exist (delete)');
-    }
-  }
-}

package/components/DynamicFonts/FontLoader.d.ts

@@ -1,35 +0,0 @@
-export type FontExtension = 'ttf' | 'otf';
-export type LoadFontInput = {
-    /**
-     * Specify registered font name (doesn't work for iOS)
-     */
-    fontName: string;
-    /**
-     * This can be a data URI or raw base64...
-     * if it is raw base64 type must be specified,
-     * but defaults to TTF (data URI mime: font/ttf or font/otf)
-     */
-    base64FontString: string;
-    /**
-     * Specify the type of font in the encoded data (ttf or otf). Defaults to "ttf"
-     */
-    fontExtension: FontExtension;
-    /**
-     * Force the loading of the font even if previously loaded it
-     */
-    forceLoad?: boolean;
-};
-export type FontLoaderProps = {
-    /**
-     * Enable debug mode to print extra logs
-     */
-    debug?: boolean;
-};
-export default class FontLoader {
-    private readonly props;
-    private readonly loadedFonts;
-    constructor(props: FontLoaderProps);
-    private log;
-    loadFont: ({ fontName, base64FontString, fontExtension, forceLoad }: LoadFontInput) => Promise<string>;
-    loadFonts: (fonts: LoadFontInput | LoadFontInput[], forceLoad?: boolean) => Promise<string[]>;
-}

package/components/DynamicFonts/FontLoader.js

@@ -1,89 +0,0 @@
-import { NativeModules } from 'react-native';
-const {
-  DynamicFont
-} = NativeModules;
-export default class FontLoader {
-  loadedFonts = new Map();
-  constructor(props) {
-    this.props = props;
-  }
-  log(message, ...optionalParams) {
-    const {
-      debug
-    } = this.props;
-    if (debug) {
-      console.log(message, optionalParams);
-    }
-  }
-  loadFont = ({
-    fontName,
-    base64FontString,
-    fontExtension = 'ttf',
-    forceLoad = false
-  }) => {
-    /* Check if this font was already loaded */
-    if (!forceLoad && this.loadedFonts.has(fontName)) {
-      this.log(fontName, 'Already loaded');
-      return Promise.resolve(this.loadedFonts.get(fontName));
-    }
-    if (!fontName) {
-      throw new Error('fontName is a required argument');
-    }
-    if (!base64FontString) {
-      throw new Error('base64FontString is a required argument');
-    }
-    this.log(fontName, 'Starting to load');
-    /* Load font via native binary code */
-    return new Promise((resolve, reject) => {
-      DynamicFont.loadFont({
-        name: fontName,
-        data: base64FontString,
-        type: fontExtension
-      }, (err, givenName) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        /* Loaded successfully... resolve promise with "real" font name */
-        this.loadedFonts.set(fontName, givenName);
-        resolve(givenName);
-      });
-    });
-  };
-
-  // TODO: Needs to be tested
-  // public loadFontFromFile = (fontName: string, filePath: string) => {
-  //   if (!fontName) {
-  //     throw new Error('name is a required argument');
-  //   }
-
-  //   if (!filePath) {
-  //     throw new Error('filePath is a required argument');
-  //   }
-
-  //   return new Promise((resolve, reject) => {
-  //     DynamicFont.loadFontFromFile({
-  //       name: fontName,
-  //       filePath
-  //     },
-  //     (err: string, givenName: string) => {
-  //       if (err) {
-  //         reject(err);
-  //         return;
-  //       }
-  //       resolve(givenName);
-  //     });
-  //   });
-  // };
-
-  loadFonts = (fonts, forceLoad) => {
-    if (!fonts) {
-      return Promise.resolve([]);
-    }
-    const fontsArray = fonts instanceof Array ? fonts : [fonts];
-    return Promise.all(fontsArray.filter(font => font).map(font => this.loadFont({
-      forceLoad,
-      ...font
-    })));
-  };
-}

package/components/DynamicFonts/NoPermissionsAcquirer.d.ts

@@ -1,3 +0,0 @@
-export default class NoPermissionsAcquirer {
-    getPermissions(): Promise<void>;
-}

package/components/DynamicFonts/NoPermissionsAcquirer.js

@@ -1,5 +0,0 @@
-export default class NoPermissionsAcquirer {
-  async getPermissions() {
-    return Promise.resolve();
-  }
-}

package/components/DynamicFonts/PermissionsAcquirer.android.d.ts

@@ -1,13 +0,0 @@
-export type PermissionsAcquirerProps = {
-    requestPermissionsTitle?: string;
-    requestPermissionsMessage?: string;
-    requestPermissionsPositiveButtonText?: string;
-    permissionsRefusalMessage?: string;
-    permissionsErrorMessage?: string;
-};
-export default class PermissionsAcquirer {
-    private readonly props;
-    constructor(props: PermissionsAcquirerProps);
-    checkPermissions(): Promise<boolean>;
-    getPermissions(): Promise<void>;
-}

package/components/DynamicFonts/PermissionsAcquirer.android.js

@@ -1,42 +0,0 @@
-import { Platform, PermissionsAndroid } from 'react-native';
-const AndroidOsVersion = Platform.OS === 'android' ? Platform.constants.Release : undefined;
-const DEFAULT_PERMISSIONS_ACQUIRER_PROPS = {
-  requestPermissionsTitle: 'Allow Storage Access',
-  requestPermissionsMessage: 'Give the app permission to access the files and storage on your device.',
-  requestPermissionsPositiveButtonText: 'Continue',
-  permissionsRefusalMessage: 'Please edit your permission settings to continue.',
-  permissionsErrorMessage: `We weren't able to obtain the required permissions. Please try Again.`
-};
-export default class PermissionsAcquirer {
-  constructor(props) {
-    this.props = props;
-  }
-  async checkPermissions() {
-    return await PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE);
-  }
-  async getPermissions() {
-    if (AndroidOsVersion && Number(AndroidOsVersion) >= 13 || (await this.checkPermissions())) {
-      return Promise.resolve();
-    }
-    try {
-      const result = await PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE, {
-        title: this.props.requestPermissionsTitle ?? DEFAULT_PERMISSIONS_ACQUIRER_PROPS.requestPermissionsTitle,
-        message: this.props.requestPermissionsMessage ?? DEFAULT_PERMISSIONS_ACQUIRER_PROPS.requestPermissionsMessage,
-        buttonPositive: this.props.requestPermissionsPositiveButtonText ?? DEFAULT_PERMISSIONS_ACQUIRER_PROPS.requestPermissionsPositiveButtonText
-      });
-      if (result === PermissionsAndroid.RESULTS.GRANTED) {
-        return Promise.resolve();
-      } else {
-        return Promise.reject({
-          source: 'uilib:FontDownloader:getPermissions',
-          message: this.props.permissionsRefusalMessage ?? DEFAULT_PERMISSIONS_ACQUIRER_PROPS.permissionsRefusalMessage
-        });
-      }
-    } catch (err) {
-      return Promise.reject({
-        source: 'uilib:FontDownloader:getPermissions',
-        message: this.props.permissionsErrorMessage ?? DEFAULT_PERMISSIONS_ACQUIRER_PROPS.permissionsErrorMessage
-      });
-    }
-  }
-}

package/components/DynamicFonts/PermissionsAcquirer.ios.d.ts

@@ -1,2 +0,0 @@
-import PermissionsAcquirer from './NoPermissionsAcquirer';
-export default PermissionsAcquirer;

package/components/DynamicFonts/PermissionsAcquirer.ios.js

@@ -1,2 +0,0 @@
-import PermissionsAcquirer from "./NoPermissionsAcquirer";
-export default PermissionsAcquirer;

package/components/DynamicFonts/PermissionsAcquirer.web.d.ts

@@ -1,2 +0,0 @@
-import PermissionsAcquirer from './NoPermissionsAcquirer';
-export default PermissionsAcquirer;

package/components/DynamicFonts/PermissionsAcquirer.web.js

@@ -1,2 +0,0 @@
-import PermissionsAcquirer from "./NoPermissionsAcquirer";
-export default PermissionsAcquirer;

package/components/DynamicFonts/RNFSPackage.d.ts

@@ -1,2 +0,0 @@
-declare let RNFS: typeof import('react-native-fs') | undefined;
-export default RNFS;

package/components/DynamicFonts/RNFSPackage.js

@@ -1,5 +0,0 @@
-let RNFS;
-try {
-  RNFS = require('react-native-fs');
-} catch (error) {}
-export default RNFS;

package/components/DynamicFonts/index.d.ts

@@ -1,61 +0,0 @@
-import { FontExtension } from './FontLoader';
-import { FontDownloaderProps } from './FontDownloader';
-import type { PermissionsAcquirerProps } from './PermissionsAcquirer.android';
-type DynamicFontsProps = {
-    fontDownloadingProps?: Omit<FontDownloaderProps, 'debug'>;
-    permissionsAcquirerProps?: PermissionsAcquirerProps;
-    fontLoadErrorMessage?: string;
-    /**
-     * Enable debug mode to print extra logs
-     */
-    debug?: boolean;
-    /**
-     * Do not request permissions
-     */
-    doNotRequestPermissions?: boolean;
-};
-type GetFontInput = {
-    /**
-     * The uri of the font (to be downloaded from)
-     */
-    fontUri: string;
-    /**
-     * The full name of the font
-     */
-    fontName: string;
-    /**
-     * The extension of the font, i.e. '.ttf' or '.otf'
-     */
-    fontExtension: FontExtension;
-    /**
-     * Milliseconds for the download to complete in (defaults to 5000)
-     */
-    timeout?: number;
-};
-export { DynamicFontsProps, FontExtension, GetFontInput };
-export default class DynamicFonts {
-    private readonly props;
-    private readonly permissionsAcquirer;
-    private readonly fontLoader;
-    private readonly fontDownloader;
-    constructor(props: DynamicFontsProps);
-    private log;
-    private loadFont;
-    /**
-     * Get font - download from uri (or from cache if already downloaded) and load it to memory
-     * You need to handle errors in the form of Promise.reject
-     * @param fontUri the uri of the font (to be downloaded from)
-     * @param fontName the full name of the font
-     * @param fontExtension the extension of the font, i.e. '.ttf' or '.otf'
-     * @param timeout milliseconds for the download to complete in (defaults to 5000)
-     */
-    getFont({ fontUri, fontName, fontExtension, timeout }: GetFontInput): Promise<string>;
-    getFonts(fonts: GetFontInput | GetFontInput[]): Promise<string[]>;
-    private buildFontData;
-    getFontFamily(rootUri: string, fontNames: string[], fontExtension: FontExtension, fontNamePrefix?: string, retries?: number): Promise<string[]>;
-    private deleteFontFromDisk;
-    deleteFont(fontName: string, fontExtension: FontExtension): Promise<void>;
-    deleteFontFamily(fontNames: string[], fontExtension: FontExtension, fontNamePrefix?: string): Promise<void>;
-    isFontDownloaded(fontName: string, fontExtension: FontExtension): Promise<boolean>;
-    isFontFamilyDownloaded(rootUri: string, fontNames: string[], fontExtension: FontExtension, fontNamePrefix?: string): Promise<boolean>;
-}

package/components/DynamicFonts/index.js

@@ -1,154 +0,0 @@
-import FontLoader, { FontExtension } from "./FontLoader";
-import FontDownloader from "./FontDownloader";
-// @ts-expect-error
-import PermissionsAcquirer from "./PermissionsAcquirer";
-import NoPermissionsAcquirer from "./NoPermissionsAcquirer";
-const DEFAULT_FONT_LOAD_ERROR_MESSAGE = 'Unable to load this font.';
-export { FontExtension };
-export default class DynamicFonts {
-  constructor(props) {
-    const {
-      debug = __DEV__,
-      doNotRequestPermissions
-    } = props;
-    this.props = {
-      fontLoadErrorMessage: DEFAULT_FONT_LOAD_ERROR_MESSAGE,
-      ...props
-    };
-    this.permissionsAcquirer = doNotRequestPermissions ? new NoPermissionsAcquirer() : new PermissionsAcquirer(this.props.permissionsAcquirerProps ?? {});
-    this.fontLoader = new FontLoader({
-      debug
-    });
-    const fontDownloadingProps = this.props.fontDownloadingProps ?? {};
-    this.fontDownloader = new FontDownloader({
-      ...fontDownloadingProps,
-      debug
-    });
-  }
-  log(message, ...optionalParams) {
-    const {
-      debug
-    } = this.props;
-    if (debug) {
-      console.log(message, optionalParams);
-    }
-  }
-  async loadFont(input) {
-    const {
-      fontLoadErrorMessage
-    } = this.props;
-    try {
-      return await this.fontLoader.loadFont(input);
-    } catch (err) {
-      return Promise.reject({
-        source: 'uilib:FontDownloader:loadFont',
-        message: `${fontLoadErrorMessage} fontName: ${input.fontName} error: ${JSON.stringify(err)}`
-      });
-    }
-  }
-
-  /**
-   * Get font - download from uri (or from cache if already downloaded) and load it to memory
-   * You need to handle errors in the form of Promise.reject
-   * @param fontUri the uri of the font (to be downloaded from)
-   * @param fontName the full name of the font
-   * @param fontExtension the extension of the font, i.e. '.ttf' or '.otf'
-   * @param timeout milliseconds for the download to complete in (defaults to 5000)
-   */
-  async getFont({
-    fontUri,
-    fontName,
-    fontExtension,
-    timeout = 5000
-  }) {
-    const {
-      fontLoadErrorMessage
-    } = this.props;
-    await this.permissionsAcquirer.getPermissions();
-    if (await this.fontDownloader.isFontDownloaded(fontName, fontExtension)) {
-      this.log(fontName, 'Already downloaded');
-    } else {
-      await this.fontDownloader.downloadFont(fontUri, fontName, fontExtension, timeout);
-    }
-    const base64FontString = await this.fontDownloader.readFontFromDisk(fontName, fontExtension);
-    if (base64FontString) {
-      this.log(fontName, 'Loading');
-      const _fontName = await this.loadFont({
-        fontName,
-        base64FontString,
-        fontExtension
-      });
-      this.log(_fontName, 'Finished loading');
-      return Promise.resolve(_fontName);
-    } else {
-      return Promise.reject({
-        source: 'uilib:FontDownloader:getFont',
-        message: `${fontLoadErrorMessage} fontName: ${fontName}`
-      });
-    }
-  }
-  async getFonts(fonts) {
-    await this.permissionsAcquirer.getPermissions();
-    if (fonts instanceof Array) {
-      return Promise.all(fonts.filter(font => font).map(font => this.getFont(font)));
-    } else {
-      return Promise.resolve([await this.getFont(fonts)]);
-    }
-  }
-  buildFontData(rootUri, fontName, fontExtension, fontNamePrefix) {
-    const _fontName = `${fontNamePrefix ?? ''}${fontName}`;
-    const fullFontName = `${_fontName}.${fontExtension}`;
-    return {
-      fontUri: `${rootUri}${fullFontName}`,
-      fontName: _fontName,
-      fontExtension,
-      fullFontName
-    };
-  }
-
-  // eslint-disable-next-line max-params
-  async getFontFamily(rootUri, fontNames, fontExtension, fontNamePrefix, retries = 1) {
-    const fonts = fontNames.map(fontName => this.buildFontData(rootUri, fontName, fontExtension, fontNamePrefix));
-    let fontsLoaded = [];
-    let tryCounter = 0;
-    while (fontsLoaded.length < fontNames.length && tryCounter < retries) {
-      try {
-        ++tryCounter;
-        // TODO: we should return successful loaded fonts and not fail all of them
-        fontsLoaded = await this.getFonts(fonts);
-      } catch (error) {
-        this.log(`getFontFamily failed (try #${tryCounter}) error:`, error);
-      }
-    }
-    return Promise.resolve(fontsLoaded);
-  }
-  async deleteFontFromDisk(fontName, fontExtension, fontNamePrefix) {
-    const fontInput = this.buildFontData('', fontName, fontExtension, fontNamePrefix);
-    await this.fontDownloader.deleteFontFromDisk(fontInput.fullFontName);
-  }
-  async deleteFont(fontName, fontExtension) {
-    await this.permissionsAcquirer.getPermissions();
-    await this.deleteFontFromDisk(fontName, fontExtension);
-  }
-  async deleteFontFamily(fontNames, fontExtension, fontNamePrefix) {
-    await this.permissionsAcquirer.getPermissions();
-    fontNames.forEach(async fontName => {
-      await this.deleteFontFromDisk(fontName, fontExtension, fontNamePrefix);
-    });
-  }
-  async isFontDownloaded(fontName, fontExtension) {
-    return await this.fontDownloader.isFontDownloaded(fontName, fontExtension);
-  }
-  async isFontFamilyDownloaded(rootUri, fontNames, fontExtension, fontNamePrefix) {
-    const fonts = fontNames.map(fontName => this.buildFontData(rootUri, fontName, fontExtension, fontNamePrefix));
-    try {
-      const areDownloaded = await Promise.all(fonts.filter(font => font).map(font => {
-        return this.fontDownloader.isFontDownloaded(font.fontName, font.fontExtension);
-      }));
-      return Promise.resolve(areDownloaded.every(v => v === true));
-    } catch (error) {
-      this.log(`isFontFamilyDownloaded failed error:`, error);
-      return Promise.resolve(false);
-    }
-  }
-}