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

package/dist/src-CI8-WIu4.js

@@ -0,0 +1,354 @@
+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 };

package/dist/types-CFmCIAvs.d.ts

@@ -0,0 +1,51 @@
+import MagicString from "magic-string";
+import ts from "typescript";
+import { FilterPattern } from "@rollup/pluginutils";
+
+//#region ../common/src/types.d.ts
+interface BaseOptions {
+  include?: FilterPattern;
+  exclude?: FilterPattern;
+}
+//#endregion
+//#region src/core/printer.d.ts
+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 printEventsByCallSignatures;
+  private printEventsByMembers;
+  printEventsRuntimeArg(node: ts.Node): string;
+}
+//#endregion
+//#region src/core/types.d.ts
+type ValidTransforms = "defineEmits" | "defineProps";
+type Options = {
+  tsconfigPath?: string;
+} & Partial<Record<ValidTransforms, boolean>> & BaseOptions;
+type ResolvedOptions = Required<Options>;
+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 };

package/dist/types-u_Hr5uXA.d.ts

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

package/dist/types.d.ts

@@ -1,30 +1,3 @@
-import { BaseOptions } from '@vue.ts/common';
-import MagicString from 'magic-string';
-import ts from 'typescript';
-
-declare class Printer {
-    private checker;
-    constructor(checker: ts.TypeChecker);
-    private getBaseType;
-    private printIntersectionTypeNode;
-    private printUnionTypeNode;
-    private printTypeLiteralNode;
-    private printByType;
-    printTypeArg(node: ts.Node): string;
-    private printEventsByCallSignatures;
-    private printEventsByMembers;
-    printEventsRuntimeArg(node: ts.Node): string;
-}
-
-type ValidTransforms = "defineEmits" | "defineProps";
-type Options = {
-    tsconfigPath?: string;
-} & {
-    [Transform in ValidTransforms]?: boolean;
-} & BaseOptions;
-type ResolvedOptions = Required<Options>;
-type TransformOptions = Pick<ResolvedOptions, ValidTransforms>;
-type Transformer = (printer: Printer, s: MagicString, id: string) => void;
-type Transformers = [ValidTransforms, Transformer][];
-
-export type { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms };
+import { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms } from "./types-CFmCIAvs.js";
+import "./types-u_Hr5uXA.js";
+export { Options, ResolvedOptions, TransformOptions, Transformer, Transformers, ValidTransforms };

package/dist/vite-Dyi1m2wg.js

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

package/dist/vite.d.ts

@@ -1,9 +1,8 @@
-import * as vite from 'vite';
-import { Options } from './types.js';
-import '@vue.ts/common';
-import 'magic-string';
-import 'typescript';
+import { Options } from "./types-CFmCIAvs.js";
+import "./types-u_Hr5uXA.js";
+import * as vite0 from "vite";
 
-declare const _default: (options?: Options | undefined) => vite.Plugin<any> | vite.Plugin<any>[];
-
-export { _default as default };
+//#region src/vite.d.ts
+declare const _default: (options?: Options | undefined) => vite0.Plugin<any> | vite0.Plugin<any>[];
+//#endregion
+export { _default as default };

package/dist/vite.js

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

package/dist/webpack-CFfuQfGw.js

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

package/dist/webpack.d.ts

@@ -1,9 +1,8 @@
-import { WebpackPluginInstance } from 'unplugin';
-import { Options } from './types.js';
-import '@vue.ts/common';
-import 'magic-string';
-import 'typescript';
+import { Options } from "./types-CFmCIAvs.js";
+import "./types-u_Hr5uXA.js";
+import * as webpack0 from "webpack";
 
-declare const _default: (options: Options) => WebpackPluginInstance;
-
-export { _default as default };
+//#region src/webpack.d.ts
+declare const _default: (options?: Options | undefined) => webpack0.WebpackPluginInstance;
+//#endregion
+export { _default as default };

package/dist/webpack.js

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

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@vue.ts/complex-types",
-  "version": "0.5.0",
+  "version": "1.0.0-beta.1",
   "author": "Ray <i@mk1.io> (@so1ve)",
+  "type": "module",
   "description": "Resolve complex types in Vue SFCs.",
   "keywords": [
     "astro",
+    "farm",
     "nuxt",
+    "rolldown",
     "rollup",
     "rspack",
     "transform",
@@ -13,6 +16,7 @@
     "unplugin",
     "vite",
     "vue",
+    "vue.ts",
     "webpack"
   ],
   "homepage": "https://github.com/so1ve/vue.ts/tree/main/packages/language#readme",
@@ -27,46 +31,22 @@
   "license": "MIT",
   "sideEffects": false,
   "exports": {
-    ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs"
-    },
+    ".": "./dist/index.js",
     "./*": "./*",
-    "./astro": {
-      "require": "./dist/astro.cjs",
-      "import": "./dist/astro.mjs"
-    },
-    "./esbuild": {
-      "require": "./dist/esbuild.cjs",
-      "import": "./dist/esbuild.mjs"
-    },
-    "./nuxt": {
-      "require": "./dist/nuxt.cjs",
-      "import": "./dist/nuxt.mjs"
-    },
-    "./rollup": {
-      "require": "./dist/rollup.cjs",
-      "import": "./dist/rollup.mjs"
-    },
-    "./rspack": {
-      "require": "./dist/rspack.cjs",
-      "import": "./dist/rspack.mjs"
-    },
-    "./types": {
-      "require": "./dist/types.cjs",
-      "import": "./dist/types.mjs"
-    },
-    "./vite": {
-      "require": "./dist/vite.cjs",
-      "import": "./dist/vite.mjs"
-    },
-    "./webpack": {
-      "require": "./dist/webpack.cjs",
-      "import": "./dist/webpack.mjs"
-    }
+    "./astro": "./dist/astro.js",
+    "./esbuild": "./dist/esbuild.js",
+    "./farm": "./dist/farm.js",
+    "./nuxt": "./dist/nuxt.js",
+    "./rolldown": "./dist/rolldown.js",
+    "./rollup": "./dist/rollup.js",
+    "./rspack": "./dist/rspack.js",
+    "./types": "./dist/types.js",
+    "./vite": "./dist/vite.js",
+    "./webpack": "./dist/webpack.js"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "dist/index.d.ts",
   "typesVersions": {
     "*": {
       "*": [
@@ -82,26 +62,60 @@
     "access": "public"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.8.1",
-    "magic-string": "^0.30.5",
-    "unplugin": "^1.5.0",
-    "@vue.ts/common": "0.5.0",
-    "@vue.ts/language": "0.5.0"
+    "@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"
   },
   "devDependencies": {
-    "@nuxt/schema": "^3.8.1",
-    "@vue-macros/better-define": "^1.6.12",
-    "rollup": "^4.3.0",
-    "unbuild": "^2.0.0",
-    "vite": "^5.0.2",
-    "webpack": "^5.89.0"
+    "@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"
   },
   "peerDependencies": {
+    "@farmfe/core": ">=1",
+    "@nuxt/kit": "^3 || ^4",
+    "@nuxt/schema": "^3 || ^4",
+    "esbuild": "*",
+    "rolldown": "*",
+    "rollup": "^3",
     "typescript": "^5.2.2",
-    "vue": "^3.3.7"
+    "vite": ">=3",
+    "vue": "^3.3.7",
+    "webpack": "^4 || ^5"
+  },
+  "peerDependenciesMeta": {
+    "@farmfe/core": {
+      "optional": true
+    },
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@nuxt/schema": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "rolldown": {
+      "optional": true
+    },
+    "rollup": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    },
+    "webpack": {
+      "optional": true
+    }
   },
   "scripts": {
-    "build": "unbuild",
-    "stub": "unbuild --stub"
+    "build": "tsdown",
+    "watch": "tsdown --watch"
   }
 }