metalsmith/metalsmith

Features

• Static Content Processors - Produce static sites, project scaffolds, or eBooks by passing files through a standardized processing pipeline.
• In-Memory File Object Representations - Converts directory trees into plain JavaScript objects to allow programmatic manipulation of content and metadata in memory.
• Transformation Plugins - Employs a pluggable pipeline architecture where custom functions manipulate content and metadata.
• Transformation Pipelines - Implements a pluggable build pipeline that passes file objects through a sequence of custom transformation functions.
• General Purpose Processing Pipelines - Implements a linear plugin pipeline that passes file objects through a sequence of functions to transform data incrementally.
• Virtual File System Representations - Transforms entire directory trees into plain JavaScript objects, enabling programmatic manipulation of content and metadata in memory.
• Static Documentation Generators - Convert Markdown to HTML, build navigation trees, and render pages with templates.
• Front Matter Parsers - Extracts YAML or JSON metadata from the top of source files to attach structured data to file objects.
• Frontmatter Serializers - Converts a file object and its metadata back into a string with a header.
• File Metadata Manipulation - Provides mechanisms to load and transform metadata from frontmatter, JSON, YAML, or environment variables.
• Global Site Metadata - Provides a shared global metadata store accessible to all plugins during the build.
• Static Site Generators - Transforms source files and templates into optimized static HTML documents for web deployment.
• Static Site Generators - Transforms source files and templates into a complete set of static HTML pages via a plugin pipeline.
• Static Websites - Generates websites consisting of pre-rendered HTML, CSS, and JavaScript files served without a dynamic backend.
• Virtual File System Manipulations - Enables renaming, moving, and removing files by manipulating the in-memory file object representation.
• File - Enables iterating over the internal file collection to apply transformations to specific subsets of content.
• Frontmatter Management - Provides tools for programmatically reading and modifying YAML or JSON frontmatter embedded in source files.
• Front-Matter Indexing - Extracts YAML front-matter from source files to attach structured metadata to the internal file objects.
• Object Transformation - Converts source directories into JavaScript objects to allow plugins to manipulate the site structure programmatically.
• Build Pipeline Plugins - Accepts user-written functions or local modules to manipulate files during the build pipeline.
• Build Output Writing - Runs source files through a plugin stack and outputs the final results into a target folder.
• Build Configurations - Uses JSON configuration files to define sources, destinations, and plugin sequences for the build process.
• Output Directory Configuration - Provides configuration options to set the target folder for processed files.
• CLI Command Frameworks - Ships a CLI for managing the entire build lifecycle, including initialization and output cleaning.
• CLI Configurations - Supports project configuration via JSON files to define build paths and plugin settings.
• Static Site Documentation - Transforms markdown files into structured technical documentation with navigation and templated HTML output.
• In-Memory File Object Manipulations - Provides the ability to create, rename, and delete files by manipulating a plain JavaScript object representing the site structure.
• Pluggable Build Pipelines - Utilizes a sequence of custom functions to incrementally manipulate file objects and metadata.
• Transformation Plugin Development - Passes source files through a chain of transformation plugins to write processed results to a destination directory.
• Build Path Mapping - Allows precise control over the working directory and the source/destination folders.
• Static Content Transformations - Transforms source files through a sequence of plugins to write finished content to a destination directory.
• Build Automation - Implements automated build workflows including change-triggered rebuilds and performance measurement.
• CLI Build Executors - Provides a command-line interface to execute site generation, project initialization, and cleanup tasks.
• Build Configuration - Allows build pipelines to be defined both programmatically via API and declaratively via JSON.
• Shared Build State - Maintains a shared metadata object that can be accessed and modified by all plugins to coordinate data across the site.
• Pipeline Plugins - Utilizes modular plugins that define sequential stages in a data processing pipeline for incremental transformations.
• Source Directory Configuration - Enables users to specify the folder containing the source files to be processed.
• Static Content Processors - Processes source files through transformations to generate diverse static outputs like websites, eBooks, and technical documentation.
• Static Site Generators - Functions as a Node.js-based static site generator that transforms source files into web assets via a processing pipeline.
• File Collection Builders - Groups files into collections to automatically generate indexes and sequential navigation links.
• Ebook Compilation - Converts Markdown chapter files into multiple ebook formats including PDF, ePUB, and MOBI.
• eBook Compilers - Assembles markdown chapter files into multiple eBook formats including PDF, ePUB, and MOBI.
• Markdown to HTML Converters - Transforms Markdown source files into structured HTML for web display.
• Structured Return Objects - Runs a plugin stack on source files and returns the final output as a structured JavaScript data object.
• Asynchronous File Operations - Supports running asynchronous tasks inside plugins and coordinating parallel operations.
• Frontmatter Serialization - Converts file objects and their metadata back into strings with frontmatter delimiters for output.
• Shared Memory Configuration Stores - Maintains a globally accessible memory space for synchronizing site-wide configuration and shared variables across all plugins.
• File-Based Build Operations - Allows users to create custom build tools by sequencing operations on a file-based abstraction.
• Build Output Directories - Allows configuration of the input source directory and the final output destination folder.
• File Ignore Patterns - Supports excluding specific files or directories from the build output using glob patterns.
• File Pattern Matching - Allows selecting specific source files or excluding directories using wildcard glob patterns.
• Glob-Based File Location - Allows excluding files or directories from the build using glob-based pattern matching.
• Glob Pattern Selectors - Uses wildcard glob patterns to select or exclude specific source files and directories from the build scope.
• In-Memory Build Processing - Executes a plugin stack on files in memory to generate a result without saving data to the physical disk.
• Watch Modes - Implements a watch mode that monitors filesystem changes to trigger automatic rebuilds of the project.
• Project Scaffolding - Includes a utility to generate new project directory structures by filling template files with user values.
• Project Scaffolding Templates - Provides the ability to generate new project directory structures from template files with customizable placeholders.
• Project Scaffolding Tools - Ships a utility to bootstrap new project directory structures using template-driven scaffolding.
• Source-to-HTML Converters - Converts input formats such as Pug, AsciiDoc, or Textile into HTML for web presentation.
• Static Asset Distributions - Moves specified files or directories directly to the destination folder without running them through plugins.
• Source File Watching - Monitors source files for changes to trigger automatic recompilation and rebuilds during development.
• Path Manipulations - Provides utilities to read and write file paths using OS-specific separators and normalized patterns.
• Asynchronous Flow Coordination - Implements patterns for managing the synchronization and resolution of concurrent asynchronous plugin operations during the build.
• Environment Variable Managers - Manages case-insensitive environment variables to control build behavior across different environments.
• Environment Variables - Implements key-value pair storage for environment variables that influence plugin behavior.
• Build Artifact Management - Clears the destination directory before writing new build results.
• Concurrent Task Limiters - Restricts the number of simultaneous open files to prevent system resource exhaustion during the build.
• Plugin Configurations - Allows wrapping plugin bodies in initializer functions to validate and set default configuration options.
• Pluggable Module Loading - Supports dynamic import of JavaScript, JSON, or ESM modules relative to the project directory.
• Page Layout Templates - Wraps source content in templates using engines like Handlebars, Twig, or React for consistent page structure.

Star history