@maplibre/maplibre-react-native 10.0.0-alpha.2 → 10.0.0-alpha.21

package/javascript/utils/StyleValue.ts

@@ -1,11 +1,11 @@
+import { Image, processColor } from "react-native";
+
 import BridgeValue, {
   type RawValueType,
   type StyleValueJSON,
-} from './BridgeValue';
-import {AllLayerStyleProps} from './MaplibreStyles';
-import {getStyleType} from './styleMap';
-
-import {Image, processColor} from 'react-native';
+} from "./BridgeValue";
+import { AllLayerStyleProps } from "./MaplibreStyles";
+import { getStyleType } from "./styleMap";
 
 export type StyleValue = {
   styletype: string;
@@ -14,26 +14,26 @@ export type StyleValue = {
 
 export function transformStyle(
   style: AllLayerStyleProps | undefined,
-): undefined | {[key: string]: StyleValue} {
+): undefined | { [key: string]: StyleValue } {
   if (!style) {
     return;
   }
 
-  const nativeStyle: {[key: string]: StyleValue} = {};
-  const styleProps = Object.keys(style) as Array<keyof typeof style>;
+  const nativeStyle: { [key: string]: StyleValue } = {};
+  const styleProps = Object.keys(style) as (keyof typeof style)[];
   for (const styleProp of styleProps) {
     const styleType = getStyleType(styleProp);
     let rawStyle: RawValueType | undefined = style[styleProp];
 
-    if (styleType === 'color' && typeof rawStyle === 'string') {
+    if (styleType === "color" && typeof rawStyle === "string") {
       const color = processColor(rawStyle);
-      if (color === null || color === undefined || typeof color === 'symbol') {
+      if (color === null || color === undefined || typeof color === "symbol") {
         console.error(`RNMaplibre: Invalid color value: ${rawStyle} using red`);
-        rawStyle = 'ff0000';
+        rawStyle = "ff0000";
       } else {
         rawStyle = color;
       }
-    } else if (styleType === 'image' && typeof rawStyle === 'number') {
+    } else if (styleType === "image" && typeof rawStyle === "number") {
       rawStyle =
         (Image.resolveAssetSource(rawStyle) as unknown as RawValueType) || {};
     }

package/javascript/utils/animated/AbstractAnimatedCoordinates.ts

@@ -1,12 +1,12 @@
-import {Animated} from 'react-native';
+import { Animated } from "react-native";
 
 // see
 // https://github.com/facebook/react-native/blob/master/Libraries/Animated/src/nodes/AnimatedWithChildren.js
 const AnimatedWithChildren = Object.getPrototypeOf(Animated.ValueXY);
 if (__DEV__) {
-  if (AnimatedWithChildren.name !== 'AnimatedWithChildren') {
+  if (AnimatedWithChildren.name !== "AnimatedWithChildren") {
     console.error(
-      'AnimatedCoordinatesArray could not obtain AnimatedWithChildren base class',
+      "AnimatedCoordinatesArray could not obtain AnimatedWithChildren base class",
     );
   }
 }
@@ -47,7 +47,7 @@ abstract class AbstractAnimatedCoordinates<State> extends AnimatedWithChildren {
       | Animated.TimingAnimationConfig
       | Animated.SpringAnimationConfig
       | Animated.DecayAnimationConfig
-    ) & {toValue: AnimatedCoordinates[]},
+    ) & { toValue: AnimatedCoordinates[] },
   ): Animated.CompositeAnimation {
     const onAnimationStart = (animation: Animated.CompositeAnimation): void => {
       if (this.animation) {
@@ -93,7 +93,7 @@ abstract class AbstractAnimatedCoordinates<State> extends AnimatedWithChildren {
   }
 
   spring(
-    config: Animated.SpringAnimationConfig & {toValue: AnimatedCoordinates[]},
+    config: Animated.SpringAnimationConfig & { toValue: AnimatedCoordinates[] },
   ): Animated.CompositeAnimation {
     const progressValue = new Animated.Value(0.0);
     return this.animate(
@@ -108,7 +108,7 @@ abstract class AbstractAnimatedCoordinates<State> extends AnimatedWithChildren {
   }
 
   decay(
-    config: Animated.DecayAnimationConfig & {toValue: AnimatedCoordinates[]},
+    config: Animated.DecayAnimationConfig & { toValue: AnimatedCoordinates[] },
   ): Animated.CompositeAnimation {
     const progressValue = new Animated.Value(0.0);
     return this.animate(

package/javascript/utils/animated/Animated.ts

@@ -1,19 +1,22 @@
-import ShapeSource from '../../components/ShapeSource';
-import ImageSource from '../../components/ImageSource';
-import FillLayer from '../../components/FillLayer';
-import FillExtrusionLayer from '../../components/FillExtrusionLayer';
-import LineLayer from '../../components/LineLayer';
-import CircleLayer from '../../components/CircleLayer';
-import SymbolLayer from '../../components/SymbolLayer';
-import RasterLayer from '../../components/RasterLayer';
-import BackgroundLayer from '../../components/BackgroundLayer';
-
-import AnimatedShape from './AnimatedShape';
-import AnimatedCoordinatesArray from './AnimatedCoordinatesArray';
-import AnimatedExtractCoordinateFromArray from './AnimatedExtractCoordinateFromArray';
-import AnimatedRouteCoordinatesArray from './AnimatedRouteCoordinatesArray';
-
-import {Animated as RNAnimated} from 'react-native';
+import React from "react";
+import { Animated as RNAnimated } from "react-native";
+
+import AnimatedCoordinatesArray from "./AnimatedCoordinatesArray";
+import AnimatedExtractCoordinateFromArray from "./AnimatedExtractCoordinateFromArray";
+import AnimatedRouteCoordinatesArray from "./AnimatedRouteCoordinatesArray";
+import AnimatedShape from "./AnimatedShape";
+import BackgroundLayer from "../../components/BackgroundLayer";
+import CircleLayer from "../../components/CircleLayer";
+import FillExtrusionLayer from "../../components/FillExtrusionLayer";
+import FillLayer from "../../components/FillLayer";
+import ImageSource from "../../components/ImageSource";
+import LineLayer from "../../components/LineLayer";
+import RasterLayer from "../../components/RasterLayer";
+import ShapeSource, {
+  ShapeSourceProps,
+  ShapeSourceRef,
+} from "../../components/ShapeSource";
+import SymbolLayer from "../../components/SymbolLayer";
 
 const Animated = {
   // sources
@@ -36,4 +39,23 @@ const Animated = {
   ExtractCoordinateFromArray: AnimatedExtractCoordinateFromArray,
 };
 
+type ShapeSourcePropsWithRef = ShapeSourceProps &
+  React.RefAttributes<ShapeSourceRef>;
+
+type BaseShapeSourceComponent =
+  React.ForwardRefExoticComponent<ShapeSourcePropsWithRef>;
+
+type AnimatedShapeSourceType =
+  RNAnimated.AnimatedComponent<BaseShapeSourceComponent> &
+    React.MemoExoticComponent<BaseShapeSourceComponent>;
+
+/**
+ * Manual typing is required for AnimatedShapeSource because the
+ * following error:
+ * `Type instantiation is excessively deep and possibly infinite.ts(2589)`
+ */
+export const AnimatedShapeSource = RNAnimated.createAnimatedComponent(
+  ShapeSource,
+) as AnimatedShapeSourceType;
+
 export default Animated;

package/javascript/utils/animated/AnimatedCoordinatesArray.ts

@@ -1,6 +1,6 @@
 import AbstractAnimatedCoordinates, {
   AnimatedCoordinates,
-} from './AbstractAnimatedCoordinates';
+} from "./AbstractAnimatedCoordinates";
 
 interface CoordinatesState {
   coords: AnimatedCoordinates[];
@@ -8,10 +8,6 @@ interface CoordinatesState {
 }
 
 class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesState> {
-  constructor(coords: AnimatedCoordinates[]) {
-    super(coords);
-  }
-
   /**
    * Subclasses can override to calculate initial state
    *
@@ -20,7 +16,7 @@ class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesSt
    */
   onInitialState(coordinatesArray: AnimatedCoordinates[]): CoordinatesState {
     return {
-      coords: coordinatesArray.map(coord => [coord[0], coord[1]]),
+      coords: coordinatesArray.map((coord) => [coord[0], coord[1]]),
       targetCoords: [],
     };
   }
@@ -32,7 +28,7 @@ class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesSt
    * @param {object} state - either state from initialState and/or from calculate
    * @returns {object}
    */
-  onGetValue(state: CoordinatesState): CoordinatesState['coords'] {
+  onGetValue(state: CoordinatesState): CoordinatesState["coords"] {
     return state.coords;
   }
 
@@ -44,7 +40,7 @@ class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesSt
    * @returns {object} next state
    */
   onCalculate(state: CoordinatesState, progress: number): CoordinatesState {
-    const {coords, targetCoords} = state;
+    const { coords, targetCoords } = state;
     const newF = progress;
     const origF = 1.0 - newF;
 
@@ -67,7 +63,7 @@ class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesSt
           addingOrig[0] * origF + newCoord[0] * newF,
           addingOrig[1] * origF + newCoord[1] * newF,
         ]);
-      return {coords: [...common, ...adding], targetCoords};
+      return { coords: [...common, ...adding], targetCoords };
     }
 
     if (coords.length > targetCoords.length) {
@@ -82,10 +78,10 @@ class AnimatedCoordinatesArray extends AbstractAnimatedCoordinates<CoordinatesSt
           origCoord[0] * origF + dissapearingNew[0] * newF,
           origCoord[1] * origF + dissapearingNew[1] * newF,
         ]);
-      return {coords: [...common, ...dissapearing], targetCoords};
+      return { coords: [...common, ...dissapearing], targetCoords };
     }
 
-    return {coords: common, targetCoords};
+    return { coords: common, targetCoords };
   }
 
   /**

package/javascript/utils/animated/AnimatedExtractCoordinateFromArray.ts

@@ -1,12 +1,12 @@
-import {Animated} from 'react-native';
+import { Animated } from "react-native";
 
 // see
 // https://github.com/facebook/react-native/blob/master/Libraries/Animated/src/nodes/AnimatedWithChildren.js
 const AnimatedWithChildren = Object.getPrototypeOf(Animated.ValueXY);
 if (__DEV__) {
-  if (AnimatedWithChildren.name !== 'AnimatedWithChildren') {
+  if (AnimatedWithChildren.name !== "AnimatedWithChildren") {
     console.error(
-      'AnimatedCoordinatesArray could not obtain AnimatedWithChildren base class',
+      "AnimatedCoordinatesArray could not obtain AnimatedWithChildren base class",
     );
   }
 }

package/javascript/utils/animated/AnimatedPoint.ts

@@ -1,11 +1,11 @@
-import {Animated} from 'react-native';
+import { Animated } from "react-native";
 
 // Used react-native-maps as a reference
 // https://github.com/react-community/react-native-maps/blob/master/lib/components/AnimatedRegion.js
 const AnimatedWithChildren = Object.getPrototypeOf(Animated.ValueXY);
 
 const DEFAULT_COORD = [0, 0];
-const DEFAULT_POINT = {type: 'Point', coordinates: DEFAULT_COORD};
+const DEFAULT_POINT = { type: "Point", coordinates: DEFAULT_COORD };
 
 let uniqueID = 0;
 
@@ -46,7 +46,7 @@ export class AnimatedPoint extends AnimatedWithChildren {
     this.longitude.stopAnimation();
     this.latitude.stopAnimation();
 
-    if (typeof cb === 'function') {
+    if (typeof cb === "function") {
       cb(this.__getValue());
     }
   }
@@ -56,7 +56,7 @@ export class AnimatedPoint extends AnimatedWithChildren {
     const id = `${String(uniqueID)}-${String(Date.now())}`;
 
     const completeCB = (): void => {
-      if (typeof cb === 'function') {
+      if (typeof cb === "function") {
         cb(this.__getValue());
       }
     };
@@ -78,7 +78,7 @@ export class AnimatedPoint extends AnimatedWithChildren {
   spring(
     config: Partial<Animated.TimingAnimationConfig> & {
       coordinates: GeoJSON.Position;
-    } = {coordinates: DEFAULT_COORD},
+    } = { coordinates: DEFAULT_COORD },
   ): Animated.CompositeAnimation {
     return Animated.parallel([
       Animated.spring(this.longitude, {
@@ -97,7 +97,7 @@ export class AnimatedPoint extends AnimatedWithChildren {
   timing(
     config: Partial<Animated.TimingAnimationConfig> & {
       coordinates: GeoJSON.Position;
-    } = {coordinates: DEFAULT_COORD},
+    } = { coordinates: DEFAULT_COORD },
   ): Animated.CompositeAnimation {
     return Animated.parallel([
       Animated.timing(this.longitude, {
@@ -115,7 +115,7 @@ export class AnimatedPoint extends AnimatedWithChildren {
 
   __getValue(): GeoJSON.Point {
     return {
-      type: 'Point',
+      type: "Point",
       coordinates: [this.longitude.__getValue(), this.latitude.__getValue()],
     };
   }

package/javascript/utils/animated/AnimatedRouteCoordinatesArray.ts

@@ -1,11 +1,11 @@
+import distance from "@turf/distance";
+import { lineString, point, convertLength, Coord, Units } from "@turf/helpers";
+import length from "@turf/length";
+import nearestPointOnLine from "@turf/nearest-point-on-line";
+
 import AbstractAnimatedCoordinates, {
   AnimatedCoordinates,
-} from './AbstractAnimatedCoordinates';
-
-import {lineString, point, convertLength, Coord, Units} from '@turf/helpers';
-import distance from '@turf/distance';
-import nearestPointOnLine from '@turf/nearest-point-on-line';
-import length from '@turf/length';
+} from "./AbstractAnimatedCoordinates";
 
 interface AnimatedRouteState {
   actRoute?: AnimatedCoordinates[];
@@ -20,10 +20,6 @@ interface AnimatedRouteState {
 }
 
 export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoordinates<AnimatedRouteState> {
-  constructor(coords: AnimatedCoordinates[]) {
-    super(coords);
-  }
-
   /**
    * Calculate initial state
    *
@@ -35,7 +31,7 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
       fullRoute: coordinatesArray.map(
         (coord): AnimatedCoordinates => [coord[0], coord[1]],
       ),
-      end: {from: 0, to: 0},
+      end: { from: 0, to: 0 },
     };
   }
 
@@ -59,7 +55,7 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
    * @returns {object} next state
    */
   onCalculate(state: AnimatedRouteState, progress: number): AnimatedRouteState {
-    const {fullRoute, end} = state;
+    const { fullRoute, end } = state;
     const currentEnd = end.from * (1.0 - progress) + progress * end.to;
 
     let prevsum = 0;
@@ -76,7 +72,7 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
     }
     if (actsum <= currentEnd) {
       const actRoute = [...fullRoute.slice(0, i + 1)];
-      return {fullRoute, end: {...end, current: currentEnd}, actRoute};
+      return { fullRoute, end: { ...end, current: currentEnd }, actRoute };
     }
     const r = (currentEnd - prevsum) / (actsum - prevsum);
     const or = 1.0 - r;
@@ -88,7 +84,7 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
         fullRoute[i][1] * r + fullRoute[i + 1][1] * or,
       ] as AnimatedCoordinates,
     ];
-    return {fullRoute, end: {...end, current: currentEnd}, actRoute};
+    return { fullRoute, end: { ...end, current: currentEnd }, actRoute };
   }
 
   /**
@@ -100,17 +96,17 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
    */
   onStart(
     state: AnimatedRouteState,
-    toValue: {end: {point?: Coord; along?: number}; units?: Units},
+    toValue: { end: { point?: Coord; along?: number }; units?: Units },
   ): AnimatedRouteState {
-    const {fullRoute, end} = state;
+    const { fullRoute, end } = state;
     let toDist = 0;
     if (!toValue.end) {
       console.error(
-        'RouteCoordinatesArray: toValue should have end with either along or point',
+        "RouteCoordinatesArray: toValue should have end with either along or point",
       );
     }
     if (toValue.end.along) {
-      const {units} = toValue;
+      const { units } = toValue;
       const ls = lineString(fullRoute);
       toDist = convertLength(toValue.end.along, units);
       toDist = length(ls) - toDist;
@@ -118,7 +114,7 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
     if (toDist != null) {
       if (toValue.end.point) {
         console.warn(
-          'RouteCoordinatesArray: toValue.end: has both along and point, point is ignored',
+          "RouteCoordinatesArray: toValue.end: has both along and point, point is ignored",
         );
       }
     } else if (toValue.end.point) {
@@ -128,7 +124,7 @@ export default class AnimatedRouteCoordinatesArray extends AbstractAnimatedCoord
       toDist = length(ls) - nearest.properties.location!;
     } else {
       console.warn(
-        'RouteCoordinatesArray: toValue.end: should have either along or point',
+        "RouteCoordinatesArray: toValue.end: should have either along or point",
       );
     }
 

package/javascript/utils/animated/AnimatedShape.ts

@@ -1,31 +1,31 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import AnimatedCoordinatesArray from './AnimatedCoordinatesArray';
-import AnimatedExtractCoordinateFromArray from './AnimatedExtractCoordinateFromArray';
-import AnimatedRouteCoordinatesArray from './AnimatedRouteCoordinatesArray';
 
-import {Animated} from 'react-native';
+import { Animated } from "react-native";
+
+import AnimatedCoordinatesArray from "./AnimatedCoordinatesArray";
+import AnimatedExtractCoordinateFromArray from "./AnimatedExtractCoordinateFromArray";
+import AnimatedRouteCoordinatesArray from "./AnimatedRouteCoordinatesArray";
 
 // see
 // https://github.com/facebook/react-native/blob/master/Libraries/Animated/src/nodes/AnimatedWithChildren.js
 const AnimatedWithChildren = Object.getPrototypeOf(Animated.ValueXY);
 if (__DEV__) {
-  if (AnimatedWithChildren.name !== 'AnimatedWithChildren') {
+  if (AnimatedWithChildren.name !== "AnimatedWithChildren") {
     console.error(
-      'AnimatedShape could not obtain AnimatedWithChildren base class',
+      "AnimatedShape could not obtain AnimatedWithChildren base class",
     );
   }
 }
 
 type Shape =
   | {
-      type: 'Point';
+      type: "Point";
       coordinates:
         | AnimatedExtractCoordinateFromArray
         | AnimatedRouteCoordinatesArray;
     }
   | {
-      type: 'LineString';
+      type: "LineString";
       coordinates: AnimatedCoordinatesArray;
     };
 
@@ -45,14 +45,14 @@ class AnimatedShape extends AnimatedWithChildren {
 
   _walkShapeAndGetValues(value: any): any {
     if (Array.isArray(value)) {
-      return value.map(i => this._walkShapeAndGetValues(i));
+      return value.map((i) => this._walkShapeAndGetValues(i));
     }
     // @ts-expect-error Animated.Node is not exported
     if (value instanceof Animated.Node) {
       return (value as any).__getValue();
     }
-    if (typeof value === 'object') {
-      const result: {[key: string]: any} = {};
+    if (typeof value === "object") {
+      const result: { [key: string]: any } = {};
       for (const key in value) {
         result[key] = this._walkShapeAndGetValues(value[key]);
       }
@@ -69,11 +69,11 @@ class AnimatedShape extends AnimatedWithChildren {
   // @ts-expect-error Animated.Node is not exported
   _walkAndProcess(value: any, cb: (value: Animated.Node) => void): void {
     if (Array.isArray(value)) {
-      value.forEach(i => this._walkAndProcess(i, cb));
+      value.forEach((i) => this._walkAndProcess(i, cb));
       // @ts-expect-error Animated.Node is not exported
     } else if (value instanceof Animated.Node) {
       cb(value);
-    } else if (typeof value === 'object') {
+    } else if (typeof value === "object") {
       for (const key in value) {
         this._walkAndProcess(value[key], cb);
       }
@@ -81,11 +81,11 @@ class AnimatedShape extends AnimatedWithChildren {
   }
 
   __attach(): void {
-    this._walkAndProcess(this.shape, v => (v as any).__addChild(this));
+    this._walkAndProcess(this.shape, (v) => (v as any).__addChild(this));
   }
 
   __detach(): void {
-    this._walkAndProcess(this.shape, v => (v as any).__removeChild(this));
+    this._walkAndProcess(this.shape, (v) => (v as any).__removeChild(this));
     super.__detach();
   }
 }

package/javascript/utils/deprecation.ts

@@ -12,17 +12,20 @@ export function copyPropertiesAsDeprecated<
   onDeprecatedCalled: (key: string) => void,
   accessors: Record<string, (value: any) => unknown> = {},
 ): WithDeprecatedType {
-  const result = newObject;
+  const result = { ...newObject };
+
   for (const [key, value] of Object.entries(origObject)) {
-    if (!newObject[key]) {
-      // eslint-disable-next-line fp/no-mutating-methods
+    if (!(key in newObject)) {
       Object.defineProperty(result, key, {
         get() {
           onDeprecatedCalled(key);
           return accessors[key] ? accessors[key](value) : value;
         },
+        enumerable: true, // Ensure the property is enumerable
+        configurable: true, // Ensure the property can be reconfigured
       });
     }
   }
+
   return result;
 }

package/javascript/utils/filterUtils.ts

@@ -1,4 +1,4 @@
-import {FilterExpression} from './MaplibreStyles';
+import { FilterExpression } from "./MaplibreStyles";
 
 export function getFilter(filter: FilterExpression | undefined): string[] {
   if (!Array.isArray(filter) || filter.length === 0) {

package/javascript/utils/geoUtils.ts

@@ -1,3 +1,6 @@
+import geoViewport from "@mapbox/geo-viewport";
+import along from "@turf/along";
+import distance from "@turf/distance";
 import {
   featureCollection,
   point,
@@ -5,10 +8,7 @@ import {
   lineString,
   Id,
   Properties,
-} from '@turf/helpers';
-import distance from '@turf/distance';
-import along from '@turf/along';
-import geoViewport from '@mapbox/geo-viewport';
+} from "@turf/helpers";
 
 const VECTOR_TILE_SIZE = 512;
 
@@ -30,7 +30,7 @@ export const makeFeature = feature;
 
 export function makeFeatureCollection(
   features: GeoJSON.Feature[] = [],
-  options?: {bbox?: GeoJSON.BBox; id?: Id},
+  options?: { bbox?: GeoJSON.BBox; id?: Id },
 ): GeoJSON.FeatureCollection {
   return featureCollection(features, options);
 }
@@ -50,12 +50,12 @@ export const calculateDistance = distance;
 export const pointAlongLine = along;
 
 export function getOrCalculateVisibleRegion(
-  coord: [number, number] | {lon: number; lat: number},
+  coord: [number, number] | { lon: number; lat: number },
   zoomLevel: number,
   width: number,
   height: number,
-  nativeRegion: {properties: {visibleBounds: [number, number][]}},
-): {ne: [number, number]; sw: [number, number]} {
+  nativeRegion: { properties: { visibleBounds: [number, number][] } },
+): { ne: [number, number]; sw: [number, number] } {
   const region = {
     ne: [0, 0] as [number, number],
     sw: [0, 0] as [number, number],

package/javascript/utils/index.ts

@@ -1,11 +1,11 @@
-import React, {Component, ReactElement} from 'react';
+import React, { Component, ReactElement } from "react";
 import {
   Image,
   NativeModules,
   findNodeHandle,
   Platform,
   ImageSourcePropType,
-} from 'react-native';
+} from "react-native";
 
 function getAndroidManagerInstance(module: string): any {
   const haveViewManagerConfig =
@@ -20,7 +20,7 @@ function getIosManagerInstance(module: string): any {
 }
 
 export function isAndroid(): boolean {
-  return Platform.OS === 'android';
+  return Platform.OS === "android";
 }
 
 export function existenceChange(cur: boolean, next: boolean): boolean {
@@ -31,23 +31,23 @@ export function existenceChange(cur: boolean, next: boolean): boolean {
 }
 
 export function isFunction(fn: unknown): fn is boolean {
-  return typeof fn === 'function';
+  return typeof fn === "function";
 }
 
 export function isNumber(num: unknown): num is number {
-  return typeof num === 'number' && !Number.isNaN(num);
+  return typeof num === "number" && !Number.isNaN(num);
 }
 
 export function isUndefined(obj: unknown): obj is undefined {
-  return typeof obj === 'undefined';
+  return typeof obj === "undefined";
 }
 
 export function isString(str: unknown): str is string {
-  return typeof str === 'string';
+  return typeof str === "string";
 }
 
 export function isBoolean(bool: unknown): bool is boolean {
-  return typeof bool === 'boolean';
+  return typeof bool === "boolean";
 }
 
 export function isPrimitive(
@@ -61,7 +61,7 @@ export type NativeArg =
   | number
   | boolean
   | null
-  | {[k: string]: NativeArg}
+  | { [k: string]: NativeArg }
   | NativeArg[];
 
 export function runNativeCommand<ReturnType = NativeArg>(
@@ -96,7 +96,7 @@ export function runNativeCommand<ReturnType = NativeArg>(
 
 export function cloneReactChildrenWithProps(
   children: Parameters<typeof React.Children.map>[0],
-  propsToAdd: {[key: string]: string} = {},
+  propsToAdd: { [key: string]: string } = {},
 ): ReactElement[] | undefined {
   if (!children) {
     return undefined;
@@ -110,8 +110,8 @@ export function cloneReactChildrenWithProps(
     foundChildren = children;
   }
 
-  const filteredChildren = foundChildren.filter(child => !!child); // filter out falsy children, since some can be null
-  return React.Children.map(filteredChildren, child =>
+  const filteredChildren = foundChildren.filter((child) => !!child); // filter out falsy children, since some can be null
+  return React.Children.map(filteredChildren, (child) =>
     React.cloneElement(child, propsToAdd),
   );
 }
@@ -122,12 +122,12 @@ export function resolveImagePath(imageRef: ImageSourcePropType): string {
 }
 
 export function getIOSModuleName(moduleName: string): string {
-  if (moduleName.startsWith('RCT')) {
+  if (moduleName.startsWith("RCT")) {
     return moduleName.substring(3);
   }
   return moduleName;
 }
 
-export function toJSONString(json: object | string = ''): string {
+export function toJSONString(json: object | string = ""): string {
   return JSON.stringify(json);
 }