@c15t/scripts 2.1.0 → 2.2.0-canary-20260804162155

package/docs/integrations/microsoft-clarity.md

@@ -0,0 +1,173 @@
+---
+title: Microsoft Clarity
+description: Session replay and behavior analytics with a prebuilt helper that
+  keeps Clarity consent synchronized with c15t measurement state.
+group: integrations
+icon: microsoft-clarity
+---
+Microsoft Clarity gives you session recordings, heatmaps, and behavioral insights. The `clarity()` helper sets up Clarity's queue stub, loads the vendor bundle, and keeps Clarity's consent state in sync as c15t measurement consent changes.
+
+## Integrate with c15t
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { clarity } from '@c15t/scripts/microsoft-clarity';
+
+const scripts = [
+  clarity({
+    id: 'abcdef1234',
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { clarity } from '@c15t/scripts/microsoft-clarity';
+
+const scripts = [
+  clarity({
+    id: 'abcdef1234',
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { clarity } from '@c15t/scripts/microsoft-clarity';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [
+    clarity({
+      id: 'abcdef1234',
+    }),
+  ],
+});
+```
+
+## How c15t loads it
+
+* **Category:** `measurement` (Analytics)
+* **Loads when:** measurement consent is granted
+* **On revocation:** stays loaded (`persistAfterConsentRevoked: true`) and receives `clarity('consent', false)` so Clarity transitions into denied mode without tearing down the script.
+
+## Configure the integration
+
+You can queue an initial Clarity consent value before the script loads.
+
+```ts
+import { clarity } from '@c15t/scripts/microsoft-clarity';
+
+clarity({
+  id: 'abcdef1234',
+  defaultConsent: false,
+});
+```
+
+Use an object when you need to map granular consent categories into Clarity's boot-time consent payload:
+
+```ts
+clarity({
+  id: 'abcdef1234',
+  defaultConsent: {
+    marketing: false,
+    analytics: true,
+  },
+});
+```
+
+c15t queues that exact `defaultConsent` object during boot. Later consent changes are mapped to simple `true` or `false` values when c15t updates Clarity.
+
+## Tracking events in your app
+
+c15t gates the Clarity script from loading until `measurement` consent is granted. Your application code that calls Clarity's runtime API (`window.clarity(...)`) is **not** automatically gated - `window.clarity` does not exist until the script is loaded, so unguarded calls before consent throw.
+
+Guard event calls by checking consent state. From React:
+
+```tsx
+import { useCallback } from 'react';
+import { useConsentManager } from '@c15t/react';
+
+function SignupExample() {
+  const { has } = useConsentManager();
+
+  const trackSignup = useCallback(() => {
+    if (has('measurement')) {
+      window.clarity?.('event', 'signup');
+    }
+  }, [has]);
+
+  // Call trackSignup() from an event handler after signup succeeds.
+}
+```
+
+From plain JavaScript:
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+
+const { consentStore } = getOrCreateConsentRuntime();
+
+if (consentStore.getState().has('measurement')) {
+  window.clarity?.('event', 'signup');
+}
+```
+
+## Types
+
+### ClarityOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`ClarityOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/analytics/microsoft-clarity.ts\`|
+
+\*ExtractedTypeTable: Could not extract "ClarityOptions" from "./packages/scripts/src/vendors/analytics/microsoft-clarity.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*

package/docs/integrations/microsoft-uet.md

@@ -0,0 +1,156 @@
+---
+title: Microsoft UET
+description: Track conversions and measure performance for Microsoft Advertising
+  and Bing Ads.
+icon: microsoft
+group: integrations
+---
+Microsoft UET (Universal Event Tracking) is Microsoft's conversion tracking tag
+for Microsoft Advertising. It tracks user actions, measures campaign
+effectiveness, and enables remarketing campaigns.
+
+## Official Microsoft documentation
+
+* [Universal Event Tracking](https://learn.microsoft.com/en-us/advertising/guides/universal-event-tracking?view=bingads-13)
+* [UET tag data object](https://learn.microsoft.com/en-us/advertising/campaign-management-service/uettag?view=bingads-13)
+* [FAQ: Universal Event Tracking](https://help.ads.microsoft.com/#apex/3/en/53056/2)
+* [FAQ: Remarketing](https://help.ads.microsoft.com/#apex/3/en/56727/1)
+
+> 📝 **Note:**
+> UET can also load Microsoft Clarity (if enabled in your UET tag settings). Since Clarity is an analytics tool, we recommend loading it separately with measurement consent instead.
+
+## Integrate with c15t
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { microsoftUet } from '@c15t/scripts/microsoft-uet';
+
+const scripts = [microsoftUet({ id: '123456789012345' })];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { microsoftUet } from '@c15t/scripts/microsoft-uet';
+
+const scripts = [microsoftUet({ id: '123456789012345' })];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { microsoftUet } from '@c15t/scripts/microsoft-uet';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [microsoftUet({ id: '123456789012345' })],
+});
+```
+
+## How c15t loads it
+
+* **Category:** `marketing` (Ads & Pixels)
+* **Loads when:** immediately, with Microsoft consent mode enabled
+* **Default consent:** c15t pushes `ad_storage: 'denied'` before loading UET unless marketing consent is already granted
+* **On grant/revocation:** c15t pushes the new consent state to `uetq` so UET can switch between granted and denied mode without removing the script
+
+Use the UET tag ID as `id`. Microsoft recommends creating one UET tag and
+adding it across your site; that tag can then support conversion goals and
+remarketing lists.
+
+## Tracking events in your app
+
+c15t loads Microsoft UET in consent mode, so `window.uetq` is created before
+consent is granted. Your own event calls are **not** automatically gated. Guard
+them if you only want to send custom conversion events after marketing consent
+is granted.
+
+Microsoft's custom event syntax uses
+`window.uetq.push('event', action, parameters)`. Conversion goals can match page
+visits and custom events, and event payloads can include revenue fields such as
+`revenue_value` and `currency`.
+
+```tsx
+import { useCallback } from 'react';
+import { useConsentManager } from '@c15t/react';
+
+function useTrackPurchase() {
+  const { has } = useConsentManager();
+
+  return useCallback(() => {
+    if (has('marketing')) {
+      window.uetq?.push('event', 'purchase', {
+        revenue_value: 10,
+        currency: 'USD',
+      });
+    }
+  }, [has]);
+}
+
+function CheckoutButton() {
+  const trackPurchase = useTrackPurchase();
+
+  return (
+    <button type="button" onClick={trackPurchase}>
+      Complete purchase
+    </button>
+  );
+}
+```
+
+## Types
+
+### MicrosoftUetOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`MicrosoftUetOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/ads-and-pixels/microsoft-uet.ts\`|
+
+\*ExtractedTypeTable: Could not extract "MicrosoftUetOptions" from "./packages/scripts/src/vendors/ads-and-pixels/microsoft-uet.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*

package/docs/integrations/mixpanel-analytics.md

@@ -0,0 +1,130 @@
+---
+title: Mixpanel Analytics
+description: Load Mixpanel with c15t and let Mixpanel's own opt-in and opt-out
+  APIs follow measurement consent.
+group: integrations
+icon: mixpanel
+---
+Mixpanel helps you track product usage, funnels, and retention. The `mixpanelAnalytics()` helper always loads the Mixpanel library, initializes it after the bundle is ready, and uses Mixpanel's own `opt_in_tracking()` and `opt_out_tracking()` methods to keep tracking aligned with `measurement` consent.
+
+## Integrate with c15t
+
+**React**
+
+```tsx
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/react';
+import { mixpanelAnalytics } from '@c15t/scripts/mixpanel-analytics';
+
+const scripts = [
+  mixpanelAnalytics({
+    token: '1234567890abcdef1234567890abcdef',
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: 'https://your-instance.c15t.dev',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**Next.js**
+
+```tsx
+'use client';
+
+import { type ReactNode } from 'react';
+import { ConsentManagerProvider } from '@c15t/nextjs';
+import { mixpanelAnalytics } from '@c15t/scripts/mixpanel-analytics';
+
+const scripts = [
+  mixpanelAnalytics({
+    token: '1234567890abcdef1234567890abcdef',
+  }),
+];
+
+export function ConsentProvider({ children }: { children: ReactNode }) {
+  return (
+    <ConsentManagerProvider
+      options={{
+        mode: 'hosted',
+        backendURL: '/api/c15t',
+        scripts,
+      }}
+    >
+      {children}
+    </ConsentManagerProvider>
+  );
+}
+```
+
+**JavaScript**
+
+```ts
+import { getOrCreateConsentRuntime } from 'c15t';
+import { mixpanelAnalytics } from '@c15t/scripts/mixpanel-analytics';
+
+getOrCreateConsentRuntime({
+  mode: 'hosted',
+  backendURL: 'https://your-instance.c15t.dev',
+  scripts: [
+    mixpanelAnalytics({
+      token: '1234567890abcdef1234567890abcdef',
+    }),
+  ],
+});
+```
+
+## How c15t loads it
+
+* **Category:** `measurement` (Analytics)
+* **Loads when:** immediately (`alwaysLoad: true`)
+* **Consent behavior:** c15t keeps the SDK loaded and toggles tracking by calling Mixpanel's opt-in and opt-out APIs when consent changes.
+
+## Configure the integration
+
+You can pass serializable init options through to `mixpanel.init(...)`.
+
+```ts
+import { mixpanelAnalytics } from '@c15t/scripts/mixpanel-analytics';
+
+mixpanelAnalytics({
+  token: '1234567890abcdef1234567890abcdef',
+  initOptions: {
+    debug: true,
+  },
+});
+```
+
+## Tracking events in your app
+
+Because Mixpanel is configured with `alwaysLoad: true`, `window.mixpanel` is available as soon as the script loads, even before `measurement` consent is granted. You can still call `window.mixpanel.track(...)` from app code; consent suppression is handled by Mixpanel's opt-in/opt-out methods that c15t triggers on consent updates.
+
+## Types
+
+### MixpanelAnalyticsOptions
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`MixpanelAnalyticsOptions\`|
+|Source Path|\`./packages/scripts/src/vendors/analytics/mixpanel-analytics.ts\`|
+
+\*ExtractedTypeTable: Could not extract "MixpanelAnalyticsOptions" from "./packages/scripts/src/vendors/analytics/mixpanel-analytics.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*
+
+### Script
+
+|Property|Value|
+|:--|:--|
+|Type Name|\`Script\`|
+|Source Path|\`./packages/core/src/libs/script-loader/types.ts\`|
+
+\*ExtractedTypeTable: Could not extract "Script" from "./packages/core/src/libs/script-loader/types.ts" using base path "/home/runner/work/c15t/c15t". Verify the path/name and that the file is included by your tsconfig.\*

package/docs/integrations/overview.md

@@ -0,0 +1,149 @@
+---
+title: Integrations
+description: Load analytics, pixels, tag managers, and widgets through c15t so
+  consent state controls when they run, update, and appear in your consent UI.
+group: integrations
+---
+Third-party tools are easy to paste into app code, but consent makes them part
+of your privacy runtime. Analytics SDKs, ad pixels, tag managers, and chat
+widgets can load remote code, store identifiers, send events, and keep running
+after the first page view.
+
+> ℹ️ **Info:**
+> Put consent-sensitive vendor tools in c15t instead of scattering script tags across your codebase. c15t becomes the place that decides when they can load, when they must stop, and which consent categories your UI needs to show.
+
+## Why Manage Tools In c15t
+
+When you install a vendor directly in your app, your consent logic has to chase
+that vendor everywhere it appears: page layouts, route handlers, event helpers,
+tag-manager snippets, and cleanup code.
+
+Register the vendor with c15t instead. The integration becomes a declarative
+`Script` that the consent runtime can reason about:
+
+* c15t registers the tool with the runtime and evaluates it against the current
+  consent state;
+* c15t automatically adds the tool's consent category to the active categories,
+  so GDPR-style consent UIs include `measurement`, `marketing`, or
+  `functionality` when an enabled integration needs them;
+* c15t blocks the script until consent is granted, or loads it with denied
+  defaults when the vendor has its own consent mode;
+* c15t handles revocation by unloading the script or calling the vendor's
+  consent API;
+* c15t runs vendor setup in the right order, including queue stubs, global
+  functions, data attributes, default page-view events, and consent updates.
+
+That gives your app one consent lifecycle instead of many scattered vendor
+lifecycles.
+
+## Built-In Helpers
+
+c15t ships prebuilt script helpers in
+[`@c15t/scripts`](https://www.npmjs.com/package/@c15t/scripts) for the
+third-party tools developers integrate most often. Prefer them over copied
+vendor snippets whenever c15t already supports the vendor.
+
+Every helper returns a regular `Script` object, so it works anywhere the c15t
+[script loader](/docs/frameworks/javascript/script-loader) accepts scripts. You
+usually choose the helper, provide the vendor ID, and pass the result to your
+provider's `scripts` option. The vendor page explains anything else that still
+matters, such as custom events, region settings, privacy modes, or ecommerce
+payloads.
+
+## Choose An Integration Style
+
+Most apps mix more than one style. Pick the smallest one that keeps consent behavior obvious.
+
+|Style|Use when|
+|--|--|
+|**Built-in helper** from `@c15t/scripts`|The vendor is listed below — start here.|
+|**Plain `Script`**|One-off app code with simple load and callback behavior.|
+|**Manifest-backed helper**|Reusable vendor integration with structured setup phases, queues, stubs, or a vendor consent API.|
+|**Iframe / renderable integration**|Vendor exposes an iframe or React component, not just a script tag.|
+
+Setup is the same shape in every framework: import the helper, call it with vendor options, and pass the result to the consent runtime through your provider's `scripts` option. See the framework guides for end-to-end snippets — [JavaScript](/docs/frameworks/javascript/script-loader), [React](/docs/frameworks/react/script-loader), [Next.js](/docs/frameworks/next/script-loader).
+
+## Renderable Integrations
+
+Maps and video embeds need a visible component as well as consent-aware loading.
+The React and Next.js packages include components that own the placeholder,
+vendor loading, and rendered surface. They are imported from the framework
+package rather than `@c15t/scripts`.
+
+* [Google Maps](/docs/integrations/google-maps)
+* [YouTube](/docs/integrations/youtube)
+
+## Analytics
+
+Analytics integrations usually require `measurement` consent. Some vendors can run in a consent-aware or cookieless mode; others should stay fully blocked until measurement consent is granted.
+
+* [Google Tag (gtag.js)](/docs/integrations/google-tag)
+* [Ahrefs Analytics](/docs/integrations/ahrefs-analytics)
+* [Adobe Analytics](/docs/integrations/adobe-analytics)
+* [Amplitude](/docs/integrations/amplitude)
+* [Cloudflare Web Analytics](/docs/integrations/cloudflare-web-analytics)
+* [Clearbit](/docs/integrations/clearbit)
+* [Microsoft Clarity](/docs/integrations/microsoft-clarity)
+* [Databuddy](/docs/integrations/databuddy)
+* [Rybbit Analytics](/docs/integrations/rybbit-analytics)
+* [Fathom Analytics](/docs/integrations/fathom-analytics)
+* [Heap](/docs/integrations/heap)
+* [Mixpanel Analytics](/docs/integrations/mixpanel-analytics)
+* [Hotjar](/docs/integrations/hotjar)
+* [Hightouch](/docs/integrations/hightouch)
+* [LogRocket](/docs/integrations/logrocket)
+* [Matomo Analytics](/docs/integrations/matomo-analytics)
+* [PostHog](/docs/integrations/posthog)
+* [Promptwatch](/docs/integrations/promptwatch)
+* [Pirsch](/docs/integrations/pirsch)
+* [RudderStack](/docs/integrations/rudderstack)
+* [Segment](/docs/integrations/segment)
+* [Plausible Analytics](/docs/integrations/plausible-analytics)
+* [Umami Analytics](/docs/integrations/umami-analytics)
+* [Vercel Analytics](/docs/integrations/vercel-analytics)
+
+## Functional
+
+Functional integrations usually require `functionality` consent. They add optional user-facing capabilities, such as chat widgets, that should only run after the user allows them.
+
+* [Crisp](/docs/integrations/crisp)
+* [Intercom](/docs/integrations/intercom)
+
+## Ads & Pixels
+
+Advertising pixels usually require `marketing` consent. Many of them need startup stubs so events can be queued safely before the remote SDK loads — built-in helpers handle this for you.
+
+* [Meta Pixel](/docs/integrations/meta-pixel)
+* [Snapchat Pixel](/docs/integrations/snapchat-pixel)
+* [Reddit Pixel](/docs/integrations/reddit-pixel)
+* [TikTok Pixel](/docs/integrations/tiktok-pixel)
+* [LinkedIn Insight Tag](/docs/integrations/linkedin-insights)
+* [Microsoft UET](/docs/integrations/microsoft-uet)
+* [X (Twitter) Pixel](/docs/integrations/x-pixel)
+
+## Tag Managers
+
+Tag managers can load other scripts, so they deserve extra care. Prefer vendor consent modes and denied defaults before any tags are allowed to run.
+
+* [Google Tag Manager](/docs/integrations/google-tag-manager)
+
+## Build Your Own
+
+If c15t does not ship the vendor you need, drop down a level:
+
+* build a one-off `Script` directly in your app for simple cases,
+* build a reusable manifest-backed helper for shared or package-level integrations,
+* or combine the script loader with iframe gating for visible media and widget integrations.
+
+### Build a Custom Integration
+
+Learn when to use a raw `Script`, when to use a manifest, and how to debug and test custom integrations.
+
+[Read the guide →](/docs/integrations/building-integrations)
+
+## Where To Next
+
+* Read the script loader guide for your framework: [JavaScript](/docs/frameworks/javascript/script-loader), [React](/docs/frameworks/react/script-loader), [Next.js](/docs/frameworks/next/script-loader).
+* Use the [Google Maps](/docs/integrations/google-maps) and [YouTube](/docs/integrations/youtube) components for built-in renderable integrations.
+* See the [iframe blocking](/docs/frameworks/react/iframe-blocking) pattern for other visible embeds such as calendars and social widgets.
+* Use [`has()`](/docs/frameworks/javascript/api/checking-consent) to conditionally run app code based on consent state.