dumi 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/assetParsers/block.d.ts

@@ -0,0 +1,17 @@
+import type { ExampleBlockAsset } from 'dumi-assets-types';
+export interface IParsedBlockAsset {
+    asset: ExampleBlockAsset;
+    sources: Record<string, string>;
+    frontmatter: ReturnType<typeof parseCodeFrontmatter>['frontmatter'];
+}
+declare function parseCodeFrontmatter(raw: string): {
+    code: string;
+    frontmatter: Record<string, any> | null;
+};
+declare function parseBlockAsset(opts: {
+    fileAbsPath: string;
+    id: string;
+    refAtomIds: string[];
+    entryPointCode?: string;
+}): Promise<IParsedBlockAsset>;
+export default parseBlockAsset;

package/dist/assetParsers/block.js

@@ -0,0 +1,130 @@
+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(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/assetParsers/block.ts
+var block_exports = {};
+__export(block_exports, {
+  default: () => block_default
+});
+module.exports = __toCommonJS(block_exports);
+var import_esbuild = require("@umijs/bundler-utils/compiled/esbuild");
+var import_fs = __toESM(require("fs"));
+var import_js_yaml = __toESM(require("js-yaml"));
+var import_path = __toESM(require("path"));
+var import_plugin_utils = require("umi/plugin-utils");
+function parseCodeFrontmatter(raw) {
+  const [, comment = "", code = ""] = raw.replace(/^\n\s*/, "").match(/^(\/\*\*[^]*?\n\s*\*\/)?(?:\s|\n)*([^]+)?$/);
+  const yamlComment = comment.replace(/^\/|\/$/g, "").replace(/(^|\n)\s*\*+/g, "$1");
+  let frontmatter = null;
+  try {
+    frontmatter = import_js_yaml.default.load(yamlComment);
+  } catch {
+  }
+  return { code: frontmatter ? code : raw, frontmatter };
+}
+async function parseBlockAsset(opts) {
+  const asset = {
+    type: "BLOCK",
+    id: opts.id,
+    refAtomIds: opts.refAtomIds,
+    dependencies: {}
+  };
+  const result = {
+    asset,
+    sources: {},
+    frontmatter: null
+  };
+  await (0, import_esbuild.build)({
+    write: false,
+    bundle: true,
+    logLevel: "silent",
+    format: "esm",
+    target: "esnext",
+    entryPoints: [import_path.default.basename(opts.fileAbsPath)],
+    absWorkingDir: import_path.default.dirname(opts.fileAbsPath),
+    plugins: [
+      {
+        name: "plugin-dumi-collect-deps",
+        setup: (builder) => {
+          builder.onResolve({ filter: /.*/ }, (args) => {
+            if (args.kind !== "entry-point" && !args.path.startsWith(".")) {
+              const pkgJsonPath = import_plugin_utils.pkgUp.pkgUpSync({
+                cwd: require.resolve(args.path, { paths: [args.resolveDir] })
+              });
+              if (pkgJsonPath) {
+                asset.dependencies[args.path] = {
+                  type: "NPM",
+                  value: require(pkgJsonPath).version
+                };
+              }
+              return { path: args.path, external: true };
+            }
+            return {
+              path: import_path.default.join(args.resolveDir, args.path),
+              pluginData: { kind: args.kind, resolveDir: args.resolveDir }
+            };
+          });
+          builder.onLoad({ filter: /.*/ }, (args) => {
+            const ext = import_path.default.extname(args.path);
+            const isModule = [".js", ".jsx", ".ts", ".tsx"].includes(ext);
+            const isPlainText = [
+              ".css",
+              ".less",
+              ".sass",
+              ".scss",
+              ".styl",
+              ".json"
+            ].includes(ext);
+            const isEntryPoint = args.pluginData.kind === "entry-point";
+            const filename = isEntryPoint ? `index${ext}` : (0, import_plugin_utils.winPath)(import_path.default.relative(import_path.default.dirname(opts.fileAbsPath), args.path));
+            if (isModule || isPlainText) {
+              asset.dependencies[filename] = {
+                type: "FILE",
+                value: opts.entryPointCode ?? import_fs.default.readFileSync(args.path, "utf-8")
+              };
+              if (isEntryPoint) {
+                const { code, frontmatter } = parseCodeFrontmatter(asset.dependencies[filename].value);
+                if (frontmatter) {
+                  asset.dependencies[filename].value = code;
+                  result.frontmatter = frontmatter;
+                  ["description", "title", "snapshot", "keywords"].forEach((key) => {
+                    asset[key] = frontmatter == null ? void 0 : frontmatter[key];
+                  });
+                }
+              }
+              if (!isEntryPoint || !opts.entryPointCode) {
+                result.sources[filename] = args.path;
+              }
+              return {
+                contents: isModule ? asset.dependencies[filename].value : "",
+                loader: isModule ? ext.slice(1) : "text"
+              };
+            }
+          });
+        }
+      }
+    ]
+  });
+  return result;
+}
+var block_default = parseBlockAsset;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/client/theme-api/DumiDemo.d.ts

@@ -0,0 +1,10 @@
+import { type FC } from 'react';
+import type { IPreviewerProps } from './types';
+export interface IDumiDemoProps {
+    demo: {
+        id: string;
+        inline?: boolean;
+    };
+    previewerProps: Omit<IPreviewerProps, 'asset' | 'children'>;
+}
+export declare const DumiDemo: FC<IDumiDemoProps>;

package/dist/client/theme-api/DumiDemo.js

@@ -0,0 +1,16 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import Previewer from 'dumi/theme/builtins/Previewer';
+import React, { createElement, useContext } from 'react';
+import { Context } from "./context";
+export var DumiDemo = function DumiDemo(props) {
+  var _useContext = useContext(Context),
+      demos = _useContext.demos;
+
+  var _demos$props$demo$id = demos[props.demo.id],
+      component = _demos$props$demo$id.component,
+      asset = _demos$props$demo$id.asset;
+  return /*#__PURE__*/React.createElement(Previewer, _extends({
+    asset: asset
+  }, props.previewerProps), /*#__PURE__*/createElement(component));
+};

package/dist/client/theme-api/DumiDemoGrid.d.ts

@@ -0,0 +1,6 @@
+import { type FC } from 'react';
+import { IDumiDemoProps } from './DumiDemo';
+export interface IDumiDemoGridProps {
+    items: IDumiDemoProps[];
+}
+export declare const DumiDemoGrid: FC<IDumiDemoGridProps>;

package/dist/client/theme-api/DumiDemoGrid.js

@@ -0,0 +1,64 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { useMatchedRouteMeta } from 'dumi/theme';
+import React, { useState } from 'react';
+import { DumiDemo } from "./DumiDemo";
+export var DumiDemoGrid = function DumiDemoGrid(props) {
+  var meta = useMatchedRouteMeta();
+
+  var _useState = useState(function () {
+    var _meta$demo;
+
+    var cols = [];
+
+    if ((_meta$demo = meta.demo) !== null && _meta$demo !== void 0 && _meta$demo.cols && meta.demo.cols > 1) {
+      for (var i = 0; i < props.items.length; i += meta.demo.cols) {
+        props.items.slice(i, i + meta.demo.cols).forEach(function (item, j) {
+          var _cols$j;
+
+          (_cols$j = cols[j]) !== null && _cols$j !== void 0 ? _cols$j : cols[j] = [];
+          cols[j].push(item);
+        });
+      }
+
+      return cols;
+    } else {
+      cols.push(props.items);
+    }
+
+    return cols;
+  }),
+      _useState2 = _slicedToArray(_useState, 1),
+      cols = _useState2[0];
+
+  return /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'flex',
+      margin: -8
+    }
+  }, cols.map(function (col, i) {
+    return /*#__PURE__*/React.createElement("section", {
+      style: {
+        flex: 1,
+        padding: 8
+      },
+      key: String(i)
+    }, col.map(function (item) {
+      return /*#__PURE__*/React.createElement(DumiDemo, _extends({
+        key: item.demo.id
+      }, item));
+    }));
+  }));
+};

package/dist/client/theme-api/context.d.ts

@@ -0,0 +1,10 @@
+import { type ComponentType } from 'react';
+import type { ILocalesConfig, IPreviewerProps } from './types';
+export interface IThemeContext {
+    demos: Record<string, {
+        component: ComponentType;
+        asset: IPreviewerProps['asset'];
+    }>;
+    locales: ILocalesConfig;
+}
+export declare const Context: import("react").Context<IThemeContext>;

package/dist/client/{theme → theme-api}/context.js

@@ -1,4 +1,5 @@
 import { createContext } from 'react';
 export var Context = /*#__PURE__*/createContext({
-  demos: {}
+  demos: {},
+  locales: []
 });

package/dist/client/theme-api/index.d.ts

@@ -0,0 +1,6 @@
+export { useIntl } from 'react-intl';
+export * from './context';
+export * from './DumiDemo';
+export * from './DumiDemoGrid';
+export * from './types';
+export * from './useMatchedRouteMeta';

package/dist/client/theme-api/index.js

@@ -0,0 +1,6 @@
+export { useIntl } from 'react-intl';
+export * from "./context";
+export * from "./DumiDemo";
+export * from "./DumiDemoGrid";
+export * from "./types";
+export * from "./useMatchedRouteMeta";

package/dist/client/theme-api/types.d.ts

@@ -0,0 +1,47 @@
+import type { ExampleBlockAsset } from 'dumi-assets-types';
+import type { ReactNode } from 'react';
+export interface IPreviewerProps {
+    /**
+     * title of current demo
+     */
+    title?: string;
+    /**
+     * description of current demo
+     */
+    description?: string;
+    /**
+     * file path of current demo
+     */
+    filePath?: string;
+    /**
+     * asset metadata of current demo
+     */
+    asset: ExampleBlockAsset;
+    /**
+     * react node of current demo
+     */
+    children: ReactNode;
+    [key: string]: any;
+}
+export interface IRouteMeta {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    category?: string;
+    order?: number;
+    toc?: boolean | 'content' | 'menu';
+    demo?: {
+        cols?: number;
+    };
+    [key: string]: any;
+}
+declare type IBasicLocale = {
+    id: string;
+    name: string;
+};
+export declare type ILocalesConfig = ((IBasicLocale & {
+    base?: string;
+}) | (IBasicLocale & {
+    suffix: string;
+}))[];
+export {};

package/dist/client/theme-api/types.js

@@ -0,0 +1 @@
+export {};

package/dist/client/theme-api/useMatchedRouteMeta.d.ts

@@ -0,0 +1,5 @@
+import type { IRouteMeta } from './types';
+/**
+ * hook for get matched route meta
+ */
+export declare const useMatchedRouteMeta: () => IRouteMeta;

package/dist/client/theme-api/useMatchedRouteMeta.js

@@ -0,0 +1,55 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import { matchRoutes, useAppData, useLocation, useRouteData } from 'dumi';
+import { useCallback, useEffect, useState } from 'react';
+
+/**
+ * hook for get matched route meta
+ */
+export var useMatchedRouteMeta = function useMatchedRouteMeta() {
+  var _useRouteData = useRouteData(),
+      route = _useRouteData.route;
+
+  var _useLocation = useLocation(),
+      pathname = _useLocation.pathname;
+
+  var _useAppData = useAppData(),
+      clientRoutes = _useAppData.clientRoutes;
+
+  var getter = useCallback(function () {
+    var ret;
+
+    if (route.path === pathname) {
+      // use `useRouteData` result if matched, for performance
+      ret = route.meta;
+    } else {
+      var _matchRoutes, _matched$route;
+
+      // match manually for dynamic route & layout component
+      var matched = (_matchRoutes = matchRoutes(clientRoutes, pathname)) === null || _matchRoutes === void 0 ? void 0 : _matchRoutes.pop();
+      ret = matched === null || matched === void 0 ? void 0 : (_matched$route = matched.route) === null || _matched$route === void 0 ? void 0 : _matched$route.meta;
+    }
+
+    return ret || {};
+  }, [clientRoutes.length, pathname]);
+
+  var _useState = useState(getter),
+      _useState2 = _slicedToArray(_useState, 2),
+      meta = _useState2[0],
+      setMeta = _useState2[1];
+
+  useEffect(function () {
+    setMeta(getter);
+  }, [clientRoutes.length, pathname]);
+  return meta;
+};

package/dist/client/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["src/*"],
+      "@@/*": ["src/.umi/*"],
+      "dumi": ["src"],
+      "dumi/theme": ["src/client/theme-api"],
+      "dumi/theme/*": ["src/client/theme-default/*"]
+    }
+  }
+}

package/dist/features/compile.js

@@ -27,20 +27,38 @@ __export(compile_exports, {
 module.exports = __toCommonJS(compile_exports);
 var import_react = __toESM(require("../techStacks/react"));
 var compile_default = (api) => {
-  api.registerTechStack(() => new import_react.default());
+  api.register({
+    key: "registerTechStack",
+    stage: Infinity,
+    fn: () => new import_react.default()
+  });
+  api.modifyDefaultConfig((memo) => {
+    memo.alias.dumi$ = memo.alias.umi;
+    return memo;
+  });
   api.chainWebpack(async (memo) => {
-    const loaderPath = require.resolve("../loaders/markdown");
     const babelInUmi = memo.module.rule("src").use("babel-loader").entries();
     const techStacks = await api.applyPlugins({
       key: "registerTechStack",
       type: api.ApplyPluginsType.add
     });
-    memo.module.rule("dumi-md").type("javascript/auto").test(/\.md$/).oneOf("demo-index").resourceQuery(/meta\.demos/).use("demo-index-loader").loader(loaderPath).options({ techStacks, cwd: api.cwd, mode: "demos" }).end().end().oneOf("md").use("babel-loader").loader(babelInUmi.loader).options(babelInUmi.options).end().use("md-loader").loader(loaderPath).options({
+    const loaderPath = require.resolve("../loaders/markdown");
+    const loaderBaseOpts = {
       techStacks,
       cwd: api.cwd,
+      codeBlockMode: api.config.resolve.codeBlockMode,
+      extraRemarkPlugins: api.config.extraRemarkPlugins,
+      extraRehypePlugins: api.config.extraRehypePlugins
+    };
+    memo.module.rule("dumi-md").type("javascript/auto").test(/\.md$/).oneOf("demo-index").resourceQuery(/meta$/).use("demo-index-loader").loader(loaderPath).options({
+      ...loaderBaseOpts,
+      mode: "meta"
+    }).end().end().oneOf("md").use("babel-loader").loader(babelInUmi.loader).options(babelInUmi.options).end().use("md-loader").loader(loaderPath).options({
+      ...loaderBaseOpts,
       builtins: api.service.themeData.builtins
     });
     memo.module.rule("dumi-demo").type("javascript/auto").test(/\..+$/).enforce("pre").resourceQuery(/techStack/).use("demo-loader").loader(require.resolve("../loaders/demo")).options({ techStacks, cwd: api.cwd });
+    memo.module.rule("dumi-raw").resourceQuery(/raw/).use("raw-loader").loader(require.resolve("raw-loader"));
     if (api.env === "development") {
       memo.plugin("fastRefresh").tap(([params]) => [
         {

package/dist/features/configPlugins/index.js

@@ -27,7 +27,8 @@ var configPlugins_default = (api) => {
   const configDefaults = {
     resolve: {
       docDirs: ["docs"],
-      entityDirs: [{ type: "component", dir: "src" }]
+      entityDirs: [{ type: "component", dir: "src" }],
+      codeBlockMode: "active"
     }
   };
   const schemas = (0, import_schema.getSchemas)();

package/dist/features/configPlugins/schema.js

@@ -22,12 +22,18 @@ __export(schema_exports, {
   getSchemas: () => getSchemas
 });
 module.exports = __toCommonJS(schema_exports);
+function getUnifiedPluginSchema(Joi) {
+  return Joi.array().items(Joi.alternatives(Joi.string(), Joi.func(), Joi.array().items(Joi.alternatives(Joi.string(), Joi.func()), Joi.object()).length(2))).optional();
+}
 function getSchemas() {
   return {
     resolve: (Joi) => Joi.object({
       docDirs: Joi.array().items(Joi.string()).optional(),
-      entityDirs: Joi.array().items(Joi.object({ type: Joi.string(), dir: Joi.string() })).optional()
-    }).optional()
+      entityDirs: Joi.array().items(Joi.object({ type: Joi.string(), dir: Joi.string() })).optional(),
+      codeBlockMode: Joi.string().valid("active", "passive").optional()
+    }).optional(),
+    extraRemarkPlugins: getUnifiedPluginSchema,
+    extraRehypePlugins: getUnifiedPluginSchema
   };
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/features/locales.d.ts

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

package/dist/features/locales.js

@@ -0,0 +1,97 @@
+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/features/locales.ts
+var locales_exports = {};
+__export(locales_exports, {
+  default: () => locales_default
+});
+module.exports = __toCommonJS(locales_exports);
+var locales_default = (api) => {
+  api.describe({
+    config: {
+      default: [{ id: "zh-CN", name: "\u4E2D\u6587", base: "/" }],
+      schema: (Joi) => {
+        const basicOpts = { id: Joi.string(), name: Joi.string() };
+        return Joi.alternatives(Joi.array().items(Joi.object({
+          ...basicOpts,
+          base: Joi.string().optional()
+        })), Joi.array().items(Joi.object({
+          ...basicOpts,
+          suffix: Joi.string().allow("")
+        })));
+      }
+    }
+  });
+  api.register({
+    key: "modifyConfig",
+    stage: Infinity,
+    fn: (memo) => {
+      var _a;
+      (_a = memo.locales) == null ? void 0 : _a.forEach((locale, i) => {
+        if (!("suffix" in locale)) {
+          locale.base ?? (locale.base = i ? `/${locale.id}` : "/");
+        }
+      });
+      return memo;
+    }
+  });
+  api.onGenerateFiles(() => {
+    api.writeTmpFile({
+      noPluginDir: true,
+      path: "dumi/locales/config.ts",
+      content: `export const locales = ${JSON.stringify(api.config.locales, null, 2)};
+export const messages = ${JSON.stringify(api.service.themeData.locales, null, 2)};`
+    });
+    api.writeTmpFile({
+      noPluginDir: true,
+      path: "dumi/locales/runtime.tsx",
+      content: `
+import { history } from 'umi';
+import React, { useState, type ReactNode } from 'react';
+import { RawIntlProvider, createIntl, createIntlCache } from 'react-intl';
+import { locales, messages } from './config';
+
+const cache = createIntlCache();
+
+const LocalesContainer: FC<{ children: ReactNode }> = (props) => {
+  const [locale] = useState(() => {
+    const matched = locales.find((locale) => (
+      // base mode
+      history.location.pathname.startsWith(locale.base) ||
+      // suffix mode
+      ('suffix' in locale && history.location.pathname.endsWith(locale.suffix))
+    ));
+
+    return matched ? matched.id : locales[0].id;
+  });
+  const [intl] = useState(() => createIntl({ locale, messages: messages[locale] || {} }, cache))
+
+  return <RawIntlProvider value={intl}>{props.children}</RawIntlProvider>;
+}
+
+export function i18nProvider(container: Element) {
+  return React.createElement(LocalesContainer, null, container);
+}
+`
+    });
+  });
+  api.addRuntimePlugin(() => "@@/dumi/locales/runtime.tsx");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/features/meta.d.ts

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