MCPInstall

syncfusion-blazor-accordion

Guide for implementing the Syncfusion Blazor Accordion component for creating collapsible panels with expandable content. Use this skill when users need to build accordions, implement collapsible sections, create expandable panels, organize content in navigation components, implement FAQs, build collapsible menus, add nested accordions, configure expand modes (single or multiple), handle accordion events, customize accordion styling, implement accessible accordions with WCAG compliance, integrate data binding, or work with any vertically collapsible content containers in Blazor applications.

Installs
347
Last 24h
—
Trending rank
—
Security
Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/syncfusion/blazor-ui-components-skills --skill syncfusion-blazor-accordion
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads syncfusion-blazor-accordion automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Syncfusion Blazor Accordion Component

The Blazor Accordion is a vertically collapsible content container that displays one or more panels. Each panel consists of a header and expandable content section. It supports single or multiple panel expansion, nested accordions, animations, and is fully accessible with WCAG compliance.

When to Use This Skill

Use this skill when you need to:

  • Create collapsible content sections in Blazor applications
  • Build FAQ sections with expandable answers
  • Implement navigation menus with nested items
  • Organize large amounts of content in compact, expandable panels
  • Create wizard-like interfaces with sequential steps
  • Display hierarchical data with nested accordions
  • Implement accessible collapsible components with keyboard navigation
  • Configure expand/collapse animations and behavior
  • Bind dynamic data to accordion items
  • Customize accordion appearance and styling

Documentation and Navigation Guide

Getting Started

📄 Read: references/getting-started.md

  • Installing Syncfusion.Blazor.Navigations NuGet package
  • Namespace imports and service registration
  • Adding theme and script references
  • Creating your first accordion with basic items
  • Implementing accordions using templates (HeaderTemplate, ContentTemplate)

Expand Modes and Behavior

📄 Read: references/expand-modes.md

  • Single expand mode (only one panel open at a time)
  • Multiple expand mode (multiple panels can be open)
  • Configuring initial expanded state with ExpandedIndices
  • Setting individual item expansion with Expanded property
  • Controlling default expand behavior

Content Rendering

📄 Read: references/content-rendering.md

  • LoadOnDemand property for performance optimization
  • Rendering all content at initial load
  • On-demand content loading (default behavior)
  • Performance considerations for large accordions

Data Binding and Events

📄 Read: references/data-binding-events.md

  • Binding local data with foreach loops
  • Using HeaderTemplate and ContentTemplate for dynamic content
  • Handling Created and Destroyed lifecycle events
  • Responding to Clicked events
  • Managing Expanding/Expanded and Collapsing/Collapsed events
  • Preventing default expand/collapse behavior with event args

Customization and Styling

📄 Read: references/customization-styling.md

  • Customizing accordion border and appearance
  • Styling accordion items with CSS
  • Customizing header content and expand/collapse icons
  • Applying hover and selected item styles
  • Using CssClass property on individual items
  • CSS class structure and available classes
  • Theme integration and responsive design

Accessibility and Animations

📄 Read: references/accessibility-animations.md

  • WCAG 2.2 and Section 508 compliance
  • ARIA attributes and screen reader support
  • Keyboard navigation (Arrow keys, Space/Enter, Home/End)
  • RTL support and color contrast
  • Configuring expand/collapse animations
  • Animation effects (SlideDown, SlideUp, FadeIn, FadeOut, ZoomIn, ZoomOut, None)
  • Customizing animation duration and easing

How-To Scenarios

📄 Read: references/how-to-scenarios.md

  • Adding custom icons to accordion headers
  • Creating nested accordions (accordion within accordion)
  • Dynamically adding and removing accordion items
  • Creating wizard interfaces with sequential validation
  • Enabling or disabling specific accordion items
  • Integrating other components (TreeView, etc.) inside accordion content
  • Preventing expand/collapse for specific conditions
  • Showing or hiding accordion items conditionally

Quick Start

Basic Accordion

@using Syncfusion.Blazor.Navigations

<SfAccordion>
    <AccordionItems>
        <AccordionItem Header="ASP.NET" Content="Microsoft ASP.NET is a set of technologies for building Web applications."></AccordionItem>
        <AccordionItem Header="ASP.NET MVC" Content="The Model-View-Controller pattern separates an application into three components."></AccordionItem>
        <AccordionItem Header="JavaScript" Content="JavaScript is an interpreted programming language for web development."></AccordionItem>
    </AccordionItems>
</SfAccordion>

Accordion with Templates

@using Syncfusion.Blazor.Navigations

<SfAccordion>
    <AccordionItems>
        <AccordionItem>
            <HeaderTemplate>
                <div>Employee Details</div>
            </HeaderTemplate>
            <ContentTemplate>
                <div>
                    <b>Name:</b> John Doe<br />
                    <b>Position:</b> Software Engineer
                </div>
            </ContentTemplate>
        </AccordionItem>
    </AccordionItems>
</SfAccordion>

Data-Bound Accordion

@using Syncfusion.Blazor.Navigations

<SfAccordion>
    <AccordionItems>
        @foreach (var item in AccordionData)
        {
            <AccordionItem>
                <HeaderTemplate>
                    <div>@item.Title</div>
                </HeaderTemplate>
                <ContentTemplate>
                    <div>@item.Content</div>
                </ContentTemplate>
            </AccordionItem>
        }
    </AccordionItems>
</SfAccordion>

@code {
    List<DataItem> AccordionData = new List<DataItem>() {
        new DataItem { Title = "Item 1", Content = "Content 1" },
        new DataItem { Title = "Item 2", Content = "Content 2" }
    };
    
    public class DataItem {
        public string Title { get; set; }
        public string Content { get; set; }
    }
}

Common Patterns

Single Expand Mode

Use when only one panel should be open at a time (like FAQs):

<SfAccordion ExpandMode="ExpandMode.Single">
    <AccordionItems>
        <AccordionItem Expanded="true" Header="Question 1" Content="Answer 1"></AccordionItem>
        <AccordionItem Header="Question 2" Content="Answer 2"></AccordionItem>
    </AccordionItems>
</SfAccordion>

Handling Expand Events

Use when you need to perform actions during expand/collapse:

<SfAccordion>
    <AccordionEvents Expanding="OnExpanding" Expanded="OnExpanded"></AccordionEvents>
    <AccordionItems>
        <AccordionItem Header="Item 1" Content="Content 1"></AccordionItem>
    </AccordionItems>
</SfAccordion>

@code {
    public void OnExpanding(ExpandEventArgs args) {
        // Perform validation or load data before expansion
    }
    
    public void OnExpanded(ExpandedEventArgs args) {
        // Handle post-expansion actions
    }
}

Dynamic Item Management

Use when items need to be added or removed at runtime:

<SfButton @onclick="AddItem">Add Item</SfButton>

<SfAccordion>
    <AccordionItems>
        @foreach (var item in Items)
        {
            <AccordionItem Header="@item.Header" Content="@item.Content"></AccordionItem>
        }
    </AccordionItems>
</SfAccordion>

@code {
    List<ItemData> Items = new List<ItemData>();
    
    void AddItem() {
        Items.Add(new ItemData { Header = "New Item", Content = "New Content" });
    }
}

Nested Accordion

Use when you need hierarchical collapsible sections:

<SfAccordion>
    <AccordionItems>
        <AccordionItem Header="Parent Item">
            <ContentTemplate>
                <SfAccordion>
                    <AccordionItems>
                        <AccordionItem Header="Child Item 1" Content="Child Content 1"></AccordionItem>
                        <AccordionItem Header="Child Item 2" Content="Child Content 2"></AccordionItem>
                    </AccordionItems>
                </SfAccordion>
            </ContentTemplate>
        </AccordionItem>
    </AccordionItems>
</SfAccordion>

Key Properties and Configuration

Core Properties

PropertyTypeDefaultDescription
ExpandModeExpandModeMultipleControls whether single or multiple items can be expanded
ExpandedIndicesint[]nullArray of indices for initially expanded items
LoadOnDemandbooltrueWhether to load content on demand or at initial render

AccordionItem Properties

PropertyTypeDefaultDescription
HeaderstringnullText content for the accordion header
ContentstringnullText content for the accordion panel
HeaderTemplateRenderFragmentnullCustom template for the header
ContentTemplateRenderFragmentnullCustom template for the content
ExpandedboolfalseWhether the item is initially expanded
DisabledboolfalseWhether the item is disabled
VisiblebooltrueWhether the item is visible
IconCssstringnullCSS class for custom header icon
CssClassstringnullCustom CSS class for the item

Animation Properties

Configure expand/collapse animations using AccordionAnimationSettings:

<SfAccordion>
    <AccordionAnimationSettings>
        <AccordionAnimationExpand Effect="AnimationEffect.SlideDown" Duration="400"></AccordionAnimationExpand>
        <AccordionAnimationCollapse Effect="AnimationEffect.SlideUp" Duration="400"></AccordionAnimationCollapse>
    </AccordionAnimationSettings>
    <AccordionItems>
        <!-- Items here -->
    </AccordionItems>
</SfAccordion>

Available animation effects: SlideDown, SlideUp, FadeIn, FadeOut, FadeZoomIn, FadeZoomOut, ZoomIn, ZoomOut, None

Common Use Cases

FAQ Section

Perfect for FAQs where only one answer should be visible at a time:

  • Use ExpandMode.Single
  • Set first item as Expanded="true"
  • Style headers to look like questions

Multi-Step Form/Wizard

Create guided workflows with sequential steps:

  • Use Disabled property to prevent skipping steps
  • Use Expanded property to control which step is active
  • Handle Expanding event to validate before moving to next step

Navigation Menu

Organize navigation items hierarchically:

  • Use nested accordions for sub-menus
  • Use IconCss for menu icons
  • Handle Clicked event for navigation actions

Content Organization

Organize large amounts of content in compact form:

  • Use LoadOnDemand="true" for performance
  • Use Multiple expand mode for flexible viewing
  • Provide clear, descriptive headers

Data Display

Display structured data in collapsible sections:

  • Use data binding with foreach
  • Use templates for rich content display
  • Handle events for lazy-loading detailed data

Next Steps

  • For installation and setup, read references/getting-started.md
  • For expand behavior configuration, read references/expand-modes.md
  • For event handling and data binding, read references/data-binding-events.md
  • For styling and customization, read references/customization-styling.md
  • For practical examples, read references/how-to-scenarios.md

FAQ

What does the syncfusion-blazor-accordion skill do?

Guide for implementing the Syncfusion Blazor Accordion component for creating collapsible panels with expandable content. Use this skill when users need to build accordions, implement collapsible sections, create expandable panels, organize content in navigation components, implement FAQs, build collapsible menus, add nested accordions, configure expand modes (single or multiple), handle accordion events, customize accordion styling, implement accessible accordions with WCAG compliance, integrate data binding, or work with any vertically collapsible content containers in Blazor applications.

How do I install syncfusion-blazor-accordion?

Run npx skills add https://github.com/syncfusion/blazor-ui-components-skills --skill syncfusion-blazor-accordion in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/syncfusion-blazor-accordion/ (personal) or .claude/skills/syncfusion-blazor-accordion/ (project).

Which AI agents can use syncfusion-blazor-accordion?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is syncfusion-blazor-accordion safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains syncfusion-blazor-accordion?

It is published by syncfusion in syncfusion/blazor-ui-components-skills. It has 347 recorded installs.

More from syncfusion/blazor-ui-components-skills

View all →

syncfusion-blazor-datagrid

syncfusion/blazor-ui-components-skills

Implements the Syncfusion Blazor DataGrid (SfGrid) for efficient tabular operations such as sorting, filtering, paging, grouping, editing, aggregates, virtualization, lazy‑load grouping, and row or column spanning. Use this skill when building data‑grid workflows in Blazor Server, WebAssembly, Web App, or MAUI applications. Supports Excel/PDF export, virtual or infinite scrolling, customizable templates, and grid state persistence for consistent and optimized data‑grid behavior.

Frontend & Design442 installs

syncfusion-blazor-common

syncfusion/blazor-ui-components-skills

Set up Syncfusion Blazor components — project creation, NuGet packages, service registration, script loading, bUnit testing, and localization & globalization configuration

Frontend & Design410 installs

syncfusion-blazor-dropdowns

syncfusion/blazor-ui-components-skills

Comprehensive guide for implementing Syncfusion Blazor dropdown components including AutoComplete, ComboBox, DropDown List, MultiSelect Dropdown, and ListBox. Use this when building selection interfaces, data binding, filtering, cascading dropdowns, custom templates, and accessible dropdown experiences in Blazor applications. Covers all dropdown components from Syncfusion.Blazor.DropDowns package.

Frontend & Design400 installs

syncfusion-blazor-charts

syncfusion/blazor-ui-components-skills

Implement Syncfusion Blazor Chart (SfChart) component for comprehensive data visualization. Use this when creating line charts, bar/column charts, area charts, financial charts, or statistical visualizations. This skill covers 30+ chart types including scatter plots, bubble charts, candlestick charts, and specialized charts like waterfall, histogram, and polar charts for Blazor applications.

Frontend & Design394 installs

syncfusion-blazor-popups

syncfusion/blazor-ui-components-skills

Implement modal and modeless dialogs using Syncfusion Blazor Dialog component. Use this skill when creating dialogs, popup windows, modal confirmations, custom forms, or interactive overlay windows. Covers templates, events, positioning, animations, accessibility, and advanced customization.

Frontend & Design394 installs

syncfusion-blazor-themes

syncfusion/blazor-ui-components-skills

Customize and apply Syncfusion Blazor themes — Theme Studio color customization, CSS/SCSS integration, lightweight themes, component filtering, and Sass variable overrides

Frontend & Design386 installs

Popular frontend & design skills

View category →

setup-matt-pocock-skills

mattpocock/skills

Configure this repo for the engineering skills: set up its issue tracker, triage label vocabulary, and domain doc layout. Run once before first use of the other engineering skills.

Frontend & Design1.1M installs

frontend-design

anthropics/skills

Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults.

OfficialFrontend & Design1M installs

hyperframes-animation

heygen-com/hyperframes

All animation knowledge for HyperFrames — atomic motion rules, multi-phase scene blueprints, scene transitions, broader motion-design techniques, AND the seven runtime adapters (GSAP default, plus Lottie, Three.js, Anime.js, CSS keyframes, Web Animations API, TypeGPU). Use for any motion or animation task: pick 2-4 rules and compose, or load a blueprint, or look up runtime-specific API (e.g. GSAP eases / Lottie player / Three.js mixer). Also covers auditing an existing composition's choreography (animation map) and 24 named text-animation effects. HyperFrames-native: single paused timeline, seek-safe, deterministic.

prototype

mattpocock/skills

Build a throwaway prototype to answer a design question. Use when the user wants to sanity-check whether a state model or logic feels right, or explore what a UI should look like.

Frontend & Design999.2K installs

hyperframes-core

heygen-com/hyperframes

The HyperFrames composition contract — build one renderable project. Use for composition structure, the data- timing attributes, class="clip", tracks, sub-compositions, variables, framework-owned media playback, deterministic-render rules, and validation. Read before writing composition HTML.

Frontend & Design930.5K installs

vercel-react-best-practices

vercel-labs/agent-skills

React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.

OfficialFrontend & Design843.1K installs