hermes-test 1.0.0 → 1.0.2

package/src/polyfills.js

@@ -17,14 +17,14 @@ if (typeof globalThis.process === 'undefined') {
 
 // process.nextTick — many Node.js-style tests use this
 if (typeof globalThis.process.nextTick === 'undefined') {
-  globalThis.process.nextTick = function(fn) {
+  globalThis.process.nextTick = function (fn) {
     Promise.resolve().then(fn);
   };
 }
 
 // Object.fromEntries — ES2019, may not exist in older Hermes builds
 if (typeof Object.fromEntries === 'undefined') {
-  Object.fromEntries = function(iterable) {
+  Object.fromEntries = function (iterable) {
     var obj = {};
     if (iterable && typeof iterable[Symbol.iterator] === 'function') {
       var iter = iterable[Symbol.iterator]();
@@ -33,7 +33,9 @@ if (typeof Object.fromEntries === 'undefined') {
         obj[next.value[0]] = next.value[1];
       }
     } else if (iterable && typeof iterable.forEach === 'function') {
-      iterable.forEach(function(pair) { obj[pair[0]] = pair[1]; });
+      iterable.forEach(function (pair) {
+        obj[pair[0]] = pair[1];
+      });
     }
     return obj;
   };
@@ -44,7 +46,7 @@ if (typeof globalThis.crypto === 'undefined') {
   globalThis.crypto = {};
 }
 if (typeof globalThis.crypto.getRandomValues === 'undefined') {
-  globalThis.crypto.getRandomValues = function(arr) {
+  globalThis.crypto.getRandomValues = function (arr) {
     for (var i = 0; i < arr.length; i++) {
       arr[i] = Math.floor(Math.random() * 256);
     }
@@ -54,54 +56,69 @@ if (typeof globalThis.crypto.getRandomValues === 'undefined') {
 
 // MessageChannel polyfill — React 19's scheduler uses it for async work
 if (typeof globalThis.MessageChannel === 'undefined') {
-  globalThis.MessageChannel = function() {
+  globalThis.MessageChannel = function () {
     var cb = null;
     this.port1 = { onmessage: null };
     this.port2 = {
-      postMessage: function() {
-        if (cb) { var fn = cb; cb = null; fn({ data: undefined }); }
-      }
+      postMessage: function () {
+        if (cb) {
+          var fn = cb;
+          cb = null;
+          fn({ data: undefined });
+        }
+      },
     };
     var self = this;
     Object.defineProperty(this.port1, 'onmessage', {
-      set: function(fn) { cb = fn; },
-      get: function() { return cb; }
+      set: function (fn) {
+        cb = fn;
+      },
+      get: function () {
+        return cb;
+      },
     });
   };
 }
 
 // Timer polyfills — React scheduler needs these
-(function() {
+(function () {
   var queue = [];
   var timerIdCounter = 1;
   var timers = {};
 
   if (typeof globalThis.setImmediate === 'undefined') {
-    globalThis.setImmediate = function(fn) { queue.push(fn); };
+    globalThis.setImmediate = function (fn) {
+      queue.push(fn);
+    };
   }
 
   // Flush all async work: Hermes microtask queue (promises) + our polyfill queues (timers).
   // The C++ bridge installs a native __HT_drain that calls Hermes's drainMicrotasks().
   // We wrap it to also flush our setImmediate/setTimeout polyfill queues.
-  var nativeDrain = globalThis.__HT_drain || function() {};
-  globalThis.__HT_drain = function() {
+  var nativeDrain = globalThis.__HT_drain || function () {};
+  globalThis.__HT_drain = function () {
     // 1. Drain Hermes's internal promise/microtask queue
     nativeDrain();
     // 2. Flush our setImmediate queue
     var limit = 1000;
-    while (queue.length > 0 && limit-- > 0) { queue.shift()(); }
+    while (queue.length > 0 && limit-- > 0) {
+      queue.shift()();
+    }
     // 3. Flush pending timers
     var ids = Object.keys(timers);
     for (var i = 0; i < ids.length; i++) {
       var t = timers[ids[i]];
-      if (t) { delete timers[ids[i]]; t(); }
+      if (t) {
+        delete timers[ids[i]];
+        t();
+      }
     }
     // 4. Drain again (timer callbacks may have queued more microtasks)
     nativeDrain();
   };
 
   if (typeof globalThis.setTimeout === 'undefined') {
-    globalThis.setTimeout = function(fn, delay) {
+    globalThis.setTimeout = function (fn, delay) {
       var id = timerIdCounter++;
       if (!delay || delay <= 0) {
         queue.push(fn);
@@ -113,35 +130,48 @@ if (typeof globalThis.MessageChannel === 'undefined') {
   }
 
   if (typeof globalThis.clearTimeout === 'undefined') {
-    globalThis.clearTimeout = function(id) { delete timers[id]; };
+    globalThis.clearTimeout = function (id) {
+      delete timers[id];
+    };
   }
 
   if (typeof globalThis.console === 'undefined') {
     globalThis.console = {
-      log: function() {},
-      warn: function() {},
-      error: function() {},
-      info: function() {},
-      debug: function() {},
+      log: function () {},
+      warn: function () {},
+      error: function () {},
+      info: function () {},
+      debug: function () {},
     };
   }
 })();
 
 // Web API polyfills — needed for RTK Query's fetchBaseQuery
-(function() {
+(function () {
   // AbortController / AbortSignal
   if (typeof globalThis.AbortController === 'undefined') {
-    function AbortSignal() { this.aborted = false; this._listeners = []; }
-    AbortSignal.prototype.addEventListener = function(type, fn) { this._listeners.push(fn); };
-    AbortSignal.prototype.removeEventListener = function(type, fn) {
-      this._listeners = this._listeners.filter(function(f) { return f !== fn; });
+    function AbortSignal() {
+      this.aborted = false;
+      this._listeners = [];
+    }
+    AbortSignal.prototype.addEventListener = function (type, fn) {
+      this._listeners.push(fn);
+    };
+    AbortSignal.prototype.removeEventListener = function (type, fn) {
+      this._listeners = this._listeners.filter(function (f) {
+        return f !== fn;
+      });
     };
 
-    function AbortController() { this.signal = new AbortSignal(); }
-    AbortController.prototype.abort = function() {
+    function AbortController() {
+      this.signal = new AbortSignal();
+    }
+    AbortController.prototype.abort = function () {
       this.signal.aborted = true;
       for (var i = 0; i < this.signal._listeners.length; i++) {
-        try { this.signal._listeners[i](); } catch(e) {}
+        try {
+          this.signal._listeners[i]();
+        } catch (e) {}
       }
     };
 
@@ -155,7 +185,11 @@ if (typeof globalThis.MessageChannel === 'undefined') {
       this._map = {};
       if (init) {
         if (typeof init.forEach === 'function') {
-          init.forEach(function(v, k) { this._map[k.toLowerCase()] = v; }.bind(this));
+          init.forEach(
+            function (v, k) {
+              this._map[k.toLowerCase()] = v;
+            }.bind(this),
+          );
         } else {
           var keys = Object.keys(init);
           for (var i = 0; i < keys.length; i++) {
@@ -164,19 +198,29 @@ if (typeof globalThis.MessageChannel === 'undefined') {
         }
       }
     }
-    Headers.prototype.get = function(k) { return this._map[k.toLowerCase()] || null; };
-    Headers.prototype.has = function(k) { return k.toLowerCase() in this._map; };
-    Headers.prototype.set = function(k, v) { this._map[k.toLowerCase()] = v; };
-    Headers.prototype.append = function(k, v) {
+    Headers.prototype.get = function (k) {
+      return this._map[k.toLowerCase()] || null;
+    };
+    Headers.prototype.has = function (k) {
+      return k.toLowerCase() in this._map;
+    };
+    Headers.prototype.set = function (k, v) {
+      this._map[k.toLowerCase()] = v;
+    };
+    Headers.prototype.append = function (k, v) {
       k = k.toLowerCase();
       this._map[k] = this._map[k] ? this._map[k] + ', ' + v : v;
     };
-    Headers.prototype.delete = function(k) { delete this._map[k.toLowerCase()]; };
-    Headers.prototype.forEach = function(fn) {
+    Headers.prototype.delete = function (k) {
+      delete this._map[k.toLowerCase()];
+    };
+    Headers.prototype.forEach = function (fn) {
       var keys = Object.keys(this._map);
       for (var i = 0; i < keys.length; i++) fn(this._map[keys[i]], keys[i], this);
     };
-    Headers.prototype.entries = function() { return Object.entries(this._map); };
+    Headers.prototype.entries = function () {
+      return Object.entries(this._map);
+    };
     globalThis.Headers = Headers;
   }
 
@@ -207,7 +251,11 @@ if (typeof globalThis.MessageChannel === 'undefined') {
           }
         } else if (typeof init.forEach === 'function') {
           // URLSearchParams-like with forEach(value, key)
-          init.forEach(function(v, k) { this._params.push([String(k), String(v)]); }.bind(this));
+          init.forEach(
+            function (v, k) {
+              this._params.push([String(k), String(v)]);
+            }.bind(this),
+          );
         } else {
           // Plain object: { key: value }
           var keys = Object.keys(init);
@@ -217,59 +265,76 @@ if (typeof globalThis.MessageChannel === 'undefined') {
         }
       }
     }
-    URLSearchParams.prototype.get = function(k) {
+    URLSearchParams.prototype.get = function (k) {
       for (var i = 0; i < this._params.length; i++) {
         if (this._params[i][0] === k) return this._params[i][1];
       }
       return null;
     };
-    URLSearchParams.prototype.has = function(k) {
+    URLSearchParams.prototype.has = function (k) {
       for (var i = 0; i < this._params.length; i++) {
         if (this._params[i][0] === k) return true;
       }
       return false;
     };
-    URLSearchParams.prototype.set = function(k, v) {
+    URLSearchParams.prototype.set = function (k, v) {
       for (var i = 0; i < this._params.length; i++) {
-        if (this._params[i][0] === k) { this._params[i][1] = String(v); return; }
+        if (this._params[i][0] === k) {
+          this._params[i][1] = String(v);
+          return;
+        }
       }
       this._params.push([k, String(v)]);
     };
-    URLSearchParams.prototype.append = function(k, v) { this._params.push([k, String(v)]); };
-    URLSearchParams.prototype['delete'] = function(k) {
-      this._params = this._params.filter(function(p) { return p[0] !== k; });
+    URLSearchParams.prototype.append = function (k, v) {
+      this._params.push([k, String(v)]);
+    };
+    URLSearchParams.prototype['delete'] = function (k) {
+      this._params = this._params.filter(function (p) {
+        return p[0] !== k;
+      });
     };
-    URLSearchParams.prototype.entries = function() {
+    URLSearchParams.prototype.entries = function () {
       var params = this._params;
       var i = 0;
-      return { next: function() {
-        if (i < params.length) return { value: [params[i][0], params[i++][1]], done: false };
-        return { value: undefined, done: true };
-      }};
+      return {
+        next: function () {
+          if (i < params.length) return { value: [params[i][0], params[i++][1]], done: false };
+          return { value: undefined, done: true };
+        },
+      };
     };
-    URLSearchParams.prototype.keys = function() {
+    URLSearchParams.prototype.keys = function () {
       var params = this._params;
       var i = 0;
-      return { next: function() {
-        if (i < params.length) return { value: params[i++][0], done: false };
-        return { value: undefined, done: true };
-      }};
+      return {
+        next: function () {
+          if (i < params.length) return { value: params[i++][0], done: false };
+          return { value: undefined, done: true };
+        },
+      };
     };
-    URLSearchParams.prototype.values = function() {
+    URLSearchParams.prototype.values = function () {
       var params = this._params;
       var i = 0;
-      return { next: function() {
-        if (i < params.length) return { value: params[i++][1], done: false };
-        return { value: undefined, done: true };
-      }};
+      return {
+        next: function () {
+          if (i < params.length) return { value: params[i++][1], done: false };
+          return { value: undefined, done: true };
+        },
+      };
     };
-    URLSearchParams.prototype.forEach = function(fn, thisArg) {
+    URLSearchParams.prototype.forEach = function (fn, thisArg) {
       for (var i = 0; i < this._params.length; i++) {
         fn.call(thisArg, this._params[i][1], this._params[i][0], this);
       }
     };
-    URLSearchParams.prototype.toString = function() {
-      return this._params.map(function(p) { return encodeURIComponent(p[0]) + '=' + encodeURIComponent(p[1]); }).join('&');
+    URLSearchParams.prototype.toString = function () {
+      return this._params
+        .map(function (p) {
+          return encodeURIComponent(p[0]) + '=' + encodeURIComponent(p[1]);
+        })
+        .join('&');
     };
     URLSearchParams.prototype[Symbol.iterator] = URLSearchParams.prototype.entries;
     globalThis.URLSearchParams = URLSearchParams;
@@ -293,13 +358,20 @@ if (typeof globalThis.MessageChannel === 'undefined') {
         this.host = this.hostname + (this.port ? ':' + this.port : '');
         this.origin = this.protocol + '//' + this.host;
       } else {
-        this.protocol = ''; this.hostname = ''; this.port = '';
-        this.pathname = url; this.search = ''; this.hash = '';
-        this.host = ''; this.origin = '';
+        this.protocol = '';
+        this.hostname = '';
+        this.port = '';
+        this.pathname = url;
+        this.search = '';
+        this.hash = '';
+        this.host = '';
+        this.origin = '';
       }
       this.searchParams = new globalThis.URLSearchParams(this.search);
     }
-    URL.prototype.toString = function() { return this.href; };
+    URL.prototype.toString = function () {
+      return this.href;
+    };
     globalThis.URL = URL;
   }
 
@@ -315,8 +387,10 @@ if (typeof globalThis.MessageChannel === 'undefined') {
 
   // Stub fetch (mockFetch will override with handler-based implementation)
   if (typeof globalThis.fetch === 'undefined') {
-    globalThis.fetch = function() {
-      return Promise.reject(new Error('fetch not configured — use mockFetch() to register handlers'));
+    globalThis.fetch = function () {
+      return Promise.reject(
+        new Error('fetch not configured — use mockFetch() to register handlers'),
+      );
     };
   }
 
@@ -328,7 +402,11 @@ if (typeof globalThis.MessageChannel === 'undefined') {
       this.ok = this.status >= 200 && this.status < 300;
       this.headers = new globalThis.Headers(init && init.headers);
     };
-    globalThis.Response.prototype.json = function() { return Promise.resolve(JSON.parse(this.body)); };
-    globalThis.Response.prototype.text = function() { return Promise.resolve(String(this.body)); };
+    globalThis.Response.prototype.json = function () {
+      return Promise.resolve(JSON.parse(this.body));
+    };
+    globalThis.Response.prototype.text = function () {
+      return Promise.resolve(String(this.body));
+    };
   }
 })();

package/src/render.ts

@@ -71,13 +71,16 @@ function makeQuery<T>(queryAll: (root: HTNode, arg: T) => HTNode[], label: strin
   return {
     getAll(root: HTNode, arg: T): HTNode[] {
       const result = queryAll(root, arg);
-      if (result.length === 0) throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
+      if (result.length === 0)
+        throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
       return result;
     },
     get(root: HTNode, arg: T): HTNode {
       const result = queryAll(root, arg);
-      if (result.length === 0) throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
-      if (result.length > 1) throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
+      if (result.length === 0)
+        throw new Error(`Unable to find element with ${label}: ${String(arg)}`);
+      if (result.length > 1)
+        throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
       return result[0];
     },
     queryAll(root: HTNode, arg: T): HTNode[] {
@@ -85,7 +88,8 @@ function makeQuery<T>(queryAll: (root: HTNode, arg: T) => HTNode[], label: strin
     },
     query(root: HTNode, arg: T): HTNode | null {
       const result = queryAll(root, arg);
-      if (result.length > 1) throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
+      if (result.length > 1)
+        throw new Error(`Found ${result.length} elements with ${label}: ${String(arg)}`);
       return result[0] || null;
     },
   };
@@ -123,7 +127,7 @@ function prettyPrint(json: any, indent: number = 0): string {
   let propsStr = '';
   if (props) {
     const entries = Object.entries(props).map(([k, v]) =>
-      typeof v === 'string' ? `${k}="${v}"` : `${k}={${JSON.stringify(v)}}`
+      typeof v === 'string' ? `${k}="${v}"` : `${k}={${JSON.stringify(v)}}`,
     );
     if (entries.length > 0) propsStr = ' ' + entries.join(' ');
   }
@@ -133,7 +137,11 @@ function prettyPrint(json: any, indent: number = 0): string {
   // Collapse adjacent string children into one
   const merged: any[] = [];
   for (const c of children) {
-    if (typeof c === 'string' && merged.length > 0 && typeof merged[merged.length - 1] === 'string') {
+    if (
+      typeof c === 'string' &&
+      merged.length > 0 &&
+      typeof merged[merged.length - 1] === 'string'
+    ) {
       merged[merged.length - 1] += c;
     } else {
       merged.push(c);
@@ -154,7 +162,9 @@ export const fireEvent = Object.assign(
     const handlerName = 'on' + eventName.charAt(0).toUpperCase() + eventName.slice(1);
     const handler = node.props?.[handlerName];
     if (!handler) throw new Error(`No handler "${handlerName}" on <${node.type}>`);
-    act(() => { handler(...args); });
+    act(() => {
+      handler(...args);
+    });
   },
   {
     press(node: HTNode, event?: any) {
@@ -166,19 +176,25 @@ export const fireEvent = Object.assign(
       const handler = target?.props?.onPress || node.props?.onPress;
       if (!handler) throw new Error(`No "onPress" handler on <${node.type}>`);
       if ((target || node).props?.disabled) return; // Disabled elements don't fire press
-      act(() => { handler(event); });
+      act(() => {
+        handler(event);
+      });
     },
     changeText(node: HTNode, text: string) {
       const handler = node.props?.onChangeText;
       if (!handler) throw new Error(`No "onChangeText" handler on <${node.type}>`);
-      act(() => { handler(text); });
+      act(() => {
+        handler(text);
+      });
     },
     scroll(node: HTNode, event: any) {
       const handler = node.props?.onScroll;
       if (!handler) throw new Error(`No "onScroll" handler on <${node.type}>`);
-      act(() => { handler(event); });
+      act(() => {
+        handler(event);
+      });
     },
-  }
+  },
 );
 
 // --- render() ---
@@ -213,11 +229,17 @@ export function render(element: any, options?: { shallow?: boolean }): RenderRes
   const container: HTNode = { type: '__ROOT__', props: {}, children: [] };
   const root = reconciler.createContainer(
     container,
-    0,    // LegacyRoot
+    0, // LegacyRoot
     null, // hydrationCallbacks
-    false, false, '',
-    (err: any) => { throw err; },
-    (err: any) => { throw err; },
+    false,
+    false,
+    '',
+    (err: any) => {
+      throw err;
+    },
+    (err: any) => {
+      throw err;
+    },
     null,
     () => {},
   );
@@ -232,7 +254,7 @@ export function render(element: any, options?: { shallow?: boolean }): RenderRes
     const topType = element.type;
     const origCE = React.createElement;
 
-    React.createElement = function(type: any, ...args: any[]) {
+    React.createElement = function (type: any, ...args: any[]) {
       if (typeof type === 'function' && type !== topType) {
         const name = type.displayName || type.name || 'Component';
         return origCE.call(React, name, ...args);
@@ -253,22 +275,22 @@ export function render(element: any, options?: { shallow?: boolean }): RenderRes
 
   const result: RenderResult = {
     container,
-    getByText: (t) => textQ.get(container, t),
-    getAllByText: (t) => textQ.getAll(container, t),
-    queryByText: (t) => textQ.query(container, t),
-    queryAllByText: (t) => textQ.queryAll(container, t),
-    getByTestId: (id) => testIdQ.get(container, id),
-    getAllByTestId: (id) => testIdQ.getAll(container, id),
-    queryByTestId: (id) => testIdQ.query(container, id),
-    queryAllByTestId: (id) => testIdQ.queryAll(container, id),
-    getByProps: (p) => propsQ.get(container, p),
-    getAllByProps: (p) => propsQ.getAll(container, p),
-    queryByProps: (p) => propsQ.query(container, p),
-    queryAllByProps: (p) => propsQ.queryAll(container, p),
-    getByType: (t) => typeQ.get(container, t),
-    getAllByType: (t) => typeQ.getAll(container, t),
-    queryByType: (t) => typeQ.query(container, t),
-    queryAllByType: (t) => typeQ.queryAll(container, t),
+    getByText: t => textQ.get(container, t),
+    getAllByText: t => textQ.getAll(container, t),
+    queryByText: t => textQ.query(container, t),
+    queryAllByText: t => textQ.queryAll(container, t),
+    getByTestId: id => testIdQ.get(container, id),
+    getAllByTestId: id => testIdQ.getAll(container, id),
+    queryByTestId: id => testIdQ.query(container, id),
+    queryAllByTestId: id => testIdQ.queryAll(container, id),
+    getByProps: p => propsQ.get(container, p),
+    getAllByProps: p => propsQ.getAll(container, p),
+    queryByProps: p => propsQ.query(container, p),
+    queryAllByProps: p => propsQ.queryAll(container, p),
+    getByType: t => typeQ.get(container, t),
+    getAllByType: t => typeQ.getAll(container, t),
+    queryByType: t => typeQ.query(container, t),
+    queryAllByType: t => typeQ.queryAll(container, t),
     toJSON() {
       if (container.children.length === 0) return null;
       if (container.children.length === 1) return toJSON(container.children[0]);

package/src/shims/async-storage.js

@@ -5,48 +5,48 @@
 var _store = {};
 
 var AsyncStorage = {
-  getItem: function(key) {
+  getItem: function (key) {
     var val = _store[key] !== undefined ? _store[key] : null;
     return Promise.resolve(val);
   },
-  setItem: function(key, value) {
+  setItem: function (key, value) {
     _store[key] = value;
     return Promise.resolve();
   },
-  removeItem: function(key) {
+  removeItem: function (key) {
     delete _store[key];
     return Promise.resolve();
   },
-  multiRemove: function(keys) {
+  multiRemove: function (keys) {
     for (var i = 0; i < keys.length; i++) {
       delete _store[keys[i]];
     }
     return Promise.resolve();
   },
-  multiGet: function(keys) {
+  multiGet: function (keys) {
     var result = [];
     for (var i = 0; i < keys.length; i++) {
       result.push([keys[i], _store[keys[i]] !== undefined ? _store[keys[i]] : null]);
     }
     return Promise.resolve(result);
   },
-  multiSet: function(pairs) {
+  multiSet: function (pairs) {
     for (var i = 0; i < pairs.length; i++) {
       _store[pairs[i][0]] = pairs[i][1];
     }
     return Promise.resolve();
   },
-  getAllKeys: function() {
+  getAllKeys: function () {
     return Promise.resolve(Object.keys(_store));
   },
-  clear: function() {
+  clear: function () {
     _store = {};
     return Promise.resolve();
   },
 };
 
 // Reset hook — called between test files by the harness
-globalThis.__HT_resetAsyncStorage = function() {
+globalThis.__HT_resetAsyncStorage = function () {
   _store = {};
 };
 

package/src/shims/react-i18next.js

@@ -2,19 +2,39 @@
 // Identity translation: t('key') returns 'key'.
 // Covers useTranslation, withTranslation, Trans, initReactI18next.
 
-var t = function(key) { return key; };
+var t = function (key) {
+  return key;
+};
 var i18n = {
   language: 'en',
-  changeLanguage: function() { return Promise.resolve(); },
-  use: function() { return i18n; },
-  init: function() { return Promise.resolve(); },
+  changeLanguage: function () {
+    return Promise.resolve();
+  },
+  use: function () {
+    return i18n;
+  },
+  init: function () {
+    return Promise.resolve();
+  },
 };
 
 module.exports = {
-  useTranslation: function() { return { t: t, i18n: i18n, ready: true }; },
-  withTranslation: function() { return function(component) { return component; }; },
-  Trans: function(props) { return props.children || null; },
-  Translation: function(props) { return props.children(t, { i18n: i18n }); },
-  initReactI18next: { type: '3rdParty', init: function() {} },
-  I18nextProvider: function(props) { return props.children; },
+  useTranslation: function () {
+    return { t: t, i18n: i18n, ready: true };
+  },
+  withTranslation: function () {
+    return function (component) {
+      return component;
+    };
+  },
+  Trans: function (props) {
+    return props.children || null;
+  },
+  Translation: function (props) {
+    return props.children(t, { i18n: i18n });
+  },
+  initReactI18next: { type: '3rdParty', init: function () {} },
+  I18nextProvider: function (props) {
+    return props.children;
+  },
 };

package/src/shims/react-native-launch-arguments.js

@@ -3,6 +3,8 @@
 
 module.exports = {
   LaunchArguments: {
-    value: function() { return {}; },
+    value: function () {
+      return {};
+    },
   },
 };