dumi 2.4.29 → 2.4.30

package/dist/assetParsers/BaseParser.d.ts

@@ -0,0 +1,55 @@
+import type { AtomComponentAsset, AtomFunctionAsset } from 'dumi-assets-types';
+import { chokidar } from 'umi/plugin-utils';
+export interface IPatchFile {
+    event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
+    fileName: string;
+}
+export interface IAtomAssetsParserResult {
+    components: Record<string, AtomComponentAsset>;
+    functions: Record<string, AtomFunctionAsset>;
+}
+/**
+ * The parsing and extraction of language metadata should be implemented separately
+ */
+export interface ILanguageMetaParser {
+    patch(file: IPatchFile): void;
+    parse(): Promise<IAtomAssetsParserResult>;
+    destroy(): Promise<void>;
+}
+export interface IHandleWatcherArgs {
+    patch: ILanguageMetaParser['patch'];
+    parse: () => void;
+    watchArgs: {
+        paths: string | string[];
+        options: chokidar.WatchOptions;
+    };
+}
+export interface IBaseAtomAssetsParserParams<T> {
+    entryFile: string;
+    resolveDir: string;
+    parser: T;
+    handleWatcher?: (watcher: chokidar.FSWatcher, params: IHandleWatcherArgs) => chokidar.FSWatcher;
+    watchOptions?: chokidar.WatchOptions;
+}
+export declare class BaseAtomAssetsParser<T extends ILanguageMetaParser = ILanguageMetaParser> {
+    private watchArgs;
+    private watcher;
+    private handleWatcher?;
+    private entryDir;
+    private resolveDir;
+    private readonly parser;
+    private isParsing;
+    private parseDeferrer;
+    private cbs;
+    constructor(opts: IBaseAtomAssetsParserParams<T>);
+    parse(): Promise<IAtomAssetsParserResult>;
+    watch(cb: (data: IAtomAssetsParserResult) => void): void;
+    unwatch(cb: (data: IAtomAssetsParserResult) => void): void;
+    patchWatchArgs(handler: (args: BaseAtomAssetsParser<T>['watchArgs']) => BaseAtomAssetsParser<T>['watchArgs']): void;
+    getWatchArgs(): {
+        paths: string | string[];
+        options: chokidar.WatchOptions;
+    };
+    destroyWorker(): Promise<void>;
+}
+export type IAtomAssetsParser = InstanceType<typeof BaseAtomAssetsParser>;

package/dist/assetParsers/atom.d.ts

@@ -0,0 +1,21 @@
+import { BaseAtomAssetsParser, IAtomAssetsParserResult, ILanguageMetaParser, IPatchFile } from './BaseParser';
+interface ParserParams {
+    entryFile: string;
+    resolveDir: string;
+    resolveFilter?: ReactMetaParser['resolveFilter'];
+    unpkgHost?: string;
+    parseOptions?: object;
+}
+declare class ReactMetaParser implements ILanguageMetaParser {
+    private parser;
+    private resolveFilter;
+    private unresolvedFiles;
+    constructor(opts: ParserParams);
+    parse(): Promise<IAtomAssetsParserResult>;
+    destroy(): Promise<void>;
+    patch(file: IPatchFile): void;
+}
+declare class ReactAtomAssetsParser extends BaseAtomAssetsParser<ReactMetaParser> {
+    constructor(opts: ParserParams);
+}
+export default ReactAtomAssetsParser;

package/dist/assetParsers/block.d.ts

@@ -0,0 +1,25 @@
+import { parseCodeFrontmatter } from "../utils";
+import type { ExampleBlockAsset } from 'dumi-assets-types';
+import type { sync } from 'enhanced-resolve';
+import { IDumiTechStack } from '../types';
+export interface IParsedBlockAsset {
+    asset: ExampleBlockAsset;
+    /**
+     * resolveMap: {
+     *   '@/constants': '/path/to/constants.ts',
+     *   'antd/es/button': '/path/to/antd/es/button/index.jsx',
+     * }
+     */
+    resolveMap: Record<string, string>;
+    frontmatter: ReturnType<typeof parseCodeFrontmatter>['frontmatter'];
+}
+declare function parseBlockAsset(opts: {
+    fileAbsPath: string;
+    fileLocale?: string;
+    id: string;
+    refAtomIds: string[];
+    entryPointCode?: string;
+    resolver: typeof sync;
+    techStack: IDumiTechStack;
+}): Promise<IParsedBlockAsset>;
+export default parseBlockAsset;

package/dist/assetParsers/utils.d.ts

@@ -0,0 +1,79 @@
+import { BaseAtomAssetsParser, IBaseAtomAssetsParserParams, ILanguageMetaParser } from './BaseParser';
+/**
+ * Only expose these methods to avoid all properties being proxied
+ * @param ClassConstructor The Class to be processed
+ * @param publicMethods accessible Class methods
+ * @returns processed Class
+ */
+export declare function createExposedClass<T extends {
+    new (...args: ConstructorParameters<T>): InstanceType<T>;
+}>(ClassConstructor: T, publicMethods?: string[]): {
+    new (...params: ConstructorParameters<T>): {};
+};
+/**
+ * Create Class that can execute across threads
+ * @param filename Child thread running script path
+ * @param ClassConstructor Class that require remote execution
+ * @param opts
+ * @returns Remote Class, all its methods are asynchronous
+ */
+export declare function createRemoteClass<T extends {
+    new (...args: ConstructorParameters<T>): InstanceType<T>;
+}>(filename: string, ClassConstructor: T, opts?: {
+    destroyMethod: string;
+    publicMethods?: string[];
+}): T;
+interface ICreateApiParserOptions<S, C> {
+    /**
+     * The full file name (absolute path) of the file where `parseWorker` is located
+     */
+    filename: string;
+    /**
+     * Parsing class working in worker_thead
+     */
+    worker: S;
+    /**
+     * Main thread side work, mainly to detect file changes
+     */
+    parseOptions?: C;
+}
+export interface IBaseApiParserOptions {
+    entryFile: string;
+    resolveDir: string;
+}
+/**
+ * Can be used to override apiParser
+ * @param options
+ * @returns A function that returns a Parser instance
+ * @example
+ * ```ts
+ * interface ParserOptions extends BaseApiParserOptions  {
+ *    // other props...
+ * }
+ * const Parser = createApiParser({
+ *    filename: __filename,
+ *    worker: (class {
+ *      constructor(opts: ParserOptions) {}
+ *      patch () {}
+ *      async parse () {
+ *        return {
+ *          components: {},
+ *          functions: {}
+ *        };
+ *      }
+ *      async destroy () {}
+ *    }),
+ *    parserOptions: {
+ *      handleWatcher(watcher, { parse, patch }) {
+ *        return watcher.on('all', (ev, file) => {
+ *          // You can perform patch and parse operations based on file changes.
+ *          // patch will transfer the corresponding file to the parseWorker,
+ *          // and parse will instruct the parseWorker to parse according to updated files.
+ *        });
+ *      },
+ *    },
+ * });
+ * ```
+ */
+export declare function createApiParser<P extends new (...args: ConstructorParameters<P>) => InstanceType<P> & ILanguageMetaParser>(options: ICreateApiParserOptions<P, Partial<IBaseAtomAssetsParserParams<P>>>): (...args: ConstructorParameters<P>) => BaseAtomAssetsParser<ILanguageMetaParser>;
+export {};

package/dist/cli.d.ts

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

package/dist/client/misc/reactDemoCompiler.d.ts

@@ -0,0 +1,3 @@
+import type { IDemoCompileFn } from '../theme-api/types';
+declare const compile: IDemoCompileFn;
+export default compile;

package/dist/client/pages/404.d.ts

@@ -0,0 +1 @@
+export { default } from 'dumi/theme/slots/NotFound';

package/dist/client/pages/Demo/index.d.ts

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import './index.less';
+declare const DemoRenderPage: FC;
+export default DemoRenderPage;

package/dist/client/pages/Loading.d.ts

@@ -0,0 +1 @@
+export { default } from 'dumi/theme/slots/Loading';

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

@@ -0,0 +1,13 @@
+import { AtomAsset, ExamplePresetAsset } from 'dumi-assets-types';
+import type { TypeMap } from 'dumi-assets-types/typings/atom/props/types';
+import { type FC } from 'react';
+interface IAtomRendererProps {
+    type: AtomAsset['type'];
+    value: ExamplePresetAsset['value'];
+    processor?: typeof builtInProcessor;
+}
+type Entity = TypeMap['element'] | TypeMap['function'] | TypeMap['dom'];
+type Exports = Record<string, any>;
+declare function builtInProcessor(entity: Entity, entryExports: Exports): any;
+export declare const AtomRenderer: FC<IAtomRendererProps>;
+export {};

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

@@ -0,0 +1,5 @@
+import { type FC, type ReactNode } from 'react';
+declare const DemoErrorBoundary: FC<{
+    children: ReactNode;
+}>;
+export default DemoErrorBoundary;

package/dist/client/theme-api/DumiDemo/index.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/DumiDemoGrid.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode, type FC } from 'react';
+import type { IDumiDemoProps } from './DumiDemo';
+export interface IDumiDemoGridProps {
+    items: IDumiDemoProps[];
+    demoRender?: (item: IDumiDemoProps) => ReactNode;
+}
+export declare const DumiDemoGrid: FC<IDumiDemoGridProps>;

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

@@ -0,0 +1,4 @@
+import { type FC, type ReactNode } from 'react';
+export declare const DumiPage: FC<{
+    children: ReactNode;
+}>;

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

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import type { PICKED_PKG_FIELDS } from "../../constants";
+import type { AtomComponentAsset } from 'dumi-assets-types';
+import type { IDemoData, ILocalesConfig, IThemeConfig } from './types';
+export interface ISiteContext {
+    pkg: Partial<Record<keyof typeof PICKED_PKG_FIELDS, any>>;
+    historyType: 'browser' | 'hash' | 'memory';
+    entryExports: Record<string, any>;
+    demos: Record<string, IDemoData>;
+    components: Record<string, AtomComponentAsset>;
+    locales: ILocalesConfig;
+    themeConfig: IThemeConfig;
+    hostname?: string;
+    loading: boolean;
+    setLoading: (status: boolean) => void;
+    /**
+     * private field, do not use it in your code
+     */
+    _2_level_nav_available: boolean;
+}
+export declare const SiteContext: import("react").Context<ISiteContext>;
+export declare const useSiteData: () => ISiteContext;

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

@@ -0,0 +1,18 @@
+export { FormattedDate, FormattedDateParts, FormattedDisplayName, FormattedList, FormattedMessage, FormattedNumber, FormattedNumberParts, FormattedPlural, FormattedRelativeTime, FormattedTime, FormattedTimeParts, IntlContext, IntlProvider, RawIntlProvider, createIntlCache, defineMessages, injectIntl, useIntl, } from 'react-intl';
+export { AtomRenderer } from './AtomRenderer';
+export { DumiDemo } from './DumiDemo';
+export { DumiDemoGrid } from './DumiDemoGrid';
+export { DumiPage } from './DumiPage';
+export { useSiteData } from './context';
+export { openCodeSandbox } from './openCodeSandbox';
+export { openStackBlitz } from './openStackBlitz';
+export type { IDemoCancelableFn, IPreviewerProps } from './types';
+export { useAtomAssets } from './useAtomAssets';
+export { useLiveDemo } from './useLiveDemo';
+export { useLocale } from './useLocale';
+export { useNavData } from './useNavData';
+export { usePrefersColor } from './usePrefersColor';
+export { useMatchedRoute, useRouteMeta } from './useRouteMeta';
+export { useFullSidebarData, useSidebarData } from './useSidebarData';
+export { useSiteSearch } from './useSiteSearch';
+export { useTabMeta } from './useTabMeta';

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

@@ -0,0 +1,10 @@
+import { type IPreviewerProps } from 'dumi';
+/**
+ * use CodeSandbox.io
+ * @param data  previewer opts
+ * @param opts  the api that CodeSandbox calls when creating the demo
+ * @note  return a open function for open demo on codesandbox.io
+ */
+export declare const openCodeSandbox: (data: IPreviewerProps, opts?: {
+    api?: string;
+}) => void;

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

@@ -0,0 +1,2 @@
+import { type IPreviewerProps } from 'dumi';
+export declare const openStackBlitz: (data: IPreviewerProps) => void;

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

@@ -0,0 +1,258 @@
+import type { ExampleBlockAsset } from 'dumi-assets-types';
+import type { ComponentType as ReactComponentType, ReactNode } from 'react';
+export interface IPreviewerProps {
+    /**
+     * title of current demo
+     */
+    title?: string;
+    /**
+     * description of current demo
+     */
+    description?: string;
+    /**
+     * filename of current demo
+     */
+    filename?: string;
+    /**
+     * use iframe to render demo
+     */
+    iframe?: boolean | number;
+    /**
+     * debug mark (will only render in dev by default)
+     */
+    debug?: boolean;
+    /**
+     * display the source code or not by default
+     */
+    defaultShowCode?: boolean;
+    /**
+     * url for render current demo in a single page
+     */
+    demoUrl: string;
+    /**
+     * disable demo content padding
+     */
+    compact?: boolean;
+    /**
+     * add transform property for handle absolute/fixed position element
+     */
+    transform?: boolean;
+    /**
+     * background color for demo content
+     */
+    background?: string;
+    /**
+     * asset metadata of current demo
+     */
+    asset: ExampleBlockAsset;
+    /**
+     * react node of current demo
+     */
+    children: ReactNode;
+    /**
+     * private field, do not use it in your code
+     */
+    _live_in_iframe?: boolean;
+    [key: string]: any;
+}
+export interface IRouteMeta {
+    frontmatter: {
+        title: string;
+        description?: string;
+        keywords?: string[];
+        nav?: string | {
+            title?: string;
+            order?: number;
+            second?: Omit<IRouteMeta['frontmatter']['nav'], 'second'>;
+        };
+        group?: string | {
+            title?: string;
+            order?: number;
+        };
+        order?: number;
+        hero?: {
+            title?: string;
+            description?: string;
+            background?: string;
+            actions?: {
+                text: string;
+                link: string;
+            }[];
+            [key: string]: any;
+        };
+        features?: {
+            emoji?: string;
+            title?: string;
+            link?: string;
+            description?: string;
+            [key: string]: any;
+        }[];
+        toc?: boolean | 'content' | 'menu';
+        demo?: {
+            cols?: number;
+            tocDepth?: number;
+        };
+        atomId?: string;
+        filename?: string;
+        lastUpdated?: number;
+        debug?: boolean;
+        /**
+         * Control the display of the sidebar menu.
+         * @default true
+         */
+        sidebar?: boolean;
+        [key: string]: any;
+    };
+    toc: {
+        id: string;
+        depth: number;
+        title: string;
+        /**
+         * private field, do not use it in your code
+         */
+        _debug_demo?: boolean;
+    }[];
+    texts: {
+        type?: 'content';
+        value: string;
+        /**
+         * paragraph index
+         */
+        paraId: number;
+        /**
+         * title index in toc
+         */
+        tocIndex?: number;
+    }[];
+    tabs?: {
+        key: string;
+        title?: string;
+        titleIntlId?: string;
+        components: {
+            default: ReactComponentType;
+            Extra: ReactComponentType;
+            Action: ReactComponentType;
+        };
+        meta: {
+            frontmatter: Omit<IRouteMeta['frontmatter'], 'description' | 'keywords' | 'nav' | 'group' | 'hero' | 'features'>;
+            toc: IRouteMeta['toc'];
+            texts: IRouteMeta['texts'];
+            [key: string]: any;
+        };
+    }[];
+    /**
+     * private field, do not use it in your code
+     */
+    _atom_route?: boolean;
+}
+type IBasicLocale = {
+    id: string;
+    name: string;
+};
+export type ILocale = (IBasicLocale & {
+    base: string;
+}) | (IBasicLocale & {
+    suffix: string;
+});
+export type ILocalesConfig = ILocale[];
+export interface INavItem {
+    title: string;
+    link?: string;
+    order?: number;
+    activePath?: string;
+    [key: string]: any;
+}
+export interface ISidebarItem {
+    title: string;
+    link: string;
+    order?: number;
+    frontmatter?: IRouteMeta['frontmatter'];
+    [key: string]: any;
+}
+export interface ISidebarGroup {
+    title?: string;
+    children: ISidebarItem[];
+    [key: string]: any;
+}
+export type SocialTypes = 'github' | 'weibo' | 'twitter' | 'x' | 'gitlab' | 'facebook' | 'zhihu' | 'yuque' | 'linkedin';
+export type INavItems = (INavItem & {
+    children?: INavItem[];
+})[];
+export type INav = INavItems | Record<string, INavItems>;
+type IUserNavItem = Pick<INavItem, 'title' | 'link' | 'activePath'>;
+export type IUserNavMode = 'override' | 'append' | 'prepend';
+export type IUserNavItems = (IUserNavItem & {
+    children?: IUserNavItem[];
+})[];
+export type IUserNavValue = IUserNavItems | Record<string, IUserNavItems>;
+export type NavWithMode<T extends IUserNavValue> = {
+    /**
+     * 扩展导航的模式
+     * @description
+     * - 'override': 用 value 中配置的导航直接覆盖约定路由的导航
+     * - 'append': 将 value 中配置的导航追加到约定路由导航后面
+     * - 'prepend': 将 value 中配置的导航添加到约定路由导航前面
+     */
+    mode: IUserNavMode;
+    value: T;
+};
+export interface IThemeConfig {
+    name?: string;
+    logo?: string | false;
+    nav?: IUserNavValue | NavWithMode<IUserNavValue>;
+    sidebar?: Record<string, ISidebarGroup[]>;
+    footer?: string | false;
+    showLineNum?: boolean;
+    prefersColor: {
+        default: 'light' | 'dark' | 'auto';
+        switch: boolean;
+    };
+    nprogress?: boolean;
+    socialLinks?: {
+        [key in SocialTypes]?: string;
+    };
+    editLink?: boolean | string;
+    sourceLink?: boolean | string;
+    lastUpdated?: boolean;
+    [key: string]: any;
+}
+export type IRoutesById = Record<string, {
+    path?: string;
+    parentId?: string;
+    meta?: IRouteMeta;
+    id: string;
+    redirect?: string;
+    [key: string]: any;
+}>;
+export type AgnosticComponentModule = {
+    default?: any;
+    [key: string]: any;
+};
+export type AgnosticComponentType = Promise<AgnosticComponentModule> | AgnosticComponentModule;
+export type IDemoCompileFn = (code: string, opts: {
+    filename: string;
+}) => Promise<string>;
+export type IDemoCancelableFn = (canvas: HTMLElement, component: AgnosticComponentModule) => (() => void) | Promise<() => void>;
+export type IDemoPreflightFn = (component: AgnosticComponentModule) => Promise<void>;
+export type IDemoData = {
+    component: ReactComponentType | AgnosticComponentType;
+    asset: IPreviewerProps['asset'];
+    routeId: string;
+    context?: Record<string, unknown>;
+    renderOpts?: {
+        /**
+         * provide a runtime compile function for compile demo code for live preview
+         */
+        compile?: IDemoCompileFn;
+        /**
+         * Component rendering function, used to manage the creation and unmount of components
+         */
+        renderer?: IDemoCancelableFn;
+        /**
+         * Used to detect initialization errors of components in advance
+         * (if there is an error, the component will not be mounted)
+         */
+        preflight?: IDemoPreflightFn;
+    };
+};
+export {};

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

@@ -0,0 +1,4 @@
+import { AtomComponentAsset } from 'dumi-assets-types';
+export declare const useAtomAssets: () => {
+    components: Record<string, AtomComponentAsset>;
+};

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

@@ -0,0 +1,10 @@
+import { type ReactNode, type RefObject } from 'react';
+export declare const useLiveDemo: (id: string, opts?: {
+    containerRef?: RefObject<HTMLElement>;
+    iframe?: boolean;
+}) => {
+    node: ReactNode;
+    loading: boolean;
+    error: Error | null;
+    setSource: (source: Record<string, string>) => Promise<void>;
+};

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

@@ -0,0 +1,2 @@
+import type { ILocale } from './types';
+export declare const useLocale: () => ILocale;

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

@@ -0,0 +1,5 @@
+import type { INavItems } from './types';
+/**
+ * hook for get nav data
+ */
+export declare const useNavData: () => INavItems;

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

@@ -0,0 +1,7 @@
+export type IColorValue = 'light' | 'dark';
+export type IPrefersColorValue = IColorValue | 'auto';
+/**
+ * hook for get/set prefers-color-schema, use to control color mode for theme package
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme
+ */
+export declare const usePrefersColor: () => [IColorValue, IPrefersColorValue, (val: IPrefersColorValue) => void];

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { AgnosticComponentType, IDemoData } from './types';
+export interface UseRendererOptions {
+    id: string;
+    component?: AgnosticComponentType;
+    renderOpts: IDemoData['renderOpts'];
+    onResolved?: () => void;
+}
+export declare const useRenderer: ({ id, component, renderOpts, onResolved, }: UseRendererOptions) => {
+    canvasRef: import("react").RefObject<HTMLDivElement>;
+    setComponent: import("react").Dispatch<import("react").SetStateAction<AgnosticComponentType | null>>;
+};

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

@@ -0,0 +1,17 @@
+import type { IRouteMeta } from './types';
+/**
+ * hook for get matched route
+ * @internal internal use. Do not use in your production code.
+ */
+export declare const useMatchedRoute: () => {
+    [key: string]: any;
+    path?: string | undefined;
+    parentId?: string | undefined;
+    meta?: IRouteMeta | undefined;
+    id: string;
+    redirect?: string | undefined;
+};
+/**
+ * hook for get matched route meta
+ */
+export declare const useRouteMeta: () => IRouteMeta;

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

@@ -0,0 +1,29 @@
+import type { ILocalesConfig, IRouteMeta, ISidebarGroup } from './types';
+export declare const getLocaleClearPath: (routePath: string, locale: ILocalesConfig[0]) => string;
+/**
+ * get parent path from route path
+ */
+export declare function getRouteParentPath(path: string, { meta, is2LevelNav, locale, }: {
+    meta?: IRouteMeta;
+    is2LevelNav: boolean;
+    locale: ILocalesConfig[0];
+}): string;
+/**
+ * hook for get sidebar data for all nav
+ */
+export declare const useFullSidebarData: () => Record<string, ISidebarGroup[]>;
+interface ITreeSidebarLeaf {
+    path: string;
+    title: string;
+    order: number;
+    children: (ITreeSidebarLeaf | ISidebarGroup)[];
+}
+/**
+ * hook for get full sidebar data in tree structure
+ */
+export declare const useTreeSidebarData: () => ITreeSidebarLeaf[];
+/**
+ * hook for get sidebar data for current nav
+ */
+export declare const useSidebarData: () => ISidebarGroup[];
+export {};