Add Comments to Your iOS App

• Verschachtelte Kommentar-Threads mit Antworten auf mehreren Ebenen und Paginierung
• Sozialer Feed mit Beitragserstellung, Reaktionen und Medienanhängen
• Live-Chat-Modus mit automatischem Scrollen und Datums-Trennzeichen
• Echtzeit-Updates über WebSocket (neue Kommentare, Stimmen, Präsenz)
• Single Sign-On (einfaches SSO für Tests, sicheres SSO für die Produktion)
• Rich-Text-Bearbeitung mit Fett, Kursiv, Code und @Erwähnungen
• Abstimmung mit konfigurierbaren Stilen (Pfeile hoch/runter oder Herzen)
• Moderationsaktionen: melden, anpinnen, sperren, blockieren
• Umfassendes Theming mit Voreinstellungen und vollständiger Anpassung
• Benutzerdefinierte Symbolleisten-Schaltflächen für Kommentare und das Erstellen von Feed-Beiträgen
• Bild-Uploads
• Unterstützung für die EU-Region
• Benutzerpräsenz (Online-/Offline-Indikatoren)
• Tag-basierte Feed-Filterung
• Unterstützung für Lokalisierung

• iOS 16+ oder macOS 14+
• Swift 5.9+
• SwiftUI

Fügen Sie FastCommentsUI Ihrem Projekt mit dem Swift Package Manager hinzu.

In Xcode: Datei > Paketabhängigkeiten hinzufügen, dann die Repository-URL eingeben.

Oder fügen Sie es zu Ihrer Package.swift hinzu:

dependencies: [
    .package(url: "https://github.com/fastcomments/fastcomments-ios.git", from: "1.0.0")
]

Fügen Sie dann das Produkt zu Ihrem Target hinzu:

.target(
    name: "YourApp",
    dependencies: [
        .product(name: "FastCommentsUI", package: "fastcomments-ios")
    ]
)

Importieren Sie beide Module dort, wo sie benötigt werden:

import FastCommentsUI
import FastCommentsSwift

Die minimale Einrichtung, um ein Kommentar-Widget anzuzeigen:

import SwiftUI
import FastCommentsUI

struct ContentView: View {
    @StateObject private var sdk = FastCommentsSDK(
        config: FastCommentsWidgetConfig(
            tenantId: "demo",
            urlId: "my-page-1",
            url: "https://example.com/page-1",
            pageTitle: "My Page"
        )
    )

    var body: some View {
        FastCommentsView(sdk: sdk)
            .task {
                try? await sdk.load()
            }
    }
}

Ersetzen Sie "demo" durch Ihre FastComments Tenant-ID. Die urlId identifiziert die Seite oder den Thread, in dem die Kommentare gespeichert werden.

FastComments unterstützt drei Authentifizierungsmodi:

1. Anonymous -- kein SSO-Token; Benutzer erhalten sitzungsbasierte Identitäten
2. Simple SSO -- clientseitiges Token für Demos und Tests (nicht sicher)
3. Secure SSO -- server-signiertes Token für den Produktionseinsatz

Simple SSO

Nützlich für Demos und lokale Tests. Jeder kann mit Simple SSO jeden Benutzer nachahmen, verwenden Sie es daher nicht in Produktionsumgebungen.

import FastCommentsSwift

let userData = SimpleSSOUserData(
    username: "Jane Doe",
    email: "jane@example.com",
    avatar: "https://example.com/avatar.jpg"
)
let sso = FastCommentsSSO.createSimple(simpleSSOUserData: userData)
let token = try? sso.prepareToSend()

let config = FastCommentsWidgetConfig(
    tenantId: "YOUR_TENANT_ID",
    urlId: "my-page-1",
    sso: token
)
let sdk = FastCommentsSDK(config: config)

SimpleSSOUserData unterstützt außerdem optionale Felder:

• id -- Benutzer-ID (standardmäßig die E-Mail, falls nicht gesetzt)
• displayName -- separater Anzeigename
• displayLabel -- benutzerdefiniertes Label, das neben dem Namen angezeigt wird (z. B. "VIP")
• websiteUrl -- Link beim Namen des Benutzers
• locale -- Lokalisierungscode
• isProfileActivityPrivate -- Profilaktivität ausblenden (standardmäßig true)

Secure SSO

In Produktionsumgebungen erzeugt Ihr Backend ein signiertes SSO-Token mithilfe Ihres API-Secrets. Die iOS-App holt dieses Token von Ihrem Server und übergibt es an die Konfiguration.

On your backend (using the FastComments Swift SDK or any language):

let userData = SecureSSOUserData(
    id: "user-123",
    email: "user@example.com",
    username: "Display Name",
    avatar: "https://example.com/avatar.jpg"
)
let sso = try FastCommentsSSO.createSecure(apiKey: "YOUR_API_KEY", secureSSOUserData: userData)
let token = try sso.prepareToSend()
// Geben Sie dieses Token über Ihre API an Ihre iOS-App zurück

In Ihrer iOS-App:

struct MyView: View {
    @StateObject private var sdk = FastCommentsSDK(
        config: FastCommentsWidgetConfig(
            tenantId: "YOUR_TENANT_ID",
            urlId: "my-page-1"
        )
    )
    @State private var isLoadingToken = true

    var body: some View {
        Group {
            if isLoadingToken {
                ProgressView("Loading...")
            } else {
                FastCommentsView(sdk: sdk)
            }
        }
        .task {
            // Rufen Sie das Token von Ihrem Backend ab
            let token = try? await fetchSSOTokenFromYourBackend()
            // Erstellen Sie eine neue Konfiguration mit dem Token oder setzen Sie es vor dem Laden
            isLoadingToken = false
            try? await sdk.load()
        }
    }
}

SecureSSOUserData unterstützt zusätzliche Felder:

• optedInNotifications -- Opt-in für E-Mail-Benachrichtigungen
• displayLabel -- benutzerdefiniertes Label
• displayName -- Anzeigename
• websiteUrl -- Website-URL
• groupIds -- Gruppenmitgliedschaften
• isAdmin -- Admin-Rechte
• isModerator -- Moderator-Rechte
• isProfileActivityPrivate -- Profil-Datenschutz

Grundlegende Verwendung

struct CommentsPage: View {
    @StateObject private var sdk = FastCommentsSDK(
        config: FastCommentsWidgetConfig(
            tenantId: "YOUR_TENANT_ID",
            urlId: "article-42",
            url: "https://example.com/article/42",
            pageTitle: "Article Title"
        )
    )

    var body: some View {
        FastCommentsView(sdk: sdk)
            .task {
                try? await sdk.load()
            }
    }
}

Abstimmungsstile

Der standardmäßige Abstimmungsstil zeigt Auf-/Ab-Pfeile. Verwende ._1 für Herz-Style-Stimmen:

FastCommentsView(sdk: sdk, voteStyle: ._1)

Ereignis-Callbacks

Verwende Callback-Modifier, um Benutzerinteraktionen zu verarbeiten:

FastCommentsView(sdk: sdk)
    .onCommentPosted { comment in
        print("New comment: \(comment.commentHTML)")
    }
    .onReplyClick { renderableComment in
        print("Replying to: \(renderableComment.comment.id)")
    }
    .onUserClick { context, userInfo, source in
        // Quelle ist .name oder .avatar
        print("Tapped \(userInfo.displayName)")
    }

Theme anwenden

Übergebe ein Theme über die SwiftUI-Umgebung:

FastCommentsView(sdk: sdk)
    .fastCommentsTheme(myTheme)
    .task { try? await sdk.load() }

Oder setze es direkt im SDK:

sdk.theme = FastCommentsTheme.modern

Sortierreihenfolge

sdk.defaultSortDirection = .nf  // Neueste zuerst (Standard)
sdk.defaultSortDirection = .of  // Älteste zuerst
sdk.defaultSortDirection = .mr  // Am relevantesten

LiveChatView bietet eine Echtzeit-Chat-Erfahrung mit automatischem Scrollen, Datums-Trennzeichen und einem kompakten Layout. Es konfiguriert das SDK automatisch für eine Sortierung "älteste zuerst" und sofortige Live-Anzeige.

struct ChatView: View {
    @StateObject private var sdk: FastCommentsSDK = {
        let config = FastCommentsWidgetConfig(
            tenantId: "YOUR_TENANT_ID",
            urlId: "chat-room-1",
            sso: ssoToken  // SSO empfohlen, damit Benutzer Namen haben
        )
        return FastCommentsSDK(config: config)
    }()

    var body: some View {
        LiveChatView(sdk: sdk)
            .onCommentPosted { comment in
                print("Sent: \(comment.commentHTML)")
            }
            .task {
                try? await sdk.load()
            }
    }
}

LiveChatView unterstützt diese Callbacks:

• .onCommentPosted -- wird ausgelöst, wenn der Benutzer eine Nachricht sendet
• .onCommentDeleted -- wird ausgelöst, wenn eine Nachricht gelöscht wird
• .onUserClick -- wird ausgelöst, wenn auf den Namen oder das Avatar eines Benutzers getippt wird

Das Feed-System ist ein separates SDK (FastCommentsFeedSDK) mit eigener Ansicht.

Laden und Anzeigen des Feeds

struct FeedPage: View {
    @StateObject private var sdk: FastCommentsFeedSDK = {
        let config = FastCommentsWidgetConfig(
            tenantId: "YOUR_TENANT_ID",
            urlId: "my-feed",
            sso: ssoToken
        )
        return FastCommentsFeedSDK(config: config)
    }()

    @State private var commentsPost: FeedPost?

    var body: some View {
        FastCommentsFeedView(sdk: sdk)
            .onPostSelected { post in
                commentsPost = post
            }
            .onCommentsRequested { post in
                commentsPost = post
            }
            .onSharePost { post in
                // Teilen-Dialog anzeigen
            }
            .onUserClick { context, userInfo, source in
                // Zum Benutzerprofil navigieren
            }
            .onMediaClick { mediaItem, index in
                // Vollbild-Bildbetrachter anzeigen
            }
            .task {
                try? await sdk.load()
            }
    }
}

Die Feed-Ansicht umfasst automatisch Pull-to-Refresh und unbegrenztes Scrollen.

Erstellen von Beiträgen

Verwenden Sie FeedPostCreateView, um ein Formular zum Erstellen von Beiträgen anzuzeigen:

@State private var showCreatePost = false

// In your view body:
.sheet(isPresented: $showCreatePost) {
    FeedPostCreateView(
        sdk: sdk,
        onPostCreated: { post in
            showCreatePost = false
            Task { try? await sdk.refresh() }
        },
        onCancelled: {
            showCreatePost = false
        }
    )
}

Reagieren auf Beiträge

Das SDK verwaltet Reaktionen mit optimistischen Updates:

try await sdk.reactPost(postId: post.id, reactionType: "l")

// Check reaction state
let hasLiked = sdk.hasUserReacted(postId: post.id, reactType: "l")
let likeCount = sdk.getLikeCount(postId: post.id)

Kommentare zu einem Beitrag öffnen

Verwenden Sie CommentsSheet, um Kommentare für einen Feed-Beitrag anzuzeigen. Es erstellt intern eine FastCommentsSDK-Instanz unter Verwendung der Konfiguration des Feed-SDKs:

.sheet(item: $commentsPost) { post in
    CommentsSheet(post: post, feedSDK: sdk, onUserClick: { context, userInfo, source in
        // Benutzerklick behandeln
    })
}

Hinweis: FeedPost muss Identifiable für .sheet(item:) entsprechen. Fügen Sie diese Erweiterung hinzu:

extension FeedPost: @retroactive Identifiable {}

Tag-basiertes Filtern des Feeds

Implementieren Sie das TagSupplier-Protokoll, um Feed-Beiträge nach Tags zu filtern:

struct TeamTagSupplier: TagSupplier {
    func getTags(currentUser: UserSessionInfo?) -> [String]? {
        guard let user = currentUser else { return nil }
        return ["team:\(user.id ?? "")", "public"]
    }
}

sdk.tagSupplier = TeamTagSupplier()

Geben Sie nil für einen ungefilterten globalen Feed zurück.

Speichern und Wiederherstellen des Feed-Zustands

Bewahren Sie den Paginierungszustand über den Lebenszyklus der Ansicht hinweg auf:

let state = sdk.savePaginationState()
// Later...
sdk.restorePaginationState(state)

Beiträge löschen

sdk.onPostDeleted = { postId in
    print("Post \(postId) was deleted")
}

Theme-Voreinstellungen

Vier integrierte Voreinstellungen sind verfügbar:

// System-Standardeinstellungen
sdk.theme = FastCommentsTheme.default

// Karten mit Schatten und großen abgerundeten Ecken
sdk.theme = FastCommentsTheme.modern

// Flach, keine Schatten, kleine Eckradien, keine Thread-Linien
sdk.theme = FastCommentsTheme.minimal

// Setzt alle Aktionsfarben auf eine einzelne Markenfarbe
sdk.theme = FastCommentsTheme.allPrimary(.indigo)

Anzeigeformate für Kommentare

var theme = FastCommentsTheme()
theme.commentStyle = .flat    // Flache Liste mit Trennlinien (Standard)
theme.commentStyle = .card    // Abgerundete Karten mit Schatten
theme.commentStyle = .bubble  // Chatblasen-Stil

Farben

Alle Farb-Eigenschaften sind optional. Nicht festgelegte Werte fallen auf sinnvolle Systemstandardwerte zurück.

var theme = FastCommentsTheme()

// Markenfarben
theme.primaryColor = .indigo
theme.primaryLightColor = .indigo.opacity(0.6)
theme.primaryDarkColor = Color(red: 0.2, green: 0.1, blue: 0.5)

// Hintergründe
theme.commentBackgroundColor = Color(.secondarySystemGroupedBackground)
theme.containerBackgroundColor = Color(.systemGroupedBackground)

// Aktionsschaltflächen
theme.actionButtonColor = .indigo
theme.replyButtonColor = .indigo
theme.toggleRepliesButtonColor = .indigo.opacity(0.8)
theme.loadMoreButtonTextColor = .indigo

// Stimmen
theme.voteActiveColor = .red
theme.voteCountColor = .primary
theme.voteCountZeroColor = .secondary
theme.voteDividerColor = Color(.separator)

// Links
theme.linkColor = .indigo
theme.linkColorPressed = .indigo.opacity(0.5)

// Dialoge
theme.dialogHeaderBackgroundColor = .indigo
theme.dialogHeaderTextColor = .white

// Eingabeleiste
theme.inputBarBackgroundColor = Color(.systemBackground)
theme.inputBarBorderColor = Color(.separator)

// Sonstiges
theme.onlineIndicatorColor = .green
theme.separatorColor = Color(.separator)
theme.badgeBackgroundColor = .gray.opacity(0.2)
theme.threadLineColor = .indigo.opacity(0.15)

Typografie

theme.commenterNameFont = .subheadline.weight(.bold)
theme.bodyFont = .body
theme.captionFont = .caption
theme.actionFont = .caption.weight(.medium)

Layout und Abstände

theme.cornerRadius = .large       // .none, .small, .medium, .large
theme.commentSpacing = 4          // Punkte zwischen Kommentarzeilen
theme.nestingIndent = 20          // Punkte Einrückung pro Verschachtelungsebene
theme.avatarSize = 36             // Avatar-Durchmesser für oberste Kommentare
theme.replyAvatarSize = 28        // Avatar-Durchmesser für verschachtelte Antworten

Visuelle Effekte

theme.showShadows = true          // Dezente Schatten auf Karten
theme.showThreadLine = true       // Vertikale Linie, die verschachtelte Antworten verbindet
theme.animateVotes = true         // Federanimation bei Stimmenänderungen

Themes anwenden

Zwei Ansätze:

// Über die SwiftUI-Umgebung (für die View-Hierarchie empfohlen)
FastCommentsView(sdk: sdk)
    .fastCommentsTheme(theme)

// Direkt im SDK
sdk.theme = theme

Schaltflächen der Kommentar-Symbolleiste

Implementieren Sie das Protokoll CustomToolbarButton, um Schaltflächen zur Kommentar-Eingabesymbolleiste hinzuzufügen:

struct EmojiButton: CustomToolbarButton {
    let id = "emoji"
    let iconSystemName = "face.smiling"       // Name des SF-Symbols
    let contentDescription = "Add Emoji"
    let badgeText: String? = nil              // Optionale Badge-Anzahl

    func onClick(text: Binding<String>) {
        text.wrappedValue += "\u{1F44D}"
    }

    // Optionale Überschreibungen (Standard: true)
    func isEnabled() -> Bool { true }
    func isVisible() -> Bool { true }
}

Übergeben Sie benutzerdefinierte Schaltflächen beim Erstellen der Ansicht:

FastCommentsView(
    sdk: sdk,
    customToolbarButtons: [EmojiButton(), CodeBlockButton()]
)

Oder fügen Sie sie global im SDK hinzu (gilt für alle Instanzen):

sdk.addGlobalCustomToolbarButton(EmojiButton())
sdk.removeGlobalCustomToolbarButton(id: "emoji")
sdk.clearGlobalCustomToolbarButtons()

Schaltflächen der Feed-Symbolleiste

Implementieren Sie FeedCustomToolbarButton für das Beitragserstellungsformular:

struct HashtagButton: FeedCustomToolbarButton {
    let id = "hashtag"
    let iconSystemName = "number"
    let contentDescription = "Add Hashtag"

    func onClick(content: Binding<String>) {
        content.wrappedValue += "#"
    }
}

Übergeben Sie sie der Erstellungsansicht:

FeedPostCreateView(
    sdk: sdk,
    customToolbarButtons: [HashtagButton()],
    onPostCreated: { _ in },
    onCancelled: { }
)

Oder setzen Sie sie global im Feed-SDK:

sdk.globalFeedToolbarButtons = [HashtagButton()]

Für alle Benutzer verfügbare Aktionen

• Melden/Markierung aufheben -- einen Kommentar zur Überprüfung melden

try await sdk.flagComment(commentId: commentId)
try await sdk.unflagComment(commentId: commentId)

• Blockieren/Blockierung aufheben -- alle Kommentare eines Nutzers ausblenden (pro Betrachter)

try await sdk.blockUser(commentId: commentId)
try await sdk.unblockUser(commentId: commentId)

Nur für Administratoren

• Anpinnen/Entpinnen -- einen Kommentar oben im Thread anpinnen

try await sdk.pinComment(commentId: commentId)
try await sdk.unpinComment(commentId: commentId)

• Sperren/Entsperren -- neue Antworten auf einen Kommentar verhindern

try await sdk.lockComment(commentId: commentId)
try await sdk.unlockComment(commentId: commentId)

Alle Moderationsaktionen sind außerdem über das Kontextmenü des Kommentars in der Benutzeroberfläche verfügbar. Administratoraktionen erscheinen nur, wenn der aktuelle Benutzer ein Site-Administrator ist (festgelegt über das SSO isAdmin Flag oder die Dashboard-Konfiguration).

Nach dem Aufruf von sdk.load() abonniert das SDK automatisch WebSocket-Ereignisse für die konfigurierte urlId. Die folgenden Ereignisse werden behandelt:

• Neue Kommentare, Bearbeitungen und Löschungen
• Stimmen (neu und entfernt)
• Änderungen beim Anpinnen, Sperren, Melden und Blockieren
• Benutzeranwesenheit (Beitritt/Verlassen)
• Thread öffnen/schließen
• Vergabe von Abzeichen
• Aktualisierungen der Serverkonfiguration

Live-Anzeige steuern

Standardmäßig werden neue Kommentare anderer Nutzer sofort angezeigt:

sdk.showLiveRightAway = true   // Standard: sofort anzeigen

Setzen Sie dies auf false, um neue Kommentare hinter einer „N neue Kommentare“-Schaltfläche zu puffern und dem Benutzer die Wahl zu lassen, wann diese angezeigt werden:

sdk.showLiveRightAway = false

Benutzeranwesenheit

Online-/Offline-Indikatoren erscheinen automatisch auf Benutzer-Avataren, wenn der Server die Präsenzverfolgung aktiviert. Auf der Clientseite ist keine zusätzliche Konfiguration erforderlich.

Seitengröße

// Kommentare: Standard 30
sdk.pageSize = 50

// Feed: Standard 10
feedSDK.pageSize = 20

Weitere Kommentare laden

Die Benutzeroberfläche zeigt die Paginierungssteuerungen automatisch an. Sie können die Paginierung auch programmgesteuert auslösen:

// Nächste Seite laden
try await sdk.loadMore()

// Alle verbleibenden laden (deaktiviert, wenn >2000 Kommentare aus Leistungsgründen)
try await sdk.loadAll()

// Zustand prüfen
sdk.hasMore            // Ob weitere Seiten vorhanden sind
sdk.shouldShowLoadAll()
sdk.getCountRemainingToShow()

Paginierung von Antworten

Verschachtelte Antworten werden lazy geladen. Wenn ein Benutzer einen Thread erweitert, werden die ersten 5 Antworten geladen. Eine Steuerung "Weitere Antworten laden" erscheint, wenn mehr vorhanden sind. Dies wird automatisch von der Benutzeroberfläche gehandhabt.

Sowohl FastCommentsSDK als auch FastCommentsFeedSDK sind ObservableObject-Klassen mit @Published-Eigenschaften. Sie können diese in Ihren SwiftUI-Ansichten beobachten, um reaktive UI-Aktualisierungen zu erhalten.

FastCommentsSDK veröffentlichte Eigenschaften

FastCommentsFeedSDK veröffentlichte Eigenschaften

Kommentarbaum

Der Kommentarbaum ist über sdk.commentsTree zugänglich:

// Flache Liste sichtbarer Knoten zur Darstellung
sdk.commentsTree.visibleNodes

// Kommentar per ID nachschlagen
sdk.commentsTree.commentsById["comment-id"]

Um das EU-Rechenzentrum zu verwenden, setzen Sie das Feld region in Ihrer Konfiguration:

let config = FastCommentsWidgetConfig(
    tenantId: "YOUR_TENANT_ID",
    urlId: "my-page",
    region: "eu"
)

Dies leitet alle API-Anfragen und WebSocket-Verbindungen an eu.fastcomments.com weiter.

Wenn Sie mit einer SDK-Instanz fertig sind (z. B. wenn die Ansicht verworfen wird), rufen Sie cleanup() auf, um die WebSocket-Verbindung zu schließen und Hintergrundaufgaben abzubrechen:

sdk.cleanup()

Für Ansichten, die von SwiftUI's @StateObject verwaltet werden, wird dies typischerweise in .onDisappear aufgerufen oder wenn die Ansicht dealloziert wird.

Kommentare

let imageUrl = try await sdk.uploadImage(imageData: jpegData, filename: "photo.jpg")

Gibt die URL-Zeichenkette des hochgeladenen Bildes zurück.

Feed-Beiträge

let mediaItem = try await feedSDK.uploadImage(imageData: jpegData, filename: "photo.jpg")

// Mehrere Bilder parallel hochladen
let mediaItems = try await feedSDK.uploadImages(images: [
    (jpegData1, "photo1.jpg"),
    (jpegData2, "photo2.jpg")
])

Nach Benutzern suchen, um die @mention-Autovervollständigung zu unterstützen:

let results = try await sdk.searchUsers(query: "jan")
// Gibt [UserSearchResult] mit userId, username, avatar usw. zurück.

Die integrierte CommentInputBar kümmert sich automatisch um die @mention-Autovervollständigung.

Bearbeiten

try await sdk.editComment(commentId: commentId, newText: "Updated text")

Der Server rendert das HTML neu. Der lokale Kommentar wird automatisch aktualisiert.

Löschen

try await sdk.deleteComment(commentId: commentId)

Das Löschen eines Kommentars entfernt auch seine Nachkommen aus dem lokalen Baum.

Beide Aktionen sind über das Kommentarkontextmenü in der Benutzeroberfläche verfügbar, wenn der aktuelle Benutzer der Kommentarautor (oder ein Seitenadministrator) ist.

SDK-Methoden werfen FastCommentsError, der LocalizedError entspricht:

do {
    try await sdk.load()
} catch let error as FastCommentsError {
    print(error.translatedError ?? error.reason ?? "Unknown error")
} catch {
    print(error.localizedDescription)
}

FastCommentsError Eigenschaften:

• code -- Fehlercode von der API
• reason -- Englische Fehlerbeschreibung
• translatedError -- vom Server bereitgestellte lokalisierte Fehlermeldung

Blockierende Fehler werden auch automatisch über sdk.blockingErrorMessage bereitgestellt, die von den integrierten Ansichten dem Benutzer angezeigt werden.

Geben Sie einen Locale-Code in der Konfiguration an, um serverseitig bereitgestellte Zeichenketten zu lokalisieren:

let config = FastCommentsWidgetConfig(
    tenantId: "YOUR_TENANT_ID",
    urlId: "my-page",
    locale: "fr_fr"
)

Clientseitige UI-Zeichenketten verwenden die auf iOS-Bundles basierende Lokalisierung.

Das Repository enthält eine vollständige Beispiel-App in ExampleApp/ mit Demonstrationen von:

• Verschachtelte Kommentare mit SSO und benutzerdefinierten Themes
• Social-Feed mit Beitragserstellung und Tag-Filterung
• Live-Chat
• Einfache und sichere SSO-Abläufe
• Benutzerdefinierte Schaltflächen in der Symbolleiste (Kommentare und Feed)