@refraction-ui/react 0.6.0 → 0.8.0

package/dist/internal/analytics-sink-app-insights/index.d.cts

@@ -0,0 +1,165 @@
+import { AnalyticsEvent, AnalyticsSink } from '../analytics/index.cjs';
+
+/**
+ * Minimal structural shape of the bits of `@microsoft/applicationinsights-web`
+ * we use. Declared locally so the vendor lib stays an OPTIONAL peer with NO
+ * type-level hard dependency — it is only ever reached via dynamic import.
+ */
+interface AppInsightsLike {
+    loadAppInsights?: () => unknown;
+    trackEvent: (event: {
+        name: string;
+    }, customProperties?: Record<string, unknown>) => void;
+    trackPageView: (pageView?: {
+        name?: string;
+        uri?: string;
+        properties?: Record<string, unknown>;
+        measurements?: Record<string, number>;
+    }) => void;
+    setAuthenticatedUserContext?: (authenticatedUserId: string, accountId?: string, storeInCookie?: boolean) => void;
+    clearAuthenticatedUserContext?: () => void;
+    flush?: (async?: boolean) => void;
+}
+/** Fan-out mode for the App Insights sink. */
+type AppInsightsSinkMode = 'client-sdk' | 'http';
+interface BaseOptions {
+    /** Consent categories this sink requires. Default `['analytics']`. */
+    consentCategories?: string[];
+    /** Stable sink name. Default `'app-insights'`. */
+    name?: string;
+}
+/**
+ * `client-sdk` mode — runs in the browser via `@microsoft/applicationinsights-web`.
+ *
+ * The vendor SDK is loaded **lazily via dynamic import** the first time a
+ * batch is delivered, so it never enters the bundle unless this sink is used.
+ * Callers may instead inject a ready instance (`appInsights`) or a custom
+ * `loadSdk` factory (used by tests with a mock transport — no network).
+ */
+interface ClientSdkOptions extends BaseOptions {
+    mode: 'client-sdk';
+    /** App Insights connection string (preferred) or instrumentation key. */
+    connectionString?: string;
+    /** Legacy instrumentation key (used when `connectionString` is absent). */
+    instrumentationKey?: string;
+    /**
+     * Pre-constructed App Insights instance. When provided, no dynamic import
+     * or `loadAppInsights()` happens — used for DI/testing.
+     */
+    appInsights?: AppInsightsLike;
+    /**
+     * Custom async SDK factory. Overrides the built-in dynamic import of
+     * `@microsoft/applicationinsights-web`. Receives the resolved config.
+     */
+    loadSdk?: (config: {
+        connectionString?: string;
+        instrumentationKey?: string;
+    }) => Promise<AppInsightsLike>;
+}
+/**
+ * `http` mode — POSTs to the App Insights `/v2/track` ingestion endpoint.
+ * No browser library is loaded; server-relay friendly.
+ */
+interface HttpOptions extends BaseOptions {
+    mode: 'http';
+    /** Instrumentation key (iKey) for the ingestion envelope. Required. */
+    instrumentationKey: string;
+    /**
+     * Ingestion endpoint base. Default the public global endpoint
+     * `https://dc.services.visualstudio.com`. Region endpoints are accepted.
+     * Events POST to `{endpoint}/v2/track`.
+     */
+    endpoint?: string;
+    /** Injected fetch (defaults to global fetch). */
+    fetchImpl?: typeof fetch;
+    /** Max retries for 429/5xx (exponential backoff). Default 3. */
+    maxRetries?: number;
+    /** Base backoff delay in ms. Default 500. */
+    backoffBaseMs?: number;
+}
+type AppInsightsSinkOptions = ClientSdkOptions | HttpOptions;
+interface IngestEnvelope {
+    name: string;
+    time: string;
+    iKey: string;
+    tags: Record<string, string>;
+    data: {
+        baseType: 'EventData' | 'PageViewData';
+        baseData: {
+            ver: 2;
+            name: string;
+            properties: Record<string, string>;
+            measurements: Record<string, number>;
+        };
+    };
+}
+/**
+ * Build an App Insights ingestion envelope (Breeze schema) for one canonical
+ * event. `tags` carry session/user/operation correlation; `baseData` carries
+ * the custom event with the properties/measurements split.
+ */
+declare function buildIngestEnvelope(ev: AnalyticsEvent, iKey: string): IngestEnvelope;
+/**
+ * Create an Azure Application Insights {@link AnalyticsSink}.
+ *
+ * Dual-mode:
+ *  - `client-sdk` — browser, lazy `@microsoft/applicationinsights-web`
+ *    (`trackEvent` / `trackPageView`); the vendor lib is an OPTIONAL peer
+ *    loaded only via dynamic import, never a hard/static dependency.
+ *  - `http` — App Insights `/v2/track` ingestion endpoint; no browser lib,
+ *    server-relay friendly.
+ *
+ * Both modes map the canonical envelope to App Insights custom events with a
+ * properties/measurements split and surface identity as
+ * `authenticatedUserId` / `anonymous`.
+ */
+declare function createAppInsightsSink(options: AppInsightsSinkOptions): AnalyticsSink;
+
+/**
+ * App Insights custom-event payload after mapping the canonical envelope.
+ *
+ * App Insights splits a custom event's bag into two dictionaries:
+ *  - `properties`  — string-valued dimensions (everything non-numeric)
+ *  - `measurements`— numeric metrics (queryable/aggregatable in KQL)
+ *
+ * We additionally surface identity:
+ *  - `authenticatedUserId` — present iff the envelope has `userId`
+ *  - `anonymous` — `'true'` when no `userId`, else `'false'` (string for the
+ *     properties bag; App Insights properties are always strings)
+ */
+interface AppInsightsEvent {
+    /** App Insights custom-event name. */
+    name: string;
+    /** String-valued custom dimensions. */
+    properties: Record<string, string>;
+    /** Numeric custom metrics. */
+    measurements: Record<string, number>;
+}
+/**
+ * Derive the App Insights custom-event name for a canonical event.
+ *
+ * - `page`  → `Page View: <name|path>` (also routed to `trackPageView` in the
+ *   client-sdk mode; the name here is the http-mode/event fallback)
+ * - `screen`→ `Screen: <name>`
+ * - `identify` → `Identify`
+ * - `group` → `Group`
+ * - `alias` → `Alias`
+ * - `track` → the event name (or `track` when absent)
+ */
+declare function eventName(ev: AnalyticsEvent): string;
+/**
+ * Map a canonical {@link AnalyticsEvent} to an {@link AppInsightsEvent}.
+ *
+ * Properties bag composition:
+ *  - canonical context: `app`, `env`, library name/version, page fields
+ *  - envelope identity/routing: `messageId`, `anonymousId`, `sessionId`,
+ *    `type`, `groupId?`, `previousId?`, `timestamp`, `schemaVersion`
+ *  - identity surface: `authenticatedUserId` (iff `userId`), `anonymous`
+ *  - the event's `properties` and `traits`, numbers → `measurements`
+ *
+ * The split is stable and lossless: every scalar lands in exactly one of the
+ * two dictionaries; nested objects are dot-flattened.
+ */
+declare function mapEvent(ev: AnalyticsEvent): AppInsightsEvent;
+
+export { type AppInsightsEvent, type AppInsightsLike, type AppInsightsSinkMode, type AppInsightsSinkOptions, type ClientSdkOptions, type HttpOptions, buildIngestEnvelope, createAppInsightsSink, eventName, mapEvent };

package/dist/internal/analytics-sink-app-insights/index.d.ts

@@ -0,0 +1,165 @@
+import { AnalyticsEvent, AnalyticsSink } from '../analytics/index.js';
+
+/**
+ * Minimal structural shape of the bits of `@microsoft/applicationinsights-web`
+ * we use. Declared locally so the vendor lib stays an OPTIONAL peer with NO
+ * type-level hard dependency — it is only ever reached via dynamic import.
+ */
+interface AppInsightsLike {
+    loadAppInsights?: () => unknown;
+    trackEvent: (event: {
+        name: string;
+    }, customProperties?: Record<string, unknown>) => void;
+    trackPageView: (pageView?: {
+        name?: string;
+        uri?: string;
+        properties?: Record<string, unknown>;
+        measurements?: Record<string, number>;
+    }) => void;
+    setAuthenticatedUserContext?: (authenticatedUserId: string, accountId?: string, storeInCookie?: boolean) => void;
+    clearAuthenticatedUserContext?: () => void;
+    flush?: (async?: boolean) => void;
+}
+/** Fan-out mode for the App Insights sink. */
+type AppInsightsSinkMode = 'client-sdk' | 'http';
+interface BaseOptions {
+    /** Consent categories this sink requires. Default `['analytics']`. */
+    consentCategories?: string[];
+    /** Stable sink name. Default `'app-insights'`. */
+    name?: string;
+}
+/**
+ * `client-sdk` mode — runs in the browser via `@microsoft/applicationinsights-web`.
+ *
+ * The vendor SDK is loaded **lazily via dynamic import** the first time a
+ * batch is delivered, so it never enters the bundle unless this sink is used.
+ * Callers may instead inject a ready instance (`appInsights`) or a custom
+ * `loadSdk` factory (used by tests with a mock transport — no network).
+ */
+interface ClientSdkOptions extends BaseOptions {
+    mode: 'client-sdk';
+    /** App Insights connection string (preferred) or instrumentation key. */
+    connectionString?: string;
+    /** Legacy instrumentation key (used when `connectionString` is absent). */
+    instrumentationKey?: string;
+    /**
+     * Pre-constructed App Insights instance. When provided, no dynamic import
+     * or `loadAppInsights()` happens — used for DI/testing.
+     */
+    appInsights?: AppInsightsLike;
+    /**
+     * Custom async SDK factory. Overrides the built-in dynamic import of
+     * `@microsoft/applicationinsights-web`. Receives the resolved config.
+     */
+    loadSdk?: (config: {
+        connectionString?: string;
+        instrumentationKey?: string;
+    }) => Promise<AppInsightsLike>;
+}
+/**
+ * `http` mode — POSTs to the App Insights `/v2/track` ingestion endpoint.
+ * No browser library is loaded; server-relay friendly.
+ */
+interface HttpOptions extends BaseOptions {
+    mode: 'http';
+    /** Instrumentation key (iKey) for the ingestion envelope. Required. */
+    instrumentationKey: string;
+    /**
+     * Ingestion endpoint base. Default the public global endpoint
+     * `https://dc.services.visualstudio.com`. Region endpoints are accepted.
+     * Events POST to `{endpoint}/v2/track`.
+     */
+    endpoint?: string;
+    /** Injected fetch (defaults to global fetch). */
+    fetchImpl?: typeof fetch;
+    /** Max retries for 429/5xx (exponential backoff). Default 3. */
+    maxRetries?: number;
+    /** Base backoff delay in ms. Default 500. */
+    backoffBaseMs?: number;
+}
+type AppInsightsSinkOptions = ClientSdkOptions | HttpOptions;
+interface IngestEnvelope {
+    name: string;
+    time: string;
+    iKey: string;
+    tags: Record<string, string>;
+    data: {
+        baseType: 'EventData' | 'PageViewData';
+        baseData: {
+            ver: 2;
+            name: string;
+            properties: Record<string, string>;
+            measurements: Record<string, number>;
+        };
+    };
+}
+/**
+ * Build an App Insights ingestion envelope (Breeze schema) for one canonical
+ * event. `tags` carry session/user/operation correlation; `baseData` carries
+ * the custom event with the properties/measurements split.
+ */
+declare function buildIngestEnvelope(ev: AnalyticsEvent, iKey: string): IngestEnvelope;
+/**
+ * Create an Azure Application Insights {@link AnalyticsSink}.
+ *
+ * Dual-mode:
+ *  - `client-sdk` — browser, lazy `@microsoft/applicationinsights-web`
+ *    (`trackEvent` / `trackPageView`); the vendor lib is an OPTIONAL peer
+ *    loaded only via dynamic import, never a hard/static dependency.
+ *  - `http` — App Insights `/v2/track` ingestion endpoint; no browser lib,
+ *    server-relay friendly.
+ *
+ * Both modes map the canonical envelope to App Insights custom events with a
+ * properties/measurements split and surface identity as
+ * `authenticatedUserId` / `anonymous`.
+ */
+declare function createAppInsightsSink(options: AppInsightsSinkOptions): AnalyticsSink;
+
+/**
+ * App Insights custom-event payload after mapping the canonical envelope.
+ *
+ * App Insights splits a custom event's bag into two dictionaries:
+ *  - `properties`  — string-valued dimensions (everything non-numeric)
+ *  - `measurements`— numeric metrics (queryable/aggregatable in KQL)
+ *
+ * We additionally surface identity:
+ *  - `authenticatedUserId` — present iff the envelope has `userId`
+ *  - `anonymous` — `'true'` when no `userId`, else `'false'` (string for the
+ *     properties bag; App Insights properties are always strings)
+ */
+interface AppInsightsEvent {
+    /** App Insights custom-event name. */
+    name: string;
+    /** String-valued custom dimensions. */
+    properties: Record<string, string>;
+    /** Numeric custom metrics. */
+    measurements: Record<string, number>;
+}
+/**
+ * Derive the App Insights custom-event name for a canonical event.
+ *
+ * - `page`  → `Page View: <name|path>` (also routed to `trackPageView` in the
+ *   client-sdk mode; the name here is the http-mode/event fallback)
+ * - `screen`→ `Screen: <name>`
+ * - `identify` → `Identify`
+ * - `group` → `Group`
+ * - `alias` → `Alias`
+ * - `track` → the event name (or `track` when absent)
+ */
+declare function eventName(ev: AnalyticsEvent): string;
+/**
+ * Map a canonical {@link AnalyticsEvent} to an {@link AppInsightsEvent}.
+ *
+ * Properties bag composition:
+ *  - canonical context: `app`, `env`, library name/version, page fields
+ *  - envelope identity/routing: `messageId`, `anonymousId`, `sessionId`,
+ *    `type`, `groupId?`, `previousId?`, `timestamp`, `schemaVersion`
+ *  - identity surface: `authenticatedUserId` (iff `userId`), `anonymous`
+ *  - the event's `properties` and `traits`, numbers → `measurements`
+ *
+ * The split is stable and lossless: every scalar lands in exactly one of the
+ * two dictionaries; nested objects are dot-flattened.
+ */
+declare function mapEvent(ev: AnalyticsEvent): AppInsightsEvent;
+
+export { type AppInsightsEvent, type AppInsightsLike, type AppInsightsSinkMode, type AppInsightsSinkOptions, type ClientSdkOptions, type HttpOptions, buildIngestEnvelope, createAppInsightsSink, eventName, mapEvent };

package/dist/internal/analytics-sink-ga4/index.d.cts

@@ -0,0 +1,219 @@
+import { AnalyticsSink, AnalyticsEvent } from '../analytics/index.cjs';
+
+/**
+ * @refraction-ui/analytics-sink-ga4 — option contracts.
+ *
+ * GA4 is "just a sink" in the epic's model (no privileged engine). This
+ * adapter implements the `AnalyticsSink` SPI from `@refraction-ui/analytics`
+ * in two interchangeable modes:
+ *
+ *   - `client-sdk` — lazy-loads gtag.js in the browser (no hard vendor dep;
+ *     the script is injected on first delivery only). Bridges Consent Mode.
+ *   - `http`       — GA4 Measurement Protocol (`/mp/collect`). No browser
+ *     library is ever loaded — server-relay friendly.
+ *
+ * Default = `http` (protocol adapter, no vendor lib in the browser), matching
+ * the epic's "default = protocol adapters" stance.
+ */
+/** Minimal gtag.js function signature (we never import the real types). */
+type GtagFn = (...args: unknown[]) => void;
+/** GA4 Consent Mode signal values. */
+type ConsentState = 'granted' | 'denied';
+/**
+ * GA4 Consent Mode bridge — maps our consent categories to the gtag
+ * `consent` command. Only used in `client-sdk` mode.
+ */
+interface GA4ConsentBridge {
+    /**
+     * Default consent state pushed via `gtag('consent', 'default', …)` before
+     * the GA4 tag loads. Keys are GA4 consent types
+     * (`analytics_storage`, `ad_storage`, `ad_user_data`,
+     * `ad_personalization`, `functionality_storage`, …).
+     */
+    default?: Record<string, ConsentState>;
+    /**
+     * Maps a refraction consent category → the GA4 consent types it controls.
+     * When the router reports the sink may deliver (category granted) the
+     * adapter pushes `gtag('consent', 'update', { <types>: 'granted' })`.
+     * Example: `{ analytics: ['analytics_storage'] }`.
+     */
+    map?: Record<string, string[]>;
+}
+interface GA4CommonOptions {
+    /** GA4 Measurement ID, e.g. `G-XXXXXXXXXX`. */
+    measurementId: string;
+    /**
+     * Consent categories this sink requires. The router will not deliver until
+     * all are granted. Default: `['analytics']`.
+     */
+    consentCategories?: string[];
+    /** Stable sink name. Default `'ga4'`. */
+    name?: string;
+}
+/** `client-sdk` mode — runs gtag.js in the browser. */
+interface GA4ClientSdkOptions extends GA4CommonOptions {
+    mode: 'client-sdk';
+    /**
+     * Inject the GA4 Consent Mode bridge. The default state (if any) is pushed
+     * before the tag loads; category grants drive `consent: update`.
+     */
+    consentMode?: GA4ConsentBridge;
+    /**
+     * Inject an existing gtag function (tests / apps that manage the tag
+     * themselves). When provided, the script loader is NOT used and **no**
+     * vendor script is injected.
+     */
+    gtag?: GtagFn;
+    /**
+     * Inject the script loader (tests / SSR-safe apps). Receives the gtag.js
+     * src URL; must resolve once the script has executed. Defaults to a DOM
+     * `<script>` injector (browser only).
+     */
+    scriptLoader?: (src: string) => Promise<void>;
+    /** Override the gtag.js base URL (testing). */
+    gtagSrcBase?: string;
+}
+/** `http` mode — GA4 Measurement Protocol. No browser library. */
+interface GA4HttpOptions extends GA4CommonOptions {
+    mode?: 'http';
+    /** GA4 Measurement Protocol API secret (server-side credential). */
+    apiSecret: string;
+    /** Override the `/mp/collect` base URL (testing / EU endpoint). */
+    endpoint?: string;
+    /** Use the Measurement Protocol `/debug/mp/collect` validation endpoint. */
+    debug?: boolean;
+    /** Injected fetch (defaults to global fetch). Never loads a vendor lib. */
+    fetchImpl?: typeof fetch;
+}
+/** Discriminated union of the two modes. */
+type GA4SinkOptions = GA4ClientSdkOptions | GA4HttpOptions;
+
+/**
+ * `createGA4Sink` — the single entry point. Dispatches on `mode`:
+ *   - `mode: 'client-sdk'` → lazy gtag.js adapter
+ *   - `mode: 'http'` (default) → Measurement Protocol adapter, no vendor lib
+ *
+ * Default is `http` to honour the epic's "default = protocol adapters (no
+ * vendor libs in the browser)" stance. GA4 is just a sink — register it via
+ * `createAnalytics({ sinks: [createGA4Sink(...)] })` or `analytics.addSink`.
+ *
+ * Both factories are independent modules. The `http` factory has ZERO
+ * references to gtag.js / DOM-script code, and the `client-sdk` factory only
+ * touches the vendor script lazily (first delivery). Selecting one mode never
+ * executes the other's load path; consumers that only ever construct an
+ * `http` sink never run any vendor code.
+ */
+
+declare function createGA4Sink(options: GA4SinkOptions): AnalyticsSink;
+
+/**
+ * GA4 `http` adapter — Measurement Protocol (`/mp/collect`).
+ *
+ * Server-relay friendly: this path NEVER loads gtag.js or any browser
+ * library. It only POSTs JSON to the Measurement Protocol endpoint:
+ *
+ *   POST {endpoint}/mp/collect?measurement_id={id}&api_secret={secret}
+ *   Content-Type: application/json
+ *   { client_id, user_id?, user_properties?, events: [{ name, params }] }
+ *
+ * GA4 Measurement Protocol constraints honoured here:
+ *   - up to 25 events per request → batches are chunked.
+ *   - `identify` envelopes carry no event; they still POST so user_id /
+ *     user_properties propagate (events array may be empty for a user-props
+ *     only ping, which GA4 accepts).
+ *   - 2xx (incl. 204) = accepted. The MP endpoint always returns 2xx for
+ *     well-formed requests; the `debug` endpoint returns validation messages.
+ */
+
+/**
+ * Create the GA4 Measurement-Protocol (`http`) sink.
+ *
+ * No vendor library is loaded on this path under any circumstance.
+ */
+declare function createGA4HttpSink(options: GA4HttpOptions): AnalyticsSink;
+
+/**
+ * GA4 `client-sdk` adapter — lazy gtag.js.
+ *
+ * The vendor library is NEVER a hard dependency and is NEVER bundled. On the
+ * first delivery the adapter:
+ *   1. installs the gtag stub + dataLayer,
+ *   2. pushes the Consent Mode default (if a bridge is configured),
+ *   3. lazily injects `https://www.googletagmanager.com/gtag/js?id=<id>`
+ *      via a `<script>` tag (or an injected loader for tests/SSR),
+ *   4. runs `gtag('js', Date)` + `gtag('config', <id>, { send_page_view:false })`.
+ *
+ * Subsequent deliveries map each canonical envelope through the shared mapper
+ * and call `gtag('set', 'user_properties', …)` / `gtag('set', { user_id })` /
+ * `gtag('event', name, params)`.
+ *
+ * Consent Mode bridge: `init` pushes `consent: default`; `deliver` is only
+ * reached when the router's consent gate already allows this sink, at which
+ * point `consent: update` is pushed for the mapped GA4 consent types.
+ */
+
+/**
+ * Create the GA4 gtag.js (`client-sdk`) sink. The vendor script is dynamically
+ * loaded on first delivery only — there is no static import of any GA4/gtag
+ * library, so `http`-mode consumers never pull this code path.
+ */
+declare function createGA4ClientSdkSink(options: GA4ClientSdkOptions): AnalyticsSink;
+
+/**
+ * Canonical envelope → GA4 mapping.
+ *
+ * One mapper, two consumers: the `client-sdk` adapter feeds the result into
+ * `gtag('event', name, params)` / `gtag('set', ...)`, and the `http` adapter
+ * serialises it into a Measurement Protocol `/mp/collect` payload. Keeping the
+ * mapping in one place guarantees the two modes stay behaviourally identical.
+ *
+ * Identity / param mapping (issue #216, epic #213):
+ *   anonymousId  → client_id           (GA4 device/browser id)
+ *   userId       → user_id             (GA4 User-ID, cross-device)
+ *   properties   → event params        (track/page/screen/group payload)
+ *   identify     → user_properties     (traits become GA4 user properties)
+ *   sessionId    → session_id param    (so GA4 sessionisation can align)
+ *
+ * GA4 event-name normalisation: GA4 recommends snake_case event names and
+ * forbids spaces. `page` → `page_view`, `screen` → `screen_view` (GA4
+ * Enhanced-Measurement parity); everything else is lower_snake_cased.
+ */
+
+/** A GA4 event ready for gtag.js or the Measurement Protocol. */
+interface GA4Event {
+    /** GA4 event name (snake_case, no spaces). */
+    name: string;
+    /** Event params (GA4 caps these; we pass them through verbatim). */
+    params: Record<string, unknown>;
+}
+/** The fully-mapped result for a single canonical envelope. */
+interface GA4Mapped {
+    /** GA4 client_id (from anonymousId). Always present. */
+    clientId: string;
+    /** GA4 user_id (from userId). Present only after identify. */
+    userId?: string;
+    /**
+     * GA4 user_properties (from identify/group traits). Each value is wrapped
+     * in `{ value }` as the Measurement Protocol requires; the gtag adapter
+     * unwraps when it calls `gtag('set', 'user_properties', ...)`.
+     */
+    userProperties?: Record<string, {
+        value: unknown;
+    }>;
+    /**
+     * The GA4 event to send. `identify` calls carry no event (they only set
+     * user_id / user_properties), so this is optional.
+     */
+    event?: GA4Event;
+}
+/** Lower_snake_case an arbitrary event/trait name for GA4. */
+declare function toGa4Name(name: string): string;
+/** Map a Segment call type + name to its GA4 event name. */
+declare function ga4EventName(ev: AnalyticsEvent): string | undefined;
+/**
+ * Map one canonical envelope to its GA4 representation. Pure — no transport,
+ * no vendor lib; both the gtag and Measurement-Protocol adapters consume this.
+ */
+declare function mapEvent(ev: AnalyticsEvent): GA4Mapped;
+
+export { type ConsentState, type GA4ClientSdkOptions, type GA4ConsentBridge, type GA4Event, type GA4HttpOptions, type GA4Mapped, type GA4SinkOptions, type GtagFn, createGA4ClientSdkSink, createGA4HttpSink, createGA4Sink, ga4EventName, mapEvent, toGa4Name };