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

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2022 Ray <https://github.com/so1ve>
-
-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.
+MIT License
+
+Copyright (c) 2022 Ray <https://github.com/so1ve>
+
+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

@@ -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>
@@ -38,6 +34,25 @@ export default defineConfig({
 
 <br></details>
 
+<details>
+<summary>Rolldown</summary><br>
+
+```ts
+// rolldown.config.js
+import VueComplexTypes from "@vue.ts/complex-types/rolldown";
+
+export default {
+	plugins: [
+		VueComplexTypes({
+			/* options */
+		}),
+		// other plugins
+	],
+};
+```
+
+<br></details>
+
 <details>
 <summary>Rollup</summary><br>
 

package/dist/astro.d.ts

@@ -1,13 +1,11 @@
-import { Options } from './types.js';
-import '@vue.ts/common';
-import 'magic-string';
-import 'typescript';
+import { t as Options } from "./types-B0cfnWIB.js";
 
+//#region src/astro.d.ts
 declare const _default: (options: Options) => {
-    name: string;
-    hooks: {
-        "astro:config:setup": (astro: any) => Promise<void>;
-    };
+  name: string;
+  hooks: {
+    "astro:config:setup": (astro: any) => Promise<void>;
+  };
 };
-
-export { _default as default };
+//#endregion
+export { _default as default };

package/dist/astro.js

@@ -0,0 +1,14 @@
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
+import { createVitePlugin } from "unplugin";
+
+//#region src/astro.ts
+var astro_default = (options) => ({
+	name: "@vue.ts/complex-types",
+	hooks: { "astro:config:setup": async (astro) => {
+		astro.config.vite.plugins ??= [];
+		astro.config.vite.plugins.push(createVitePlugin(unpluginFactory)(options));
+	} }
+});
+
+//#endregion
+export { astro_default as default };

package/dist/esbuild.d.ts

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

package/dist/esbuild.js

@@ -0,0 +1,8 @@
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
+import { createEsbuildPlugin } from "unplugin";
+
+//#region src/esbuild.ts
+var esbuild_default = createEsbuildPlugin(unpluginFactory);
+
+//#endregion
+export { esbuild_default as default };

package/dist/farm.d.ts

@@ -0,0 +1,8 @@
+import { t as Options } from "./types-B0cfnWIB.js";
+import "./types-u_Hr5uXA.js";
+import * as _farmfe_core0 from "@farmfe/core";
+
+//#region src/farm.d.ts
+declare const _default: (options?: Options | undefined) => _farmfe_core0.JsPlugin;
+//#endregion
+export { _default as default };

package/dist/farm.js

@@ -0,0 +1,8 @@
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
+import { createFarmPlugin } from "unplugin";
+
+//#region src/farm.ts
+var farm_default = createFarmPlugin(unpluginFactory);
+
+//#endregion
+export { farm_default as default };

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-import * as unplugin from 'unplugin';
-import { Options } from './types.js';
-import '@vue.ts/common';
-import 'magic-string';
-import 'typescript';
+import { t as Options } from "./types-B0cfnWIB.js";
+import * as unplugin0 from "unplugin";
+import { UnpluginFactory } from "unplugin";
 
-declare const _default: unplugin.UnpluginInstance<Options | undefined, boolean>;
-
-export { _default as default };
+//#region src/index.d.ts
+declare const unpluginFactory: UnpluginFactory<Options | undefined>;
+declare const unplugin: unplugin0.UnpluginInstance<Options | undefined, boolean>;
+//#endregion
+export { unplugin as default, unplugin, unpluginFactory };

package/dist/index.js

@@ -0,0 +1,3 @@
+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,9 +1,8 @@
-import { ModuleDefinition } from '@nuxt/schema';
-import { Options } from './types.js';
-import '@vue.ts/common';
-import 'magic-string';
-import 'typescript';
+import { t as Options } from "./types-B0cfnWIB.js";
+import "./types-u_Hr5uXA.js";
+import * as _nuxt_schema0 from "@nuxt/schema";
 
-declare const _default: ModuleDefinition<Options>;
-
-export { _default as default };
+//#region src/nuxt.d.ts
+declare const _default: _nuxt_schema0.NuxtModule<Options, Options, false>;
+//#endregion
+export { _default as default };

package/dist/nuxt.js

@@ -0,0 +1,20 @@
+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
+var nuxt_default = defineNuxtModule({
+	meta: {
+		name: "@vue.ts/complex-types",
+		configKey: "complexTypes"
+	},
+	defaults: {},
+	setup(options, _nuxt) {
+		addVitePlugin(() => vite_default(options));
+		addWebpackPlugin(() => webpack_default(options));
+	}
+});
+
+//#endregion
+export { nuxt_default as default };

package/dist/rolldown.d.ts

@@ -0,0 +1,8 @@
+import { t as Options } from "./types-B0cfnWIB.js";
+import "./types-u_Hr5uXA.js";
+import * as rolldown0 from "rolldown";
+
+//#region src/rolldown.d.ts
+declare const _default: (options?: Options | undefined) => rolldown0.Plugin<any> | rolldown0.Plugin<any>[];
+//#endregion
+export { _default as default };

package/dist/rolldown.js

@@ -0,0 +1,8 @@
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
+import { createRolldownPlugin } from "unplugin";
+
+//#region src/rolldown.ts
+var rolldown_default = createRolldownPlugin(unpluginFactory);
+
+//#endregion
+export { rolldown_default as default };

package/dist/rollup.d.ts

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

package/dist/rollup.js

@@ -0,0 +1,8 @@
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
+import { createRollupPlugin } from "unplugin";
+
+//#region src/rollup.ts
+var rollup_default = createRollupPlugin(unpluginFactory);
+
+//#endregion
+export { rollup_default as default };

package/dist/rspack.d.ts

@@ -1,8 +1,7 @@
-import { Options } from './types.js';
-import '@vue.ts/common';
-import 'magic-string';
-import 'typescript';
+import { t as Options } from "./types-B0cfnWIB.js";
+import "./types-u_Hr5uXA.js";
 
+//#region src/rspack.d.ts
 declare const _default: (options?: Options | undefined) => RspackPluginInstance;
-
-export { _default as default };
+//#endregion
+export { _default as default };

package/dist/rspack.js

@@ -0,0 +1,8 @@
+import { r as unpluginFactory } from "./src-Ci8DJn1t.js";
+import { createRspackPlugin } from "unplugin";
+
+//#region src/rspack.ts
+var rspack_default = createRspackPlugin(unpluginFactory);
+
+//#endregion
+export { rspack_default as default };

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-B0cfnWIB.d.ts

@@ -0,0 +1,37 @@
+import { FilterPattern } from "unplugin";
+import MagicString from "magic-string";
+import ts from "typescript";
+
+//#region ../shared/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 typeToString;
+  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;
+}
+//#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 { Transformers as a, Transformer as i, ResolvedOptions as n, ValidTransforms as o, TransformOptions as r, Options as t };

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 { 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-D-Xfh8NL.js

@@ -0,0 +1,8 @@
+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 as t };

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 { t as Options } from "./types-B0cfnWIB.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-Ci8DJn1t.js";
+import { t as vite_default } from "./vite-D-Xfh8NL.js";
+
+export { vite_default as default };