uilib-native 4.1.0 → 4.1.2

package/android/build/.transforms/107c050573bf60c5e0c8269943a793ec/results.bin

@@ -0,0 +1 @@
+o/classes

package/android/build/.transforms/7c61673e4df105aee95a22a8dfbf4af6/results.bin

@@ -0,0 +1 @@
+o/classes

package/android/src/main/java/com/wix/reactnativeuilib/dynamicfont/DynamicFontModule.java

@@ -1,35 +1,24 @@
 package com.wix.reactnativeuilib.dynamicfont;
 
+import android.app.Activity;
+import android.graphics.Typeface;
+import android.util.Base64;
+
+import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.bridge.Callback;
-import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.views.text.ReactFontManager;
 
-import android.app.Activity;
-import android.graphics.Typeface;
-import android.util.Base64;
-
 import java.io.File;
 import java.io.FileOutputStream;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
 public class DynamicFontModule extends ReactContextBaseJavaModule {
   int tempNameCounter = 0;
 
-  private final ReactApplicationContext reactContext;
-
   public DynamicFontModule(ReactApplicationContext reactContext) {
     super(reactContext);
-    this.reactContext = reactContext;
   }
 
   @Override
@@ -37,42 +26,44 @@ public class DynamicFontModule extends ReactContextBaseJavaModule {
     return "DynamicFont";
   }
 
-  @ReactMethod
-  public void loadFontFromFile(final ReadableMap options, final Callback callback) {
-    Activity currentActivity = getCurrentActivity();
-    if (currentActivity == null) {
-      callback.invoke("Invalid activity");
-      return;
-    }
-
-    String filePath = options.hasKey("filePath") ? options.getString("filePath") : null,
-           name = (options.hasKey("name")) ? options.getString("name") : null;
-
-    if (filePath == null || filePath.length() == 0) {
-      callback.invoke("filePath property empty");
-      return;
-    }
-
-    File f = new File(filePath);
-
-    if (f.exists() && f.canRead()) {
-      boolean wasLoaded = false;
-      try {
-        Typeface typeface = Typeface.createFromFile(f);
-        //Cache the font for react
-        ReactFontManager.getInstance().setTypeface(name, typeface.getStyle(), typeface);
-        wasLoaded = true;
-      } catch (Throwable e) {
-        callback.invoke(e.getMessage());
-      } finally {
-        if (wasLoaded) {
-          callback.invoke(null, name);
-        }
-      }
-    } else {
-      callback.invoke("invalid file");
-    }
-  }
+  // TODO: Needs to be tested
+  // @ReactMethod
+  // public void loadFontFromFile(final ReadableMap options, final Callback callback) {
+  //   Activity currentActivity = getCurrentActivity();
+  //   if (currentActivity == null) {
+  //     callback.invoke("Invalid activity");
+  //     return;
+  //   }
+
+  //   String filePath = options.hasKey("filePath") ? options.getString("filePath") : null,
+  //          name = (options.hasKey("name")) ? options.getString("name") : null;
+
+  //   if (filePath == null || filePath.length() == 0) {
+  //     callback.invoke("filePath property empty");
+  //     return;
+  //   }
+
+  //   File f = new File(filePath);
+
+  //   if (f.exists() && f.canRead()) {
+  //     boolean wasLoaded = false;
+  //     try {
+  //       Typeface typeface = Typeface.createFromFile(f);
+  //       //Cache the font for react
+  // TODO: probably needs to be Typeface.NORMAL and not typeface.getStyle()
+  //       ReactFontManager.getInstance().setTypeface(name, typeface.getStyle(), typeface);
+  //       wasLoaded = true;
+  //     } catch (Throwable e) {
+  //       callback.invoke(e.getMessage());
+  //     } finally {
+  //       if (wasLoaded) {
+  //         callback.invoke(null, name);
+  //       }
+  //     }
+  //   } else {
+  //     callback.invoke("invalid file");
+  //   }
+  // }
 
   @ReactMethod
   public void loadFont(final ReadableMap options, final Callback callback) throws Exception {
@@ -136,7 +127,7 @@ public class DynamicFontModule extends ReactContextBaseJavaModule {
       Typeface typeface = Typeface.createFromFile(cacheFile);
 
       //Cache the font for react
-      ReactFontManager.getInstance().setTypeface(name, typeface.getStyle(), typeface);
+      ReactFontManager.getInstance().setTypeface(name, Typeface.NORMAL, typeface);
 
       cacheFile.delete();
     } catch(Exception e) {

package/android/src/main/java/com/wix/reactnativeuilib/dynamicfont/DynamicFontPackage.java

@@ -9,6 +9,7 @@ import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.bridge.JavaScriptModule;
+
 public class DynamicFontPackage implements ReactPackage {
     @Override
     public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
@@ -24,4 +25,4 @@ public class DynamicFontPackage implements ReactPackage {
     public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
       return Collections.emptyList();
     }
-}
+}

package/android/src/main/java/com/wix/reactnativeuilib/keyboardinput/ReactScreenMonitor.java

@@ -62,7 +62,9 @@ public class ReactScreenMonitor implements LifecycleEventListener {
     }
 
     private void registerWindowLayoutListener() {
-        getWindow().getDecorView().getViewTreeObserver().addOnGlobalLayoutListener(mWindowLayoutListener);
+        if (getWindow() != null) {
+            getWindow().getDecorView().getViewTreeObserver().addOnGlobalLayoutListener(mWindowLayoutListener);
+        }
     }
 
     private void removeWindowLayoutListener() {

package/components/DynamicFonts/FontDownloader.ts

@@ -1,5 +1,5 @@
 import {Platform} from 'react-native';
-import fs from 'react-native-fs';
+import RNFS from './RNFSPackage';
 import {FontExtension} from './FontLoader';
 
 const DEFAULT_DYNAMIC_FONTS_FOLDER = '/dynamicFonts';
@@ -20,6 +20,7 @@ export type FontDownloaderProps = {
 // TODO: this can probably be a more general "downloader" if we so choose
 export default class FontDownloader {
   private readonly props: FontDownloaderProps;
+  private readonly fs: NonNullable<typeof RNFS>;
 
   constructor(props: FontDownloaderProps) {
     this.props = {
@@ -27,11 +28,25 @@ export default class FontDownloader {
       downloadErrorMessage: DEFAULT_DOWNLOAD_ERROR_MESSAGE,
       ...props
     };
+
+    if (!RNFS) {
+      throw new Error(`RNUILib FontDownloader requires installing "react-native-fs" dependency`);
+    }
+    this.fs = RNFS;
+  }
+
+  private log(message?: any, ...optionalParams: any[]) {
+    const {debug} = this.props;
+    if (debug) {
+      console.log(message, optionalParams);
+    }
   }
 
   private getPrivateFolder() {
     const {dynamicFontsFolder} = this.props;
-    return (Platform.OS === 'android' ? fs.ExternalDirectoryPath : fs.DocumentDirectoryPath) + dynamicFontsFolder;
+    return (
+      (Platform.OS === 'android' ? this.fs.ExternalDirectoryPath : this.fs.DocumentDirectoryPath) + dynamicFontsFolder
+    );
   }
 
   private getPrivateFilePath(fileName: string) {
@@ -44,13 +59,13 @@ export default class FontDownloader {
 
   private async _isFontDownloaded(fileName: string) {
     const privateFilePath = this.getPrivateFilePath(fileName);
-    return await fs.exists(privateFilePath);
+    return await this.fs.exists(privateFilePath);
   }
 
   private async createPrivateFolderIfNeeded() {
     const privateFolder = this.getPrivateFolder();
-    if (!(await fs.exists(privateFolder))) {
-      await fs.mkdir(privateFolder);
+    if (!(await this.fs.exists(privateFolder))) {
+      await this.fs.mkdir(privateFolder);
     }
   }
 
@@ -95,19 +110,24 @@ export default class FontDownloader {
     const downloadLocation = this.getPrivateFilePath(fileName);
 
     try {
-      const result = await fs.downloadFile(this.getDownloadFontOptions(fontUri, downloadLocation, timeout)).promise;
+      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: ${error}`
+        message: `${downloadErrorMessage} fontName: ${fontName} error: ${JSON.stringify(error)}`
       });
     }
   }
@@ -126,10 +146,29 @@ export default class FontDownloader {
     let base64FontString;
     const fileName = this.getFileName(fontName, fontExtension);
     const privateFilePath = this.getPrivateFilePath(fileName);
-    if (await fs.exists(privateFilePath)) {
-      base64FontString = await fs.readFile(privateFilePath, 'base64').catch(() => {});
+    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;
   }
+
+  public async deleteFontFromDisk(fontFullName: string): Promise<void> {
+    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.ts

@@ -40,18 +40,22 @@ export default class FontLoader {
     this.props = props;
   }
 
+  private log(message?: any, ...optionalParams: any[]) {
+    const {debug} = this.props;
+    if (debug) {
+      console.log(message, optionalParams);
+    }
+  }
+
   public loadFont = ({
     fontName,
     base64FontString,
     fontExtension = 'ttf',
     forceLoad = false
   }: LoadFontInput): Promise<string> => {
-    const {debug} = this.props;
     /* Check if this font was already loaded */
     if (!forceLoad && this.loadedFonts.has(fontName)) {
-      if (debug) {
-        console.log(fontName, 'Already loaded');
-      }
+      this.log(fontName, 'Already loaded');
       return Promise.resolve(this.loadedFonts.get(fontName) as string);
     }
 
@@ -63,9 +67,7 @@ export default class FontLoader {
       throw new Error('base64FontString is a required argument');
     }
 
-    if (debug) {
-      console.log(fontName, 'Starting to load');
-    }
+    this.log(fontName, 'Starting to load');
     /* Load font via native binary code */
     return new Promise((resolve, reject) => {
       DynamicFont.loadFont({
@@ -85,29 +87,30 @@ export default class FontLoader {
     });
   };
 
-  public loadFontFromFile = (fontName: string, filePath: string) => {
-    if (!fontName) {
-      throw new Error('name is a required argument');
-    }
+  // 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');
-    }
+  //   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);
-      });
-    });
-  };
+  //   return new Promise((resolve, reject) => {
+  //     DynamicFont.loadFontFromFile({
+  //       name: fontName,
+  //       filePath
+  //     },
+  //     (err: string, givenName: string) => {
+  //       if (err) {
+  //         reject(err);
+  //         return;
+  //       }
+  //       resolve(givenName);
+  //     });
+  //   });
+  // };
 
   public loadFonts = (fonts: LoadFontInput | LoadFontInput[], forceLoad?: boolean) => {
     if (!fonts) {

package/components/DynamicFonts/NoPermissionsAcquirer.ts

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

package/components/DynamicFonts/PermissionsAcquirer.android.ts

@@ -4,7 +4,6 @@ const AndroidOsVersion = Platform.OS === 'android' ? Platform.constants.Release
 export type PermissionsAcquirerProps = {
   requestPermissionsTitle?: string;
   requestPermissionsMessage?: string;
-  requestPermissionsNegativeButtonText?: string;
   requestPermissionsPositiveButtonText?: string;
   permissionsRefusalMessage?: string;
   permissionsErrorMessage?: string;
@@ -12,8 +11,7 @@ export type PermissionsAcquirerProps = {
 
 const DEFAULT_PERMISSIONS_ACQUIRER_PROPS: Required<PermissionsAcquirerProps> = {
   requestPermissionsTitle: 'Allow Storage Access',
-  requestPermissionsMessage: 'Give the Spaces app permission to access the files and storage on your device.',
-  requestPermissionsNegativeButtonText: 'Cancel',
+  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.`
@@ -38,9 +36,6 @@ export default class PermissionsAcquirer {
       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,
-        buttonNegative:
-          this.props.requestPermissionsNegativeButtonText ??
-          DEFAULT_PERMISSIONS_ACQUIRER_PROPS.requestPermissionsNegativeButtonText,
         buttonPositive:
           this.props.requestPermissionsPositiveButtonText ??
           DEFAULT_PERMISSIONS_ACQUIRER_PROPS.requestPermissionsPositiveButtonText

package/components/DynamicFonts/PermissionsAcquirer.ios.ts

@@ -1,9 +1,3 @@
-export default class PermissionsAcquirer {
-  public async checkPermissions() {
-    return Promise.resolve(true);
-  }
+import PermissionsAcquirer from './NoPermissionsAcquirer';
 
-  public async getPermissions() {
-    return Promise.resolve();
-  }
-}
+export default PermissionsAcquirer;

package/components/DynamicFonts/PermissionsAcquirer.web.ts

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

package/components/DynamicFonts/RNFSPackage.ts

@@ -0,0 +1,6 @@
+let RNFS: typeof import('react-native-fs') | undefined;
+try {
+  RNFS = require('react-native-fs');
+} catch (error) {}
+
+export default RNFS;

package/components/DynamicFonts/index.ts

@@ -1,9 +1,9 @@
-import {Platform} from 'react-native';
 import FontLoader, {FontExtension, LoadFontInput} from './FontLoader';
 import FontDownloader, {FontDownloaderProps} from './FontDownloader';
-import PermissionsAcquirerAndroid, {PermissionsAcquirerProps} from './PermissionsAcquirer.android';
-import PermissionsAcquirerIOS from './PermissionsAcquirer.ios';
-const PermissionsAcquirer = Platform.OS === 'android' ? PermissionsAcquirerAndroid : PermissionsAcquirerIOS;
+import type {PermissionsAcquirerProps} from './PermissionsAcquirer.android';
+// @ts-expect-error
+import PermissionsAcquirer from './PermissionsAcquirer';
+import NoPermissionsAcquirer from './NoPermissionsAcquirer';
 
 const DEFAULT_FONT_LOAD_ERROR_MESSAGE = 'Unable to load this font.';
 
@@ -15,6 +15,10 @@ type DynamicFontsProps = {
    * Enable debug mode to print extra logs
    */
   debug?: boolean;
+  /**
+   * Do not request permissions
+   */
+  doNotRequestPermissions?: boolean;
 };
 
 type GetFontInput = {
@@ -45,14 +49,23 @@ export default class DynamicFonts {
   private readonly fontDownloader: InstanceType<typeof FontDownloader>;
 
   constructor(props: DynamicFontsProps) {
-    const {debug} = props;
+    const {debug = __DEV__, doNotRequestPermissions} = props;
     this.props = {fontLoadErrorMessage: DEFAULT_FONT_LOAD_ERROR_MESSAGE, ...props};
-    this.permissionsAcquirer = new PermissionsAcquirer(this.props.permissionsAcquirerProps ?? {});
+    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});
   }
 
+  private log(message?: any, ...optionalParams: any[]) {
+    const {debug} = this.props;
+    if (debug) {
+      console.log(message, optionalParams);
+    }
+  }
+
   private async loadFont(input: LoadFontInput) {
     const {fontLoadErrorMessage} = this.props;
     try {
@@ -60,7 +73,7 @@ export default class DynamicFonts {
     } catch (err) {
       return Promise.reject({
         source: 'uilib:FontDownloader:loadFont',
-        message: `${fontLoadErrorMessage} fontName: ${input.fontName}`
+        message: `${fontLoadErrorMessage} fontName: ${input.fontName} error: ${JSON.stringify(err)}`
       });
     }
   }
@@ -74,32 +87,19 @@ export default class DynamicFonts {
    * @param timeout milliseconds for the download to complete in (defaults to 5000)
    */
   public async getFont({fontUri, fontName, fontExtension, timeout = 5000}: GetFontInput): Promise<string> {
-    const {debug} = this.props;
     const {fontLoadErrorMessage} = this.props;
     await this.permissionsAcquirer.getPermissions();
     if (await this.fontDownloader.isFontDownloaded(fontName, fontExtension)) {
-      if (debug) {
-        console.log(fontName, 'Already downloaded');
-      }
+      this.log(fontName, 'Already downloaded');
     } else {
-      if (debug) {
-        console.log(fontName, 'Starting to download');
-      }
       await this.fontDownloader.downloadFont(fontUri, fontName, fontExtension, timeout);
-      if (debug) {
-        console.log(fontName, 'Finished downloading');
-      }
     }
 
     const base64FontString = await this.fontDownloader.readFontFromDisk(fontName, fontExtension);
     if (base64FontString) {
-      if (debug) {
-        console.log(fontName, 'Loading');
-      }
+      this.log(fontName, 'Loading');
       const _fontName = await this.loadFont({fontName, base64FontString, fontExtension});
-      if (debug) {
-        console.log(_fontName, 'Finished loading');
-      }
+      this.log(_fontName, 'Finished loading');
       return Promise.resolve(_fontName);
     } else {
       return Promise.reject({
@@ -118,13 +118,13 @@ export default class DynamicFonts {
     }
   }
 
-  private buildFontName(rootUri: string,
+  private buildFontData(rootUri: string,
     fontName: string,
     fontExtension: FontExtension,
-    fontNamePrefix?: string): GetFontInput {
+    fontNamePrefix?: string): GetFontInput & {fullFontName: string} {
     const _fontName = `${fontNamePrefix ?? ''}${fontName}`;
     const fullFontName = `${_fontName}.${fontExtension}`;
-    return {fontUri: `${rootUri}${fullFontName}`, fontName: _fontName, fontExtension};
+    return {fontUri: `${rootUri}${fullFontName}`, fontName: _fontName, fontExtension, fullFontName};
   }
 
   // eslint-disable-next-line max-params
@@ -133,9 +133,8 @@ export default class DynamicFonts {
     fontExtension: FontExtension,
     fontNamePrefix?: string,
     retries = 1): Promise<string[]> {
-    const {debug} = this.props;
     const fonts: GetFontInput[] = fontNames.map(fontName =>
-      this.buildFontName(rootUri, fontName, fontExtension, fontNamePrefix));
+      this.buildFontData(rootUri, fontName, fontExtension, fontNamePrefix));
     let fontsLoaded: string[] = [];
     let tryCounter = 0;
     while (fontsLoaded.length < fontNames.length && tryCounter < retries) {
@@ -144,12 +143,52 @@ export default class DynamicFonts {
         // TODO: we should return successful loaded fonts and not fail all of them
         fontsLoaded = await this.getFonts(fonts);
       } catch (error) {
-        if (debug) {
-          console.log(`getFontFamily failed (try #${tryCounter}) error: ${error}`);
-        }
+        this.log(`getFontFamily failed (try #${tryCounter}) error:`, error);
       }
     }
 
     return Promise.resolve(fontsLoaded);
   }
+
+  private async deleteFontFromDisk(fontName: string, fontExtension: FontExtension, fontNamePrefix?: string) {
+    const fontInput = this.buildFontData('', fontName, fontExtension, fontNamePrefix);
+    await this.fontDownloader.deleteFontFromDisk(fontInput.fullFontName);
+  }
+
+  public async deleteFont(fontName: string, fontExtension: FontExtension): Promise<void> {
+    await this.permissionsAcquirer.getPermissions();
+    await this.deleteFontFromDisk(fontName, fontExtension);
+  }
+
+  public async deleteFontFamily(fontNames: string[],
+    fontExtension: FontExtension,
+    fontNamePrefix?: string): Promise<void> {
+    await this.permissionsAcquirer.getPermissions();
+    fontNames.forEach(async fontName => {
+      await this.deleteFontFromDisk(fontName, fontExtension, fontNamePrefix);
+    });
+  }
+
+  public async isFontDownloaded(fontName: string, fontExtension: FontExtension): Promise<boolean> {
+    return await this.fontDownloader.isFontDownloaded(fontName, fontExtension);
+  }
+
+  public async isFontFamilyDownloaded(rootUri: string,
+    fontNames: string[],
+    fontExtension: FontExtension,
+    fontNamePrefix?: string): Promise<boolean> {
+    const fonts: GetFontInput[] = 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);
+    }
+  }
 }

package/components/index.ts

@@ -1,4 +1,4 @@
-import DynamicFonts from './DynamicFonts';
+import DynamicFonts, {FontExtension} from './DynamicFonts';
 import HighlighterOverlayView from './HighlighterOverlayView';
 import SafeAreaSpacerView from './SafeArea/SafeAreaSpacerView';
 import SafeAreaInsetsManager from './SafeArea/SafeAreaInsetsManager';
@@ -6,6 +6,7 @@ import Keyboard, {KeyboardTrackingViewProps, KeyboardAccessoryViewProps} from '.
 
 export {
   DynamicFonts,
+  FontExtension,
   HighlighterOverlayView,
   SafeAreaSpacerView,
   SafeAreaInsetsManager,

package/ios/reactnativeuilib/dynamicfont/DynamicFont.m

@@ -11,27 +11,28 @@
 }
 RCT_EXPORT_MODULE()
 
-RCT_EXPORT_METHOD(
-  loadFontFromFile:(NSDictionary *)options callback:(RCTResponseSenderBlock)callback)
-{
-    NSString *path = [options valueForKey:@"path"];
-    NSString *name = [options valueForKey:@"name"];
-    NSData *data = [[NSFileManager defaultManager] contentsAtPath:path];
-    CFErrorRef error;
-    CGDataProviderRef provider = CGDataProviderCreateWithCFData((CFDataRef)data);
-    CGFontRef font = CGFontCreateWithDataProvider(provider);
-    NSString *newFontName = (__bridge NSString *)CGFontCopyPostScriptName(font);
-    if (! CTFontManagerRegisterGraphicsFont(font, &error)) {
-        CFStringRef errorDescription = CFErrorCopyDescription(error);
-        NSLog(@"Failed to load font: %@", errorDescription);
-        CFRelease(errorDescription);
-        callback(@[@"Failed to load font: %@", (__bridge NSString *)errorDescription]);
-    }
-    CFRelease(font);
-    CFRelease(provider);
-    // Resolve to the caller.
-    callback(@[[NSNull null], newFontName]);
-}
+// TODO: Needs to be tested (notice param name "path" here)
+// RCT_EXPORT_METHOD(
+//   loadFontFromFile:(NSDictionary *)options callback:(RCTResponseSenderBlock)callback)
+// {
+//     NSString *path = [options valueForKey:@"path"];
+//     NSString *name = [options valueForKey:@"name"];
+//     NSData *data = [[NSFileManager defaultManager] contentsAtPath:path];
+//     CFErrorRef error;
+//     CGDataProviderRef provider = CGDataProviderCreateWithCFData((CFDataRef)data);
+//     CGFontRef font = CGFontCreateWithDataProvider(provider);
+//     NSString *newFontName = (__bridge NSString *)CGFontCopyPostScriptName(font);
+//     if (! CTFontManagerRegisterGraphicsFont(font, &error)) {
+//         CFStringRef errorDescription = CFErrorCopyDescription(error);
+//         NSLog(@"Failed to load font: %@", errorDescription);
+//         CFRelease(errorDescription);
+//         callback(@[@"Failed to load font: %@", (__bridge NSString *)errorDescription]);
+//     }
+//     CFRelease(font);
+//     CFRelease(provider);
+//     // Resolve to the caller.
+//     callback(@[[NSNull null], newFontName]);
+// }
 
 RCT_EXPORT_METHOD(loadFont:(NSDictionary *)options callback:(RCTResponseSenderBlock)callback)
 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uilib-native",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "homepage": "https://github.com/wix/react-native-ui-lib",
   "description": "uilib native components (separated from js components)",
   "main": "components/index.js",