nuxt-yandex-metrika 1.3.1 → 2.0.1

package/README.md

@@ -31,7 +31,7 @@ npm install --save-dev nuxt-yandex-metrika
 
 ```ts
 export default defineNuxtConfig({
-  modules: ["nuxt-yandex-metrika"],
+	modules: ['nuxt-yandex-metrika']
 });
 ```
 
@@ -56,7 +56,7 @@ export default defineNuxtConfig({
 ## Options
 
 | Name                | Default value | Type    | Description                                                                                                                                      |
-|---------------------|---------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| ------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | accurateTrackBounce | true          | Boolean | Number                                                                                                                                           | Accurate bounce rate The parameter can accept these values: true — Enable the accurate bounce rate, with a non-bounce event registered after 15000 ms (15 s). false — Don't enable the accurate bounce rate. <N> (integer) — Enable the accurate bounce rate. Non-bounce events are recorded after <N> ms. |
 | childIframe         | false         | Boolean | Whether to record iframe contents without a tag in a child window                                                                                |
 | clickmap            | true          | Boolean | Whether to collect data for a click map                                                                                                          |
@@ -75,25 +75,21 @@ For more information:
 
 - [Documentation for Ya.Metrika](https://yandex.com/support/metrica/code/counter-initialize.html)
 
-## Usage
-
-| Component Name              | Auto Imported | Description                      |
-|-----------------------------|---------------|----------------------------------|
-| `<YandexMetrikaInformer />` | ✅             | Shows informer                   |
-| `<YandexVerification />`    | ✅             | Verification in Yandex Webmaster |
 
 ### Methods
 
 ```vue
-<template>
-    <button @click.prevent.stop="reachGoal('click', {})">click</button>
-</template>
-
 <script setup lang="ts">
-import { useYandexMetrika } from "#imports";
+import { useYandexMetrika } from '#imports';
 
 const { reachGoal } = useYandexMetrika();
 </script>
+
+<template>
+	<button @click.prevent.stop="reachGoal('click', {})">
+		click
+	</button>
+</template>
 ```
 
 - [For more information](https://yandex.com/support/metrica/objects/method-reference.html?lang=en)

package/dist/module.d.mts

@@ -1,15 +1,75 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { InitParameters } from '../dist/runtime/yandex-metrika/index.js';
 
-type YandexMetrikaModuleOptions = {
+declare const _default: _nuxt_schema.NuxtModule<{
     id: string;
     debug: boolean;
+    delay: number;
     cdn: boolean;
+    verification?: string | null | undefined;
+    options?: {
+        accurateTrackBounce?: number | boolean | undefined;
+        childIframe?: boolean | undefined;
+        clickmap?: boolean | undefined;
+        ecommerce?: string | boolean | any[] | undefined;
+        params?: ({
+            order_price?: number | undefined;
+            currency?: string | undefined;
+        } & {
+            [key: string]: unknown;
+        })[] | ({
+            order_price?: number | undefined;
+            currency?: string | undefined;
+        } & {
+            [key: string]: unknown;
+        }) | undefined;
+        userParams?: ({
+            UserID?: number | undefined;
+        } & {
+            [key: string]: unknown;
+        }) | undefined;
+        trackHash?: boolean | undefined;
+        trackLinks?: boolean | undefined;
+        trustedDomain?: string[] | undefined;
+        type?: number | undefined;
+        webvisor?: boolean | undefined;
+        triggerEvent?: boolean | undefined;
+        sendTitle?: boolean | undefined;
+    } | undefined;
+}, {
+    id: string;
+    debug: boolean;
     delay: number;
-    verification: null | string;
-    options: Partial<InitParameters>;
-};
-
-declare const _default: _nuxt_schema.NuxtModule<YandexMetrikaModuleOptions, YandexMetrikaModuleOptions, false>;
+    cdn: boolean;
+    verification?: string | null | undefined;
+    options?: {
+        accurateTrackBounce?: number | boolean | undefined;
+        childIframe?: boolean | undefined;
+        clickmap?: boolean | undefined;
+        ecommerce?: string | boolean | any[] | undefined;
+        params?: ({
+            order_price?: number | undefined;
+            currency?: string | undefined;
+        } & {
+            [key: string]: unknown;
+        })[] | ({
+            order_price?: number | undefined;
+            currency?: string | undefined;
+        } & {
+            [key: string]: unknown;
+        }) | undefined;
+        userParams?: ({
+            UserID?: number | undefined;
+        } & {
+            [key: string]: unknown;
+        }) | undefined;
+        trackHash?: boolean | undefined;
+        trackLinks?: boolean | undefined;
+        trustedDomain?: string[] | undefined;
+        type?: number | undefined;
+        webvisor?: boolean | undefined;
+        triggerEvent?: boolean | undefined;
+        sendTitle?: boolean | undefined;
+    } | undefined;
+}, false>;
 
 export { _default as default };

package/dist/module.json

@@ -2,9 +2,9 @@
   "name": "nuxt-yandex-metrika",
   "configKey": "yandexMetrika",
   "compatibility": {
-    "nuxt": ">=3.0.0"
+    "nuxt": ">=4.0.0"
   },
-  "version": "1.3.1",
+  "version": "2.0.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,4 +1,4 @@
-import { defineNuxtModule, createResolver, addPlugin, addComponentsDir, addImports } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addPlugin, addImports } from '@nuxt/kit';
 import { defu } from 'defu';
 
 const module$1 = defineNuxtModule({
@@ -6,10 +6,14 @@ const module$1 = defineNuxtModule({
     name: "nuxt-yandex-metrika",
     configKey: "yandexMetrika",
     compatibility: {
-      nuxt: ">=3.0.0"
+      nuxt: ">=4.0.0"
     }
   },
-  // Default configuration options of the Nuxt module
+  moduleDependencies() {
+    return {
+      "@nuxt/scripts": {}
+    };
+  },
   defaults: {
     id: "xxx",
     debug: import.meta.env.NODE_ENV !== "production",
@@ -20,7 +24,6 @@ const module$1 = defineNuxtModule({
       accurateTrackBounce: true,
       childIframe: true,
       clickmap: true,
-      defer: false,
       ecommerce: false,
       trackHash: false,
       trackLinks: true,
@@ -29,7 +32,7 @@ const module$1 = defineNuxtModule({
       sendTitle: true
     }
   },
-  setup(options, nuxt) {
+  async setup(options, nuxt) {
     nuxt.options.runtimeConfig.public.yandexMetrika = defu(
       nuxt.options.runtimeConfig.public.yandexMetrika ?? {},
       options,
@@ -58,13 +61,10 @@ const module$1 = defineNuxtModule({
       mode: "all",
       src: resolver.resolve("./runtime/plugin")
     });
-    void addComponentsDir({
-      path: resolver.resolve("runtime/components")
-    });
     addImports({
       name: "useYandexMetrika",
       as: "useYandexMetrika",
-      from: resolver.resolve("runtime/composables/useYandexMetrika")
+      from: resolver.resolve("runtime/composable")
     });
   }
 });

package/dist/runtime/composable.d.ts

@@ -0,0 +1,3 @@
+import type { YandexMetrikaApi } from './yandex-metrika/index.js';
+export declare function useYandexMetrikaScript<T extends YandexMetrikaApi>(): import("#nuxt-scripts/types").UseScriptContext<T>;
+export declare function useYandexMetrika(): YandexMetrikaApi;

package/dist/runtime/composable.js

@@ -0,0 +1,58 @@
+import { useRuntimeConfig } from "#app";
+import { useHead, useScriptTriggerIdleTimeout } from "#imports";
+import { useRegistryScript } from "#nuxt-scripts/utils";
+import { YandexMetrikaSchemeOptions } from "./scheme.js";
+import { metrika } from "./yandex-metrika/index.js";
+export function useYandexMetrikaScript() {
+  return useRegistryScript(
+    "yandex-metrika",
+    (config) => {
+      const { id, cdn, delay, debug, verification, options = {} } = config;
+      const api = metrika(id, debug);
+      if (import.meta.dev) {
+        useHead({
+          script: [
+            {
+              innerHTML: "window.ym=window.ym||function(){(window.ym.a=window.ym.a||[]).push(arguments)};window.ym.l=(new Date).getTime();"
+            }
+          ]
+        });
+      } else {
+        useHead({
+          noscript: [
+            {
+              innerHTML: `<div><img src="https://mc.yandex.ru/watch/${id}" style="position:absolute; left:-9999px;" alt="" />`
+            }
+          ]
+        });
+      }
+      if (verification) {
+        useHead({
+          meta: [{ name: "yandex-verification", content: verification }]
+        });
+      }
+      return {
+        scriptInput: {
+          src: cdn ? "https://cdn.jsdelivr.net/npm/yandex-metrica-watch/tag.js" : "https://mc.yandex.ru/metrika/tag.js"
+        },
+        schema: YandexMetrikaSchemeOptions,
+        scriptOptions: {
+          key: "yandex-metrika",
+          bundle: false,
+          tagDuplicateStrategy: "replace",
+          trigger: delay ? useScriptTriggerIdleTimeout({ timeout: delay }) : void 0,
+          use() {
+            return api;
+          }
+        },
+        clientInit: import.meta.server ? void 0 : () => {
+          api.init(options);
+        }
+      };
+    },
+    useRuntimeConfig().public.yandexMetrika
+  );
+}
+export function useYandexMetrika() {
+  return useYandexMetrikaScript().proxy;
+}

package/dist/runtime/plugin.d.ts

@@ -1,7 +1,2 @@
-import { YandexMetrika } from './yandex-metrika/index.js';
-declare const _default: import("#app").Plugin<{
-    yandexMetrika: YandexMetrika;
-}> & import("#app").ObjectPlugin<{
-    yandexMetrika: YandexMetrika;
-}>;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugin.js

@@ -1,62 +1,10 @@
-import { defineNuxtPlugin, useRouter, useRuntimeConfig } from "#app";
-import { useHead } from "#imports";
-import { Methods, YandexMetrika } from "./yandex-metrika/index.js";
+import { defineNuxtPlugin } from "#app";
+import { useRouter } from "#imports";
+import { useYandexMetrikaScript } from "./composable.js";
 export default defineNuxtPlugin({
   parallel: true,
   setup() {
-    const config = useRuntimeConfig().public.yandexMetrika;
-    const { id, cdn = false, delay = 0, debug, verification = null, options = {} } = config;
-    if (import.meta.dev) {
-      useHead({
-        script: [
-          {
-            key: "yandex-metrika-ym",
-            innerHTML: `window.ym=window.ym||function(){(window.ym.a=window.ym.a||[]).push(arguments)};window.ym.l=(new Date).getTime();`
-          }
-        ]
-      });
-    } else {
-      useHead({
-        noscript: [
-          {
-            key: "yandex-metrika-noscript",
-            innerHTML: `<div><img src="https://mc.yandex.ru/watch/${id}" style="position:absolute; left:-9999px;" alt="" />`
-          }
-        ]
-      });
-      if (delay && delay > 0) {
-        if (import.meta.client) {
-          setTimeout(() => {
-            const script = document.createElement("script");
-            script.defer = true;
-            script.src = YandexMetrika.src(cdn);
-            document.head.append(script);
-          }, delay);
-        }
-      } else {
-        useHead({
-          script: [
-            {
-              key: "yandex-metrika",
-              innerHTML: `(function(m,e,t,r,i,k,a){m[i]=m[i]||function(){(m[i].a=m[i].a||[]).push(arguments)}; m[i].l=1*new Date(); for (var j = 0; j < document.scripts.length; j++) {if (document.scripts[j].src === r) { return; }} k=e.createElement(t),a=e.getElementsByTagName(t)[0],k.async=1,k.src=r,a.parentNode.insertBefore(k,a)}) (window, document, "script", "${YandexMetrika.src(
-                cdn
-              )}", "ym");`
-            }
-          ]
-        });
-      }
-    }
-    useHead({
-      script: [
-        {
-          key: "yandex-metrika-init",
-          innerHTML: `ym("${id}","${Methods.Init}", ${JSON.stringify(options)});`
-        }
-      ]
-    });
-    const yandexMetrika = new YandexMetrika(id);
-    yandexMetrika.debug = debug;
-    yandexMetrika.verification = verification;
+    const { proxy } = useYandexMetrikaScript();
     if (import.meta.client) {
       let ready = false;
       const router = useRouter();
@@ -67,22 +15,10 @@ export default defineNuxtPlugin({
         if (!ready) {
           return;
         }
-        yandexMetrika.hit(to.fullPath, {
+        proxy.hit(to.fullPath, {
           referer: from.fullPath
         });
       });
     }
-    return {
-      provide: {
-        yandexMetrika: new Proxy(yandexMetrika, {
-          get(target, name) {
-            if (typeof target[name] === "function") {
-              return target[name].bind(target);
-            }
-            return target[name];
-          }
-        })
-      }
-    };
   }
 });

package/dist/runtime/scheme.d.ts

@@ -0,0 +1,30 @@
+export declare const YandexMetrikaSchemeOptions: import("valibot").ObjectSchema<{
+    readonly id: import("valibot").StringSchema<undefined>;
+    readonly debug: import("valibot").BooleanSchema<undefined>;
+    readonly delay: import("valibot").NumberSchema<undefined>;
+    readonly cdn: import("valibot").BooleanSchema<undefined>;
+    readonly verification: import("valibot").NullishSchema<import("valibot").StringSchema<undefined>, undefined>;
+    readonly options: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+        readonly accurateTrackBounce: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").NumberSchema<undefined>, import("valibot").BooleanSchema<undefined>], undefined>, undefined>;
+        readonly childIframe: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly clickmap: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly ecommerce: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").StringSchema<undefined>, import("valibot").BooleanSchema<undefined>, import("valibot").ArraySchema<import("valibot").AnySchema, undefined>], undefined>, undefined>;
+        readonly params: import("valibot").OptionalSchema<import("valibot").UnionSchema<[import("valibot").ArraySchema<import("valibot").LooseObjectSchema<{
+            readonly order_price: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            readonly currency: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, import("valibot").LooseObjectSchema<{
+            readonly order_price: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+            readonly currency: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>], undefined>, undefined>;
+        readonly userParams: import("valibot").OptionalSchema<import("valibot").LooseObjectSchema<{
+            readonly UserID: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        readonly trackHash: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly trackLinks: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly trustedDomain: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+        readonly type: import("valibot").OptionalSchema<import("valibot").NumberSchema<undefined>, undefined>;
+        readonly webvisor: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly triggerEvent: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        readonly sendTitle: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;

package/dist/runtime/scheme.js

@@ -0,0 +1,41 @@
+import { any, array, boolean, looseObject, nullish, number, object, optional, string, union } from "valibot";
+const options = object({
+  accurateTrackBounce: optional(union([number(), boolean()])),
+  childIframe: optional(boolean()),
+  clickmap: optional(boolean()),
+  ecommerce: optional(union([string(), boolean(), array(any())])),
+  params: optional(
+    union([
+      array(
+        looseObject({
+          order_price: optional(number()),
+          currency: optional(string())
+        })
+      ),
+      looseObject({
+        order_price: optional(number()),
+        currency: optional(string())
+      })
+    ])
+  ),
+  userParams: optional(
+    looseObject({
+      UserID: optional(number())
+    })
+  ),
+  trackHash: optional(boolean()),
+  trackLinks: optional(boolean()),
+  trustedDomain: optional(array(string())),
+  type: optional(number()),
+  webvisor: optional(boolean()),
+  triggerEvent: optional(boolean()),
+  sendTitle: optional(boolean())
+});
+export const YandexMetrikaSchemeOptions = object({
+  id: string(),
+  debug: boolean(),
+  delay: number(),
+  cdn: boolean(),
+  verification: nullish(string()),
+  options: optional(options)
+});

package/dist/runtime/yandex-metrika/index.d.ts

@@ -1,2 +1,2 @@
+export { metrika, type YandexMetrikaApi } from './metrika.js';
 export * from './types.js';
-export { YandexMetrika } from './YandexMetrika.js';

package/dist/runtime/yandex-metrika/index.js

@@ -1,2 +1,2 @@
+export { metrika } from "./metrika.js";
 export * from "./types.js";
-export { YandexMetrika } from "./YandexMetrika.js";

package/dist/runtime/yandex-metrika/metrika.d.ts

@@ -0,0 +1,3 @@
+import type { YandexMetrikaApi } from './types.js';
+export * from './types.js';
+export declare function metrika(id: string, debug?: boolean): YandexMetrikaApi;

package/dist/runtime/yandex-metrika/metrika.js

@@ -0,0 +1,54 @@
+import { consola } from "consola";
+import { Methods } from "./types.js";
+export * from "./types.js";
+export function metrika(id, debug = false) {
+  function call(type, ...args) {
+    if (debug) {
+      consola.info(`[yandex-metrika] ${type}`, ...args);
+    }
+    if (typeof window !== "undefined" && window.ym) {
+      window.ym(id, type, ...args);
+    }
+  }
+  return {
+    init(options = {}) {
+      call(Methods.Init, ...arguments);
+    },
+    addFileExtension(extensions) {
+      call(Methods.AddFileExtension, ...arguments);
+    },
+    extLink(url, options = {}) {
+      call(Methods.ExtLink, ...arguments);
+    },
+    file(url, options) {
+      call(Methods.File, ...arguments);
+    },
+    firstPartyParams(people) {
+      call(Methods.FirstPartyParams, ...arguments);
+    },
+    firstPartyParamsHashed(people) {
+      call(Methods.FirstPartyParamsHashed, ...arguments);
+    },
+    getClientID(cb) {
+      call(Methods.GetClientID, ...arguments);
+    },
+    hit(url = "", options) {
+      call(Methods.Hit, ...arguments);
+    },
+    notBounce(options = {}) {
+      call(Methods.NotBounce, ...arguments);
+    },
+    params(params = {}) {
+      call(Methods.Params, ...arguments);
+    },
+    reachGoal(target, params, callback, ctx) {
+      call(Methods.ReachGoal, ...arguments);
+    },
+    setUserID(userId) {
+      call(Methods.SetUserID, ...arguments);
+    },
+    userParams(params = {}) {
+      call(Methods.UserParams, ...arguments);
+    }
+  };
+}

package/dist/runtime/yandex-metrika/types.d.ts

@@ -19,7 +19,6 @@ export interface InitParameters {
     accurateTrackBounce?: boolean | number;
     childIframe?: boolean;
     clickmap?: boolean;
-    defer?: boolean;
     ecommerce?: boolean | string | any[];
     params?: VisitParameters | VisitParameters[];
     userParams?: UserParameters;
@@ -29,7 +28,7 @@ export interface InitParameters {
     type?: number;
     webvisor?: boolean;
     triggerEvent?: boolean;
-    sendTitle: boolean;
+    sendTitle?: boolean;
 }
 export interface HitOptions<CTX> {
     callback?: (this: CTX) => void;
@@ -52,21 +51,33 @@ export interface People {
         country?: string;
     };
 }
-export declare const enum Methods {
-    Init = "init",
-    AddFileExtension = "addFileExtension",
-    ExtLink = "extLink",
-    File = "file",
-    FirstPartyParams = "firstPartyParams",
-    FirstPartyParamsHashed = "firstPartyParamsHashed",
-    GetClientID = "getClientID",
-    Hit = "hit",
-    NotBounce = "notBounce",
-    Params = "params",
-    ReachGoal = "reachGoal",
-    SetUserID = "setUserID",
-    UserParams = "userParams"
-}
-export type Events = {
-    [key in Methods]: (...args: any[]) => void;
+export declare const Methods: {
+    readonly Init: "init";
+    readonly AddFileExtension: "addFileExtension";
+    readonly ExtLink: "extLink";
+    readonly File: "file";
+    readonly FirstPartyParams: "firstPartyParams";
+    readonly FirstPartyParamsHashed: "firstPartyParamsHashed";
+    readonly GetClientID: "getClientID";
+    readonly Hit: "hit";
+    readonly NotBounce: "notBounce";
+    readonly Params: "params";
+    readonly ReachGoal: "reachGoal";
+    readonly SetUserID: "setUserID";
+    readonly UserParams: "userParams";
 };
+export interface YandexMetrikaApi {
+    init: (options: Partial<InitParameters>) => void;
+    addFileExtension: (extensions?: string | string[]) => void;
+    extLink: <CTX>(url: string, options: Omit<HitOptions<CTX>, 'referer'>) => void;
+    file: <CTX>(url: string, options?: HitOptions<CTX>) => void;
+    firstPartyParams: (people: People) => void;
+    firstPartyParamsHashed: (people: People) => void;
+    getClientID: (cb: (clientID: number) => void) => void;
+    hit: <CTX>(url: string, options?: HitOptions<CTX>) => void;
+    notBounce: <CTX>(options: Pick<HitOptions<CTX>, 'ctx' | 'callback'>) => void;
+    params: (params: VisitParameters) => void;
+    reachGoal: <CTX>(target: string, params: VisitParameters, callback?: (this: CTX) => void, ctx?: CTX) => void;
+    setUserID: (userId: string) => void;
+    userParams: (params: UserParameters) => void;
+}

package/dist/runtime/yandex-metrika/types.js

@@ -1,16 +1,15 @@
-export var Methods = /* @__PURE__ */ ((Methods2) => {
-  Methods2["Init"] = "init";
-  Methods2["AddFileExtension"] = "addFileExtension";
-  Methods2["ExtLink"] = "extLink";
-  Methods2["File"] = "file";
-  Methods2["FirstPartyParams"] = "firstPartyParams";
-  Methods2["FirstPartyParamsHashed"] = "firstPartyParamsHashed";
-  Methods2["GetClientID"] = "getClientID";
-  Methods2["Hit"] = "hit";
-  Methods2["NotBounce"] = "notBounce";
-  Methods2["Params"] = "params";
-  Methods2["ReachGoal"] = "reachGoal";
-  Methods2["SetUserID"] = "setUserID";
-  Methods2["UserParams"] = "userParams";
-  return Methods2;
-})(Methods || {});
+export const Methods = {
+  Init: "init",
+  AddFileExtension: "addFileExtension",
+  ExtLink: "extLink",
+  File: "file",
+  FirstPartyParams: "firstPartyParams",
+  FirstPartyParamsHashed: "firstPartyParamsHashed",
+  GetClientID: "getClientID",
+  Hit: "hit",
+  NotBounce: "notBounce",
+  Params: "params",
+  ReachGoal: "reachGoal",
+  SetUserID: "setUserID",
+  UserParams: "userParams"
+};

package/package.json

@@ -1,69 +1,86 @@
 {
-  "name": "nuxt-yandex-metrika",
-  "version": "1.3.1",
-  "description": "Add Yandex Metrika to your Nuxt 3 application.",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/TakNePoidet/nuxt-yandex-metrika.git"
-  },
-  "homepage": "TakNePoidet/nuxt-yandex-metrika",
-  "license": "MIT",
-  "type": "module",
-  "author": {
-    "name": "TakNePoidet <https://taknepoidet.xyz/>",
-    "url": "https://github.com/TakNePoidet"
-  },
-  "exports": {
-    ".": {
-      "types": "./dist/types.d.mts",
-      "import": "./dist/module.mjs"
-    }
-  },
-  "main": "./dist/module.mjs",
-  "types": "./dist/types.d.mts",
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "@nuxt/kit": "^4.2.2",
-    "chalk": "^5.6.2",
-    "defu": "^6.1.4"
-  },
-  "devDependencies": {
-    "@nuxt/devtools": "latest",
-    "@nuxt/eslint-config": "^1.12.1",
-    "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.2.2",
-    "@poidet/prettier": "^0.8.4",
-    "@types/node": "^25.0.3",
-    "changelogen": "^0.6.2",
-    "eslint": "^9.39.2",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.2.7",
-    "nuxt": "^4.2.2",
-    "prettier": "^3.7.4",
-    "typescript": "5.9.3",
-    "vue-tsc": "^3.2.1"
-  },
-  "lint-staged": {
-    "**/*.(ts|vue)": [
-      "eslint --fix",
-      "git add"
-    ],
-    "**/*.*": [
-      "prettier --write",
-      "git add"
-    ]
-  },
-  "scripts": {
-    "dev": "nuxi dev playground",
-    "dev:build": "nuxi build playground build",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-    "release": "npm run lint && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
-    "prettier": "prettier --write .",
-    "lint": "eslint --fix ."
-  }
-}
+	"name": "nuxt-yandex-metrika",
+	"type": "module",
+	"version": "2.0.1",
+	"packageManager": "pnpm@10.26.2",
+	"description": "Add Yandex Metrika to your Nuxt 4 application.",
+	"author": {
+		"name": "TakNePoidet <https://taknepoidet.xyz/>",
+		"url": "https://github.com/TakNePoidet"
+	},
+	"license": "MIT",
+	"homepage": "TakNePoidet/nuxt-yandex-metrika",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/TakNePoidet/nuxt-yandex-metrika.git"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/types.d.mts",
+			"import": "./dist/module.mjs"
+		}
+	},
+	"main": "./dist/module.mjs",
+	"types": "./dist/types.d.mts",
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"prepack": "nuxt-module-build build",
+		"dev": "nuxi dev playground",
+		"dev:build": "nuxi build playground build",
+		"dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
+		"release": "pnpm run lint && npm run prepack && changelogen --release --major && npm publish && git push --follow-tags",
+		"test:type": "tsc --noEmit",
+		"test": "pnpm run lint && pnpm run test:type",
+		"lint": "pnpm run lint:code && pnpm run lint:format",
+		"lint:code": "eslint --cache --cache-strategy content \"**/*.ts\"",
+		"lint:format": "prettier --check --cache --cache-strategy content \"!**/*.{ts,vue}\" .",
+		"fix": "pnpm run fix:code && pnpm run fix:format",
+		"fix:code": "eslint --fix --cache --cache-strategy content \"**/*.ts\"",
+		"fix:format": "prettier --cache --cache-strategy content --write \"!**/*.{ts,vue}\" .",
+		"prepare": "husky install"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"@nuxt/scripts": "^0.13.2"
+	},
+	"dependencies": {
+		"@nuxt/kit": "^4.2.2",
+		"@prleasing/utility": "^5.0.1",
+		"consola": "^3.4.2",
+		"defu": "^6.1.4",
+		"valibot": "^1.2.0"
+	},
+	"devDependencies": {
+		"@nuxt/devtools": "^3.1.1",
+		"@nuxt/eslint-config": "^1.12.1",
+		"@nuxt/module-builder": "^1.0.2",
+		"@nuxt/schema": "^4.2.2",
+		"@poidet/prettier": "^0.8.4",
+		"@prleasing/eslint": "^5.0.1",
+		"@prleasing/prettier": "^5.0.1",
+		"@types/node": "^25.0.3",
+		"changelogen": "^0.6.2",
+		"eslint": "^9.39.2",
+		"eslint-plugin-format": "^1.1.0",
+		"husky": "^9.1.7",
+		"lint-staged": "^16.2.7",
+		"nuxt": "^4.2.2",
+		"prettier": "^3.7.4",
+		"typescript": "5.9.3",
+		"vue-tsc": "^3.2.1"
+	},
+	"lint-staged": {
+		"**/*.(ts|vue)": [
+			"eslint --fix",
+			"git add"
+		],
+		"**/*.*": [
+			"prettier --write",
+			"git add"
+		]
+	}
+}

package/dist/runtime/components/yandex-metrika-informer.d.vue.ts

@@ -1,3 +0,0 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/yandex-metrika-informer.vue

@@ -1,19 +0,0 @@
-<script setup>
-import { useYandexMetrika } from "../composables/useYandexMetrika";
-const { id } = useYandexMetrika();
-</script>
-
-<template>
-	<!-- Yandex.Metrika informer -->
-	<a :href="`https://metrika.yandex.ru/stat/?id=${id}&amp;from=informer`" target="_blank" rel="nofollow"
-		><img
-			:src="`https://informer.yandex.ru/informer/${id}/3_1_FFFFFFFF_EFEFEFFF_0_pageviews`"
-			style="width: 88px; height: 31px; border: 0"
-			alt="Яндекс.Метрика"
-			title="Яндекс.Метрика: данные за сегодня (просмотры, визиты и уникальные посетители)"
-			class="ym-advanced-informer"
-			:data-cid="id"
-			data-lang="ru"
-	></a>
-	<!-- /Yandex.Metrika informer -->
-</template>

package/dist/runtime/components/yandex-metrika-informer.vue.d.ts

@@ -1,3 +0,0 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/yandex-verification.d.vue.ts

@@ -1,3 +0,0 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

package/dist/runtime/components/yandex-verification.vue

@@ -1,12 +0,0 @@
-<script setup>
-import chalk from "chalk";
-import { useYandexMetrika } from "../composables/useYandexMetrika";
-const { verification } = useYandexMetrika();
-if (!verification) {
-  console.error(`${chalk.bgRed(chalk.black("[yandex-metrika]"))} ${chalk.red("Verification key not found")}`);
-}
-</script>
-
-<template>
-	<Meta v-if="verification" name="yandex-verification" :content="verification" />
-</template>

package/dist/runtime/components/yandex-verification.vue.d.ts

@@ -1,3 +0,0 @@
-declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: typeof __VLS_export;
-export default _default;

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

@@ -1,2 +0,0 @@
-import type { YandexMetrika } from '../yandex-metrika/index.js';
-export declare function useYandexMetrika(): YandexMetrika;

package/dist/runtime/composables/useYandexMetrika.js

@@ -1,5 +0,0 @@
-import { useNuxtApp } from "#app";
-export function useYandexMetrika() {
-  const { $yandexMetrika } = useNuxtApp();
-  return $yandexMetrika;
-}

package/dist/runtime/yandex-metrika/YandexMetrika.d.ts

@@ -1,25 +0,0 @@
-import type { Events, HitOptions, InitParameters, People, UserParameters, VisitParameters } from './types.js';
-export * from './types.js';
-export declare class YandexMetrika implements Events {
-    #private;
-    static src(cdn?: boolean): "https://cdn.jsdelivr.net/npm/yandex-metrica-watch/tag.js" | "https://mc.yandex.ru/metrika/tag.js";
-    constructor(id: string);
-    get debug(): boolean;
-    set debug(value: boolean);
-    get verification(): string | null;
-    set verification(value: string | null);
-    get id(): string;
-    init(options?: Partial<InitParameters>): void;
-    addFileExtension(extensions?: string | string[]): void;
-    extLink<CTX>(url: string, options?: Omit<HitOptions<CTX>, 'referer'>): void;
-    file<CTX>(url: string, options?: HitOptions<CTX>): void;
-    firstPartyParams(people: People): void;
-    firstPartyParamsHashed(people: People): void;
-    getClientID(cb: (clientID: number) => void): void;
-    hit<CTX>(url?: string, options?: HitOptions<CTX>): void;
-    notBounce<CTX>(options?: Pick<HitOptions<CTX>, 'ctx' | 'callback'>): void;
-    params(params?: VisitParameters): void;
-    reachGoal<CTX>(target: string, params: VisitParameters, callback?: (this: CTX) => void, ctx?: CTX): void;
-    setUserID(userId: string): void;
-    userParams(params?: UserParameters): void;
-}

package/dist/runtime/yandex-metrika/YandexMetrika.js

@@ -1,76 +0,0 @@
-import chalk from "chalk";
-import { Methods } from "./types.js";
-export * from "./types.js";
-export class YandexMetrika {
-  #id;
-  #debug = false;
-  #verification = null;
-  static src(cdn = false) {
-    return cdn ? "https://cdn.jsdelivr.net/npm/yandex-metrica-watch/tag.js" : "https://mc.yandex.ru/metrika/tag.js";
-  }
-  constructor(id) {
-    this.#id = id;
-  }
-  get debug() {
-    return this.#debug;
-  }
-  set debug(value) {
-    this.#debug = value;
-  }
-  get verification() {
-    return this.#verification;
-  }
-  set verification(value) {
-    this.#verification = value;
-  }
-  get id() {
-    return this.#id;
-  }
-  init(options = {}) {
-    this.#call(Methods.Init, ...arguments);
-  }
-  addFileExtension(extensions) {
-    this.#call(Methods.AddFileExtension, ...arguments);
-  }
-  extLink(url, options = {}) {
-    this.#call(Methods.ExtLink, ...arguments);
-  }
-  file(url, options) {
-    this.#call(Methods.File, ...arguments);
-  }
-  firstPartyParams(people) {
-    this.#call(Methods.FirstPartyParams, ...arguments);
-  }
-  firstPartyParamsHashed(people) {
-    this.#call(Methods.FirstPartyParamsHashed, ...arguments);
-  }
-  getClientID(cb) {
-    this.#call(Methods.GetClientID, ...arguments);
-  }
-  hit(url = "", options) {
-    this.#call(Methods.Hit, ...arguments);
-  }
-  notBounce(options = {}) {
-    this.#call(Methods.NotBounce, ...arguments);
-  }
-  params(params = {}) {
-    this.#call(Methods.Params, ...arguments);
-  }
-  reachGoal(target, params, callback, ctx) {
-    this.#call(Methods.ReachGoal, ...arguments);
-  }
-  setUserID(userId) {
-    this.#call(Methods.SetUserID, ...arguments);
-  }
-  userParams(params = {}) {
-    this.#call(Methods.UserParams, ...arguments);
-  }
-  #call(type, ...args) {
-    if (this.#debug) {
-      console.log(`${chalk.bgGreen(chalk.black("[yandex-metrika]"))} ${chalk.blue(type)}`, ...args);
-    }
-    if (typeof window !== "undefined" && window.ym) {
-      window.ym(this.id, type, ...args);
-    }
-  }
-}