π Open source, privacy-first web analytics β a cookie-less Google Analytics alternative with built-in error tracking and performance monitoring. Self-host it or use our cloud. Get started for free!
TypeScript chartsclickhousedockergdprgoogle-analyticsmetricsmonitoringmysqlnestjsprivacyredisself-hostedselfhostedstatisticstailwindcssweb-analyticswebanalyticswebsite
React integrations
Blue Mouse669ab4371e4e
diff --git a/docs/docs/integrations/nextjs.md b/docs/docs/integrations/nextjs.mdnew file mode 100644index 000000000..a85460072--- /dev/null+++ b/docs/docs/integrations/nextjs.md@@ -0,0 +1,338 @@+---+title: Next.js+slug: /nextjs-integration+---++Integrate Swetrix with your [Next.js](https://nextjs.org/) application to track page views, monitor errors, and capture custom events β all while staying privacy-friendly and GDPR-compliant.++This guide covers both the **App Router** (Next.js 13+) and the **Pages Router**.++## Installation++The recommended approach for Next.js is to install Swetrix as an npm package, which gives you full TypeScript support and works seamlessly with server-side rendering.++```bash+npm install swetrix+```++### App Router (recommended)++Create a client component that initialises Swetrix and tracks page views across route changes.++**1. Create the analytics component**++Create a new file at `src/components/Analytics.tsx` (or `src/components/Analytics.jsx` if you're not using TypeScript):++```tsx+'use client'++import { useEffect } from 'react'+import { usePathname, useSearchParams } from 'next/navigation'+import * as Swetrix from 'swetrix'++export default function Analytics() {+ const pathname = usePathname()+ const searchParams = useSearchParams()++ useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ }, [])++ useEffect(() => {+ Swetrix.trackViews()+ }, [pathname, searchParams])++ return null+}+```++**2. Add it to your root layout**++Open `src/app/layout.tsx` and render the `Analytics` component. Wrap it in `<Suspense>` because `useSearchParams()` requires it:++```tsx+import { Suspense } from 'react'+import Analytics from '@/components/Analytics'++export default function RootLayout({+ children,+}: {+ children: React.ReactNode+}) {+ return (+ <html lang="en">+ <body>+ {children}+ <Suspense fallback={null}>+ <Analytics />+ </Suspense>+ </body>+ </html>+ )+}+```++:::caution+Replace `YOUR_PROJECT_ID` with your actual Project ID from the [Swetrix dashboard](https://swetrix.com/projects), otherwise tracking won't work.+:::++### Pages Router++If you're using the Pages Router, add Swetrix to your `_app.tsx` (or `_app.jsx`) file and listen for route changes via Next.js's router events.++```tsx+import { useEffect } from 'react'+import { useRouter } from 'next/router'+import type { AppProps } from 'next/app'+import * as Swetrix from 'swetrix'++export default function App({ Component, pageProps }: AppProps) {+ const router = useRouter()++ useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()++ const handleRouteChange = () => {+ Swetrix.trackViews()+ }++ router.events.on('routeChangeComplete', handleRouteChange)++ return () => {+ router.events.off('routeChangeComplete', handleRouteChange)+ }+ }, [router.events])++ return <Component {...pageProps} />+}+```++### Noscript fallback (optional)++To track visitors who have JavaScript disabled, add a noscript image pixel to your root layout (App Router) or `_document.tsx` (Pages Router).++**App Router** β add to `src/app/layout.tsx` inside `<body>`:++```tsx+<noscript>+ <img+ src="https://api.swetrix.com/log/noscript?pid=YOUR_PROJECT_ID"+ alt=""+ referrerPolicy="no-referrer-when-downgrade"+ />+</noscript>+```++**Pages Router** β add to `pages/_document.tsx` inside `<body>`:++```tsx+import { Html, Head, Main, NextScript } from 'next/document'++export default function Document() {+ return (+ <Html>+ <Head />+ <body>+ <Main />+ <NextScript />+ <noscript>+ <img+ src="https://api.swetrix.com/log/noscript?pid=YOUR_PROJECT_ID"+ alt=""+ referrerPolicy="no-referrer-when-downgrade"+ />+ </noscript>+ </body>+ </Html>+ )+}+```++## Disable tracking in development++By default, Swetrix ignores `localhost` traffic. If you want to be explicit about it, you can conditionally disable tracking based on your environment:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ disabled: process.env.NODE_ENV === 'development',+})+```++:::tip+If you want to verify tracking locally during development, set `devMode: true` instead:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ devMode: true,+})+```++Remember to remove this before deploying to production.+:::++## Check your installation++Deploy your application (or temporarily enable `devMode`) and visit a few pages. Within a minute you should see new pageviews appearing in your Swetrix dashboard.++## Error tracking++Enable automatic client-side error monitoring by adding `trackErrors()` to your analytics component. This captures unhandled JavaScript errors and reports them to Swetrix.++**App Router** β update `src/components/Analytics.tsx`:++```tsx+useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ Swetrix.trackErrors()+}, [])+```++**Pages Router** β update `_app.tsx`:++```tsx+useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ Swetrix.trackErrors()++ // ...router event handlers+}, [router.events])+```++Errors will appear in the **Errors** tab of your project dashboard. See the [tracking script reference](/swetrix-js-reference#trackerrors) for options like `sampleRate` and `callback`.++## Tracking custom events++Custom events let you track specific user interactions β button clicks, form submissions, sign-ups, purchases, and more. Import `swetrix` in any client component and call `track()`.++### Example: tracking button clicks++```tsx+'use client'++import * as Swetrix from 'swetrix'++export default function PricingCTA() {+ const handleClick = () => {+ Swetrix.track({+ ev: 'PRICING_CTA_CLICK',+ meta: {+ plan: 'pro',+ location: 'hero',+ },+ })+ }++ return (+ <button onClick={handleClick}>+ Upgrade to Pro+ </button>+ )+}+```++### Example: tracking form submissions++```tsx+'use client'++import * as Swetrix from 'swetrix'++export default function NewsletterForm() {+ const handleSubmit = (e: React.FormEvent) => {+ e.preventDefault()++ Swetrix.track({+ ev: 'NEWSLETTER_SIGNUP',+ meta: {+ source: 'footer',+ },+ })++ // ...submit logic+ }++ return (+ <form onSubmit={handleSubmit}>+ <input type="email" placeholder="[email protected]" required />+ <button type="submit">Subscribe</button>+ </form>+ )+}+```++### Example: tracking outbound links++Create a reusable component for external links:++```tsx+'use client'++import * as Swetrix from 'swetrix'++interface TrackedLinkProps {+ href: string+ children: React.ReactNode+ eventName?: string+}++export default function TrackedLink({+ href,+ children,+ eventName = 'OUTBOUND_CLICK',+}: TrackedLinkProps) {+ const handleClick = () => {+ Swetrix.track({+ ev: eventName,+ meta: { url: href },+ })+ }++ return (+ <a href={href} target="_blank" rel="noopener noreferrer" onClick={handleClick}>+ {children}+ </a>+ )+}+```++### Event naming rules++Event names must:++- Contain only English letters (a-Z), numbers (0-9), underscores (`_`), and dots (`.`)+- Be fewer than 64 characters+- Start with an English letter++We recommend `UPPER_SNAKE_CASE` for consistency (e.g. `PRICING_CTA_CLICK`, `NEWSLETTER_SIGNUP`).++## Using environment variables for your Project ID++Rather than hardcoding your Project ID, you can use a Next.js environment variable. Since the analytics component runs on the client, the variable must be prefixed with `NEXT_PUBLIC_`.++**1. Add to your `.env.local` file:**++```+NEXT_PUBLIC_SWETRIX_PID=YOUR_PROJECT_ID+```++**2. Reference it in your analytics component:**++```tsx+Swetrix.init(process.env.NEXT_PUBLIC_SWETRIX_PID!)+```++## Bypassing adblockers with a proxy++Some adblockers may block requests to the Swetrix API domain. You can proxy analytics traffic through your own domain using Next.js rewrites. This keeps all requests first-party, making them invisible to adblockers.++See the full setup guide: [How to proxy Swetrix with Next.js](/adblockers/guides/nextjs).++## Further reading++- [Tracking script reference](/swetrix-js-reference) β full API documentation for `init()`, `track()`, `trackViews()`, `trackErrors()`, and more.+- [Swetrix npm package](https://www.npmjs.com/package/swetrix) β package details and changelog.+- [How to proxy Swetrix with Next.js](/adblockers/guides/nextjs) β avoid adblockers by proxying analytics through your domain.diff --git a/docs/docs/integrations/react.md b/docs/docs/integrations/react.mdnew file mode 100644index 000000000..28941ee28--- /dev/null+++ b/docs/docs/integrations/react.md@@ -0,0 +1,281 @@+---+title: React (Vite / CRA)+slug: /react-integration+---++Integrate Swetrix with your [React](https://react.dev/) application to track page views, monitor errors, and capture custom events β all while staying privacy-friendly and GDPR-compliant.++This guide covers React apps built with **Vite**, **Create React App**, or any other bundler. If you're using a React framework, see the dedicated guides for [Next.js](/nextjs-integration) and [Remix](/remix-integration) instead.++## Installation++Install the Swetrix npm package:++```bash+npm install swetrix+```++### Basic setup (single-page apps without routing)++If your app doesn't use client-side routing, you can initialise Swetrix once in your entry point.++Open `src/main.tsx` (Vite) or `src/index.tsx` (CRA):++```tsx+import React from 'react'+import ReactDOM from 'react-dom/client'+import * as Swetrix from 'swetrix'+import App from './App'++Swetrix.init('YOUR_PROJECT_ID')+Swetrix.trackViews()++ReactDOM.createRoot(document.getElementById('root')!).render(+ <React.StrictMode>+ <App />+ </React.StrictMode>,+)+```++:::caution+Replace `YOUR_PROJECT_ID` with your actual Project ID from the [Swetrix dashboard](https://swetrix.com/projects), otherwise tracking won't work.+:::++### With React Router++Most React SPAs use [React Router](https://reactrouter.com/) for client-side navigation. Since page transitions don't trigger full page loads, you need to call `trackViews()` on every route change.++**1. Create an analytics component**++Create `src/components/Analytics.tsx`:++```tsx+import { useEffect } from 'react'+import { useLocation } from 'react-router-dom'+import * as Swetrix from 'swetrix'++export default function Analytics() {+ const location = useLocation()++ useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ }, [])++ useEffect(() => {+ Swetrix.trackViews()+ }, [location])++ return null+}+```++**2. Add it inside your Router**++The `Analytics` component must be rendered inside the `<BrowserRouter>` (or whichever router you use) so that `useLocation()` has access to the routing context:++```tsx+import { BrowserRouter, Routes, Route } from 'react-router-dom'+import Analytics from './components/Analytics'+import Home from './pages/Home'+import About from './pages/About'++export default function App() {+ return (+ <BrowserRouter>+ <Analytics />+ <Routes>+ <Route path="/" element={<Home />} />+ <Route path="/about" element={<About />} />+ </Routes>+ </BrowserRouter>+ )+}+```++### Noscript fallback (optional)++To track visitors who have JavaScript disabled, add a noscript image pixel to your `index.html`:++```html+<body>+ <div id="root"></div>++ <noscript>+ <img+ src="https://api.swetrix.com/log/noscript?pid=YOUR_PROJECT_ID"+ alt=""+ referrerpolicy="no-referrer-when-downgrade"+ />+ </noscript>+</body>+```++## Disable tracking in development++By default, Swetrix ignores `localhost` traffic. You can also explicitly disable it based on your environment:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ disabled: import.meta.env.DEV, // Vite+ // disabled: process.env.NODE_ENV === 'development', // CRA+})+```++:::tip+If you want to verify tracking locally during development, set `devMode: true` instead:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ devMode: true,+})+```++Remember to remove this before deploying to production.+:::++## Check your installation++Build and deploy your application (or temporarily enable `devMode`) and visit a few pages. Within a minute you should see new pageviews appearing in your Swetrix dashboard.++## Error tracking++Enable automatic client-side error monitoring by adding `trackErrors()` to your initialisation. This captures unhandled JavaScript errors and reports them to Swetrix.++Update your analytics setup:++```tsx+useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ Swetrix.trackErrors()+}, [])+```++Errors will appear in the **Errors** tab of your project dashboard. See the [tracking script reference](/swetrix-js-reference#trackerrors) for options like `sampleRate` and `callback`.++## Tracking custom events++Custom events let you track specific user interactions β button clicks, form submissions, sign-ups, purchases, and more. Import `swetrix` in any component and call `track()`.++### Example: tracking button clicks++```tsx+import * as Swetrix from 'swetrix'++export default function SignUpButton() {+ const handleClick = () => {+ Swetrix.track({+ ev: 'SIGNUP_CTA_CLICK',+ meta: {+ location: 'navbar',+ },+ })+ }++ return <button onClick={handleClick}>Sign up</button>+}+```++### Example: tracking form submissions++```tsx+import * as Swetrix from 'swetrix'++export default function ContactForm() {+ const handleSubmit = (e: React.FormEvent) => {+ e.preventDefault()++ Swetrix.track({+ ev: 'CONTACT_FORM_SUBMITTED',+ meta: {+ source: 'support_page',+ },+ })++ // ...submit logic+ }++ return (+ <form onSubmit={handleSubmit}>+ <input type="email" placeholder="[email protected]" required />+ <textarea placeholder="How can we help?" required />+ <button type="submit">Send</button>+ </form>+ )+}+```++### Example: tracking outbound links++Create a reusable component for external links:++```tsx+import * as Swetrix from 'swetrix'++interface TrackedLinkProps {+ href: string+ children: React.ReactNode+ eventName?: string+}++export default function TrackedLink({+ href,+ children,+ eventName = 'OUTBOUND_CLICK',+}: TrackedLinkProps) {+ const handleClick = () => {+ Swetrix.track({+ ev: eventName,+ meta: { url: href },+ })+ }++ return (+ <a href={href} target="_blank" rel="noopener noreferrer" onClick={handleClick}>+ {children}+ </a>+ )+}+```++### Event naming rules++Event names must:++- Contain only English letters (a-Z), numbers (0-9), underscores (`_`), and dots (`.`)+- Be fewer than 64 characters+- Start with an English letter++We recommend `UPPER_SNAKE_CASE` for consistency (e.g. `SIGNUP_CTA_CLICK`, `CONTACT_FORM_SUBMITTED`).++## Using environment variables for your Project ID++Rather than hardcoding your Project ID, you can use an environment variable.++**Vite** β prefix with `VITE_`:++```+VITE_SWETRIX_PID=YOUR_PROJECT_ID+```++```tsx+Swetrix.init(import.meta.env.VITE_SWETRIX_PID)+```++**Create React App** β prefix with `REACT_APP_`:++```+REACT_APP_SWETRIX_PID=YOUR_PROJECT_ID+```++```tsx+Swetrix.init(process.env.REACT_APP_SWETRIX_PID!)+```++## Further reading++- [Next.js integration](/nextjs-integration) β if you're using Next.js, follow the dedicated guide instead.+- [Remix integration](/remix-integration) β if you're using Remix, follow the dedicated guide instead.+- [Tracking script reference](/swetrix-js-reference) β full API documentation for `init()`, `track()`, `trackViews()`, `trackErrors()`, and more.+- [Swetrix npm package](https://www.npmjs.com/package/swetrix) β package details and changelog.diff --git a/docs/docs/integrations/remix.md b/docs/docs/integrations/remix.mdnew file mode 100644index 000000000..4c6804c7b--- /dev/null+++ b/docs/docs/integrations/remix.md@@ -0,0 +1,335 @@+---+title: Remix+slug: /remix-integration+---++Integrate Swetrix with your [Remix](https://remix.run/) application to track page views, monitor errors, and capture custom events β all while staying privacy-friendly and GDPR-compliant.++## Installation++Install the Swetrix npm package:++```bash+npm install swetrix+```++### Set up the analytics component++Since Swetrix runs in the browser, you need a client-only component that initialises tracking and responds to route changes. Remix uses React Router under the hood, so you can use `useLocation()` to detect navigations.++**1. Create the analytics component**++Create `app/components/Analytics.tsx`:++```tsx+import { useEffect } from 'react'+import { useLocation } from '@remix-run/react'+import * as Swetrix from 'swetrix'++export default function Analytics() {+ const location = useLocation()++ useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ }, [])++ useEffect(() => {+ Swetrix.trackViews()+ }, [location])++ return null+}+```++**2. Add it to your root route**++Open `app/root.tsx` and render the `Analytics` component inside the `<body>`. Use Remix's `ClientOnly` approach β since Swetrix must run in the browser, wrap the import so it only loads client-side:++```tsx+import {+ Links,+ Meta,+ Outlet,+ Scripts,+ ScrollRestoration,+} from '@remix-run/react'+import Analytics from '~/components/Analytics'++export default function App() {+ return (+ <html lang="en">+ <head>+ <meta charSet="utf-8" />+ <meta name="viewport" content="width=device-width, initial-scale=1" />+ <Meta />+ <Links />+ </head>+ <body>+ <Outlet />+ <ScrollRestoration />+ <Scripts />+ <Analytics />+ </body>+ </html>+ )+}+```++Swetrix guards against server-side execution internally, so the component is safe to render in the root route without extra checks.++:::caution+Replace `YOUR_PROJECT_ID` with your actual Project ID from the [Swetrix dashboard](https://swetrix.com/projects), otherwise tracking won't work.+:::++### Noscript fallback (optional)++To track visitors who have JavaScript disabled, add a noscript image pixel to your `app/root.tsx` inside `<body>`:++```tsx+<noscript>+ <img+ src="https://api.swetrix.com/log/noscript?pid=YOUR_PROJECT_ID"+ alt=""+ referrerPolicy="no-referrer-when-downgrade"+ />+</noscript>+```++## Disable tracking in development++By default, Swetrix ignores `localhost` traffic. You can also explicitly disable it in development:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ disabled: process.env.NODE_ENV === 'development',+})+```++:::tip+If you want to verify tracking locally during development, set `devMode: true` instead:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ devMode: true,+})+```++Remember to remove this before deploying to production.+:::++## Check your installation++Deploy your application (or temporarily enable `devMode`) and visit a few pages. Within a minute you should see new pageviews appearing in your Swetrix dashboard.++## Error tracking++Enable automatic client-side error monitoring by adding `trackErrors()` to your analytics component. This captures unhandled JavaScript errors and reports them to Swetrix.++Update `app/components/Analytics.tsx`:++```tsx+useEffect(() => {+ Swetrix.init('YOUR_PROJECT_ID')+ Swetrix.trackViews()+ Swetrix.trackErrors()+}, [])+```++Errors will appear in the **Errors** tab of your project dashboard. See the [tracking script reference](/swetrix-js-reference#trackerrors) for options like `sampleRate` and `callback`.++## Tracking custom events++Custom events let you track specific user interactions β button clicks, form submissions, sign-ups, and more. Import `swetrix` in any component and call `track()`.++### Example: tracking button clicks++```tsx+import * as Swetrix from 'swetrix'++export default function UpgradeButton() {+ const handleClick = () => {+ Swetrix.track({+ ev: 'UPGRADE_CTA_CLICK',+ meta: {+ plan: 'pro',+ location: 'pricing',+ },+ })+ }++ return <button onClick={handleClick}>Upgrade to Pro</button>+}+```++### Example: tracking Remix form actions++Remix encourages server-side form handling via `action` functions. You can track submissions on the client before the form posts:++```tsx+import { Form } from '@remix-run/react'+import * as Swetrix from 'swetrix'++export default function WaitlistForm() {+ const handleSubmit = () => {+ Swetrix.track({+ ev: 'WAITLIST_SIGNUP',+ meta: {+ source: 'landing_page',+ },+ })+ }++ return (+ <Form method="post" onSubmit={handleSubmit}>+ <input type="email" name="email" placeholder="[email protected]" required />+ <button type="submit">Join waitlist</button>+ </Form>+ )+}+```++### Example: tracking outbound links++```tsx+import * as Swetrix from 'swetrix'++interface TrackedLinkProps {+ href: string+ children: React.ReactNode+ eventName?: string+}++export default function TrackedLink({+ href,+ children,+ eventName = 'OUTBOUND_CLICK',+}: TrackedLinkProps) {+ const handleClick = () => {+ Swetrix.track({+ ev: eventName,+ meta: { url: href },+ })+ }++ return (+ <a href={href} target="_blank" rel="noopener noreferrer" onClick={handleClick}>+ {children}+ </a>+ )+}+```++### Event naming rules++Event names must:++- Contain only English letters (a-Z), numbers (0-9), underscores (`_`), and dots (`.`)+- Be fewer than 64 characters+- Start with an English letter++We recommend `UPPER_SNAKE_CASE` for consistency (e.g. `UPGRADE_CTA_CLICK`, `WAITLIST_SIGNUP`).++## Using environment variables for your Project ID++Rather than hardcoding your Project ID, you can use an environment variable. In Remix, client-side environment variables need to be explicitly passed from the server.++**1. Set the variable in your `.env` file:**++```+SWETRIX_PID=YOUR_PROJECT_ID+```++**2. Expose it to the client via your root loader:**++```tsx+// app/root.tsx+import { json } from '@remix-run/node'+import type { LoaderFunctionArgs } from '@remix-run/node'++export async function loader({ request }: LoaderFunctionArgs) {+ return json({+ ENV: {+ SWETRIX_PID: process.env.SWETRIX_PID,+ },+ })+}+```++**3. Make it available on `window` and pass it to the analytics component:**++In your root component, render the environment variables as a script tag:++```tsx+import { useLoaderData } from '@remix-run/react'++export default function App() {+ const { ENV } = useLoaderData<typeof loader>()++ return (+ <html lang="en">+ <head>{/* ... */}</head>+ <body>+ <Outlet />+ <Scripts />+ <script+ dangerouslySetInnerHTML={{+ __html: `window.ENV = ${JSON.stringify(ENV)}`,+ }}+ />+ <Analytics />+ </body>+ </html>+ )+}+```++Then in your analytics component:++```tsx+Swetrix.init(window.ENV.SWETRIX_PID)+```++## Bypassing adblockers with a proxy++Some adblockers may block requests to the Swetrix API domain. Remix apps are commonly deployed on platforms that support request rewrites (Vercel, Netlify, Cloudflare). You can proxy analytics traffic through your own domain to keep all requests first-party.++If your Remix app runs on a Node server, you can add a proxy route at `app/routes/sproxy.$.tsx`:++```tsx+import type { LoaderFunctionArgs } from '@remix-run/node'++export async function loader({ request }: LoaderFunctionArgs) {+ const url = new URL(request.url)+ const target = `https://api.swetrix.com/log${url.pathname.replace('/sproxy', '')}${url.search}`++ return fetch(target, {+ method: request.method,+ headers: request.headers,+ body: request.method !== 'GET' ? await request.text() : undefined,+ })+}++export async function action({ request }: LoaderFunctionArgs) {+ return loader({ request, params: {}, context: {} })+}+```++Then update your analytics initialisation:++```tsx+Swetrix.init('YOUR_PROJECT_ID', {+ apiURL: '/sproxy',+})+```++:::note+Use a generic route name instead of `/analytics` or `/log` β common names are blocked by adblockers.+:::++## Further reading++- [React integration](/react-integration) β for plain React apps without a framework.+- [Next.js integration](/nextjs-integration) β for Next.js applications.+- [Tracking script reference](/swetrix-js-reference) β full API documentation for `init()`, `track()`, `trackViews()`, `trackErrors()`, and more.+- [Swetrix npm package](https://www.npmjs.com/package/swetrix) β package details and changelog.diff --git a/docs/sidebars.js b/docs/sidebars.jsindex a6514e726..306732f5a 100644--- a/docs/sidebars.js+++ b/docs/sidebars.js@@ -22,6 +22,15 @@ module.exports = {'integrations/joomla','integrations/laravel','integrations/prestashop',+ {+ type: 'category',+ label: 'React (Vite / CRA)',+ items: [+ 'integrations/react',+ 'integrations/nextjs',+ 'integrations/remix',+ ],+ },'integrations/shopify','integrations/squarespace','integrations/sveltekit',