@posthog/nuxt 0.0.27 → 1.0.1

package/dist/module.d.mts

@@ -12,16 +12,24 @@ interface EnabledSourcemaps {
     version?: string;
     project?: string;
     verbose?: boolean;
+    deleteAfterUpload?: boolean;
 }
 interface ModuleOptions {
     host: string;
     publicKey: string;
     debug?: boolean;
-    clientConfig?: Partial<PostHogConfig>;
-    serverConfig?: PostHogOptions;
+    clientConfig?: PostHogClientConfig;
+    serverConfig?: PostHogServerConfig;
     sourcemaps: DisabledSourcemaps | EnabledSourcemaps | undefined;
 }
+interface PostHogCommon {
+    publicKey: string;
+    host: string;
+    debug?: boolean;
+}
+type PostHogServerConfig = PostHogOptions;
+type PostHogClientConfig = Partial<PostHogConfig>;
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
 export { _default as default };
-export type { ModuleOptions };
+export type { ModuleOptions, PostHogClientConfig, PostHogCommon, PostHogServerConfig };

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.7.0"
   },
-  "version": "0.0.27",
+  "version": "1.0.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,10 +1,8 @@
 import { defineNuxtModule, createResolver, addPlugin, addServerPlugin } from '@nuxt/kit';
 import { spawnLocal } from '@posthog/core/process';
 import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
+import path, { dirname } from 'node:path';
 
-const VUE_OUTPUT_DIRECTORY = ".output/public";
-const NITRO_OUTPUT_DIRECTORY = ".output/server";
 const filename = fileURLToPath(import.meta.url);
 const resolvedDirname = dirname(filename);
 const module = defineNuxtModule({
@@ -25,85 +23,105 @@ const module = defineNuxtModule({
     const resolver = createResolver(import.meta.url);
     addPlugin(resolver.resolve("./runtime/vue-plugin"));
     addServerPlugin(resolver.resolve("./runtime/nitro-plugin"));
-    nuxt.options.runtimeConfig.public.posthogPublicKey = nuxt.options.runtimeConfig.public.posthogPublicKey || options.publicKey;
-    nuxt.options.runtimeConfig.public.posthogHost = nuxt.options.runtimeConfig.public.posthogHost || options.host;
-    nuxt.options.runtimeConfig.public.posthogDebug = nuxt.options.runtimeConfig.public.posthogDebug || options.debug;
-    nuxt.options.runtimeConfig.public.posthogClientConfig = nuxt.options.runtimeConfig.public.posthogClientConfig || options.clientConfig;
-    nuxt.options.runtimeConfig.public.posthogServerConfig = nuxt.options.runtimeConfig.public.posthogServerConfig || options.serverConfig;
-    if (!options.sourcemaps?.enabled || nuxt.options.dev) {
-      return;
-    }
+    Object.assign(nuxt.options.runtimeConfig.public, {
+      posthog: {
+        publicKey: options.publicKey,
+        host: options.host,
+        debug: options.debug
+      },
+      posthogClientConfig: options.clientConfig
+    });
+    Object.assign(nuxt.options.runtimeConfig, {
+      posthogServerConfig: options.serverConfig
+    });
     const sourcemapsConfig = options.sourcemaps;
-    const cliEnv = {
-      ...process.env,
-      POSTHOG_CLI_ENV_ID: sourcemapsConfig.envId,
-      POSTHOG_CLI_TOKEN: sourcemapsConfig.personalApiKey
-    };
-    const sharedInjectOptions = [
-      "--host",
-      options.host,
-      "sourcemap",
-      "inject",
-      "--ignore",
-      "**/node_modules/**"
-    ];
-    if (options.sourcemaps.project) {
-      sharedInjectOptions.push("--project", options.sourcemaps.project);
-    }
-    if (options.sourcemaps.version) {
-      sharedInjectOptions.push("--version", options.sourcemaps.version);
+    if (!sourcemapsConfig?.enabled || nuxt.options.dev) {
+      return;
     }
-    nuxt.hooks.hook("nitro:build:public-assets", async () => {
-      try {
-        await spawnLocal("posthog-cli", [...sharedInjectOptions, "--directory", VUE_OUTPUT_DIRECTORY], {
-          env: cliEnv,
-          cwd: process.cwd(),
-          resolveFrom: resolvedDirname,
-          stdio: "inherit",
-          onBinaryFound: () => {
-          }
-        });
-      } catch (error) {
-        console.error("PostHog sourcemap inject failed:", error);
-      }
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.rollupConfig = {
+        ...nitroConfig.rollupConfig || {},
+        output: {
+          ...nitroConfig.rollupConfig?.output || {},
+          sourcemapExcludeSources: false
+          // Make sure to set it (otherwise server sourcemaps will not be generated)
+        }
+      };
+    });
+    nuxt.hook("build:before", () => {
+      nuxt.options.sourcemap = {
+        client: "hidden",
+        server: "hidden"
+      };
     });
-    nuxt.hooks.hook("close", async () => {
+    const outputDir = getOutputDir(nuxt.options.nitro);
+    let isBuildProcess = false;
+    nuxt.hook("nitro:build:public-assets", async () => {
+      isBuildProcess = true;
       try {
-        await spawnLocal("posthog-cli", [...sharedInjectOptions, "--directory", NITRO_OUTPUT_DIRECTORY], {
-          env: cliEnv,
-          cwd: process.cwd(),
-          resolveFrom: resolvedDirname,
-          stdio: "inherit",
-          onBinaryFound: () => {
-          }
-        });
+        await runInject(path.join(outputDir, "public"), options.host, sourcemapsConfig);
       } catch (error) {
-        console.error("PostHog sourcemap inject failed:", error);
+        console.error("Failed to process public sourcemaps:", error);
       }
-      const uploadOptions = [
-        "--host",
-        options.host,
-        "sourcemap",
-        "upload",
-        "--directory",
-        ".output",
-        "--ignore",
-        "**/node_modules/**"
-      ];
+    });
+    nuxt.hook("close", async () => {
+      if (!isBuildProcess) return;
       try {
-        await spawnLocal("posthog-cli", uploadOptions, {
-          env: cliEnv,
-          cwd: process.cwd(),
-          resolveFrom: resolvedDirname,
-          stdio: "inherit",
-          onBinaryFound: () => {
-          }
-        });
+        await runInject(path.join(outputDir, "server"), options.host, sourcemapsConfig);
+        await runUpload(outputDir, options.host, sourcemapsConfig);
       } catch (error) {
-        console.error("PostHog sourcemap upload failed:", error);
+        console.error("Failed to process server sourcemaps:", error);
       }
     });
   }
 });
+async function runInject(directory, host, sourcemapsConfig) {
+  const processOptions = ["--host", host, "sourcemap", "process", "--ignore", "**/node_modules/**"];
+  if (sourcemapsConfig.project) {
+    processOptions.push("--project", sourcemapsConfig.project);
+  }
+  if (sourcemapsConfig.version) {
+    processOptions.push("--version", sourcemapsConfig.version);
+  }
+  await spawnLocal("posthog-cli", [...processOptions, "--directory", directory], {
+    env: {
+      ...process.env,
+      POSTHOG_CLI_ENV_ID: sourcemapsConfig.envId,
+      POSTHOG_CLI_TOKEN: sourcemapsConfig.personalApiKey
+    },
+    cwd: process.cwd(),
+    resolveFrom: resolvedDirname,
+    stdio: "inherit",
+    onBinaryFound: () => {
+    }
+  });
+}
+async function runUpload(directory, host, sourcemapsConfig) {
+  const processOptions = ["--host", host, "sourcemap", "upload", "--ignore", "**/node_modules/**"];
+  if (sourcemapsConfig.deleteAfterUpload ?? true) {
+    processOptions.push("--delete-after");
+  }
+  await spawnLocal("posthog-cli", [...processOptions, "--directory", directory], {
+    env: {
+      ...process.env,
+      POSTHOG_CLI_ENV_ID: sourcemapsConfig.envId,
+      POSTHOG_CLI_TOKEN: sourcemapsConfig.personalApiKey
+    },
+    cwd: process.cwd(),
+    resolveFrom: resolvedDirname,
+    stdio: "inherit",
+    onBinaryFound: () => {
+    }
+  });
+}
+function getOutputDir(nitroConfig) {
+  if (nitroConfig.preset && nitroConfig.preset.includes("vercel")) {
+    return ".vercel/output";
+  }
+  if (nitroConfig.output && nitroConfig.output.dir) {
+    return nitroConfig.output.dir;
+  }
+  return ".output";
+}
 
 export { module as default };

package/dist/runtime/nitro-plugin.js

@@ -4,25 +4,28 @@ import { defineNitroPlugin } from "nitropack/runtime";
 import { useRuntimeConfig } from "#imports";
 export default defineNitroPlugin((nitroApp) => {
   const runtimeConfig = useRuntimeConfig();
-  const host = runtimeConfig.public.posthogHost;
-  const apiKey = runtimeConfig.public.posthogPublicKey;
-  const configOverride = runtimeConfig.public.posthogServerConfig;
-  const debug = runtimeConfig.public.posthogDebug;
-  const { enableExceptionAutocapture, ...restOfConfig } = configOverride;
-  const client = new PostHog(apiKey, {
-    host,
-    ...restOfConfig
+  const posthogCommon = runtimeConfig.public.posthog;
+  const posthogServerConfig = runtimeConfig.posthogServerConfig;
+  const debug = posthogCommon.debug;
+  const client = new PostHog(posthogCommon.publicKey, {
+    host: posthogCommon.host,
+    ...posthogServerConfig
   });
   if (debug) {
     client.debug(true);
   }
-  if (configOverride.enableExceptionAutocapture) {
-    nitroApp.hooks.hook("error", async (error, { event }) => {
-      await client.captureException(error, uuidv7(), {
-        $process_person_profile: false,
-        path: event?.path,
-        method: event?.method
-      });
+  if (posthogServerConfig.enableExceptionAutocapture) {
+    nitroApp.hooks.hook("error", (error, { event }) => {
+      const props = {
+        $process_person_profile: false
+      };
+      if (event?.path) {
+        props.path = event.path;
+      }
+      if (event?.method) {
+        props.method = event.method;
+      }
+      client.captureException(error, uuidv7(), props);
     });
   }
   nitroApp.hooks.hook("close", async () => {

package/dist/runtime/vue-plugin.d.ts

@@ -1,6 +1,6 @@
-declare const _default: import("#app").Plugin<{
+declare const _default: import("nuxt/app").Plugin<{
     posthog: () => import("posthog-js").PostHog;
-}> & import("#app").ObjectPlugin<{
+}> & import("nuxt/app").ObjectPlugin<{
     posthog: () => import("posthog-js").PostHog;
 }>;
 export default _default;

package/dist/runtime/vue-plugin.js

@@ -1,24 +1,33 @@
 import { defineNuxtPlugin, useRuntimeConfig } from "#app";
 import posthog from "posthog-js";
-export default defineNuxtPlugin(() => {
+export default defineNuxtPlugin((nuxtApp) => {
   const runtimeConfig = useRuntimeConfig();
-  const publicApiKey = runtimeConfig.public.posthogPublicKey;
-  const host = runtimeConfig.public.posthogHost;
-  const configOverride = runtimeConfig.public.posthogClientConfig;
-  const debug = runtimeConfig.public.posthogDebug;
+  const posthogCommon = runtimeConfig.public.posthog;
+  const posthogClientConfig = runtimeConfig.public.posthogClientConfig;
   if (!window || posthog.__loaded) {
     return;
   }
-  posthog.init(publicApiKey, {
-    api_host: host,
-    ...configOverride
+  posthog.init(posthogCommon.publicKey, {
+    api_host: posthogCommon.host,
+    ...posthogClientConfig
   });
-  if (debug) {
+  if (posthogCommon.debug) {
     posthog.debug(true);
   }
+  if (autocaptureEnabled(posthogClientConfig)) {
+    nuxtApp.hook("vue:error", (error, info) => {
+      posthog.captureException(error, { info });
+    });
+  }
   return {
     provide: {
       posthog: () => posthog
     }
   };
 });
+function autocaptureEnabled(config) {
+  if (!config) return false;
+  if (typeof config.capture_exceptions === "boolean") return config.capture_exceptions;
+  if (typeof config.capture_exceptions === "object") return config.capture_exceptions.capture_unhandled_errors === true;
+  return false;
+}

package/dist/types.d.mts

@@ -1,3 +1,3 @@
 export { default } from './module.mjs'
 
-export { type ModuleOptions } from './module.mjs'
+export { type ModuleOptions, type PostHogClientConfig, type PostHogCommon, type PostHogServerConfig } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/nuxt",
-  "version": "0.0.27",
+  "version": "1.0.1",
   "description": "Nuxt module for Posthog 🦔",
   "repository": {
     "type": "git",
@@ -20,11 +20,11 @@
     "dist"
   ],
   "dependencies": {
-    "@posthog/cli": "^0.5.2",
+    "@posthog/cli": "^0.5.7",
     "@nuxt/kit": ">=3.7.0",
-    "posthog-node": "5.11.0",
-    "@posthog/core": "1.5.0",
-    "posthog-js": "1.285.1"
+    "posthog-node": "5.11.1",
+    "@posthog/core": "1.5.1",
+    "posthog-js": "1.286.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",