@rspress-theme-anatole/rspress-plugin-devkit 0.0.1

package/dist/ConfigMutator/index.d.ts

@@ -0,0 +1,14 @@
+import type { RspressPlugin } from '@rspress-theme-anatole/shared';
+type PluginConfigMutatorInput = Parameters<NonNullable<RspressPlugin['config']>>[0];
+export declare class PresetConfigMutator {
+    private readonly config;
+    private readonly utils?;
+    constructor(config: PluginConfigMutatorInput, utils?: {
+        addPlugin: (plugin: RspressPlugin) => void;
+        removePlugin: (pluginName: string) => void;
+    } | undefined);
+    toConfig(): PluginConfigMutatorInput;
+    addPlugins(...plugins: RspressPlugin[]): this;
+    disableMdxRs(): PresetConfigMutator;
+}
+export {};

package/dist/ConfigMutator/index.js

@@ -0,0 +1,25 @@
+export class PresetConfigMutator {
+    constructor(config, utils) {
+        this.config = config;
+        this.utils = utils;
+    }
+    toConfig() {
+        return this.config;
+    }
+    addPlugins(...plugins) {
+        if (!this.utils) {
+            throw new Error('PluginConfigUtils not provided.');
+        }
+        plugins.forEach((plugin) => {
+            this.utils.addPlugin(plugin);
+        });
+        return this;
+    }
+    disableMdxRs() {
+        var _a;
+        var _b;
+        (_a = (_b = this.config).markdown) !== null && _a !== void 0 ? _a : (_b.markdown = {});
+        this.config.markdown.mdxRs = false;
+        return this;
+    }
+}

package/dist/DirectivesTransformer/index.d.ts

@@ -0,0 +1,41 @@
+import { type RemarkPluginFactory } from '../Exports/Unist';
+import type { Content } from 'mdast';
+import type { VFile } from 'vfile';
+import type { Dictionary, MaybeArray } from 'util-ts-types';
+/**
+ * Directives can be transformed to:
+ *
+ * - MDAST Node, reference directive usually, like `:comment` referencing to JSDoc comment node.
+ * - Global component, like `:info` referencing to built-in `Info` component.
+ */
+declare const directiveTypes: string[] & {
+    _type: "textComponent" | "containerComponent";
+};
+declare const directiveTransformerTypes: string[] & {
+    _type: "globalComponent" | "astNode";
+};
+export type DirectiveTypes = typeof directiveTypes._type;
+export type DirectiveTransformerTypes = typeof directiveTransformerTypes._type;
+type ParsedDirectiveMeta<Attrs = Dictionary<string>> = {
+    type: DirectiveTypes;
+    name: string;
+    attributes: Attrs;
+};
+type Directive2ComponentTransformer<DirectiveAttributes = Dictionary<string>, Ext = {}> = {
+    type: 'globalComponent';
+    getComponentName: (meta: ParsedDirectiveMeta<DirectiveAttributes>, vfile: VFile) => string;
+    getComponentProps?: (attributes: DirectiveAttributes, vfile: VFile) => Dictionary<string>;
+    getComponentChildren?: (meta: ParsedDirectiveMeta<DirectiveAttributes>, node: any, vfile: VFile) => string;
+} & Ext;
+type Directive2AstNodeTransformer<DirectiveAttributes = Dictionary<string>, Ext = {}> = {
+    type: 'astNode';
+    getContent: (meta: ParsedDirectiveMeta<DirectiveAttributes>, vfile: VFile) => Content[];
+} & Ext;
+export type RemarkDirectiveTransformer<DirectiveAttributes = Dictionary<string>, GlobalComponentExt = {}, ASTNodeExt = {}> = {
+    directive: string;
+    transformer: Directive2ComponentTransformer<DirectiveAttributes, GlobalComponentExt> | Directive2AstNodeTransformer<DirectiveAttributes, ASTNodeExt>;
+};
+export type RemarkTransformDirectiveOptions = MaybeArray<RemarkDirectiveTransformer>;
+export declare const remarkTransformDirective: RemarkPluginFactory<RemarkTransformDirectiveOptions>;
+export declare const remarkParseDirective: RemarkPluginFactory;
+export {};

package/dist/DirectivesTransformer/index.js

@@ -0,0 +1,86 @@
+import _remarkParseDirective from 'remark-mdc';
+import { toString } from 'mdast-util-to-string';
+import { unistVisit } from '../Exports/Unist';
+import { createTuple } from '../Utils/createTuple';
+import { ensureArray } from '../Utils/ensureArray';
+import { MdxAttrNodeFactory } from '../NodeFactory/MdxAttrNodeFactory';
+/**
+ * Directives can be transformed to:
+ *
+ * - MDAST Node, reference directive usually, like `:comment` referencing to JSDoc comment node.
+ * - Global component, like `:info` referencing to built-in `Info` component.
+ */
+const directiveTypes = createTuple('textComponent', 'containerComponent');
+const directiveTransformerTypes = createTuple('globalComponent', 'astNode');
+export const remarkTransformDirective = (options = []) => {
+    const directiveTransformers = ensureArray(options);
+    return (tree, vfile) => {
+        unistVisit(tree, (node, index = 0, parent) => {
+            if (!directiveTypes.includes(node.type)) {
+                return;
+            }
+            directiveTransformers.forEach((trdirectiveTransformeransformer) => {
+                var _a;
+                const { transformer, directive } = trdirectiveTransformeransformer;
+                if (node.name !== directive) {
+                    return;
+                }
+                const meta = {
+                    type: node.type,
+                    name: node.name,
+                    attributes: node.attributes,
+                };
+                const transformerType = transformer.type;
+                if (transformerType === 'astNode') {
+                    const content = transformer.getContent(meta, vfile);
+                    parent.children.splice(index, 1, ...content);
+                }
+                else if (transformerType === 'globalComponent') {
+                    const attrsNormalizer = (_a = transformer === null || transformer === void 0 ? void 0 : transformer.getComponentProps) !== null && _a !== void 0 ? _a : MdxAttrNodeFactory.createMdxJsxAttributeNodes;
+                    // parent.children.splice(index, 1, {
+                    //     type: 'mdxJsxFlowElement',
+                    //     name: transformer.getComponentName(meta, vfile),
+                    //     attributes: attrsNormalizer(meta.attributes, vfile),
+                    //     children: transformer.getComponentChildren
+                    //         ? [
+                    //             {
+                    //                 type: 'text',
+                    //                 value: transformer.getComponentChildren(meta, node, vfile),
+                    //             },
+                    //         ]
+                    //         : [
+                    //             {
+                    //                 type: 'text',
+                    //                 value: toString(node),
+                    //             },
+                    //         ],
+                    // });
+
+                    // Preserve markdown formatting by properly handling node children
+                    const children = transformer.getComponentChildren
+                        ? [{
+                            type: 'paragraph',
+                            children: [{
+                                type: 'text',
+                                value: transformer.getComponentChildren(meta, node, vfile),
+                            }]
+                        }]
+                        : node.children || [{
+                            type: 'text',
+                            value: toString(node),
+                        }];
+
+                    parent.children.splice(index, 1, {
+                        type: 'mdxJsxFlowElement',
+                        name: transformer.getComponentName(meta, vfile),
+                        attributes: attrsNormalizer(meta.attributes, vfile),
+                        children: children,
+                    });
+                }
+                else {
+                }
+            });
+        });
+    };
+};
+export const remarkParseDirective = _remarkParseDirective;

package/dist/Exports/Unist.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from 'unified';
+import type { Root as MDASTRoot } from 'mdast';
+import type { Root as HASTRoot } from 'hast';
+export type RemarkPluginFactory<PluginOptions = unknown> = Plugin<[
+    PluginOptions
+], MDASTRoot>;
+export type RehypePluginFactory<PluginOptions = unknown> = Plugin<[
+    PluginOptions
+], HASTRoot>;
+export { visit as unistVisit } from 'unist-util-visit';
+export { fromMarkdown as MDASTFromMarkdown } from 'mdast-util-from-markdown';
+export { toMarkdown as MDASTToMarkdown } from 'mdast-util-to-markdown';
+export { toString as MDASTToString } from 'mdast-util-to-string';
+export type { Plugin, MDASTRoot, HASTRoot };

package/dist/Exports/Unist.js

@@ -0,0 +1,4 @@
+export { visit as unistVisit } from 'unist-util-visit';
+export { fromMarkdown as MDASTFromMarkdown } from 'mdast-util-from-markdown';
+export { toMarkdown as MDASTToMarkdown } from 'mdast-util-to-markdown';
+export { toString as MDASTToString } from 'mdast-util-to-string';

package/dist/NodeFactory/ESTreeNodeFactory.d.ts

@@ -0,0 +1,23 @@
+import type { Dictionary } from 'util-ts-types';
+import type { ObjectExpression, SimpleLiteral, ExpressionStatement, Program, Property, Statement, Identifier, ArrayExpression, ImportDeclaration, ModuleDeclaration } from 'estree-jsx';
+import type { Primitive } from '../Shared';
+export declare class ESTreeNodeFactory {
+    private static createNamedImportSpecifierNode;
+    private static createDefaultImportSpecifierNode;
+    static createNamedImportDeclarationNode(specifiers: string[], source: string): ImportDeclaration;
+    static createDefaultImportDeclarationNode(specifier: string, source: string): ImportDeclaration;
+    private static createBasePropertyNode;
+    static createIdentifierNode(name: string): Identifier;
+    static createLiteralNode(val: Primitive): SimpleLiteral;
+    static createObjectExpressionNode(val: Dictionary<any>): ObjectExpression;
+    static createArrayExpressionNode(val: Array<any>): ArrayExpression;
+    static createValueNode(input: Primitive): SimpleLiteral;
+    static createValueNode(input: Array<any>): ArrayExpression;
+    static createValueNode(input: Dictionary): ObjectExpression;
+    static createLiteralPropertyNode(key: string, val: Primitive): Property;
+    static createObjectPropertyNode(key: string, val: Dictionary): Property;
+    static createArrayPropertyNode(key: string, val: Array<any>): Property;
+    static createPropertyNode(key: string, val: Primitive | Array<any> | Dictionary): Property;
+    static createSpreadObjectExpressionNode(spread: Dictionary): ExpressionStatement;
+    static createESTreeProgramNode(statements: (Statement | ModuleDeclaration)[]): Program;
+}

package/dist/NodeFactory/ESTreeNodeFactory.js

@@ -0,0 +1,126 @@
+import { isObject } from '../Utils/is';
+export class ESTreeNodeFactory {
+    static createNamedImportSpecifierNode(name) {
+        return {
+            type: 'ImportSpecifier',
+            imported: ESTreeNodeFactory.createIdentifierNode(name),
+            local: ESTreeNodeFactory.createIdentifierNode(name),
+        };
+    }
+    static createDefaultImportSpecifierNode(name) {
+        return {
+            type: 'ImportDefaultSpecifier',
+            local: ESTreeNodeFactory.createIdentifierNode(name),
+        };
+    }
+    static createNamedImportDeclarationNode(specifiers, source) {
+        return {
+            type: 'ImportDeclaration',
+            specifiers: specifiers.map((specifier) => ESTreeNodeFactory.createNamedImportSpecifierNode(specifier)),
+            source: ESTreeNodeFactory.createLiteralNode(source),
+        };
+    }
+    static createDefaultImportDeclarationNode(specifier, source) {
+        return {
+            type: 'ImportDeclaration',
+            specifiers: [
+                ESTreeNodeFactory.createDefaultImportSpecifierNode(specifier),
+            ],
+            source: ESTreeNodeFactory.createLiteralNode(source),
+        };
+    }
+    static createBasePropertyNode() {
+        return {
+            type: 'Property',
+            method: false,
+            shorthand: false,
+            computed: false,
+            kind: 'init',
+        };
+    }
+    static createIdentifierNode(name) {
+        return {
+            type: 'Identifier',
+            name,
+        };
+    }
+    static createLiteralNode(val) {
+        return {
+            type: 'Literal',
+            value: val !== null && val !== void 0 ? val : '',
+            raw: JSON.stringify(val),
+        };
+    }
+    static createObjectExpressionNode(val) {
+        return {
+            type: 'ObjectExpression',
+            properties: Object.entries(val).map(([k, v]) => ESTreeNodeFactory.createPropertyNode(k, v)),
+        };
+    }
+    static createArrayExpressionNode(val) {
+        return {
+            type: 'ArrayExpression',
+            elements: val.map((v) => ESTreeNodeFactory.createValueNode(v)),
+        };
+    }
+    static createValueNode(input) {
+        if (Array.isArray(input)) {
+            return ESTreeNodeFactory.createArrayExpressionNode(input);
+        }
+        if (isObject(input)) {
+            return ESTreeNodeFactory.createObjectExpressionNode(input);
+        }
+        return ESTreeNodeFactory.createLiteralNode(input);
+    }
+    static createLiteralPropertyNode(key, val) {
+        return {
+            ...ESTreeNodeFactory.createBasePropertyNode(),
+            key: ESTreeNodeFactory.createIdentifierNode(key),
+            value: ESTreeNodeFactory.createLiteralNode(val),
+        };
+    }
+    static createObjectPropertyNode(key, val) {
+        return {
+            ...ESTreeNodeFactory.createBasePropertyNode(),
+            key: ESTreeNodeFactory.createIdentifierNode(key),
+            value: ESTreeNodeFactory.createObjectExpressionNode(val),
+        };
+    }
+    static createArrayPropertyNode(key, val) {
+        return {
+            ...ESTreeNodeFactory.createBasePropertyNode(),
+            key: ESTreeNodeFactory.createIdentifierNode(key),
+            value: ESTreeNodeFactory.createArrayExpressionNode(val),
+        };
+    }
+    static createPropertyNode(key, val) {
+        if (Array.isArray(val)) {
+            return ESTreeNodeFactory.createArrayPropertyNode(key, val);
+        }
+        if (isObject(val)) {
+            return ESTreeNodeFactory.createObjectPropertyNode(key, val);
+        }
+        return ESTreeNodeFactory.createLiteralPropertyNode(key, val);
+    }
+    static createSpreadObjectExpressionNode(spread) {
+        return {
+            type: 'ExpressionStatement',
+            expression: {
+                type: 'ObjectExpression',
+                properties: [
+                    {
+                        type: 'SpreadElement',
+                        argument: ESTreeNodeFactory.createObjectExpressionNode(spread),
+                    },
+                ],
+            },
+        };
+    }
+    static createESTreeProgramNode(statements) {
+        return {
+            type: 'Program',
+            sourceType: 'module',
+            body: statements,
+        };
+    }
+}

package/dist/NodeFactory/MdAstNodeFactory.d.ts

@@ -0,0 +1,31 @@
+import { toString as mdastToString } from 'mdast-util-to-string';
+import type { Root, Heading, Code, Paragraph, Link, Text, Table, Blockquote, ThematicBreak, Content } from 'mdast';
+export type Depth = Heading['depth'];
+export declare class MDASTNodeFactory {
+    static matchAllLinks(str: string): {
+        text: string;
+        url: string;
+    }[];
+    static createRoot(children: Content[]): Root;
+    static createAnyNodeParagraphNode(...contents: any): Paragraph;
+    static createLinkNode(text: string, url: string): Link;
+    static createHeadingNode(text: string, depth: Depth): Heading;
+    static createTextNode(text: string): Text;
+    static toString: typeof mdastToString;
+    static createTextChildren(text: string): Text[];
+    static createParagraphNode(text: string): Paragraph;
+    static createBlockquote(...contents: any[]): Blockquote;
+    static createThematicBreakNode(): ThematicBreak;
+    static createCodeBlockNode(input: {
+        lang: string;
+        value: string;
+        meta?: string | null;
+        data?: Record<string, unknown>;
+    }): Code;
+    static crateTableNode<T extends any = any>(source: T[], getter: {
+        [key: string]: (source: T) => string | {
+            text: string;
+            url: string;
+        } | Paragraph;
+    }): Table;
+}

package/dist/NodeFactory/MdAstNodeFactory.js

@@ -0,0 +1,113 @@
+import { toString as mdastToString } from 'mdast-util-to-string';
+export class MDASTNodeFactory {
+    static matchAllLinks(str) {
+        const regex = /\[(.*?)\]\((.*?)\)/g;
+        const matches = [...str.matchAll(regex)];
+        return matches.map((match) => {
+            return { text: match[1], url: match[2] };
+        });
+    }
+    static createRoot(children) {
+        return {
+            type: 'root',
+            children,
+        };
+    }
+    static createAnyNodeParagraphNode(...contents) {
+        const children = contents.map((content) => typeof content === 'string'
+            ? MDASTNodeFactory.createTextChildren(content)[0]
+            : content);
+        return {
+            type: 'paragraph',
+            children,
+        };
+    }
+    static createLinkNode(text, url) {
+        return {
+            type: 'link',
+            url,
+            children: MDASTNodeFactory.createTextChildren(text),
+        };
+    }
+    static createHeadingNode(text, depth) {
+        return {
+            type: 'heading',
+            depth,
+            children: MDASTNodeFactory.createTextChildren(text),
+        };
+    }
+    static createTextNode(text) {
+        return {
+            type: 'text',
+            value: text,
+        };
+    }
+    static createTextChildren(text) {
+        return [MDASTNodeFactory.createTextNode(text)];
+    }
+    static createParagraphNode(text) {
+        return {
+            type: 'paragraph',
+            children: MDASTNodeFactory.createTextChildren(text),
+        };
+    }
+    static createBlockquote(...contents) {
+        const children = contents.map((content) => typeof content === 'string'
+            ? MDASTNodeFactory.createParagraphNode(content)
+            : content);
+        return {
+            type: 'blockquote',
+            children,
+        };
+    }
+    static createThematicBreakNode() {
+        return {
+            type: 'thematicBreak',
+        };
+    }
+    static createCodeBlockNode(input) {
+        var _a;
+        return {
+            type: 'code',
+            lang: input.lang,
+            meta: input.meta,
+            value: input.value,
+            data: (_a = input.data) !== null && _a !== void 0 ? _a : {},
+        };
+    }
+    static crateTableNode(source, getter) {
+        const argTableFirstRow = {
+            type: 'tableRow',
+            children: Object.keys(getter).map((rowTitle) => {
+                return {
+                    type: 'tableCell',
+                    children: MDASTNodeFactory.createTextChildren(rowTitle),
+                };
+            }),
+        };
+        return {
+            type: 'table',
+            align: Object.keys(getter).map(() => 'center'),
+            children: [argTableFirstRow].concat(source.map((member) => {
+                return {
+                    type: 'tableRow',
+                    children: Object.keys(getter).map((rowTitle) => {
+                        var _a;
+                        const targetGetter = getter[rowTitle];
+                        const value = (_a = targetGetter(member)) !== null && _a !== void 0 ? _a : '';
+                        const node = typeof value === 'object'
+                            ? 'url' in value
+                                ? [MDASTNodeFactory.createLinkNode(value.text, value.url)]
+                                : [value]
+                            : MDASTNodeFactory.createTextChildren(value);
+                        return {
+                            type: 'tableCell',
+                            children: node,
+                        };
+                    }),
+                };
+            })),
+        };
+    }
+}
+MDASTNodeFactory.toString = mdastToString;

package/dist/NodeFactory/MdxAttrNodeFactory.d.ts

@@ -0,0 +1,7 @@
+import type { MdxJsxAttribute, MdxJsxExpressionAttribute } from 'mdast-util-mdx-jsx';
+import type { Dictionary } from 'util-ts-types';
+export declare class MdxAttrNodeFactory {
+    static createMdxJsxAttributeNodes(attributes: Dictionary<any>): (MdxJsxExpressionAttribute | MdxJsxAttribute)[];
+    static createMdxJsxLiteralAttributeNode(name: string, value: string | number | boolean): MdxJsxAttribute;
+    static createMdxJsxExpressionAttributeNode(name: string, value: Dictionary<any>): MdxJsxExpressionAttribute;
+}

package/dist/NodeFactory/MdxAttrNodeFactory.js

@@ -0,0 +1,35 @@
+import { ESTreeNodeFactory } from './ESTreeNodeFactory';
+import { isObject } from '../Utils/is';
+export class MdxAttrNodeFactory {
+    static createMdxJsxAttributeNodes(attributes) {
+        var _a, _b;
+        const parsedAttrs = (_b = (_a = Object.entries(attributes)) === null || _a === void 0 ? void 0 : _a.filter(([_, v]) => typeof v !== 'undefined' && v !== null)) === null || _b === void 0 ? void 0 : _b.map(([key, val]) => {
+            return isObject(val) || Array.isArray(val)
+                ? MdxAttrNodeFactory.createMdxJsxExpressionAttributeNode(key, val)
+                : MdxAttrNodeFactory.createMdxJsxLiteralAttributeNode(key, val);
+        });
+        return parsedAttrs;
+    }
+    static createMdxJsxLiteralAttributeNode(name, value) {
+        return {
+            type: 'mdxJsxAttribute',
+            name,
+            value: value.toString(),
+        };
+    }
+    static createMdxJsxExpressionAttributeNode(name, value) {
+        return {
+            type: 'mdxJsxExpressionAttribute',
+            value: `{...${JSON.stringify({
+                [name]: value,
+            })}`,
+            data: {
+                estree: ESTreeNodeFactory.createESTreeProgramNode([
+                    ESTreeNodeFactory.createSpreadObjectExpressionNode({
+                        [name]: value,
+                    }),
+                ]),
+            },
+        };
+    }
+}

package/dist/NodeFactory/MdxJsxElementFactory.d.ts

@@ -0,0 +1,13 @@
+import type { Content } from 'mdast';
+import type { Dictionary, MaybeArray } from 'util-ts-types';
+import type { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
+import type { MdxjsEsm } from 'mdast-util-mdxjs-esm';
+export interface ComponentRegistration<ComponentMetaProvider = any> {
+    componentName: string;
+    propsProvider?: (input: ComponentMetaProvider) => Dictionary<unknown>;
+    childrenProvider?: (input: ComponentMetaProvider) => Content[];
+}
+export declare class MdxJsxElementFactory {
+    static createMdxJsxImportStatementNode(spcifiers: MaybeArray<string>, source: string): MdxjsEsm;
+    static createMdxJsxFlowElementNode<ComponentMetaProvider>(meta: ComponentMetaProvider, component: string | ComponentRegistration<ComponentMetaProvider>): MdxJsxFlowElement;
+}

package/dist/NodeFactory/MdxJsxElementFactory.js

@@ -0,0 +1,33 @@
+import { ensureArray } from '../Utils/ensureArray';
+import { ESTreeNodeFactory } from './ESTreeNodeFactory';
+import { MdxAttrNodeFactory } from './MdxAttrNodeFactory';
+export class MdxJsxElementFactory {
+    static createMdxJsxImportStatementNode(spcifiers, source) {
+        return {
+            type: 'mdxjsEsm',
+            value: Array.isArray(spcifiers)
+                ? `import { ${spcifiers.join(', ')} } from '${source}';`
+                : `import ${spcifiers} from '${source}';`,
+            data: {
+                estree: ESTreeNodeFactory.createESTreeProgramNode([
+                    Array.isArray(spcifiers)
+                        ? ESTreeNodeFactory.createNamedImportDeclarationNode(spcifiers, source)
+                        : ESTreeNodeFactory.createDefaultImportDeclarationNode(spcifiers, source),
+                ]),
+            },
+        };
+    }
+    static createMdxJsxFlowElementNode(meta, component) {
+        var _a, _b, _c, _d;
+        const componentProvider = typeof component === 'string' ? { componentName: component } : component;
+        return {
+            type: 'mdxJsxFlowElement',
+            name: componentProvider.componentName,
+            // @ts-expect-error
+            children: meta
+                ? ensureArray((_b = (_a = componentProvider.childrenProvider) === null || _a === void 0 ? void 0 : _a.call(componentProvider, meta)) !== null && _b !== void 0 ? _b : [])
+                : [],
+            attributes: MdxAttrNodeFactory.createMdxJsxAttributeNodes(meta ? (_d = (_c = componentProvider.propsProvider) === null || _c === void 0 ? void 0 : _c.call(componentProvider, meta)) !== null && _d !== void 0 ? _d : {} : {}),
+        };
+    }
+}

package/dist/RemarkPluginFactory/CodeBlock2GlobalComponent.d.ts

@@ -0,0 +1,15 @@
+import { RemarkPluginFactoryBase, type ComponentRegistration } from './FactoryBase';
+import type { Plugin } from 'unified';
+import type { Root } from 'mdast';
+interface ComponentTransform extends ComponentRegistration<string> {
+    lang: string;
+}
+interface Options {
+    components: ComponentTransform[];
+}
+export declare class RemarkCodeBlockToGlobalComponentPluginFactory extends RemarkPluginFactoryBase {
+    private readonly options;
+    constructor(options: Options);
+    get remarkPlugin(): Plugin<[unknown], Root>;
+}
+export {};

package/dist/RemarkPluginFactory/CodeBlock2GlobalComponent.js

@@ -0,0 +1,29 @@
+import { RemarkPluginFactoryBase, } from './FactoryBase';
+import { unistVisit } from '../Exports/Unist';
+import { MdxJsxElementFactory } from '../NodeFactory/MdxJsxElementFactory';
+import { getComponentName } from '../Utils/registerComponent';
+export class RemarkCodeBlockToGlobalComponentPluginFactory extends RemarkPluginFactoryBase {
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    get remarkPlugin() {
+        var _a, _b;
+        const components = (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.components) !== null && _b !== void 0 ? _b : [];
+        return () => (tree, vfile) => {
+            unistVisit(tree, 'code', (code, index = 0, parent) => {
+                components.forEach(({ lang, componentPath, propsProvider, childrenProvider }) => {
+                    if (code.lang === lang) {
+                        parent.children.splice(index, 1, 
+                        // @ts-expect-error
+                        MdxJsxElementFactory.createMdxJsxFlowElementNode(code.value, {
+                            componentName: getComponentName(componentPath),
+                            propsProvider,
+                            childrenProvider,
+                        }));
+                    }
+                });
+            });
+        };
+    }
+}

package/dist/RemarkPluginFactory/FactoryBase.d.ts

@@ -0,0 +1,18 @@
+import type { RspressPlugin } from '@rspress-theme-anatole/shared';
+import type { Content } from 'mdast';
+import type { Dictionary } from 'util-ts-types';
+type RsbuildConfig = NonNullable<RspressPlugin['builderConfig']>;
+export interface ComponentRegistration<ComponentMetaProvider = void> {
+    componentPath: string;
+    propsProvider?: (input: ComponentMetaProvider) => Dictionary<any>;
+    childrenProvider?: (input: ComponentMetaProvider) => Content[];
+}
+export declare class RemarkPluginFactoryBase {
+    private readonly baseOptions;
+    constructor(baseOptions: {
+        components: ComponentRegistration<any>[];
+    });
+    get mdxComponents(): string[];
+    get builderConfig(): RsbuildConfig;
+}
+export {};

package/dist/RemarkPluginFactory/FactoryBase.js

@@ -0,0 +1,23 @@
+import { uniqArray } from '../Utils/uniqArray';
+export class RemarkPluginFactoryBase {
+    constructor(baseOptions) {
+        this.baseOptions = baseOptions;
+    }
+    get mdxComponents() {
+        return uniqArray(this.baseOptions.components.map(({ componentPath }) => componentPath));
+    }
+    get builderConfig() {
+        return {
+            tools: {
+                bundlerChain(chain) {
+                    chain.module
+                        .rule('Raw')
+                        .resourceQuery(/raw/)
+                        .type('asset/source')
+                        .end();
+                    chain.resolve.extensions.prepend('.md').prepend('.mdx');
+                },
+            },
+        };
+    }
+}

package/dist/RemarkPluginFactory/InsertComponent.d.ts

@@ -0,0 +1,16 @@
+import { RemarkPluginFactoryBase, type ComponentRegistration } from './FactoryBase';
+import type { Plugin } from 'unified';
+import type { Root } from 'mdast';
+type InsertPosition = 'pre' | 'post' | 'after-first-heading';
+interface ComponentInsertDescriptor extends ComponentRegistration<void> {
+    position: InsertPosition;
+}
+interface Options {
+    components: ComponentInsertDescriptor[];
+}
+export declare class RemarkInsertComponentPluginFactory extends RemarkPluginFactoryBase {
+    readonly options: Options;
+    constructor(options: Options);
+    get remarkPlugin(): Plugin<[unknown], Root>;
+}
+export {};

package/dist/RemarkPluginFactory/InsertComponent.js

@@ -0,0 +1,48 @@
+import { MdxJsxElementFactory } from '../NodeFactory/MdxJsxElementFactory';
+import { RemarkPluginFactoryBase, } from './FactoryBase';
+import { getComponentName } from '../Utils/registerComponent';
+export class RemarkInsertComponentPluginFactory extends RemarkPluginFactoryBase {
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    get remarkPlugin() {
+        var _a, _b;
+        const components = (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.components) !== null && _b !== void 0 ? _b : [];
+        return () => (tree, vfile) => {
+            if (!(components === null || components === void 0 ? void 0 : components.length))
+                return;
+            function getInsertIndex(position) {
+                var _a;
+                if (!((_a = tree.children) === null || _a === void 0 ? void 0 : _a.length))
+                    return 0;
+                switch (position) {
+                    case 'pre':
+                        return (
+                        // @ts-expect-error
+                        tree.children.findLastIndex((node) => node.type === 'mdxjsEsm') +
+                            1);
+                    case 'post':
+                        const beforeInsertCount = components.filter(({ position }) => position === 'pre' || position === 'after-first-heading').length;
+                        const insertIndexAtPost = tree.children.length + beforeInsertCount;
+                        return insertIndexAtPost;
+                    case 'after-first-heading':
+                        const firstHeadingIndex = tree.children.findIndex((node) => node.type === 'heading');
+                        return firstHeadingIndex + 1;
+                    default:
+                        throw new Error(`Unknown insert position: ${position}`);
+                }
+            }
+            components.forEach(({ position, componentPath, propsProvider, childrenProvider }) => {
+                const insertIndex = getInsertIndex(position);
+                tree.children.splice(insertIndex, 0, 
+                // @ts-expect-error
+                MdxJsxElementFactory.createMdxJsxFlowElementNode({}, {
+                    componentName: getComponentName(componentPath),
+                    propsProvider,
+                    childrenProvider,
+                }));
+            });
+        };
+    }
+}

package/dist/Shared/SharedPluginOptions.d.ts

@@ -0,0 +1,4 @@
+export type PresetLocale = 'zh-CN' | 'en-US';
+export interface WithDefaultLocale {
+    defaultLocale?: PresetLocale;
+}

package/dist/Shared/SharedPluginOptions.js

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

package/dist/Shared.d.ts

@@ -0,0 +1 @@
+export type Primitive = string | number | boolean | null | undefined;

package/dist/Shared.js

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

package/dist/SourceParser/ParserUtils.d.mts

@@ -0,0 +1,9 @@
+import { Project, InterfaceDeclaration, TypeAliasDeclaration } from 'ts-morph';
+import { FunctionDeclaration, VariableStatement, SourceFile } from 'ts-morph';
+export declare class TSParserUtils {
+    static ParserProject: Project;
+    static isFunctionDeclaration(input: FunctionDeclaration | VariableStatement): input is FunctionDeclaration;
+    static getFunctionDeclaration(source: SourceFile, name: string): FunctionDeclaration | VariableStatement | undefined;
+    static isInterfaceDeclaration(input: InterfaceDeclaration | TypeAliasDeclaration): input is InterfaceDeclaration;
+    static getTypingDeclaration(source: SourceFile, name: string): InterfaceDeclaration | TypeAliasDeclaration | undefined;
+}

package/dist/SourceParser/ParserUtils.mjs

@@ -0,0 +1,16 @@
+import { SyntaxKind, Project, } from 'ts-morph';
+export class TSParserUtils {
+    static isFunctionDeclaration(input) {
+        return input.getKind() === SyntaxKind.FunctionDeclaration;
+    }
+    static getFunctionDeclaration(source, name) {
+        return source.getFunction(name) || source.getVariableStatement(name);
+    }
+    static isInterfaceDeclaration(input) {
+        return input.getKind() === SyntaxKind.InterfaceDeclaration;
+    }
+    static getTypingDeclaration(source, name) {
+        return source.getTypeAlias(name) || source.getInterface(name);
+    }
+}
+TSParserUtils.ParserProject = new Project();

package/dist/SourceParser/TS.d.mts

@@ -0,0 +1,17 @@
+import { Nullable } from 'util-ts-types';
+export interface ParsedTypingDescriptionMember {
+    name: string;
+    description: string;
+    typingDescription: string;
+    default: Nullable<string>;
+    required: boolean;
+}
+export interface ParsedTypingDescription {
+    name: string;
+    members: ParsedTypingDescriptionMember[];
+    description: string;
+}
+export declare class TSSourceParser {
+    static parseTypingDeclaration(filePath: string, name: string): Nullable<ParsedTypingDescription>;
+    static findTargetExport(filePath: string, functionName: string): Nullable<string>;
+}

package/dist/SourceParser/TS.mjs

@@ -0,0 +1,84 @@
+import { SyntaxKind } from 'ts-morph';
+import { TSParserUtils } from './ParserUtils.mjs';
+export class TSSourceParser {
+    static parseTypingDeclaration(filePath, name) {
+        var _a, _b;
+        const source = TSParserUtils.ParserProject.addSourceFileAtPath(filePath);
+        const input = TSParserUtils.getTypingDeclaration(source, name);
+        if (!input)
+            return null;
+        const declarationName = input.getName();
+        const declarationDescription = (_b = (_a = input
+            .getJsDocs()[0]) === null || _a === void 0 ? void 0 : _a.getComment()) === null || _b === void 0 ? void 0 : _b.toString();
+        const parsedMembers = [];
+        input
+            .getType()
+            .getProperties()
+            .forEach((propertyKey) => {
+            var _a;
+            const property = propertyKey
+                .getValueDeclarationOrThrow()
+                .asKind(SyntaxKind.PropertySignature);
+            const memberName = propertyKey.getName();
+            const memberType = property === null || property === void 0 ? void 0 : property.getType().getText();
+            const memberRequired = !property.hasQuestionToken();
+            const memberJSDocComment = property.getJsDocs()[0];
+            if (!memberJSDocComment) {
+                parsedMembers.push({
+                    name: memberName,
+                    typingDescription: memberType,
+                    required: memberRequired,
+                    description: '',
+                    default: null,
+                });
+                return;
+            }
+            const memberDescription = memberJSDocComment.getCommentText();
+            const memberDefault = (_a = memberJSDocComment
+                .getTags()
+                .find((tag) => tag.getTagName() === 'default')) === null || _a === void 0 ? void 0 : _a.getCommentText();
+            parsedMembers.push({
+                name: memberName,
+                description: memberDescription || '',
+                typingDescription: memberType,
+                default: memberDefault || null,
+                required: memberRequired,
+            });
+        });
+        TSParserUtils.ParserProject.removeSourceFile(source);
+        return {
+            name: declarationName,
+            description: declarationDescription || '',
+            members: parsedMembers,
+        };
+    }
+    static findTargetExport(filePath, functionName) {
+        var _a, _b;
+        const source = TSParserUtils.ParserProject.addSourceFileAtPath(filePath);
+        const allExports = source.getStatements();
+        const targetExport = allExports.find((statement) => {
+            var _a, _b, _c;
+            const kind = statement.getKind();
+            if (kind === SyntaxKind.FunctionDeclaration) {
+                const currentFunctionName = (_a = statement
+                    .asKind(SyntaxKind.FunctionDeclaration)) === null || _a === void 0 ? void 0 : _a.getName();
+                return currentFunctionName && currentFunctionName === functionName;
+            }
+            if (kind === SyntaxKind.VariableStatement) {
+                const declaration = (_b = statement
+                    .asKind(SyntaxKind.VariableStatement)) === null || _b === void 0 ? void 0 : _b.getDeclarations()[0];
+                const isArrowFunc = ((_c = declaration === null || declaration === void 0 ? void 0 : declaration.getInitializer()) === null || _c === void 0 ? void 0 : _c.getKind()) === SyntaxKind.ArrowFunction;
+                if (!isArrowFunc)
+                    return false;
+                const currentFunctionName = declaration === null || declaration === void 0 ? void 0 : declaration.getName();
+                return currentFunctionName && currentFunctionName === functionName;
+            }
+        });
+        if (!targetExport)
+            return null;
+        const jsdocContent = (_b = (_a = targetExport
+            .asKind(SyntaxKind.VariableStatement)) === null || _a === void 0 ? void 0 : _a.getJsDocs()[0]) === null || _b === void 0 ? void 0 : _b.getText();
+        TSParserUtils.ParserProject.removeSourceFile(source);
+        return `${jsdocContent}\n${targetExport.getText()}`;
+    }
+}

package/dist/Utils/createTuple.d.ts

@@ -0,0 +1,3 @@
+export declare const createTuple: <const T extends string>(...input: T[]) => string[] & {
+    _type: T;
+};

package/dist/Utils/createTuple.js

@@ -0,0 +1,4 @@
+export const createTuple = (...input) => {
+    // @ts-expect-error
+    return input;
+};

package/dist/Utils/ensureArray.d.ts

@@ -0,0 +1,2 @@
+import type { MaybeArray } from 'util-ts-types';
+export declare const ensureArray: <T>(val: MaybeArray<T>) => T[];

package/dist/Utils/ensureArray.js

@@ -0,0 +1,3 @@
+export const ensureArray = (val) => {
+    return Array.isArray(val) ? val : [val];
+};

package/dist/Utils/is.d.ts

@@ -0,0 +1,3 @@
+import { Dictionary } from 'util-ts-types';
+export declare function isObject(value: unknown): value is Dictionary;
+export declare function isPrimitive(value: unknown): value is string | number | boolean;

package/dist/Utils/is.js

@@ -0,0 +1,8 @@
+export function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+export function isPrimitive(value) {
+    return (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}

package/dist/Utils/registerComponent.d.ts

@@ -0,0 +1 @@
+export declare function getComponentName(componentPath: string): string;

package/dist/Utils/registerComponent.js

@@ -0,0 +1,4 @@
+import path from 'path';
+export function getComponentName(componentPath) {
+    return path.basename(componentPath, '.tsx');
+}

package/dist/Utils/resolveSourcePath.d.ts

@@ -0,0 +1 @@
+export declare function resolveSourcePath(inputSourcePath: string, currentFilePath: string): string;

package/dist/Utils/resolveSourcePath.js

@@ -0,0 +1,15 @@
+import path from 'path';
+export function resolveSourcePath(inputSourcePath, currentFilePath) {
+    // source=src/... → resolve from workspace root
+    // source=./src/... → resolve from current file
+    // source=/src/... → check is already absolute path, if not, resolve from workspace root
+    if (inputSourcePath.startsWith('/')) {
+        return path.isAbsolute(inputSourcePath)
+            ? inputSourcePath
+            : path.resolve(inputSourcePath);
+    }
+    if (inputSourcePath.startsWith('.')) {
+        return path.resolve(path.dirname(currentFilePath), inputSourcePath);
+    }
+    return path.resolve(inputSourcePath);
+}

package/dist/Utils/uniqArray.d.ts

@@ -0,0 +1 @@
+export declare function uniqArray<T>(arr: T[]): T[];

package/dist/Utils/uniqArray.js

@@ -0,0 +1,3 @@
+export function uniqArray(arr) {
+    return Array.from(new Set(arr));
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { RemarkCodeBlockToGlobalComponentPluginFactory } from './RemarkPluginFactory/CodeBlock2GlobalComponent';
+export { RemarkInsertComponentPluginFactory } from './RemarkPluginFactory/InsertComponent';
+export { PresetConfigMutator } from './ConfigMutator/index';
+export type * from 'util-ts-types';
+export * from './Exports/Unist';
+export { type DirectiveTypes, type DirectiveTransformerTypes, type RemarkDirectiveTransformer, type RemarkTransformDirectiveOptions, remarkTransformDirective, remarkParseDirective, } from './DirectivesTransformer';
+export { MDASTNodeFactory } from './NodeFactory/MdAstNodeFactory';
+export { ESTreeNodeFactory } from './NodeFactory/ESTreeNodeFactory';
+export { MdxAttrNodeFactory } from './NodeFactory/MdxAttrNodeFactory';
+export { MdxJsxElementFactory } from './NodeFactory/MdxJsxElementFactory';
+export { TSSourceParser } from './SourceParser/TS.mjs';
+export { createTuple } from './Utils/createTuple';
+export { ensureArray } from './Utils/ensureArray';
+export { uniqArray } from './Utils/uniqArray';
+export { resolveSourcePath } from './Utils//resolveSourcePath';
+export * from './Utils/registerComponent';
+export * from './Utils/is';
+export * from './Shared/SharedPluginOptions';

package/dist/index.js

@@ -0,0 +1,17 @@
+export { RemarkCodeBlockToGlobalComponentPluginFactory } from './RemarkPluginFactory/CodeBlock2GlobalComponent';
+export { RemarkInsertComponentPluginFactory } from './RemarkPluginFactory/InsertComponent';
+export { PresetConfigMutator } from './ConfigMutator/index';
+export * from './Exports/Unist';
+export { remarkTransformDirective, remarkParseDirective, } from './DirectivesTransformer';
+export { MDASTNodeFactory } from './NodeFactory/MdAstNodeFactory';
+export { ESTreeNodeFactory } from './NodeFactory/ESTreeNodeFactory';
+export { MdxAttrNodeFactory } from './NodeFactory/MdxAttrNodeFactory';
+export { MdxJsxElementFactory } from './NodeFactory/MdxJsxElementFactory';
+export { TSSourceParser } from './SourceParser/TS.mjs';
+export { createTuple } from './Utils/createTuple';
+export { ensureArray } from './Utils/ensureArray';
+export { uniqArray } from './Utils/uniqArray';
+export { resolveSourcePath } from './Utils//resolveSourcePath';
+export * from './Utils/registerComponent';
+export * from './Utils/is';
+export * from './Shared/SharedPluginOptions';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@rspress-theme-anatole/rspress-plugin-devkit",
+  "version": "0.0.1",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "rspress",
+    "plugin",
+    "devkit"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@rspress-theme-anatole/shared": "0.1.18",
+    "@types/estree-jsx": "^1.0.5",
+    "@types/hast": "^2.3.4",
+    "@types/mdast": "^3.0.15",
+    "@types/node": "^20.12.5",
+    "clsx": "^2.1.0",
+    "lodash-es": "^4.17.21",
+    "mdast-util-from-markdown": "^1.3.1",
+    "mdast-util-mdx-jsx": "^3.1.2",
+    "mdast-util-mdxjs-esm": "^2.0.1",
+    "mdast-util-to-markdown": "^1.5.0",
+    "mdast-util-to-string": "^4.0.0",
+    "remark-mdc": "1.2.0",
+    "ts-morph": "^22.0.0",
+    "unified": "^10.1.2",
+    "unist-util-visit": "^5.0.0",
+    "unist-util-visit-parents": "^6.0.1",
+    "util-ts-types": "^1.0.0",
+    "vfile": "^5.3.7",
+    "vfile-reporter": "^7.0.5"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12"
+  },
+  "peerDependencies": {
+    "rspress": "*"
+  }
+}