@vue3-oop/preset-vue 2.4.14

package/dist/requireHook.js

@@ -0,0 +1,67 @@
+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 = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __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 || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/requireHook.ts
+var requireHook_exports = {};
+__export(requireHook_exports, {
+  hookPropertyMap: () => hookPropertyMap
+});
+module.exports = __toCommonJS(requireHook_exports);
+var import_deepImports = __toESM(require("@umijs/bundler-webpack/compiled/webpack/deepImports.json"));
+var hookPropertyMap = /* @__PURE__ */ new Map([
+  ["webpack", "@umijs/bundler-webpack/compiled/webpack"],
+  ["webpack/package", "@umijs/bundler-webpack/compiled/webpack/package"],
+  ["webpack/package.json", "@umijs/bundler-webpack/compiled/webpack/package"],
+  ["webpack/lib/webpack", "@umijs/bundler-webpack/compiled/webpack"],
+  ["webpack/lib/webpack.js", "@umijs/bundler-webpack/compiled/webpack"],
+  ["tapable", "@umijs/bundler-utils/compiled/tapable"]
+]);
+import_deepImports.default.forEach((item) => {
+  const name = item.split("/").pop();
+  hookPropertyMap.set(item, `@umijs/bundler-webpack/compiled/webpack/${name}`);
+  hookPropertyMap.set(
+    `${item}.js`,
+    `@umijs/bundler-webpack/compiled/webpack/${name}`
+  );
+});
+var mod = require("module");
+var resolveFilename = mod._resolveFilename;
+mod._resolveFilename = function(request, parent, isMain, options) {
+  const hookResolved = hookPropertyMap.get(request);
+  return resolveFilename.call(
+    mod,
+    hookResolved ?? request,
+    parent,
+    isMain,
+    options
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hookPropertyMap
+});

package/dist/shared.d.ts

@@ -0,0 +1,11 @@
+import type { IApi } from 'dumi';
+export declare const BABEL_STANDALONE_CDN = "https://cdn.bootcdn.net/ajax/libs/babel-standalone/7.22.17/babel.min.js";
+export declare const TYPESCRIPT_STANDALONE_CDN = "https://cdn.bootcdn.net/ajax/libs/typescript/5.5.3/typescript.min.js";
+export declare function getPluginPath(api: IApi, filename: string): string;
+export declare function hasDep(pkg: any, dep: string): any;
+export declare function getPkgPath(dep: string, cwd: string): string;
+export declare function getDepVersion(opts: {
+    pkg: any;
+    cwd: string;
+    dep: string;
+}): string | undefined;

package/dist/shared.js

@@ -0,0 +1,64 @@
+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/shared.ts
+var shared_exports = {};
+__export(shared_exports, {
+  BABEL_STANDALONE_CDN: () => BABEL_STANDALONE_CDN,
+  TYPESCRIPT_STANDALONE_CDN: () => TYPESCRIPT_STANDALONE_CDN,
+  getDepVersion: () => getDepVersion,
+  getPkgPath: () => getPkgPath,
+  getPluginPath: () => getPluginPath,
+  hasDep: () => hasDep
+});
+module.exports = __toCommonJS(shared_exports);
+var import_plugin_utils = require("dumi/plugin-utils");
+var import_path = require("path");
+var BABEL_STANDALONE_CDN = "https://cdn.bootcdn.net/ajax/libs/babel-standalone/7.22.17/babel.min.js";
+var TYPESCRIPT_STANDALONE_CDN = "https://cdn.bootcdn.net/ajax/libs/typescript/5.5.3/typescript.min.js";
+function getPluginPath(api, filename) {
+  return (0, import_plugin_utils.winPath)(
+    (0, import_path.join)(api.paths.absTmpPath, `plugin-${api.plugin.key}`, filename)
+  );
+}
+function hasDep(pkg, dep) {
+  var _a, _b;
+  return ((_a = pkg.dependencies) == null ? void 0 : _a[dep]) || ((_b = pkg.devDependencies) == null ? void 0 : _b[dep]);
+}
+function getPkgPath(dep, cwd) {
+  return (0, import_path.dirname)(
+    import_plugin_utils.resolve.sync(`${dep}/package.json`, {
+      basedir: cwd
+    })
+  );
+}
+function getDepVersion(opts) {
+  if (hasDep(opts.pkg, opts.dep)) {
+    const pkgPath = getPkgPath(opts.dep, opts.cwd);
+    return require(pkgPath).version;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BABEL_STANDALONE_CDN,
+  TYPESCRIPT_STANDALONE_CDN,
+  getDepVersion,
+  getPkgPath,
+  getPluginPath,
+  hasDep
+});

package/dist/vue/checkVersion.d.ts

@@ -0,0 +1,2 @@
+import type { IApi } from 'dumi';
+export default function checkVersion(api: IApi): void;

package/dist/vue/checkVersion.js

@@ -0,0 +1,52 @@
+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/vue/checkVersion.ts
+var checkVersion_exports = {};
+__export(checkVersion_exports, {
+  default: () => checkVersion
+});
+module.exports = __toCommonJS(checkVersion_exports);
+var import_shared = require("../shared");
+var import_compare_versions = require("compare-versions");
+var import_plugin_utils = require("dumi/plugin-utils");
+function checkVersion(api) {
+  const vueVersion = (0, import_shared.getDepVersion)({
+    pkg: api.pkg,
+    cwd: api.cwd,
+    dep: "vue"
+  });
+  if (!vueVersion) {
+    throw new Error("Please install Vue.");
+  }
+  import_plugin_utils.logger.info(import_plugin_utils.chalk.cyan.bold(`Vue v${vueVersion}`));
+  const shouldInstallCompiler = (0, import_compare_versions.compare)(vueVersion, "3.3.6", "<");
+  const hasOwnCompiler = (0, import_shared.hasDep)(api.pkg, "@vue/compiler-sfc");
+  if (shouldInstallCompiler && !hasOwnCompiler) {
+    throw new Error(`Please install @vue/compiler-sfc v${vueVersion}`);
+  }
+  if (shouldInstallCompiler) {
+    api.modifyConfig((memo) => {
+      memo.alias = {
+        ...memo.alias,
+        "vue/compiler-sfc": "@vue/compiler-sfc"
+      };
+      return memo;
+    });
+  }
+}

package/dist/vue/index.d.ts

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

package/dist/vue/index.js

@@ -0,0 +1,56 @@
+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/vue/index.ts
+var vue_exports = {};
+__export(vue_exports, {
+  default: () => vue_default
+});
+module.exports = __toCommonJS(vue_exports);
+var import_checkVersion = __toESM(require("./checkVersion"));
+var import_techStack = __toESM(require("./techStack"));
+var import_webpack = __toESM(require("./webpack"));
+var vue_default = (api) => {
+  api.describe({
+    key: "preset-vue"
+    // dont add `:`, if use `api.writeTmpFile` in plugin
+  });
+  (0, import_checkVersion.default)(api);
+  (0, import_webpack.default)(api);
+  api.modifyDefaultConfig((config) => {
+    config.define = {
+      ...config.define,
+      __VUE_OPTIONS_API__: true,
+      __VUE_PROD_DEVTOOLS__: false,
+      __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: false
+      // vue3.4
+    };
+    return config;
+  });
+  (0, import_techStack.default)(api);
+};

package/dist/vue/techStack/index.d.ts

@@ -0,0 +1,2 @@
+import type { IApi } from 'dumi';
+export default function registerTechStack(api: IApi): void;

package/dist/vue/techStack/index.js

@@ -0,0 +1,95 @@
+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/vue/techStack/index.ts
+var techStack_exports = {};
+__export(techStack_exports, {
+  default: () => registerTechStack
+});
+module.exports = __toCommonJS(techStack_exports);
+var import_shared = require("../../shared");
+var import_plugin_utils = require("dumi/plugin-utils");
+var import_path = require("path");
+var import_jsx = require("./jsx");
+var import_sfc = require("./sfc");
+var COMPILE_FILENAME = "compiler.mjs";
+var RENDERER_FILENAME = "renderer.mjs";
+var PREFLIGHT_FILENAME = "preflight.mjs";
+function registerTechStack(api) {
+  var _a;
+  const vueConfig = (_a = api.userConfig) == null ? void 0 : _a.vue;
+  const pkgPath = (0, import_shared.getPkgPath)("@dumijs/preset-vue", api.cwd);
+  const libPath = (0, import_path.join)(pkgPath, "/lib");
+  api.onGenerateFiles(() => {
+    api.writeTmpFile({
+      path: COMPILE_FILENAME,
+      content: import_plugin_utils.fsExtra.readFileSync((0, import_path.join)(libPath, COMPILE_FILENAME), "utf8")
+    });
+    api.writeTmpFile({
+      path: RENDERER_FILENAME,
+      content: import_plugin_utils.fsExtra.readFileSync((0, import_path.join)(libPath, RENDERER_FILENAME), "utf8")
+    });
+    api.writeTmpFile({
+      path: PREFLIGHT_FILENAME,
+      content: import_plugin_utils.fsExtra.readFileSync((0, import_path.join)(libPath, PREFLIGHT_FILENAME), "utf8")
+    });
+  });
+  const runtimeOpts = {
+    compilePath: (0, import_shared.getPluginPath)(api, COMPILE_FILENAME),
+    rendererPath: (0, import_shared.getPluginPath)(api, RENDERER_FILENAME),
+    preflightPath: (0, import_shared.getPluginPath)(api, PREFLIGHT_FILENAME),
+    pluginPath: (0, import_path.join)(libPath, "runtimePlugin.mjs")
+  };
+  if (vueConfig.supportTsMetadata) {
+    globalThis.supportTsMetadata = true;
+  }
+  api.addHTMLHeadScripts(() => {
+    var _a2, _b;
+    const scripts = [
+      {
+        src: ((_a2 = vueConfig == null ? void 0 : vueConfig.compiler) == null ? void 0 : _a2.babelStandaloneCDN) || import_shared.BABEL_STANDALONE_CDN,
+        async: true
+      }
+    ];
+    if (vueConfig.supportTsMetadata) {
+      scripts.push({
+        src: ((_b = vueConfig == null ? void 0 : vueConfig.compiler) == null ? void 0 : _b.typescriptCDN) || import_shared.TYPESCRIPT_STANDALONE_CDN,
+        async: true
+      });
+    }
+    return scripts;
+  });
+  api.modifyConfig((memo) => {
+    memo.externals = {
+      ...memo.externals,
+      "@babel/standalone": "Babel",
+      typescript: "ts"
+    };
+    return memo;
+  });
+  api.register({
+    key: "registerTechStack",
+    stage: 0,
+    fn: () => (0, import_jsx.VueJSXTechStack)(runtimeOpts)
+  });
+  api.register({
+    key: "registerTechStack",
+    stage: 1,
+    fn: () => (0, import_sfc.VueSfcTechStack)(runtimeOpts)
+  });
+}

package/dist/vue/techStack/jsx.d.ts

@@ -0,0 +1,2 @@
+import type { IDumiTechStackRuntimeOpts } from 'dumi/tech-stack-utils';
+export declare const VueJSXTechStack: (runtimeOpts: IDumiTechStackRuntimeOpts) => import("dumi/tech-stack-utils").IDumiTechStack;

package/dist/vue/techStack/jsx.js

@@ -0,0 +1,81 @@
+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/vue/techStack/jsx.ts
+var jsx_exports = {};
+__export(jsx_exports, {
+  VueJSXTechStack: () => VueJSXTechStack
+});
+module.exports = __toCommonJS(jsx_exports);
+var import_node = require("../../compiler/node");
+var import_tech_stack_utils = require("dumi/tech-stack-utils");
+var import_hash_sum = __toESM(require("hash-sum"));
+var VueJSXTechStack = (runtimeOpts) => (0, import_tech_stack_utils.defineTechStack)({
+  name: "vue3-tsx",
+  runtimeOpts,
+  isSupported(_, lang) {
+    return ["jsx", "tsx"].includes(lang);
+  },
+  onBlockLoad(args) {
+    if (!args.path.endsWith(".tsx") && !args.path.endsWith(".jsx"))
+      return null;
+    const { filename } = args;
+    return {
+      type: "tsx",
+      content: (0, import_node.compile)({
+        id: filename,
+        filename,
+        code: args.entryPointCode
+      })
+    };
+  },
+  transformCode(raw, opts) {
+    if (opts.type === "code-block") {
+      const filename = opts.fileAbsPath;
+      const result = (0, import_node.compile)({
+        id: (0, import_hash_sum.default)(raw),
+        filename,
+        code: raw
+      });
+      if (result) {
+        const code = (0, import_tech_stack_utils.wrapDemoWithFn)(result, {
+          filename,
+          parserConfig: {
+            syntax: "ecmascript"
+          }
+        });
+        return `(${code})()`;
+      }
+    }
+    return raw;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VueJSXTechStack
+});

package/dist/vue/techStack/sfc.d.ts

@@ -0,0 +1,2 @@
+import type { IDumiTechStackRuntimeOpts } from 'dumi/tech-stack-utils';
+export declare const VueSfcTechStack: (runtimeOpts: IDumiTechStackRuntimeOpts) => import("dumi/tech-stack-utils").IDumiTechStack;

package/dist/vue/techStack/sfc.js

@@ -0,0 +1,80 @@
+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/vue/techStack/sfc.ts
+var sfc_exports = {};
+__export(sfc_exports, {
+  VueSfcTechStack: () => VueSfcTechStack
+});
+module.exports = __toCommonJS(sfc_exports);
+var import_node = require("../../compiler/node");
+var import_plugin_utils = require("dumi/plugin-utils");
+var import_tech_stack_utils = require("dumi/tech-stack-utils");
+var import_hash_sum = __toESM(require("hash-sum"));
+var VueSfcTechStack = (runtimeOpts) => (0, import_tech_stack_utils.defineTechStack)({
+  name: "vue3-sfc",
+  runtimeOpts,
+  isSupported(_, lang) {
+    return ["vue"].includes(lang);
+  },
+  onBlockLoad(args) {
+    if (!args.path.endsWith(".vue")) return null;
+    const result = import_node.compiler.compileSFC({
+      id: args.path,
+      code: args.entryPointCode,
+      filename: args.filename
+    });
+    return {
+      type: "tsx",
+      content: Array.isArray(result) ? "" : result.js
+    };
+  },
+  transformCode(raw, opts) {
+    if (opts.type === "code-block") {
+      const filename = opts.fileAbsPath;
+      const id = (0, import_hash_sum.default)(raw);
+      const js = (0, import_node.compile)({ id, filename, code: raw });
+      if (Array.isArray(js)) {
+        import_plugin_utils.logger.error(js);
+        return "";
+      }
+      const code = (0, import_tech_stack_utils.wrapDemoWithFn)(js, {
+        filename,
+        parserConfig: {
+          syntax: "ecmascript"
+        }
+      });
+      return `(${code})()`;
+    }
+    return raw;
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VueSfcTechStack
+});

package/dist/vue/webpack/config.d.ts

@@ -0,0 +1,3 @@
+import type Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import type { IApi } from 'dumi';
+export declare function getConfig(config: Config, api: IApi): void;

package/dist/vue/webpack/config.js

@@ -0,0 +1,85 @@
+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/vue/webpack/config.ts
+var config_exports = {};
+__export(config_exports, {
+  getConfig: () => getConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_tech_stack_utils = require("dumi/tech-stack-utils");
+var import_node_path = __toESM(require("node:path"));
+var import_pluginWebpack5 = __toESM(require("vue-loader/dist/pluginWebpack5.js"));
+function getConfig(config, api) {
+  var _a;
+  const dumiSrc = import_node_path.default.resolve(api.paths.absSrcPath);
+  const babelInUmi = config.module.rule("src").use("babel-loader").entries();
+  const { userConfig } = api;
+  config.module.rule("jsx-ts-tsx").include.add(dumiSrc).end();
+  config.module.rule("vue-jsx-tsx").test(/\.(jsx|ts|tsx)$/).exclude.add(dumiSrc).end().use("babel-loader").loader(babelInUmi.loader).options({
+    ...babelInUmi.options,
+    presets: [...babelInUmi.options.presets, (0, import_tech_stack_utils.babelPresetTypeScript)()],
+    plugins: [require.resolve("../../../compiled/@vue/babel-plugin-jsx")]
+  });
+  if ((_a = userConfig.vue) == null ? void 0 : _a.supportTsMetadata) {
+    config.module.rule("vue-jsx-tsx").use("ts-loader").loader(require.resolve("ts-loader")).after("babel-loader").options({
+      transpileOnly: true,
+      configFile: userConfig.vue.tsconfigPath
+    });
+  }
+  config.module.noParse(/^(vue|vue-router|vuex|vuex-router-sync)$/);
+  config.module.rule("esm").type("javascript/auto").test(/\.m?jsx?$/).resolve.set("fullySpecified", false);
+  config.resolve.extensions.merge([".vue"]).end();
+  config.module.rule("vue").test(/\.vue$/).exclude.add(dumiSrc).end().use("vue-loader").loader(require.resolve("vue-loader")).options({
+    babelParserPlugins: ["jsx", "classProperties", "decorators-legacy"]
+  });
+  config.plugin("vue-loader-plugin").use(import_pluginWebpack5.default);
+  config.module.rule("vue-style").test(/\.vue$/).exclude.add(dumiSrc).end().resourceQuery(/type=style/).sideEffects(true);
+  config.module.rule("fix-element-ui-plus").test(/\.mjs$/).include.add(/node_modules/).end().type("javascript/auto").resolve.fullySpecified(false);
+  config.module.rules.delete("asset");
+  const inlineLimit = parseInt(userConfig.inlineLimit || "10000", 10);
+  config.module.rule("avif").test(/\.avif$/).type("asset").mimetype("image/avif").parser({
+    dataUrlCondition: {
+      maxSize: inlineLimit
+    }
+  });
+  config.module.rule("image").test(/\.(bmp|gif|jpg|jpeg|png)$/).type("asset").parser({
+    dataUrlCondition: {
+      maxSize: inlineLimit
+    }
+  });
+  config.module.rules.delete("svg");
+  config.module.rule("svg").test(/\.svg$/).use("url-loader").loader(require.resolve("@umijs/bundler-webpack/compiled/url-loader")).options({
+    limit: userConfig.inlineLimit,
+    fallback: require.resolve("@umijs/bundler-webpack/compiled/file-loader")
+  }).end();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfig
+});

package/dist/vue/webpack/index.d.ts

@@ -0,0 +1,2 @@
+import type { IApi } from 'dumi';
+export default function (api: IApi): void;