Skip to content
Manifesto-DigitalPublic

About

No description, website, or topics provided.

Resources

Contributing

Security policy

Stars

3 stars

Watchers

1 watching

Forks

Repository files navigation

RazorKit logo

A component preview and development tool for ASP.NET Core Razor components

Inspired by Storybook, built for .NET developers

Build Status NuGet Version NuGet Downloads License .NET

GitHub Stars GitHub Forks GitHub Issues GitHub Pull Requests Contributors Last Commit

Features • Installation • Quick Start • Documentation • Contributing • License


Overview

RazorKit brings the component-driven development experience to ASP.NET Core Razor applications. Develop, test, and document your UI components in isolation within your running application using an interactive preview environment—without navigating through the full application flow.

Features

  • 🎨 Interactive Component Preview — View and interact with Razor components in isolation
  • ⚡ Real-time Property Editor — Dynamically modify component props and see changes instantly
  • 📚 Story Support — Define multiple states and variants for each component
  • ♿ Accessibility Testing — Built-in axe-core integration for automated a11y validation
  • 📱 Responsive Testing — Preview components at different viewport sizes
  • 🔍 Component Discovery — Automatically discovers components in your project
  • 🏗️ Atomic Design Support — Organize components using Atomic Design methodology

Installation

Requirements

Package Installation

dotnet add package Manifesto.RazorKit

Or add to your .csproj:

<PackageReference Include="Manifesto.RazorKit" Version="0.0.1" />

Quick Start

1. Register Services

Add RazorKit to your ASP.NET Core application in Program.cs:

using Manifesto.RazorKit.Extensions;

var builder = WebApplication.CreateBuilder(args);

// Add Razor Pages (required for RazorKit UI)
builder.Services.AddRazorPages();

// Add RazorKit services
builder.Services.AddRazorKit(options =>
{
    options.ComponentLibraryName = "YourProject.Components";
});

var app = builder.Build();

// Map RazorKit routes
app.MapControllers();
app.MapRazorPages();

app.Run();

2. Define Component Props

Create a props class for your component:

public class ButtonProps
{
    public string Text { get; set; } = "Click me";
    public string Variant { get; set; } = "primary";
    public bool Disabled { get; set; } = false;
}

Keep each component a pure function of its props: render only from the props it's given, and don't look up content, call services or read the request from a component's view. RazorKit renders components with whatever values are entered in its Controls panel.

3. Create Stories

Define stories to showcase different component states:

using Manifesto.RazorKit.Models;

public class ButtonStories : ComponentStoriesBase<ButtonProps>
{
    public override string ComponentName => "Button";

    public override List<ComponentStory> GetStories()
    {
        return new List<ComponentStory>
        {
            CreateStory("primary", "Primary Button", "Default primary button", new ButtonProps
            {
                Text = "Primary",
                Variant = "primary"
            }),
            CreateStory("secondary", "Secondary Button", "Secondary variant", new ButtonProps
            {
                Text = "Secondary",
                Variant = "secondary"
            }),
            CreateStory("disabled", "Disabled State", "Disabled button", new ButtonProps
            {
                Text = "Disabled",
                Disabled = true
            })
        };
    }
}

Story values are serialised into the explorer page and its Controls panel, so don't put live services, connections or secrets in stories.

4. Launch RazorKit

Start your application and navigate to /razorkit to view your components. Live editing in the Controls panel needs the site to be served over HTTPS, or from localhost.

Documentation

Component Organization

RazorKit supports Atomic Design principles:

Components/
├── Atoms/
│   └── Button/
│       ├── Button.cshtml
│       ├── ButtonProps.cs
│       └── ButtonStories.cs
├── Molecules/
├── Organisms/
└── Templates/

Configuration Options

Component Library Name

Configure the component library name to specify static asset paths in the preview HTML:

builder.Services.AddRazorKit(options =>
{
    options.ComponentLibraryName = "YourProject.Components";
});

This generates preview HTML with paths like:

  • /_content/YourProject.Components/css/main.css
  • /_content/YourProject.Components/js/main.js

Themes

If your component library styles itself from a data-theme attribute, list the themes and RazorKit sets the attribute on the preview's <html> element:

builder.Services.AddRazorKit(options =>
{
    options.Themes = new List<RazorKitTheme>
    {
        new() { Name = "Light", DataTheme = "light" },
        new() { Name = "Dark", DataTheme = "dark" }
    };
});
  • The first theme is the default. With one theme it is always applied; with two or more, a theme dropdown appears in the toolbar. With none, the preview sets no data-theme.
  • The chosen theme travels as ?theme=<Name> on RazorKit's links, so a shared link opens in the same theme. A ?theme= that exactly matches a configured Name always wins.
  • The browser remembers the last theme chosen. When the URL's ?theme= is missing, or does not exactly match a configured Name, the remembered theme is used. With no theme remembered, the first configured theme is the default.
  • Name must be unique (ignoring case). DataTheme may only contain letters, digits, hyphens and underscores. An invalid entry stops the application at startup.

The list binds from configuration too, for example builder.Configuration.GetSection("RazorKit:Themes").Bind(options.Themes) with entries of Name and DataTheme.

Custom Component Discovery

Implement IComponentDiscovery to customize how components are discovered:

public class CustomComponentDiscovery : IComponentDiscovery
{
    public List<ComponentInfo> DiscoverComponents()
    {
        // Your custom discovery logic
    }
}

// Register in Program.cs
builder.Services.AddRazorKit(options =>
{
    options.UseCustomDiscovery<CustomComponentDiscovery>();
});

Umbraco Integration

For Umbraco CMS projects, see Umbraco Setup Guide for detailed integration instructions.

Quick Umbraco Setup

Create a Composer to register RazorKit services:

using Manifesto.RazorKit.Extensions;
using Umbraco.Cms.Core.Composing;

namespace YourProject.Composers;

public class RazorKitComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.Services.AddRazorKit(options =>
        {
            options.ComponentLibraryName = "YourProject.UmbracoComponents";
        });
    }
}

Contributing

We welcome contributions! Please see our Contributing Guide for details on:

  • Setting up the development environment
  • Submitting pull requests
  • Coding standards and guidelines
  • Publishing new versions

Support

Roadmap

  • Visual regression testing integration
  • Dark mode support
  • Component documentation generation
  • Plugin system for custom addons

License

This project is licensed under the MIT License - see the LICENSE.md file for details.

Acknowledgments


About

No description, website, or topics provided.

Resources

Contributing

Security policy

Stars

3 stars

Watchers

1 watching

Forks

Releases

Packages

Used by

Contributors

Languages