markdoc/markdoc

Features

• Markdown-Based Content Authoring - Provides a Markdown-based syntax extended with custom tags and components for creating documentation sites.
• Markdown Custom Tags - Extends standard Markdown with custom tags, typed schemas, and reusable components for rich documentation authoring.
• Reusable Content Blocks - Provides partial template inclusion and variable passing for composing documents from reusable content blocks.
• Schema Validators - Validates document nodes and attributes against defined schema rules before rendering.
• Markdown Extensions - Extends standard Markdown with custom tags, nodes, and functions for rich content authoring.
• Markdoc - Converts parsed abstract syntax trees into renderable data structures using custom schemas and components.
• Markdown - Transforms parsed Markdown ASTs into renderable content structures using optional configuration.
• Custom Rendering Integrations - Accepts a renderable tree and returns any desired output format, enabling integration with any UI framework.
• Inline Function Invocations - Invokes JavaScript-like functions from document body, annotations, or tag attributes to transform values.
• Markdown Node Transformers - Converts parsed Markdown nodes into any renderable format via custom transform functions.
• Markdown Parsing Pipelines - Parses Markdown source text into an abstract syntax tree for further processing.
• Markdown AST Parsing - Converts raw Markdown strings into abstract syntax trees capturing content structure and location.
• Component Tree Renderers - Converts Markdown documents into React component trees for interactive documentation features.
• Multi-Format Document Rendering - Transforms parsed content into HTML or other output formats through pluggable renderers.
• Live Page Content Readers - Inserts content from separate files into a document so the same text appears in multiple places without duplication.
• Partial Document Inclusion - Embeds separate files into documents via partial tags, enabling content reuse across multiple pages.
• Renderable AST Transformations - Converts abstract syntax trees into serializable intermediate representations for flexible output generation.
• Conditional Content Blocks - Uses variables, functions, and conditional tags to control what content renders based on runtime data.
• Reusable Content Snippets - Loads and renders partial files from a designated directory to reuse content across pages.
• Pluggable Template Renderers - Accepts a renderable tree and returns any output format through configurable renderers for HTML, React, and custom frameworks.
• Abstract Syntax Tree Parsing - Parses Markdown extended with custom tags into an abstract syntax tree for further processing.
• Document - Provides a system for attaching typed attributes to document nodes via separate annotation blocks.
• AST Transformation Pipelines - Implements an AST transformation pipeline that converts Markdown into a renderable intermediate representation.
• Conditional Logic Evaluation - Evaluates boolean expressions within document templates to conditionally render content based on variable states.
• Custom Component Tags - Defines custom tags that map to React components or Web Components for interactive content elements.
• Markdown Tag Composition - Extends standard Markdown with custom tags enclosed in delimiters to create reusable, nestable content components.
• Markdown Tag Syntax Extensions - Adds a declarative tag syntax to Markdown for expressing document hierarchy, interactive components, and conditional content.
• Schema-Backed Markdown Tags - Registers custom tags with schemas that map to components, including typed attributes and allowed child content.
• Component Data Passing - Passes typed values to custom tags using HTML-like or annotation syntax for component configuration.
• Conditional Rendering - Renders content only when specified conditions evaluate to true, with optional fallback for false conditions.
• Markdown Block Components - Provides a system for defining custom block-level components within Markdown content using typed schemas.
• Configurable Document Rendering - Passes variables, custom tags, nodes, functions, and partials to control how Markdown content renders.
• HTML Document Renderers - Converts the renderable tree into an HTML string for direct use in web pages or server responses.
• Markdown Render Overrides - Overrides how standard Markdown elements render by defining custom node schemas.
• Content Transformers - Parses documents into traversable ASTs for static analysis, validation, and automated transformation.
• React Renderers - Converts the renderable tree into React elements using a mapping of custom tags to components.
• Markdown-to-React Renderers - Converts Markdown documents into React element trees with support for custom components.
• HTML Content Renderers - Transforms content into HTML on the server using a configurable renderer with custom tags and nodes.
• Documentation Frameworks - Provides a content framework that parses Markdown into an AST and renders it as React components or HTML.
• Custom Validation Functions - Runs user-defined validation functions on document nodes and tags to enforce content constraints.
• Content Manifest Builders - Parses documents on the server to build a route-to-content mapping for dynamic serving.
• Document-Level Switch/Case Logic - Implements switch/case conditional rendering in documents using custom tags.
• Rich Table Syntaxes - Ships a list-based table syntax supporting code blocks, lists, and configurable column spans.
• Content Manifests - Generates page manifests and validates content at build time for rendering Markdown documents as pages in Next.js.
• Server-Side Rendering Integrations - Integrates with Next.js for server-side rendering of Markdown documents with custom components.
• Frontmatter - Exposes parsed frontmatter values as template variables for rendering inside document bodies.
• Content Validation Rules - Ships a build-time validation pipeline that checks document structure and attributes against custom rules.
• Template Partials - Loads and renders reusable content snippets from external files with context-specific variable passing.
• Looping Content Blocks - Iterates over items in a custom tag's transform function to generate repeated content from a data array.
• Custom Runtime Logic - Registers user-defined JavaScript functions callable within content to transform data or perform custom operations.
• Documentation Validators - Checks documents for correctness separately from the rendering pipeline using custom rules.
• Schema-Driven Validations - Checks document structure and attribute values against defined schemas during transformation to catch errors before rendering.
• Dynamic Function Injection - Registers user-defined JavaScript functions callable from document body and tag attributes for runtime data transformation.
• Heading Identifiers - Overrides default heading nodes to generate custom HTML id attributes for deep linking.
• Document Conditional Evaluations - Evaluates boolean expressions and variable comparisons to control content visibility in documents.
• Undefined Value Handling - Returns specified default values when variables are undefined to prevent rendering errors.
• Tag Attribute Schemas - Provides per-tag attribute type configuration with validation rules to enforce correct usage.
• Page Metadata Overrides - Attaches structured metadata like title and description to documents using frontmatter formats.
• Custom Components - Creates reusable custom elements for tags to encapsulate rendering logic within Markdown content.
• Separate Block Annotations - Applies attributes to inline Markdown nodes using a separate annotation block for per-element customization.
• Custom Inline Tag Definitions - Defines new tags that render as inline elements, automatically wrapped in paragraph nodes.
• Separate Block Annotations - Attaches typed data to any node by placing attributes in a separate annotation block after the node.
• Syntax Highlighting - Applies syntax highlighting to code blocks by replacing default fence nodes with custom renderers.
• Tabbed Content Panes - Groups content into tabs using custom tags and components that switch between labeled panels.
• Data Value Injections - Inserts server-side data into documents at render time, updating output as data changes.
• Next.js - Registers and renders Next.js-specific tags directly inside content for framework integration.
• Template Variable Injection - Inserts dynamic, serializable values prefixed with a symbol into document content at render time.
• Document Attribute Passing - Attaches typed values to tags and nodes to control their rendering behavior in document pipelines.
• Document Layout Wrappers - Provides a mechanism to wrap rendered Markdown content in custom layout components.
• Table of Contents Generators - Collects all headings from the transformed document tree and renders them as a navigable list with anchor links.

Star history