@eventra_dev/cli-plugin-vue 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Eventra
+
+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,159 @@
+<p align="center">
+<img src="./assets/eventra-icon-animated.svg" width="120">
+</p>
+
+# Eventra CLI Plugin — Vue
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@eventra_dev/cli-plugin-vue"><img alt="npm version" src="https://img.shields.io/npm/v/@eventra_dev/cli-plugin-vue.svg?style=flat-square&color=blue"></a>
+  <a href="https://www.npmjs.com/package/@eventra_dev/cli-plugin-vue"><img alt="npm downloads" src="https://img.shields.io/npm/dm/@eventra_dev/cli-plugin-vue.svg?style=flat-square&color=blue"></a>
+  <img alt="tests passing" src="https://img.shields.io/badge/tests-15%20passing-brightgreen?style=flat-square&logo=vitest&logoColor=white">
+  <img alt="node" src="https://img.shields.io/node/v/@eventra_dev/cli-plugin-vue?style=flat-square&color=darkgreen&logo=node.js&logoColor=white">
+  <a href="https://www.typescriptlang.org/"><img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ready-blue?style=flat-square&logo=typescript&logoColor=white"></a>
+  <img alt="license" src="https://img.shields.io/npm/l/@eventra_dev/cli-plugin-vue?style=flat-square&color=lightgrey">
+</p>
+
+Official [**Eventra CLI**](https://www.npmjs.com/package/@eventra_dev/eventra-cli) plugin — extracts `track()` calls from Vue Single-File Components (`.vue`), so `eventra sync`/`check`/`watch` understand Vue and Nuxt code the same way they already understand plain TypeScript.
+
+---
+
+## Overview
+
+The CLI core is framework-agnostic and only walks `.ts`/`.tsx`/`.js`/`.jsx`. This plugin teaches it `.vue`: it parses each SFC with the real Vue compiler ([`@vue/compiler-sfc`](https://www.npmjs.com/package/@vue/compiler-sfc)) — not a regex — and hands the CLI a single virtual TypeScript module per file, so every existing detection rule (direct SDK calls, function wrappers, cross-file propagation, dynamic-name reporting) applies to Vue code without any Vue-specific case in the core engine.
+
+Vue and Nuxt `.vue` files are handled the same way — Nuxt pages/layouts/components are ordinary Vue SFCs. See [Nuxt](#nuxt) below for auto-import composables.
+
+---
+
+## Installation
+
+```bash
+npm install -D @eventra_dev/cli-plugin-vue @eventra_dev/eventra-cli
+# or
+pnpm add -D @eventra_dev/cli-plugin-vue @eventra_dev/eventra-cli
+```
+
+Enable it in `eventra.json`:
+
+```json
+{
+  "plugins": ["@eventra_dev/cli-plugin-vue"],
+  "sync": {
+    "include": ["**/*.{ts,tsx,js,jsx}"],
+    "exclude": ["node_modules", "dist", ".next", ".git"]
+  }
+}
+```
+
+`sync.include` does **not** need `**/*.vue` added manually — the plugin registers it via `includeGlobs`.
+
+---
+
+## What gets detected
+
+### `<script>` / `<script setup>`
+
+Handled exactly like a regular `.ts` file — direct SDK calls, function wrappers, variables, ternaries, cross-file propagation all apply:
+
+```vue
+<script setup lang="ts">
+import { Eventra } from "@eventra_dev/eventra-sdk";
+
+const tracker = new Eventra({ apiKey: "YOUR_PROJECT_API_KEY" });
+
+tracker.track("checkout.started");
+</script>
+```
+
+`<script>` + `<script setup>` in the same file are merged in source order. `defineProps`/`defineEmits`/`defineExpose`/`defineOptions`/`withDefaults` pass through untouched.
+
+### `<template>` — literal event attributes
+
+```vue
+<template>
+  <Button event="checkout.cta" />
+</template>
+```
+
+### `<template>` — dynamic event attributes
+
+```vue
+<template>
+  <Button :event="computedEventName" />
+</template>
+```
+
+The expression is copied as-is into the same module scope as the script. If it resolves to a real script-level constant, the event name is detected normally; otherwise it's reported as a **dynamic occurrence** (same mechanism as `tracker.track(someVariable)` in plain TypeScript) instead of being silently dropped.
+
+### External blocks
+
+`<script src="./logic.ts">` and `<template src="./view.html">` are resolved and read from disk.
+
+---
+
+## Nuxt
+
+Nuxt pages, layouts, and components are ordinary `.vue` SFCs — parsed identically, no extra configuration needed.
+
+Composables auto-imported without an explicit `import` statement (Nuxt's own composables, or your own from `composables/`/`utils/`) resolve correctly **once the project has run `nuxt prepare`/`nuxt dev`** (so `.nuxt/` exists and is wired into `tsconfig.json` — the CLI analyzes the project's real `tsconfig.json`, so Nuxt's generated ambient types are visible to it like any other TypeScript project). This includes the case where a wrapper function that calls `track()` is only reachable via auto-import: the CLI understands the `declare const x: typeof import("./module")["name"]` shape Nuxt/`unplugin-auto-import` generate for these bindings.
+
+---
+
+## Configuration
+
+No plugin-specific config — it activates purely by being listed in `eventra.json`'s `plugins` array (see [Installation](#installation)).
+
+---
+
+## Plugin contract
+
+```ts
+export interface CliPluginVue {
+  readonly id: string;
+  readonly version: string;
+  readonly includeGlobs: readonly string[];
+  readonly staticSinks?: readonly CliPluginStaticCalleeSink[];
+  match(path: string): boolean;
+  transform(input: { path: string; source: string }): Promise<{
+    modules: Array<{ path: string; content: string }>;
+  }>;
+}
+```
+
+No dependency on `@eventra_dev/eventra-cli` — the CLI adapts this shape internally. `.vue` → one virtual `.vue.ts` module (compiled script content, then a function wrapping synthetic calls for every template `event="..."` binding). `staticSinks` describes those synthetic calls; the CLI builds its own sink detector from them. See [`@eventra_dev/eventra-cli`'s plugin docs](https://www.npmjs.com/package/@eventra_dev/eventra-cli#plugin-contract-for-authors) for the full external-plugin contract.
+
+---
+
+## Requirements
+
+- Node.js 18+
+- `@eventra_dev/eventra-cli` as the host CLI
+
+---
+
+## Test Coverage
+
+**15 unit tests** (vitest), covering:
+
+| Area | Covers |
+|---|---|
+| SFC parsing | Script + script-setup merge order, comment safety, `src=` external files |
+| Template — literal | Nested elements, `v-if`/`v-for`, slots, multiple template roots |
+| Template — dynamic | Raw expression passthrough, resolution through the merged script scope |
+| Script-setup macros | `defineProps`/`defineEmits` pass through without special-casing |
+| Virtual module output | Single combined `.vue.ts`, export stub when script/template are empty |
+| Plugin contract | `match()`, `includeGlobs`, `staticSinks`, `transform()` |
+
+Also validated end-to-end against real Vue and Nuxt projects (including Nuxt's own generated `.nuxt/` ambient types) as part of `@eventra_dev/eventra-cli`'s test suite.
+
+Run locally:
+
+```bash
+pnpm --filter @eventra_dev/cli-plugin-vue test
+```
+
+---
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import type { CliPluginVue } from "./types";
+export declare function createCliPluginVue(): CliPluginVue;
+declare const _default: CliPluginVue;
+export default _default;
+export { transformVueSfc } from "./transform";
+export { buildScriptModule, parseVueSfc, scriptVirtualPath } from "./parse-vue-sfc";
+export type { CliPluginStaticCalleeSink, CliPluginTransformInput, CliPluginTransformResult, CliPluginVirtualModule, CliPluginVue, } from "./types";
+export type { ParsedVueSfc, TemplateEventBinding, VueScriptBlock } from "./parse-vue-sfc";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,wBAAgB,kBAAkB,IAAI,YAAY,CAejD;;AAED,wBAAoC;AAEpC,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpF,YAAY,EACV,yBAAyB,EACzB,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptVirtualPath = exports.parseVueSfc = exports.buildScriptModule = exports.transformVueSfc = void 0;
+exports.createCliPluginVue = createCliPluginVue;
+const transform_1 = require("./transform");
+function createCliPluginVue() {
+    return {
+        id: "vue",
+        version: "0.1.0",
+        includeGlobs: ["**/*.vue"],
+        staticSinks: [
+            {
+                id: "vue-template-event",
+                callee: "__eventra_vue_template_event__",
+                eventNameArgumentIndex: 0,
+            },
+        ],
+        match: (path) => path.endsWith(".vue"),
+        transform: transform_1.transformVueSfc,
+    };
+}
+exports.default = createCliPluginVue();
+var transform_2 = require("./transform");
+Object.defineProperty(exports, "transformVueSfc", { enumerable: true, get: function () { return transform_2.transformVueSfc; } });
+var parse_vue_sfc_1 = require("./parse-vue-sfc");
+Object.defineProperty(exports, "buildScriptModule", { enumerable: true, get: function () { return parse_vue_sfc_1.buildScriptModule; } });
+Object.defineProperty(exports, "parseVueSfc", { enumerable: true, get: function () { return parse_vue_sfc_1.parseVueSfc; } });
+Object.defineProperty(exports, "scriptVirtualPath", { enumerable: true, get: function () { return parse_vue_sfc_1.scriptVirtualPath; } });

package/dist/parse-vue-sfc.d.ts

@@ -0,0 +1,32 @@
+export interface VueScriptBlock {
+    readonly lang: string;
+    readonly setup: boolean;
+    readonly content: string;
+}
+/** A single `event="..."` binding found on an element in the `<template>`. */
+export interface TemplateEventBinding {
+    /** `literal`: the event name is a string constant. `dynamic`: a raw JS/TS expression, copied verbatim. */
+    readonly kind: "literal" | "dynamic";
+    readonly value: string;
+}
+export interface ParsedVueSfc {
+    readonly scripts: readonly VueScriptBlock[];
+    readonly templateEvents: readonly TemplateEventBinding[];
+    readonly errors: readonly string[];
+}
+/** Parse a Vue SFC via the real `@vue/compiler-sfc` parser (handles comments, `src=`, malformed markup, etc). */
+export declare function parseVueSfc(source: string, filePath: string): ParsedVueSfc;
+/** Map `App.vue` → `App.vue.ts` (single virtual TS module for the compiler). */
+export declare function scriptVirtualPath(vuePath: string): string;
+/**
+ * Build one virtual TS module from the parsed SFC: compiled `<script>` +
+ * `<script setup>` content, followed by a function wrapping synthetic calls
+ * for every template `event="..."` binding. Because everything shares one
+ * module scope, a dynamic binding (`:event="expr"`) that references a real
+ * top-level script identifier (an imported constant, a `<script setup>`
+ * const) resolves through the same checker-based pipeline as any other TS
+ * expression; anything that doesn't resolve (e.g. a `v-for` loop variable)
+ * is correctly reported as a dynamic occurrence rather than silently dropped.
+ */
+export declare function buildScriptModule(parsed: ParsedVueSfc): string;
+//# sourceMappingURL=parse-vue-sfc.d.ts.map

package/dist/parse-vue-sfc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-vue-sfc.d.ts","sourceRoot":"","sources":["../src/parse-vue-sfc.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,8EAA8E;AAC9E,MAAM,WAAW,oBAAoB;IACnC,0GAA0G;IAC1G,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IAC5C,QAAQ,CAAC,cAAc,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACzD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAyDD,iHAAiH;AACjH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAiC1E;AAED,gFAAgF;AAChF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD;AAID;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CA+B9D"}

package/dist/parse-vue-sfc.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVueSfc = parseVueSfc;
+exports.scriptVirtualPath = scriptVirtualPath;
+exports.buildScriptModule = buildScriptModule;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const compiler_sfc_1 = require("@vue/compiler-sfc");
+const compiler_dom_1 = require("@vue/compiler-dom");
+const compiler_core_1 = require("@vue/compiler-core");
+function readSrcFile(sfcPath, src) {
+    const resolved = node_path_1.default.resolve(node_path_1.default.dirname(sfcPath), src);
+    try {
+        return node_fs_1.default.readFileSync(resolved, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function collectEventBindings(root, out) {
+    function visitChildren(children) {
+        for (const child of children) {
+            visitNode(child);
+        }
+    }
+    function visitElementProps(props) {
+        for (const prop of props) {
+            if (prop.type === compiler_core_1.NodeTypes.ATTRIBUTE && prop.name === "event") {
+                const value = prop.value?.content?.trim();
+                if (value) {
+                    out.push({ kind: "literal", value });
+                }
+                continue;
+            }
+            if (prop.type === compiler_core_1.NodeTypes.DIRECTIVE &&
+                prop.name === "bind" &&
+                prop.arg?.type === compiler_core_1.NodeTypes.SIMPLE_EXPRESSION &&
+                prop.arg.isStatic &&
+                prop.arg.content === "event" &&
+                prop.exp?.type === compiler_core_1.NodeTypes.SIMPLE_EXPRESSION) {
+                const expr = prop.exp.content.trim();
+                if (expr) {
+                    out.push({ kind: "dynamic", value: expr });
+                }
+            }
+        }
+    }
+    // `descriptor.template.ast` comes from the parse-only pass (no `transform()`
+    // call), so `v-if`/`v-for` elements are still plain `ElementNode`s with the
+    // directive attached in `props` — there is no separate IfNode/ForNode to
+    // handle here.
+    function visitNode(node) {
+        if (node.type === compiler_core_1.NodeTypes.ELEMENT) {
+            visitElementProps(node.props);
+            visitChildren(node.children);
+        }
+    }
+    visitChildren(root.children);
+}
+/** Parse a Vue SFC via the real `@vue/compiler-sfc` parser (handles comments, `src=`, malformed markup, etc). */
+function parseVueSfc(source, filePath) {
+    const { descriptor, errors } = (0, compiler_sfc_1.parse)(source, { filename: filePath });
+    const scripts = [];
+    for (const block of [descriptor.script, descriptor.scriptSetup]) {
+        if (!block)
+            continue;
+        const content = (block.src ? readSrcFile(filePath, block.src) : block.content)?.trim();
+        if (!content)
+            continue;
+        scripts.push({
+            lang: (block.lang ?? "js").toLowerCase(),
+            setup: Boolean(block.setup),
+            content,
+        });
+    }
+    const templateEvents = [];
+    const template = descriptor.template;
+    if (template) {
+        if (template.ast) {
+            collectEventBindings(template.ast, templateEvents);
+        }
+        else if (template.src) {
+            const external = readSrcFile(filePath, template.src);
+            if (external) {
+                collectEventBindings((0, compiler_dom_1.parse)(external), templateEvents);
+            }
+        }
+    }
+    return {
+        scripts,
+        templateEvents,
+        errors: errors.map((error) => (error instanceof Error ? error.message : String(error))),
+    };
+}
+/** Map `App.vue` → `App.vue.ts` (single virtual TS module for the compiler). */
+function scriptVirtualPath(vuePath) {
+    return vuePath.replace(/\.vue$/i, ".vue.ts");
+}
+const TEMPLATE_EVENT_CALLEE = "__eventra_vue_template_event__";
+/**
+ * Build one virtual TS module from the parsed SFC: compiled `<script>` +
+ * `<script setup>` content, followed by a function wrapping synthetic calls
+ * for every template `event="..."` binding. Because everything shares one
+ * module scope, a dynamic binding (`:event="expr"`) that references a real
+ * top-level script identifier (an imported constant, a `<script setup>`
+ * const) resolves through the same checker-based pipeline as any other TS
+ * expression; anything that doesn't resolve (e.g. a `v-for` loop variable)
+ * is correctly reported as a dynamic occurrence rather than silently dropped.
+ */
+function buildScriptModule(parsed) {
+    const parts = [];
+    if (parsed.scripts.length === 0) {
+        parts.push("export {}");
+    }
+    else {
+        for (const block of parsed.scripts) {
+            const header = [`// --- vue script${block.setup ? " setup" : ""} ---`];
+            if (block.lang !== "ts" && block.lang !== "tsx") {
+                header.push("// @ts-nocheck");
+            }
+            parts.push([...header, block.content].join("\n"));
+        }
+    }
+    if (parsed.templateEvents.length > 0) {
+        const lines = [
+            "// --- vue template (auto-generated) ---",
+            `declare function ${TEMPLATE_EVENT_CALLEE}(name: string): void;`,
+            "function __eventraVueTemplate() {",
+            ...parsed.templateEvents.map((binding) => binding.kind === "literal"
+                ? `  ${TEMPLATE_EVENT_CALLEE}("${escapeString(binding.value)}");`
+                : `  ${TEMPLATE_EVENT_CALLEE}(${binding.value});`),
+            "}",
+        ];
+        parts.push(lines.join("\n"));
+    }
+    return `${parts.join("\n\n")}\n`;
+}
+function escapeString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}

package/dist/transform.d.ts

@@ -0,0 +1,3 @@
+import type { CliPluginTransformInput, CliPluginTransformResult } from "./types";
+export declare function transformVueSfc(input: CliPluginTransformInput): Promise<CliPluginTransformResult>;
+//# sourceMappingURL=transform.d.ts.map

package/dist/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAEjF,wBAAsB,eAAe,CACnC,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,wBAAwB,CAAC,CAWnC"}

package/dist/transform.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVueSfc = transformVueSfc;
+const parse_vue_sfc_1 = require("./parse-vue-sfc");
+async function transformVueSfc(input) {
+    const parsed = (0, parse_vue_sfc_1.parseVueSfc)(input.source, input.path);
+    return {
+        modules: [
+            {
+                path: (0, parse_vue_sfc_1.scriptVirtualPath)(input.path),
+                content: (0, parse_vue_sfc_1.buildScriptModule)(parsed),
+            },
+        ],
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+/** Input passed to a CLI plugin transform step. */
+export interface CliPluginTransformInput {
+    readonly path: string;
+    readonly source: string;
+}
+/** Virtual module produced from a source file (e.g. Vue SFC → `.vue.ts`). */
+export interface CliPluginVirtualModule {
+    readonly path: string;
+    readonly content: string;
+}
+/**
+ * Declarative sink: match `CallExpression` by callee identifier and read the
+ * event name from a string-literal argument. The CLI converts this to its
+ * internal sink detector.
+ */
+export interface CliPluginStaticCalleeSink {
+    readonly id: string;
+    readonly callee: string;
+    readonly eventNameArgumentIndex: number;
+}
+export interface CliPluginTransformResult {
+    readonly modules: readonly CliPluginVirtualModule[];
+}
+/** Contract for `@eventra_dev/cli-plugin-vue` and compatible CLI plugins. */
+export interface CliPluginVue {
+    readonly id: string;
+    readonly version: string;
+    readonly includeGlobs: readonly string[];
+    readonly staticSinks?: readonly CliPluginStaticCalleeSink[];
+    match(path: string): boolean;
+    transform(input: CliPluginTransformInput): Promise<CliPluginTransformResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,6EAA6E;AAC7E,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;CACzC;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACrD;AAED,6EAA6E;AAC7E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAC5D,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B,SAAS,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAC9E"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@eventra_dev/cli-plugin-vue",
+  "version": "0.2.1",
+  "description": "Eventra CLI plugin — extract track() calls from Vue SFC (.vue) files",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/and-1991/eventra-cli-plugin-vue"
+  },
+  "homepage": "https://eventra.dev",
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@vue/compiler-core": "^3.5.40",
+    "@vue/compiler-dom": "^3.5.40",
+    "@vue/compiler-sfc": "^3.5.40"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.7"
+  },
+  "keywords": [
+    "eventra",
+    "eventra-cli",
+    "vue",
+    "vue3",
+    "nuxt",
+    "sfc",
+    "static-analysis",
+    "analytics",
+    "plugin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}