Syncfusion Angular Accordion

Implementing Syncfusion Angular Accordion Component

When to Use This Skill

Use this skill when you need to:

• Create collapsible content panels - Organize related content into expandable sections that collapse to save space
• Build step-by-step wizards - Create multi-step forms or workflows where users progress through accordion items
• Implement FAQ sections - Display frequently asked questions with expandable answers
• Create navigation menus - Build hierarchical menus or navigation structures with nested expandable items
• Load content dynamically - Fetch and display content on-demand as users expand accordion items
• Add custom animations - Enhance user experience with smooth expand/collapse transitions
• Organize complex data - Display structured data with expandable categories and subcategories

Component Overview

The Syncfusion Angular Accordion component displays a vertically collapsible content panel where users can expand one or more sections at a time. Key capabilities include:

• Single/Multiple expand modes - Control whether one or multiple items can be open simultaneously
• Data binding - Bind accordion items from arrays or OData services
• Dynamic item management - Add, remove, or update items at runtime
• Event handling - Respond to expand, collapse, and click events
• Custom animations - Configure smooth transitions with custom effects and duration
• Nested accordions - Create hierarchical accordion structures for complex navigation
• TreeView integration - Embed other components like TreeView for advanced navigation
• Content projection - Use Angular's ng-content for reusable content components

Master Table of Contents

Quick Navigation to Documentation:

1. Getting Started - Installation, setup, and basic initialization
2. Expand Modes - Single vs. Multiple expand modes, configuration
3. Data Binding - Data sources, OData, REST APIs, refresh strategies
4. Dynamic Loading and Interactions - Events, methods, dynamic item management
5. Advanced Features - Animations, nested accordions, styling, RTL
6. Use Cases and Patterns - Real-world implementations and patterns

Documentation and Navigation Guide

Getting Started

📄 Read: references/getting-started.md

When to use:

• Setting up your first Accordion component
• Installing required packages and dependencies
• Understanding CSS imports and theme configuration
• Learning basic initialization methods (template-based, items array, HTML elements)
• Creating your first working example

Expand Modes

📄 Read: references/expand-modes.md

When to use:

• Deciding whether users should expand one or multiple items
• Configuring single mode (only one item open at a time)
• Using multiple mode for simultaneously open items
• Selecting the right mode for your use case
• Handling performance with large datasets

Data Binding

📄 Read: references/data-binding.md

When to use:

• Binding accordion data from external sources
• Using DataManager to fetch from OData services
• Mapping data properties to headers and content
• Working with structured data arrays
• Refreshing accordion content after data updates

Dynamic Loading and Interactions

📄 Read: references/dynamic-loading-and-interactions.md

When to use:

• Adding items dynamically at runtime
• Handling expand/collapse/click events
• Loading content via AJAX or remote requests
• Implementing checkbox-controlled expansion
• Preventing item collapse or forcing items to stay open
• Using ng-content for reusable content components
• Creating always-open accordion items

Advanced Features

📄 Read: references/advanced-features.md

When to use:

• Customizing expand/collapse animations with effects and easing
• Creating nested accordions for hierarchical structures
• Integrating TreeView components within accordion items
• Applying custom CSS styling and theming
• Enabling RTL (right-to-left) support
• Styling headers, items, and expand/collapse icons

Use Cases and Patterns

📄 Read: references/use-cases-patterns.md

When to use:

• Building FAQ sections with best practices
• Creating multi-step wizard forms with validation
• Designing settings panels with categories
• Building navigation menus and organizational hierarchies
• Displaying help and documentation sections
• Learning real-world patterns and code organization strategies

Quick Start Example

Basic template-based accordion with three items:

import { Component } from '@angular/core';
import { AccordionModule } from '@syncfusion/ej2-angular-navigations';

@Component({
  standalone: true,
  selector: 'app-root',
  imports: [AccordionModule],
  template: `
    <ejs-accordion>
      <e-accordionitems>
        <e-accordionitem expanded="true">
          <ng-template #header>
            <div>ASP.NET</div>
          </ng-template>
          <ng-template #content>
            <div>Microsoft ASP.NET is a set of technologies in the Microsoft .NET Framework for building Web applications and XML Web services.</div>
          </ng-template>
        </e-accordionitem>
        
        <e-accordionitem>
          <ng-template #header>
            <div>ASP.NET MVC</div>
          </ng-template>
          <ng-template #content>
            <div>The Model-View-Controller (MVC) architectural pattern separates an application into three main components: the model, the view, and the controller.</div>
          </ng-template>
        </e-accordionitem>
        
        <e-accordionitem>
          <ng-template #header>
            <div>JavaScript</div>
          </ng-template>
          <ng-template #content>
            <div>JavaScript (JS) is an interpreted computer programming language used for creating interactive web pages and applications.</div>
          </ng-template>
        </e-accordionitem>
      </e-accordionitems>
    </ejs-accordion>
  `
})
export class AppComponent {}

Using items array approach:

import { Component } from '@angular/core';
import { AccordionModule } from '@syncfusion/ej2-angular-navigations';

@Component({
  standalone: true,
  selector: 'app-root',
  imports: [AccordionModule],
  template: `<ejs-accordion [items]="accordionItems"></ejs-accordion>`
})
export class AppComponent {
  public accordionItems = [
    {
      header: 'ASP.NET',
      content: 'Microsoft ASP.NET is a set of technologies in the Microsoft .NET Framework for building Web applications.',
      expanded: true
    },
    {
      header: 'ASP.NET MVC',
      content: 'The Model-View-Controller (MVC) architectural pattern separates an application into three main components.'
    },
    {
      header: 'JavaScript',
      content: 'JavaScript (JS) is an interpreted computer programming language used for creating interactive web pages.'
    }
  ];
}

Common Patterns

Pattern 1: Single Expand Mode (One Item Open)

Use when you want only one accordion item open at a time, common for navigation menus and settings panels.

<ejs-accordion expandMode="Single">
  <!-- items here -->
</ejs-accordion>

Pattern 2: Dynamic Item Addition

Add items programmatically in response to user actions or data loading.

@ViewChild('accordion') accordionObj?: AccordionComponent;

addNewItem() {
  this.accordionObj?.addItem({
    header: 'New Item',
    content: 'New content here'
  });
}

Pattern 3: Event-Driven Workflows

Respond to accordion events for custom logic like validation or data loading.

<ejs-accordion (expanding)="onExpanding($event)" (expanded)="onExpanded($event)">
  <!-- items here -->
</ejs-accordion>

onExpanding(event: ExpandEventArgs) {
  // Prevent collapse of currently open item
  event.cancel = true;
}

Pattern 4: Animated Expand/Collapse

Add smooth animations for better visual feedback.

<ejs-accordion [animation]="animationSettings">
  <!-- items here -->
</ejs-accordion>

animationSettings = {
  expand: { effect: 'SlideDown', duration: 400, easing: 'ease' },
  collapse: { effect: 'SlideUp', duration: 400, easing: 'ease' }
};

Complete API Reference

For detailed documentation on each API element with working code examples, refer to the reference files. Below is a comprehensive summary.

Accordion Component Properties (13 Total)

AccordionItem Properties (8 Total)

Methods (7 Total)

Events (5 Total)

Animation Effects (6 Types)

Easing Functions (5 Types)

Common Use Cases

1. FAQ Section - Expandable question/answer pairs with single expand mode
2. Multi-Step Wizard - Sequential items with validation and conditional enabling
3. Settings Panel - Grouped settings organized in expandable sections
4. Navigation Menu - Hierarchical navigation with nested accordions
5. Data Explorer - Expandable data categories with dynamic loading
6. Help Documentation - Collapsible help sections organized by topic

Troubleshooting Quick Reference

Item won't expand?

• Check if item is disabled with enableItem(false, index)
• Verify expandMode setting matches your requirement

Content not loading?

• Ensure header and content properties are set
• Check CSS imports are included in styles

Animation not smooth?

• Verify CSS is properly imported
• Check browser console for errors
• Consider reducing animation duration for slower devices

Multiple items closing unexpectedly?

• Verify expandMode is set to 'Multiple' if multiple should be open
• Check event handlers aren't calling e.cancel = true

For detailed information on any aspect, refer to the documentation and navigation guide above. Start with getting-started.md if you're new to the component.