@vue3-oop/preset-vue 2.4.14

package/compiled/@vue/babel-plugin-jsx/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@vue/babel-plugin-jsx",
+  "version": "1.1.5",
+  "license": "MIT",
+  "author": "Amour1688 <lcz_1996@foxmail.com>",
+  "_lastModified": "2024-01-07T08:42:45.781Z"
+}

package/dist/atomParser/index.d.ts

@@ -0,0 +1,14 @@
+import type { MetaCheckerOptions } from '@dumijs/vue-meta';
+import { IBaseApiParserOptions, ILanguageMetaParser } from 'dumi/tech-stack-utils';
+export interface VueParserOptions extends IBaseApiParserOptions {
+    tsconfigPath?: string;
+    /**
+     * By default, this option is the repository.directory option in package.json
+     *
+     * Mainly used to change the root directory of parser.
+     * The default root directory is obtained through getProjectRoot.
+     */
+    directory?: string;
+    checkerOptions?: MetaCheckerOptions;
+}
+export declare const VueApiParser: (opts: VueParserOptions) => import("../../../../dist/assetParsers/BaseParser").BaseAtomAssetsParser<ILanguageMetaParser>;

package/dist/atomParser/index.js

@@ -0,0 +1,115 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/atomParser/index.ts
+var atomParser_exports = {};
+__export(atomParser_exports, {
+  VueApiParser: () => VueApiParser
+});
+module.exports = __toCommonJS(atomParser_exports);
+var import_vue_meta = require("@dumijs/vue-meta");
+var import_dumi = require("dumi");
+var import_plugin_utils = require("dumi/plugin-utils");
+var import_tech_stack_utils = require("dumi/tech-stack-utils");
+var import_node_path = __toESM(require("node:path"));
+var VueMetaParser = class {
+  entryFile;
+  resolveDir;
+  checkerOptions;
+  checker;
+  constructor(opts) {
+    const {
+      tsconfigPath,
+      checkerOptions,
+      resolveDir,
+      entryFile,
+      directory = ""
+    } = opts;
+    this.checkerOptions = Object.assign(
+      {
+        // Source link generation is turned off by default, and will provided by dumi
+        disableSources: true
+      },
+      checkerOptions
+    );
+    this.resolveDir = resolveDir;
+    this.entryFile = import_node_path.default.resolve(this.resolveDir, entryFile);
+    this.checker = (0, import_vue_meta.createProject)({
+      rootPath: import_node_path.default.join((0, import_dumi.getProjectRoot)(resolveDir), directory),
+      tsconfigPath,
+      checkerOptions: this.checkerOptions
+    });
+  }
+  async patch(file) {
+    const { event, fileName } = file;
+    switch (event) {
+      case "add":
+      case "change": {
+        const fileContent = await import_plugin_utils.fsExtra.readFile(fileName, "utf8");
+        this.checker.patchFiles([
+          { action: event, fileName, text: fileContent }
+        ]);
+        return;
+      }
+      case "unlink":
+        this.checker.deleteFile(fileName);
+        return;
+    }
+  }
+  async parse() {
+    return this.checker.service.getComponentLibraryMeta(
+      this.entryFile,
+      import_vue_meta.dumiTransformer
+    );
+  }
+  async destroy() {
+    this.checker.close();
+  }
+};
+var VueApiParser = (0, import_tech_stack_utils.createApiParser)({
+  filename: __filename,
+  worker: VueMetaParser,
+  parseOptions: {
+    handleWatcher(watcher, { parse, patch, watchArgs }) {
+      return watcher.on("all", (ev, file) => {
+        if (["add", "change", "unlink"].includes(ev) && /((?<!\.d)\.ts|\.(jsx?|tsx|vue))$/.test(file)) {
+          const cwd = watchArgs.options.cwd;
+          patch({
+            event: ev,
+            fileName: import_node_path.default.join(cwd, file)
+          });
+          parse();
+        }
+      });
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VueApiParser
+});

package/dist/common.d.ts

@@ -0,0 +1,3 @@
+import type { IApi } from 'dumi';
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/common.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/common.ts
+var common_exports = {};
+__export(common_exports, {
+  default: () => common_default
+});
+module.exports = __toCommonJS(common_exports);
+var import_atomParser = require("./atomParser");
+var common_default = (api) => {
+  api.describe({
+    key: "preset-vue:common"
+  });
+  api.modifyBabelPresetOpts((memo) => {
+    memo.presetTypeScript = {
+      allExtensions: true,
+      isTSX: true
+    };
+    return memo;
+  });
+  api.modifyConfig((memo) => {
+    var _a, _b;
+    const userConfig = api.userConfig;
+    const vueConfig = userConfig == null ? void 0 : userConfig.vue;
+    const parserOptions = {
+      directory: (vueConfig == null ? void 0 : vueConfig.directory) ?? ((_a = api.pkg.repository) == null ? void 0 : _a.directory),
+      tsconfigPath: vueConfig == null ? void 0 : vueConfig.tsconfigPath,
+      checkerOptions: vueConfig == null ? void 0 : vueConfig.checkerOptions
+    };
+    const entryFile = (_b = userConfig == null ? void 0 : userConfig.resolve) == null ? void 0 : _b.entryFile;
+    const resolveDir = api.cwd;
+    const options = {
+      entryFile,
+      resolveDir
+    };
+    Object.assign(options, parserOptions);
+    if (!options.entryFile || !options.resolveDir) return memo;
+    api.service.atomParser = (0, import_atomParser.VueApiParser)(options);
+    return memo;
+  });
+};

package/dist/compiler/browser.d.ts

@@ -0,0 +1,3 @@
+export default function compile(code: string, { filename }: {
+    filename: string;
+}): string;

package/dist/compiler/browser.js

@@ -0,0 +1,78 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compiler/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  default: () => compile
+});
+module.exports = __toCommonJS(browser_exports);
+var import_babel_plugin_jsx = __toESM(require("@vue/babel-plugin-jsx"));
+var import_hash_sum = __toESM(require("hash-sum"));
+var import_index = require("./index");
+var { compileSFC, transformTS, toCommonJS } = (0, import_index.createCompiler)({
+  // @ts-ignore
+  typescript: () => window.ts,
+  babel: {
+    // @ts-ignore
+    transformSync(...args) {
+      if (typeof window !== void 0 && "Babel" in window) {
+        return Babel.transform(...args);
+      }
+      console.error("@babel/standablone is loading!");
+      return null;
+    }
+  },
+  availablePlugins: {
+    "vue-jsx": import_babel_plugin_jsx.default
+  }
+});
+function compile(code, { filename }) {
+  var _a;
+  const { lang } = (0, import_index.resolveFilename)(filename);
+  if (["js", "jsx", "ts", "tsx"].includes(lang)) {
+    return transformTS(code, filename, {
+      lang,
+      presets: [["env", { modules: "cjs" }]]
+    });
+  }
+  const id = (0, import_hash_sum.default)(filename);
+  const compiled = compileSFC({ id, filename, code });
+  if (Array.isArray(compiled)) {
+    throw compiled[0];
+  }
+  let { js, css } = compiled;
+  if (css) {
+    js += `
+${import_index.COMP_IDENTIFIER}.__css__ = ${JSON.stringify(css)};`;
+  }
+  js += `
+${import_index.COMP_IDENTIFIER}.__id__ = "${id}";
+    export default ${import_index.COMP_IDENTIFIER};`;
+  return ((_a = toCommonJS(js)) == null ? void 0 : _a.code) || "";
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,34 @@
+import type { BabelCore, babelCore } from 'dumi/tech-stack-utils';
+import type * as typescript from 'typescript';
+import { CompilerError } from 'vue/compiler-sfc';
+export interface CompileOptions {
+    id: string;
+    filename: string;
+    code: string;
+}
+export type CompileResult = (string | CompilerError | SyntaxError)[] | {
+    js: string;
+    css: string;
+};
+export declare function resolveFilename(filename: string): {
+    basename: string;
+    lang: string;
+};
+type Plugins = Record<string, BabelCore.PluginItem>;
+type CreateCompilerContext = {
+    typescript: () => typeof typescript;
+    babel: ReturnType<typeof babelCore>;
+    availablePlugins?: Plugins;
+    availablePresets?: Plugins;
+};
+export declare const COMP_IDENTIFIER = "__sfc__";
+export declare function createCompiler({ typescript, babel, availablePlugins, availablePresets, }: CreateCompilerContext): {
+    toCommonJS: (es: string) => BabelCore.BabelFileResult | null;
+    transformTS: (src: string, filename: string, options?: {
+        lang?: string;
+        plugins?: BabelCore.PluginItem[];
+        presets?: BabelCore.PluginItem[];
+    }) => string;
+    compileSFC: (options: CompileOptions) => CompileResult;
+};
+export {};

package/dist/compiler/index.js

@@ -0,0 +1,208 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compiler/index.ts
+var compiler_exports = {};
+__export(compiler_exports, {
+  COMP_IDENTIFIER: () => COMP_IDENTIFIER,
+  createCompiler: () => createCompiler,
+  resolveFilename: () => resolveFilename
+});
+module.exports = __toCommonJS(compiler_exports);
+var import_compiler_sfc = require("vue/compiler-sfc");
+function resolveFilename(filename) {
+  const [, basename, lang] = filename.match(/([^.]+)\.([^.]+)$/) || [];
+  return { basename, lang };
+}
+var COMP_IDENTIFIER = "__sfc__";
+function createCompiler({
+  typescript,
+  babel,
+  availablePlugins = {},
+  availablePresets = {}
+}) {
+  function toCommonJS(es) {
+    return babel.transformSync(es, {
+      presets: [[availablePresets["env"] ?? "env", { modules: "cjs" }]]
+    });
+  }
+  function transformTS(src, filename, options = {}) {
+    const { lang, plugins = [], presets = [] } = options;
+    if (lang === "ts" || lang === "tsx") {
+      const isTSX = lang === "tsx";
+      presets.push([
+        availablePresets["typescript"] ?? "typescript",
+        { isTSX, allExtensions: isTSX, onlyRemoveTypeImports: true }
+      ]);
+    }
+    if (lang === "tsx" || lang === "jsx") {
+      plugins.push(availablePlugins["vue-jsx"] ?? "vue-jsx");
+    }
+    const { basename } = resolveFilename(filename);
+    let code = src;
+    if ((lang === "ts" || lang === "tsx") && typescript()) {
+      const ts = typescript();
+      const { outputText } = ts.transpileModule(src, {
+        compilerOptions: {
+          module: ts.ModuleKind.ESNext,
+          target: ts.ScriptTarget.ES2020,
+          jsx: ts.JsxEmit.Preserve,
+          jsxImportSource: "vue",
+          isolatedModules: true,
+          experimentalDecorators: true,
+          emitDecoratorMetadata: true,
+          useDefineForClassFields: false,
+          verbatimModuleSyntax: true,
+          inlineSourceMap: true
+        },
+        fileName: basename + "." + (lang || "ts"),
+        reportDiagnostics: true
+      });
+      code = outputText;
+    }
+    const result = babel.transformSync(code, {
+      filename: basename + "." + (lang || "ts"),
+      presets,
+      plugins
+    });
+    return (result == null ? void 0 : result.code) || "";
+  }
+  function doCompileScript(id, descriptor, hasScoped, lang) {
+    const { filename, template, scriptSetup, script } = descriptor;
+    const templateContent = template == null ? void 0 : template.content;
+    const hasSetup = !!scriptSetup;
+    const isTS = lang === "ts" || lang === "tsx";
+    const expressionPlugins = [];
+    if (isTS) expressionPlugins.push("typescript");
+    if (lang === "jsx" || lang === "tsx") expressionPlugins.push("jsx");
+    let sfcCode = "";
+    if (script || scriptSetup) {
+      try {
+        const { content } = (0, import_compiler_sfc.compileScript)(descriptor, {
+          id,
+          inlineTemplate: hasSetup,
+          templateOptions: {
+            compilerOptions: { expressionPlugins }
+          }
+        });
+        sfcCode = transformTS(
+          (0, import_compiler_sfc.rewriteDefault)(content, COMP_IDENTIFIER, expressionPlugins),
+          filename,
+          { lang }
+        );
+      } catch (error) {
+        return [error];
+      }
+    } else {
+      sfcCode = `const ${COMP_IDENTIFIER} = {};`;
+    }
+    if (!hasSetup && templateContent) {
+      let { code, errors } = (0, import_compiler_sfc.compileTemplate)({
+        id,
+        filename,
+        source: templateContent,
+        scoped: hasScoped,
+        compilerOptions: { expressionPlugins }
+      });
+      if (errors.length) {
+        return errors;
+      }
+      code = transformTS(code, filename, { lang });
+      sfcCode += `
+${code.replace(
+        /\nexport (function|const) render/,
+        `$1 render`
+      )}
+      ${COMP_IDENTIFIER}.render = render;`;
+    }
+    return sfcCode;
+  }
+  function doCompileStyle(id, descriptor) {
+    const { filename } = descriptor;
+    const styleList = [];
+    for (const style of descriptor.styles) {
+      const { code, errors } = (0, import_compiler_sfc.compileStyle)({
+        source: style.content,
+        filename,
+        id,
+        scoped: style.scoped
+      });
+      if (errors.length) {
+        return errors;
+      }
+      styleList.push(code);
+    }
+    return styleList.join("\n");
+  }
+  function compileSFC(options) {
+    const { id, code, filename } = options;
+    const { descriptor, errors } = (0, import_compiler_sfc.parse)(code, { filename });
+    if (errors.length) {
+      return errors;
+    }
+    let js = "";
+    let skipStyleCompile = false;
+    if (descriptor.styles.some((style) => style.lang) || descriptor.template && descriptor.template.lang) {
+      skipStyleCompile = true;
+      js += '\nconsole.warn("Custom preprocessors for <template> and <style> are not supported in the Codeblock.")';
+    }
+    if (descriptor.styles.some((style) => style.module)) {
+      skipStyleCompile = true;
+      js += '\nconsole.warn("<style module> is not supported in the the Codeblock.")';
+    }
+    const scriptLang = descriptor.script && descriptor.script.lang || descriptor.scriptSetup && descriptor.scriptSetup.lang;
+    const hasScoped = descriptor.styles.some((style) => style.scoped);
+    const scriptResult = doCompileScript(
+      id,
+      descriptor,
+      hasScoped,
+      scriptLang || ""
+    );
+    if (Array.isArray(scriptResult)) {
+      return scriptResult;
+    }
+    js += `
+${scriptResult}`;
+    if (hasScoped) {
+      js += `
+${COMP_IDENTIFIER}.__scopeId = ${JSON.stringify(
+        `data-v-${id}`
+      )};`;
+    }
+    let css = "";
+    if (!skipStyleCompile) {
+      const styleResult = doCompileStyle(id, descriptor);
+      if (Array.isArray(styleResult)) {
+        return styleResult;
+      }
+      css = styleResult;
+    }
+    return { js, css };
+  }
+  return {
+    toCommonJS,
+    transformTS,
+    compileSFC
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMP_IDENTIFIER,
+  createCompiler,
+  resolveFilename
+});

package/dist/compiler/node.d.ts

@@ -0,0 +1,11 @@
+import { type CompileOptions } from './index';
+export declare const compiler: {
+    toCommonJS: (es: string) => import("@umijs/bundler-utils/compiled/@babel/core").BabelFileResult | null;
+    transformTS: (src: string, filename: string, options?: {
+        lang?: string | undefined;
+        plugins?: import("@umijs/bundler-utils/compiled/@babel/core").PluginItem[] | undefined;
+        presets?: import("@umijs/bundler-utils/compiled/@babel/core").PluginItem[] | undefined;
+    }) => string;
+    compileSFC: (options: CompileOptions) => import("./index").CompileResult;
+};
+export declare function compile(options: CompileOptions): string | (string | import("vue/compiler-sfc").CompilerError | SyntaxError)[];

package/dist/compiler/node.js

@@ -0,0 +1,75 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compiler/node.ts
+var node_exports = {};
+__export(node_exports, {
+  compile: () => compile,
+  compiler: () => compiler
+});
+module.exports = __toCommonJS(node_exports);
+var import_tech_stack_utils = require("dumi/tech-stack-utils");
+var ts = __toESM(require("typescript"));
+var import_index = require("./index");
+var babel = (0, import_tech_stack_utils.babelCore)();
+var env = (0, import_tech_stack_utils.babelPresetEnv)();
+var typescript = (0, import_tech_stack_utils.babelPresetTypeScript)();
+var compiler = (0, import_index.createCompiler)({
+  // @ts-ignore
+  typescript: () => globalThis.supportTsMetadata && ts,
+  babel,
+  availablePlugins: {
+    "vue-jsx": require.resolve("../../compiled/@vue/babel-plugin-jsx")
+  },
+  availablePresets: { env, typescript }
+});
+function compile(options) {
+  const { id, filename, code } = options;
+  const [, lang] = filename.match(/[^.]+\.([^.]+)$/) || [];
+  if (["js", "jsx", "ts", "tsx"].includes(lang)) {
+    return compiler.transformTS(code, filename, { lang });
+  }
+  const compiled = compiler.compileSFC(options);
+  if (Array.isArray(compiled)) {
+    return compiled;
+  }
+  let { js, css } = compiled;
+  if (css) {
+    js += `
+${import_index.COMP_IDENTIFIER}.__css__ = ${JSON.stringify(css)};`;
+  }
+  js += `
+${import_index.COMP_IDENTIFIER}.__id__ = "${id}";
+    export default ${import_index.COMP_IDENTIFIER};`;
+  return js;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compile,
+  compiler
+});

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { IApi } from 'dumi';
+import './requireHook';
+declare const _default: (api: IApi) => {
+    plugins: string[];
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,59 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_types = require("@umijs/core/dist/types");
+var import_requireHook = require("./requireHook");
+var src_default = (api) => {
+  api.describe({
+    key: "vue",
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          directory: zod.string().optional(),
+          tsconfigPath: zod.string().optional(),
+          supportTsMetadata: zod.boolean().optional(),
+          checkerOptions: zod.object({}).optional(),
+          compiler: zod.object({
+            babelStandaloneCDN: zod.string().optional(),
+            typescriptCDN: zod.string().optional()
+          }).optional()
+        });
+      }
+    },
+    enableBy: import_types.EnableBy.config
+  });
+  return {
+    plugins: [require.resolve("./common"), require.resolve("./vue")]
+  };
+};

package/dist/requireHook.d.ts

@@ -0,0 +1,2 @@
+declare const hookPropertyMap: Map<string, string>;
+export { hookPropertyMap };