@vue.ts/complex-types 1.0.0-beta.1 → 1.0.0-beta.10

package/README.md

@@ -2,7 +2,7 @@
 
 [![NPM version](https://img.shields.io/npm/v/@vue.ts/complex-types?color=a1b858&label=)](https://www.npmjs.com/package/@vue.ts/complex-types)
 
-Use [`@vue/language-core`](https://github.com/vuejs/language-tools/tree/master/packages/language-core) to support complex types for Vue Macros.
+Use [`@vue/language-core`](https://github.com/vuejs/language-tools/tree/master/packages/language-core) to support complex types for Vue's Macros.
 
 For example: fixes https://github.com/vuejs/core/issues/8286.
 
@@ -14,10 +14,6 @@ $ yarn add -D @vue.ts/complex-types
 $ pnpm add -D @vue.ts/complex-types
 ```
 
-## TODOs
-
-- [ ] Add more tests
-
 ## 🚀 Usage
 
 <details>

package/dist/astro.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 
 //#region src/astro.d.ts
 declare const _default: (options: Options) => {

package/dist/astro.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createVitePlugin } from "unplugin";
 
 //#region src/astro.ts

package/dist/esbuild.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as esbuild0 from "esbuild";
 

package/dist/esbuild.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createEsbuildPlugin } from "unplugin";
 
 //#region src/esbuild.ts

package/dist/farm.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as _farmfe_core0 from "@farmfe/core";
 

package/dist/farm.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createFarmPlugin } from "unplugin";
 
 //#region src/farm.ts

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import * as unplugin0 from "unplugin";
 import { UnpluginFactory } from "unplugin";
 

package/dist/index.js

@@ -1,3 +1,3 @@
-import { src_default, unplugin, unpluginFactory } from "./src-CI8-WIu4.js";
+import { n as unplugin, r as unpluginFactory, t as src_default } from "./src-Ci8DJn1t.js";
 
 export { src_default as default, unplugin, unpluginFactory };

package/dist/nuxt.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as _nuxt_schema0 from "@nuxt/schema";
 

package/dist/nuxt.js

@@ -1,6 +1,6 @@
-import "./src-CI8-WIu4.js";
-import { vite_default } from "./vite-Dyi1m2wg.js";
-import { webpack_default } from "./webpack-CFfuQfGw.js";
+import "./src-Ci8DJn1t.js";
+import { t as vite_default } from "./vite-D-Xfh8NL.js";
+import { t as webpack_default } from "./webpack-By_BEclB.js";
 import { addVitePlugin, addWebpackPlugin, defineNuxtModule } from "@nuxt/kit";
 
 //#region src/nuxt.ts

package/dist/rolldown.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as rolldown0 from "rolldown";
 

package/dist/rolldown.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createRolldownPlugin } from "unplugin";
 
 //#region src/rolldown.ts

package/dist/rollup.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as rollup0 from "rollup";
 

package/dist/rollup.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createRollupPlugin } from "unplugin";
 
 //#region src/rollup.ts

package/dist/rspack.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 
 //#region src/rspack.d.ts

package/dist/rspack.js

@@ -1,4 +1,4 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createRspackPlugin } from "unplugin";
 
 //#region src/rspack.ts

package/dist/src-Ci8DJn1t.js

@@ -0,0 +1,228 @@
+import { createUnplugin } from "unplugin";
+import { ensureLanguage, getLanguage } from "@vue.ts/language";
+import { createFilter } from "unplugin-utils";
+import MagicString from "magic-string";
+import ts from "typescript";
+import { join } from "node:path";
+import { defu } from "defu";
+import { normalizePath } from "@vue.ts/shared";
+import { isReservedProp } from "@vue/shared";
+
+//#region src/core/utils.ts
+const defaultOptions = {
+	include: ["**/*.vue"],
+	exclude: ["node_modules/**"],
+	tsconfigPath: join(process.cwd(), "tsconfig.json"),
+	defineEmits: true,
+	defineProps: true
+};
+const resolveOptions = (rawOptions) => defu(rawOptions, defaultOptions);
+const quotesReg = /"/g;
+const escapeQuotes = (s) => s.replace(quotesReg, "\\\"");
+
+//#endregion
+//#region src/core/printer.ts
+var Printer = class {
+	constructor(checker) {
+		this.checker = checker;
+	}
+	typeToString(type) {
+		return this.checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+	}
+	printUnionOrIntersection(type, separator, isPropertyBlacklisted, inner) {
+		return [...new Set(type.types.map((t) => this.printType(t, isPropertyBlacklisted, inner)).filter(Boolean))].join(separator);
+	}
+	isSymbolOptional(symbol) {
+		return !!(symbol.flags & ts.SymbolFlags.Optional);
+	}
+	printConditionType(type, isPropertyBlacklisted, inner) {
+		const { trueType, falseType } = type.root.node;
+		const trueTypeNode = this.checker.getTypeAtLocation(trueType);
+		const falseTypeNode = this.checker.getTypeAtLocation(falseType);
+		return `${this.printType(trueTypeNode, isPropertyBlacklisted, inner)} | ${this.printType(falseTypeNode, isPropertyBlacklisted, inner)}`;
+	}
+	printPrimitiveType(type) {
+		if (type.flags & ts.TypeFlags.BooleanLiteral) return "boolean";
+		else if (type.flags & ts.TypeFlags.String || type.isStringLiteral()) return "string";
+		else if (type.flags & ts.TypeFlags.Number || type.isNumberLiteral()) return "number";
+		else if (type.flags & ts.TypeFlags.BigInt) return "bigint";
+		else if (type.flags & ts.TypeFlags.Any) return "any";
+		else if (type.flags & ts.TypeFlags.Unknown) return "unknown";
+		else if (type.flags & ts.TypeFlags.Null) return "null";
+		return "";
+	}
+	printType(type, isPropertyBlacklisted, inner = false) {
+		if (type.isUnion()) return this.printUnionOrIntersection(type, " | ", isPropertyBlacklisted, inner);
+		else if (type.isIntersection()) return this.printUnionOrIntersection(type, " & ", isPropertyBlacklisted, inner);
+		if (this.checker.isArrayType(type)) return "Array";
+		else if (type.flags & ts.TypeFlags.Object) {
+			const decl = type.getSymbol()?.declarations?.[0];
+			if (decl && ts.isFunctionTypeNode(decl)) return "Function";
+			if (inner) return "object";
+			const properties = type.getProperties();
+			const props = {};
+			for (const prop of properties) {
+				const propType = this.checker.getTypeOfSymbol(prop);
+				const name = prop.getName();
+				if (isPropertyBlacklisted(name)) continue;
+				props[name] = {
+					value: this.printType(propType, isPropertyBlacklisted, true),
+					isOptional: this.isSymbolOptional(prop)
+				};
+			}
+			const parts = [];
+			for (const [propName, { isOptional, value }] of Object.entries(props)) {
+				const questionMark = isOptional ? "?" : "";
+				parts.push(`"${escapeQuotes(propName)}"${questionMark}: ${value},`);
+			}
+			return Object.keys(props).length > 0 ? `{\n${parts.join("\n")}\n}` : "";
+		} else if (type.isLiteral() || type.flags & ts.TypeFlags.BooleanLiteral || type.flags & ts.TypeFlags.String || type.flags & ts.TypeFlags.Number || type.flags & ts.TypeFlags.BigInt || type.flags & ts.TypeFlags.Any || type.flags & ts.TypeFlags.Unknown || type.flags & ts.TypeFlags.Null) return this.printPrimitiveType(type);
+		else if (type.flags & ts.TypeFlags.Undefined) return "";
+		else if (type.flags & ts.TypeFlags.Conditional) return this.printConditionType(type, isPropertyBlacklisted, inner);
+		else if (type.isTypeParameter()) {
+			const decl = type.getSymbol()?.declarations?.[0];
+			if (!decl || !ts.isTypeParameterDeclaration(decl)) return "";
+			const ref = ts.getEffectiveConstraintOfTypeParameter(decl);
+			if (!ref) return "";
+			const refType = this.checker.getTypeAtLocation(ref);
+			return this.printType(refType, isPropertyBlacklisted, inner);
+		}
+		return this.typeToString(type);
+	}
+	printPropsTypeArg(node, isPropertyBlacklisted) {
+		const type = this.checker.getTypeAtLocation(node);
+		return this.printType(type, isPropertyBlacklisted);
+	}
+	printEventsByCallSignatures(callSignatures) {
+		return callSignatures.map((c) => {
+			const event = c.getParameters()[0];
+			return this.typeToString(this.checker.getTypeOfSymbol(event));
+		});
+	}
+	printEventsByMembers(members) {
+		return members.map((m) => `"${escapeQuotes(m.getName())}"`);
+	}
+	printEventsRuntimeArg(node) {
+		const parts = [];
+		const type = this.checker.getTypeAtLocation(node);
+		const callSignatures = type.getCallSignatures();
+		const members = type.getProperties();
+		if (callSignatures.length > 0 && members.length > 0) throw new Error("[@vue.ts/complex-types] You may not use old style `defineEmits` and `defineEmits` shorthand together.");
+		if (members.length > 0) parts.push(...this.printEventsByMembers(members));
+		else parts.push(...this.printEventsByCallSignatures(callSignatures));
+		return `[${parts.join(", ")}]`;
+	}
+};
+
+//#endregion
+//#region src/core/transformers/defineEmits.ts
+const transformDefineEmits = (printer, s, id) => {
+	const normalizedFilepath = normalizePath(id);
+	const language = getLanguage();
+	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
+	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
+	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
+	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
+	const scriptSetupDefineEmitsNode = language.findNodeByRange(scriptSetupAst, (scriptSetupRanges) => scriptSetupRanges.defineEmits?.callExp);
+	const virtualFileDefineEmitsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Emit");
+	if (!scriptSetupDefineEmitsNode || !virtualFileDefineEmitsTypeNode) return;
+	const offset = scriptSetupBlock.startTagEnd;
+	if (ts.isCallExpression(scriptSetupDefineEmitsNode) && scriptSetupDefineEmitsNode.arguments[0]) throw new Error("[@vue.ts/complex-types] `defineEmits` cannot accept both runtime argument and type argument.");
+	const tokens = scriptSetupDefineEmitsNode.getChildren(scriptSetupAst);
+	const lessThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.LessThanToken);
+	const greaterThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.GreaterThanToken);
+	const openParenToken = tokens.find((t) => t.kind === ts.SyntaxKind.OpenParenToken);
+	if (!lessThanToken || !greaterThanToken || !openParenToken) return;
+	const defineEmitsTypeArgRange = [offset + lessThanToken.pos, offset + greaterThanToken.end];
+	const runtimeArgPos = offset + openParenToken.end;
+	const printedRuntimeArg = printer.printEventsRuntimeArg(virtualFileDefineEmitsTypeNode);
+	s.remove(...defineEmitsTypeArgRange);
+	s.appendRight(runtimeArgPos, printedRuntimeArg);
+};
+
+//#endregion
+//#region src/core/transformers/defineProps.ts
+const transformDefineProps = (printer, s, id) => {
+	const normalizedFilepath = normalizePath(id);
+	const language = getLanguage();
+	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
+	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
+	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
+	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
+	const scriptSetupDefinePropsTypeRange = language.parseScriptSetupRanges(scriptSetupAst).defineProps?.typeArg;
+	const virtualFileDefinePropsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Props");
+	if (!scriptSetupDefinePropsTypeRange || !virtualFileDefinePropsTypeNode) return;
+	const printedType = printer.printPropsTypeArg(virtualFileDefinePropsTypeNode, isReservedProp);
+	const offset = scriptSetupBlock.startTagEnd;
+	s.overwrite(offset + scriptSetupDefinePropsTypeRange.start, offset + scriptSetupDefinePropsTypeRange.end, printedType);
+};
+
+//#endregion
+//#region src/core/transformers/index.ts
+const transformers = [["defineEmits", transformDefineEmits], ["defineProps", transformDefineProps]];
+const getTransformers = (options) => transformers.filter(([key]) => !!options[key]);
+
+//#endregion
+//#region src/core/transform.ts
+function transform(code, id, options) {
+	const s = new MagicString(code);
+	const printer = new Printer(getLanguage().tsLs.getProgram().getTypeChecker());
+	const transformers$1 = getTransformers(options);
+	for (const [, transform$1] of transformers$1) transform$1(printer, s, id);
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: true })
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const languageExtRegexp = /\.((?:c|m)?(?:j|t)sx?|d\.ts|vue)$/i;
+const unpluginFactory = (options = {}) => {
+	const resolvedOptions = resolveOptions(options);
+	const filter = createFilter(resolvedOptions.include, resolvedOptions.exclude);
+	return {
+		name: "@vue.ts/complex-types",
+		enforce: "pre",
+		vite: { async handleHotUpdate(ctx) {
+			const { file } = ctx;
+			if (!languageExtRegexp.test(file)) return;
+			const language = getLanguage();
+			const { read } = ctx;
+			async function readAndUpdateLanguage() {
+				const content = await read();
+				language.updateFile(file, content);
+				return content;
+			}
+			if (!filter(file)) {
+				await readAndUpdateLanguage();
+				return;
+			}
+			let cached;
+			ctx.read = async () => {
+				cached ??= (async () => {
+					const code = await readAndUpdateLanguage();
+					return transform(code, file, resolvedOptions)?.code ?? code;
+				})();
+				return cached;
+			};
+			for (const mod of ctx.modules) ctx.server.moduleGraph.invalidateModule(mod);
+			return ctx.modules;
+		} },
+		buildStart() {
+			ensureLanguage(resolveOptions(options).tsconfigPath);
+		},
+		transform: {
+			filter: { id: {
+				include: resolvedOptions.include,
+				exclude: resolvedOptions.exclude
+			} },
+			handler: (code, id) => transform(code, id, resolvedOptions)
+		}
+	};
+};
+const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
+var src_default = unplugin;
+
+//#endregion
+export { unplugin as n, unpluginFactory as r, src_default as t };

package/dist/{types-CFmCIAvs.d.ts → types-B0cfnWIB.d.ts}

@@ -1,8 +1,8 @@
+import { FilterPattern } from "unplugin";
 import MagicString from "magic-string";
 import ts from "typescript";
-import { FilterPattern } from "@rollup/pluginutils";
 
-//#region ../common/src/types.d.ts
+//#region ../shared/src/types.d.ts
 interface BaseOptions {
   include?: FilterPattern;
   exclude?: FilterPattern;
@@ -12,27 +12,13 @@ interface BaseOptions {
 declare class Printer {
   private checker;
   constructor(checker: ts.TypeChecker);
-  private getBaseType;
   private typeToString;
-  private printIntersectionTypeNode;
-  private printUnionTypeNode;
-  private printTypeLiteralNode;
-  private printTypeByType;
-  private printIdentifier;
-  private printInterfaceDeclaration;
-  private printEnumDeclaration;
-  private printClassDeclaration;
-  private printFunctionTypeNode;
-  private printConstructorTypeNode;
-  private printTypeQueryNode;
-  private printArrayTypeNode;
-  private printTupleTypeNode;
-  private printConditionalTypeNode;
-  private printIndexedAccessTypeNode;
-  private printHeritageClause;
-  private printImportSpecifier;
-  private isKeywordTypeNode;
-  print(node: ts.Node): string;
+  private printUnionOrIntersection;
+  private isSymbolOptional;
+  private printConditionType;
+  private printPrimitiveType;
+  private printType;
+  printPropsTypeArg(node: ts.Node, isPropertyBlacklisted: (prop: string) => boolean): string;
   private printEventsByCallSignatures;
   private printEventsByMembers;
   printEventsRuntimeArg(node: ts.Node): string;
@@ -48,4 +34,4 @@ type TransformOptions = Pick<ResolvedOptions, ValidTransforms>;
 type Transformer = (printer: Printer, s: MagicString, id: string) => void;
 type Transformers = [ValidTransforms, Transformer][];
 //#endregion
-export { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms };
+export { Transformers as a, Transformer as i, ResolvedOptions as n, ValidTransforms as o, TransformOptions as r, Options as t };

package/dist/types.d.ts

@@ -1,3 +1,3 @@
-import { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms } from "./types-CFmCIAvs.js";
+import { a as Transformers, i as Transformer, n as ResolvedOptions, o as ValidTransforms, r as TransformOptions, t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 export { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms };

package/dist/types.js

@@ -0,0 +1 @@
+export {  };

package/dist/{vite-Dyi1m2wg.js → vite-D-Xfh8NL.js}

@@ -1,8 +1,8 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createVitePlugin } from "unplugin";
 
 //#region src/vite.ts
 var vite_default = createVitePlugin(unpluginFactory);
 
 //#endregion
-export { vite_default };
+export { vite_default as t };

package/dist/vite.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as vite0 from "vite";
 

package/dist/vite.js

@@ -1,4 +1,4 @@
-import "./src-CI8-WIu4.js";
-import { vite_default } from "./vite-Dyi1m2wg.js";
+import "./src-Ci8DJn1t.js";
+import { t as vite_default } from "./vite-D-Xfh8NL.js";
 
 export { vite_default as default };

package/dist/{webpack-CFfuQfGw.js → webpack-By_BEclB.js}

@@ -1,8 +1,8 @@
-import { unpluginFactory } from "./src-CI8-WIu4.js";
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
 import { createWebpackPlugin } from "unplugin";
 
 //#region src/webpack.ts
 var webpack_default = createWebpackPlugin(unpluginFactory);
 
 //#endregion
-export { webpack_default };
+export { webpack_default as t };

package/dist/webpack.d.ts

@@ -1,4 +1,4 @@
-import { Options } from "./types-CFmCIAvs.js";
+import { t as Options } from "./types-B0cfnWIB.js";
 import "./types-u_Hr5uXA.js";
 import * as webpack0 from "webpack";
 

package/dist/webpack.js

@@ -1,4 +1,4 @@
-import "./src-CI8-WIu4.js";
-import { webpack_default } from "./webpack-CFfuQfGw.js";
+import "./src-Ci8DJn1t.js";
+import { t as webpack_default } from "./webpack-By_BEclB.js";
 
 export { webpack_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue.ts/complex-types",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.10",
   "author": "Ray <i@mk1.io> (@so1ve)",
   "type": "module",
   "description": "Resolve complex types in Vue SFCs.",
@@ -62,31 +62,34 @@
     "access": "public"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.17.6",
-    "magic-string": "^0.30.17",
-    "unplugin": "^2.3.5",
-    "@vue.ts/language": "1.0.0-beta.1",
-    "@vue.ts/common": "1.0.0-beta.1"
+    "@nuxt/kit": "^4.2.0",
+    "@vue/shared": "^3.5.22",
+    "defu": "^6.1.4",
+    "magic-string": "^0.30.21",
+    "unplugin": "2.3.10",
+    "unplugin-utils": "^0.3.1",
+    "@vue.ts/language": "1.0.0-beta.10",
+    "@vue.ts/shared": "1.0.0-beta.10"
   },
   "devDependencies": {
-    "@nuxt/schema": "^3.17.6",
-    "@vue-macros/better-define": "^1.11.4",
-    "rolldown": "1.0.0-beta.27",
-    "rollup": "^4.44.2",
-    "vite": "^7.0.4",
-    "webpack": "^5.100.1"
+    "@nuxt/schema": "^4.2.0",
+    "@vue-macros/better-define": "^3.1.1",
+    "rolldown": "1.0.0-beta.45",
+    "rollup": "^4.52.5",
+    "vite": "7.1.12",
+    "webpack": "^5.102.1"
   },
   "peerDependencies": {
-    "@farmfe/core": ">=1",
-    "@nuxt/kit": "^3 || ^4",
-    "@nuxt/schema": "^3 || ^4",
+    "@farmfe/core": ">=1.7.11",
+    "@nuxt/kit": "^4.2.0",
+    "@nuxt/schema": "^4.2.0",
     "esbuild": "*",
     "rolldown": "*",
-    "rollup": "^3",
-    "typescript": "^5.2.2",
-    "vite": ">=3",
-    "vue": "^3.3.7",
-    "webpack": "^4 || ^5"
+    "rollup": "^4.52.5",
+    "typescript": ">=5.9.3",
+    "vite": ">=7.1.12",
+    "vue": ">=3.5.22",
+    "webpack": "^5.102.1"
   },
   "peerDependenciesMeta": {
     "@farmfe/core": {

package/dist/src-CI8-WIu4.js

@@ -1,354 +0,0 @@
-import { createUnplugin } from "unplugin";
-import { createFilter, normalizePath } from "@vue.ts/common";
-import { ensureLanguage, getLanguage } from "@vue.ts/language";
-import MagicString from "magic-string";
-import ts from "typescript";
-import { join } from "node:path";
-
-//#region src/core/utils.ts
-const resolveOptions = (rawOptions) => ({
-	include: rawOptions.include ?? ["**/*.vue"],
-	exclude: rawOptions.exclude ?? ["node_modules/**"],
-	tsconfigPath: rawOptions.tsconfigPath ?? join(process.cwd(), "tsconfig.json"),
-	defineEmits: rawOptions.defineEmits ?? true,
-	defineProps: rawOptions.defineProps ?? true
-});
-const quotesReg = /"/g;
-const escapeQuotes = (s) => s.replace(quotesReg, "\\\"");
-
-//#endregion
-//#region src/core/printer.ts
-var Printer = class {
-	constructor(checker) {
-		this.checker = checker;
-	}
-	getBaseType(nodeOrType) {
-		if ("kind" in nodeOrType) nodeOrType = this.checker.getTypeAtLocation(nodeOrType);
-		return this.checker.getBaseConstraintOfType(nodeOrType) ?? this.checker.getBaseTypeOfLiteralType(nodeOrType);
-	}
-	typeToString(type) {
-		return this.checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
-	}
-	printIntersectionTypeNode(node) {
-		return node.types.map((t) => this.print(t)).join(" & ");
-	}
-	printUnionTypeNode(node) {
-		return node.types.map((t) => this.print(t)).join(" | ");
-	}
-	printTypeLiteralNode(node) {
-		const parts = ["{"];
-		for (const member of node.members) if (ts.isPropertySignature(member)) {
-			const stringBaseType = member.type ? this.typeToString(this.getBaseType(member.type)) : "any";
-			parts.push([
-				member.name.getText(),
-				member.questionToken?.getText(),
-				": ",
-				stringBaseType
-			].filter(Boolean).join(""));
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printTypeByType(node) {
-		const type = this.checker.getTypeAtLocation(node);
-		const properties = type.getProperties();
-		const parts = ["{"];
-		const isMapped = ts.isMappedTypeNode(node);
-		for (const property of properties) {
-			const questionToken = isMapped ? node.questionToken?.getText() ?? "" : property.flags & ts.SymbolFlags.Optional ? "?" : "";
-			const valueType = this.checker.getTypeOfSymbol(property);
-			const stringValueType = this.typeToString(this.getBaseType(valueType));
-			parts.push(`${this.checker.symbolToString(property)}${questionToken}: ${stringValueType}`);
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printIdentifier(node) {
-		const symbol = this.checker.getSymbolAtLocation(node);
-		if (!symbol) return node.getText();
-		const declarations = symbol.getDeclarations();
-		if (!declarations || declarations.length === 0) return node.getText();
-		return this.print(declarations[0]);
-	}
-	printInterfaceDeclaration(node) {
-		const parts = ["{"];
-		for (const member of node.members) if (ts.isPropertySignature(member)) {
-			const stringBaseType = member.type ? this.print(member.type) : "any";
-			parts.push([
-				member.name?.getText(),
-				member.questionToken?.getText(),
-				": ",
-				stringBaseType
-			].filter(Boolean).join(""));
-		} else if (ts.isMethodSignature(member)) {
-			const signature = this.checker.getSignatureFromDeclaration(member);
-			const returnType = signature ? this.typeToString(signature.getReturnType()) : "any";
-			const parameters = member.parameters.map((param) => {
-				const paramType = param.type ? this.typeToString(this.getBaseType(param.type)) : "any";
-				return `${param.name.getText()}: ${paramType}`;
-			}).join(", ");
-			parts.push(`${member.name?.getText()}(${parameters}): ${returnType}`);
-		}
-		parts.push("}");
-		let result = parts.join("\n");
-		if (node.heritageClauses && node.heritageClauses.length > 0) result = node.heritageClauses.map((clause) => this.print(clause)).join(" & ");
-		return result;
-	}
-	printEnumDeclaration(node) {
-		const parts = ["{"];
-		for (const member of node.members) {
-			const name = member.name.getText();
-			if (member.initializer) {
-				const value = member.initializer.getText();
-				parts.push(`${name}: ${value}`);
-			} else parts.push(`${name}: number`);
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printClassDeclaration(node) {
-		const parts = ["{"];
-		for (const member of node.members) if (ts.isPropertyDeclaration(member)) {
-			const name = member.name?.getText();
-			const typeAnnotation = member.type ? this.typeToString(this.getBaseType(member.type)) : "any";
-			const optional = member.questionToken ? "?" : "";
-			parts.push(`${name}${optional}: ${typeAnnotation}`);
-		} else if (ts.isMethodDeclaration(member)) {
-			const name = member.name?.getText();
-			const signature = this.checker.getSignatureFromDeclaration(member);
-			const returnType = signature ? this.typeToString(signature.getReturnType()) : "any";
-			const parameters = member.parameters.map((param) => {
-				const paramType = param.type ? this.typeToString(this.getBaseType(param.type)) : "any";
-				return `${param.name.getText()}: ${paramType}`;
-			}).join(", ");
-			parts.push(`${name}(${parameters}): ${returnType}`);
-		} else if (ts.isConstructorDeclaration(member)) {
-			const parameters = member.parameters.map((param) => {
-				const paramType = param.type ? this.typeToString(this.getBaseType(param.type)) : "any";
-				return `${param.name.getText()}: ${paramType}`;
-			}).join(", ");
-			parts.push(`constructor(${parameters}): void`);
-		}
-		parts.push("}");
-		return parts.join("\n");
-	}
-	printFunctionTypeNode(node) {
-		const parameters = node.parameters.map((param) => {
-			const paramType = param.type ? this.print(param.type) : "any";
-			const optional = param.questionToken ? "?" : "";
-			const rest = param.dotDotDotToken ? "..." : "";
-			return `${rest}${param.name.getText()}${optional}: ${paramType}`;
-		}).join(", ");
-		const returnType = node.type ? this.print(node.type) : "any";
-		return `(${parameters}) => ${returnType}`;
-	}
-	printConstructorTypeNode(node) {
-		const parameters = node.parameters.map((param) => {
-			const paramType = param.type ? this.print(param.type) : "any";
-			const optional = param.questionToken ? "?" : "";
-			const rest = param.dotDotDotToken ? "..." : "";
-			return `${rest}${param.name.getText()}${optional}: ${paramType}`;
-		}).join(", ");
-		const returnType = node.type ? this.print(node.type) : "any";
-		return `new (${parameters}) => ${returnType}`;
-	}
-	printTypeQueryNode(node) {
-		const exprName = node.exprName.getText();
-		return `typeof ${exprName}`;
-	}
-	printArrayTypeNode(node) {
-		return `${this.print(node.elementType)}[]`;
-	}
-	printTupleTypeNode(node) {
-		const elements = node.elements.map((element) => {
-			if (ts.isRestTypeNode(element)) return `...${this.print(element.type)}`;
-			if (ts.isOptionalTypeNode(element)) return `${this.print(element.type)}?`;
-			if (ts.isNamedTupleMember(element)) {
-				const type = this.print(element.type);
-				const optional = element.questionToken ? "?" : "";
-				const rest = element.dotDotDotToken ? "..." : "";
-				return `${rest}${element.name.getText()}${optional}: ${type}`;
-			}
-			return this.print(element);
-		});
-		return `[${elements.join(", ")}]`;
-	}
-	printConditionalTypeNode(node) {
-		const checkType = this.print(node.checkType);
-		const extendsType = this.print(node.extendsType);
-		const trueType = this.print(node.trueType);
-		const falseType = this.print(node.falseType);
-		return `${checkType} extends ${extendsType} ? ${trueType} : ${falseType}`;
-	}
-	printIndexedAccessTypeNode(node) {
-		const objectType = this.print(node.objectType);
-		const indexType = this.print(node.indexType);
-		return `${objectType}[${indexType}]`;
-	}
-	printHeritageClause(node) {
-		if (node.token === ts.SyntaxKind.ExtendsKeyword) {
-			const parts = [];
-			for (const type of node.types) if (ts.isExpressionWithTypeArguments(type)) if (type.expression && type.typeArguments) parts.push(this.print(type));
-			else parts.push(this.print(type.expression));
-			return parts.join(" & ");
-		}
-		return "";
-	}
-	printImportSpecifier(node) {
-		const name = node.propertyName ? node.propertyName.getText() : node.name.getText();
-		const symbol = this.checker.getSymbolAtLocation(node.name);
-		if (!symbol) return name;
-		const aliasedSymbol = this.checker.getAliasedSymbol(symbol);
-		const targetSymbol = aliasedSymbol || symbol;
-		const declarations = targetSymbol.getDeclarations();
-		if (!declarations || declarations.length === 0) return name;
-		const declaration = declarations.find((decl) => ts.isTypeAliasDeclaration(decl) || ts.isInterfaceDeclaration(decl) || ts.isClassDeclaration(decl) || ts.isEnumDeclaration(decl) || ts.isVariableDeclaration(decl));
-		if (declaration) return this.print(declaration);
-		return name;
-	}
-	isKeywordTypeNode(node) {
-		return node.kind === ts.SyntaxKind.StringKeyword || node.kind === ts.SyntaxKind.NumberKeyword || node.kind === ts.SyntaxKind.BooleanKeyword || node.kind === ts.SyntaxKind.ObjectKeyword || node.kind === ts.SyntaxKind.UndefinedKeyword || node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.VoidKeyword || node.kind === ts.SyntaxKind.AnyKeyword || node.kind === ts.SyntaxKind.UnknownKeyword || node.kind === ts.SyntaxKind.NeverKeyword || node.kind === ts.SyntaxKind.SymbolKeyword || node.kind === ts.SyntaxKind.BigIntKeyword;
-	}
-	print(node) {
-		if (ts.isIdentifier(node)) return this.printIdentifier(node);
-		else if (ts.isIntersectionTypeNode(node)) return this.printIntersectionTypeNode(node);
-		else if (ts.isUnionTypeNode(node)) return this.printUnionTypeNode(node);
-		else if (ts.isTypeLiteralNode(node)) return this.printTypeLiteralNode(node);
-		else if (ts.isTypeReferenceNode(node)) return this.print(node.typeName);
-		else if (ts.isInterfaceDeclaration(node)) return this.printInterfaceDeclaration(node);
-		else if (ts.isTypeAliasDeclaration(node)) return node.type ? this.print(node.type) : "any";
-		else if (ts.isEnumDeclaration(node)) return this.printEnumDeclaration(node);
-		else if (ts.isClassDeclaration(node)) return this.printClassDeclaration(node);
-		else if (ts.isFunctionTypeNode(node)) return this.printFunctionTypeNode(node);
-		else if (ts.isConstructorTypeNode(node)) return this.printConstructorTypeNode(node);
-		else if (ts.isTypeQueryNode(node)) return this.printTypeQueryNode(node);
-		else if (ts.isArrayTypeNode(node)) return this.printArrayTypeNode(node);
-		else if (ts.isTupleTypeNode(node)) return this.printTupleTypeNode(node);
-		else if (ts.isConditionalTypeNode(node)) return this.printConditionalTypeNode(node);
-		else if (ts.isIndexedAccessTypeNode(node)) return this.printIndexedAccessTypeNode(node);
-		else if (ts.isParenthesizedTypeNode(node)) return this.print(node.type);
-		else if (ts.isHeritageClause(node)) return this.printHeritageClause(node);
-		else if (ts.isTypeAliasDeclaration(node) && node.type) return this.print(node.type);
-		else if (ts.isInterfaceDeclaration(node)) return this.printInterfaceDeclaration(node);
-		else if (ts.isVariableDeclaration(node) && node.type) return this.print(node.type);
-		else if (ts.isImportSpecifier(node)) return this.printImportSpecifier(node);
-		else if (ts.isTypeParameterDeclaration(node)) {
-			if (node.constraint) return this.print(node.constraint);
-			else if (node.default) return this.print(node.default);
-			return "{}";
-		} else if (ts.isParameter(node) && node.type) return this.print(node.type);
-		else if (ts.isLiteralTypeNode(node) || ts.isThisTypeNode(node) || ts.isPropertyAccessExpression(node) || this.isKeywordTypeNode(node)) return node.getText();
-		else if (ts.isMappedTypeNode(node) || ts.isExpressionWithTypeArguments(node)) return this.printTypeByType(node);
-		else {
-			console.error(`[@vue.ts/complex-types] \`${ts.SyntaxKind[node.kind]}\` is not supported.`);
-			return node.getText();
-		}
-	}
-	printEventsByCallSignatures(callSignatures) {
-		return callSignatures.map((c) => {
-			const parameters = c.getParameters();
-			const event = parameters[0];
-			return this.typeToString(this.checker.getTypeOfSymbol(event));
-		});
-	}
-	printEventsByMembers(members) {
-		return members.map((m) => `"${escapeQuotes(m.getName())}"`);
-	}
-	printEventsRuntimeArg(node) {
-		const parts = [];
-		const type = this.checker.getTypeAtLocation(node);
-		const callSignatures = type.getCallSignatures();
-		const members = type.getProperties();
-		if (callSignatures.length > 0 && members.length > 0) throw new Error("[@vue.ts/complex-types] You may not use old style `defineEmits` and `defineEmits` shorthand together.");
-		if (members.length > 0) parts.push(...this.printEventsByMembers(members));
-		else parts.push(...this.printEventsByCallSignatures(callSignatures));
-		return `[${parts.join(", ")}]`;
-	}
-};
-
-//#endregion
-//#region src/core/transformers/defineEmits.ts
-const transformDefineEmits = (printer, s, id) => {
-	const normalizedFilepath = normalizePath(id);
-	const language = getLanguage();
-	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
-	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
-	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
-	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
-	const scriptSetupDefineEmitsNode = language.findNodeByRange(scriptSetupAst, (scriptSetupRanges) => scriptSetupRanges.defineEmits?.callExp);
-	const virtualFileDefineEmitsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Emit");
-	if (!scriptSetupDefineEmitsNode || !virtualFileDefineEmitsTypeNode) return;
-	const offset = scriptSetupBlock.startTagEnd;
-	const defineEmitsRuntimeArg = ts.isCallExpression(scriptSetupDefineEmitsNode) && scriptSetupDefineEmitsNode.arguments[0];
-	if (defineEmitsRuntimeArg) throw new Error("[@vue.ts/complex-types] `defineEmits` cannot accept both runtime argument and type argument.");
-	const tokens = scriptSetupDefineEmitsNode.getChildren(scriptSetupAst);
-	const lessThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.LessThanToken);
-	const greaterThanToken = tokens.find((t) => t.kind === ts.SyntaxKind.GreaterThanToken);
-	const openParenToken = tokens.find((t) => t.kind === ts.SyntaxKind.OpenParenToken);
-	if (!lessThanToken || !greaterThanToken || !openParenToken) return;
-	const defineEmitsTypeArgRange = [offset + lessThanToken.pos, offset + greaterThanToken.end];
-	const runtimeArgPos = offset + openParenToken.end;
-	const printedRuntimeArg = printer.printEventsRuntimeArg(virtualFileDefineEmitsTypeNode);
-	s.remove(...defineEmitsTypeArgRange);
-	s.appendRight(runtimeArgPos, printedRuntimeArg);
-};
-
-//#endregion
-//#region src/core/transformers/defineProps.ts
-const transformDefineProps = (printer, s, id) => {
-	const normalizedFilepath = normalizePath(id);
-	const language = getLanguage();
-	const scriptSetupBlock = language.getScriptSetupBlock(normalizedFilepath);
-	const scriptSetupAst = language.getScriptSetupAst(normalizedFilepath);
-	const virtualFileAst = language.getVirtualFileOrTsAst(normalizedFilepath);
-	if (!scriptSetupBlock || !scriptSetupAst || !virtualFileAst) return;
-	const scriptSetupDefinePropsTypeRange = language.parseScriptSetupRanges(scriptSetupAst).defineProps?.typeArg;
-	const virtualFileDefinePropsTypeNode = language.findNodeByName(virtualFileAst, "__VLS_Props");
-	if (!scriptSetupDefinePropsTypeRange || !virtualFileDefinePropsTypeNode) return;
-	const printedType = printer.print(virtualFileDefinePropsTypeNode);
-	const offset = scriptSetupBlock.startTagEnd;
-	s.overwrite(offset + scriptSetupDefinePropsTypeRange.start, offset + scriptSetupDefinePropsTypeRange.end, printedType);
-};
-
-//#endregion
-//#region src/core/transformers/index.ts
-const transformers = [["defineEmits", transformDefineEmits], ["defineProps", transformDefineProps]];
-const getTransformers = (options) => transformers.filter(([key]) => !!options[key]);
-
-//#endregion
-//#region src/core/transform.ts
-function transform(code, id, options) {
-	const s = new MagicString(code);
-	const language = getLanguage();
-	const typeChecker = language.__internal__.typeChecker;
-	const printer = new Printer(typeChecker);
-	const transformers$1 = getTransformers(options);
-	for (const [, transform$1] of transformers$1) transform$1(printer, s, id);
-	return {
-		code: s.toString(),
-		map: s.generateMap({ hires: true })
-	};
-}
-
-//#endregion
-//#region src/index.ts
-const unpluginFactory = (options = {}) => {
-	const resolvedOptions = resolveOptions(options);
-	const filter = createFilter(resolvedOptions.include, resolvedOptions.exclude);
-	return {
-		name: "@vue.ts/complex-types",
-		buildStart() {
-			const resolvedOptions$1 = resolveOptions(options);
-			ensureLanguage(resolvedOptions$1.tsconfigPath);
-		},
-		transform(code, id) {
-			if (!filter(id)) return;
-			return transform(code, id, resolvedOptions);
-		}
-	};
-};
-const unplugin = /* @__PURE__ */ createUnplugin(unpluginFactory);
-var src_default = unplugin;
-
-//#endregion
-export { src_default, unplugin, unpluginFactory };