@unproducts/nuxt-posthog 2.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Nuxt Community
+
+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,25 @@
+# @unproducts/nuxt-posthog
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+> [PostHog](https://posthog.com/) module for [Nuxt](https://nuxt.com/)
+
+#### This is a fork of the original [nuxt-posthog](https://github.com/mitjans/nuxt-posthog) with improved runtime config handling. Also upcoming: sourcemaps upload, and logging support.
+
+#### Other Changes
+- Better deps management: posthog clients are peers not underlying dependencies.
+- It is possible to selectively use posthog on either client of server.
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@unproducts/nuxt-posthog/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://npmjs.com/package/@unproducts/nuxt-posthog
+[npm-downloads-src]: https://img.shields.io/npm/dm/@unproducts/nuxt-posthog.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://npmjs.com/package/@unproducts/nuxt-posthog
+[license-src]: https://img.shields.io/npm/l/@unproducts/nuxt-posthog.svg?style=flat&colorA=18181B&colorB=28CF8D
+[license-href]: https://npmjs.com/package/@unproducts/nuxt-posthog
+[nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,74 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { PostHogConfig } from 'posthog-js';
+
+interface ModuleOptions {
+    /**
+     * The PostHog API key
+     * @default process.env.POSTHOG_API_KEY
+     * @example 'phc_1234567890abcdef1234567890abcdef1234567890a'
+     * @type string
+     * @docs https://posthog.com/docs/api
+     */
+    publicKey: string;
+    /**
+     * The PostHog API host
+     * @default process.env.POSTHOG_API_HOST
+     * @example 'https://app.posthog.com'
+     * @type string
+     * @docs https://posthog.com/docs/api
+     */
+    host: string;
+    /**
+     * If set to true, the module will capture page views automatically
+     * @default true
+     * @type boolean
+     * @docs https://posthog.com/docs/product-analytics/capture-events#single-page-apps-and-pageviews
+     */
+    capturePageViews?: boolean;
+    /**
+     * If set to true, the module will capture page leaves automatically
+     * @default true
+     * @type boolean
+     * @docs https://posthog.com/docs/product-analytics/capture-events#single-page-apps-and-pageviews
+     */
+    capturePageLeaves?: boolean;
+    /**
+     * PostHog Client options
+     * @default {
+     *    api_host: process.env.POSTHOG_API_HOST,
+     * }
+     * @type object
+     * @docs https://posthog.com/docs/libraries/js#config
+     */
+    clientOptions?: Partial<PostHogConfig>;
+    /**
+     * If set to true, the module will be disabled (no events will be sent to PostHog).
+     * This is useful for development environments. Directives and components will still be available for you to use.
+     * @default false
+     * @type boolean
+     */
+    disabled?: boolean;
+    /**
+     * If set to true, the module will be enabled on the client side.
+     * @default true
+     * @type boolean
+     */
+    client?: boolean;
+    /**
+     * If set to true, the module will be enabled on the server side.
+     * @default true
+     * @type boolean
+     */
+    server?: boolean;
+    /**
+     * If set to true, PostHog will be proxied through the Nuxt server.
+     * @default false
+     * @type boolean
+     * @docs https://posthog.com/docs/advanced/proxy/nuxt
+     */
+    proxy?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "nuxt-posthog",
+  "configKey": "posthog",
+  "version": "2.0.2",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,89 @@
+import { defineNuxtModule, createResolver, addPlugin, addComponent, addTypeTemplate, addServerPlugin, addServerImports } from '@nuxt/kit';
+import { defu } from 'defu';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-posthog",
+    configKey: "posthog"
+  },
+  defaults: {
+    publicKey: process.env.POSTHOG_API_KEY,
+    host: process.env.POSTHOG_API_HOST,
+    capturePageViews: true,
+    capturePageLeaves: true,
+    disabled: false,
+    client: true,
+    server: true,
+    proxy: false
+  },
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    if (!options.publicKey || !options.host) {
+      options.disabled = true;
+    } else if (!options.disabled) {
+      nuxt.options.runtimeConfig.public.posthog = defu(
+        nuxt.options.runtimeConfig.public.posthog,
+        {
+          publicKey: options.publicKey,
+          host: options.host,
+          capturePageViews: options.capturePageViews,
+          capturePageLeaves: options.capturePageLeaves,
+          clientOptions: options.clientOptions,
+          proxy: options.proxy
+        }
+      );
+      nuxt.options.runtimeConfig.posthog = defu(nuxt.options.runtimeConfig.posthog, {
+        client: !!options.client,
+        server: !!options.server
+      });
+    }
+    const config = nuxt.options.runtimeConfig.public.posthog;
+    if (config && config.proxy) {
+      const url = new URL(config.host);
+      const region = url.hostname.split(".")[0];
+      if (!region) {
+        throw new Error("Invalid PostHog API host when setting proxy");
+      }
+      if (!["eu", "us"].includes(region)) {
+        throw new Error(`Invalid PostHog API host when setting proxy, expected 'us' or 'eu', got '${region}'`);
+      }
+      nuxt.options.routeRules = nuxt.options.routeRules || {};
+      nuxt.options.routeRules["/ingest/ph/static/**"] = {
+        proxy: `https://${region}-assets.i.posthog.com/static/**`
+      };
+      nuxt.options.routeRules["/ingest/ph/**"] = {
+        proxy: `https://${region}.i.posthog.com/**`
+      };
+    }
+    nuxt.hook("imports:dirs", (dirs) => {
+      dirs.push(resolve("./runtime/composables"));
+    });
+    addPlugin(resolve("./runtime/plugins/directives"));
+    addPlugin(resolve("./runtime/plugins/posthog.client"));
+    addPlugin(resolve("./runtime/plugins/posthog.server"));
+    addComponent({
+      filePath: resolve("./runtime/components/PostHogFeatureFlag.vue"),
+      name: "PostHogFeatureFlag"
+    });
+    addTypeTemplate({
+      filename: "types/posthog-directives.d.ts",
+      src: resolve("./runtime/types/directives.d.ts")
+    });
+    addServerPlugin(resolve("./runtime/plugins/nitro"));
+    addServerImports([
+      {
+        from: resolve("./runtime/utils/nitro"),
+        name: "usePostHog"
+      }
+    ]);
+    addTypeTemplate(
+      {
+        filename: "types/posthog-nitro.d.ts",
+        src: resolve("./runtime/types/nitro.d.ts")
+      },
+      { nitro: true }
+    );
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/components/PostHogFeatureFlag.d.vue.ts

@@ -0,0 +1,37 @@
+declare var __VLS_1: {
+    payload: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    match: {
+        default: boolean;
+        required: false;
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    match: {
+        default: boolean;
+        required: false;
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+}>> & Readonly<{}>, {
+    match: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/PostHogFeatureFlag.vue

@@ -0,0 +1,14 @@
+<script setup>
+import { computed } from "vue";
+import usePostHogFeatureFlag from "../composables/usePostHogFeatureFlag";
+const { name, match } = defineProps({
+  name: { type: String, required: true },
+  match: { default: true, required: false, type: [String, Boolean] }
+});
+const { getFeatureFlag } = usePostHogFeatureFlag();
+const featureFlag = computed(() => getFeatureFlag(name));
+</script>
+
+<template>
+  <slot v-if="featureFlag?.value === match" :payload="featureFlag.payload" />
+</template>

package/dist/runtime/components/PostHogFeatureFlag.vue.d.ts

@@ -0,0 +1,37 @@
+declare var __VLS_1: {
+    payload: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    match: {
+        default: boolean;
+        required: false;
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    match: {
+        default: boolean;
+        required: false;
+        type: (StringConstructor | BooleanConstructor)[];
+    };
+}>> & Readonly<{}>, {
+    match: string | boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/composables/usePostHogFeatureFlag.d.ts

@@ -0,0 +1,9 @@
+import type { JsonType } from 'posthog-js';
+declare const _default: () => {
+    isFeatureEnabled: (feature: string) => string | boolean;
+    getFeatureFlag: (feature: string) => {
+        value: string | boolean;
+        payload: JsonType;
+    };
+};
+export default _default;

package/dist/runtime/composables/usePostHogFeatureFlag.js

@@ -0,0 +1,18 @@
+import { useState } from "#app";
+export default () => {
+  const posthogFeatureFlags = useState("ph-feature-flags");
+  const posthogFeatureFlagPayloads = useState("ph-feature-flag-payloads");
+  const isFeatureEnabled = (feature) => {
+    return posthogFeatureFlags.value?.[feature] ?? false;
+  };
+  const getFeatureFlag = (feature) => {
+    return {
+      value: posthogFeatureFlags.value?.[feature] ?? false,
+      payload: posthogFeatureFlagPayloads.value?.[feature]
+    };
+  };
+  return {
+    isFeatureEnabled,
+    getFeatureFlag
+  };
+};

package/dist/runtime/directives/v-posthog-capture.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectDirective } from 'vue';
+export declare const vPostHogCapture: ObjectDirective;

package/dist/runtime/directives/v-posthog-capture.js

@@ -0,0 +1,17 @@
+import { useNuxtApp } from "#app";
+const directive = (el, { value, arg }) => {
+  const nuxtApp = useNuxtApp();
+  const $clientPosthog = nuxtApp.$clientPosthog;
+  if (!$clientPosthog) return;
+  if (el.hasAttribute("posthog-listener")) return;
+  el.setAttribute("posthog-listener", "true");
+  el.addEventListener(arg ?? "click", () => {
+    if (!$clientPosthog) return;
+    if (typeof value === "string") $clientPosthog.capture(value);
+    else $clientPosthog.capture(value.name, value.properties);
+  });
+};
+export const vPostHogCapture = {
+  mounted: directive,
+  updated: directive
+};

package/dist/runtime/plugins/directives.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/directives.js

@@ -0,0 +1,5 @@
+import { vPostHogCapture } from "../directives/v-posthog-capture.js";
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin(({ vueApp }) => {
+  vueApp.directive("posthog-capture", vPostHogCapture);
+});

package/dist/runtime/plugins/nitro.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nitropack/types").NitroAppPlugin;
+export default _default;

package/dist/runtime/plugins/nitro.js

@@ -0,0 +1,12 @@
+import { useRuntimeConfig } from "#imports";
+import { defineNitroPlugin } from "nitropack/runtime";
+import { getCookie } from "h3";
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("request", async (event) => {
+    const config = useRuntimeConfig().public.posthog;
+    const runtimeConfig = useRuntimeConfig().posthog;
+    if (!config || !runtimeConfig.server) return;
+    const distinctId = getCookie(event, "ph-identify");
+    event.context.posthogId = distinctId;
+  });
+});

package/dist/runtime/plugins/posthog.client.d.ts

@@ -0,0 +1,9 @@
+import type { PostHog } from 'posthog-js';
+declare const _default: import("nuxt/app").Plugin<{
+    posthog: "Deprecated: use $clientPosthog instead.";
+    clientPosthog: PostHog | null;
+}> & import("nuxt/app").ObjectPlugin<{
+    posthog: "Deprecated: use $clientPosthog instead.";
+    clientPosthog: PostHog | null;
+}>;
+export default _default;

package/dist/runtime/plugins/posthog.client.js

@@ -0,0 +1,60 @@
+import { defineNuxtPlugin, useCookie, useRouter, useRuntimeConfig, useState } from "#app";
+import { defu } from "defu";
+export default defineNuxtPlugin({
+  name: "posthog",
+  enforce: "pre",
+  setup: async () => {
+    console.log("setup posthog client");
+    const runtimeConfig = useRuntimeConfig().posthog;
+    const config = useRuntimeConfig().public.posthog;
+    if (!config || !runtimeConfig.client)
+      return {
+        provide: {
+          posthog: "Deprecated: use $clientPosthog instead.",
+          clientPosthog: null
+        }
+      };
+    const posthog = (await import("posthog-js")).posthog;
+    const posthogFeatureFlags = useState("ph-feature-flags");
+    const posthogFeatureFlagPayloads = useState("ph-feature-flag-payloads");
+    const clientOptions = defu(config.clientOptions ?? {}, {
+      api_host: config.host,
+      capture_pageview: false,
+      capture_pageleave: !!config.capturePageLeaves,
+      bootstrap: {
+        featureFlags: posthogFeatureFlags.value,
+        featureFlagPayloads: posthogFeatureFlagPayloads.value
+      }
+    });
+    if (config.proxy && config.host) {
+      const url = new URL(config.host);
+      const region = url.hostname.split(".")[0];
+      clientOptions.ui_host = `https://${region}.posthog.com`;
+      clientOptions.api_host = `${window.location.origin}/ingest/ph`;
+    }
+    const posthogClient = posthog.init(config.publicKey, clientOptions);
+    const identity = useCookie("ph-identify");
+    identity.value = posthog.get_distinct_id();
+    if (config.capturePageViews) {
+      const router = useRouter();
+      router.afterEach((to) => {
+        posthog.capture("$pageview", {
+          current_url: to.fullPath
+        });
+      });
+    }
+    posthog.onFeatureFlags((flags, featureFlags) => {
+      posthogFeatureFlags.value = featureFlags;
+      posthogFeatureFlagPayloads.value = flags.reduce((acc, flag) => {
+        acc[flag] = posthog.getFeatureFlagPayload(flag);
+        return acc;
+      }, {});
+    });
+    return {
+      provide: {
+        clientPosthog: posthogClient ? posthogClient : null,
+        posthog: "Deprecated: use $clientPosthog instead."
+      }
+    };
+  }
+});

package/dist/runtime/plugins/posthog.server.d.ts

@@ -0,0 +1,7 @@
+import type { PostHog } from 'posthog-node';
+declare const _default: import("nuxt/app").Plugin<{
+    serverPosthog: PostHog | null;
+}> & import("nuxt/app").ObjectPlugin<{
+    serverPosthog: PostHog | null;
+}>;
+export default _default;

package/dist/runtime/plugins/posthog.server.js

@@ -0,0 +1,27 @@
+import { defineNuxtPlugin, useCookie, useRuntimeConfig, useState } from "#app";
+export default defineNuxtPlugin({
+  name: "posthog-server",
+  enforce: "pre",
+  setup: async () => {
+    const config = useRuntimeConfig().public.posthog;
+    const runtimeConfig = useRuntimeConfig().posthog;
+    if (!config || !runtimeConfig.server)
+      return {
+        provide: {
+          serverPosthog: null
+        }
+      };
+    const PostHog = (await import("posthog-node")).PostHog;
+    const posthog = new PostHog(config.publicKey, { host: config.host });
+    await posthog.reloadFeatureFlags();
+    const identity = useCookie("ph-identify", { default: () => "" });
+    const { featureFlags, featureFlagPayloads } = await posthog.getAllFlagsAndPayloads(identity.value);
+    useState("ph-feature-flags", () => featureFlags);
+    useState("ph-feature-flag-payloads", () => featureFlagPayloads);
+    return {
+      provide: {
+        serverPosthog: posthog
+      }
+    };
+  }
+});

package/dist/runtime/types/directives.d.ts

@@ -0,0 +1,27 @@
+import type { ObjectDirective } from 'vue';
+import type { Property } from 'posthog-js';
+
+declare global {
+  export interface PostHogCaptureEvent {
+    /**
+     * Event name
+     *
+     * @docs https://posthog.com/docs/product-analytics/capture-events
+     */
+    name: string;
+
+    /**
+     * Event properties
+     *
+     * @docs https://posthog.com/docs/product-analytics/capture-events#setting-event-properties
+     */
+    properties?: Record<string, Property>;
+  }
+}
+
+declare module 'vue' {
+  export interface ComponentCustomProperties {
+    vPosthogCapture: ObjectDirective<HTMLElement, PostHogCaptureEvent | string>;
+  }
+}
+export {};

package/dist/runtime/types/index.d.ts

@@ -0,0 +1,13 @@
+import type { ModuleOptions } from '../../module';
+
+declare module '@nuxt/schema' {
+  interface RuntimeConfig {
+    posthog: Pick<ModuleOptions, 'client' | 'server'>;
+  }
+  interface PublicRuntimeConfig {
+    posthog?: Pick<
+      ModuleOptions,
+      'publicKey' | 'host' | 'capturePageViews' | 'capturePageLeaves' | 'clientOptions' | 'proxy'
+    >;
+  }
+}

package/dist/runtime/types/nitro.d.ts

@@ -0,0 +1,7 @@
+declare module 'h3' {
+  interface H3EventContext {
+    posthogId?: string;
+  }
+}
+
+export {};

package/dist/runtime/utils/nitro.d.ts

@@ -0,0 +1,2 @@
+import type { PostHog } from 'posthog-node';
+export declare const usePostHog: () => Promise<PostHog | undefined>;

package/dist/runtime/utils/nitro.js

@@ -0,0 +1,12 @@
+import { useRuntimeConfig } from "#imports";
+let posthog = null;
+export const usePostHog = async () => {
+  const config = useRuntimeConfig().public.posthog;
+  const runtimeConfig = useRuntimeConfig().posthog;
+  if (!config || !runtimeConfig.server) return;
+  if (!posthog) {
+    const PostHog = (await import("posthog-node")).PostHog;
+    posthog = new PostHog(config.publicKey, { host: config.host });
+  }
+  return posthog;
+};

package/dist/types.d.mts

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

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@unproducts/nuxt-posthog",
+  "version": "2.0.2",
+  "description": "PostHog module for nuxt",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unproducts/nuxt-posthog-2.git"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "resolutions": {
+    "unimport": "4.1.1"
+  },
+  "scripts": {
+    "prepack": "nuxt-module-build build",
+    "postinstall": "nuxt prepare",
+    "dev": "nuxi dev playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^4.2.1",
+    "defu": "^6.1.4"
+  },
+  "peerDependencies": {
+    "posthog-js": "^1.252.0",
+    "posthog-node": "5.14.0"
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint-config": "^1.4.1",
+    "@nuxt/module-builder": "^1.0.1",
+    "@nuxt/schema": "^4.2.1",
+    "@nuxt/test-utils": "^3.19.1",
+    "@types/node": "^24.0.1",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-prettier": "^5.4.1",
+    "nuxt": "^4.2.1",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.14"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "better-sqlite3"
+    ],
+    "ignoredBuiltDependencies": [
+      "vue-demi"
+    ]
+  },
+  "packageManager": "pnpm@10.12.1"
+}