@lookiero/checkout 0.6.0-beta.32 → 0.6.0-beta.34

package/dist/shared/logging/SentryDependencies.native.js

@@ -3,11 +3,18 @@ import { ReactNativeClient, Hub, ErrorBoundary, wrap as sentryWrap, ReactNativeT
 import { makeReactNativeTransport } from "@sentry/react-native/dist/js/transports/native";
 import { NATIVE } from "@sentry/react-native/dist/js/wrapper";
 import { useEffect } from "react";
-import { useLocation, useNavigationType } from "react-router-native";
+import { useLocation } from "react-router-native";
 import { matchRoutes } from "./matchRoutes";
-import { ReactRouterV6Instrumentation } from "./reactRouterV6Instrumentation.native";
-const transport = (options, nativeFetch) => NATIVE.isNativeTransportAvailable() ? makeReactNativeTransport(options) : makeFetchTransport(options, nativeFetch);
-const routingInstrumentation = new ReactRouterV6Instrumentation(useEffect, useLocation, useNavigationType, matchRoutes);
+import { ReactRouterV6Instrumentation } from "./reactRouterV6Instrumentation/reactRouterV6Instrumentation.native";
+const transport = (options, nativeFetch) => {
+    console.log("NATIVE.isNativeTransportAvailable()", NATIVE.isNativeTransportAvailable());
+    console.log(makeReactNativeTransport(options));
+    console.log(makeFetchTransport(options, nativeFetch));
+    return NATIVE.isNativeTransportAvailable()
+        ? makeReactNativeTransport(options)
+        : makeFetchTransport(options, nativeFetch);
+};
+const routingInstrumentation = new ReactRouterV6Instrumentation(useEffect, useLocation, matchRoutes);
 const integrations = [new ReactNativeTracing({ routingInstrumentation })];
 const wrapComponent = (Component) => sentryWrap(Component);
 const wrapUseRoutes = routingInstrumentation.wrapUseRoutes.bind(routingInstrumentation);

package/dist/shared/logging/SentryLogger.d.ts

@@ -2,7 +2,7 @@ import { ComponentType } from "react";
 import { Platform } from "react-native";
 interface SentryLoggerFunctionArgs {
     readonly publicKey: string;
-    readonly environment: `${typeof Platform.OS}-${"DEV" | "PROD"}`;
+    readonly environment: `${typeof Platform.OS}-${"DEV" | "PROD" | "EXPO"}`;
     readonly release: string;
     readonly project: string;
 }

package/dist/shared/logging/reactRouterV6Instrumentation/normalizedNameAndMatchForLocation.d.ts

@@ -0,0 +1,12 @@
+import { RouteMatch, RouteObject } from "react-router-native";
+import { Location } from "../types";
+interface NormalizedNameAndMatchForLocationFunctionArgs {
+    readonly routes: RouteObject[];
+    readonly location: Location;
+    readonly branches: RouteMatch[];
+}
+interface NormalizedNameAndMatchForLocationFunction {
+    (args: NormalizedNameAndMatchForLocationFunctionArgs): [string, RouteMatch | null];
+}
+declare const normalizedNameAndMatchForLocation: NormalizedNameAndMatchForLocationFunction;
+export { normalizedNameAndMatchForLocation };

package/dist/shared/logging/reactRouterV6Instrumentation/normalizedNameAndMatchForLocation.js

@@ -0,0 +1,34 @@
+import { getNumberOfUrlSegments } from "@sentry/utils";
+const normalizedNameAndMatchForLocation = ({ routes, location, branches, }) => {
+    if (!routes || routes.length === 0) {
+        return [location.pathname, null];
+    }
+    let pathBuilder = "";
+    if (branches) {
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let x = 0; x < branches.length; x++) {
+            const branch = branches[x];
+            const route = branch.route;
+            if (route) {
+                // Early return if index route
+                if (route.index) {
+                    return [branch.pathname, branch];
+                }
+                const path = route.path;
+                if (path) {
+                    const newPath = path[0] === "/" || pathBuilder[pathBuilder.length - 1] === "/" ? path : `/${path}`;
+                    pathBuilder += newPath;
+                    if (branch.pathname === location.pathname) {
+                        if (getNumberOfUrlSegments(pathBuilder) !== getNumberOfUrlSegments(branch.pathname) &&
+                            pathBuilder.slice(-2) !== "/*") {
+                            return [newPath, branch];
+                        }
+                        return [pathBuilder, branch];
+                    }
+                }
+            }
+        }
+    }
+    return [location.pathname, null];
+};
+export { normalizedNameAndMatchForLocation };

package/dist/shared/logging/reactRouterV6Instrumentation/reactRouterV6Instrumentation.native.d.ts

@@ -0,0 +1,22 @@
+import { RoutingInstrumentation } from "@sentry/react-native";
+import { OnConfirmRoute, TransactionCreator } from "@sentry/react-native/dist/js/tracing/routingInstrumentation";
+import { BeforeNavigate } from "@sentry/react-native/dist/js/tracing/types";
+import { MatchRoutes, UseEffect, UseLocation, WrapUseRoutes } from "../types";
+declare class ReactRouterV6Instrumentation extends RoutingInstrumentation {
+    static instrumentationName: string;
+    private useEffect;
+    private useLocation;
+    private matchRoutes;
+    private prevRoute?;
+    private recentRouteKeys;
+    private latestTransaction?;
+    private readonly maxRecentRouteLen;
+    constructor(useEffect: UseEffect, useLocation: UseLocation, matchRoutes: MatchRoutes);
+    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
+    private onRouteChange;
+    private currentRouteFromLocation;
+    private pushRecentRouteKey;
+    private onBeforeNavigateNotSampled;
+    wrapUseRoutes: WrapUseRoutes;
+}
+export { ReactRouterV6Instrumentation };

package/dist/shared/logging/reactRouterV6Instrumentation/reactRouterV6Instrumentation.native.js

@@ -0,0 +1,124 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { RoutingInstrumentation } from "@sentry/react-native";
+import { logger } from "@sentry/utils";
+import React from "react";
+import { normalizedNameAndMatchForLocation } from "./normalizedNameAndMatchForLocation";
+import { transactionContext } from "./transactionContext";
+class ReactRouterV6Instrumentation extends RoutingInstrumentation {
+    static instrumentationName = "react-router-v6";
+    useEffect;
+    useLocation;
+    matchRoutes;
+    prevRoute;
+    recentRouteKeys = [];
+    latestTransaction;
+    maxRecentRouteLen = 200;
+    constructor(useEffect, useLocation, matchRoutes) {
+        super();
+        this.useEffect = useEffect;
+        this.useLocation = useLocation;
+        this.matchRoutes = matchRoutes;
+    }
+    registerRoutingInstrumentation(listener, beforeNavigate, onConfirmRoute) {
+        super.registerRoutingInstrumentation(listener, beforeNavigate, onConfirmRoute);
+        this.latestTransaction = this.onRouteWillChange(INITIAL_TRANSACTION_CONTEXT);
+    }
+    onRouteChange(location, routes, updateLatestTransaction = false) {
+        const currentRoute = this.currentRouteFromLocation(location, routes);
+        if (!currentRoute || (this.prevRoute && currentRoute.key === this.prevRoute.key)) {
+            return;
+        }
+        const originalContext = transactionContext({
+            instrumentationName: ReactRouterV6Instrumentation.instrumentationName,
+            route: currentRoute,
+            previousRoute: this.prevRoute,
+        });
+        let finalContext = this._beforeNavigate?.(originalContext);
+        if (!finalContext) {
+            logger.error(`[ReactRouterV6Instrumentation] beforeNavigate returned ${finalContext}, return context.sampled = false to not send transaction.`);
+            finalContext = { ...originalContext, sampled: false };
+        }
+        if (finalContext.sampled === false) {
+            this.onBeforeNavigateNotSampled(finalContext.name);
+        }
+        if (updateLatestTransaction && this.latestTransaction) {
+            this.latestTransaction.updateWithContext(finalContext);
+        }
+        else {
+            this.latestTransaction = this.onRouteWillChange(finalContext);
+        }
+        this.pushRecentRouteKey(currentRoute.key);
+        this.prevRoute = currentRoute;
+    }
+    currentRouteFromLocation(location, routes) {
+        const branches = this.matchRoutes(routes, location);
+        if (!branches) {
+            return null;
+        }
+        const [normalizedName, match] = normalizedNameAndMatchForLocation({ location, routes, branches });
+        if (!match) {
+            return {
+                name: normalizedName,
+                key: normalizedName,
+                params: {},
+                hasBeenSeen: this.recentRouteKeys.includes(normalizedName),
+            };
+        }
+        const name = match.route.path;
+        const key = match.route.id ?? name;
+        return {
+            name,
+            key,
+            params: match.params,
+            hasBeenSeen: this.recentRouteKeys.includes(key),
+        };
+    }
+    pushRecentRouteKey(key) {
+        this.recentRouteKeys.push(key);
+        if (this.recentRouteKeys.length > this.maxRecentRouteLen) {
+            this.recentRouteKeys = this.recentRouteKeys.slice(this.recentRouteKeys.length - this.maxRecentRouteLen);
+        }
+    }
+    onBeforeNavigateNotSampled(transactionName) {
+        logger.log(`[ReactRouterV6Instrumentation] Will not send transaction "${transactionName}" due to beforeNavigate.`);
+    }
+    wrapUseRoutes = (origUseRoutes) => {
+        if (!this.useEffect || !this.useLocation || !this.matchRoutes) {
+            __DEBUG_BUILD__ &&
+                logger.warn("ReactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters.");
+            return origUseRoutes;
+        }
+        let isMountRenderPass = true;
+        const useRoutes = (routes, locationArg) => {
+            const SentryRoutes = () => {
+                const Routes = origUseRoutes(routes, locationArg);
+                const location = this.useLocation();
+                const stableLocationParam = typeof locationArg === "string" || (locationArg && locationArg.pathname)
+                    ? locationArg
+                    : location;
+                this.useEffect(() => {
+                    const normalizedLocation = typeof stableLocationParam === "string" ? { pathname: stableLocationParam } : stableLocationParam;
+                    if (isMountRenderPass) {
+                        this.onRouteChange(normalizedLocation, routes, true);
+                        isMountRenderPass = false;
+                    }
+                    else {
+                        this.onRouteChange(normalizedLocation, routes);
+                    }
+                }, [stableLocationParam]);
+                return Routes;
+            };
+            return React.createElement(SentryRoutes, null);
+        };
+        return useRoutes;
+    };
+}
+const INITIAL_TRANSACTION_CONTEXT = {
+    name: "App Launch",
+    op: "navigation",
+    tags: {
+        ["routing.instrumentation"]: ReactRouterV6Instrumentation.instrumentationName,
+    },
+    data: {},
+};
+export { ReactRouterV6Instrumentation };

package/dist/shared/logging/reactRouterV6Instrumentation/transactionContext.d.ts

@@ -0,0 +1,22 @@
+import { TransactionContext } from "@sentry/types";
+import { NavigationCurrentRoute, NavigationRoute } from "./types";
+interface NavigationTransactionContext extends TransactionContext {
+    readonly tags: {
+        readonly ["routing.instrumentation"]: string;
+        readonly ["routing.route.name"]: string;
+    };
+    readonly data: {
+        readonly route: NavigationCurrentRoute;
+        readonly previousRoute: NavigationRoute | null;
+    };
+}
+interface TransactionContextFunctionArgs {
+    readonly instrumentationName: string;
+    readonly route: NavigationCurrentRoute;
+    readonly previousRoute?: NavigationRoute;
+}
+interface TransactionContextFunction {
+    (args: TransactionContextFunctionArgs): NavigationTransactionContext;
+}
+declare const transactionContext: TransactionContextFunction;
+export { transactionContext };

package/dist/shared/logging/reactRouterV6Instrumentation/transactionContext.js

@@ -0,0 +1,15 @@
+const transactionContext = ({ instrumentationName, route, previousRoute = null, }) => {
+    return {
+        name: route.name,
+        op: "navigation",
+        tags: {
+            ["routing.instrumentation"]: instrumentationName,
+            ["routing.route.name"]: route.name,
+        },
+        data: {
+            route,
+            previousRoute,
+        },
+    };
+};
+export { transactionContext };

package/dist/shared/logging/reactRouterV6Instrumentation/types.d.ts

@@ -0,0 +1,9 @@
+interface NavigationRoute {
+    readonly name: string;
+    readonly key: string;
+    readonly params: Record<string, unknown>;
+}
+interface NavigationCurrentRoute extends NavigationRoute {
+    readonly hasBeenSeen: boolean;
+}
+export type { NavigationRoute, NavigationCurrentRoute };

package/dist/shared/logging/reactRouterV6Instrumentation/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/logging/types.d.ts

@@ -1,8 +1,10 @@
 import { ComponentType, useEffect } from "react";
 import { matchRoutes, RouteObject, useLocation } from "react-router-native";
+interface Location {
+    readonly pathname: string;
+}
 type UseEffect = typeof useEffect;
 type UseLocation = typeof useLocation;
-type UseNavigationType = () => "PUSH" | "REPLACE" | "POP";
 type MatchRoutes = typeof matchRoutes;
 type UseRoutes = (routes: RouteObject[], locationArg?: Partial<Location> | string) => React.ReactElement | null;
 interface WrapUseRoutes {
@@ -11,4 +13,4 @@ interface WrapUseRoutes {
 interface WrapComponent {
     <P>(Component: ComponentType<P>): ComponentType<P>;
 }
-export type { UseEffect, UseLocation, UseNavigationType, MatchRoutes, WrapUseRoutes, WrapComponent };
+export type { Location, UseEffect, UseLocation, MatchRoutes, UseRoutes, WrapUseRoutes, WrapComponent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lookiero/checkout",
-  "version": "0.6.0-beta.32",
+  "version": "0.6.0-beta.34",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [