@neomanex/analytics-nuxt 1.0.2

package/README.md

@@ -0,0 +1,54 @@
+# @neomanex/analytics
+
+Nuxt module for analytics tracking with SSR middleware, browser plugin, and server proxy.
+
+## Quick Start
+
+```bash
+pnpm add @neomanex/analytics
+```
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['@neomanex/analytics'],
+
+  analytics: {
+    apiUrl: 'https://analytics-api.neomanex.com',
+    source: 'my-app',
+  },
+})
+```
+
+## Features
+
+- **Server-side tracking** - Accurate analytics even with ad blockers
+- **Automatic events** - `page.visit`, `page.view`, `session.start`, `page.leave`
+- **Manual tracking** - `useAnalytics()` composable for custom events
+- **Correlation IDs** - Links SSR and browser events across the session
+- **Secure proxy** - API URL never exposed to browser
+
+## Full Documentation
+
+For complete documentation including installation, configuration, API reference, and guides:
+
+**[View Full Documentation →](./docs/01-overview/01-introduction.md)**
+
+Key sections:
+- [Introduction](./docs/01-overview/01-introduction.md) - What, why, and architecture
+- [Installation](./docs/01-overview/02-installation.md) - Setup and configuration
+- [API Reference](./docs/02-api/) - Coming soon
+- [Guides](./docs/03-guides/) - Coming soon
+
+## Development
+
+```bash
+npm install          # Install dependencies
+npm test            # Run tests
+npm run dev         # Dev playground
+npm run build       # Build module
+```
+
+## License
+
+UNLICENSED

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,6 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { ModuleOptions } from '../dist/runtime/types.js';
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.d.ts

@@ -0,0 +1,6 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { ModuleOptions } from '../dist/runtime/types.js';
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@neomanex/analytics",
+  "configKey": "analytics",
+  "compatibility": {
+    "nuxt": ">=3.10.0"
+  },
+  "version": "1.0.0",
+  "builder": {
+    "@nuxt/module-builder": "0.8.4",
+    "unbuild": "unknown"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,86 @@
+import { defineNuxtModule, createResolver, addServerHandler, addPlugin, addImports, addTypeTemplate } from '@nuxt/kit';
+import { defu } from 'defu';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@neomanex/analytics",
+    configKey: "analytics",
+    compatibility: {
+      nuxt: ">=3.10.0"
+    },
+    version: "1.0.0"
+  },
+  defaults: {
+    apiUrl: "",
+    source: "",
+    trackPageVisits: true,
+    trackPageViews: true,
+    trackPageLeave: true,
+    excludePaths: []
+  },
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.analytics = defu(
+      nuxt.options.runtimeConfig.analytics || {},
+      {
+        apiUrl: options.apiUrl,
+        source: options.source,
+        trackPageVisits: options.trackPageVisits,
+        trackPageViews: options.trackPageViews,
+        trackPageLeave: options.trackPageLeave,
+        excludePaths: options.excludePaths
+      }
+    );
+    nuxt.options.runtimeConfig.public.analytics = defu(
+      nuxt.options.runtimeConfig.public.analytics || {},
+      {
+        source: options.source,
+        trackPageViews: options.trackPageViews,
+        trackPageLeave: options.trackPageLeave,
+        excludePaths: options.excludePaths
+      }
+    );
+    addServerHandler({
+      handler: resolver.resolve("./runtime/server/middleware/page-visit"),
+      middleware: true
+    });
+    addServerHandler({
+      route: "/api/_analytics",
+      handler: resolver.resolve("./runtime/server/api/_analytics.post")
+    });
+    addPlugin({
+      src: resolver.resolve("./runtime/plugin.server"),
+      mode: "server"
+    });
+    addPlugin({
+      src: resolver.resolve("./runtime/plugin.client"),
+      mode: "client"
+    });
+    addImports({
+      name: "useAnalytics",
+      from: resolver.resolve("./runtime/app/composables/useAnalytics")
+    });
+    addTypeTemplate({
+      filename: "types/analytics.d.ts",
+      getContents: () => `
+import type { AnalyticsClient } from '${resolver.resolve("./runtime/client")}'
+
+declare module '#app' {
+  interface NuxtApp {
+    $analytics: AnalyticsClient
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $analytics: AnalyticsClient
+  }
+}
+
+export {}
+`
+    });
+  }
+});
+
+export { module as default };

package/dist/runtime/app/composables/useAnalytics.js

@@ -0,0 +1,8 @@
+import { useNuxtApp } from "#imports";
+export function useAnalytics() {
+  const { $analytics } = useNuxtApp();
+  return {
+    track: $analytics.track.bind($analytics),
+    flush: $analytics.flush.bind($analytics)
+  };
+}

package/dist/runtime/client.js

@@ -0,0 +1,170 @@
+import { $fetch } from "ofetch";
+import { resolveConfig, OVERFLOW_WARNING_DEBOUNCE_MS } from "./config.js";
+export class AnalyticsClient {
+  config;
+  queue = [];
+  flushTimer = null;
+  isFlushing = false;
+  isShutdown = false;
+  /** Debounce state for queue overflow warnings */
+  _lastOverflowWarning = 0;
+  _overflowWarningShown = false;
+  constructor(config) {
+    this.config = resolveConfig(config);
+    this.startFlushTimer();
+  }
+  /**
+   * Add an event to the queue. Returns immediately and never throws.
+   */
+  track(eventType, metadata, options) {
+    if (this.isShutdown) {
+      return;
+    }
+    try {
+      const event = {
+        event_type: eventType,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        source: this.config.source,
+        metadata: metadata ?? void 0,
+        account_id: options?.account_id,
+        user_id: options?.user_id
+      };
+      if (this.queue.length >= this.config.maxQueueSize) {
+        this.handleQueueOverflow(event);
+        return;
+      }
+      this.queue.push(event);
+      if (this.queue.length >= this.config.flushSize) {
+        void this.flush();
+      }
+    } catch {
+    }
+  }
+  /**
+   * Manually flush all queued events to the batch endpoint.
+   */
+  async flush() {
+    if (this.isFlushing || this.queue.length === 0) {
+      return;
+    }
+    this.isFlushing = true;
+    const events = this.queue.splice(0, this.queue.length);
+    try {
+      await this.flushWithRetry(events);
+    } catch {
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  /**
+   * Flush remaining events and stop the timer. Call on process exit.
+   */
+  async shutdown() {
+    this.isShutdown = true;
+    this.stopFlushTimer();
+    if (this.queue.length > 0) {
+      await this.flush();
+    }
+  }
+  /**
+   * Get current queue length (for testing/monitoring).
+   */
+  get queueLength() {
+    return this.queue.length;
+  }
+  /**
+   * Build an event payload for sendBeacon usage (browser page.leave).
+   * Returns the JSON string to send via navigator.sendBeacon.
+   */
+  buildBeaconPayload(eventType, metadata) {
+    const event = {
+      event_type: eventType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      source: this.config.source,
+      metadata
+    };
+    return JSON.stringify({ events: [event] });
+  }
+  /**
+   * Send a batch of events to the API with exponential backoff retry.
+   */
+  async flushWithRetry(events) {
+    let attempt = 0;
+    let delay = this.config.retryDelay;
+    const maxRetries = this.config.maxRetries;
+    const backoffMultiplier = this.config.retryBackoffMultiplier;
+    while (attempt <= maxRetries) {
+      try {
+        await this.sendBatch(events);
+        return;
+      } catch (error) {
+        attempt++;
+        if (attempt > maxRetries) {
+          if (this.config.onError) {
+            this.config.onError(error, events);
+          }
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay *= backoffMultiplier;
+      }
+    }
+  }
+  /**
+   * Send a batch of events via ofetch.
+   */
+  async sendBatch(events) {
+    await $fetch("/api/v1/events/batch", {
+      baseURL: this.config.apiUrl,
+      method: "POST",
+      body: { events }
+    });
+  }
+  /**
+   * Handle queue overflow: drop oldest event, push new one, warn with debounce.
+   */
+  handleQueueOverflow(event) {
+    this.queue.shift();
+    const now = Date.now();
+    if (!this._overflowWarningShown || now - this._lastOverflowWarning > OVERFLOW_WARNING_DEBOUNCE_MS) {
+      console.warn(
+        "[Analytics] Queue overflow: dropping events. Increase maxQueueSize or reduce event frequency."
+      );
+      this._lastOverflowWarning = now;
+      this._overflowWarningShown = true;
+    }
+    this.queue.push(event);
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      void this.flush();
+    }, this.config.flushInterval);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+}
+let clientInstance = null;
+export function init(config) {
+  if (clientInstance) {
+    console.warn("[Analytics] Already initialized");
+    return clientInstance;
+  }
+  clientInstance = new AnalyticsClient(config);
+  return clientInstance;
+}
+export function getInstance() {
+  if (!clientInstance) {
+    throw new Error("[Analytics] Not initialized. Call init() first.");
+  }
+  return clientInstance;
+}
+export function resetInstance() {
+  if (clientInstance) {
+    void clientInstance.shutdown();
+  }
+  clientInstance = null;
+}

package/dist/runtime/config.js

@@ -0,0 +1,20 @@
+export const DEFAULT_FLUSH_INTERVAL = 1e4;
+export const DEFAULT_FLUSH_SIZE = 10;
+export const DEFAULT_MAX_QUEUE_SIZE = 1e3;
+export const DEFAULT_MAX_RETRIES = 3;
+export const DEFAULT_RETRY_DELAY = 1e3;
+export const DEFAULT_RETRY_BACKOFF_MULTIPLIER = 2;
+export const OVERFLOW_WARNING_DEBOUNCE_MS = 6e4;
+export function resolveConfig(config) {
+  return {
+    apiUrl: config.apiUrl,
+    source: config.source,
+    flushInterval: config.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
+    flushSize: config.flushSize ?? DEFAULT_FLUSH_SIZE,
+    maxQueueSize: config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
+    maxRetries: config.maxRetries ?? DEFAULT_MAX_RETRIES,
+    retryDelay: config.retryDelay ?? DEFAULT_RETRY_DELAY,
+    retryBackoffMultiplier: config.retryBackoffMultiplier ?? DEFAULT_RETRY_BACKOFF_MULTIPLIER,
+    onError: config.onError
+  };
+}

package/dist/runtime/imports-stub.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type declarations for #imports stub.
+ *
+ * Provides type signatures matching Nuxt's auto-imports for development
+ * and type checking outside of a Nuxt context.
+ */
+
+export declare function defineEventHandler<T>(handler: (event: any) => T | Promise<T>): (event: any) => T | Promise<T>
+export declare function defineNuxtPlugin(factory: (nuxtApp?: any) => any): any
+export declare function getRequestHeader(event: any, name: string): string | undefined
+export declare function setResponseHeader(event: any, name: string, value: string): void
+export declare function useRuntimeConfig(): any
+export declare function getRequestURL(event: any): URL
+export declare function readBody<T = any>(event: any): Promise<T>
+export declare function useRouter(): any
+export declare function useNuxtApp(): any

package/dist/runtime/imports-stub.js

@@ -0,0 +1,42 @@
+export function defineEventHandler(handler) {
+  return handler;
+}
+export function defineNuxtPlugin(factory) {
+  return factory;
+}
+export function getRequestHeader(_event, _name) {
+  return void 0;
+}
+export function setResponseHeader(_event, _name, _value) {
+}
+export function useRuntimeConfig() {
+  return {};
+}
+export function getRequestURL(_event) {
+  return new URL("http://localhost/");
+}
+export function readBody(_event) {
+  return Promise.resolve({});
+}
+export function useRouter() {
+  return {
+    afterEach: () => {
+    }
+  };
+}
+export function useNuxtApp() {
+  return {
+    $analytics: {}
+  };
+}
+export function addServerHandler(_options) {
+}
+export function addPlugin(_options) {
+}
+export function addImports(_options) {
+}
+export function addTypeTemplate(_options) {
+}
+export function createResolver(_url) {
+  return { resolve: (path) => path };
+}

package/dist/runtime/plugin.client.js

@@ -0,0 +1,98 @@
+import { defineNuxtPlugin, useRouter, useRuntimeConfig } from "#imports";
+import { init, getInstance } from "./client.js";
+const SESSION_ID_KEY = "neomanex_analytics_session_id";
+const PAGE_ENTRY_KEY = "neomanex_analytics_page_entry";
+function generateUUID() {
+  return self.crypto.randomUUID();
+}
+function getOrCreateSessionId() {
+  let sessionId = sessionStorage.getItem(SESSION_ID_KEY);
+  if (!sessionId) {
+    sessionId = generateUUID();
+    sessionStorage.setItem(SESSION_ID_KEY, sessionId);
+  }
+  return sessionId;
+}
+function getCorrelationId() {
+  const meta = document.querySelector('meta[name="x-correlation-id"]');
+  return meta?.getAttribute("content") ?? void 0;
+}
+function getScrollDepthPct() {
+  const docHeight = document.documentElement.scrollHeight;
+  const winHeight = window.innerHeight;
+  const scrollTop = window.scrollY;
+  if (docHeight <= winHeight) {
+    return 100;
+  }
+  return Math.min(100, Math.round((scrollTop + winHeight) / docHeight * 100));
+}
+function shouldExclude(path, excludePaths) {
+  return excludePaths.some((pattern) => path.startsWith(pattern));
+}
+export default defineNuxtPlugin(() => {
+  const runtimeConfig = useRuntimeConfig();
+  const publicConfig = runtimeConfig.public.analytics;
+  let client;
+  try {
+    client = getInstance();
+  } catch {
+    client = init({
+      apiUrl: "/api/_analytics",
+      source: publicConfig.source,
+      flushInterval: 1e4,
+      flushSize: 5
+    });
+  }
+  const router = useRouter();
+  const sessionId = getOrCreateSessionId();
+  const correlationId = getCorrelationId();
+  let isFirstPageView = !sessionStorage.getItem(PAGE_ENTRY_KEY);
+  sessionStorage.setItem(PAGE_ENTRY_KEY, Date.now().toString());
+  if (isFirstPageView) {
+    client.track("session.start", {
+      entry_path: window.location.pathname,
+      screen_width: window.screen.width,
+      screen_height: window.screen.height,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      language: navigator.language,
+      correlation_id: correlationId,
+      session_id: sessionId
+    });
+    isFirstPageView = false;
+  }
+  if (publicConfig.trackPageViews) {
+    router.afterEach((to, from) => {
+      if (shouldExclude(to.path, publicConfig.excludePaths ?? [])) {
+        return;
+      }
+      sessionStorage.setItem(PAGE_ENTRY_KEY, Date.now().toString());
+      client.track("page.view", {
+        path: to.path,
+        query: to.query,
+        title: typeof document !== "undefined" ? document.title : void 0,
+        from_path: from.path,
+        correlation_id: getCorrelationId(),
+        session_id: sessionId
+      });
+    });
+  }
+  if (publicConfig.trackPageLeave) {
+    window.addEventListener("beforeunload", () => {
+      const entryTime = parseInt(sessionStorage.getItem(PAGE_ENTRY_KEY) ?? "0", 10);
+      const durationMs = entryTime > 0 ? Date.now() - entryTime : 0;
+      const payload = client.buildBeaconPayload("page.leave", {
+        path: window.location.pathname,
+        duration_ms: durationMs,
+        scroll_depth_pct: getScrollDepthPct(),
+        correlation_id: getCorrelationId(),
+        session_id: sessionId
+      });
+      navigator.sendBeacon("/api/_analytics", payload);
+    });
+  }
+  return {
+    provide: {
+      analytics: client
+    }
+  };
+});

package/dist/runtime/plugin.server.js

@@ -0,0 +1,23 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+import { init, getInstance } from "./client.js";
+export default defineNuxtPlugin(() => {
+  const config = useRuntimeConfig();
+  const analyticsConfig = config.analytics;
+  let client;
+  try {
+    client = getInstance();
+  } catch {
+    client = init({
+      apiUrl: analyticsConfig.apiUrl,
+      source: analyticsConfig.source,
+      // Server-side uses longer flush interval (events are fewer but more valuable)
+      flushInterval: 5e3,
+      flushSize: 20
+    });
+  }
+  return {
+    provide: {
+      analytics: client
+    }
+  };
+});

package/dist/runtime/server/api/_analytics.post.js

@@ -0,0 +1,60 @@
+import { defineEventHandler, readBody, getRequestHeader, useRuntimeConfig } from "#imports";
+import { $fetch } from "ofetch";
+function extractClientIp(event) {
+  const forwarded = getRequestHeader(event, "x-forwarded-for");
+  if (forwarded) {
+    return forwarded.split(",")[0]?.trim();
+  }
+  const realIp = getRequestHeader(event, "x-real-ip");
+  if (realIp) {
+    return realIp;
+  }
+  const nodeReq = event.node?.req;
+  if (nodeReq?.socket?.remoteAddress) {
+    return nodeReq.socket.remoteAddress;
+  }
+  return void 0;
+}
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const analyticsConfig = config.analytics;
+  let body;
+  try {
+    body = await readBody(event);
+  } catch {
+    return { ok: false, error: "Invalid request body" };
+  }
+  if (!body?.events || !Array.isArray(body.events) || body.events.length === 0) {
+    return { ok: false, error: "No events provided" };
+  }
+  const clientIp = extractClientIp(event);
+  const userAgent = getRequestHeader(event, "user-agent");
+  const referer = getRequestHeader(event, "referer");
+  const acceptLanguage = getRequestHeader(event, "accept-language");
+  const origin = getRequestHeader(event, "origin");
+  const correlationId = getRequestHeader(event, "x-correlation-id");
+  const enrichedEvents = body.events.map((evt) => ({
+    ...evt,
+    source: evt.source || analyticsConfig.source,
+    client_ip: clientIp,
+    user_agent: userAgent,
+    referer,
+    accept_language: acceptLanguage,
+    metadata: {
+      ...evt.metadata,
+      origin,
+      correlation_id: correlationId ?? evt.metadata?.correlation_id
+    }
+  }));
+  try {
+    const response = await $fetch("/api/v1/events/batch", {
+      baseURL: analyticsConfig.apiUrl,
+      method: "POST",
+      body: { events: enrichedEvents }
+    });
+    return { ok: true, ingested: response.ingested };
+  } catch (error) {
+    console.error("[Analytics] Failed to forward events:", error);
+    return { ok: false, error: "Analytics service unavailable" };
+  }
+});

package/dist/runtime/server/middleware/page-visit.js

@@ -0,0 +1,67 @@
+import { defineEventHandler, getRequestHeader, setResponseHeader, useRuntimeConfig, getRequestURL } from "#imports";
+import { getInstance } from "../../client.js";
+const EXCLUDED_PREFIXES = ["/api/", "/_nuxt/", "/__nuxt_error"];
+const EXCLUDED_EXACT = ["/favicon.ico", "/_health", "/healthz"];
+function extractClientIp(event) {
+  const forwarded = getRequestHeader(event, "x-forwarded-for");
+  if (forwarded) {
+    return forwarded.split(",")[0]?.trim();
+  }
+  const realIp = getRequestHeader(event, "x-real-ip");
+  if (realIp) {
+    return realIp;
+  }
+  const nodeReq = event.node?.req;
+  if (nodeReq?.socket?.remoteAddress) {
+    return nodeReq.socket.remoteAddress;
+  }
+  return void 0;
+}
+function generateCorrelationId() {
+  return crypto.randomUUID();
+}
+export default defineEventHandler((event) => {
+  const config = useRuntimeConfig();
+  const analyticsConfig = config.analytics;
+  if (!analyticsConfig.trackPageVisits) {
+    return;
+  }
+  const url = getRequestURL(event);
+  const path = url.pathname;
+  if (EXCLUDED_PREFIXES.some((prefix) => path.startsWith(prefix))) {
+    return;
+  }
+  if (EXCLUDED_EXACT.includes(path)) {
+    return;
+  }
+  if (analyticsConfig.excludePaths?.some((p) => path.startsWith(p))) {
+    return;
+  }
+  const ext = path.split(".").pop();
+  if (ext && ["js", "css", "png", "jpg", "jpeg", "gif", "svg", "ico", "woff", "woff2", "ttf", "eot", "map"].includes(ext)) {
+    return;
+  }
+  const correlationId = generateCorrelationId();
+  setResponseHeader(event, "X-Correlation-Id", correlationId);
+  const clientIp = extractClientIp(event);
+  const userAgent = getRequestHeader(event, "user-agent");
+  const referer = getRequestHeader(event, "referer");
+  const acceptLanguage = getRequestHeader(event, "accept-language");
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  try {
+    const client = getInstance();
+    client.track("page.visit", {
+      path,
+      query: Object.keys(query).length > 0 ? query : void 0,
+      correlation_id: correlationId,
+      client_ip: clientIp,
+      user_agent: userAgent,
+      referer,
+      accept_language: acceptLanguage
+    });
+  } catch {
+  }
+});

package/dist/types.d.mts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@neomanex/analytics-nuxt",
+  "version": "1.0.2",
+  "description": "Nuxt module for analytics tracking with SSR middleware, browser plugin, and server proxy",
+  "license": "UNLICENSED",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxi prepare playground",
+    "build": "nuxt-module-build build",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^3.10.0",
+    "defu": "^6.1.4",
+    "ofetch": "^1.4.1"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "^0.8.0",
+    "@nuxt/schema": "^3.10.0",
+    "nuxt": "^3.10.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "peerDependencies": {
+    "nuxt": ">=3.10.0 || >=4.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/neomanex/neoanalytics/analytics-nuxt.git"
+  }
+}