@vue.ts/complex-types 0.4.0

package/dist/index.mjs

@@ -0,0 +1,221 @@
+import { createFilter } from '@vue.ts/common';
+import { getLanguage, ensureLanguage } from '@vue.ts/language';
+import { createUnplugin } from 'unplugin';
+import MagicString from 'magic-string';
+import ts from 'typescript';
+import { join } from 'node:path';
+
+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, '\\"');
+
+class Printer {
+  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);
+  }
+  printIntersectionTypeNode(node) {
+    return node.types.map((t) => this.printTypeArg(t)).join(" & ");
+  }
+  printUnionTypeNode(node) {
+    return node.types.map((t) => this.printTypeArg(t)).join(" | ");
+  }
+  printTypeLiteralNode(node) {
+    const parts = ["{"];
+    for (const member of node.members) {
+      if (ts.isPropertySignature(member)) {
+        const stringBaseType = member.type ? this.checker.typeToString(this.getBaseType(member.type)) : "any";
+        parts.push(
+          [
+            member.name.getText(),
+            member.questionToken?.getText(),
+            ": ",
+            stringBaseType
+          ].filter(Boolean).join("")
+        );
+      }
+    }
+    parts.push("}");
+    return parts.join("\n");
+  }
+  printByType(node) {
+    const type = this.checker.getTypeAtLocation(node);
+    const properties = type.getProperties();
+    const parts = ["{"];
+    let questionToken = "";
+    if (ts.isMappedTypeNode(node)) {
+      questionToken = node.questionToken?.getText() ?? "";
+    }
+    for (const property of properties) {
+      const valueType = this.checker.getTypeOfSymbol(property);
+      const stringValueType = this.checker.typeToString(
+        this.getBaseType(valueType)
+      );
+      parts.push(
+        `${this.checker.symbolToString(
+          property
+        )}${questionToken}: ${stringValueType}`
+      );
+    }
+    parts.push("}");
+    return parts.join("\n");
+  }
+  printTypeArg(node) {
+    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.isMappedTypeNode(node) || ts.isTypeReferenceNode(node)) {
+      return this.printByType(node);
+    } else {
+      console.error(
+        `[unplugin-vue-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.checker.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(
+        "[unplugin-vue-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(", ")}]`;
+  }
+}
+
+const transformDefineEmits = (printer, s, id) => {
+  const language = getLanguage();
+  const defineEmits = language.findNodeByRange(
+    id,
+    (scriptSetupRanges) => scriptSetupRanges.emits.define
+  );
+  if (!defineEmits) {
+    return;
+  }
+  const scriptSetupAst = language.getScriptSetupAst(id);
+  const {
+    scriptNode: defineEmitsNode,
+    virtualFileNode: virtualFileDefineEmitsNode,
+    offset
+  } = defineEmits;
+  const defineEmitsTypeArg = ts.isCallExpression(virtualFileDefineEmitsNode) && virtualFileDefineEmitsNode.typeArguments?.[0];
+  const defineEmitsRuntimeArg = ts.isCallExpression(virtualFileDefineEmitsNode) && virtualFileDefineEmitsNode.arguments[0];
+  if (!defineEmitsTypeArg) {
+    return;
+  }
+  if (defineEmitsRuntimeArg) {
+    throw new Error(
+      "[unplugin-vue-complex-types] `defineEmits` cannot accept both runtime argument and type argument."
+    );
+  }
+  const tokens = defineEmitsNode.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(defineEmitsTypeArg);
+  s.remove(...defineEmitsTypeArgRange);
+  s.appendRight(runtimeArgPos, printedRuntimeArg);
+};
+
+const transformDefineProps = (printer, s, id) => {
+  const language = getLanguage();
+  const definePropsTypeArg = language.findNodeByRange(
+    id,
+    (scriptSetupRanges) => scriptSetupRanges.props.define?.typeArg
+  );
+  if (!definePropsTypeArg) {
+    return;
+  }
+  const { virtualFileNode: typeArgNode, setupRange: typeArgRange } = definePropsTypeArg;
+  const printedType = printer.printTypeArg(typeArgNode);
+  s.overwrite(typeArgRange.start, typeArgRange.end, printedType);
+};
+
+const transformers = [
+  ["defineEmits", transformDefineEmits],
+  ["defineProps", transformDefineProps]
+];
+const getTransformers = (options) => transformers.filter(([key]) => !!options[key]);
+
+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 = getTransformers(options);
+  for (const [, transform2] of transformers) {
+    transform2(printer, s, id);
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true })
+  };
+}
+
+const unplugin = createUnplugin((options = {}) => ({
+  name: "@vue.ts/complex-types",
+  buildStart() {
+    const resolvedOptions = resolveOptions(options);
+    ensureLanguage(resolvedOptions.tsconfigPath);
+  },
+  transform(code, id) {
+    const resolvedOptions = resolveOptions(options);
+    const filter = createFilter(
+      resolvedOptions.include,
+      resolvedOptions.exclude
+    );
+    if (!filter(id)) {
+      return;
+    }
+    return transform(code, id, resolvedOptions);
+  }
+}));
+
+export { unplugin as default };

package/dist/nuxt.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const kit = require('@nuxt/kit');
+const vite = require('./vite.cjs');
+const webpack = require('./webpack.cjs');
+require('./index.cjs');
+require('@vue.ts/common');
+require('@vue.ts/language');
+require('unplugin');
+require('magic-string');
+require('typescript');
+require('node:path');
+
+const name = "@vue.ts/complex-types";
+const version = "0.4.0";
+
+const nuxt = kit.defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "complexTypes",
+    compatibility: {
+      bridge: true
+    }
+  },
+  defaults: {
+    tsconfigPath: "tsconfig.json"
+  },
+  setup(options) {
+    kit.addVitePlugin(vite(options));
+    kit.addWebpackPlugin(webpack(options));
+  }
+});
+
+module.exports = nuxt;

package/dist/nuxt.d.cts

@@ -0,0 +1,9 @@
+import { ModuleDefinition } from '@nuxt/schema';
+import { Options } from './types.cjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: ModuleDefinition<Options>;
+
+export { _default as default };

package/dist/nuxt.d.mts

@@ -0,0 +1,9 @@
+import { ModuleDefinition } from '@nuxt/schema';
+import { Options } from './types.mjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: ModuleDefinition<Options>;
+
+export { _default as default };

package/dist/nuxt.d.ts

@@ -0,0 +1,9 @@
+import { ModuleDefinition } from '@nuxt/schema';
+import { Options } from './types.js';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: ModuleDefinition<Options>;
+
+export { _default as default };

package/dist/nuxt.mjs

@@ -0,0 +1,33 @@
+import { defineNuxtModule, addVitePlugin, addWebpackPlugin } from '@nuxt/kit';
+import VitePlugin from './vite.mjs';
+import WebpackPlugin from './webpack.mjs';
+import './index.mjs';
+import '@vue.ts/common';
+import '@vue.ts/language';
+import 'unplugin';
+import 'magic-string';
+import 'typescript';
+import 'node:path';
+
+const name = "@vue.ts/complex-types";
+const version = "0.4.0";
+
+const nuxt = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "complexTypes",
+    compatibility: {
+      bridge: true
+    }
+  },
+  defaults: {
+    tsconfigPath: "tsconfig.json"
+  },
+  setup(options) {
+    addVitePlugin(VitePlugin(options));
+    addWebpackPlugin(WebpackPlugin(options));
+  }
+});
+
+export { nuxt as default };

package/dist/rollup.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const index = require('./index.cjs');
+require('@vue.ts/common');
+require('@vue.ts/language');
+require('unplugin');
+require('magic-string');
+require('typescript');
+require('node:path');
+
+const rollup = index.rollup;
+
+module.exports = rollup;

package/dist/rollup.d.cts

@@ -0,0 +1,9 @@
+import * as rollup from 'rollup';
+import { Options } from './types.cjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => rollup.Plugin<any> | rollup.Plugin<any>[];
+
+export { _default as default };

package/dist/rollup.d.mts

@@ -0,0 +1,9 @@
+import * as rollup from 'rollup';
+import { Options } from './types.mjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => rollup.Plugin<any> | rollup.Plugin<any>[];
+
+export { _default as default };

package/dist/rollup.d.ts

@@ -0,0 +1,9 @@
+import * as rollup from 'rollup';
+import { Options } from './types.js';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => rollup.Plugin<any> | rollup.Plugin<any>[];
+
+export { _default as default };

package/dist/rollup.mjs

@@ -0,0 +1,11 @@
+import unplugin from './index.mjs';
+import '@vue.ts/common';
+import '@vue.ts/language';
+import 'unplugin';
+import 'magic-string';
+import 'typescript';
+import 'node:path';
+
+const rollup = unplugin.rollup;
+
+export { rollup as default };

package/dist/rspack.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const index = require('./index.cjs');
+require('@vue.ts/common');
+require('@vue.ts/language');
+require('unplugin');
+require('magic-string');
+require('typescript');
+require('node:path');
+
+const rspack = index.rspack;
+
+module.exports = rspack;

package/dist/rspack.d.cts

@@ -0,0 +1,8 @@
+import { Options } from './types.cjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => RspackPluginInstance;
+
+export { _default as default };

package/dist/rspack.d.mts

@@ -0,0 +1,8 @@
+import { Options } from './types.mjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => RspackPluginInstance;
+
+export { _default as default };

package/dist/rspack.d.ts

@@ -0,0 +1,8 @@
+import { Options } from './types.js';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => RspackPluginInstance;
+
+export { _default as default };

package/dist/rspack.mjs

@@ -0,0 +1,11 @@
+import unplugin from './index.mjs';
+import '@vue.ts/common';
+import '@vue.ts/language';
+import 'unplugin';
+import 'magic-string';
+import 'typescript';
+import 'node:path';
+
+const rspack = unplugin.rspack;
+
+export { rspack as default };

package/dist/types.cjs

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.d.cts

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

package/dist/types.d.mts

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

package/dist/types.d.ts

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

package/dist/types.mjs

@@ -0,0 +1 @@
+

package/dist/vite.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const index = require('./index.cjs');
+require('@vue.ts/common');
+require('@vue.ts/language');
+require('unplugin');
+require('magic-string');
+require('typescript');
+require('node:path');
+
+const VitePlugin = index.vite;
+
+module.exports = VitePlugin;

package/dist/vite.d.cts

@@ -0,0 +1,9 @@
+import * as vite from 'vite';
+import { Options } from './types.cjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => vite.Plugin<any> | vite.Plugin<any>[];
+
+export { _default as default };

package/dist/vite.d.mts

@@ -0,0 +1,9 @@
+import * as vite from 'vite';
+import { Options } from './types.mjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options?: Options | undefined) => vite.Plugin<any> | vite.Plugin<any>[];
+
+export { _default as default };

package/dist/vite.d.ts

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

package/dist/vite.mjs

@@ -0,0 +1,11 @@
+import unplugin from './index.mjs';
+import '@vue.ts/common';
+import '@vue.ts/language';
+import 'unplugin';
+import 'magic-string';
+import 'typescript';
+import 'node:path';
+
+const VitePlugin = unplugin.vite;
+
+export { VitePlugin as default };

package/dist/webpack.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const index = require('./index.cjs');
+require('@vue.ts/common');
+require('@vue.ts/language');
+require('unplugin');
+require('magic-string');
+require('typescript');
+require('node:path');
+
+const WebpackPlugin = index.webpack;
+
+module.exports = WebpackPlugin;

package/dist/webpack.d.cts

@@ -0,0 +1,9 @@
+import { WebpackPluginInstance } from 'unplugin';
+import { Options } from './types.cjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options: Options) => WebpackPluginInstance;
+
+export { _default as default };

package/dist/webpack.d.mts

@@ -0,0 +1,9 @@
+import { WebpackPluginInstance } from 'unplugin';
+import { Options } from './types.mjs';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options: Options) => WebpackPluginInstance;
+
+export { _default as default };

package/dist/webpack.d.ts

@@ -0,0 +1,9 @@
+import { WebpackPluginInstance } from 'unplugin';
+import { Options } from './types.js';
+import '@vue.ts/common';
+import 'magic-string';
+import 'typescript';
+
+declare const _default: (options: Options) => WebpackPluginInstance;
+
+export { _default as default };

package/dist/webpack.mjs

@@ -0,0 +1,11 @@
+import unplugin from './index.mjs';
+import '@vue.ts/common';
+import '@vue.ts/language';
+import 'unplugin';
+import 'magic-string';
+import 'typescript';
+import 'node:path';
+
+const WebpackPlugin = unplugin.webpack;
+
+export { WebpackPlugin as default };