@react-native-firebase/app 23.7.0 → 23.8.1

package/dist/typescript/module/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+import { Utils } from '../types/app';
+declare const _default: Utils.Statics & (() => Utils.Module);
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/typescript/module/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/utils/index.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;wBAyEpB,KAAK,CAAC,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC;AATrD,wBASsD"}

package/dist/typescript/module/lib/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "23.8.1";
+//# sourceMappingURL=version.d.ts.map

package/dist/typescript/module/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../lib/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,WAAW,CAAC"}

package/dist/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/ios/RNFBApp/RNFBNullSentinelInterceptor.h

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef RNFBNullSentinelInterceptor_h
+#define RNFBNullSentinelInterceptor_h
+
+#import <Foundation/Foundation.h>
+
+/**
+ * Intercepts TurboModule conversions to automatically decode null sentinels.
+ *
+ * iOS TurboModules strip null values from object properties during serialization.
+ * See: https://github.com/facebook/react-native/issues/52802
+ * The JavaScript side encodes nulls as sentinel objects,
+ * and this interceptor automatically converts them back to NSNull before they
+ * reach module implementation methods.
+ *
+ * This class uses method swizzling on RCTCxxConvert to intercept all TurboModule
+ * data conversion methods (JS_*Module_Spec*Data:), decoding sentinels before the
+ * data reaches the C++ bridging layer and ultimately your module methods.
+ */
+@interface RNFBNullSentinelInterceptor : NSObject
+
+/**
+ * Initializes the null sentinel interceptor.
+ * This swizzles RCTCxxConvert (TurboModule converter) to automatically decode null sentinels.
+ * Called automatically when the class is loaded via +load.
+ */
++ (void)initialize;
+
+@end
+
+#endif

package/ios/RNFBApp/RNFBNullSentinelInterceptor.m

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#import "RNFBNullSentinelInterceptor.h"
+#import <objc/runtime.h>
+#import "RNFBSharedUtils.h"
+
+@implementation RNFBNullSentinelInterceptor
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    [self swizzleRCTConvertMethods];
+  });
+}
+
++ (void)swizzleRCTConvertMethods {
+  // For TurboModules: Swizzle RCTCxxConvert to intercept all conversion methods
+  Class cxxConvertClass = NSClassFromString(@"RCTCxxConvert");
+  if (cxxConvertClass) {
+    [self swizzleTurboModuleConversions:cxxConvertClass];
+  }
+}
+
++ (void)swizzleTurboModuleConversions:(Class)cxxConvertClass {
+  // Get all methods from RCTCxxConvert
+  unsigned int methodCount = 0;
+  Method *methods = class_copyMethodList(object_getClass(cxxConvertClass), &methodCount);
+
+  for (unsigned int i = 0; i < methodCount; i++) {
+    Method method = methods[i];
+    SEL selector = method_getName(method);
+    NSString *selectorName = NSStringFromSelector(selector);
+
+    // Intercept TurboModule data conversion methods (they follow pattern:
+    // JS_NativeRNFBTurbo*_Spec*)
+    if ([selectorName hasPrefix:@"JS_NativeRNFBTurbo"] && [selectorName containsString:@"_Spec"]) {
+      // Create a swizzled version using IMP
+      IMP originalIMP = method_getImplementation(method);
+      const char *typeEncoding = method_getTypeEncoding(method);
+
+      // Replace with our wrapper that decodes nulls
+      IMP newIMP = imp_implementationWithBlock(^id(id self, id json) {
+        // Decode null sentinels before passing to original conversion
+        id decoded = [RNFBSharedUtils decodeNullSentinels:json];
+
+        // Call original implementation with decoded data
+        typedef id (*OriginalFunc)(id, SEL, id);
+        OriginalFunc originalFunc = (OriginalFunc)originalIMP;
+        return originalFunc(self, selector, decoded);
+      });
+
+      method_setImplementation(method, newIMP);
+    }
+  }
+
+  free(methods);
+}
+
+@end

package/ios/RNFBApp/RNFBSharedUtils.h

@@ -60,6 +60,8 @@ extern NSString *const DEFAULT_APP_NAME;
 
 + (BOOL)getConfigBooleanValue:(NSString *)tag key:(NSString *)key defaultValue:(BOOL)defaultValue;
 
++ (id)decodeNullSentinels:(id)value;
+
 @end
 
 #endif

package/ios/RNFBApp/RNFBSharedUtils.m

@@ -164,4 +164,122 @@ static NSString *const RNFBErrorDomain = @"RNFBErrorDomain";
   return enabled;
 }
 
+/**
+ * Decodes null sentinel objects back to NSNull values.
+ * Uses iterative stack-based traversal to avoid stack overflow on deeply nested structures.
+ *
+ * This reverses the encoding done on the JavaScript side where null values in object
+ * properties are replaced with {__rnfbNull: true} sentinel objects to survive iOS
+ * TurboModule serialization.
+ *
+ * Process:
+ * 1. Detects sentinel objects: dictionaries with single key "__rnfbNull" set to true
+ * 2. Replaces sentinels with NSNull in object properties and arrays
+ * 3. Preserves regular NSNull values that were in arrays (never encoded as sentinels)
+ * 4. Deep processes all nested objects and arrays using a stack-based iteration
+ *
+ * @param value - The value to decode (dictionary, array, or primitive)
+ * @return The decoded value with sentinels replaced by NSNull
+ */
++ (id)decodeNullSentinels:(id)value {
+  // Non-container values are returned as-is
+  if (![value isKindOfClass:[NSDictionary class]] && ![value isKindOfClass:[NSArray class]]) {
+    return value;
+  }
+
+  // Helper to detect the sentinel
+  BOOL (^isNullSentinel)(NSDictionary *) = ^BOOL(NSDictionary *dict) {
+    id flag = dict[@"__rnfbNull"];
+    return (dict.count == 1 && flag != nil && [flag boolValue]);
+  };
+
+  // Helper to process a child element and add it to the parent container
+  void (^processChild)(id, id, id, BOOL, NSMutableArray *) =
+      ^void(id child, id parentMutable, id keyOrNil, BOOL isParentDict, NSMutableArray *stack) {
+        id processedValue = nil;
+
+        if ([child isKindOfClass:[NSDictionary class]]) {
+          NSDictionary *childDict = (NSDictionary *)child;
+
+          if (isNullSentinel(childDict)) {
+            // Replace sentinel with NSNull
+            processedValue = [NSNull null];
+          } else {
+            // Process nested dictionary
+            NSMutableDictionary *childMut =
+                [NSMutableDictionary dictionaryWithCapacity:childDict.count];
+            processedValue = childMut;
+            [stack addObject:@{@"original" : childDict, @"mutable" : childMut}];
+          }
+        } else if ([child isKindOfClass:[NSArray class]]) {
+          // Process nested array
+          NSArray *childArray = (NSArray *)child;
+          NSMutableArray *childMut = [NSMutableArray arrayWithCapacity:childArray.count];
+          processedValue = childMut;
+          [stack addObject:@{@"original" : childArray, @"mutable" : childMut}];
+        } else {
+          // Preserve primitive values
+          processedValue = child ?: [NSNull null];
+        }
+
+        // Add to parent container based on type
+        if (isParentDict) {
+          NSMutableDictionary *mutDict = (NSMutableDictionary *)parentMutable;
+          if (processedValue) {
+            mutDict[keyOrNil] = processedValue;
+          }
+          // NSDictionary can't store nil, and original code wouldn't see nil values either.
+        } else {
+          NSMutableArray *mutArray = (NSMutableArray *)parentMutable;
+          [mutArray addObject:processedValue];
+        }
+      };
+
+  // Root-level sentinel case
+  if ([value isKindOfClass:[NSDictionary class]] && isNullSentinel((NSDictionary *)value)) {
+    return [NSNull null];
+  }
+
+  id rootOriginal = value;
+  id rootMutable = nil;
+
+  if ([value isKindOfClass:[NSDictionary class]]) {
+    NSDictionary *dict = (NSDictionary *)value;
+    rootMutable = [NSMutableDictionary dictionaryWithCapacity:dict.count];
+  } else {
+    NSArray *array = (NSArray *)value;
+    rootMutable = [NSMutableArray arrayWithCapacity:array.count];
+  }
+
+  // Stack-based iteration to process nested structures without recursion
+  // Stack frames: { @"original": container, @"mutable": mutableContainer }
+  NSMutableArray<NSDictionary *> *stack = [NSMutableArray array];
+  [stack addObject:@{@"original" : rootOriginal, @"mutable" : rootMutable}];
+
+  while (stack.count > 0) {
+    NSDictionary *frame = [stack lastObject];
+    [stack removeLastObject];
+
+    id original = frame[@"original"];
+    id mutable = frame[@"mutable"];
+
+    if ([original isKindOfClass:[NSDictionary class]]) {
+      NSDictionary *origDict = (NSDictionary *)original;
+
+      for (id key in origDict) {
+        id child = origDict[key];
+        processChild(child, mutable, key, YES, stack);
+      }
+    } else if ([original isKindOfClass:[NSArray class]]) {
+      NSArray *origArray = (NSArray *)original;
+
+      for (id child in origArray) {
+        processChild(child, mutable, nil, NO, stack);
+      }
+    }
+  }
+
+  return rootMutable;
+}
+
 @end

package/ios/RNFBApp/RNFBVersion.m

@@ -18,4 +18,4 @@
 #import <React/RCTVersion.h>
 
 // generated file - do not modify or commit
-NSString* const RNFBVersionString = @"23.7.0";
+NSString* const RNFBVersionString = @"23.8.1";

package/ios/RNFBApp.xcodeproj/project.pbxproj

@@ -17,6 +17,7 @@
 		2748D8202237018600FC8DC8 /* RNFBMeta.m in Sources */ = {isa = PBXBuildFile; fileRef = 2748D81F2237018600FC8DC8 /* RNFBMeta.m */; };
 		4D97BAD423042F2700077358 /* RNFBUtilsModule.m in Sources */ = {isa = PBXBuildFile; fileRef = 4D97BAD323042F2700077358 /* RNFBUtilsModule.m */; };
 		DAA1F28522FCF6AD00F4DEC1 /* RNFBVersion.m in Sources */ = {isa = PBXBuildFile; fileRef = DAA1F28422FCF6AD00F4DEC1 /* RNFBVersion.m */; };
+		RNFB00001A2025011100000001 /* RNFBNullSentinelInterceptor.m in Sources */ = {isa = PBXBuildFile; fileRef = RNFB00001A2025011100000002 /* RNFBNullSentinelInterceptor.m */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -53,6 +54,8 @@
 		4D97BAD323042F2700077358 /* RNFBUtilsModule.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBUtilsModule.m; sourceTree = "<group>"; };
 		DAA1F28422FCF6AD00F4DEC1 /* RNFBVersion.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBVersion.m; sourceTree = "<group>"; };
 		DAA1F28622FCF6C200F4DEC1 /* RNFBVersion.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBVersion.h; sourceTree = "<group>"; };
+		RNFB00001A2025011100000002 /* RNFBNullSentinelInterceptor.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBNullSentinelInterceptor.m; sourceTree = "<group>"; };
+		RNFB00001A2025011100000003 /* RNFBNullSentinelInterceptor.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBNullSentinelInterceptor.h; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -97,6 +100,8 @@
 				DAA1F28622FCF6C200F4DEC1 /* RNFBVersion.h */,
 				4D97BAD223042F0800077358 /* RNFBUtilsModule.h */,
 				4D97BAD323042F2700077358 /* RNFBUtilsModule.m */,
+				RNFB00001A2025011100000003 /* RNFBNullSentinelInterceptor.h */,
+				RNFB00001A2025011100000002 /* RNFBNullSentinelInterceptor.m */,
 			);
 			path = RNFBApp;
 			sourceTree = "<group>";
@@ -178,6 +183,7 @@
 				2744B99121F46140004F8E3F /* RNFBRCTEventEmitter.m in Sources */,
 				2744B9A421F48A4F004F8E3F /* RCTConvert+FIROptions.m in Sources */,
 				2748D8152236426300FC8DC8 /* RNFBJSON.m in Sources */,
+				RNFB00001A2025011100000001 /* RNFBNullSentinelInterceptor.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

package/lib/FirebaseApp.ts

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+import { warnIfNotModularCall } from './common';
+import { getAppModule } from './internal/registry/nativeModule';
+import type { ReactNativeFirebase, Utils } from './types/app';
+
+export default class FirebaseApp implements ReactNativeFirebase.FirebaseAppBase {
+  private _name: string;
+  private _deleted: boolean;
+  private _deleteApp: () => Promise<void>;
+  private _options: ReactNativeFirebase.FirebaseAppOptions;
+  private _automaticDataCollectionEnabled: boolean;
+  _initialized: boolean;
+  _nativeInitialized: boolean;
+
+  constructor(
+    options: ReactNativeFirebase.FirebaseAppOptions,
+    appConfig: ReactNativeFirebase.FirebaseAppConfig,
+    fromNative: boolean,
+    deleteApp: () => Promise<void>,
+  ) {
+    const { name = '[DEFAULT]', automaticDataCollectionEnabled } = appConfig;
+
+    this._name = name;
+    this._deleted = false;
+    this._deleteApp = deleteApp;
+    this._options = Object.assign({}, options);
+    this._automaticDataCollectionEnabled = !!automaticDataCollectionEnabled;
+
+    if (fromNative) {
+      this._initialized = true;
+      this._nativeInitialized = true;
+    } else {
+      this._initialized = false;
+      this._nativeInitialized = false;
+    }
+  }
+
+  get name(): string {
+    return this._name;
+  }
+
+  get options(): ReactNativeFirebase.FirebaseAppOptions {
+    return Object.assign({}, this._options);
+  }
+
+  get automaticDataCollectionEnabled(): boolean {
+    return this._automaticDataCollectionEnabled;
+  }
+
+  set automaticDataCollectionEnabled(enabled: boolean) {
+    this._checkDestroyed();
+    getAppModule().setAutomaticDataCollectionEnabled(this.name, enabled);
+    this._automaticDataCollectionEnabled = enabled;
+  }
+
+  private _checkDestroyed(): void {
+    if (this._deleted) {
+      throw new Error(`Firebase App named '${this._name}' already deleted`);
+    }
+  }
+
+  extendApp(extendedProps: Record<string, unknown>): void {
+    warnIfNotModularCall(arguments);
+    this._checkDestroyed();
+    Object.assign(this, extendedProps);
+  }
+
+  delete(): Promise<void> {
+    warnIfNotModularCall(arguments, 'deleteApp()');
+    this._checkDestroyed();
+    return this._deleteApp();
+  }
+
+  toString(): string {
+    warnIfNotModularCall(arguments, '.name property');
+    return this.name;
+  }
+
+  // For backward compatibility - utils method added by registry
+  utils(): Utils.Module {
+    throw new Error('utils() should be added by registry');
+  }
+}

package/lib/common/{Base64.js → Base64.ts}

@@ -15,6 +15,7 @@
  *
  */
 
+// @ts-expect-error - No type declarations available
 import binaryToBase64 from 'react-native/Libraries/Utilities/binaryToBase64';
 import { promiseDefer } from './promise';
 
@@ -23,7 +24,7 @@ const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
 /**
  * window.btoa
  */
-function btoa(input) {
+function btoa(input: string): string {
   let map;
   let i = 0;
   let block = 0;
@@ -51,11 +52,11 @@ function btoa(input) {
 /**
  * window.atob
  */
-function atob(input) {
+function atob(input: string): string {
   let i = 0;
   let bc = 0;
   let bs = 0;
-  let buffer;
+  let buffer: number | string;
   let output = '';
 
   const str = input.replace(/[=]+$/, '');
@@ -69,7 +70,7 @@ function atob(input) {
   for (
     bc = 0, bs = 0, i = 0;
     (buffer = str.charAt(i++));
-    ~buffer && ((bs = bc % 4 ? bs * 64 + buffer : buffer), bc++ % 4)
+    ~buffer && ((bs = bc % 4 ? bs * 64 + (buffer as number) : buffer), bc++ % 4)
       ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
       : 0
   ) {
@@ -79,23 +80,30 @@ function atob(input) {
   return output;
 }
 
+export interface Base64Result {
+  string: string | ArrayBuffer | null;
+  format: 'data_url' | 'base64';
+}
+
 /**
  * Converts a Blob, ArrayBuffer or Uint8Array to a base64 string.
  */
-function fromData(data) {
+function fromData(data: Blob | ArrayBuffer | Uint8Array): Promise<Base64Result> {
   if (data instanceof Blob) {
     const fileReader = new FileReader();
-    const { resolve, reject, promise } = promiseDefer();
+    const { resolve, reject, promise } = promiseDefer<Base64Result>();
 
     fileReader.readAsDataURL(data);
 
-    fileReader.onloadend = function onloadend() {
-      resolve({ string: fileReader.result, format: 'data_url' });
+    fileReader.onloadend = () => {
+      if (fileReader?.result) {
+        resolve?.({ string: fileReader.result, format: 'data_url' });
+      }
     };
 
-    fileReader.onerror = function onerror(event) {
-      fileReader.abort();
-      reject(event);
+    fileReader.onerror = event => {
+      fileReader?.abort();
+      reject?.(event);
     };
 
     return promise;

package/lib/common/MutatableParams.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { deepGet, deepSet } from './deeps';
+
+export default class MutatableParams {
+  _mutatableParams: Record<string, unknown>;
+  _parentInstance: MutatableParams;
+
+  constructor(parentInstance?: MutatableParams) {
+    if (parentInstance) {
+      this._mutatableParams = parentInstance._mutatableParams;
+      this._parentInstance = parentInstance;
+    } else {
+      this._mutatableParams = {};
+      this._parentInstance = this;
+    }
+  }
+
+  set(param: string, value: unknown): MutatableParams {
+    deepSet(this._mutatableParams, param, value);
+    return this._parentInstance;
+  }
+
+  get<T = unknown>(param: string): T | undefined {
+    return deepGet<T>(this._mutatableParams, param, '.');
+  }
+
+  toJSON(): Record<string, unknown> {
+    return Object.assign({}, this._mutatableParams);
+  }
+
+  validate(): void {
+    // do nothing
+  }
+}

package/lib/common/ReferenceBase.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+export default class ReferenceBase {
+  path: string;
+
+  constructor(_path: string) {
+    let path = _path;
+
+    if (path) {
+      path = path.length > 1 && path.endsWith('/') ? path.substring(0, path.length - 1) : path;
+      if (path.startsWith('/') && path.length > 1) {
+        path = path.substring(1, path.length);
+      }
+    } else {
+      path = '/';
+    }
+
+    this.path = path;
+  }
+
+  /**
+   * The last part of a Reference's path (after the last '/')
+   * The key of a root Reference is null.
+   * @type {String}
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#key}
+   */
+  get key(): string | null {
+    return this.path === '/' ? null : this.path.substring(this.path.lastIndexOf('/') + 1);
+  }
+}

package/lib/common/deeps.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import { isArray, isObject } from './validate';
+
+/**
+ * Deep get a value from an object.
+ * @website https://github.com/Salakar/deeps
+ * @param object
+ * @param path
+ * @param joiner
+ * @returns {*}
+ */
+export function deepGet<T = unknown>(
+  object: Record<string, unknown> | unknown[],
+  path: string,
+  joiner: string = '/',
+): T | undefined {
+  if (!isObject(object) && !Array.isArray(object)) {
+    return undefined;
+  }
+  const keys = path.split(joiner);
+
+  let i = 0;
+  let tmp: unknown = object;
+  const len = keys.length;
+
+  while (i < len) {
+    const key = keys[i++]!;
+    if (!tmp || !Object.hasOwnProperty.call(tmp, key)) {
+      return undefined;
+    }
+    tmp = (tmp as Record<string, unknown>)[key];
+  }
+
+  return tmp as T;
+}
+
+/**
+ * Deep set a value
+ * @param object
+ * @param path
+ * @param value
+ * @param initPaths
+ * @param joiner
+ */
+export function deepSet(
+  object: Record<string, unknown>,
+  path: string,
+  value: unknown,
+  initPaths: boolean = true,
+  joiner: string = '.',
+): boolean {
+  if (!isObject(object)) {
+    return false;
+  }
+  const keys = path.split(joiner);
+
+  let i = 0;
+  let _object: unknown = object;
+  const len = keys.length - 1;
+
+  while (i < len) {
+    const key = keys[i++]!;
+    if (initPaths && !Object.hasOwnProperty.call(object, key)) {
+      (_object as Record<string, unknown>)[key] = {};
+    }
+    _object = (_object as Record<string, unknown>)[key];
+  }
+
+  if (isObject(_object) || (isArray(_object) && !Number.isNaN(keys[i]))) {
+    (_object as Record<string, unknown>)[keys[i]!] = value;
+  } else {
+    return false;
+  }
+
+  return true;
+}