@umijs/plugins 4.0.0-beta.8 → 4.0.0-canary-20240513.3

package/dist/qiankun/slave.js

@@ -0,0 +1,345 @@
+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/qiankun/slave.ts
+var slave_exports = {};
+__export(slave_exports, {
+  default: () => slave_default
+});
+module.exports = __toCommonJS(slave_exports);
+var import_http_proxy_middleware = require("@umijs/bundler-utils/compiled/http-proxy-middleware");
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_umi = require("umi");
+var import_plugin_utils = require("umi/plugin-utils");
+var import_withTmpPath = require("../utils/withTmpPath");
+var import_constants = require("./constants");
+function getCurrentLocalDevServerEntry(api, req) {
+  const port = api.appData.port;
+  const hostname = req.hostname;
+  const protocol = req.protocol;
+  return `${protocol}://${hostname}${port ? ":" : ""}${port}/local-dev-server`;
+}
+function handleOriginalHtml(api, microAppEntry, originalHtml) {
+  var _a, _b;
+  const appName = ((_b = (_a = api.config.qiankun) == null ? void 0 : _a.slave) == null ? void 0 : _b.appName) || api.pkg.name;
+  (0, import_assert.default)(
+    appName,
+    "[@umijs/plugin-qiankun]: You should have name in package.json"
+  );
+  const $ = import_utils.cheerio.load(originalHtml);
+  $("head").prepend(
+    `<script>window.__QIANKUN_DEVELOPMENT__=true</script>
+    <script type="extra-qiankun-config">${JSON.stringify({
+      master: {
+        apps: [
+          {
+            name: appName,
+            entry: microAppEntry,
+            extraSource: microAppEntry
+          }
+        ],
+        routes: [
+          {
+            microApp: appName,
+            name: appName,
+            path: "/" + appName,
+            extraSource: microAppEntry
+          }
+        ],
+        prefetch: false
+      }
+    })}</script>`
+  );
+  return api.applyPlugins({
+    key: "modifyMasterHTML",
+    type: api.ApplyPluginsType.modify,
+    initialValue: $.html()
+  });
+}
+function isSlaveEnable(opts) {
+  var _a, _b;
+  const slaveCfg = (_b = (_a = opts.userConfig) == null ? void 0 : _a.qiankun) == null ? void 0 : _b.slave;
+  if (slaveCfg) {
+    return slaveCfg.enable !== false;
+  }
+  return !!process.env.INITIAL_QIANKUN_SLAVE_OPTIONS;
+}
+var slave_default = (api) => {
+  api.describe({
+    key: "qiankun-slave",
+    enableBy: isSlaveEnable
+  });
+  api.addRuntimePlugin(() => {
+    return [(0, import_withTmpPath.withTmpPath)({ api, path: "slaveRuntimePlugin.ts" })];
+  });
+  api.register({
+    key: "addExtraModels",
+    fn() {
+      return [
+        (0, import_withTmpPath.withTmpPath)({
+          api,
+          path: `qiankunModel.ts#{"namespace":"${import_constants.qiankunStateFromMasterModelNamespace}"}`
+        })
+      ];
+    }
+  });
+  api.onGenerateFiles(() => {
+    api.writeTmpFile({
+      path: import_umi.RUNTIME_TYPE_FILE_NAME,
+      content: `
+interface LifeCycles {
+    bootstrap?: (props?: any) => Promise<any>;
+    mount?: (props?: any) => Promise<any>;
+    unmount?: (props?: any) => Promise<any>;
+    update?: (props?: any) => Promise<any>;
+}
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+type XOR<T, U> = (Without<T, U> & U) | (Without<U, T> & T);
+interface SlaveOption extends LifeCycles {
+    enable?: boolean;
+}
+interface Config {
+    slave?: SlaveOption;
+}
+export interface IRuntimeConfig {
+    qiankun?: XOR<Config, LifeCycles>
+}
+      `
+    });
+  });
+  api.modifyDefaultConfig((memo) => {
+    var _a, _b, _c, _d, _e;
+    const initialSlaveOptions = {
+      devSourceMap: true,
+      ...JSON.parse(process.env.INITIAL_QIANKUN_SLAVE_OPTIONS || "{}"),
+      ...(memo.qiankun || {}).slave
+    };
+    const modifiedDefaultConfig = {
+      ...memo,
+      // 默认开启 runtimePublicPath，避免出现 dynamic import 场景子应用资源地址出问题
+      runtimePublicPath: true,
+      qiankun: {
+        ...memo.qiankun,
+        slave: initialSlaveOptions
+      }
+    };
+    const shouldNotModifyDefaultBase = ((_b = (_a = api.userConfig.qiankun) == null ? void 0 : _a.slave) == null ? void 0 : _b.shouldNotModifyDefaultBase) ?? initialSlaveOptions.shouldNotModifyDefaultBase;
+    const historyType = ((_c = api.userConfig.history) == null ? void 0 : _c.type) || "browser";
+    if (!shouldNotModifyDefaultBase && historyType !== "hash") {
+      modifiedDefaultConfig.base = `/${api.pkg.name}`;
+    }
+    if (modifiedDefaultConfig.mfsu !== false) {
+      modifiedDefaultConfig.mfsu = {
+        ...modifiedDefaultConfig.mfsu,
+        mfName: ((_d = modifiedDefaultConfig.mfsu) == null ? void 0 : _d.mfName) || `mf_${(_e = api.pkg.name) == null ? void 0 : _e.replace(/^@/, "").replace(/\W/g, "_")}`
+      };
+    }
+    return modifiedDefaultConfig;
+  });
+  api.addHTMLHeadScripts(() => {
+    var _a, _b;
+    const dontModify = (_b = (_a = api.config.qiankun) == null ? void 0 : _a.slave) == null ? void 0 : _b.shouldNotModifyRuntimePublicPath;
+    return dontModify ? [] : [
+      `window.publicPath = window.__INJECTED_PUBLIC_PATH_BY_QIANKUN__ || "${api.config.publicPath || "/"}";`
+    ];
+  });
+  api.chainWebpack((config, { ssr }) => {
+    if (ssr) {
+      return;
+    }
+    (0, import_assert.default)(api.pkg.name, "You should have name in package.json.");
+    const {
+      shouldNotAddLibraryChunkName = api.env === "production" || !Boolean(api.config.mfsu)
+    } = (api.config.qiankun || {}).slave;
+    config.output.libraryTarget("umd").library(
+      shouldNotAddLibraryChunkName ? api.pkg.name : `${api.pkg.name}-[name]`
+    );
+    return config;
+  });
+  api.modifyHTML(($) => {
+    $("script").each((_, el) => {
+      const scriptEl = $(el);
+      const umiEntry = /\/?umi(\.\w+)?\.js$/g;
+      if (umiEntry.test(scriptEl.attr("src") ?? "")) {
+        scriptEl.attr("entry", "");
+      }
+    });
+    return $;
+  });
+  api.addEntryImports(() => {
+    return [
+      {
+        source: "@@/plugin-qiankun-slave/lifecycles",
+        specifier: "{ genMount as qiankun_genMount, genBootstrap as qiankun_genBootstrap, genUnmount as qiankun_genUnmount, genUpdate as qiankun_genUpdate }"
+      }
+    ];
+  });
+  api.addEntryCode(() => [
+    `
+const qiankun_noop = () => new Error('qiankun lifecycle is not available for server runtime!');
+const isServer = typeof window === 'undefined';
+export const bootstrap = isServer ? qiankun_noop: qiankun_genBootstrap(render);
+export const mount = isServer ? qiankun_noop : qiankun_genMount('${api.config.mountElementId}');
+export const unmount = isServer ? qiankun_noop : qiankun_genUnmount('${api.config.mountElementId}');
+export const update = isServer ? qiankun_noop : qiankun_genUpdate();
+// 增加 ssr 的判断
+if (!isServer && !window.__POWERED_BY_QIANKUN__) {
+  bootstrap().then(mount);
+}
+    `
+  ]);
+  function getFileContent(file) {
+    return (0, import_fs.readFileSync)(
+      (0, import_path.join)(__dirname, "../../libs/qiankun/slave", file),
+      "utf-8"
+    );
+  }
+  api.onGenerateFiles({
+    fn() {
+      [
+        "constants.ts",
+        "qiankunModel.ts",
+        "connectMaster.tsx",
+        "MicroAppLink.tsx",
+        "slaveRuntimePlugin.ts",
+        "lifecycles.ts"
+      ].forEach((file) => {
+        api.writeTmpFile({
+          path: file.replace(/\.tpl$/, ""),
+          content: getFileContent(file).replace(
+            "__USE_MODEL__",
+            api.isPluginEnable("model") ? `import { useModel } from '@@/plugin-model'` : `const useModel = null;`
+          ).replace(
+            /from 'qiankun'/g,
+            `from '${(0, import_plugin_utils.winPath)((0, import_path.dirname)(require.resolve("qiankun/package")))}'`
+          ).replace(
+            /from 'lodash\//g,
+            `from '${(0, import_plugin_utils.winPath)((0, import_path.dirname)(require.resolve("lodash/package")))}/`
+          )
+        });
+      });
+      api.writeTmpFile({
+        path: "index.ts",
+        content: `
+export { connectMaster } from './connectMaster';
+export { MicroAppLink } from './MicroAppLink';
+      `
+      });
+    },
+    before: "model"
+  });
+  api.addMiddlewares(async () => {
+    return async (req, res, next) => {
+      var _a;
+      const qiankunConfig = api.config.qiankun || {};
+      const masterEntry = (_a = qiankunConfig.slave) == null ? void 0 : _a.masterEntry;
+      const { proxyToMasterEnabled } = await api.applyPlugins({
+        key: "shouldProxyToMaster",
+        type: api.ApplyPluginsType.modify,
+        initialValue: { proxyToMasterEnabled: true, req }
+      }) ?? {};
+      if (masterEntry && proxyToMasterEnabled) {
+        await api.applyPlugins({
+          key: "onLocalProxyStart",
+          type: api.ApplyPluginsType.event
+        });
+        const modifyLocalProxyOpts = await api.applyPlugins({
+          key: "modifyLocalProxyOpts",
+          type: api.ApplyPluginsType.modify,
+          initialValue: {}
+        }) ?? {};
+        const localProxyOpts = {
+          target: masterEntry,
+          secure: false,
+          ignorePath: false,
+          followRedirects: false,
+          changeOrigin: true,
+          selfHandleResponse: true,
+          ...modifyLocalProxyOpts
+        };
+        return (0, import_http_proxy_middleware.createProxyMiddleware)(
+          (pathname) => pathname !== "/local-dev-server",
+          {
+            ...localProxyOpts,
+            onProxyReq(proxyReq) {
+              api.applyPlugins({
+                key: "onLocalProxyReq",
+                type: api.ApplyPluginsType.event,
+                sync: true,
+                args: proxyReq
+              });
+            },
+            onProxyRes: (0, import_http_proxy_middleware.responseInterceptor)(
+              async (responseBuffer, proxyRes, req2, res2) => {
+                var _a2;
+                if (proxyRes.statusCode === 302) {
+                  const { ignorePath = false } = localProxyOpts;
+                  const { hostname, url, protocol } = req2;
+                  const port = process.env.PORT || ((_a2 = api.appData) == null ? void 0 : _a2.port);
+                  const gotoBasePart = `${protocol}://${hostname}:${port}${ignorePath && url ? url : "/"}`;
+                  const fromBasePart = masterEntry;
+                  const locationUrl = proxyRes.headers.location || "";
+                  const [originAndPath, searchParams] = locationUrl.split("?");
+                  const searchHandled = searchParams ? `?${searchParams.replace(
+                    encodeURIComponent(fromBasePart),
+                    encodeURIComponent(gotoBasePart)
+                  )}` : "";
+                  const redirectUrl = `${originAndPath}${searchHandled}`;
+                  const redirectMessage = `[@umijs/plugin-qiankun]: redirect to ${redirectUrl}`;
+                  api.logger.info(redirectMessage);
+                  res2.statusCode = 302;
+                  res2.setHeader("location", redirectUrl);
+                  return redirectMessage;
+                }
+                const microAppEntry = getCurrentLocalDevServerEntry(api, req2);
+                const originalHtml = responseBuffer.toString("utf8");
+                const html = handleOriginalHtml(
+                  api,
+                  microAppEntry,
+                  originalHtml
+                );
+                return html;
+              }
+            ),
+            onError(err, _, res2) {
+              api.logger.error(err);
+              res2.set("content-type", "text/plain; charset=UTF-8");
+              res2.end(
+                `[@umijs/plugin-qiankun] 代理到 ${masterEntry} 时出错了，请尝试 ${masterEntry} 是否是可以正常访问的，然后重新启动项目试试。(注意如果出现跨域问题，请修改本地 host ，通过一个和主应用相同的一级域名的域名来访问 127.0.0.1)`
+              );
+            }
+          }
+        )(req, res, next);
+      }
+      return next();
+    };
+  });
+};

package/dist/qiankun.d.ts

@@ -1,3 +1,3 @@
+import { IApi } from 'umi';
 declare const _default: (api: IApi) => void;
 export default _default;
-//# sourceMappingURL=qiankun.d.ts.map

package/dist/qiankun.js

@@ -1,5 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (api) => {
-    api;
+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/qiankun.ts
+var qiankun_exports = {};
+__export(qiankun_exports, {
+  default: () => qiankun_default
+});
+module.exports = __toCommonJS(qiankun_exports);
+var qiankun_default = (api) => {
+  api.describe({
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          slave: zod.record(zod.any()),
+          master: zod.record(zod.any()),
+          externalQiankun: zod.boolean()
+        }).deepPartial();
+      }
+    }
+  });
+  api.addRuntimePluginKey(() => ["qiankun"]);
+  api.registerPlugins([
+    require.resolve("./qiankun/master"),
+    require.resolve("./qiankun/slave")
+  ]);
 };

package/dist/react-query.d.ts

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

package/dist/react-query.js

@@ -0,0 +1,193 @@
+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/react-query.ts
+var react_query_exports = {};
+__export(react_query_exports, {
+  default: () => react_query_default
+});
+module.exports = __toCommonJS(react_query_exports);
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var import_resolveProjectDep = require("./utils/resolveProjectDep");
+var import_withTmpPath = require("./utils/withTmpPath");
+var react_query_default = (api) => {
+  api.describe({
+    key: "reactQuery",
+    config: {
+      schema({ zod }) {
+        return zod.object({
+          devtool: zod.union([zod.record(zod.any()), zod.boolean()]),
+          queryClient: zod.union([zod.record(zod.any()), zod.boolean()])
+        }).deepPartial();
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  let pkgPath;
+  let devtoolsPkgPath;
+  const REACT_QUERY_DEP_NAME = "@tanstack/react-query";
+  const REACT_QUERY_DEVTOOLS_DEP_NAME = "@tanstack/react-query-devtools";
+  const defaultPkgPath = (0, import_utils.winPath)(
+    (0, import_path.dirname)(require.resolve(`${REACT_QUERY_DEP_NAME}/package.json`))
+  );
+  const defaultDevtoolPkgPath = (0, import_utils.winPath)(
+    (0, import_path.dirname)(require.resolve(`${REACT_QUERY_DEVTOOLS_DEP_NAME}/package.json`))
+  );
+  try {
+    const localQueryPath = (0, import_resolveProjectDep.resolveProjectDep)({
+      pkg: api.pkg,
+      cwd: api.cwd,
+      dep: REACT_QUERY_DEP_NAME
+    });
+    pkgPath = localQueryPath ? (0, import_utils.winPath)(localQueryPath) : defaultPkgPath;
+  } catch (e) {
+    throw new Error(
+      `[reactQuery] package '${REACT_QUERY_DEP_NAME}' resolve failed, ${e.message}`
+    );
+  }
+  try {
+    const localDevtoolsPkgPath = (0, import_resolveProjectDep.resolveProjectDep)({
+      pkg: api.pkg,
+      cwd: api.cwd,
+      dep: REACT_QUERY_DEVTOOLS_DEP_NAME
+    });
+    devtoolsPkgPath = localDevtoolsPkgPath ? (0, import_utils.winPath)(localDevtoolsPkgPath) : defaultDevtoolPkgPath;
+  } catch (e) {
+    throw new Error(
+      `[reactQuery] package '${REACT_QUERY_DEVTOOLS_DEP_NAME}' resolve failed, ${e.message}`
+    );
+  }
+  const pkg = require((0, import_path.join)(pkgPath, "package.json"));
+  const devtoolsPkg = require((0, import_path.join)(devtoolsPkgPath, "package.json"));
+  const pkgVersion = pkg.version;
+  const devtoolsVersion = devtoolsPkg.version;
+  const useV4 = pkgVersion.startsWith("4");
+  const useV4Devtools = devtoolsVersion.startsWith("4");
+  const useV5 = pkgVersion.startsWith("5");
+  const useV5Devtools = devtoolsVersion.startsWith("5");
+  const canUseDevtools = useV4 && useV4Devtools || useV5 && useV5Devtools;
+  api.onStart(() => {
+    if (pkgPath !== defaultPkgPath && !process.env.IS_UMI_BUILD_WORKER) {
+      api.logger.info(`[reactQuery] use local package, version: ${pkgVersion}`);
+    }
+  });
+  api.addRuntimePlugin(() => {
+    return [(0, import_withTmpPath.withTmpPath)({ api, path: "runtime.tsx" })];
+  });
+  api.addRuntimePluginKey(() => {
+    return ["reactQuery"];
+  });
+  api.modifyConfig((memo) => {
+    memo.alias[REACT_QUERY_DEP_NAME] = pkgPath;
+    if (canUseDevtools) {
+      memo.alias[REACT_QUERY_DEVTOOLS_DEP_NAME] = devtoolsPkgPath;
+    }
+    return memo;
+  });
+  api.onGenerateFiles(() => {
+    var _a;
+    const enableDevTools = api.config.reactQuery.devtool !== false && canUseDevtools;
+    const enableQueryClient = api.config.reactQuery.queryClient !== false;
+    const reactQueryRuntimeCode = ((_a = api.appData.appJS) == null ? void 0 : _a.exports.includes(
+      "reactQuery"
+    )) ? `import { reactQuery as reactQueryConfig } from '@/app';` : `const reactQueryConfig = {};`;
+    api.writeTmpFile({
+      path: "runtime.tsx",
+      content: enableQueryClient ? `
+import React from 'react';
+import {
+  ${useV4 ? "defaultContext," : ""}
+  QueryClient,
+  QueryClientProvider
+} from '${pkgPath}';
+${enableDevTools ? `import { ReactQueryDevtools } from '${devtoolsPkgPath}';` : ""}
+${reactQueryRuntimeCode}
+const client = new QueryClient(reactQueryConfig.queryClient || {});
+export function rootContainer(container) {
+  return (
+    <QueryClientProvider
+      client={client}
+      ${useV4 ? "context={defaultContext}" : ""}
+    >
+      {container}
+      ${enableDevTools ? `<ReactQueryDevtools
+  ${useV4 ? "context={defaultContext}" : ""}
+  initialIsOpen={false}
+  {...(reactQueryConfig.devtool || {})}
+/>` : ""}
+    </QueryClientProvider>
+  );
+}
+      ` : ""
+    });
+    api.writeTmpFile({
+      path: "index.tsx",
+      content: `
+export {
+  // from @tanstack/query-core
+  QueryClient,
+  MutationObserver,
+  MutationCache,
+  InfiniteQueryObserver,
+  QueriesObserver,
+  QueryObserver,
+  QueryCache,
+  // from @tanstack/react-query
+  useIsRestoring,
+  IsRestoringProvider,
+  useInfiniteQuery,
+  useIsMutating,
+  useIsFetching,
+  useMutation,
+  useQueries,
+  useQuery,
+  QueryClientProvider,
+  useQueryClient,
+  QueryErrorResetBoundary,
+  useQueryErrorResetBoundary,
+  ${useV5 ? "queryOptions," : ""}
+} from '${pkgPath}';
+      `
+    });
+    api.writeTmpFile({
+      path: "types.d.ts",
+      content: `
+export type {
+  // from @tanstack/query-core
+  Query, QueryState, Mutation,
+  // from @tanstack/react-query
+  QueriesResults,
+  QueriesOptions,
+  QueryErrorResetBoundaryProps,
+  QueryClientProviderProps,
+  ${useV4 ? "ContextOptions as QueryContextOptions," : ""}
+  UseQueryOptions,
+  UseBaseQueryOptions,
+  UseQueryResult,
+  UseBaseQueryResult,
+  UseInfiniteQueryOptions,
+  UseMutationResult,
+  UseMutateFunction,
+  UseMutateAsyncFunction,
+  UseBaseMutationResult,
+} from '${pkgPath}';
+      `
+    });
+  });
+};

package/dist/request.d.ts

@@ -1,3 +1,3 @@
+import { IApi } from 'umi';
 declare const _default: (api: IApi) => void;
 export default _default;
-//# sourceMappingURL=request.d.ts.map