@luciq/react-native 19.4.0 → 19.6.0

package/src/utils/LuciqUtils.ts

@@ -420,6 +420,54 @@ export function updateNetworkLogSnapshot(networkSnapshot: NetworkData) {
   );
 }
 
+/**
+ * @internal
+ * This method is for internal use only.
+ *
+ * Parses a string value to an integer, returning null if the value is null or cannot be parsed.
+ * @param value The string value to parse
+ * @returns The parsed integer or null
+ */
+export function getIntValue(value: string | null): number | null {
+  if (value === null) {
+    return null;
+  }
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? null : parsed;
+}
+
+// One-time anchor captured at module load to convert performance.now() to epoch time.
+// performance.now() gives high-resolution monotonic time (sub-ms precision) but relative
+// to app start. We pair it with Date.now() once, then derive epoch from the offset.
+const perfAnchorMs: number = performance.now();
+const epochAnchorUs: number = Date.now() * 1000;
+
+/**
+ * Returns a high-resolution monotonic timestamp in microseconds.
+ * Use this for all internal duration measurements.
+ */
+export function nowMicros(): number {
+  return performance.now() * 1000;
+}
+
+/**
+ * Converts an internal monotonic microsecond timestamp to epoch microseconds.
+ * Use this only when reporting to the native layer or external systems.
+ */
+export function toEpochMicros(monotonicUs: number): number {
+  const offsetUs = monotonicUs - perfAnchorMs * 1000;
+  return epochAnchorUs + offsetUs;
+}
+
+/**
+ * Converts an epoch microsecond timestamp to internal monotonic microseconds.
+ * Use this when receiving timestamps from the native layer that are epoch-based.
+ */
+export function fromEpochMicros(epochUs: number): number {
+  const offsetUs = epochUs - epochAnchorUs;
+  return perfAnchorMs * 1000 + offsetUs;
+}
+
 export default {
   parseErrorStack,
   captureJsErrors,
@@ -427,6 +475,7 @@ export default {
   getFullRoute,
   getStackTrace,
   stringifyIfNotString,
+  getIntValue,
   sendCrashReport,
   reportNetworkLog,
   generateTracePartialId,

package/src/utils/RouteMatcher.ts

@@ -0,0 +1,83 @@
+// TODO: This class is currently unused but will be used later for route matching.
+/**
+ * Matches route path definitions (potentially containing parameters and wildcards)
+ * against actual navigation paths.
+ *
+ * Supports `:param` segments for named parameters and `**` for wildcard matching.
+ */
+class RouteMatcher {
+  private static _instance: RouteMatcher = new RouteMatcher();
+
+  static get instance(): RouteMatcher {
+    return RouteMatcher._instance;
+  }
+
+  /** @internal visible for testing */
+  static setInstance(instance: RouteMatcher): void {
+    RouteMatcher._instance = instance;
+  }
+
+  /**
+   * Checks whether the given `routePath` definition matches the given `actualPath`.
+   *
+   * The `routePath` definition can contain parameters in the form of `:param`,
+   * or `**` for a wildcard parameter.
+   *
+   * Returns `true` if the `actualPath` matches the `routePath`, otherwise `false`.
+   *
+   * @example
+   * ```ts
+   * RouteMatcher.instance.match('/users', '/users'); // true
+   * RouteMatcher.instance.match('/user/:id', '/user/123'); // true
+   * RouteMatcher.instance.match('/user/**', '/user/123/profile'); // true
+   * ```
+   */
+  match(routePath: string | null, actualPath: string | null): boolean {
+    if (routePath == null || actualPath == null) {
+      return routePath === actualPath;
+    }
+
+    const routePathSegments = this.segmentPath(routePath);
+    const actualPathSegments = this.segmentPath(actualPath);
+
+    const hasWildcard = routePathSegments.includes('**');
+
+    if (routePathSegments.length !== actualPathSegments.length && !hasWildcard) {
+      return false;
+    }
+
+    for (let i = 0; i < routePathSegments.length; i++) {
+      const routeSegment = routePathSegments[i];
+
+      const isWildcard = routeSegment === '**';
+      const isParameter = routeSegment.startsWith(':');
+
+      const noMoreActualSegments = i >= actualPathSegments.length;
+
+      if (noMoreActualSegments) {
+        return isWildcard;
+      }
+
+      if (isParameter) {
+        continue;
+      }
+
+      if (isWildcard) {
+        return true;
+      }
+
+      if (routeSegment !== actualPathSegments[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private segmentPath(path: string): string[] {
+    const pathWithoutQuery = path.split('?')[0];
+    return pathWithoutQuery.split('/').filter((segment) => segment.length > 0);
+  }
+}
+
+export default RouteMatcher;