@stackonward/google-tag-manager-nuxt 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @stackonward/google-tag-manager-nuxt
+
+## 0.1.0
+
+### Minor Changes
+
+- Add a provider-neutral analytics pipeline, Nuxt lifecycle integration, consent-aware Google Tag Manager transport, configurable global capture, and typed product event APIs. Distribute the integration through the Nuxt template and remove the superseded source-owned analytics runtime from the site shell.
+
+### Patch Changes
+
+- Updated dependencies
+  - @stackonward/analytics-core@0.1.0
+  - @stackonward/analytics-nuxt@0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present yhy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @stackonward/google-tag-manager-nuxt
+
+Consent-aware Google Tag Manager composition module for Nuxt. It installs the provider-neutral analytics runtime, configurable global capture and the Google transport.
+
+## Install
+
+```bash
+pnpm add @stackonward/google-tag-manager-nuxt @nuxt/scripts
+```
+
+```typescript
+export default defineNuxtConfig({
+  modules: ["@stackonward/google-tag-manager-nuxt"],
+  googleTagManager: {
+    id: process.env.NUXT_PUBLIC_GTM_ID || "",
+    analytics: {
+      applicationId: "product-a",
+      environment: process.env.NUXT_PUBLIC_SITE_ENV || "development",
+      autoCapture: {
+        internalDomains: ["product.example"],
+        modulePrefix: "product_",
+        moduleRules: [{ selector: "header", module: "navigation" }],
+      },
+    },
+  },
+});
+```
+
+The integration starts disabled when the container ID is empty. Its default consent state denies every Google storage category. The product or CMP restores the user's decision and calls `useAnalyticsConsent().grant()` or `.deny()`.
+
+The remote GTM container must contain and publish the required GA4 tags, triggers and consent checks. This package does not mutate Google account configuration.
+
+## License
+
+[MIT](./LICENSE)

package/dist/module.d.mts

@@ -0,0 +1,22 @@
+import { NuxtModule } from '@nuxt/schema';
+import { GoogleTagManagerNuxtRuntimeConfig, GoogleTagManagerNuxtModuleOptions } from '../dist/runtime/types.js';
+export { GoogleConsentState, GoogleConsentValue, GoogleTagManagerNuxtModuleOptions, GoogleTagManagerNuxtRuntimeConfig, GoogleTagManagerScriptOptions } from '../dist/runtime/types.js';
+import { AnalyticsNuxtRuntimeConfig } from '@stackonward/analytics-nuxt';
+
+interface NormalizedGoogleTagManagerOptions {
+    readonly runtime: GoogleTagManagerNuxtRuntimeConfig;
+    readonly analytics: AnalyticsNuxtRuntimeConfig;
+}
+declare function normalizeGoogleTagManagerNuxtOptions(input?: unknown): NormalizedGoogleTagManagerOptions;
+
+declare module "@nuxt/schema" {
+    interface NuxtConfig {
+        googleTagManager?: GoogleTagManagerNuxtModuleOptions;
+    }
+    interface NuxtOptions {
+        googleTagManager?: GoogleTagManagerNuxtModuleOptions;
+    }
+}
+declare const module$1: NuxtModule<GoogleTagManagerNuxtModuleOptions>;
+
+export { module$1 as default, normalizeGoogleTagManagerNuxtOptions };

package/dist/module.d.ts

@@ -0,0 +1,22 @@
+import { NuxtModule } from '@nuxt/schema';
+import { GoogleTagManagerNuxtRuntimeConfig, GoogleTagManagerNuxtModuleOptions } from '../dist/runtime/types.js';
+export { GoogleConsentState, GoogleConsentValue, GoogleTagManagerNuxtModuleOptions, GoogleTagManagerNuxtRuntimeConfig, GoogleTagManagerScriptOptions } from '../dist/runtime/types.js';
+import { AnalyticsNuxtRuntimeConfig } from '@stackonward/analytics-nuxt';
+
+interface NormalizedGoogleTagManagerOptions {
+    readonly runtime: GoogleTagManagerNuxtRuntimeConfig;
+    readonly analytics: AnalyticsNuxtRuntimeConfig;
+}
+declare function normalizeGoogleTagManagerNuxtOptions(input?: unknown): NormalizedGoogleTagManagerOptions;
+
+declare module "@nuxt/schema" {
+    interface NuxtConfig {
+        googleTagManager?: GoogleTagManagerNuxtModuleOptions;
+    }
+    interface NuxtOptions {
+        googleTagManager?: GoogleTagManagerNuxtModuleOptions;
+    }
+}
+declare const module$1: NuxtModule<GoogleTagManagerNuxtModuleOptions>;
+
+export { module$1 as default, normalizeGoogleTagManagerNuxtOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@stackonward/google-tag-manager-nuxt",
+  "configKey": "googleTagManager",
+  "compatibility": {
+    "nuxt": ">=3.15.0"
+  },
+  "version": "0.1.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.3",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,103 @@
+import analyticsNuxtModule, { normalizeAnalyticsNuxtOptions } from '@stackonward/analytics-nuxt';
+import { defineNuxtModule, installModule, createResolver, addPlugin } from '@nuxt/kit';
+import { z } from 'zod';
+
+const consentValueSchema = z.enum(["granted", "denied"]);
+const consentSchema = z.object({
+  ad_storage: consentValueSchema.optional(),
+  ad_user_data: consentValueSchema.optional(),
+  ad_personalization: consentValueSchema.optional(),
+  analytics_storage: consentValueSchema.optional(),
+  functionality_storage: consentValueSchema.optional(),
+  personalization_storage: consentValueSchema.optional(),
+  security_storage: consentValueSchema.optional(),
+  region: z.array(z.string().trim().min(2).max(6)).max(100).optional(),
+  wait_for_update: z.number().int().min(0).max(1e4).optional()
+}).strict();
+const optionsSchema = z.object({
+  id: z.string().trim().optional(),
+  enabled: z.boolean().optional(),
+  dataLayerName: z.string().trim().regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/).optional(),
+  defaultConsent: consentSchema.optional(),
+  grantedConsent: consentSchema.optional(),
+  script: z.object({
+    bundle: z.union([z.boolean(), z.literal("force")]).optional(),
+    proxy: z.boolean().optional(),
+    partytown: z.boolean().optional(),
+    warmupStrategy: z.union([
+      z.literal(false),
+      z.literal("preload"),
+      z.literal("preconnect"),
+      z.literal("dns-prefetch")
+    ]).optional()
+  }).strict().optional(),
+  analytics: z.unknown().optional()
+}).strict();
+const DEFAULT_GOOGLE_CONSENT = Object.freeze({
+  ad_storage: "denied",
+  ad_user_data: "denied",
+  ad_personalization: "denied",
+  analytics_storage: "denied",
+  functionality_storage: "denied",
+  personalization_storage: "denied",
+  security_storage: "denied"
+});
+const DEFAULT_GRANTED_GOOGLE_CONSENT = Object.freeze({
+  ...DEFAULT_GOOGLE_CONSENT,
+  analytics_storage: "granted",
+  security_storage: "granted"
+});
+function normalizeGoogleTagManagerNuxtOptions(input = {}) {
+  const parsed = optionsSchema.parse(input);
+  const id = parsed.id ?? "";
+  const analytics = normalizeAnalyticsNuxtOptions(parsed.analytics ?? {});
+  const configuredEnabled = parsed.enabled ?? id.length > 0;
+  const enabled = configuredEnabled && analytics.enabled;
+  if (id && !/^GTM-[A-Z0-9]+$/.test(id)) {
+    throw new Error("Google Tag Manager ID must match GTM-[A-Z0-9]+");
+  }
+  if (configuredEnabled && !id) {
+    throw new Error("Google Tag Manager ID is required when the integration is enabled");
+  }
+  return Object.freeze({
+    runtime: Object.freeze({
+      id,
+      enabled,
+      dataLayerName: parsed.dataLayerName ?? "dataLayer",
+      defaultConsent: Object.freeze({ ...DEFAULT_GOOGLE_CONSENT, ...parsed.defaultConsent }),
+      grantedConsent: Object.freeze({
+        ...DEFAULT_GRANTED_GOOGLE_CONSENT,
+        ...parsed.grantedConsent
+      }),
+      script: Object.freeze({ ...parsed.script })
+    }),
+    analytics
+  });
+}
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@stackonward/google-tag-manager-nuxt",
+    configKey: "googleTagManager",
+    compatibility: { nuxt: ">=3.15.0" }
+  },
+  async setup(options, nuxt) {
+    const normalized = normalizeGoogleTagManagerNuxtOptions(options);
+    await installModule("@nuxt/scripts", {}, nuxt);
+    await installModule(
+      analyticsNuxtModule,
+      {
+        ...normalized.analytics,
+        enabled: normalized.runtime.enabled && normalized.analytics?.enabled !== false
+      },
+      nuxt
+    );
+    nuxt.options.runtimeConfig.public.stackonwardGoogleTagManager = normalized.runtime;
+    if (normalized.runtime.enabled) {
+      const { resolve } = createResolver(import.meta.url);
+      addPlugin(resolve("./runtime/plugins/google-tag-manager.client"));
+    }
+  }
+});
+
+export { module$1 as default, normalizeGoogleTagManagerNuxtOptions };

package/dist/runtime/google-tag-manager-lifecycle.d.ts

@@ -0,0 +1,21 @@
+import type { AnalyticsNuxtLifecycleParticipant } from "@stackonward/analytics-nuxt";
+import type { GoogleConsentState } from "./types.js";
+export type GoogleTagManagerLifecycleErrorCode = "consent-api-unavailable" | "disposed";
+export declare class GoogleTagManagerLifecycleError extends Error {
+    readonly code: GoogleTagManagerLifecycleErrorCode;
+    constructor(code: GoogleTagManagerLifecycleErrorCode);
+}
+export interface GoogleTagManagerScriptLifecycle {
+    readonly consent?: {
+        update(state: GoogleConsentState): void;
+    };
+    load(): Promise<unknown>;
+    reload(): Promise<unknown>;
+    remove(): boolean;
+}
+export interface GoogleTagManagerLifecycleOptions {
+    readonly script: GoogleTagManagerScriptLifecycle;
+    readonly defaultConsent: GoogleConsentState;
+    readonly grantedConsent: GoogleConsentState;
+}
+export declare function createGoogleTagManagerLifecycleParticipant(options: GoogleTagManagerLifecycleOptions): AnalyticsNuxtLifecycleParticipant;

package/dist/runtime/google-tag-manager-lifecycle.js

@@ -0,0 +1,62 @@
+export class GoogleTagManagerLifecycleError extends Error {
+  code;
+  constructor(code) {
+    super(`Google Tag Manager lifecycle error: ${code}`);
+    this.name = "GoogleTagManagerLifecycleError";
+    this.code = code;
+  }
+}
+export function createGoogleTagManagerLifecycleParticipant(options) {
+  let attemptedLoad = false;
+  let loaded = false;
+  let disposed = false;
+  let startPromise;
+  const updateConsent = (state) => {
+    if (!options.script.consent) {
+      throw new GoogleTagManagerLifecycleError("consent-api-unavailable");
+    }
+    options.script.consent.update(state);
+  };
+  return {
+    id: "google-tag-manager",
+    start() {
+      if (disposed) {
+        throw new GoogleTagManagerLifecycleError("disposed");
+      }
+      updateConsent(options.grantedConsent);
+      if (loaded) {
+        return;
+      }
+      if (startPromise) {
+        return startPromise;
+      }
+      const operation = (async () => {
+        const load = attemptedLoad ? options.script.reload : options.script.load;
+        attemptedLoad = true;
+        await load.call(options.script);
+        loaded = true;
+      })();
+      const tracked = operation.finally(() => {
+        if (startPromise === tracked) {
+          startPromise = void 0;
+        }
+      });
+      startPromise = tracked;
+      return tracked;
+    },
+    stop() {
+      if (disposed) {
+        return;
+      }
+      updateConsent(options.defaultConsent);
+    },
+    dispose() {
+      if (disposed) {
+        return;
+      }
+      updateConsent(options.defaultConsent);
+      disposed = true;
+      options.script.remove();
+    }
+  };
+}

package/dist/runtime/plugins/google-tag-manager.client.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/google-tag-manager.client.js

@@ -0,0 +1,34 @@
+import { defineNuxtPlugin, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { createGoogleTagManagerTransport } from "../../google-tag-manager-transport";
+import { createGoogleTagManagerLifecycleParticipant } from "../google-tag-manager-lifecycle.js";
+export default defineNuxtPlugin({
+  name: "stackonward:google-tag-manager",
+  dependsOn: ["stackonward:analytics"],
+  setup() {
+    const config = useRuntimeConfig().public.stackonwardGoogleTagManager;
+    const app = useNuxtApp();
+    const analytics = app.$analyticsRuntime;
+    if (!analytics) {
+      throw new Error("Google Tag Manager requires @stackonward/analytics-nuxt");
+    }
+    const script = useScriptGoogleTagManager({
+      id: config.id,
+      l: config.dataLayerName,
+      defaultConsent: config.defaultConsent,
+      trigger: "manual",
+      ...config.script
+    });
+    analytics.registerLifecycleParticipant(
+      createGoogleTagManagerLifecycleParticipant({
+        script,
+        defaultConsent: config.defaultConsent,
+        grantedConsent: config.grantedConsent
+      })
+    );
+    analytics.registerTransport(
+      createGoogleTagManagerTransport({
+        push: (event) => script.proxy.dataLayer.push(event)
+      })
+    );
+  }
+});

package/dist/runtime/types.d.ts

@@ -0,0 +1,36 @@
+import type { AnalyticsNuxtModuleOptions } from "@stackonward/analytics-nuxt";
+export type GoogleConsentValue = "granted" | "denied";
+export interface GoogleConsentState {
+    readonly ad_storage?: GoogleConsentValue;
+    readonly ad_user_data?: GoogleConsentValue;
+    readonly ad_personalization?: GoogleConsentValue;
+    readonly analytics_storage?: GoogleConsentValue;
+    readonly functionality_storage?: GoogleConsentValue;
+    readonly personalization_storage?: GoogleConsentValue;
+    readonly security_storage?: GoogleConsentValue;
+    readonly region?: readonly string[];
+    readonly wait_for_update?: number;
+}
+export interface GoogleTagManagerScriptOptions {
+    readonly bundle?: boolean | "force";
+    readonly proxy?: boolean;
+    readonly partytown?: boolean;
+    readonly warmupStrategy?: false | "preload" | "preconnect" | "dns-prefetch";
+}
+export interface GoogleTagManagerNuxtModuleOptions {
+    readonly id?: string;
+    readonly enabled?: boolean;
+    readonly dataLayerName?: string;
+    readonly defaultConsent?: GoogleConsentState;
+    readonly grantedConsent?: GoogleConsentState;
+    readonly script?: GoogleTagManagerScriptOptions;
+    readonly analytics?: AnalyticsNuxtModuleOptions;
+}
+export interface GoogleTagManagerNuxtRuntimeConfig {
+    readonly id: string;
+    readonly enabled: boolean;
+    readonly dataLayerName: string;
+    readonly defaultConsent: GoogleConsentState;
+    readonly grantedConsent: GoogleConsentState;
+    readonly script: GoogleTagManagerScriptOptions;
+}

package/dist/transport.d.mts

@@ -0,0 +1,30 @@
+import * as _stackonward_analytics_core from '@stackonward/analytics-core';
+import { AnalyticsPrimitive, AnalyticsEnvelope, AnalyticsValidationIssue, AnalyticsTransport } from '@stackonward/analytics-core';
+
+type GoogleTagManagerDataLayerEvent = Readonly<Record<string, AnalyticsPrimitive> & {
+    event: string;
+}>;
+type GoogleEventProjectionResult = {
+    readonly success: true;
+    readonly data: GoogleTagManagerDataLayerEvent;
+} | {
+    readonly success: false;
+    readonly issues: readonly AnalyticsValidationIssue[];
+};
+declare function projectGoogleTagManagerEvent(envelope: AnalyticsEnvelope): GoogleEventProjectionResult;
+
+declare class GoogleTagManagerProjectionError extends Error {
+    readonly issues: readonly _stackonward_analytics_core.AnalyticsValidationIssue[];
+    constructor(issues: ReturnType<typeof projectGoogleTagManagerEvent> & {
+        success: false;
+    });
+}
+interface GoogleTagManagerTransportOptions {
+    readonly beforeSend?: () => void | Promise<void>;
+    readonly push: (event: GoogleTagManagerDataLayerEvent) => void;
+    readonly dispose?: () => void | Promise<void>;
+}
+declare function createGoogleTagManagerTransport(options: GoogleTagManagerTransportOptions): AnalyticsTransport;
+
+export { GoogleTagManagerProjectionError, createGoogleTagManagerTransport, projectGoogleTagManagerEvent };
+export type { GoogleEventProjectionResult, GoogleTagManagerDataLayerEvent, GoogleTagManagerTransportOptions };

package/dist/transport.d.ts

@@ -0,0 +1,30 @@
+import * as _stackonward_analytics_core from '@stackonward/analytics-core';
+import { AnalyticsPrimitive, AnalyticsEnvelope, AnalyticsValidationIssue, AnalyticsTransport } from '@stackonward/analytics-core';
+
+type GoogleTagManagerDataLayerEvent = Readonly<Record<string, AnalyticsPrimitive> & {
+    event: string;
+}>;
+type GoogleEventProjectionResult = {
+    readonly success: true;
+    readonly data: GoogleTagManagerDataLayerEvent;
+} | {
+    readonly success: false;
+    readonly issues: readonly AnalyticsValidationIssue[];
+};
+declare function projectGoogleTagManagerEvent(envelope: AnalyticsEnvelope): GoogleEventProjectionResult;
+
+declare class GoogleTagManagerProjectionError extends Error {
+    readonly issues: readonly _stackonward_analytics_core.AnalyticsValidationIssue[];
+    constructor(issues: ReturnType<typeof projectGoogleTagManagerEvent> & {
+        success: false;
+    });
+}
+interface GoogleTagManagerTransportOptions {
+    readonly beforeSend?: () => void | Promise<void>;
+    readonly push: (event: GoogleTagManagerDataLayerEvent) => void;
+    readonly dispose?: () => void | Promise<void>;
+}
+declare function createGoogleTagManagerTransport(options: GoogleTagManagerTransportOptions): AnalyticsTransport;
+
+export { GoogleTagManagerProjectionError, createGoogleTagManagerTransport, projectGoogleTagManagerEvent };
+export type { GoogleEventProjectionResult, GoogleTagManagerDataLayerEvent, GoogleTagManagerTransportOptions };

package/dist/transport.mjs

@@ -0,0 +1,97 @@
+const GOOGLE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,39}$/;
+const RESERVED_PREFIXES = ["firebase_", "google_", "ga_"];
+const GOOGLE_PARAMETER_LIMIT = 25;
+function projectGoogleTagManagerEvent(envelope) {
+  const issues = [];
+  validateGoogleName("name", envelope.name, issues);
+  const contextKeys = new Set(Object.keys(envelope.context));
+  for (const name of Object.keys(envelope.properties)) {
+    if (contextKeys.has(name)) {
+      issues.push({
+        path: `properties.${name}`,
+        code: "context_property_collision",
+        message: "Event properties cannot overwrite analytics context"
+      });
+    }
+  }
+  const merged = { ...envelope.context, ...envelope.properties, event_source: envelope.source };
+  const entries = Object.entries(merged);
+  if (entries.length > GOOGLE_PARAMETER_LIMIT) {
+    issues.push({
+      path: "properties",
+      code: "too_many_parameters",
+      message: `Google events cannot exceed ${GOOGLE_PARAMETER_LIMIT} parameters`
+    });
+  }
+  for (const [name, value] of entries) {
+    validateGoogleName(`properties.${name}`, name, issues);
+    if (Array.isArray(value)) {
+      issues.push({
+        path: `properties.${name}`,
+        code: "unsupported_array",
+        message: "Google Tag Manager event parameters must be primitive values"
+      });
+    }
+  }
+  if (issues.length > 0) {
+    return { success: false, issues: Object.freeze(issues) };
+  }
+  return {
+    success: true,
+    data: Object.freeze({
+      event: envelope.name,
+      ...Object.fromEntries(entries)
+    })
+  };
+}
+function validateGoogleName(path, value, issues) {
+  if (!GOOGLE_NAME_PATTERN.test(value)) {
+    issues.push({
+      path,
+      code: "invalid_google_name",
+      message: "Google names must start with a letter and contain at most 40 alphanumeric or underscore characters"
+    });
+  }
+  if (RESERVED_PREFIXES.some((prefix) => value.toLowerCase().startsWith(prefix))) {
+    issues.push({
+      path,
+      code: "reserved_google_prefix",
+      message: "Google event and parameter names cannot use reserved prefixes"
+    });
+  }
+}
+
+class GoogleTagManagerProjectionError extends Error {
+  issues;
+  constructor(issues) {
+    super("Analytics event is not compatible with Google Tag Manager");
+    this.name = "GoogleTagManagerProjectionError";
+    this.issues = issues.issues;
+  }
+}
+function createGoogleTagManagerTransport(options) {
+  let disposed = false;
+  return {
+    id: "google-tag-manager",
+    async send(envelope) {
+      if (disposed) {
+        throw new Error("Google Tag Manager transport is disposed");
+      }
+      const projection = projectGoogleTagManagerEvent(envelope);
+      if (!projection.success) {
+        throw new GoogleTagManagerProjectionError(projection);
+      }
+      await options.beforeSend?.();
+      options.push(projection.data);
+    },
+    async dispose() {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      await options.dispose?.();
+    }
+  };
+}
+
+export { GoogleTagManagerProjectionError, createGoogleTagManagerTransport, projectGoogleTagManagerEvent };

package/dist/types.d.mts

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

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@stackonward/google-tag-manager-nuxt",
+  "version": "0.1.0",
+  "description": "Consent-aware Google Tag Manager transport and analytics composition module for Nuxt",
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "types": "./dist/module.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.mts",
+      "import": "./dist/module.mjs"
+    },
+    "./transport": {
+      "types": "./dist/transport.d.mts",
+      "import": "./dist/transport.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/1yhy/stackonward.git",
+    "directory": "packages/integrations/google/tag-manager-nuxt"
+  },
+  "keywords": [
+    "analytics",
+    "google-tag-manager",
+    "gtm",
+    "nuxt"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^3.24.0",
+    "@stackonward/analytics-core": "^0.1.0",
+    "@stackonward/analytics-nuxt": "^0.1.0"
+  },
+  "peerDependencies": {
+    "@nuxt/scripts": ">=1.3.0 <2",
+    "nuxt": ">=3.15.0 <5",
+    "vue": ">=3.5.0 <4"
+  },
+  "devDependencies": {
+    "@nuxt/kit": "^3.15.0",
+    "@nuxt/module-builder": "^1.0.2",
+    "@nuxt/schema": "^3.15.0",
+    "@nuxt/scripts": "^1.3.0",
+    "happy-dom": "^17.6.3",
+    "nuxt": "^3.20.1",
+    "typescript": "^5.9.3",
+    "unbuild": "^3.5.0",
+    "vitest": "^3.2.4",
+    "vue": "^3.5.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "nuxt-module-build build && unbuild",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}