refactor(core): type-guards utils moved from sanitizer

Author: Reversean

packages/core/src/index.ts

@@ -4,4 +4,5 @@ export { HawkUserManager } from './users/hawk-user-manager';
 export type { Logger, LogType } from './logger/logger';
 export { isLoggerSet, setLogger, resetLogger, log } from './logger/logger';
 export { validateUser, validateContext, isValidEventPayload, isValidBreadcrumb } from './utils/validation';
-export { isPlainObject } from './utils/type-guards';
+export { isPlainObject, isArray, isClassPrototype, isClassInstance, isString } from './utils/type-guards';
+export { Sanitizer } from './modules/sanitizer';

packages/core/src/modules/sanitizer.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { isPlainObject } from '../utils/validation';
+import { isArray, isClassInstance, isClassPrototype, isPlainObject, isString } from '../utils/type-guards';
 
 /**
  * Custom type handler for Sanitizer.
@@ -55,15 +55,6 @@ export class Sanitizer {
    */
   private static readonly customHandlers: SanitizerTypeHandler[] = [];
 
-  /**
-   * Check if passed variable is an object
-   *
-   * @param target - variable to check
-   */
-  public static isObject(target: any): boolean {
-    return isPlainObject(target);
-  }
-
   /**
    * Register a custom type handler.
    * Handlers are checked before built-in type checks, in reverse registration order
@@ -96,7 +87,7 @@ export class Sanitizer {
     /**
      * If value is an Array, apply sanitizing for each element
      */
-    if (Sanitizer.isArray(data)) {
+    if (isArray(data)) {
       return this.sanitizeArray(data, depth + 1, seen);
     }
 
@@ -112,26 +103,26 @@ export class Sanitizer {
      * If values is a not-constructed class, it will be formatted as "<class SomeClass>"
      * class Editor {...} -> <class Editor>
      */
-    if (Sanitizer.isClassPrototype(data)) {
+    if (isClassPrototype(data)) {
       return Sanitizer.formatClassPrototype(data);
 
       /**
        * If values is a some class instance, it will be formatted as "<instance of SomeClass>"
        * new Editor() -> <instance of Editor>
        */
-    } else if (Sanitizer.isClassInstance(data)) {
+    } else if (isClassInstance(data)) {
       return Sanitizer.formatClassInstance(data);
 
       /**
        * If values is an object, do recursive call
        */
-    } else if (Sanitizer.isObject(data)) {
+    } else if (isPlainObject(data)) {
       return Sanitizer.sanitizeObject(data, depth + 1, seen);
 
       /**
        * If values is a string, trim it for max-length
        */
-    } else if (Sanitizer.isString(data)) {
+    } else if (isString(data)) {
       return Sanitizer.trimString(data);
     }
 
@@ -199,54 +190,6 @@ export class Sanitizer {
     return result;
   }
 
-  /**
-   * Check if passed variable is an array
-   *
-   * @param target - variable to check
-   */
-  private static isArray(target: any): boolean {
-    return Array.isArray(target);
-  }
-
-  /**
-   * Check if passed variable is a not-constructed class
-   *
-   * @param target - variable to check
-   */
-  private static isClassPrototype(target: any): boolean {
-    if (!target || !target.constructor) {
-      return false;
-    }
-
-    /**
-     * like
-     * "function Function {
-     *   [native code]
-     * }"
-     */
-    const constructorStr = target.constructor.toString();
-
-    return constructorStr.includes('[native code]') && constructorStr.includes('Function');
-  }
-
-  /**
-   * Check if passed variable is a constructed class instance
-   *
-   * @param target - variable to check
-   */
-  private static isClassInstance(target: any): boolean {
-    return target && target.constructor && (/^class \S+ {/).test(target.constructor.toString());
-  }
-
-  /**
-   * Check if passed variable is a string
-   *
-   * @param target - variable to check
-   */
-  private static isString(target: any): boolean {
-    return typeof target === 'string';
-  }
-
   /**
    * Return name of a passed class
    *

packages/core/src/utils/type-guards.ts

@@ -7,3 +7,51 @@
 export function isPlainObject(value: unknown): value is Record<string, unknown> {
   return Object.prototype.toString.call(value) === '[object Object]';
 }
+
+/**
+ * Check if passed variable is an array
+ *
+ * @param value - variable to check
+ */
+export function isArray(value: any): value is any[] {
+  return Array.isArray(value);
+}
+
+/**
+ * Check if passed variable is a not-constructed class
+ *
+ * @param value - variable to check
+ */
+export function isClassPrototype(value: any): boolean {
+  if (!value || !value.constructor) {
+    return false;
+  }
+
+  /**
+   * like
+   * "function Function {
+   *   [native code]
+   * }"
+   */
+  const constructorStr = value.constructor.toString();
+
+  return constructorStr.includes('[native code]') && constructorStr.includes('Function');
+}
+
+/**
+ * Check if passed variable is a constructed class instance
+ *
+ * @param value - variable to check
+ */
+export function isClassInstance(value: any): boolean {
+  return value && value.constructor && (/^class \S+ {/).test(value.constructor.toString());
+}
+
+/**
+ * Check if passed variable is a string
+ *
+ * @param value - variable to check
+ */
+export function isString(value: any): value is string {
+  return typeof value === 'string';
+}