Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/InviteLinksUI/Sources/AdditionalLinkItem.swift

@@ -0,0 +1,526 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import ShimmerEffect
+import TelegramCore
+
+public class AdditionalLinkItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let username: TelegramPeerUsername?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let tapAction: (() -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        presentationData: ItemListPresentationData,
+        systemStyle: ItemListSystemStyle = .legacy,
+        username: TelegramPeerUsername?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        tapAction: (() -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.username = username
+        self.sectionId = sectionId
+        self.style = style
+        self.tapAction = tapAction
+        self.tag = tag
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            var firstWithHeader = false
+            var last = false
+            if self.style == .plain {
+                if previousItem == nil {
+                    firstWithHeader = true
+                }
+                if nextItem == nil {
+                    last = true
+                }
+            }
+            let node = AdditionalLinkItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? AdditionalLinkItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    var firstWithHeader = false
+                    var last = false
+                    if self.style == .plain {
+                        if previousItem == nil {
+                            firstWithHeader = true
+                        }
+                        if nextItem == nil {
+                            last = true
+                        }
+                    }
+                    
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView) {
+        listView.clearHighlightAnimated(true)
+        self.tapAction?()
+    }
+}
+
+public class AdditionalLinkItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let extractedBackgroundImageNode: ASImageNode
+
+    private let containerNode: ContextControllerSourceNode
+    private let contextSourceNode: ContextExtractedContentContainingNode
+    
+    private var extractedRect: CGRect?
+    private var nonExtractedRect: CGRect?
+    
+    private let offsetContainerNode: ASDisplayNode
+    
+    private let iconBackgroundNode: ASImageNode
+    private let iconNode: ASImageNode
+    
+    private let titleNode: TextNode
+    private let subtitleNode: TextNode
+    
+    private var placeholderNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    private var layoutParams: (AdditionalLinkItem, ListViewItemLayoutParams, ItemListNeighbors, Bool, Bool)?
+    
+    private var reorderControlNode: ItemListEditableReorderControlNode?
+    
+    public var tag: ItemListItemTag?
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        self.maskNode = ASImageNode()
+        
+        self.extractedBackgroundImageNode = ASImageNode()
+        self.extractedBackgroundImageNode.displaysAsynchronously = false
+        self.extractedBackgroundImageNode.alpha = 0.0
+        
+        self.contextSourceNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        
+        self.offsetContainerNode = ASDisplayNode()
+        
+        self.iconBackgroundNode = ASImageNode()
+        self.iconBackgroundNode.displaysAsynchronously = false
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.displaysAsynchronously = false
+        self.iconNode.displayWithoutProcessing = true
+        self.iconNode.contentMode = .center
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+    
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        self.subtitleNode.contentMode = .left
+        self.subtitleNode.contentsScale = UIScreen.main.scale
+            
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.isAccessibilityElement = true
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        self.addSubnode(self.containerNode)
+        
+        self.contextSourceNode.contentNode.addSubnode(self.extractedBackgroundImageNode)
+        self.contextSourceNode.contentNode.addSubnode(self.offsetContainerNode)
+        
+        self.offsetContainerNode.addSubnode(self.iconBackgroundNode)
+        self.offsetContainerNode.addSubnode(self.iconNode)
+        self.offsetContainerNode.addSubnode(self.titleNode)
+        self.offsetContainerNode.addSubnode(self.subtitleNode)
+    }
+        
+    public func asyncLayout() -> (_ item: AdditionalLinkItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors, _ firstWithHeader: Bool, _ last: Bool) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        let reorderControlLayout = ItemListEditableReorderControlNode.asyncLayout(self.reorderControlNode)
+        
+        let currentItem = self.layoutParams?.0
+                
+        return { item, params, neighbors, firstWithHeader, last in
+            var updatedTheme: PresentationTheme?
+            var updatedIsActive = false
+        
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            let subtitleFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 14.0 / 17.0))
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            if currentItem?.username?.isActive != item.username?.isActive {
+                updatedIsActive = true
+            }
+            
+            let iconColor: UIColor
+            if let username = item.username {
+                if username.isActive {
+                    iconColor = item.presentationData.theme.list.itemAccentColor
+                } else {
+                    iconColor = UIColor(rgb: 0xa8b2bb)
+                }
+            } else {
+                iconColor = item.presentationData.theme.list.mediaPlaceholderColor
+            }
+            
+            let titleText: String
+            let subtitleText: String
+            let subtitleColor: UIColor
+            if let username = item.username {
+                titleText = "@\(username.username)"
+                
+                if username.isActive {
+                    subtitleText = item.presentationData.strings.Group_Setup_LinkActive
+                    subtitleColor = item.presentationData.theme.list.itemAccentColor
+                } else {
+                    subtitleText = item.presentationData.strings.Group_Setup_LinkInactive
+                    subtitleColor = item.presentationData.theme.list.itemSecondaryTextColor
+                }
+            } else {
+                titleText = " "
+                subtitleText = " "
+                subtitleColor = item.presentationData.theme.list.itemSecondaryTextColor
+            }
+            
+            let titleAttributedString = NSAttributedString(string: titleText, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            let subtitleAttributedString = NSAttributedString(string: subtitleText, font: subtitleFont, textColor: subtitleColor)
+            
+            let reorderControlSizeAndApply = reorderControlLayout(item.presentationData.theme)
+            let reorderInset: CGFloat = reorderControlSizeAndApply.0
+            
+            let leftInset: CGFloat = 65.0 + params.leftInset
+            let rightInset: CGFloat = 16.0 + params.rightInset
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = subtitleAttributedString.string.isEmpty ? 18.0 : 12.0
+            case .legacy:
+                verticalInset = subtitleAttributedString.string.isEmpty ? 14.0 : 8.0
+            }
+           
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset - reorderInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: subtitleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset - reorderInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let titleSpacing: CGFloat = 1.0
+            
+            let minHeight: CGFloat = titleLayout.size.height + verticalInset * 2.0
+            let rawHeight: CGFloat = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + subtitleLayout.size.height
+            
+            var insets: UIEdgeInsets
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            switch item.style {
+                case .plain:
+                    itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                    insets = itemListNeighborsPlainInsets(neighbors)
+                    insets.top = firstWithHeader ? 29.0 : 0.0
+                    insets.bottom = 0.0
+                case .blocks:
+                    itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                    insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let contentSize = CGSize(width: params.width, height: max(minHeight, rawHeight))
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.layoutParams = (item, params, neighbors, firstWithHeader, last)
+                                        
+                    strongSelf.accessibilityLabel = titleAttributedString.string
+                    strongSelf.accessibilityValue = subtitleAttributedString.string
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.offsetContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.contentNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.containerNode.isGestureEnabled = false
+                    
+                    let nonExtractedRect = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width - 16.0, height: layout.contentSize.height))
+                    let extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: 16.0 + params.leftInset, dy: 0.0)
+                    strongSelf.extractedRect = extractedRect
+                    strongSelf.nonExtractedRect = nonExtractedRect
+                    
+                    if strongSelf.contextSourceNode.isExtractedToContextPreview {
+                        strongSelf.extractedBackgroundImageNode.frame = extractedRect
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.frame = nonExtractedRect
+                    }
+                    strongSelf.contextSourceNode.contentRect = extractedRect
+                     
+                    strongSelf.iconBackgroundNode.image = generateFilledCircleImage(diameter: 40.0, color: iconColor)
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                        
+                       
+                    }
+                    
+                    if updatedIsActive || updatedTheme != nil {
+                        strongSelf.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: item.username?.isActive == true ? "Chat/Context Menu/Link" : "Chat/Context Menu/Unlink"), color: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                    }
+                                        
+                    let transition = ContainedViewLayoutTransition.immediate
+                                        
+                    let _ = titleApply()
+                    let _ = subtitleApply()
+                    
+                    switch item.style {
+                        case .plain:
+                            if strongSelf.backgroundNode.supernode != nil {
+                                strongSelf.backgroundNode.removeFromSupernode()
+                            }
+                            if strongSelf.topStripeNode.supernode != nil {
+                                strongSelf.topStripeNode.removeFromSupernode()
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                            }
+                            if strongSelf.maskNode.supernode != nil {
+                                strongSelf.maskNode.removeFromSupernode()
+                            }
+                            
+                            let stripeInset: CGFloat
+                            if case .none = neighbors.bottom {
+                                stripeInset = 0.0
+                            } else {
+                                stripeInset = leftInset
+                            }
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: stripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - stripeInset, height: separatorHeight))
+                            strongSelf.bottomStripeNode.isHidden = last
+                        case .blocks:
+                            if strongSelf.backgroundNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                            }
+                            if strongSelf.topStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                            }
+                            if strongSelf.maskNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                            }
+                            
+                            let hasCorners = itemListHasRoundedBlockLayout(params)
+                            var hasTopCorners = false
+                            var hasBottomCorners = false
+                            switch neighbors.top {
+                                case .sameSection(false):
+                                    strongSelf.topStripeNode.isHidden = true
+                                default:
+                                    hasTopCorners = true
+                                    strongSelf.topStripeNode.isHidden = hasCorners
+                            }
+                            let bottomStripeInset: CGFloat
+                            switch neighbors.bottom {
+                                case .sameSection(false):
+                                    bottomStripeInset = leftInset
+                                    strongSelf.bottomStripeNode.isHidden = false
+                                default:
+                                    bottomStripeInset = 0.0
+                                    hasBottomCorners = true
+                                    strongSelf.bottomStripeNode.isHidden = hasCorners
+                            }
+                            
+                            strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                            
+                            strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                            strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                            strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    }
+                    
+                    let iconSize: CGSize = CGSize(width: 40.0, height: 40.0)
+                    let iconFrame = CGRect(origin: CGPoint(x: params.leftInset + 12.0, y: floorToScreenPixels((layout.contentSize.height - iconSize.height) / 2.0)), size: iconSize)
+                    strongSelf.iconBackgroundNode.bounds = CGRect(origin: CGPoint(), size: iconSize)
+                    strongSelf.iconBackgroundNode.position = iconFrame.center
+                    strongSelf.iconNode.frame = iconFrame
+                                                                                
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.subtitleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset + titleLayout.size.height + titleSpacing), size: subtitleLayout.size))
+                                        
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                    
+                    let isReorderable = item.username?.isActive == true
+                    if isReorderable {
+                        let reorderControlNode = reorderControlSizeAndApply.1(layout.contentSize.height, false, .immediate)
+                        strongSelf.reorderControlNode = reorderControlNode
+                        strongSelf.addSubnode(reorderControlNode)
+                        reorderControlNode.alpha = 0.0
+                        transition.updateAlpha(node: reorderControlNode, alpha: 1.0)
+                    } else if let reorderControlNode = strongSelf.reorderControlNode, item.username?.isActive == false {
+                        strongSelf.reorderControlNode = nil
+                        reorderControlNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false, completion: { [weak reorderControlNode] _ in
+                            reorderControlNode?.removeFromSupernode()
+                        })
+                    }
+                                
+                    let reorderControlFrame = CGRect(origin: CGPoint(x: params.width - params.rightInset - reorderControlSizeAndApply.0, y: 0.0), size: CGSize(width: reorderControlSizeAndApply.0, height: layout.contentSize.height))
+                    strongSelf.reorderControlNode?.frame = reorderControlFrame
+                    
+                    if item.username == nil {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.placeholderNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.placeholderNode = shimmerNode
+                            strongSelf.addSubnode(shimmerNode)
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+                        
+                        var shapes: [ShimmerEffectNode.Shape] = []
+                        
+                        let titleLineWidth: CGFloat = 180.0
+                        let subtitleLineWidth: CGFloat = 60.0
+                        let lineDiameter: CGFloat = 10.0
+                        
+                        let iconFrame = strongSelf.iconBackgroundNode.frame
+                        shapes.append(.circle(iconFrame))
+                        
+                        let titleFrame = strongSelf.titleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: titleFrame.minX, y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: titleLineWidth, diameter: lineDiameter))
+                        
+                        let subtitleFrame = strongSelf.subtitleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: subtitleFrame.minX, y: subtitleFrame.minY + floor((subtitleFrame.height - lineDiameter) / 2.0)), width: subtitleLineWidth, diameter: lineDiameter))
+                        
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: layout.contentSize)
+                    } else if let shimmerNode = strongSelf.placeholderNode {
+                        strongSelf.placeholderNode = nil
+                        shimmerNode.removeFromSupernode()
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.placeholderNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+    
+    override public func isReorderable(at point: CGPoint) -> Bool {
+        if let reorderControlNode = self.reorderControlNode, reorderControlNode.frame.contains(point) {
+            return true
+        }
+        return false
+    }
+}

submodules/InviteLinksUI/Sources/FolderInviteLinkListController.swift

@@ -0,0 +1,826 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import OverlayStatusController
+import AccountContext
+import AlertUI
+import PresentationDataUtils
+import AppBundle
+import ContextUI
+import TelegramStringFormatting
+import ItemListPeerActionItem
+import ItemListPeerItem
+import ShareController
+import UndoUI
+import QrCodeUI
+import PromptUI
+
+private final class FolderInviteLinkListControllerArguments {
+    let context: AccountContext
+    let shareMainLink: (String) -> Void
+    let openMainLink: (String) -> Void
+    let copyLink: (String) -> Void
+    let mainLinkContextAction: (ExportedChatFolderLink?, ASDisplayNode, ContextGesture?) -> Void
+    let peerAction: (EnginePeer, Bool) -> Void
+    let toggleAllSelected: () -> Void
+    
+    init(
+        context: AccountContext,
+        shareMainLink: @escaping (String) -> Void,
+        openMainLink: @escaping (String) -> Void,
+        copyLink: @escaping (String) -> Void,
+        mainLinkContextAction: @escaping (ExportedChatFolderLink?, ASDisplayNode, ContextGesture?) -> Void,
+        peerAction: @escaping (EnginePeer, Bool) -> Void,
+        toggleAllSelected: @escaping () -> Void
+    ) {
+        self.context = context
+        self.shareMainLink = shareMainLink
+        self.openMainLink = openMainLink
+        self.copyLink = copyLink
+        self.mainLinkContextAction = mainLinkContextAction
+        self.peerAction = peerAction
+        self.toggleAllSelected = toggleAllSelected
+    }
+}
+
+private enum InviteLinksListSection: Int32 {
+    case header
+    case mainLink
+    case peers
+}
+
+private enum InviteLinksListEntry: ItemListNodeEntry {
+    enum StableId: Hashable {
+        case index(Int)
+        case peer(EnginePeer.Id)
+    }
+    
+    case header(NSAttributedString)
+   
+    case mainLinkHeader(String)
+    case mainLink(link: ExportedChatFolderLink?, isGenerating: Bool)
+    
+    case peersHeader(String, String?)
+    case peer(index: Int, peer: EnginePeer, isSelected: Bool, disabledReasonText: String?)
+    case peersInfo(String)
+    
+    var section: ItemListSectionId {
+        switch self {
+        case .header:
+            return InviteLinksListSection.header.rawValue
+        case .mainLinkHeader, .mainLink:
+            return InviteLinksListSection.mainLink.rawValue
+        case .peersHeader, .peer, .peersInfo:
+            return InviteLinksListSection.peers.rawValue
+        }
+    }
+    
+    var stableId: StableId {
+        switch self {
+        case .header:
+            return .index(0)
+        case .mainLinkHeader:
+            return .index(1)
+        case .mainLink:
+            return .index(2)
+        case .peersHeader:
+            return .index(4)
+        case .peersInfo:
+            return .index(5)
+        case let .peer(_, peer, _, _):
+            return .peer(peer.id)
+        }
+    }
+    
+    var sortIndex: Int {
+        switch self {
+        case .header:
+            return 0
+        case .mainLinkHeader:
+            return 1
+        case .mainLink:
+            return 2
+        case .peersHeader:
+            return 4
+        case let .peer(index, _, _, _):
+            return 10 + index
+        case .peersInfo:
+            return 1000
+        }
+    }
+    
+    static func ==(lhs: InviteLinksListEntry, rhs: InviteLinksListEntry) -> Bool {
+        switch lhs {
+        case let .header(text):
+            if case .header(text) = rhs {
+                return true
+            } else {
+                return false
+            }
+        case let .mainLinkHeader(text):
+            if case .mainLinkHeader(text) = rhs {
+                return true
+            } else {
+                return false
+            }
+        case let .mainLink(lhsLink, lhsIsGenerating):
+            if case let .mainLink(rhsLink, rhsIsGenerating) = rhs, lhsLink == rhsLink, lhsIsGenerating == rhsIsGenerating {
+                return true
+            } else {
+                return false
+            }
+        case let .peersHeader(text, action):
+            if case .peersHeader(text, action) = rhs {
+                return true
+            } else {
+                return false
+            }
+        case let .peersInfo(text):
+            if case .peersInfo(text) = rhs {
+                return true
+            } else {
+                return false
+            }
+        case let .peer(index, peer, isSelected, disabledReasonText):
+            if case .peer(index, peer, isSelected, disabledReasonText) = rhs {
+                return true
+            } else {
+                return false
+            }
+        }
+    }
+    
+    static func <(lhs: InviteLinksListEntry, rhs: InviteLinksListEntry) -> Bool {
+        return lhs.sortIndex < rhs.sortIndex
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! FolderInviteLinkListControllerArguments
+        switch self {
+        case let .header(text):
+            return InviteLinkHeaderItem(context: arguments.context, theme: presentationData.theme, text: text, animationName: "ChatListCloudFolderLink", sectionId: self.section)
+        case let .mainLinkHeader(text):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+        case let .mainLink(link, isGenerating):
+            return ItemListFolderInviteLinkItem(context: arguments.context, presentationData: presentationData, systemStyle: .glass, invite: link, count: 0, peers: [], displayButton: true, enableButton: !isGenerating, buttonTitle: presentationData.strings.FolderLinkScreen_LinkActionCopy, secondaryButtonTitle: link != nil ? presentationData.strings.FolderLinkScreen_LinkActionShare : nil, displayImporters: false, buttonColor: nil, sectionId: self.section, style: .blocks, copyAction: {
+                if let link {
+                    arguments.copyLink(link.link)
+                }
+            }, shareAction: {
+                if let link {
+                    arguments.copyLink(link.link)
+                }
+            }, secondaryAction: {
+                if let link {
+                    arguments.shareMainLink(link.link)
+                }
+            }, contextAction: { node, gesture in
+                arguments.mainLinkContextAction(link, node, gesture)
+            }, viewAction: {
+                if let link {
+                    arguments.openMainLink(link.link)
+                }
+            })
+        case let .peersHeader(text, action):
+            return ItemListSectionHeaderItem(presentationData: presentationData, text: text, actionText: action, action: action == nil ? nil : {
+                arguments.toggleAllSelected()
+            }, sectionId: self.section)
+        case let .peersInfo(text):
+            return ItemListTextItem(presentationData: presentationData, text: .markdown(text), sectionId: self.section)
+        case let .peer(_, peer, isSelected, disabledReasonText):
+            return ItemListPeerItem(
+                presentationData: presentationData,
+                systemStyle: .glass,
+                dateTimeFormat: PresentationDateTimeFormat(),
+                nameDisplayOrder: presentationData.nameDisplayOrder,
+                context: arguments.context,
+                peer: peer,
+                presence: nil,
+                text: .text(disabledReasonText ?? presentationData.strings.FolderLinkScreen_LabelCanInvite, .secondary),
+                label: .none,
+                editing: ItemListPeerItemEditing(editable: false, editing: false, revealed: false),
+                switchValue: ItemListPeerItemSwitch(value: isSelected, style: .leftCheck, isEnabled: disabledReasonText == nil),
+                enabled: true,
+                selectable: true,
+                highlightable: false,
+                sectionId: self.section,
+                action: {
+                    arguments.peerAction(peer, disabledReasonText == nil)
+                },
+                setPeerIdWithRevealedOptions: { _, _ in
+                },
+                removePeer: { _ in
+                }
+            )
+        }
+    }
+}
+
+private func folderInviteLinkListControllerEntries(
+    presentationData: PresentationData,
+    state: FolderInviteLinkListControllerState,
+    title: ChatFolderTitle,
+    allPeers: [EnginePeer]
+) -> [InviteLinksListEntry] {
+    var entries: [InviteLinksListEntry] = []
+    
+    var infoString: String?
+    let chatCountString: NSAttributedString
+    let peersHeaderString: String
+    
+    let canShareChats = !allPeers.allSatisfy({ !canShareLinkToPeer(peer: $0) })
+    let allSelected = allPeers.filter({ canShareLinkToPeer(peer: $0) }).allSatisfy({ state.selectedPeerIds.contains($0.id) })
+    
+    var selectAllString: String?
+    
+    if !canShareChats {
+        infoString = presentationData.strings.FolderLinkScreen_TitleDescriptionUnavailable
+        chatCountString = NSAttributedString(string: presentationData.strings.FolderLinkScreen_ChatCountHeaderUnavailable)
+        peersHeaderString = presentationData.strings.FolderLinkScreen_ChatsSectionHeaderUnavailable
+    } else if state.selectedPeerIds.isEmpty {
+        let chatCountStringValue = NSMutableAttributedString(string: presentationData.strings.FolderLinkScreen_TitleDescriptionDeselectedV2)
+        let folderRange = (chatCountStringValue.string as NSString).range(of: "{folder}")
+        if folderRange.location != NSNotFound {
+            chatCountStringValue.replaceCharacters(in: folderRange, with: "")
+            chatCountStringValue.insert(title.rawAttributedString, at: folderRange.location)
+        }
+        
+        chatCountString = chatCountStringValue
+        peersHeaderString = presentationData.strings.FolderLinkScreen_ChatsSectionHeader
+        if allPeers.count > 1 {
+            selectAllString = allSelected ? presentationData.strings.FolderLinkScreen_ChatsSectionHeaderActionDeselectAll : presentationData.strings.FolderLinkScreen_ChatsSectionHeaderActionSelectAll
+        }
+    } else {
+        let chatCountStringValue = NSMutableAttributedString(string: presentationData.strings.FolderLinkScreen_TitleDescriptionSelectedV2)
+        let folderRange = (chatCountStringValue.string as NSString).range(of: "{folder}")
+        if folderRange.location != NSNotFound {
+            chatCountStringValue.replaceCharacters(in: folderRange, with: "")
+            chatCountStringValue.insert(title.rawAttributedString, at: folderRange.location)
+        }
+        let chatsRange = (chatCountStringValue.string as NSString).range(of: "{chats}")
+        if chatsRange.location != NSNotFound {
+            chatCountStringValue.replaceCharacters(in: chatsRange, with: "")
+            let countValue = presentationData.strings.FolderLinkScreen_TitleDescriptionSelectedCount(Int32(state.selectedPeerIds.count))
+            chatCountStringValue.insert(NSAttributedString(string: countValue), at: chatsRange.location)
+        }
+        
+        chatCountString = chatCountStringValue
+        peersHeaderString = presentationData.strings.FolderLinkScreen_ChatsSectionHeaderSelected(Int32(state.selectedPeerIds.count))
+        if allPeers.count > 1 {
+            selectAllString = allSelected ? presentationData.strings.FolderLinkScreen_ChatsSectionHeaderActionDeselectAll : presentationData.strings.FolderLinkScreen_ChatsSectionHeaderActionSelectAll
+        }
+    }
+    entries.append(.header(chatCountString))
+    
+    if canShareChats {
+        entries.append(.mainLinkHeader(presentationData.strings.FolderLinkScreen_LinkSectionHeader))
+        entries.append(.mainLink(link: state.currentLink, isGenerating: state.generatingLink))
+    }
+    
+    entries.append(.peersHeader(peersHeaderString, selectAllString))
+    
+    var sortedPeers: [EnginePeer] = []
+    for peer in allPeers.filter({ canShareLinkToPeer(peer: $0) }) {
+        sortedPeers.append(peer)
+    }
+    for peer in allPeers.filter({ !canShareLinkToPeer(peer: $0) }) {
+        sortedPeers.append(peer)
+    }
+    
+    for peer in sortedPeers {
+        var disabledReasonText: String?
+        if !canShareLinkToPeer(peer: peer) {
+            if case let .user(user) = peer {
+                if user.botInfo != nil {
+                    disabledReasonText = presentationData.strings.FolderLinkScreen_LabelUnavailableBot
+                } else {
+                    disabledReasonText = presentationData.strings.FolderLinkScreen_LabelUnavailableUser
+                }
+            } else {
+                disabledReasonText = presentationData.strings.FolderLinkScreen_LabelUnavailableGeneric
+            }
+        }
+        entries.append(.peer(index: entries.count, peer: peer, isSelected: state.selectedPeerIds.contains(peer.id), disabledReasonText: disabledReasonText))
+    }
+    
+    if let infoString {
+        entries.append(.peersInfo(infoString))
+    }
+    
+    return entries
+}
+
+private struct FolderInviteLinkListControllerState: Equatable {
+    var title: String?
+    var currentLink: ExportedChatFolderLink?
+    var selectedPeerIds = Set<EnginePeer.Id>()
+    var generatingLink: Bool = false
+    var isSaving: Bool = false
+}
+
+public func folderInviteLinkListController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, filterId: Int32, title filterTitle: ChatFolderTitle, allPeerIds: [EnginePeer.Id], currentInvitation: ExportedChatFolderLink?, linkUpdated: @escaping (ExportedChatFolderLink?) -> Void, presentController parentPresentController: ((ViewController) -> Void)?) -> ViewController {
+    var pushControllerImpl: ((ViewController) -> Void)?
+    let _ = pushControllerImpl
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    var presentInGlobalOverlayImpl: ((ViewController) -> Void)?
+    var dismissImpl: (() -> Void)?
+    var attemptNavigationImpl: ((@escaping () -> Void) -> Bool)?
+    var navigationController: (() -> NavigationController?)?
+    
+    var dismissTooltipsImpl: (() -> Void)?
+    
+    let actionsDisposable = DisposableSet()
+    
+    var initialState = FolderInviteLinkListControllerState()
+    initialState.title = currentInvitation?.title
+    initialState.currentLink = currentInvitation
+    let statePromise = ValuePromise(initialState, ignoreRepeated: true)
+    let stateValue = Atomic(value: initialState)
+    let updateState: ((FolderInviteLinkListControllerState) -> FolderInviteLinkListControllerState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    let _ = updateState
+    
+    let revokeLinkDisposable = MetaDisposable()
+    actionsDisposable.add(revokeLinkDisposable)
+    
+    let deleteAllRevokedLinksDisposable = MetaDisposable()
+    actionsDisposable.add(deleteAllRevokedLinksDisposable)
+        
+    var getControllerImpl: (() -> ViewController?)?
+    
+    var displayTooltipImpl: ((UndoOverlayContent, Bool) -> Void)?
+    
+    var didDisplayAddPeerNotice: Bool = false
+    
+    var combinedPeerIds: [EnginePeer.Id] = []
+    if let currentInvitation {
+        for peerId in currentInvitation.peerIds {
+            if !combinedPeerIds.contains(peerId) {
+                combinedPeerIds.append(peerId)
+            }
+        }
+    }
+    for peerId in allPeerIds {
+        if !combinedPeerIds.contains(peerId) {
+            combinedPeerIds.append(peerId)
+        }
+    }
+    
+    let arguments = FolderInviteLinkListControllerArguments(context: context, shareMainLink: { inviteLink in
+        let shareController = ShareController(context: context, subject: .url(inviteLink), updatedPresentationData: updatedPresentationData)
+        shareController.completed = { peerIds in
+            let _ = (context.engine.data.get(
+                EngineDataList(
+                    peerIds.map(TelegramEngine.EngineData.Item.Peer.Peer.init)
+                )
+            )
+            |> deliverOnMainQueue).start(next: { peerList in
+                let peers = peerList.compactMap { $0 }
+                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                
+                let text: String
+                var savedMessages = false
+                if peerIds.count == 1, let peerId = peerIds.first, peerId == context.account.peerId {
+                    text = presentationData.strings.InviteLink_InviteLinkForwardTooltip_SavedMessages_One
+                    savedMessages = true
+                } else {
+                    if peers.count == 1, let peer = peers.first {
+                        let peerName = peer.id == context.account.peerId ? presentationData.strings.DialogList_SavedMessages : peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
+                        text = presentationData.strings.InviteLink_InviteLinkForwardTooltip_Chat_One(peerName).string
+                    } else if peers.count == 2, let firstPeer = peers.first, let secondPeer = peers.last {
+                        let firstPeerName = firstPeer.id == context.account.peerId ? presentationData.strings.DialogList_SavedMessages : firstPeer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
+                        let secondPeerName = secondPeer.id == context.account.peerId ? presentationData.strings.DialogList_SavedMessages : secondPeer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
+                        text = presentationData.strings.InviteLink_InviteLinkForwardTooltip_TwoChats_One(firstPeerName, secondPeerName).string
+                    } else if let peer = peers.first {
+                        let peerName = peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
+                        text = presentationData.strings.InviteLink_InviteLinkForwardTooltip_ManyChats_One(peerName, "\(peers.count - 1)").string
+                    } else {
+                        text = ""
+                    }
+                }
+                
+                presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .forward(savedMessages: savedMessages, text: text), elevatedLayout: false, animateInAsReplacement: true, action: { action in
+                    if savedMessages, action == .info {
+                        let _ = (context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: context.account.peerId))
+                        |> deliverOnMainQueue).start(next: { peer in
+                            guard let peer else {
+                                return
+                            }
+                            guard let navigationController = navigationController?() else {
+                                return
+                            }
+                            context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), forceOpenChat: true))
+                        })
+                    }
+                    return false
+                }), nil)
+            })
+        }
+        shareController.actionCompleted = {
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .linkCopied(title: nil, text: presentationData.strings.InviteLink_InviteLinkCopiedText), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+        }
+        presentControllerImpl?(shareController, nil)
+    }, openMainLink: { _ in
+    }, copyLink: { link in
+        UIPasteboard.general.string = link
+        
+        dismissTooltipsImpl?()
+        
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .linkCopied(title: nil, text: presentationData.strings.InviteLink_InviteLinkCopiedText), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+    }, mainLinkContextAction: { invite, node, gesture in
+        guard let node = node as? ContextReferenceContentNode, let controller = getControllerImpl?(), let invite = invite else {
+            return
+        }
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        var items: [ContextMenuItem] = []
+        
+        items.append(.action(ContextMenuActionItem(text: presentationData.strings.FolderLinkScreen_ContextActionNameLink, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Pencil"), color: theme.contextMenu.primaryColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+            
+            let state = stateValue.with({ $0 })
+            
+            let promptController = promptController(sharedContext: context.sharedContext, updatedPresentationData: updatedPresentationData, text: presentationData.strings.FolderLinkScreen_NameLink_Title, titleFont: .bold, value: state.title ?? "", characterLimit: 32, apply: { value in
+                if let value {
+                    updateState { state in
+                        var state = state
+                        
+                        state.title = value
+                        
+                        return state
+                    }
+                }
+            })
+            presentControllerImpl?(promptController, nil)
+        })))
+
+        items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextCopy, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+            
+            dismissTooltipsImpl?()
+            
+            UIPasteboard.general.string = invite.link
+            
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .linkCopied(title: nil, text: presentationData.strings.InviteLink_InviteLinkCopiedText), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+        })))
+        
+        items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextGetQRCode, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Settings/QrIcon"), color: theme.contextMenu.primaryColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+            
+            presentControllerImpl?(QrCodeScreen(context: context, updatedPresentationData: updatedPresentationData, subject: .chatFolder(slug: invite.slug)), nil)
+        })))
+        
+        items.append(.action(ContextMenuActionItem(text: presentationData.strings.InviteLink_ContextRevoke, textColor: .destructive, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.contextMenu.destructiveColor)
+        }, action: { _, f in
+            f(.dismissWithoutContent)
+            
+            let _ = (context.engine.peers.editChatFolderLink(filterId: filterId, link: invite, title: nil, peerIds: nil, revoke: true)
+            |> deliverOnMainQueue).start(completed: {
+                let _ = (context.engine.peers.deleteChatFolderLink(filterId: filterId, link: invite)
+                |> deliverOnMainQueue).start(completed: {
+                    linkUpdated(nil)
+                    dismissImpl?()
+                })
+            })
+        })))
+
+        let contextController = ContextController(presentationData: presentationData, source: .reference(InviteLinkContextReferenceContentSource(controller: controller, sourceNode: node)), items: .single(ContextController.Items(content: .list(items))), gesture: gesture)
+        presentInGlobalOverlayImpl?(contextController)
+    }, peerAction: { peer, isEnabled in
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        
+        if isEnabled {
+            var added = false
+            updateState { state in
+                var state = state
+                
+                if state.selectedPeerIds.contains(peer.id) {
+                    state.selectedPeerIds.remove(peer.id)
+                } else {
+                    state.selectedPeerIds.insert(peer.id)
+                    
+                    if let currentInvitation, !currentInvitation.peerIds.contains(peer.id) {
+                        added = true
+                    }
+                }
+                
+                return state
+            }
+            
+            if added && !didDisplayAddPeerNotice {
+                didDisplayAddPeerNotice = true
+                
+                dismissTooltipsImpl?()
+                displayTooltipImpl?(.info(title: nil, text: presentationData.strings.FolderLinkScreen_ToastNewChatAdded, timeout: 8, customUndoText: nil), true)
+            }
+        } else {
+            let text: String
+            if case let .user(user) = peer {
+                if user.botInfo != nil {
+                    text = presentationData.strings.FolderLinkScreen_AlertTextUnavailableBot
+                } else {
+                    text = presentationData.strings.FolderLinkScreen_AlertTextUnavailableUser
+                }
+            } else {
+                var isGroup = true
+                let isPrivate = peer.addressName == nil
+                if case let .channel(channel) = peer, case .broadcast = channel.info {
+                    isGroup = false
+                }
+                if isGroup {
+                    if isPrivate {
+                        text = presentationData.strings.FolderLinkScreen_AlertTextUnavailablePrivateGroup
+                    } else {
+                        text = presentationData.strings.FolderLinkScreen_AlertTextUnavailablePublicGroup
+                    }
+                } else {
+                    if isPrivate {
+                        text = presentationData.strings.FolderLinkScreen_AlertTextUnavailablePrivateChannel
+                    } else {
+                        text = presentationData.strings.FolderLinkScreen_AlertTextUnavailablePublicChannel
+                    }
+                }
+            }
+            dismissTooltipsImpl?()
+            displayTooltipImpl?(.peers(context: context, peers: [peer], title: nil, text: text, customUndoText: nil), true)
+        }
+    }, toggleAllSelected: {
+        let _ = (context.engine.data.get(
+            EngineDataList(combinedPeerIds.map(TelegramEngine.EngineData.Item.Peer.Peer.init(id:)))
+        )
+        |> deliverOnMainQueue).start(next: { allPeers in
+            let allPeers = allPeers.compactMap({ $0 })
+            
+            let selectablePeers = allPeers.filter({ canShareLinkToPeer(peer: $0) })
+            let state = stateValue.with({ $0 })
+            let allSelected = selectablePeers.allSatisfy({ state.selectedPeerIds.contains($0.id) })
+            
+            updateState { state in
+                var state = state
+                
+                if allSelected {
+                    state.selectedPeerIds.removeAll()
+                } else {
+                    state.selectedPeerIds.removeAll()
+                    for peer in selectablePeers {
+                        state.selectedPeerIds.insert(peer.id)
+                    }
+                }
+                
+                return state
+            }
+        })
+    })
+    
+    let allPeers = context.engine.data.subscribe(
+        EngineDataList(combinedPeerIds.map(TelegramEngine.EngineData.Item.Peer.Peer.init(id:)))
+    )
+    |> map { peers -> [EnginePeer] in
+        return peers.compactMap({ peer -> EnginePeer? in
+            guard let peer else {
+                return nil
+            }
+            if case let .legacyGroup(group) = peer, group.migrationReference != nil {
+                return nil
+            }
+            return peer
+        })
+    }
+    
+    let applyChangesImpl: (() -> Void)? = {
+        let state = stateValue.with({ $0 })
+        
+        if state.selectedPeerIds.isEmpty {
+            return
+        }
+        
+        if let currentLink = state.currentLink {
+            if currentLink.title != state.title || Set(currentLink.peerIds) != state.selectedPeerIds {
+                updateState { state in
+                    var state = state
+                    state.isSaving = true
+                    return state
+                }
+                actionsDisposable.add((context.engine.peers.editChatFolderLink(filterId: filterId, link: currentLink, title: state.title, peerIds: Array(state.selectedPeerIds), revoke: false)
+                |> deliverOnMainQueue).start(error: { _ in
+                    updateState { state in
+                        var state = state
+                        state.isSaving = false
+                        return state
+                    }
+                    
+                    dismissTooltipsImpl?()
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .info(title: nil, text: presentationData.strings.FolderLinkScreen_SaveUnknownError, timeout: nil, customUndoText: nil), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+                }, completed: {
+                    let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                    linkUpdated(ExportedChatFolderLink(title: state.title ?? "", link: currentLink.link, peerIds: Array(state.selectedPeerIds), isRevoked: false))
+                    displayTooltipImpl?(.info(title: nil, text: presentationData.strings.FolderLinkScreen_ToastLinkUpdated, timeout: 3, customUndoText: nil), false)
+                    
+                    dismissImpl?()
+                }))
+            } else {
+                dismissImpl?()
+            }
+        } else {
+            dismissImpl?()
+        }
+    }
+    
+    let _ = (allPeers
+    |> take(1)
+    |> deliverOnMainQueue).start(next: { peers in
+        updateState { state in
+            var state = state
+            
+            if let currentInvitation {
+                for peerId in currentInvitation.peerIds {
+                    state.selectedPeerIds.insert(peerId)
+                }
+            } else {
+                for peerId in peers.map(\.id) {
+                    if let peer = peers.first(where: { $0.id == peerId }) {
+                        if canShareLinkToPeer(peer: peer) {
+                            state.selectedPeerIds.insert(peerId)
+                        }
+                    }
+                }
+            }
+            
+            return state
+        }
+    })
+    
+    let previousState = Atomic<FolderInviteLinkListControllerState?>(value: nil)
+    
+    let presentationData = updatedPresentationData?.signal ?? context.sharedContext.presentationData
+    let signal = combineLatest(queue: .mainQueue(),
+        presentationData,
+        statePromise.get(),
+        allPeers
+    )
+    |> map { presentationData, state, allPeers -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let allPeers = allPeers.compactMap { $0 }
+        
+        let crossfade = false
+        
+        var animateChanges = false
+        
+        let previousStateValue = previousState.swap(state)
+        if let previousStateValue, previousStateValue.selectedPeerIds != state.selectedPeerIds {
+            animateChanges = true
+        }
+        
+        let title: ItemListControllerTitle
+        
+        var folderTitle = presentationData.strings.FolderLinkScreen_Title
+        if let title = state.title, !title.isEmpty {
+            folderTitle = title
+        }
+        title = .text(folderTitle)
+        
+        var doneButton: ItemListNavigationButton?
+        
+        let canShareChats = !allPeers.allSatisfy({ !canShareLinkToPeer(peer: $0) })
+        
+        if !canShareChats {
+            doneButton = nil
+        } else if state.isSaving {
+            doneButton = ItemListNavigationButton(content: .none, style: .activity, enabled: true, action: {})
+        } else {
+            var saveEnabled = false
+            if let currentLink = state.currentLink {
+                if currentLink.title != state.title || Set(currentLink.peerIds) != state.selectedPeerIds {
+                    saveEnabled = true
+                }
+            } else {
+                saveEnabled = true
+            }
+            
+            doneButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Save), style: .bold, enabled: !state.selectedPeerIds.isEmpty && saveEnabled, action: {
+                applyChangesImpl?()
+            })
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: title, leftNavigationButton: nil, rightNavigationButton: doneButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: folderInviteLinkListControllerEntries(
+            presentationData: presentationData,
+            state: state,
+            title: filterTitle,
+            allPeers: allPeers
+        ), style: .blocks, emptyStateItem: nil, crossfadeState: crossfade, animateChanges: animateChanges)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.navigationPresentation = .modal
+    controller.willDisappear = { _ in
+        dismissTooltipsImpl?()
+    }
+    controller.didDisappear = { [weak controller] _ in
+        controller?.clearItemNodesHighlight(animated: true)
+    }
+    controller.visibleBottomContentOffsetChanged = { offset in
+        if case let .known(value) = offset, value < 40.0 {
+            
+        }
+    }
+    controller.attemptNavigation = { f in
+        return attemptNavigationImpl?(f) ?? true
+    }
+    attemptNavigationImpl = { f in
+        if let currentInvitation {
+            let state = stateValue.with({ $0 })
+            
+            var hasChanges = false
+            if state.title != currentInvitation.title {
+                hasChanges = true
+            }
+            if state.selectedPeerIds != Set(currentInvitation.peerIds) {
+                hasChanges = true
+            }
+            
+            if hasChanges {
+                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                presentControllerImpl?(standardTextAlertController(theme: AlertControllerTheme(presentationData: presentationData), title: presentationData.strings.FolderLinkScreen_SaveAlertTitle, text: presentationData.strings.FolderLinkScreen_SaveAlertText, actions: [
+                    TextAlertAction(type: .genericAction, title: presentationData.strings.FolderLinkScreen_SaveAlertActionDiscard, action: {
+                        f()
+                        dismissImpl?()
+                    }),
+                    TextAlertAction(type: .defaultAction, title: state.selectedPeerIds.isEmpty ? presentationData.strings.FolderLinkScreen_SaveAlertActionApply : presentationData.strings.FolderLinkScreen_SaveAlertActionContinue, action: {
+                        applyChangesImpl?()
+                    })
+                ]), nil)
+                return false
+            } else {
+                f()
+                return true
+            }
+        } else {
+            f()
+            return true
+        }
+    }
+    navigationController = { [weak controller] in
+        return controller?.navigationController as? NavigationController
+    }
+    pushControllerImpl = { [weak controller] c in
+        if let controller = controller {
+            (controller.navigationController as? NavigationController)?.pushViewController(c, animated: true)
+        }
+    }
+    presentControllerImpl = { [weak controller] c, p in
+        if let controller = controller {
+            controller.present(c, in: .window(.root), with: p)
+        }
+    }
+    presentInGlobalOverlayImpl = { [weak controller] c in
+        if let controller = controller {
+            controller.presentInGlobalOverlay(c)
+        }
+    }
+    dismissImpl = { [weak controller] in
+        controller?.dismiss()
+    }
+    getControllerImpl = { [weak controller] in
+        return controller
+    }
+    displayTooltipImpl = { [weak controller] c, inCurrentContext in
+        let presentationData = context.sharedContext.currentPresentationData.with({ $0 })
+        if let controller = controller, inCurrentContext {
+            controller.present(UndoOverlayController(presentationData: presentationData, content: c, elevatedLayout: false, action: { _ in return false }), in: .current)
+        } else if !inCurrentContext {
+            parentPresentController?(UndoOverlayController(presentationData: presentationData, content: c, elevatedLayout: false, action: { _ in return false }))
+        }
+    }
+    dismissTooltipsImpl = { [weak controller] in
+        controller?.forEachController({ controller in
+            if let controller = controller as? UndoOverlayController {
+                controller.dismissWithCommitAction()
+            }
+            return true
+        })
+    }
+    return controller
+}

submodules/InviteLinksUI/Sources/InviteLinkEditController.swift

@@ -0,0 +1,856 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import OverlayStatusController
+import AccountContext
+import AlertUI
+import PresentationDataUtils
+import AppBundle
+import ContextUI
+import TelegramStringFormatting
+import UndoUI
+import ItemListDatePickerItem
+import TextFormat
+
+private final class InviteLinkEditControllerArguments {
+    let context: AccountContext
+    let updateState: ((InviteLinkEditControllerState) -> InviteLinkEditControllerState) -> Void
+    let focusOnItem: (InviteLinksEditEntryTag) -> Void
+    let errorWithItem: (InviteLinksEditEntryTag) -> Void
+    let scrollToUsage: () -> Void
+    let dismissInput: () -> Void
+    let revoke: () -> Void
+    
+    init(
+        context: AccountContext, 
+        updateState: @escaping ((InviteLinkEditControllerState) -> InviteLinkEditControllerState) -> Void,
+        focusOnItem: @escaping (InviteLinksEditEntryTag) -> Void,
+        errorWithItem: @escaping (InviteLinksEditEntryTag) -> Void,
+        scrollToUsage: @escaping () -> Void,
+        dismissInput: @escaping () -> Void,
+        revoke: @escaping () -> Void)
+    {
+        self.context = context
+        self.updateState = updateState
+        self.focusOnItem = focusOnItem
+        self.errorWithItem = errorWithItem
+        self.scrollToUsage = scrollToUsage
+        self.dismissInput = dismissInput
+        self.revoke = revoke
+    }
+}
+
+private enum InviteLinksEditSection: Int32 {
+    case title
+    case subscriptionFee
+    case requestApproval
+    case time
+    case usage
+    case revoke
+}
+
+private enum InviteLinksEditEntryTag: ItemListItemTag {
+    case subscriptionFee
+    case usage
+
+    func isEqual(to other: ItemListItemTag) -> Bool {
+        if let other = other as? InviteLinksEditEntryTag, self == other {
+            return true
+        } else {
+            return false
+        }
+    }
+}
+
+private let invalidAmountCharacters = CharacterSet(charactersIn: "01234567890.,").inverted
+func isValidNumberOfUsers(_ number: String) -> Bool {
+    if number.isEmpty {
+        return true
+    }
+    let number = normalizeArabicNumeralString(number, type: .western)
+    if number.rangeOfCharacter(from: invalidAmountCharacters) != nil || number == "0" {
+        return false
+    }
+    if let value = Int32(number), value > 0 && value < 100000 {
+        return true
+    } else {
+        return false
+    }
+}
+
+private enum InviteLinksEditEntry: ItemListNodeEntry {
+    case titleHeader(PresentationTheme, String)
+    case title(PresentationTheme, String, String)
+    case titleInfo(PresentationTheme, String)
+    
+    
+    case subscriptionFeeToggle(PresentationTheme, String, Bool, Bool)
+    case subscriptionFee(PresentationTheme, String, Bool, StarsAmount?, String, StarsAmount?)
+    case subscriptionFeeInfo(PresentationTheme, String)
+    
+    case requestApproval(PresentationTheme, String, Bool, Bool)
+    case requestApprovalInfo(PresentationTheme, String)
+    
+    case timeHeader(PresentationTheme, String)
+    case timePicker(PresentationTheme, InviteLinkTimeLimit, Bool)
+    case timeExpiryDate(PresentationTheme, PresentationDateTimeFormat, Int32?, Bool, Bool)
+    case timeCustomPicker(PresentationTheme, PresentationDateTimeFormat, Int32?, Bool, Bool, Bool)
+    case timeInfo(PresentationTheme, String)
+    
+    case usageHeader(PresentationTheme, String)
+    case usagePicker(PresentationTheme, PresentationDateTimeFormat, InviteLinkUsageLimit, Bool)
+    case usageCustomPicker(PresentationTheme, Int32?, Bool, Bool, Bool)
+    case usageInfo(PresentationTheme, String)
+    
+    case revoke(PresentationTheme, String)
+   
+    var section: ItemListSectionId {
+        switch self {
+            case .titleHeader, .title, .titleInfo:
+                return InviteLinksEditSection.title.rawValue
+            case .subscriptionFeeToggle, .subscriptionFee, .subscriptionFeeInfo:
+                return InviteLinksEditSection.subscriptionFee.rawValue
+            case .requestApproval, .requestApprovalInfo:
+                return InviteLinksEditSection.requestApproval.rawValue
+            case .timeHeader, .timePicker, .timeExpiryDate, .timeCustomPicker, .timeInfo:
+                return InviteLinksEditSection.time.rawValue
+            case .usageHeader, .usagePicker, .usageCustomPicker, .usageInfo:
+                return InviteLinksEditSection.usage.rawValue
+            case .revoke:
+                return InviteLinksEditSection.revoke.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .titleHeader:
+                return 0
+            case .title:
+                return 1
+            case .titleInfo:
+                return 2
+            case .subscriptionFeeToggle:
+                return 3
+            case .subscriptionFee:
+                return 4
+            case .subscriptionFeeInfo:
+                return 5
+            case .requestApproval:
+                return 6
+            case .requestApprovalInfo:
+                return 7
+            case .timeHeader:
+                return 8
+            case .timePicker:
+                return 9
+            case .timeExpiryDate:
+                return 10
+            case .timeCustomPicker:
+                return 11
+            case .timeInfo:
+                return 12
+            case .usageHeader:
+                return 13
+            case .usagePicker:
+                return 14
+            case .usageCustomPicker:
+                return 15
+            case .usageInfo:
+                return 16
+            case .revoke:
+                return 17
+        }
+    }
+    
+    static func ==(lhs: InviteLinksEditEntry, rhs: InviteLinksEditEntry) -> Bool {
+        switch lhs {
+            case let .titleHeader(lhsTheme, lhsText):
+                if case let .titleHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .title(lhsTheme, lhsPlaceholder, lhsValue):
+                if case let .title(rhsTheme, rhsPlaceholder, rhsValue) = rhs, lhsTheme === rhsTheme, lhsPlaceholder == rhsPlaceholder, lhsValue == rhsValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .titleInfo(lhsTheme, lhsText):
+                if case let .titleInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .subscriptionFeeToggle(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .subscriptionFeeToggle(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .subscriptionFee(lhsTheme, lhsText, lhsValue, lhsEnabled, lhsLabel, lhsMaxValue):
+                if case let .subscriptionFee(rhsTheme, rhsText, rhsValue, rhsEnabled, rhsLabel, rhsMaxValue) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled, lhsLabel == rhsLabel, lhsMaxValue == rhsMaxValue {
+                    return true
+                } else {
+                    return false
+                }
+            case let .subscriptionFeeInfo(lhsTheme, lhsText):
+                if case let .subscriptionFeeInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .requestApproval(lhsTheme, lhsText, lhsValue, lhsEnabled):
+                if case let .requestApproval(rhsTheme, rhsText, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsText == rhsText, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .requestApprovalInfo(lhsTheme, lhsText):
+                if case let .requestApprovalInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timeHeader(lhsTheme, lhsText):
+                if case let .timeHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timePicker(lhsTheme, lhsValue, lhsEnabled):
+                if case let .timePicker(rhsTheme, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timeExpiryDate(lhsTheme, lhsDateTimeFormat, lhsDate, lhsActive, lhsEnabled):
+                if case let .timeExpiryDate(rhsTheme, rhsDateTimeFormat, rhsDate, rhsActive, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsDateTimeFormat == rhsDateTimeFormat, lhsDate == rhsDate, lhsActive == rhsActive, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timeCustomPicker(lhsTheme, lhsDateTimeFormat, lhsDate, lhsDisplayingDateSelection, lhsDisplayingTimeSelection, lhsEnabled):
+                if case let .timeCustomPicker(rhsTheme, rhsDateTimeFormat, rhsDate, rhsDisplayingDateSelection, rhsDisplayingTimeSelection, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsDateTimeFormat == rhsDateTimeFormat, lhsDate == rhsDate, lhsDisplayingDateSelection == rhsDisplayingDateSelection, lhsDisplayingTimeSelection == rhsDisplayingTimeSelection, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .timeInfo(lhsTheme, lhsText):
+                if case let .timeInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .usageHeader(lhsTheme, lhsText):
+                if case let .usageHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .usagePicker(lhsTheme, lhsDateTimeFormat, lhsValue, lhsEnabled):
+                if case let .usagePicker(rhsTheme, rhsDateTimeFormat, rhsValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsDateTimeFormat == rhsDateTimeFormat, lhsValue == rhsValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .usageCustomPicker(lhsTheme, lhsValue, lhsFocused, lhsCustomValue, lhsEnabled):
+                if case let .usageCustomPicker(rhsTheme, rhsValue, rhsFocused, rhsCustomValue, rhsEnabled) = rhs, lhsTheme === rhsTheme, lhsValue == rhsValue, lhsFocused == rhsFocused, lhsCustomValue == rhsCustomValue, lhsEnabled == rhsEnabled {
+                    return true
+                } else {
+                    return false
+                }
+            case let .usageInfo(lhsTheme, lhsText):
+                if case let .usageInfo(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .revoke(lhsTheme, lhsText):
+                if case let .revoke(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: InviteLinksEditEntry, rhs: InviteLinksEditEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! InviteLinkEditControllerArguments
+        switch self {
+            case let .titleHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .title(_, placeholder, value):
+                return ItemListSingleLineInputItem(context: arguments.context, presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(), text: value, placeholder: placeholder, maxLength: 32, sectionId: self.section, textUpdated: { value in
+                    arguments.updateState { state in
+                        var updatedState = state
+                        updatedState.title = value
+                        return updatedState
+                    }
+                }, action: {})
+            case let .titleInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .subscriptionFeeToggle(_, text, value, enabled):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enabled: enabled, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.updateState { state in
+                        var updatedState = state
+                        updatedState.subscriptionEnabled = value
+                        if value {
+                            updatedState.requestApproval = false
+                        } else {
+                            updatedState.subscriptionFee = nil
+                        }
+                        return updatedState
+                    }
+                    if value {
+                        Queue.mainQueue().after(0.1) {
+                            arguments.focusOnItem(.subscriptionFee)
+                        }
+                    }
+                })
+            case let .subscriptionFee(_, placeholder, enabled, value, label, maxValue):
+                let title = NSMutableAttributedString(string: "⭐️", font: Font.semibold(18.0), textColor: .white)
+                if let range = title.string.range(of: "⭐️") {
+                    title.addAttribute(ChatTextInputAttributes.customEmoji, value: ChatTextInputTextCustomEmojiAttribute(interactivelySelectedFromPackId: nil, fileId: 0, file: nil, custom: .stars(tinted: false)), range: NSRange(range, in: title.string))
+                    title.addAttribute(.baselineOffset, value: -1.0, range: NSRange(range, in: title.string))
+                }
+                return ItemListSingleLineInputItem(context: arguments.context, presentationData: presentationData, systemStyle: .glass, title: title, text: value.flatMap { "\($0)" } ?? "", placeholder: placeholder, label: label, type: .number, spacing: 3.0, enabled: enabled, tag: InviteLinksEditEntryTag.subscriptionFee, sectionId: self.section, textUpdated: { text in
+                    arguments.updateState { state in
+                        var updatedState = state
+                        if var value = Int64(text).flatMap({ StarsAmount(value: $0, nanos: 0) }) {
+                            if let maxValue, value > maxValue {
+                                value = maxValue
+                                arguments.errorWithItem(.subscriptionFee)
+                            }
+                            updatedState.subscriptionFee = value
+                        } else {
+                            updatedState.subscriptionFee = nil
+                        }
+                        return updatedState
+                    }
+                },  action: {})
+            case let .subscriptionFeeInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .markdown(text), sectionId: self.section)
+            case let .requestApproval(_, text, value, enabled):
+                return ItemListSwitchItem(presentationData: presentationData, systemStyle: .glass, title: text, value: value, enabled: enabled, sectionId: self.section, style: .blocks, updated: { value in
+                    arguments.updateState { state in
+                        var updatedState = state
+                        updatedState.requestApproval = value
+                        return updatedState
+                    }
+                })
+            case let .requestApprovalInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .timeHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .timePicker(_, value, enabled):
+                return ItemListInviteLinkTimeLimitItem(theme: presentationData.theme, strings: presentationData.strings, value: value, enabled: enabled, sectionId: self.section, updated: { value in
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        if value != updatedState.time {
+                            updatedState.pickingExpiryDate = false
+                            updatedState.pickingExpiryTime = false
+                        }
+                        updatedState.time = value
+                        return updatedState
+                    })
+                })
+            case let .timeExpiryDate(theme, dateTimeFormat, value, active, enabled):
+                let text: String
+                if let value = value {
+                    text = stringForMediumDate(timestamp: value, strings: presentationData.strings, dateTimeFormat: dateTimeFormat)
+                } else {
+                    text = presentationData.strings.InviteLink_Create_TimeLimitExpiryDateNever
+                }
+                return ItemListDisclosureItem(presentationData: presentationData, systemStyle: .glass, title: presentationData.strings.InviteLink_Create_TimeLimitExpiryDate, enabled: enabled, label: text, labelStyle: active ? .coloredText(theme.list.itemAccentColor) : .text, sectionId: self.section, style: .blocks, disclosureStyle: .none, action: {
+                    arguments.dismissInput()
+                    arguments.updateState { state in
+                        var updatedState = state
+                        if updatedState.pickingExpiryTime {
+                            updatedState.pickingExpiryTime = false
+                        } else {
+                            updatedState.pickingExpiryDate = !state.pickingExpiryDate
+                        }
+                        return updatedState
+                    }
+                })
+            case let .timeCustomPicker(_, dateTimeFormat, date, displayingDateSelection, displayingTimeSelection, enabled):
+                let _ = enabled
+                let title = presentationData.strings.InviteLink_Create_TimeLimitExpiryTime
+                return ItemListDatePickerItem(presentationData: presentationData, dateTimeFormat: dateTimeFormat, date: date, title: title, displayingDateSelection: displayingDateSelection, displayingTimeSelection: displayingTimeSelection, sectionId: self.section, style: .blocks, toggleDateSelection: {
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        updatedState.pickingExpiryDate = !updatedState.pickingExpiryDate
+                        if updatedState.pickingExpiryDate {
+                            updatedState.pickingExpiryTime = false
+                        }
+                        return updatedState
+                    })
+                }, toggleTimeSelection: {
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        updatedState.pickingExpiryTime = !updatedState.pickingExpiryTime
+                        if updatedState.pickingExpiryTime {
+                            updatedState.pickingExpiryDate = false
+                        }
+                        return updatedState
+                    })
+                }, updated: { date in
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        updatedState.time = .custom(date)
+                        return updatedState
+                    })
+                })
+            case let .timeInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .usageHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .usagePicker(_, dateTimeFormat, value, enabled):
+                return ItemListInviteLinkUsageLimitItem(theme: presentationData.theme, strings: presentationData.strings, dateTimeFormat: dateTimeFormat, value: value, enabled: enabled, sectionId: self.section, updated: { value in
+                    arguments.dismissInput()
+                    arguments.updateState({ state in
+                        var updatedState = state
+                        if value != updatedState.usage {
+                            updatedState.pickingExpiryDate = false
+                            updatedState.pickingExpiryTime = false
+                        }
+                        updatedState.usage = value
+                        return updatedState
+                    })
+                })
+            case let .usageCustomPicker(theme, value, focused, customValue, enabled):
+                let text: String
+                if let value = value, value != 0 {
+                    text = String(value)
+                } else {
+                    text = focused ? "" : presentationData.strings.InviteLink_Create_UsersLimitNumberOfUsersUnlimited
+                }
+                return ItemListSingleLineInputItem(context: arguments.context, presentationData: presentationData, systemStyle: .glass, title: NSAttributedString(string: presentationData.strings.InviteLink_Create_UsersLimitNumberOfUsers, textColor: theme.list.itemPrimaryTextColor), text: text, placeholder: "", type: .number, alignment: .right, enabled: enabled, selectAllOnFocus: true, secondaryStyle: !customValue, tag: InviteLinksEditEntryTag.usage, sectionId: self.section, textUpdated: { updatedText in
+                    arguments.updateState { state in
+                        var updatedState = state
+                        if updatedText.isEmpty {
+                            updatedState.usage = .unlimited
+                        } else if let value = Int32(updatedText) {
+                            updatedState.usage = InviteLinkUsageLimit(value: value)
+                        }
+                        return updatedState
+                    }
+                }, shouldUpdateText: { text in
+                    return isValidNumberOfUsers(text)
+                }, updatedFocus: { focus in
+                    if focus {
+                        arguments.updateState { state in
+                            var updatedState = state
+                            updatedState.pickingExpiryDate = false
+                            updatedState.pickingExpiryTime = false
+                            updatedState.pickingUsageLimit = true
+                            return updatedState
+                        }
+                        arguments.scrollToUsage()
+                    } else {
+                        arguments.updateState { state in
+                            var updatedState = state
+                            updatedState.pickingUsageLimit = false
+                            return updatedState
+                        }
+                    }
+                }, action: {
+                    
+                })
+            case let .usageInfo(_, text):
+                return ItemListTextItem(presentationData: presentationData, text: .plain(text), sectionId: self.section)
+            case let .revoke(_, text):
+                return ItemListActionItem(presentationData: presentationData, systemStyle: .glass, title: text, kind: .destructive, alignment: .center, sectionId: self.section, style: .blocks, action: {
+                    arguments.revoke()
+                }, tag: nil)
+        }
+    }
+}
+
+private func inviteLinkEditControllerEntries(invite: ExportedInvitation?, state: InviteLinkEditControllerState, isGroup: Bool, isPublic: Bool, presentationData: PresentationData, configuration: StarsSubscriptionConfiguration) -> [InviteLinksEditEntry] {
+    var entries: [InviteLinksEditEntry] = []
+    
+    entries.append(.titleHeader(presentationData.theme, presentationData.strings.InviteLink_Create_LinkNameTitle.uppercased()))
+    entries.append(.title(presentationData.theme, presentationData.strings.InviteLink_Create_LinkName, state.title))
+    entries.append(.titleInfo(presentationData.theme, presentationData.strings.InviteLink_Create_LinkNameInfo))
+    
+    let isEditingEnabled = invite?.pricing == nil
+    let isSubscription = state.subscriptionEnabled
+    if !isGroup {
+        entries.append(.subscriptionFeeToggle(presentationData.theme, presentationData.strings.InviteLink_Create_Fee, state.subscriptionEnabled, isEditingEnabled))
+        if state.subscriptionEnabled {
+            var label: String = ""
+            if let subscriptionFee = state.subscriptionFee, subscriptionFee > StarsAmount.zero {
+                let usdRate = Double(configuration.usdWithdrawRate) / 1000.0 / 100.0
+                label = presentationData.strings.InviteLink_Create_FeePerMonth("~\(formatTonUsdValue(subscriptionFee.value, divide: false, rate: usdRate, dateTimeFormat: presentationData.dateTimeFormat))").string
+            }
+            entries.append(.subscriptionFee(presentationData.theme, presentationData.strings.InviteLink_Create_FeePlaceholder, isEditingEnabled, state.subscriptionFee, label, StarsAmount(value: configuration.maxFee, nanos: 0)))
+        }
+        let infoText: String
+        if let _ = invite, state.subscriptionEnabled {
+            infoText = presentationData.strings.InviteLink_Create_FeeEditInfo
+        } else {
+            infoText = presentationData.strings.InviteLink_Create_FeeInfo
+        }
+        entries.append(.subscriptionFeeInfo(presentationData.theme, infoText))
+    }
+    
+    if !isPublic {
+        entries.append(.requestApproval(presentationData.theme, presentationData.strings.InviteLink_Create_RequestApproval, state.requestApproval, isEditingEnabled && !isSubscription))
+        var requestApprovalInfoText = presentationData.strings.InviteLink_Create_RequestApprovalOffInfoChannel
+        if isSubscription {
+            requestApprovalInfoText = presentationData.strings.InviteLink_Create_RequestApprovalFeeUnavailable
+        } else {
+            if state.requestApproval {
+                requestApprovalInfoText = isGroup ? presentationData.strings.InviteLink_Create_RequestApprovalOnInfoGroup : presentationData.strings.InviteLink_Create_RequestApprovalOnInfoChannel
+            } else {
+                requestApprovalInfoText = isGroup ? presentationData.strings.InviteLink_Create_RequestApprovalOnInfoGroup : presentationData.strings.InviteLink_Create_RequestApprovalOffInfoChannel
+            }
+        }
+        entries.append(.requestApprovalInfo(presentationData.theme, requestApprovalInfoText))
+    }
+    
+    entries.append(.timeHeader(presentationData.theme,  presentationData.strings.InviteLink_Create_TimeLimit.uppercased()))
+    entries.append(.timePicker(presentationData.theme, state.time, isEditingEnabled))
+    
+    let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+    var time: Int32?
+    if case let .custom(value) = state.time {
+        time = value
+    } else if let value = state.time.value {
+        time = currentTime + value
+    }
+    entries.append(.timeExpiryDate(presentationData.theme, presentationData.dateTimeFormat, time, state.pickingExpiryDate || state.pickingExpiryTime, isEditingEnabled))
+    if state.pickingExpiryDate || state.pickingExpiryTime {
+        entries.append(.timeCustomPicker(presentationData.theme, presentationData.dateTimeFormat, time, state.pickingExpiryDate, state.pickingExpiryTime, isEditingEnabled))
+    }
+    entries.append(.timeInfo(presentationData.theme, presentationData.strings.InviteLink_Create_TimeLimitInfo))
+    
+    if !state.requestApproval || isPublic {
+        entries.append(.usageHeader(presentationData.theme,  presentationData.strings.InviteLink_Create_UsersLimit.uppercased()))
+        entries.append(.usagePicker(presentationData.theme, presentationData.dateTimeFormat, state.usage, isEditingEnabled))
+        
+        var customValue = false
+        if case .custom = state.usage {
+            customValue = true
+        }
+        entries.append(.usageCustomPicker(presentationData.theme, state.usage.value, state.pickingUsageLimit, customValue, isEditingEnabled))
+        entries.append(.usageInfo(presentationData.theme, presentationData.strings.InviteLink_Create_UsersLimitInfo))
+    }
+    
+    if let _ = invite {
+        entries.append(.revoke(presentationData.theme, presentationData.strings.InviteLink_Create_Revoke))
+    }
+    
+    return entries
+}
+
+private struct InviteLinkEditControllerState: Equatable {
+    var title: String
+    var usage: InviteLinkUsageLimit
+    var time: InviteLinkTimeLimit
+    var requestApproval = false
+    var subscriptionEnabled = false
+    var subscriptionFee: StarsAmount?
+    var pickingExpiryDate = false
+    var pickingExpiryTime = false
+    var pickingUsageLimit = false
+    var updating = false
+}
+
+public func inviteLinkEditController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, peerId: EnginePeer.Id, invite: ExportedInvitation?, completion: ((ExportedInvitation?) -> Void)? = nil) -> ViewController {
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    let actionsDisposable = DisposableSet()
+
+    let initialState: InviteLinkEditControllerState
+    if let invite = invite, case let .link(_, title, _, requestApproval, _, _, _, _, expireDate, usageLimit, count, _, pricing) = invite {
+        var usageLimit = usageLimit
+        if let limit = usageLimit, let count = count, count > 0 {
+            usageLimit = limit - count
+        }
+        
+        let timeLimit: InviteLinkTimeLimit
+        let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+        if let expireDate = expireDate {
+            if currentTime >= expireDate {
+                timeLimit = .day
+            } else {
+                timeLimit = .custom(expireDate)
+            }
+        } else {
+            timeLimit = .unlimited
+        }
+        
+        initialState = InviteLinkEditControllerState(title: title ?? "", usage: InviteLinkUsageLimit(value: usageLimit), time: timeLimit, requestApproval: requestApproval, subscriptionEnabled: pricing != nil, subscriptionFee: pricing?.amount, pickingExpiryDate: false, pickingExpiryTime: false, pickingUsageLimit: false)
+    } else {
+        initialState = InviteLinkEditControllerState(title: "", usage: .unlimited, time: .unlimited, requestApproval: false, subscriptionEnabled: false, subscriptionFee: nil, pickingExpiryDate: false, pickingExpiryTime: false, pickingUsageLimit: false)
+    }
+    
+    let statePromise = ValuePromise(initialState, ignoreRepeated: true)
+    let stateValue = Atomic(value: initialState)
+    let updateState: ((InviteLinkEditControllerState) -> InviteLinkEditControllerState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+
+    var dismissImpl: (() -> Void)?
+    var dismissInputImpl: (() -> Void)?
+    var scrollToUsageImpl: (() -> Void)?
+    var focusImpl: ((InviteLinksEditEntryTag) -> Void)?
+    var errorImpl: ((InviteLinksEditEntryTag) -> Void)?
+    
+    let arguments = InviteLinkEditControllerArguments(context: context, updateState: { f in
+        updateState(f)
+    }, focusOnItem: { tag in
+        focusImpl?(tag)
+    }, errorWithItem: { tag in
+        errorImpl?(tag)
+    }, scrollToUsage: {
+        scrollToUsageImpl?()
+    }, dismissInput: {
+       dismissInputImpl?()
+    }, revoke: {
+        guard let inviteLink = invite?.link else {
+            return
+        }
+        let _ = (context.account.postbox.loadedPeerWithId(peerId)
+        |> deliverOnMainQueue).start(next: { peer in
+            let isGroup: Bool
+            if let peer = peer as? TelegramChannel, case .broadcast = peer.info {
+                isGroup = false
+            } else {
+                isGroup = true
+            }
+            let presentationData = updatedPresentationData?.initial ?? context.sharedContext.currentPresentationData.with { $0 }
+            let controller = ActionSheetController(presentationData: presentationData)
+            let dismissAction: () -> Void = { [weak controller] in
+                controller?.dismissAnimated()
+            }
+            controller.setItemGroups([
+                ActionSheetItemGroup(items: [
+                    ActionSheetTextItem(title: isGroup ? presentationData.strings.GroupInfo_InviteLink_RevokeAlert_Text : presentationData.strings.ChannelInfo_InviteLink_RevokeAlert_Text),
+                    ActionSheetButtonItem(title: presentationData.strings.GroupInfo_InviteLink_RevokeLink, color: .destructive, action: {
+                        dismissAction()
+                        dismissImpl?()
+                        
+                        let _ = (context.engine.peers.revokePeerExportedInvitation(peerId: peerId, link: inviteLink)
+                        |> timeout(10, queue: Queue.mainQueue(), alternate: .fail(.generic))
+                        |> deliverOnMainQueue).start(next: { invite in
+                            switch invite {
+                            case .none:
+                                completion?(nil)
+                            case let .update(invitation):
+                                completion?(invitation)
+                            case let .replace(_, invitation):
+                                completion?(invitation)
+                            }
+                            
+                            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                            presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .linkRevoked(text: presentationData.strings.InviteLink_InviteLinkRevoked), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+                        }, error: { _ in
+                            updateState { state in
+                                var updatedState = state
+                                updatedState.updating = false
+                                return updatedState
+                            }
+                            presentControllerImpl?(textAlertController(context: context, updatedPresentationData: updatedPresentationData, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), nil)
+                        })
+                    })
+                ]),
+                ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+            ])
+            presentControllerImpl?(controller, nil)
+        })
+    })
+    
+    let presentationData = updatedPresentationData?.signal ?? context.sharedContext.presentationData
+    
+    let configuration = StarsSubscriptionConfiguration.with(appConfiguration: context.currentAppConfiguration.with { $0 })
+    
+    let previousState = Atomic<InviteLinkEditControllerState?>(value: nil)
+    let signal = combineLatest(
+        presentationData,
+        statePromise.get(),
+        context.engine.data.subscribe(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)
+        ))
+    |> deliverOnMainQueue
+    |> map { presentationData, state, peer -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        let isPublic = !(peer?.addressName?.isEmpty ?? true)
+        
+        let leftNavigationButton = ItemListNavigationButton(content: .text(presentationData.strings.Common_Cancel), style: .regular, enabled: true, action: {
+            dismissImpl?()
+        })
+        
+        var doneIsEnabled = true
+        if state.subscriptionEnabled {
+            if (state.subscriptionFee ?? StarsAmount.zero) == StarsAmount.zero {
+                doneIsEnabled = false
+            }
+        }
+        
+        let rightNavigationButton = ItemListNavigationButton(content: .text(invite == nil ? presentationData.strings.Common_Create : presentationData.strings.Common_Save), style: state.updating ? .activity : .bold, enabled: doneIsEnabled, action: {
+            updateState { state in
+                var updatedState = state
+                updatedState.updating = true
+                return updatedState
+            }
+            
+            var expireDate: Int32?
+            if case let .custom(value) = state.time {
+                expireDate = value
+            } else if let value = state.time.value {
+                let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+                expireDate = currentTime + value
+            } else {
+                expireDate = 0
+            }
+
+            let titleString = state.title.trimmingCharacters(in: .whitespacesAndNewlines)
+            let title = titleString.isEmpty ? nil : titleString
+            var usageLimit = state.usage.value
+            var requestNeeded: Bool? = state.requestApproval && !isPublic
+            
+            if invite == nil {
+                let subscriptionPricing: StarsSubscriptionPricing?
+                if let subscriptionFee = state.subscriptionFee {
+                    subscriptionPricing = StarsSubscriptionPricing(
+                        period: context.account.testingEnvironment ? StarsSubscriptionPricing.testPeriod : StarsSubscriptionPricing.monthPeriod,
+                        amount: subscriptionFee
+                    )
+                } else {
+                    subscriptionPricing = nil
+                }
+                let _ = (context.engine.peers.createPeerExportedInvitation(peerId: peerId, title: title, expireDate: expireDate, usageLimit: requestNeeded == true ? 0 : usageLimit, requestNeeded: requestNeeded, subscriptionPricing: subscriptionPricing)
+                |> timeout(10, queue: Queue.mainQueue(), alternate: .fail(.generic))
+                |> deliverOnMainQueue).start(next: { invite in
+                    completion?(invite)
+                    dismissImpl?()
+                }, error: { _ in
+                    updateState { state in
+                        var updatedState = state
+                        updatedState.updating = false
+                        return updatedState
+                    }
+                    presentControllerImpl?(textAlertController(context: context, updatedPresentationData: updatedPresentationData, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), nil)
+                })
+            } else if let initialInvite = invite, case let .link(link, initialTitle, _, initialRequestApproval, _, _, _, _, initialExpireDate, initialUsageLimit, _, _, _) = initialInvite {
+                if (initialExpireDate ?? 0) == expireDate && (initialUsageLimit ?? 0) == usageLimit && initialRequestApproval == requestNeeded && (initialTitle ?? "") == title {
+                    completion?(initialInvite)
+                    dismissImpl?()
+                    return
+                }
+                
+                if (initialExpireDate ?? 0) == expireDate {
+                    expireDate = nil
+                }
+                if (initialUsageLimit ?? 0) == usageLimit {
+                    usageLimit = nil
+                }
+                if initialRequestApproval == requestNeeded {
+                    requestNeeded = nil
+                }
+                
+                let _ = (context.engine.peers.editPeerExportedInvitation(peerId: peerId, link: link, title: title, expireDate: expireDate, usageLimit: requestNeeded == true ? 0 : usageLimit, requestNeeded: requestNeeded)
+                |> timeout(10, queue: Queue.mainQueue(), alternate: .fail(.generic))
+                |> deliverOnMainQueue).start(next: { invite in
+                    completion?(invite)
+                    dismissImpl?()
+                }, error: { _ in
+                    updateState { state in
+                        var updatedState = state
+                        updatedState.updating = false
+                        return updatedState
+                    }
+                    presentControllerImpl?(textAlertController(context: context, updatedPresentationData: updatedPresentationData, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {})]), nil)
+                })
+            }
+        })
+        
+        let previousState = previousState.swap(state)
+        var animateChanges = false
+        if let previousState = previousState, previousState.pickingExpiryDate != state.pickingExpiryDate || previousState.pickingExpiryTime != state.pickingExpiryTime || previousState.requestApproval != state.requestApproval || previousState.subscriptionEnabled != state.subscriptionEnabled {
+            animateChanges = true
+        }
+        
+        let isGroup: Bool
+        if case let .channel(channel) = peer, case .broadcast = channel.info {
+            isGroup = false
+        } else {
+            isGroup = true
+        }
+        
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: .text(invite == nil ? presentationData.strings.InviteLink_Create_Title : presentationData.strings.InviteLink_Create_EditTitle), leftNavigationButton: leftNavigationButton, rightNavigationButton: rightNavigationButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: inviteLinkEditControllerEntries(invite: invite, state: state, isGroup: isGroup, isPublic: isPublic, presentationData: presentationData, configuration: configuration), style: .blocks, emptyStateItem: nil, crossfadeState: false, animateChanges: animateChanges)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.beganInteractiveDragging = {
+        dismissInputImpl?()
+    }
+    presentControllerImpl = { [weak controller] c, p in
+        if let controller = controller {
+            controller.present(c, in: .window(.root), with: p)
+        }
+    }
+    scrollToUsageImpl = { [weak controller] in
+        controller?.afterLayout({
+            guard let controller = controller else {
+                return
+            }
+            
+            var resultItemNode: ListViewItemNode?
+            let _ = controller.frameForItemNode({ itemNode in
+                if let itemNode = itemNode as? ItemListSingleLineInputItemNode {
+                    if let tag = itemNode.tag as? InviteLinksEditEntryTag, tag == .usage {
+                        resultItemNode = itemNode
+                        return true
+                    }
+                }
+                return false
+            })
+            if let resultItemNode = resultItemNode {
+                controller.ensureItemNodeVisible(resultItemNode)
+            }
+        })
+    }
+    dismissInputImpl = { [weak controller] in
+        controller?.view.endEditing(true)
+    }
+    dismissImpl = { [weak controller] in
+        controller?.dismiss()
+    }
+    focusImpl = { [weak controller] targetTag in
+        controller?.forEachItemNode { itemNode in
+            if let itemNode = itemNode as? ItemListSingleLineInputItemNode, let tag = itemNode.tag, tag.isEqual(to: targetTag) {
+                itemNode.focus()
+            }
+        }
+    }
+    let hapticFeedback = HapticFeedback()
+    errorImpl = { [weak controller] targetTag in
+        hapticFeedback.error()
+        controller?.forEachItemNode { itemNode in
+            if let itemNode = itemNode as? ItemListSingleLineInputItemNode, let tag = itemNode.tag, tag.isEqual(to: targetTag) {
+                itemNode.animateError()
+            }
+        }
+    }
+    return controller
+}

submodules/InviteLinksUI/Sources/InviteLinkHeaderItem.swift

@@ -0,0 +1,229 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import TelegramAnimatedStickerNode
+import AccountContext
+import Markdown
+import TextFormat
+import TextNodeWithEntities
+
+public class InviteLinkHeaderItem: ListViewItem, ItemListItem {
+    public let context: AccountContext
+    public let theme: PresentationTheme
+    public let title: String?
+    public let text: NSAttributedString
+    public let animationName: String
+    public let hideOnSmallScreens: Bool
+    public let sectionId: ItemListSectionId
+    public let linkAction: ((ItemListTextItemLinkAction) -> Void)?
+    
+    public init(context: AccountContext, theme: PresentationTheme, title: String? = nil, text: NSAttributedString, animationName: String, hideOnSmallScreens: Bool = false, sectionId: ItemListSectionId, linkAction: ((ItemListTextItemLinkAction) -> Void)? = nil) {
+        self.context = context
+        self.theme = theme
+        self.title = title
+        self.text = text
+        self.animationName = animationName
+        self.hideOnSmallScreens = hideOnSmallScreens
+        self.sectionId = sectionId
+        self.linkAction = linkAction
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = InviteLinkHeaderItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            guard let nodeValue = node() as? InviteLinkHeaderItemNode else {
+                assertionFailure()
+                return
+            }
+            
+            let makeLayout = nodeValue.asyncLayout()
+            
+            async {
+                let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                Queue.mainQueue().async {
+                    completion(layout, { _ in
+                        apply()
+                    })
+                }
+            }
+        }
+    }
+}
+
+private let titleFont = Font.semibold(17.0)
+private let textFont = Font.regular(14.0)
+
+class InviteLinkHeaderItemNode: ListViewItemNode {
+    private let titleNode: TextNode
+    private let textNode: TextNodeWithEntities
+    private var animationNode: AnimatedStickerNode
+    
+    private var item: InviteLinkHeaderItem?
+    
+    init() {
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+        
+        self.textNode = TextNodeWithEntities()
+        self.textNode.textNode.isUserInteractionEnabled = false
+        self.textNode.textNode.contentMode = .left
+        self.textNode.textNode.contentsScale = UIScreen.main.scale
+        
+        self.animationNode = DefaultAnimatedStickerNodeImpl()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode.textNode)
+        self.addSubnode(self.animationNode)
+    }
+    
+    override public func didLoad() {
+        super.didLoad()
+        
+        let recognizer = TapLongTapOrDoubleTapGestureRecognizer(target: self, action: #selector(self.tapLongTapOrDoubleTapGesture(_:)))
+        recognizer.tapActionAtPoint = { _ in
+            return .waitForSingleTap
+        }
+        self.view.addGestureRecognizer(recognizer)
+    }
+    
+    func asyncLayout() -> (_ item: InviteLinkHeaderItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeTextLayout = TextNodeWithEntities.asyncLayout(self.textNode)
+        
+        return { item, params, neighbors in
+            let leftInset: CGFloat = 24.0 + params.leftInset
+            let iconSize: CGSize
+            if params.width > params.availableHeight && params.width > 320.0 {
+                iconSize = CGSize(width: 140.0, height: 140.0)
+            } else {
+                if item.hideOnSmallScreens {
+                    iconSize = .zero
+                } else {
+                    iconSize = CGSize(width: 124.0, height: 124.0)
+                }
+            }
+            let topInset: CGFloat = iconSize.height - 4.0
+            let spacing: CGFloat = 5.0
+            
+            let attributedTitle = NSAttributedString(string: item.title ?? "", font: titleFont, textColor: item.theme.list.itemPrimaryTextColor, paragraphAlignment: .center)
+            
+            let attributedText = NSMutableAttributedString(string: item.text.string)
+            attributedText.addAttribute(.font, value: Font.regular(14.0), range: NSRange(location: 0, length: attributedText.length))
+            attributedText.addAttribute(.foregroundColor, value: item.theme.list.freeTextColor, range: NSRange(location: 0, length: attributedText.length))
+            item.text.enumerateAttributes(in: NSRange(location: 0, length: item.text.length), using: { attributes, range, _ in
+                for (key, value) in attributes {
+                    if key == ChatTextInputAttributes.bold {
+                        attributedText.addAttribute(.font, value: Font.semibold(14.0), range: range)
+                    } else if key == ChatTextInputAttributes.italic {
+                        attributedText.addAttribute(.font, value: Font.italic(14.0), range: range)
+                    } else if key == ChatTextInputAttributes.monospace {
+                        attributedText.addAttribute(.font, value: Font.monospace(14.0), range: range)
+                    } else {
+                        attributedText.addAttribute(key, value: value, range: range)
+                    }
+                }
+            })
+            
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: attributedTitle, backgroundColor: nil, maximumNumberOfLines: 0, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset * 2.0, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: attributedText, backgroundColor: nil, maximumNumberOfLines: 0, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset * 2.0, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            var contentSize = CGSize(width: params.width, height: topInset + textLayout.size.height)
+            if let _ = item.title {
+                contentSize.height += titleLayout.size.height + spacing
+            }
+                        
+            let insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    if strongSelf.item == nil {
+                        strongSelf.animationNode.setup(source: AnimatedStickerNodeLocalFileSource(name: item.animationName), width: 256, height: 256, playbackMode: .count(1), mode: .direct(cachePathPrefix: nil))
+                        strongSelf.animationNode.visibility = true
+                    }
+                    strongSelf.item = item
+                    strongSelf.accessibilityLabel = attributedText.string
+                                        
+                    strongSelf.animationNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - iconSize.width) / 2.0), y: -10.0), size: iconSize)
+                    strongSelf.animationNode.updateLayout(size: iconSize)
+                    
+                    var origin: CGFloat = topInset + 8.0
+                    
+                    let _ = titleApply()
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleLayout.size.width) / 2.0), y: origin), size: titleLayout.size)
+                    if titleLayout.size.height > 0.0 {
+                        origin += titleLayout.size.height + spacing
+                    }
+                    
+                    let _ = textApply(TextNodeWithEntities.Arguments(
+                        context: item.context,
+                        cache: item.context.animationCache,
+                        renderer: item.context.animationRenderer,
+                        placeholderColor: item.theme.list.mediaPlaceholderColor,
+                        attemptSynchronous: true
+                    ))
+                    strongSelf.textNode.textNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - textLayout.size.width) / 2.0), y: origin), size: textLayout.size)
+                    strongSelf.textNode.visibilityRect = .infinite
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    @objc private func tapLongTapOrDoubleTapGesture(_ recognizer: TapLongTapOrDoubleTapGestureRecognizer) {
+        switch recognizer.state {
+            case .ended:
+                if let (gesture, location) = recognizer.lastRecognizedGestureAndLocation {
+                    switch gesture {
+                        case .tap:
+                        let textFrame = self.textNode.textNode.frame
+                            if let item = self.item, textFrame.contains(location) {
+                                if let (_, attributes) = self.textNode.textNode.attributesAtPoint(CGPoint(x: location.x - textFrame.minX, y: location.y - textFrame.minY)) {
+                                    if let url = attributes[NSAttributedString.Key(rawValue: TelegramTextAttributes.URL)] as? String {
+                                        item.linkAction?(.tap(url))
+                                    }
+                                }
+                            }
+                        default:
+                            break
+                    }
+                }
+            default:
+                break
+        }
+    }
+}

submodules/InviteLinksUI/Sources/InviteLinkInviteHeaderItem.swift

@@ -0,0 +1,154 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import AppBundle
+
+class InviteLinkInviteHeaderItem: ListViewItem, ItemListItem {
+    var sectionId: ItemListSectionId = 0
+    
+    let theme: PresentationTheme
+    let title: String
+    let text: String
+    
+    init(theme: PresentationTheme, title: String, text: String) {
+        self.theme = theme
+        self.title = title
+        self.text = text
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = InviteLinkInviteHeaderItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            guard let nodeValue = node() as? InviteLinkInviteHeaderItemNode else {
+                assertionFailure()
+                return
+            }
+            
+            let makeLayout = nodeValue.asyncLayout()
+            
+            async {
+                let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                Queue.mainQueue().async {
+                    completion(layout, { _ in
+                        apply()
+                    })
+                }
+            }
+        }
+    }
+}
+
+private let titleFont = Font.bold(24.0)
+private let textFont = Font.regular(15.0)
+
+class InviteLinkInviteHeaderItemNode: ListViewItemNode {
+    private let titleNode: TextNode
+    private let textNode: TextNode
+    private let iconBackgroundNode: ASImageNode
+    private let iconNode: ASImageNode
+    
+    private var item: InviteLinkInviteHeaderItem?
+    
+    init() {
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.textNode = TextNode()
+        self.textNode.isUserInteractionEnabled = false
+        
+        self.iconBackgroundNode = ASImageNode()
+        self.iconBackgroundNode.displaysAsynchronously = false
+        self.iconBackgroundNode.displayWithoutProcessing = true
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.contentMode = .center
+        self.iconNode.displaysAsynchronously = false
+        self.iconNode.displayWithoutProcessing = true
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode)
+        self.addSubnode(self.iconBackgroundNode)
+        self.addSubnode(self.iconNode)
+    }
+    
+    func asyncLayout() -> (_ item: InviteLinkInviteHeaderItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeTextLayout = TextNode.asyncLayout(self.textNode)
+        let currentItem = self.item
+        
+        return { item, params, neighbors in
+            let leftInset: CGFloat = 40.0 + params.leftInset
+            let topInset: CGFloat = 98.0
+            let spacing: CGFloat = 10.0
+            let bottomInset: CGFloat = 13.0
+            
+            var updatedTheme: PresentationTheme?
+            if currentItem?.theme !== item.theme {
+                updatedTheme = item.theme
+            }
+            
+            let titleAttributedText = NSAttributedString(string: item.title, font: titleFont, textColor: item.theme.list.itemPrimaryTextColor)
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedText, backgroundColor: nil, maximumNumberOfLines: 0, truncationType: .end, constrainedSize: CGSize(width: params.width - params.rightInset - leftInset * 2.0, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let attributedText = NSAttributedString(string: item.text, font: textFont, textColor: item.theme.list.itemPrimaryTextColor)
+            let (textLayout, textApply) = makeTextLayout(TextNodeLayoutArguments(attributedString: attributedText, backgroundColor: nil, maximumNumberOfLines: 0, truncationType: .end, constrainedSize: CGSize(width: params.width - params.rightInset - leftInset * 2.0, height: CGFloat.greatestFiniteMagnitude), alignment: .center, cutout: nil, insets: UIEdgeInsets()))
+            
+            let contentSize = CGSize(width: params.width, height: topInset + titleLayout.size.height + spacing + textLayout.size.height + bottomInset)
+        
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: UIEdgeInsets())
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.accessibilityLabel = attributedText.string
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.iconBackgroundNode.image = generateFilledCircleImage(diameter: 92.0, color: item.theme.actionSheet.controlAccentColor)
+                        strongSelf.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Links/LargeLink"), color: item.theme.list.itemCheckColors.foregroundColor)
+                    }
+                                        
+                    let iconSize = CGSize(width: 92.0, height: 92.0)
+                    strongSelf.iconBackgroundNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - iconSize.width) / 2.0), y: -18.0), size: iconSize)
+                    strongSelf.iconNode.frame = strongSelf.iconBackgroundNode.frame.insetBy(dx: 8.0, dy: 8.0)
+                    
+                    let _ = titleApply()
+                    strongSelf.titleNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - titleLayout.size.width) / 2.0), y: topInset + 10.0), size: titleLayout.size)
+                    
+                    let _ = textApply()
+                    strongSelf.textNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - textLayout.size.width) / 2.0), y: topInset + 10.0 + titleLayout.size.height + spacing), size: textLayout.size)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/InviteLinksUI/Sources/InviteLinkInviteManageItem.swift

@@ -0,0 +1,118 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import AppBundle
+
+class InviteLinkInviteManageItem: ListViewItem, ItemListItem {
+    var sectionId: ItemListSectionId = 0
+    
+    let theme: PresentationTheme
+    let text: String
+    let standalone: Bool
+    let action: () -> Void
+    
+    init(theme: PresentationTheme, text: String, standalone: Bool, action: @escaping () -> Void) {
+        self.theme = theme
+        self.text = text
+        self.standalone = standalone
+        self.action = action
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = InviteLinkInviteManageItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            guard let nodeValue = node() as? InviteLinkInviteManageItemNode else {
+                assertionFailure()
+                return
+            }
+            
+            let makeLayout = nodeValue.asyncLayout()
+            
+            async {
+                let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                Queue.mainQueue().async {
+                    completion(layout, { _ in
+                        apply()
+                    })
+                }
+            }
+        }
+    }
+}
+
+private let titleFont = Font.medium(23.0)
+private let textFont = Font.regular(13.0)
+
+class InviteLinkInviteManageItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let buttonNode: HighlightableButtonNode
+    
+    private var item: InviteLinkInviteManageItem?
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.buttonNode = HighlightableButtonNode()
+      
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.backgroundNode)
+        self.addSubnode(self.buttonNode)
+        
+        self.buttonNode.addTarget(self, action: #selector(self.buttonPressed), forControlEvents: .touchUpInside)
+    }
+    
+    @objc private func buttonPressed() {
+        self.item?.action()
+    }
+    
+    func asyncLayout() -> (_ item: InviteLinkInviteManageItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        return { item, params, neighbors in
+            let contentSize = CGSize(width: params.width, height: 70.0)
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: UIEdgeInsets())
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.standalone ? .clear : item.theme.list.blocksBackgroundColor
+                    
+                    strongSelf.buttonNode.setTitle(item.text, with: Font.regular(17.0), with: item.theme.actionSheet.controlAccentColor, for: .normal)
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(), size: CGSize(width: params.width, height: 1000.0))
+
+                    let size = strongSelf.buttonNode.measure(layout.contentSize)
+                    strongSelf.buttonNode.frame = CGRect(origin: CGPoint(x: floorToScreenPixels((layout.contentSize.width - size.width) / 2.0), y: floorToScreenPixels((layout.contentSize.height - size.height) / 2.0)), size: size)
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+}

submodules/InviteLinksUI/Sources/InviteRequestsController.swift

@@ -0,0 +1,434 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import ItemListUI
+import PresentationDataUtils
+import OverlayStatusController
+import AccountContext
+import AlertUI
+import PresentationDataUtils
+import AppBundle
+import ContextUI
+import TelegramStringFormatting
+import ItemListPeerActionItem
+import ItemListPeerItem
+import ShareController
+import UndoUI
+
+private final class InviteRequestsControllerArguments {
+    let context: AccountContext
+    let openLinks: () -> Void
+    let openPeer: (EnginePeer) -> Void
+    let approveRequest: (EnginePeer) -> Void
+    let denyRequest: (EnginePeer) -> Void
+    let peerContextAction: (EnginePeer, ASDisplayNode, ContextGesture?) -> Void
+    
+    init(context: AccountContext, openLinks: @escaping () -> Void, openPeer: @escaping (EnginePeer) -> Void, approveRequest: @escaping (EnginePeer) -> Void, denyRequest: @escaping (EnginePeer) -> Void, peerContextAction: @escaping (EnginePeer, ASDisplayNode, ContextGesture?) -> Void) {
+        self.context = context
+        self.openLinks = openLinks
+        self.openPeer = openPeer
+        self.approveRequest = approveRequest
+        self.denyRequest = denyRequest
+        self.peerContextAction = peerContextAction
+    }
+}
+
+private enum InviteRequestsSection: Int32 {
+    case header
+    case requests
+}
+
+private enum InviteRequestsEntry: ItemListNodeEntry {
+    case header(PresentationTheme, String)
+   
+    case requestsHeader(PresentationTheme, String)
+    case request(Int32, PresentationTheme, PresentationDateTimeFormat, PresentationPersonNameOrder, PeerInvitationImportersState.Importer, Bool)
+    
+    var section: ItemListSectionId {
+        switch self {
+            case .header:
+                return InviteRequestsSection.header.rawValue
+            case .requestsHeader, .request:
+                return InviteRequestsSection.requests.rawValue
+        }
+    }
+    
+    var stableId: Int32 {
+        switch self {
+            case .header:
+                return 0
+            case .requestsHeader:
+                return 1
+            case let .request(index, _, _, _, _, _):
+                return 2 + index
+        }
+    }
+    
+    static func ==(lhs: InviteRequestsEntry, rhs: InviteRequestsEntry) -> Bool {
+        switch lhs {
+            case let .header(lhsTheme, lhsText):
+                if case let .header(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .requestsHeader(lhsTheme, lhsText):
+                if case let .requestsHeader(rhsTheme, rhsText) = rhs, lhsTheme === rhsTheme, lhsText == rhsText {
+                    return true
+                } else {
+                    return false
+                }
+            case let .request(lhsIndex, lhsTheme, lhsDateTimeFormat, lhsNameDisplayOrder, lhsImporter, lhsIsGroup):
+                if case let .request(rhsIndex, rhsTheme, rhsDateTimeFormat, rhsNameDisplayOrder, rhsImporter, rhsIsGroup) = rhs, lhsIndex == rhsIndex, lhsTheme === rhsTheme, lhsDateTimeFormat == rhsDateTimeFormat, lhsNameDisplayOrder == rhsNameDisplayOrder, lhsImporter == rhsImporter, lhsIsGroup == rhsIsGroup {
+                    return true
+                } else {
+                    return false
+                }
+        }
+    }
+    
+    static func <(lhs: InviteRequestsEntry, rhs: InviteRequestsEntry) -> Bool {
+        return lhs.stableId < rhs.stableId
+    }
+    
+    func item(presentationData: ItemListPresentationData, arguments: Any) -> ListViewItem {
+        let arguments = arguments as! InviteRequestsControllerArguments
+        switch self {
+            case let .header(theme, text):
+                return InviteLinkHeaderItem(context: arguments.context, theme: theme, text: NSAttributedString(string: text), animationName: "Requests", sectionId: self.section, linkAction: { _ in
+                    arguments.openLinks()
+                })
+            case let .requestsHeader(_, text):
+                return ItemListSectionHeaderItem(presentationData: presentationData, text: text, sectionId: self.section)
+            case let .request(_, _, dateTimeFormat, nameDisplayOrder, importer, isGroup):
+                return ItemListInviteRequestItem(context: arguments.context, presentationData: presentationData, dateTimeFormat: dateTimeFormat, nameDisplayOrder: nameDisplayOrder, importer: importer, isGroup: isGroup, sectionId: self.section, style: .blocks, tapAction: {
+                    if let peer = importer.peer.peer.flatMap({ EnginePeer($0) }) {
+                        arguments.openPeer(peer)
+                    }
+                }, addAction: {
+                    if let peer = importer.peer.peer.flatMap({ EnginePeer($0) }) {
+                        arguments.approveRequest(peer)
+                    }
+                }, dismissAction: {
+                    if let peer = importer.peer.peer.flatMap({ EnginePeer($0) }) {
+                        arguments.denyRequest(peer)
+                    }
+                }, contextAction: { node, gesture in
+                    if let peer = importer.peer.peer.flatMap({ EnginePeer($0) }) {
+                        arguments.peerContextAction(peer, node, gesture)
+                    }
+                })
+        }
+    }
+}
+
+private func inviteRequestsControllerEntries(presentationData: PresentationData, peer: EnginePeer?, importers: [PeerInvitationImportersState.Importer]?, count: Int32, isGroup: Bool) -> [InviteRequestsEntry] {
+    var entries: [InviteRequestsEntry] = []
+    
+    if let importers = importers, !importers.isEmpty {
+        let helpText: String
+        if case let .channel(peer) = peer, case .broadcast = peer.info {
+            helpText = presentationData.strings.MemberRequests_DescriptionChannel
+        } else {
+            helpText = presentationData.strings.MemberRequests_DescriptionGroup
+        }
+        entries.append(.header(presentationData.theme, helpText))
+    
+        entries.append(.requestsHeader(presentationData.theme, presentationData.strings.MemberRequests_PeopleRequested(count).uppercased()))
+        
+        var index: Int32 = 0
+        for importer in importers {
+            entries.append(.request(index, presentationData.theme, presentationData.dateTimeFormat, presentationData.nameDisplayOrder, importer, isGroup))
+            index += 1
+        }
+    }
+
+    return entries
+}
+
+private struct InviteRequestsControllerState: Equatable {
+    var searchingMembers: Bool
+}
+
+public func inviteRequestsController(context: AccountContext, updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)? = nil, peerId: EnginePeer.Id, existingContext: PeerInvitationImportersContext? = nil) -> ViewController {
+    var pushControllerImpl: ((ViewController) -> Void)?
+    var presentControllerImpl: ((ViewController, ViewControllerPresentationArguments?) -> Void)?
+    var presentInGlobalOverlayImpl: ((ViewController) -> Void)?
+    var navigateToProfileImpl: ((EnginePeer) -> Void)?
+    var navigateToChatImpl: ((EnginePeer) -> Void)?
+    var dismissInputImpl: (() -> Void)?
+    var dismissTooltipsImpl: (() -> Void)?
+    
+    let actionsDisposable = DisposableSet()
+    
+    if let existingContext = existingContext {
+        existingContext.reload()
+    }
+    
+    let statePromise = ValuePromise(InviteRequestsControllerState(searchingMembers: false), ignoreRepeated: true)
+    let stateValue = Atomic(value: InviteRequestsControllerState(searchingMembers: false))
+    let updateState: ((InviteRequestsControllerState) -> InviteRequestsControllerState) -> Void = { f in
+        statePromise.set(stateValue.modify { f($0) })
+    }
+    
+    let updateDisposable = MetaDisposable()
+    actionsDisposable.add(updateDisposable)
+        
+    let importersContext = existingContext ?? context.engine.peers.peerInvitationImporters(peerId: peerId, subject: .requests(query: nil))
+    
+    let approveRequestImpl: (EnginePeer) -> Void = { peer in
+        importersContext.update(peer.id, action: .approve)
+                
+        let _ = (context.engine.data.get(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)
+        )
+        |> deliverOnMainQueue).start(next: { chatPeer in
+            guard let chatPeer = chatPeer else {
+                return
+            }
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            let string: String
+            if case let .channel(channel) = chatPeer, case .broadcast = channel.info {
+                string = presentationData.strings.MemberRequests_UserAddedToChannel(peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)).string
+            } else {
+                string = presentationData.strings.MemberRequests_UserAddedToGroup(peer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)).string
+            }
+            presentControllerImpl?(UndoOverlayController(presentationData: presentationData, content: .invitedToVoiceChat(context: context, peer: peer, title: nil, text: string, action: nil, duration: 3), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), nil)
+        })
+    }
+    
+    let denyRequestImpl: (EnginePeer) -> Void = { peer in
+        importersContext.update(peer.id, action: .deny)
+    }
+    
+    let arguments = InviteRequestsControllerArguments(context: context, openLinks: {
+        let controller = inviteLinkListController(context: context, updatedPresentationData: updatedPresentationData, peerId: peerId, admin: nil)
+        pushControllerImpl?(controller)
+    }, openPeer: { peer in
+        navigateToProfileImpl?(peer)
+    }, approveRequest: { peer in
+        approveRequestImpl(peer)
+    }, denyRequest: { peer in
+        denyRequestImpl(peer)
+    }, peerContextAction: { peer, node, gesture in
+        guard let node = node as? ContextExtractedContentContainingNode else {
+            return
+        }
+        
+        let _ = (context.engine.data.get(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)
+        )
+        |> deliverOnMainQueue).start(next: { chatPeer in
+            guard let chatPeer = chatPeer else {
+                return
+            }
+            let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+            let addString: String
+            if case let .channel(channel) = chatPeer, case .broadcast = channel.info {
+                addString = presentationData.strings.MemberRequests_AddToChannel
+            } else {
+                addString = presentationData.strings.MemberRequests_AddToGroup
+            }
+            var items: [ContextMenuItem] = []
+
+            items.append(.action(ContextMenuActionItem(text: addString, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/AddUser"), color: theme.contextMenu.primaryColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+                
+                approveRequestImpl(peer)
+            })))
+            
+            items.append(.action(ContextMenuActionItem(text: presentationData.strings.ContactList_Context_SendMessage, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Message"), color: theme.contextMenu.primaryColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+                
+                navigateToChatImpl?(peer)
+            })))
+            
+            items.append(.action(ContextMenuActionItem(text: presentationData.strings.MemberRequests_Dismiss, textColor: .destructive, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.destructiveColor)
+            }, action: { _, f in
+                f(.dismissWithoutContent)
+                
+                Queue.mainQueue().after(0.3, {
+                    denyRequestImpl(peer)
+                })
+            })))
+            
+            let dismissPromise = ValuePromise<Bool>(false)
+            let source = InviteRequestsContextExtractedContentSource(sourceNode: node, keepInPlace: false, blurBackground: true, centerVertically: true, shouldBeDismissed: dismissPromise.get())
+    //        sourceNode.requestDismiss = {
+    //            dismissPromise.set(true)
+    //        }
+            
+            let contextController = ContextController(presentationData: presentationData, source: .extracted(source), items: .single(ContextController.Items(content: .list(items))), gesture: gesture)
+            presentInGlobalOverlayImpl?(contextController)
+        })
+    })
+    
+    let previousEntries = Atomic<[InviteRequestsEntry]>(value: [])
+        
+    let presentationData = updatedPresentationData?.signal ?? context.sharedContext.presentationData
+    let signal = combineLatest(queue: .mainQueue(),
+        presentationData,
+        context.engine.data.subscribe(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)
+        ),
+        importersContext.state,
+        statePromise.get()
+    )
+    |> map { presentationData, peer, importersState, state -> (ItemListControllerState, (ItemListNodeState, Any)) in
+        var isGroup = true
+        if case let .channel(channel) = peer, case .broadcast = channel.info {
+            isGroup = false
+        }
+        
+        var emptyStateItem: ItemListControllerEmptyStateItem?
+        if importersState.hasLoadedOnce && importersState.importers.isEmpty {
+            emptyStateItem = InviteRequestsEmptyStateItem(context: context, theme: presentationData.theme, strings: presentationData.strings, isGroup: isGroup)
+        }
+        
+        let entries = inviteRequestsControllerEntries(presentationData: presentationData, peer: peer, importers: importersState.hasLoadedOnce ? importersState.importers : nil, count: importersState.count, isGroup: isGroup)
+        let previousEntries = previousEntries.swap(entries)
+        
+        let crossfade = !previousEntries.isEmpty && entries.isEmpty
+        let animateChanges = (!previousEntries.isEmpty && !entries.isEmpty) && previousEntries.count != entries.count
+        
+        let rightNavigationButton: ItemListNavigationButton?
+        if !importersState.importers.isEmpty {
+            rightNavigationButton = ItemListNavigationButton(content: .icon(.search), style: .regular, enabled: true, action: {
+                updateState { state in
+                    var updatedState = state
+                    updatedState.searchingMembers = true
+                    return updatedState
+                }
+            })
+        } else {
+            rightNavigationButton = nil
+        }
+        
+        var searchItem: ItemListControllerSearch?
+        if state.searchingMembers && !importersState.importers.isEmpty {
+            searchItem = InviteRequestsSearchItem(context: context, peerId: peerId, cancel: {
+                updateState { state in
+                    var updatedState = state
+                    updatedState.searchingMembers = false
+                    return updatedState
+                }
+            }, openPeer: { peer in
+                arguments.openPeer(peer)
+            }, approveRequest: { peer in
+                arguments.approveRequest(peer)
+            }, denyRequest: { peer in
+                arguments.denyRequest(peer)
+            }, navigateToChat: { peer in
+                navigateToChatImpl?(peer)
+            }, pushController: { c in
+                pushControllerImpl?(c)
+            }, dismissInput: {
+                dismissInputImpl?()
+            }, presentInGlobalOverlay: { c in
+                presentInGlobalOverlayImpl?(c)
+            })
+        }
+        
+        let title: ItemListControllerTitle = .text(presentationData.strings.MemberRequests_Title)
+        let controllerState = ItemListControllerState(presentationData: ItemListPresentationData(presentationData), title: title, leftNavigationButton: nil, rightNavigationButton: rightNavigationButton, backNavigationButton: ItemListBackButton(title: presentationData.strings.Common_Back), animateChanges: true)
+        let listState = ItemListNodeState(presentationData: ItemListPresentationData(presentationData), entries: entries, style: .blocks, emptyStateItem: emptyStateItem, searchItem: searchItem, crossfadeState: crossfade, animateChanges: animateChanges, scrollEnabled: emptyStateItem == nil)
+        
+        return (controllerState, (listState, arguments))
+    }
+    |> afterDisposed {
+        actionsDisposable.dispose()
+    }
+    
+    let controller = ItemListController(context: context, state: signal)
+    controller.willDisappear = { _ in
+        dismissTooltipsImpl?()
+    }
+    controller.didDisappear = { [weak controller] _ in
+        controller?.clearItemNodesHighlight(animated: true)
+    }
+    controller.visibleBottomContentOffsetChanged = { offset in
+        if case let .known(value) = offset, value < 40.0 {
+            importersContext.loadMore()
+        }
+    }
+    pushControllerImpl = { [weak controller] c in
+        if let controller = controller {
+            (controller.navigationController as? NavigationController)?.pushViewController(c, animated: true)
+        }
+    }
+    presentControllerImpl = { [weak controller] c, p in
+        if let controller = controller {
+            controller.present(c, in: .window(.root), with: p)
+        }
+    }
+    presentInGlobalOverlayImpl = { [weak controller] c in
+        if let controller = controller {
+            controller.presentInGlobalOverlay(c)
+        }
+    }
+    navigateToProfileImpl = { [weak controller] peer in
+        if let navigationController = controller?.navigationController as? NavigationController, let controller = context.sharedContext.makePeerInfoController(context: context, updatedPresentationData: nil, peer: peer._asPeer(), mode: .generic, avatarInitiallyExpanded: peer.largeProfileImage != nil, fromChat: false, requestsContext: nil) {
+            navigationController.pushViewController(controller)
+        }
+    }
+    navigateToChatImpl = { [weak controller] peer in
+        if let navigationController = controller?.navigationController as? NavigationController {
+            context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), keepStack: .always))
+        }
+    }
+    dismissInputImpl = { [weak controller] in
+        controller?.view.endEditing(true)
+    }
+    dismissTooltipsImpl = { [weak controller] in
+        controller?.window?.forEachController({ controller in
+            if let controller = controller as? UndoOverlayController {
+                controller.dismissWithCommitAction()
+            }
+        })
+        controller?.forEachController({ controller in
+            if let controller = controller as? UndoOverlayController {
+                controller.dismissWithCommitAction()
+            }
+            return true
+        })
+    }
+    return controller
+}
+
+
+final class InviteRequestsContextExtractedContentSource: ContextExtractedContentSource {
+    var keepInPlace: Bool
+    let ignoreContentTouches: Bool = false
+    let blurBackground: Bool
+
+    private let sourceNode: ContextExtractedContentContainingNode
+    
+    var centerVertically: Bool
+    var shouldBeDismissed: Signal<Bool, NoError>
+    
+    init(sourceNode: ContextExtractedContentContainingNode, keepInPlace: Bool, blurBackground: Bool, centerVertically: Bool, shouldBeDismissed: Signal<Bool, NoError>) {
+        self.sourceNode = sourceNode
+        self.keepInPlace = keepInPlace
+        self.blurBackground = blurBackground
+        self.centerVertically = centerVertically
+        self.shouldBeDismissed = shouldBeDismissed
+    }
+    
+    func takeView() -> ContextControllerTakeViewInfo? {
+        return ContextControllerTakeViewInfo(containingItem: .node(self.sourceNode), contentAreaInScreenSpace: UIScreen.main.bounds)
+    }
+    
+    func putBack() -> ContextControllerPutBackViewInfo? {
+        return ContextControllerPutBackViewInfo(contentAreaInScreenSpace: UIScreen.main.bounds)
+    }
+}

submodules/InviteLinksUI/Sources/InviteRequestsEmptyItem.swift

@@ -0,0 +1,112 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import TelegramPresentationData
+import ItemListUI
+import PresentationDataUtils
+import AnimatedStickerNode
+import TelegramAnimatedStickerNode
+import AccountContext
+
+final class InviteRequestsEmptyStateItem: ItemListControllerEmptyStateItem {
+    let context: AccountContext
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let isGroup: Bool
+    
+    init(context: AccountContext, theme: PresentationTheme, strings: PresentationStrings, isGroup: Bool) {
+        self.context = context
+        self.theme = theme
+        self.strings = strings
+        self.isGroup = isGroup
+    }
+    
+    func isEqual(to: ItemListControllerEmptyStateItem) -> Bool {
+        if let item = to as? InviteRequestsEmptyStateItem {
+            return self.theme === item.theme && self.strings === item.strings && self.isGroup == item.isGroup
+        } else {
+            return false
+        }
+    }
+    
+    func node(current: ItemListControllerEmptyStateItemNode?) -> ItemListControllerEmptyStateItemNode {
+        if let current = current as? InviteRequestsEmptyStateItemNode {
+            current.item = self
+            return current
+        } else {
+            return InviteRequestsEmptyStateItemNode(item: self)
+        }
+    }
+}
+
+final class InviteRequestsEmptyStateItemNode: ItemListControllerEmptyStateItemNode {
+    private var animationNode: AnimatedStickerNode
+    private let titleNode: ASTextNode
+    private let textNode: ASTextNode
+    private var validLayout: (ContainerViewLayout, CGFloat)?
+    
+    var item: InviteRequestsEmptyStateItem {
+        didSet {
+            self.updateThemeAndStrings(theme: self.item.theme, strings: self.item.strings)
+            if let (layout, navigationHeight) = self.validLayout {
+                self.updateLayout(layout: layout, navigationBarHeight: navigationHeight, transition: .immediate)
+            }
+        }
+    }
+    
+    init(item: InviteRequestsEmptyStateItem) {
+        self.item = item
+        
+        self.animationNode = DefaultAnimatedStickerNodeImpl()
+        self.animationNode.setup(source: AnimatedStickerNodeLocalFileSource(name: "TwoFactorSetupRememberSuccess"), width: 192, height: 192, playbackMode: .once, mode: .direct(cachePathPrefix: nil))
+        self.animationNode.visibility = true
+        
+        self.titleNode = ASTextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        
+        self.textNode = ASTextNode()
+        self.textNode.isUserInteractionEnabled = false
+        
+        super.init()
+        
+        self.isUserInteractionEnabled = false
+        
+        self.addSubnode(self.animationNode)
+        self.addSubnode(self.titleNode)
+        self.addSubnode(self.textNode)
+        
+        self.updateThemeAndStrings(theme: self.item.theme, strings: self.item.strings)
+    }
+    
+    private func updateThemeAndStrings(theme: PresentationTheme, strings: PresentationStrings) {
+        self.titleNode.attributedText = NSAttributedString(string: strings.MemberRequests_NoRequests, font: Font.bold(17.0), textColor: theme.list.freeTextColor, paragraphAlignment: .center)
+        self.textNode.attributedText = NSAttributedString(string: self.item.isGroup ? strings.MemberRequests_NoRequestsDescriptionGroup : strings.MemberRequests_NoRequestsDescriptionChannel, font: Font.regular(14.0), textColor: theme.list.freeTextColor, paragraphAlignment: .center)
+    }
+    
+    override func updateLayout(layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        self.validLayout = (layout, navigationBarHeight)
+        var insets = layout.insets(options: [])
+        insets.top += navigationBarHeight
+        
+        let imageSpacing: CGFloat = 10.0
+        let textSpacing: CGFloat = 8.0
+    
+        let imageSize = CGSize(width: 112.0, height: 112.0)
+        let imageHeight = layout.size.width < layout.size.height ? imageSize.height + imageSpacing : 0.0
+        
+        self.animationNode.frame = CGRect(origin: CGPoint(x: floor((layout.size.width - imageSize.width) / 2.0), y: -10.0), size: imageSize)
+        self.animationNode.updateLayout(size: imageSize)
+        
+        let titleSize = self.titleNode.measure(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right - 50.0, height: max(1.0, layout.size.height - insets.top - insets.bottom)))
+        let textSize = self.textNode.measure(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right - 50.0, height: max(1.0, layout.size.height - insets.top - insets.bottom)))
+        
+        let totalHeight = imageHeight + titleSize.height + textSpacing + textSize.height
+        let topOffset = insets.top + floor((layout.size.height - insets.top - insets.bottom - totalHeight) / 2.0)
+        
+        transition.updateAlpha(node: self.animationNode, alpha: imageHeight > 0.0 ? 1.0 : 0.0)
+        transition.updateFrame(node: self.animationNode, frame: CGRect(origin: CGPoint(x: floor((layout.size.width - imageSize.width) / 2.0), y: topOffset), size: imageSize))
+        transition.updateFrame(node: self.titleNode, frame: CGRect(origin: CGPoint(x: layout.safeInsets.left + layout.intrinsicInsets.left + floor((layout.size.width - titleSize.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right) / 2.0), y: topOffset + imageHeight), size: titleSize))
+        transition.updateFrame(node: self.textNode, frame: CGRect(origin: CGPoint(x: layout.safeInsets.left + layout.intrinsicInsets.left + floor((layout.size.width - textSize.width - layout.safeInsets.left - layout.safeInsets.right - layout.intrinsicInsets.left - layout.intrinsicInsets.right) / 2.0), y: self.titleNode.frame.maxY + textSpacing), size: textSize))
+    }
+}

submodules/InviteLinksUI/Sources/InviteRequestsSearchItem.swift

@@ -0,0 +1,685 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SwiftSignalKit
+import ItemListUI
+import PresentationDataUtils
+import TelegramPresentationData
+import TelegramUIPreferences
+import AccountContext
+import SearchBarNode
+import MergeLists
+import ChatListSearchItemHeader
+import ItemListUI
+import SearchUI
+import ContextUI
+
+private let searchBarFont = Font.regular(17.0)
+
+final class SearchNavigationContentNode: NavigationBarContentNode, ItemListControllerSearchNavigationContentNode {
+    private var theme: PresentationTheme
+    private let strings: PresentationStrings
+    
+    private let cancel: () -> Void
+    
+    private let searchBar: SearchBarNode
+    
+    private var queryUpdated: ((String) -> Void)?
+    var activity: Bool = false {
+        didSet {
+            searchBar.activity = activity
+        }
+    }
+    init(theme: PresentationTheme, strings: PresentationStrings, cancel: @escaping () -> Void, updateActivity: @escaping(@escaping(Bool)->Void) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        
+        self.cancel = cancel
+        
+        self.searchBar = SearchBarNode(theme: SearchBarNodeTheme(theme: theme, hasSeparator: false), strings: strings, fieldStyle: .modern, displayBackground: false)
+        
+        super.init()
+        
+        self.addSubnode(self.searchBar)
+        
+        self.searchBar.cancel = { [weak self] in
+            self?.searchBar.deactivate(clear: false)
+            self?.cancel()
+        }
+        
+        self.searchBar.textUpdated = { [weak self] query, _ in
+            self?.queryUpdated?(query)
+        }
+        
+        updateActivity({ [weak self] value in
+            self?.activity = value
+        })
+        
+        self.updatePlaceholder()
+    }
+    
+    func setQueryUpdated(_ f: @escaping (String) -> Void) {
+        self.queryUpdated = f
+    }
+    
+    func updateTheme(_ theme: PresentationTheme) {
+        self.theme = theme
+        self.searchBar.updateThemeAndStrings(theme: SearchBarNodeTheme(theme: self.theme), strings: self.strings)
+        self.updatePlaceholder()
+    }
+    
+    func updatePlaceholder() {
+        self.searchBar.placeholderString = NSAttributedString(string: self.strings.MemberRequests_SearchPlaceholder, font: searchBarFont, textColor: self.theme.rootController.navigationSearchBar.inputPlaceholderTextColor)
+    }
+    
+    override var nominalHeight: CGFloat {
+        return 56.0
+    }
+    
+    override func updateLayout(size: CGSize, leftInset: CGFloat, rightInset: CGFloat, transition: ContainedViewLayoutTransition) {
+        let searchBarFrame = CGRect(origin: CGPoint(x: 0.0, y: size.height - self.nominalHeight), size: CGSize(width: size.width, height: 56.0))
+        self.searchBar.frame = searchBarFrame
+        self.searchBar.updateLayout(boundingSize: searchBarFrame.size, leftInset: leftInset, rightInset: rightInset, transition: transition)
+    }
+    
+    func activate() {
+        self.searchBar.activate()
+    }
+    
+    func deactivate() {
+        self.searchBar.deactivate(clear: false)
+    }
+}
+
+
+final class InviteRequestsSearchItem: ItemListControllerSearch {
+    let context: AccountContext
+    let peerId: EnginePeer.Id
+    let cancel: () -> Void
+    let openPeer: (EnginePeer) -> Void
+    let approveRequest: (EnginePeer) -> Void
+    let denyRequest: (EnginePeer) -> Void
+    let navigateToChat: (EnginePeer) -> Void
+    let pushController: (ViewController) -> Void
+    let presentInGlobalOverlay: (ViewController) -> Void
+    let dismissInput: () -> Void
+    
+    private var updateActivity: ((Bool) -> Void)?
+    private var activity: ValuePromise<Bool> = ValuePromise(ignoreRepeated: false)
+    private let activityDisposable = MetaDisposable()
+    
+    init(context: AccountContext, peerId: EnginePeer.Id, cancel: @escaping () -> Void, openPeer: @escaping (EnginePeer) -> Void, approveRequest: @escaping (EnginePeer) -> Void, denyRequest: @escaping (EnginePeer) -> Void, navigateToChat: @escaping (EnginePeer) -> Void, pushController: @escaping (ViewController) -> Void, dismissInput: @escaping () -> Void, presentInGlobalOverlay: @escaping (ViewController) -> Void) {
+        self.context = context
+        self.peerId = peerId
+        self.cancel = cancel
+        self.openPeer = openPeer
+        self.approveRequest = approveRequest
+        self.denyRequest = denyRequest
+        self.navigateToChat = navigateToChat
+        self.pushController = pushController
+        self.dismissInput = dismissInput
+        self.presentInGlobalOverlay = presentInGlobalOverlay
+        self.activityDisposable.set((activity.get() |> mapToSignal { value -> Signal<Bool, NoError> in
+            if value {
+                return .single(value) |> delay(0.2, queue: Queue.mainQueue())
+            } else {
+                return .single(value)
+            }
+        }).start(next: { [weak self] value in
+            self?.updateActivity?(value)
+        }))
+    }
+    
+    deinit {
+        self.activityDisposable.dispose()
+    }
+    
+    func isEqual(to: ItemListControllerSearch) -> Bool {
+        if let to = to as? InviteRequestsSearchItem {
+            if self.context !== to.context {
+                return false
+            }
+            if self.peerId != to.peerId {
+                return false
+            }
+            return true
+        } else {
+            return false
+        }
+    }
+    
+    func titleContentNode(current: (NavigationBarContentNode & ItemListControllerSearchNavigationContentNode)?) -> (NavigationBarContentNode & ItemListControllerSearchNavigationContentNode)? {
+        let presentationData = self.context.sharedContext.currentPresentationData.with { $0 }
+        if let current = current as? SearchNavigationContentNode {
+            current.updateTheme(presentationData.theme)
+            return current
+        } else {
+            return SearchNavigationContentNode(theme: presentationData.theme, strings: presentationData.strings, cancel: self.cancel, updateActivity: { [weak self] value in
+                self?.updateActivity = value
+            })
+        }
+    }
+    
+    func node(current: ItemListControllerSearchNode?, titleContentNode: (NavigationBarContentNode & ItemListControllerSearchNavigationContentNode)?) -> ItemListControllerSearchNode {
+        return InviteRequestsSearchItemNode(context: self.context, peerId: self.peerId, openPeer: self.openPeer, approveRequest: self.approveRequest, denyRequest: self.denyRequest, navigateToChat: self.navigateToChat, cancel: self.cancel, updateActivity: { [weak self] value in
+            self?.activity.set(value)
+        }, pushController: { [weak self] c in
+            self?.pushController(c)
+        }, dismissInput: self.dismissInput, presentInGlobalOverlay: self.presentInGlobalOverlay)
+    }
+}
+
+private final class InviteRequestsSearchItemNode: ItemListControllerSearchNode {
+    private let containerNode: InviteRequestsSearchContainerNode
+    
+    init(context: AccountContext, peerId: EnginePeer.Id, openPeer: @escaping (EnginePeer) -> Void, approveRequest: @escaping (EnginePeer) -> Void, denyRequest: @escaping (EnginePeer) -> Void, navigateToChat: @escaping (EnginePeer) -> Void, cancel: @escaping () -> Void, updateActivity: @escaping(Bool) -> Void, pushController: @escaping (ViewController) -> Void, dismissInput: @escaping () -> Void, presentInGlobalOverlay: @escaping (ViewController) -> Void) {
+        self.containerNode = InviteRequestsSearchContainerNode(context: context, forceTheme: nil, peerId: peerId, openPeer: { peer in
+            openPeer(peer)
+        }, approveRequest: { peer in
+            approveRequest(peer)
+        }, denyRequest: { peer in
+            denyRequest(peer)
+        }, navigateToChat: { peer in
+            navigateToChat(peer)
+        }, updateActivity: updateActivity, pushController: pushController, presentInGlobalOverlay: presentInGlobalOverlay)
+        self.containerNode.cancel = {
+            cancel()
+        }
+        
+        super.init()
+        
+        self.addSubnode(self.containerNode)
+        
+        self.containerNode.dismissInput = {
+            dismissInput()
+        }
+    }
+    
+    override func queryUpdated(_ query: String) {
+        self.containerNode.searchTextUpdated(text: query)
+    }
+    
+    override func scrollToTop() {
+        self.containerNode.scrollToTop()
+    }
+    
+    override func updateLayout(layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        transition.updateFrame(node: self.containerNode, frame: CGRect(origin: CGPoint(x: 0.0, y: navigationBarHeight), size: CGSize(width: layout.size.width, height: layout.size.height - navigationBarHeight)))
+        self.containerNode.containerLayoutUpdated(layout.withUpdatedSize(CGSize(width: layout.size.width, height: layout.size.height - navigationBarHeight)), navigationBarHeight: 0.0, transition: transition)
+    }
+    
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        if let result = self.containerNode.hitTest(self.view.convert(point, to: self.containerNode.view), with: event) {
+            return result
+        }
+        
+        return super.hitTest(point, with: event)
+    }
+}
+
+
+private final class InviteRequestsSearchContainerInteraction {
+    let openPeer: (EnginePeer) -> Void
+    let approveRequest: (EnginePeer) -> Void
+    let denyRequest: (EnginePeer) -> Void
+    let peerContextAction: (EnginePeer, ASDisplayNode, ContextGesture?) -> Void
+    
+    init(openPeer: @escaping (EnginePeer) -> Void, approveRequest: @escaping (EnginePeer) -> Void, denyRequest: @escaping (EnginePeer) -> Void, peerContextAction: @escaping (EnginePeer, ASDisplayNode, ContextGesture?) -> Void) {
+        self.openPeer = openPeer
+        self.approveRequest = approveRequest
+        self.denyRequest = denyRequest
+        self.peerContextAction = peerContextAction
+    }
+}
+
+private enum InviteRequestsSearchEntryId: Hashable {
+    case placeholder(Int)
+    case request(EnginePeer.Id)
+}
+
+private final class InviteRequestsSearchEntry: Comparable, Identifiable {
+    let index: Int
+    let request: PeerInvitationImportersState.Importer?
+    let dateTimeFormat: PresentationDateTimeFormat
+    let nameDisplayOrder: PresentationPersonNameOrder
+    let isGroup: Bool
+    
+    init(index: Int, request: PeerInvitationImportersState.Importer?, dateTimeFormat: PresentationDateTimeFormat, nameDisplayOrder: PresentationPersonNameOrder, isGroup: Bool) {
+        self.index = index
+        self.request = request
+        self.dateTimeFormat = dateTimeFormat
+        self.nameDisplayOrder = nameDisplayOrder
+        self.isGroup = isGroup
+    }
+    
+    var stableId: InviteRequestsSearchEntryId {
+        if let request = self.request {
+            return .request(request.peer.peerId)
+        } else {
+            return .placeholder(self.index)
+        }
+    }
+    
+    static func ==(lhs: InviteRequestsSearchEntry, rhs: InviteRequestsSearchEntry) -> Bool {
+        return lhs.index == rhs.index && lhs.request == rhs.request && lhs.dateTimeFormat == rhs.dateTimeFormat && lhs.nameDisplayOrder == rhs.nameDisplayOrder && lhs.isGroup == rhs.isGroup
+    }
+    
+    static func <(lhs: InviteRequestsSearchEntry, rhs: InviteRequestsSearchEntry) -> Bool {
+        return lhs.index < rhs.index
+    }
+    
+    func item(context: AccountContext, presentationData: PresentationData, nameSortOrder: PresentationPersonNameOrder, nameDisplayOrder: PresentationPersonNameOrder, interaction: InviteRequestsSearchContainerInteraction) -> ListViewItem {
+        return ItemListInviteRequestItem(context: context, presentationData: ItemListPresentationData(presentationData), dateTimeFormat: dateTimeFormat, nameDisplayOrder: nameDisplayOrder, importer: self.request, isGroup: self.isGroup, sectionId: 0, style: .plain, tapAction: {
+            if let peer = self.request?.peer.peer.flatMap({ EnginePeer($0) }) {
+                interaction.openPeer(peer)
+            }
+        }, addAction: {
+            if let peer = self.request?.peer.peer.flatMap({ EnginePeer($0) }) {
+                interaction.approveRequest(peer)
+            }
+        }, dismissAction: {
+            if let peer = self.request?.peer.peer.flatMap({ EnginePeer($0) }) {
+                interaction.denyRequest(peer)
+            }
+        }, contextAction: { node, gesture in
+            if let peer = self.request?.peer.peer.flatMap({ EnginePeer($0) }) {
+                interaction.peerContextAction(peer, node, gesture)
+            }
+        })
+    }
+}
+
+struct InviteRequestsSearchContainerTransition {
+    let deletions: [ListViewDeleteItem]
+    let insertions: [ListViewInsertItem]
+    let updates: [ListViewUpdateItem]
+    let isSearching: Bool
+    let isEmpty: Bool
+    let query: String
+}
+
+private func inviteRequestsSearchContainerPreparedRecentTransition(from fromEntries: [InviteRequestsSearchEntry], to toEntries: [InviteRequestsSearchEntry], isSearching: Bool, isEmpty: Bool, query: String, context: AccountContext, presentationData: PresentationData, nameSortOrder: PresentationPersonNameOrder, nameDisplayOrder: PresentationPersonNameOrder, interaction: InviteRequestsSearchContainerInteraction) -> InviteRequestsSearchContainerTransition {
+    let (deleteIndices, indicesAndItems, updateIndices) = mergeListsStableWithUpdates(leftList: fromEntries, rightList: toEntries)
+    
+    let deletions = deleteIndices.map { ListViewDeleteItem(index: $0, directionHint: nil) }
+    let insertions = indicesAndItems.map { ListViewInsertItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(context: context, presentationData: presentationData, nameSortOrder: nameSortOrder, nameDisplayOrder: nameDisplayOrder, interaction: interaction), directionHint: nil) }
+    let updates = updateIndices.map { ListViewUpdateItem(index: $0.0, previousIndex: $0.2, item: $0.1.item(context: context, presentationData: presentationData, nameSortOrder: nameSortOrder, nameDisplayOrder: nameDisplayOrder, interaction: interaction), directionHint: nil) }
+    
+    return InviteRequestsSearchContainerTransition(deletions: deletions, insertions: insertions, updates: updates, isSearching: isSearching, isEmpty: isEmpty, query: query)
+}
+
+
+public final class InviteRequestsSearchContainerNode: SearchDisplayControllerContentNode {
+    private let context: AccountContext
+    private let openPeer: (EnginePeer) -> Void
+    
+    private let dimNode: ASDisplayNode
+    private let listNode: ListView
+    
+    private let emptyResultsTitleNode: ImmediateTextNode
+    private let emptyResultsTextNode: ImmediateTextNode
+    
+    private var enqueuedTransitions: [(InviteRequestsSearchContainerTransition, Bool)] = []
+    private var validLayout: (ContainerViewLayout, CGFloat)?
+    
+    private let searchQuery = Promise<String?>()
+    private let emptyQueryDisposable = MetaDisposable()
+    private let searchDisposable = MetaDisposable()
+    
+    private let forceTheme: PresentationTheme?
+    private var presentationData: PresentationData
+    private var presentationDataDisposable: Disposable?
+        
+    private let presentationDataPromise: Promise<PresentationData>
+    
+    private var _hasDim: Bool = false
+    override public var hasDim: Bool {
+        return _hasDim
+    }
+    
+    private var processedPeerIdsPromise = ValuePromise<Set<EnginePeer.Id>>(Set())
+    private var processedPeerIds = Set<EnginePeer.Id>() {
+        didSet {
+            self.processedPeerIdsPromise.set(self.processedPeerIds)
+        }
+    }
+    
+    public init(context: AccountContext, forceTheme: PresentationTheme?, peerId: EnginePeer.Id, openPeer: @escaping (EnginePeer) -> Void, approveRequest: @escaping (EnginePeer) -> Void, denyRequest: @escaping (EnginePeer) -> Void, navigateToChat: @escaping (EnginePeer) -> Void, updateActivity: @escaping (Bool) -> Void, pushController: @escaping (ViewController) -> Void, presentInGlobalOverlay: @escaping (ViewController) -> Void) {
+        self.context = context
+        self.openPeer = openPeer
+        
+        let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+        self.presentationData = presentationData
+        
+        self.forceTheme = forceTheme
+        if let forceTheme = self.forceTheme {
+            self.presentationData = self.presentationData.withUpdated(theme: forceTheme)
+        }
+        self.presentationDataPromise = Promise(self.presentationData)
+        
+        self.dimNode = ASDisplayNode()
+        self.dimNode.backgroundColor = UIColor.black.withAlphaComponent(0.5)
+        
+        self.listNode = ListView()
+        self.listNode.accessibilityPageScrolledString = { row, count in
+            return presentationData.strings.VoiceOver_ScrollStatus(row, count).string
+        }
+        
+        self.emptyResultsTitleNode = ImmediateTextNode()
+        self.emptyResultsTitleNode.displaysAsynchronously = false
+        self.emptyResultsTitleNode.attributedText = NSAttributedString(string: self.presentationData.strings.ChatList_Search_NoResults, font: Font.semibold(17.0), textColor: self.presentationData.theme.list.freeTextColor)
+        self.emptyResultsTitleNode.textAlignment = .center
+        self.emptyResultsTitleNode.isHidden = true
+        
+        self.emptyResultsTextNode = ImmediateTextNode()
+        self.emptyResultsTextNode.displaysAsynchronously = false
+        self.emptyResultsTextNode.maximumNumberOfLines = 0
+        self.emptyResultsTextNode.textAlignment = .center
+        self.emptyResultsTextNode.isHidden = true
+        
+        super.init()
+                
+        self.listNode.backgroundColor = self.presentationData.theme.chatList.backgroundColor
+        self.listNode.isHidden = true
+        
+        self._hasDim = true
+        
+        self.addSubnode(self.dimNode)
+        self.addSubnode(self.listNode)
+        
+        self.addSubnode(self.emptyResultsTitleNode)
+        self.addSubnode(self.emptyResultsTextNode)
+        
+    
+        let interaction = InviteRequestsSearchContainerInteraction(openPeer: { [weak self] peer in
+            openPeer(peer)
+            self?.listNode.clearHighlightAnimated(true)
+        }, approveRequest: { [weak self] peer in
+            approveRequest(peer)
+            self?.processedPeerIds.insert(peer.id)
+        }, denyRequest: { [weak self] peer in
+            denyRequest(peer)
+            self?.processedPeerIds.insert(peer.id)
+        }, peerContextAction: { [weak self] peer, node, gesture in
+            guard let node = node as? ContextExtractedContentContainingNode else {
+                return
+            }
+            
+            let _ = (context.engine.data.get(
+                TelegramEngine.EngineData.Item.Peer.Peer(id: peerId)
+            )
+            |> deliverOnMainQueue).start(next: { [weak self] peer in
+                guard let peer = peer else {
+                    return
+                }
+                let presentationData = context.sharedContext.currentPresentationData.with { $0 }
+                let addString: String
+                if case let .channel(channel) = peer, case .broadcast = channel.info {
+                    addString = presentationData.strings.MemberRequests_AddToChannel
+                } else {
+                    addString = presentationData.strings.MemberRequests_AddToGroup
+                }
+                var items: [ContextMenuItem] = []
+
+                items.append(.action(ContextMenuActionItem(text: addString, icon: { theme in
+                    return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/AddUser"), color: theme.contextMenu.primaryColor)
+                }, action: { [weak self] _, f in
+                    f(.dismissWithoutContent)
+                    
+                    approveRequest(peer)
+                    self?.processedPeerIds.insert(peer.id)
+                })))
+                
+                items.append(.action(ContextMenuActionItem(text: presentationData.strings.ContactList_Context_SendMessage, icon: { theme in
+                    return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Message"), color: theme.contextMenu.primaryColor)
+                }, action: { _, f in
+                    f(.dismissWithoutContent)
+                    
+                    navigateToChat(peer)
+                })))
+                
+                items.append(.action(ContextMenuActionItem(text: presentationData.strings.MemberRequests_Dismiss, textColor: .destructive, icon: { theme in
+                    return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.destructiveColor)
+                }, action: { [weak self] _, f in
+                    f(.dismissWithoutContent)
+                    
+                    denyRequest(peer)
+                    self?.processedPeerIds.insert(peer.id)
+                })))
+                
+                let dismissPromise = ValuePromise<Bool>(false)
+                let source = InviteRequestsContextExtractedContentSource(sourceNode: node, keepInPlace: false, blurBackground: true, centerVertically: true, shouldBeDismissed: dismissPromise.get())
+        //        sourceNode.requestDismiss = {
+        //            dismissPromise.set(true)
+        //        }
+                
+                let contextController = ContextController(presentationData: presentationData, source: .extracted(source), items: .single(ContextController.Items(content: .list(items))), gesture: gesture)
+                presentInGlobalOverlay(contextController)
+            })
+        })
+        
+        let presentationDataPromise = self.presentationDataPromise
+        
+        let previousRequestsContext = Atomic<PeerInvitationImportersContext?>(value: nil)
+        
+        let processedPeerIds = self.processedPeerIdsPromise
+        let searchQuery = self.searchQuery.get()
+        |> mapToSignal { query -> Signal<String?, NoError> in
+            if let query = query, !query.isEmpty {
+                if query.count == 1 {
+                    return .single(" ")
+                } else {
+                    return (.complete() |> delay(0.6, queue: Queue.mainQueue()))
+                    |> then(.single(query))
+                }
+            } else {
+                return .single(query)
+            }
+        }
+        
+        let foundItems = combineLatest(searchQuery, context.account.postbox.peerView(id: peerId) |> take(1))
+        |> mapToSignal { query, peerView -> Signal<[InviteRequestsSearchEntry]?, NoError> in
+            guard let query = query, !query.isEmpty, let peer = peerViewMainPeer(peerView) else {
+                return .single(nil)
+            }
+            
+            let signal: Signal<PeerInvitationImportersState, NoError>
+            if query == " " {
+                signal = .single(PeerInvitationImportersState.Loading)
+            } else {
+                updateActivity(true)
+                let requestsContext = context.engine.peers.peerInvitationImporters(peerId: peerId, subject: .requests(query: query))
+                let _ = previousRequestsContext.swap(requestsContext)
+                signal = requestsContext.state
+            }
+                                    
+            return combineLatest(signal, presentationDataPromise.get(), processedPeerIds.get())
+            |> mapToSignal { state, presentationData, processedPeerIds -> Signal<[InviteRequestsSearchEntry]?, NoError> in
+                let isGroup: Bool
+                if let channel = peer as? TelegramChannel, case .broadcast = channel.info {
+                    isGroup = false
+                } else {
+                    isGroup = true
+                }
+                
+                var entries: [InviteRequestsSearchEntry] = []
+                var index = 0
+                if !state.hasLoadedOnce {
+                    for _ in 0 ..< 2 {
+                        entries.append(InviteRequestsSearchEntry(index: index, request: nil, dateTimeFormat: presentationData.dateTimeFormat, nameDisplayOrder: presentationData.nameDisplayOrder, isGroup: isGroup))
+                        index += 1
+                    }
+                    return .single(entries)
+                }
+                
+                for importer in state.importers {
+                    if processedPeerIds.contains(importer.peer.peerId) {
+                        continue
+                    }
+                    entries.append(InviteRequestsSearchEntry(index: index, request: importer, dateTimeFormat: presentationData.dateTimeFormat, nameDisplayOrder: presentationData.nameDisplayOrder, isGroup: isGroup))
+                    index += 1
+                }
+                return .single(entries)
+            }
+        }
+        
+        let previousSearchItems = Atomic<[InviteRequestsSearchEntry]?>(value: nil)
+    
+        self.searchDisposable.set((combineLatest(searchQuery, foundItems, self.presentationDataPromise.get())
+        |> deliverOnMainQueue).start(next: { [weak self] query, entries, presentationData in
+            if let strongSelf = self {
+                let previousEntries = previousSearchItems.swap(entries)
+                updateActivity(false)
+                let firstTime = previousEntries == nil
+                let transition = inviteRequestsSearchContainerPreparedRecentTransition(from: previousEntries ?? [], to: entries ?? [], isSearching: entries != nil, isEmpty: entries?.isEmpty ?? false, query: query ?? "", context: context, presentationData: presentationData, nameSortOrder: presentationData.nameSortOrder, nameDisplayOrder: presentationData.nameDisplayOrder, interaction: interaction)
+                strongSelf.enqueueTransition(transition, firstTime: firstTime)
+            }
+        }))
+        
+        self.presentationDataDisposable = (context.sharedContext.presentationData
+        |> deliverOnMainQueue).start(next: { [weak self] presentationData in
+            if let strongSelf = self {
+                var presentationData = presentationData
+                
+                let previousTheme = strongSelf.presentationData.theme
+                let previousStrings = strongSelf.presentationData.strings
+                
+                if let forceTheme = strongSelf.forceTheme {
+                    presentationData = presentationData.withUpdated(theme: forceTheme)
+                }
+                
+                strongSelf.presentationData = presentationData
+                
+                if previousTheme !== presentationData.theme || previousStrings !== presentationData.strings {
+                    strongSelf.updateThemeAndStrings(theme: presentationData.theme, strings: presentationData.strings)
+                }
+            }
+        })
+        
+        self.listNode.beganInteractiveDragging = { [weak self] _ in
+            self?.dismissInput?()
+        }
+    }
+    
+    deinit {
+        self.searchDisposable.dispose()
+        self.presentationDataDisposable?.dispose()
+    }
+    
+    override public func didLoad() {
+        super.didLoad()
+        
+        self.dimNode.view.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(self.dimTapGesture(_:))))
+    }
+    
+    private func updateThemeAndStrings(theme: PresentationTheme, strings: PresentationStrings) {
+        self.listNode.backgroundColor = theme.chatList.backgroundColor
+    }
+    
+    override public func searchTextUpdated(text: String) {
+        if text.isEmpty {
+            self.searchQuery.set(.single(nil))
+        } else {
+            self.searchQuery.set(.single(text))
+        }
+    }
+    
+    private func enqueueTransition(_ transition: InviteRequestsSearchContainerTransition, firstTime: Bool) {
+        self.enqueuedTransitions.append((transition, firstTime))
+        
+        if let _ = self.validLayout {
+            while !self.enqueuedTransitions.isEmpty {
+                self.dequeueTransition()
+            }
+        }
+    }
+    
+    private func dequeueTransition() {
+        if let (transition, _) = self.enqueuedTransitions.first {
+            self.enqueuedTransitions.remove(at: 0)
+            
+            var options = ListViewDeleteAndInsertOptions()
+            options.insert(.PreferSynchronousDrawing)
+            options.insert(.PreferSynchronousResourceLoading)
+            
+            let isSearching = transition.isSearching
+            self.listNode.transaction(deleteIndices: transition.deletions, insertIndicesAndItems: transition.insertions, updateIndicesAndItems: transition.updates, options: options, updateSizeAndInsets: nil, updateOpaqueState: nil, completion: { [weak self] _ in
+                guard let strongSelf = self else {
+                    return
+                }
+                
+                strongSelf.listNode.isHidden = !isSearching
+                strongSelf.dimNode.isHidden = transition.isSearching
+                
+                strongSelf.emptyResultsTextNode.attributedText = NSAttributedString(string: strongSelf.presentationData.strings.ChatList_Search_NoResultsQueryDescription(transition.query).string, font: Font.regular(15.0), textColor: strongSelf.presentationData.theme.list.freeTextColor)
+                
+                let emptyResults = transition.isSearching && transition.isEmpty
+                strongSelf.emptyResultsTitleNode.isHidden = !emptyResults
+                strongSelf.emptyResultsTextNode.isHidden = !emptyResults
+                
+                if let (layout, navigationBarHeight) = strongSelf.validLayout {
+                    strongSelf.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: .immediate)
+                }
+            })
+        }
+    }
+    
+    override public func containerLayoutUpdated(_ layout: ContainerViewLayout, navigationBarHeight: CGFloat, transition: ContainedViewLayoutTransition) {
+        super.containerLayoutUpdated(layout, navigationBarHeight: navigationBarHeight, transition: transition)
+        
+        let hadValidLayout = self.validLayout == nil
+        self.validLayout = (layout, navigationBarHeight)
+        
+        let (duration, curve) = listViewAnimationDurationAndCurve(transition: transition)
+        
+        var insets = layout.insets(options: [.input])
+        insets.top += navigationBarHeight
+        insets.left += layout.safeInsets.left
+        insets.right += layout.safeInsets.right
+        
+        let topInset = navigationBarHeight
+        transition.updateFrame(node: self.dimNode, frame: CGRect(origin: CGPoint(x: 0.0, y: topInset), size: CGSize(width: layout.size.width, height: layout.size.height - topInset)))
+        
+        self.listNode.frame = CGRect(origin: CGPoint(), size: layout.size)
+        self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous], scrollToItem: nil, updateSizeAndInsets: ListViewUpdateSizeAndInsets(size: layout.size, insets: insets, duration: duration, curve: curve), stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+        
+        let padding: CGFloat = 16.0
+        let emptyTitleSize = self.emptyResultsTitleNode.updateLayout(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - padding * 2.0, height: CGFloat.greatestFiniteMagnitude))
+        let emptyTextSize = self.emptyResultsTextNode.updateLayout(CGSize(width: layout.size.width - layout.safeInsets.left - layout.safeInsets.right - padding * 2.0, height: CGFloat.greatestFiniteMagnitude))
+        
+        let emptyTextSpacing: CGFloat = 8.0
+        let emptyTotalHeight = emptyTitleSize.height + emptyTextSize.height + emptyTextSpacing
+        let emptyTitleY = navigationBarHeight + floorToScreenPixels((layout.size.height - navigationBarHeight - max(insets.bottom, layout.intrinsicInsets.bottom) - emptyTotalHeight) / 2.0)
+        
+        transition.updateFrame(node: self.emptyResultsTitleNode, frame: CGRect(origin: CGPoint(x: layout.safeInsets.left + padding + (layout.size.width - layout.safeInsets.left - layout.safeInsets.right - padding * 2.0 - emptyTitleSize.width) / 2.0, y: emptyTitleY), size: emptyTitleSize))
+        transition.updateFrame(node: self.emptyResultsTextNode, frame: CGRect(origin: CGPoint(x: layout.safeInsets.left + padding + (layout.size.width - layout.safeInsets.left - layout.safeInsets.right - padding * 2.0 - emptyTextSize.width) / 2.0, y: emptyTitleY + emptyTitleSize.height + emptyTextSpacing), size: emptyTextSize))
+        
+        if !hadValidLayout {
+            while !self.enqueuedTransitions.isEmpty {
+                self.dequeueTransition()
+            }
+        }
+    }
+    
+    override public func scrollToTop() {
+        self.listNode.transaction(deleteIndices: [], insertIndicesAndItems: [], updateIndicesAndItems: [], options: [.Synchronous, .LowLatency], scrollToItem: ListViewScrollToItem(index: 0, position: .top(0.0), animated: true, curve: .Default(duration: nil), directionHint: .Up), updateSizeAndInsets: nil, stationaryItemRange: nil, updateOpaqueState: nil, completion: { _ in })
+    }
+    
+    @objc func dimTapGesture(_ recognizer: UITapGestureRecognizer) {
+        if case .ended = recognizer.state {
+            self.cancel?()
+        }
+    }
+    
+    override public func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        guard let result = self.view.hitTest(point, with: event) else {
+            return nil
+        }
+        if result === self.view {
+            return nil
+        }
+        return result
+    }
+}

submodules/InviteLinksUI/Sources/ItemListFolderInviteLinkItem.swift

@@ -0,0 +1,639 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import AccountContext
+import TelegramPresentationData
+import ItemListUI
+import SolidRoundedButtonNode
+import AnimatedAvatarSetNode
+import ShimmerEffect
+import TelegramCore
+
+private func actionButtonImage(color: UIColor) -> UIImage? {
+    return generateImage(CGSize(width: 24.0, height: 24.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: CGPoint(), size: size))
+        
+        context.setFillColor(color.cgColor)
+        context.fillEllipse(in: CGRect(origin: CGPoint(), size: size))
+        
+        context.setBlendMode(.clear)
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 4.0, y: 10.0), size: CGSize(width: 4.0, height: 4.0)))
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 10.0, y: 10.0), size: CGSize(width: 4.0, height: 4.0)))
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 16.0, y: 10.0), size: CGSize(width: 4.0, height: 4.0)))
+    })
+}
+
+public class ItemListFolderInviteLinkItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let invite: ExportedChatFolderLink?
+    let count: Int32
+    let peers: [EnginePeer]
+    let displayButton: Bool
+    let enableButton: Bool
+    let buttonTitle: String
+    let secondaryButtonTitle: String?
+    let displayImporters: Bool
+    let buttonColor: UIColor?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let copyAction: (() -> Void)?
+    let shareAction: (() -> Void)?
+    let secondaryAction: (() -> Void)?
+    let contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?
+    let viewAction: (() -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        systemStyle: ItemListSystemStyle = .legacy,
+        invite: ExportedChatFolderLink?,
+        count: Int32,
+        peers: [EnginePeer],
+        displayButton: Bool,
+        enableButton: Bool,
+        buttonTitle: String,
+        secondaryButtonTitle: String?,
+        displayImporters: Bool,
+        buttonColor: UIColor?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        copyAction: (() -> Void)?,
+        shareAction: (() -> Void)?,
+        secondaryAction: (() -> Void)?,
+        contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?,
+        viewAction: (() -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.invite = invite
+        self.count = count
+        self.peers = peers
+        self.displayButton = displayButton
+        self.enableButton = enableButton
+        self.buttonTitle = buttonTitle
+        self.secondaryButtonTitle = secondaryButtonTitle
+        self.displayImporters = displayImporters
+        self.buttonColor = buttonColor
+        self.sectionId = sectionId
+        self.style = style
+        self.copyAction = copyAction
+        self.shareAction = shareAction
+        self.secondaryAction = secondaryAction
+        self.contextAction = contextAction
+        self.viewAction = viewAction
+        self.tag = tag
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = ItemListFolderInviteLinkItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListFolderInviteLinkItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = false
+}
+
+public class ItemListFolderInviteLinkItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let fieldNode: ASImageNode
+    private let addressNode: TextNode
+    private let fieldButtonNode: HighlightTrackingButtonNode
+    private let referenceContainerNode: ContextReferenceContentNode
+    private let containerNode: ContextControllerSourceNode
+    private let addressButtonNode: HighlightTrackingButtonNode
+    private let addressButtonIconNode: ASImageNode
+    private var addressShimmerNode: ShimmerEffectNode?
+    private var shareButtonNode: SolidRoundedButtonNode?
+    private var secondaryButtonNode: SolidRoundedButtonNode?
+    
+    private let avatarsButtonNode: HighlightTrackingButtonNode
+    private let avatarsContext: AnimatedAvatarSetContext
+    private var avatarsContent: AnimatedAvatarSetContext.Content?
+    private let avatarsNode: AnimatedAvatarSetNode
+    private let invitedPeersNode: TextNode
+    private var shimmerNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: ItemListFolderInviteLinkItem?
+    
+    override public var canBeSelected: Bool {
+        return false
+    }
+    
+    public var tag: ItemListItemTag? {
+        return self.item?.tag
+    }
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.fieldNode = ASImageNode()
+        self.fieldNode.displaysAsynchronously = false
+        self.fieldNode.displayWithoutProcessing = true
+        
+        self.addressNode = TextNode()
+        self.addressNode.isUserInteractionEnabled = false
+        
+        self.fieldButtonNode = HighlightTrackingButtonNode()
+    
+        self.containerNode = ContextControllerSourceNode()
+        self.containerNode.animateScale = false
+        self.referenceContainerNode = ContextReferenceContentNode()
+        
+        self.addressButtonNode = HighlightTrackingButtonNode()
+        self.addressButtonIconNode = ASImageNode()
+        self.addressButtonIconNode.contentMode = .center
+        self.addressButtonIconNode.displaysAsynchronously = false
+        self.addressButtonIconNode.displayWithoutProcessing = true
+        
+        self.avatarsButtonNode = HighlightTrackingButtonNode()
+        self.avatarsContext = AnimatedAvatarSetContext()
+        self.avatarsNode = AnimatedAvatarSetNode()
+        self.invitedPeersNode = TextNode()
+                
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.fieldNode)
+        self.addSubnode(self.addressNode)
+        self.addSubnode(self.fieldButtonNode)
+        self.addSubnode(self.avatarsNode)
+        self.addSubnode(self.invitedPeersNode)
+        self.addSubnode(self.avatarsButtonNode)
+        
+        self.containerNode.addSubnode(self.referenceContainerNode)
+        self.referenceContainerNode.addSubnode(self.addressButtonIconNode)
+        self.referenceContainerNode.addSubnode(self.addressButtonNode)
+        self.addSubnode(self.containerNode)
+        
+        self.addSubnode(self.activateArea)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            if let strongSelf = self, let item = strongSelf.item {
+                item.contextAction?(strongSelf.referenceContainerNode, gesture)
+            }
+        }
+        
+        self.fieldButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.addressNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.addressNode.alpha = 0.4
+                } else {
+                    strongSelf.addressNode.alpha = 1.0
+                    strongSelf.addressNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.fieldButtonNode.addTarget(self, action: #selector(self.fieldButtonPressed), forControlEvents: .touchUpInside)
+        
+        self.addressButtonNode.addTarget(self, action: #selector(self.addressButtonPressed), forControlEvents: .touchUpInside)
+        self.addressButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.addressButtonIconNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.addressButtonIconNode.alpha = 0.4
+                } else {
+                    strongSelf.addressButtonIconNode.alpha = 1.0
+                    strongSelf.addressButtonIconNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.shareButtonNode?.pressed = { [weak self] in
+            if let strongSelf = self, let item = strongSelf.item {
+                item.shareAction?()
+            }
+        }
+        self.avatarsButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.avatarsNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.invitedPeersNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.avatarsNode.alpha = 0.4
+                    strongSelf.invitedPeersNode.alpha = 0.4
+                } else {
+                    strongSelf.avatarsNode.alpha = 1.0
+                    strongSelf.invitedPeersNode.alpha = 1.0
+                    strongSelf.avatarsNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                    strongSelf.invitedPeersNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.avatarsButtonNode.addTarget(self, action: #selector(self.avatarsButtonPressed), forControlEvents: .touchUpInside)
+    }
+    
+    @objc private func fieldButtonPressed() {
+        if let item = self.item {
+            item.copyAction?()
+        }
+    }
+    
+    @objc private func addressButtonPressed() {
+        if let item = self.item {
+            item.contextAction?(self.referenceContainerNode, nil)
+        }
+    }
+    
+    @objc private func avatarsButtonPressed() {
+        if let item = self.item {
+            item.viewAction?()
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListFolderInviteLinkItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeAddressLayout = TextNode.asyncLayout(self.addressNode)
+        let makeInvitedPeersLayout = TextNode.asyncLayout(self.invitedPeersNode)
+        
+        let currentItem = self.item
+        let avatarsContext = self.avatarsContext
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            let leftInset = 16.0 + params.leftInset
+            let rightInset = 16.0 + params.rightInset
+            
+            let titleColor: UIColor
+            titleColor = item.presentationData.theme.list.itemInputField.primaryColor
+            
+            let alignCentrally = !"".isEmpty//!(item.invite?.link?.contains("joinchat") ?? true)
+            
+            let addressFont = Font.regular(!alignCentrally && params.width == 320 ? floor(item.presentationData.fontSize.itemListBaseFontSize * 15.0 / 17.0) : item.presentationData.fontSize.itemListBaseFontSize)
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            
+            let constrainedWidth = alignCentrally ? params.width - leftInset - rightInset - 90.0 : params.width - leftInset - rightInset - 60.0
+            
+            let (addressLayout, addressApply) = makeAddressLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.invite.flatMap({ $0.link.replacingOccurrences(of: "https://", with: "") }) ?? "", font: addressFont, textColor: titleColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .middle, constrainedSize: CGSize(width: constrainedWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let subtitle: String
+            let subtitleColor: UIColor
+            if item.count > 0 {
+                subtitle = item.presentationData.strings.InviteLink_PeopleJoined(item.count)
+                subtitleColor = item.presentationData.theme.list.itemAccentColor
+            } else {
+                subtitle = item.presentationData.strings.InviteLink_PeopleJoinedNone
+                subtitleColor = item.presentationData.theme.list.itemSecondaryTextColor
+            }
+            
+            let (invitedPeersLayout, invitedPeersApply) = makeInvitedPeersLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: subtitle, font: titleFont, textColor: subtitleColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - params.rightInset - 20.0 - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let avatarsContent = avatarsContext.update(peers: item.peers, animated: false)
+            
+            let verticalInset: CGFloat = 16.0
+            let fieldHeight: CGFloat = 52.0
+            let fieldSpacing: CGFloat = 16.0
+            let buttonHeight: CGFloat = 52.0
+            
+            var height = verticalInset * 2.0 + fieldHeight + fieldSpacing + buttonHeight + 54.0
+            
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = .clear
+                insets = UIEdgeInsets()
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            if !item.displayImporters {
+                height -= 57.0
+            }
+            if !item.displayButton {
+                height -= 63.0
+            }
+            
+            contentSize = CGSize(width: params.width, height: height)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.avatarsContent = avatarsContent
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+//                    strongSelf.activateArea.accessibilityLabel = item.title
+//                    strongSelf.activateArea.accessibilityValue = item.label
+                    strongSelf.activateArea.accessibilityTraits = []
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.fieldNode.image = generateStretchableFilledCircleImage(diameter: 52.0, color: item.presentationData.theme.list.itemInputField.backgroundColor)
+                        strongSelf.addressButtonIconNode.image = actionButtonImage(color: item.presentationData.theme.list.itemInputField.controlColor)
+                    }
+                                        
+                    let _ = addressApply()
+                    let _ = invitedPeersApply()
+                    
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        if strongSelf.backgroundNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                        }
+                        if strongSelf.topStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                        }
+                        if strongSelf.maskNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                        }
+                        
+                        let hasCorners = itemListHasRoundedBlockLayout(params)
+                        var hasTopCorners = false
+                        var hasBottomCorners = false
+                        switch neighbors.top {
+                            case .sameSection(false):
+                                strongSelf.topStripeNode.isHidden = true
+                            default:
+                                hasTopCorners = true
+                                strongSelf.topStripeNode.isHidden = hasCorners
+                        }
+                        let bottomStripeInset: CGFloat
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = leftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 0.0
+                                hasBottomCorners = true
+                                strongSelf.bottomStripeNode.isHidden = hasCorners
+                        }
+                        
+                        strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                        strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    }
+                    
+                    let fieldFrame = CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: CGSize(width: params.width - leftInset - rightInset, height: fieldHeight))
+                    strongSelf.fieldNode.frame = fieldFrame
+                    strongSelf.fieldButtonNode.frame = fieldFrame
+                    
+                    strongSelf.addressNode.frame = CGRect(origin: CGPoint(x: fieldFrame.minX + (alignCentrally ? floorToScreenPixels((fieldFrame.width - addressLayout.size.width) / 2.0) : 14.0), y: fieldFrame.minY + floorToScreenPixels((fieldFrame.height - addressLayout.size.height) / 2.0) + 1.0), size: addressLayout.size)
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(x: params.width - rightInset - 38.0 - 14.0, y: verticalInset), size: CGSize(width: 52.0, height: 52.0))
+                    strongSelf.addressButtonNode.frame = strongSelf.containerNode.bounds
+                    strongSelf.referenceContainerNode.frame =  strongSelf.containerNode.bounds
+                    strongSelf.addressButtonIconNode.frame = strongSelf.containerNode.bounds
+                                                           
+                    let shareButtonNode: SolidRoundedButtonNode
+                    if let currentShareButtonNode = strongSelf.shareButtonNode {
+                        shareButtonNode = currentShareButtonNode
+                    } else {
+                        let buttonTheme: SolidRoundedButtonTheme
+                        if let buttonColor = item.buttonColor {
+                            buttonTheme = SolidRoundedButtonTheme(backgroundColor: buttonColor, foregroundColor: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                        } else {
+                            buttonTheme = SolidRoundedButtonTheme(theme: item.presentationData.theme)
+                        }
+                        shareButtonNode = SolidRoundedButtonNode(theme: buttonTheme, glass: item.systemStyle == .glass, height: buttonHeight, cornerRadius: buttonHeight * 0.5)
+                        shareButtonNode.pressed = { [weak self] in
+                            self?.item?.shareAction?()
+                        }
+                        strongSelf.addSubnode(shareButtonNode)
+                        strongSelf.shareButtonNode = shareButtonNode
+                    }
+                    shareButtonNode.title = item.buttonTitle
+                    
+                    if let secondaryButtonTitle = item.secondaryButtonTitle {
+                        let secondaryButtonNode: SolidRoundedButtonNode
+                        if let current = strongSelf.secondaryButtonNode {
+                            secondaryButtonNode = current
+                        } else {
+                            let buttonTheme: SolidRoundedButtonTheme
+                            if let buttonColor = item.buttonColor {
+                                buttonTheme = SolidRoundedButtonTheme(backgroundColor: buttonColor, foregroundColor: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                            } else {
+                                buttonTheme = SolidRoundedButtonTheme(theme: item.presentationData.theme)
+                            }
+                            secondaryButtonNode = SolidRoundedButtonNode(theme: buttonTheme, glass: item.systemStyle == .glass, height: buttonHeight, cornerRadius: buttonHeight * 0.5)
+                            secondaryButtonNode.pressed = { [weak self] in
+                                self?.item?.secondaryAction?()
+                            }
+                            strongSelf.addSubnode(secondaryButtonNode)
+                            strongSelf.secondaryButtonNode = secondaryButtonNode
+                        }
+                        secondaryButtonNode.title = secondaryButtonTitle
+                    } else {
+                        if let secondaryButtonNode = strongSelf.secondaryButtonNode {
+                            strongSelf.secondaryButtonNode = nil
+                            secondaryButtonNode.removeFromSupernode()
+                        }
+                    }
+                    
+                    var buttonWidth = contentSize.width - leftInset - rightInset
+                    let totalButtonWidth = buttonWidth
+                    let buttonSpacing: CGFloat = 8.0
+                    if strongSelf.secondaryButtonNode != nil {
+                        buttonWidth = floor((buttonWidth - 8.0) / 2.0)
+                    }
+                    
+                    let _ = shareButtonNode.updateLayout(width: buttonWidth, transition: .immediate)
+                    shareButtonNode.frame = CGRect(x: leftInset, y: verticalInset + fieldHeight + fieldSpacing, width: buttonWidth, height: buttonHeight)
+                    
+                    if let secondaryButtonNode = strongSelf.secondaryButtonNode {
+                        let _ = secondaryButtonNode.updateLayout(width: totalButtonWidth - buttonWidth - buttonSpacing, transition: .immediate)
+                        secondaryButtonNode.frame = CGRect(x: leftInset + buttonWidth + buttonSpacing, y: verticalInset + fieldHeight + fieldSpacing, width: totalButtonWidth - buttonWidth - buttonSpacing, height: buttonHeight)
+                    }
+                    
+                    var totalWidth = invitedPeersLayout.size.width
+                    var leftOrigin: CGFloat = floorToScreenPixels((params.width - invitedPeersLayout.size.width) / 2.0)
+                    let avatarSpacing: CGFloat = 21.0
+                    if let avatarsContent = strongSelf.avatarsContent {
+                        let avatarsSize = strongSelf.avatarsNode.update(context: item.context, content: avatarsContent, itemSize: CGSize(width: 32.0, height: 32.0), animated: true, synchronousLoad: true)
+                        
+                        if !avatarsSize.width.isZero {
+                            totalWidth += avatarsSize.width + avatarSpacing
+                        }
+                        
+                        let avatarsNodeFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - totalWidth) / 2.0), y: fieldFrame.maxY + 87.0), size: avatarsSize)
+                        strongSelf.avatarsNode.frame = avatarsNodeFrame
+                        if !avatarsSize.width.isZero {
+                            leftOrigin = avatarsNodeFrame.maxX + avatarSpacing
+                        }
+                    }
+                    
+                    strongSelf.invitedPeersNode.frame = CGRect(origin: CGPoint(x: leftOrigin, y: fieldFrame.maxY + 92.0), size: invitedPeersLayout.size)
+                    
+                    strongSelf.avatarsButtonNode.frame = CGRect(x: floorToScreenPixels((params.width - totalWidth) / 2.0), y: fieldFrame.maxY + 87.0, width: totalWidth, height: 32.0)
+                    strongSelf.avatarsButtonNode.isUserInteractionEnabled = !item.peers.isEmpty && item.invite != nil
+                    
+                    strongSelf.addressButtonNode.isUserInteractionEnabled = item.invite != nil
+                    strongSelf.fieldButtonNode.isUserInteractionEnabled = item.invite != nil
+                    strongSelf.addressButtonIconNode.alpha = item.invite != nil ? 1.0 : 0.0
+                    
+                    strongSelf.shareButtonNode?.isUserInteractionEnabled = item.enableButton
+                    strongSelf.shareButtonNode?.alpha = item.enableButton ? 1.0 : 0.4
+                    strongSelf.shareButtonNode?.isHidden = !item.displayButton
+                    strongSelf.avatarsButtonNode.isHidden = !item.displayImporters
+                    strongSelf.avatarsNode.isHidden = !item.displayImporters || item.invite == nil
+                    strongSelf.invitedPeersNode.isHidden = !item.displayImporters || item.invite == nil
+                    
+                    if item.invite == nil {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.shimmerNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.shimmerNode = shimmerNode
+                            strongSelf.insertSubnode(shimmerNode, belowSubnode: strongSelf.fieldNode)
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+                        
+                        if itemListHasRoundedBlockLayout(params) {
+                            shimmerNode.clipsToBounds = true
+                            shimmerNode.cornerRadius = 11.0
+                        } else {
+                            shimmerNode.cornerRadius = 0.0
+                        }
+                        
+                        let lineWidth: CGFloat = 180.0
+                        let lineDiameter: CGFloat = 12.0
+                        let titleFrame = strongSelf.invitedPeersNode.frame
+                        
+                        var shapes: [ShimmerEffectNode.Shape] = []
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: floor(titleFrame.center.x - lineWidth / 2.0), y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: lineWidth, diameter: lineDiameter))
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: layout.contentSize)
+                        
+                        let addressShimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.addressShimmerNode {
+                            addressShimmerNode = current
+                        } else {
+                            addressShimmerNode = ShimmerEffectNode()
+                            strongSelf.addressShimmerNode = addressShimmerNode
+                            strongSelf.insertSubnode(addressShimmerNode, aboveSubnode: strongSelf.fieldNode)
+                        }
+                        addressShimmerNode.frame = strongSelf.fieldNode.frame.insetBy(dx: 18.0, dy: 0.0)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            addressShimmerNode.updateAbsoluteRect(CGRect(x: rect.minX + strongSelf.fieldNode.frame.minX + 18.0, y: rect.minY + strongSelf.fieldNode.frame.minY, width: strongSelf.fieldNode.frame.width - 18.0 * 2.0, height: strongSelf.fieldNode.frame.height), within: size)
+                        }
+                        
+                        let addressLineWidth: CGFloat = strongSelf.fieldNode.frame.width - 100.0
+                        var addressShapes: [ShimmerEffectNode.Shape] = []
+                        addressShapes.append(.roundedRectLine(startPoint: CGPoint(x: floor(addressShimmerNode.frame.width / 2.0 - addressLineWidth / 2.0), y: 16.0 + floor((22.0 - lineDiameter) / 2.0)), width: addressLineWidth, diameter: lineDiameter))
+                        addressShimmerNode.update(backgroundColor: item.presentationData.theme.list.itemInputField.backgroundColor, foregroundColor: item.presentationData.theme.list.itemInputField.controlColor.mixedWith(item.presentationData.theme.list.itemInputField.backgroundColor, alpha: 0.7), shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: addressShapes, size: addressShimmerNode.frame.size)
+
+                    } else {
+                        if let shimmerNode = strongSelf.shimmerNode {
+                            strongSelf.shimmerNode = nil
+                            shimmerNode.removeFromSupernode()
+                        }
+                        if let shimmerNode = strongSelf.addressShimmerNode {
+                            strongSelf.shimmerNode = nil
+                            shimmerNode.removeFromSupernode()
+                        }
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.addressShimmerNode {
+            shimmerNode.updateAbsoluteRect(CGRect(x: rect.minX + self.fieldNode.frame.minX + 18.0, y: rect.minY + self.fieldNode.frame.minY, width: self.fieldNode.frame.width - 18.0 * 2.0, height: self.fieldNode.frame.height), within: containerSize)
+        }
+        if let shimmerNode = self.shimmerNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+}

submodules/InviteLinksUI/Sources/ItemListFolderInviteLinkListItem.swift

@@ -0,0 +1,791 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import ShimmerEffect
+import TelegramCore
+
+private enum ItemBackgroundColor: Equatable {
+    case blue
+    case green
+    case yellow
+    case red
+    case gray
+    
+    var colors: (top: UIColor, bottom: UIColor, text: UIColor) {
+        switch self {
+            case .blue:
+                return (UIColor(rgb: 0x00b5f7), UIColor(rgb: 0x00b2f6), UIColor(rgb: 0xa7f4ff))
+            case .green:
+                return (UIColor(rgb: 0x4aca62), UIColor(rgb: 0x43c85c), UIColor(rgb: 0xc5ffe6))
+            case .yellow:
+                return (UIColor(rgb: 0xf8a953), UIColor(rgb: 0xf7a64e), UIColor(rgb: 0xfeffd7))
+            case .red:
+                return (UIColor(rgb: 0xf2656a), UIColor(rgb: 0xf25f65), UIColor(rgb: 0xffd3de))
+            case .gray:
+                return (UIColor(rgb: 0xa8b2bb), UIColor(rgb: 0xa2abb4), UIColor(rgb: 0xe3e6e8))
+        }
+    }
+}
+
+public class ItemListFolderInviteLinkListItem: ListViewItem, ItemListItem {
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let invite: ExportedChatFolderLink?
+    let share: Bool
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let tapAction: ((ExportedChatFolderLink) -> Void)?
+    let removeAction: ((ExportedChatFolderLink) -> Void)?
+    let contextAction: ((ExportedChatFolderLink, ASDisplayNode, ContextGesture?) -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        presentationData: ItemListPresentationData,
+        systemStyle: ItemListSystemStyle,
+        invite: ExportedChatFolderLink?,
+        share: Bool,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        tapAction: ((ExportedChatFolderLink) -> Void)?,
+        removeAction: ((ExportedChatFolderLink) -> Void)?,
+        contextAction: ((ExportedChatFolderLink, ASDisplayNode, ContextGesture?) -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.invite = invite
+        self.share = share
+        self.sectionId = sectionId
+        self.style = style
+        self.tapAction = tapAction
+        self.removeAction = removeAction
+        self.contextAction = contextAction
+        self.tag = tag
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            var firstWithHeader = false
+            var last = false
+            if self.style == .plain {
+                if previousItem == nil {
+                    firstWithHeader = true
+                }
+                if nextItem == nil {
+                    last = true
+                }
+            }
+            let node = ItemListFolderInviteLinkListItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListFolderInviteLinkListItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    var firstWithHeader = false
+                    var last = false
+                    if self.style == .plain {
+                        if previousItem == nil {
+                            firstWithHeader = true
+                        }
+                        if nextItem == nil {
+                            last = true
+                        }
+                    }
+                    
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView) {
+        listView.clearHighlightAnimated(true)
+        if let invite = self.invite {
+            self.tapAction?(invite)
+        }
+    }
+}
+
+public class ItemListFolderInviteLinkListItemNode: ItemListRevealOptionsItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let extractedBackgroundImageNode: ASImageNode
+
+    private let containerNode: ContextControllerSourceNode
+    private let contextSourceNode: ContextExtractedContentContainingNode
+    
+    private var extractedRect: CGRect?
+    private var nonExtractedRect: CGRect?
+    
+    private let offsetContainerNode: ASDisplayNode
+    public override var controlsContainer: ASDisplayNode {
+        //return super.controlsContainer
+        return self.containerNode
+    }
+    
+    private let iconBackgroundNode: ASDisplayNode
+    private let iconNode: ASImageNode
+    private var timerNode: TimerNode?
+    
+    private let titleNode: TextNode
+    private let subtitleNode: TextNode
+    
+    private var placeholderNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    private var currentColor: ItemBackgroundColor?
+    private var layoutParams: (ItemListFolderInviteLinkListItem, ListViewItemLayoutParams, ItemListNeighbors, Bool, Bool)?
+    
+    public var tag: ItemListItemTag?
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        self.maskNode = ASImageNode()
+        
+        self.extractedBackgroundImageNode = ASImageNode()
+        self.extractedBackgroundImageNode.displaysAsynchronously = false
+        self.extractedBackgroundImageNode.alpha = 0.0
+        
+        self.contextSourceNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        
+        self.offsetContainerNode = ASDisplayNode()
+        
+        self.iconBackgroundNode = ASDisplayNode()
+        self.iconBackgroundNode.setLayerBlock { () -> CALayer in
+            return CAShapeLayer()
+        }
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.displaysAsynchronously = false
+        self.iconNode.displayWithoutProcessing = true
+        self.iconNode.contentMode = .center
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+    
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        self.subtitleNode.contentMode = .left
+        self.subtitleNode.contentsScale = UIScreen.main.scale
+            
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.isAccessibilityElement = true
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        self.addSubnode(self.containerNode)
+        
+        self.contextSourceNode.contentNode.addSubnode(self.extractedBackgroundImageNode)
+        self.contextSourceNode.contentNode.addSubnode(self.offsetContainerNode)
+        
+        self.offsetContainerNode.addSubnode(self.iconBackgroundNode)
+        self.offsetContainerNode.addSubnode(self.iconNode)
+        self.offsetContainerNode.addSubnode(self.titleNode)
+        self.offsetContainerNode.addSubnode(self.subtitleNode)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0, let invite = item.invite, let contextAction = item.contextAction else {
+                gesture.cancel()
+                return
+            }
+            contextAction(invite, strongSelf.contextSourceNode, gesture)
+        }
+        
+        self.contextSourceNode.willUpdateIsExtractedToContextPreview = { [weak self] isExtracted, transition in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0 else {
+                return
+            }
+            
+            if isExtracted {
+                strongSelf.extractedBackgroundImageNode.image = generateStretchableFilledCircleImage(diameter: 28.0, color: item.presentationData.theme.list.plainBackgroundColor)
+            }
+            
+            if let extractedRect = strongSelf.extractedRect, let nonExtractedRect = strongSelf.nonExtractedRect {
+                let rect = isExtracted ? extractedRect : nonExtractedRect
+                transition.updateFrame(node: strongSelf.extractedBackgroundImageNode, frame: rect)
+            }
+            
+            transition.updateSublayerTransformOffset(layer: strongSelf.offsetContainerNode.layer, offset: CGPoint(x: isExtracted ? 12.0 : 0.0, y: 0.0))
+            transition.updateAlpha(node: strongSelf.extractedBackgroundImageNode, alpha: isExtracted ? 1.0 : 0.0, completion: { _ in
+                if !isExtracted {
+                    self?.extractedBackgroundImageNode.image = nil
+                }
+            })
+        }
+    }
+    
+    public override func didLoad() {
+        super.didLoad()
+        
+        if let shapeLayer = self.iconBackgroundNode.layer as? CAShapeLayer {
+            shapeLayer.path = UIBezierPath(ovalIn: CGRect(x: 0.0, y: 0.0, width: 40.0, height: 40.0)).cgPath
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListFolderInviteLinkListItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors, _ firstWithHeader: Bool, _ last: Bool) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        
+        let currentItem = self.layoutParams?.0
+                
+        return { item, params, neighbors, firstWithHeader, last in
+            var updatedTheme: PresentationTheme?
+        
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            let subtitleFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 14.0 / 17.0))
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let color: ItemBackgroundColor
+            let nextColor: ItemBackgroundColor
+            let transitionFraction: CGFloat
+            
+            color = .blue
+            nextColor = .blue
+            transitionFraction = 1.0
+            
+            let topColor = color.colors.top
+            let nextTopColor = nextColor.colors.top
+            let iconColor: UIColor
+            if let _ = item.invite {
+                if case .blue = color {
+                    iconColor = item.presentationData.theme.list.itemAccentColor
+                } else {
+                    iconColor = nextTopColor.mixedWith(topColor, alpha: transitionFraction)
+                }
+            } else {
+                iconColor = item.presentationData.theme.list.mediaPlaceholderColor
+            }
+            
+            let inviteLink = item.invite?.link.replacingOccurrences(of: "https://", with: "") ?? ""
+            var titleText = inviteLink
+            var subtitleText: String = ""
+            
+            if let invite = item.invite {
+                if !invite.title.isEmpty {
+                    titleText = invite.title
+                }
+                
+                subtitleText = item.presentationData.strings.ChatListFilter_LinkLabelChatCount(Int32(invite.peerIds.count))
+            } else {
+                titleText = " "
+                subtitleText = " "
+            }
+            
+            let titleAttributedString = NSAttributedString(string: titleText, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            let subtitleAttributedString = NSAttributedString(string: subtitleText, font: subtitleFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+            
+            let leftInset: CGFloat = 65.0 + params.leftInset
+            let rightInset: CGFloat = 16.0 + params.rightInset
+            var verticalInset: CGFloat = subtitleAttributedString.string.isEmpty ? 14.0 : 8.0
+            if case .glass = item.systemStyle {
+                verticalInset += 4.0
+            }
+           
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: subtitleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let titleSpacing: CGFloat = 1.0
+            
+            let minHeight: CGFloat = titleLayout.size.height + verticalInset * 2.0
+            let rawHeight: CGFloat = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + subtitleLayout.size.height
+            
+            var insets: UIEdgeInsets
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            switch item.style {
+                case .plain:
+                    itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                    insets = itemListNeighborsPlainInsets(neighbors)
+                    insets.top = firstWithHeader ? 29.0 : 0.0
+                    insets.bottom = 0.0
+                case .blocks:
+                    itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                    insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let contentSize = CGSize(width: params.width, height: max(minHeight, rawHeight))
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.layoutParams = (item, params, neighbors, firstWithHeader, last)
+                                        
+                    strongSelf.accessibilityLabel = titleAttributedString.string
+                    strongSelf.accessibilityValue = subtitleAttributedString.string
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.offsetContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.contentNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.containerNode.isGestureEnabled = item.contextAction != nil
+                    
+                    let nonExtractedRect = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width - 16.0, height: layout.contentSize.height))
+                    let extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: 16.0 + params.leftInset, dy: 0.0)
+                    strongSelf.extractedRect = extractedRect
+                    strongSelf.nonExtractedRect = nonExtractedRect
+                    
+                    if strongSelf.contextSourceNode.isExtractedToContextPreview {
+                        strongSelf.extractedBackgroundImageNode.frame = extractedRect
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.frame = nonExtractedRect
+                    }
+                    strongSelf.contextSourceNode.contentRect = extractedRect
+                     
+                    if let layer = strongSelf.iconBackgroundNode.layer as? CAShapeLayer {
+                        layer.fillColor = iconColor.cgColor
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                        
+                        strongSelf.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Link"), color: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                    }
+                                        
+                    let transition = ContainedViewLayoutTransition.immediate
+                                        
+                    let _ = titleApply()
+                    let _ = subtitleApply()
+                    
+                    switch item.style {
+                        case .plain:
+                            if strongSelf.backgroundNode.supernode != nil {
+                                strongSelf.backgroundNode.removeFromSupernode()
+                            }
+                            if strongSelf.topStripeNode.supernode != nil {
+                                strongSelf.topStripeNode.removeFromSupernode()
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                            }
+                            if strongSelf.maskNode.supernode != nil {
+                                strongSelf.maskNode.removeFromSupernode()
+                            }
+                            
+                            let stripeInset: CGFloat
+                            if case .none = neighbors.bottom {
+                                stripeInset = 0.0
+                            } else {
+                                stripeInset = leftInset
+                            }
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: stripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - stripeInset, height: separatorHeight))
+                            strongSelf.bottomStripeNode.isHidden = last
+                        case .blocks:
+                            if strongSelf.backgroundNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                            }
+                            if strongSelf.topStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                            }
+                            if strongSelf.maskNode.supernode == nil {
+                                //strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                                strongSelf.maskNode.isUserInteractionEnabled = false
+                                strongSelf.addSubnode(strongSelf.maskNode)
+                            }
+                            
+                            let hasCorners = itemListHasRoundedBlockLayout(params)
+                            var hasTopCorners = false
+                            var hasBottomCorners = false
+                            switch neighbors.top {
+                                case .sameSection(false):
+                                    strongSelf.topStripeNode.isHidden = true
+                                default:
+                                    hasTopCorners = true
+                                    strongSelf.topStripeNode.isHidden = hasCorners
+                            }
+                            let bottomStripeInset: CGFloat
+                            switch neighbors.bottom {
+                                case .sameSection(false):
+                                    bottomStripeInset = leftInset
+                                    strongSelf.bottomStripeNode.isHidden = false
+                                default:
+                                    bottomStripeInset = 0.0
+                                    hasBottomCorners = true
+                                    strongSelf.bottomStripeNode.isHidden = hasCorners
+                            }
+                            
+                            strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                            
+                            strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                            strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                            strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    }
+                    
+                    let iconSize: CGSize = CGSize(width: 40.0, height: 40.0)
+                    let iconFrame = CGRect(origin: CGPoint(x: params.leftInset + 12.0, y: floorToScreenPixels((layout.contentSize.height - iconSize.height) / 2.0)), size: iconSize)
+                    strongSelf.iconBackgroundNode.bounds = CGRect(origin: CGPoint(), size: iconSize)
+                    strongSelf.iconBackgroundNode.position = iconFrame.center
+                    strongSelf.iconNode.frame = iconFrame
+                    
+                    transition.updateTransformScale(node: strongSelf.iconBackgroundNode, scale: 1.0)
+                    
+                    strongSelf.timerNode?.frame = iconFrame.insetBy(dx: -5.0, dy: -5.0)
+                    
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.subtitleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset + titleLayout.size.height + titleSpacing), size: subtitleLayout.size))
+                                        
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                    
+                    if item.invite == nil {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.placeholderNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.placeholderNode = shimmerNode
+                            strongSelf.addSubnode(shimmerNode)
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+                        
+                        var shapes: [ShimmerEffectNode.Shape] = []
+                        
+                        let titleLineWidth: CGFloat = 180.0
+                        let subtitleLineWidth: CGFloat = 60.0
+                        let lineDiameter: CGFloat = 10.0
+                        
+                        let iconFrame = strongSelf.iconBackgroundNode.frame
+                        shapes.append(.circle(iconFrame))
+                        
+                        let titleFrame = strongSelf.titleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: titleFrame.minX, y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: titleLineWidth, diameter: lineDiameter))
+                        
+                        let subtitleFrame = strongSelf.subtitleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: subtitleFrame.minX, y: subtitleFrame.minY + floor((subtitleFrame.height - lineDiameter) / 2.0)), width: subtitleLineWidth, diameter: lineDiameter))
+                        
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: layout.contentSize)
+                    } else if let shimmerNode = strongSelf.placeholderNode {
+                        strongSelf.placeholderNode = nil
+                        shimmerNode.removeFromSupernode()
+                    }
+                    
+                    strongSelf.updateLayout(size: layout.contentSize, leftInset: params.leftInset, rightInset: params.rightInset)
+                    
+                    if item.removeAction != nil {
+                        strongSelf.setRevealOptions((left: [], right: [ItemListRevealOption(key: 0, title: item.presentationData.strings.ChatListFilter_LinkActionDelete, icon: .none, color: item.presentationData.theme.list.itemDisclosureActions.destructive.fillColor, textColor: item.presentationData.theme.list.itemDisclosureActions.destructive.foregroundColor)]))
+                    } else {
+                        strongSelf.setRevealOptions((left: [], right: []))
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.placeholderNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+    
+    override public func updateRevealOffset(offset: CGFloat, transition: ContainedViewLayoutTransition) {
+        super.updateRevealOffset(offset: offset, transition: transition)
+        
+        transition.updateSublayerTransformOffset(layer: self.offsetContainerNode.layer, offset: CGPoint(x: offset + (self.contextSourceNode.isExtractedToContextPreview ? 12.0 : 0.0), y: 0.0))
+    }
+    
+    override public func revealOptionSelected(_ option: ItemListRevealOption, animated: Bool) {
+        if let item = self.layoutParams?.0, let invite = item.invite {
+            item.removeAction?(invite)
+        }
+        
+        self.setRevealOptionsOpened(false, animated: true)
+        self.revealOptionsInteractivelyClosed()
+    }
+}
+
+private struct ContentParticle {
+    var position: CGPoint
+    var direction: CGPoint
+    var velocity: CGFloat
+    var alpha: CGFloat
+    var lifetime: Double
+    var beginTime: Double
+    
+    init(position: CGPoint, direction: CGPoint, velocity: CGFloat, alpha: CGFloat, lifetime: Double, beginTime: Double) {
+        self.position = position
+        self.direction = direction
+        self.velocity = velocity
+        self.alpha = alpha
+        self.lifetime = lifetime
+        self.beginTime = beginTime
+    }
+}
+
+private final class TimerNode: ASDisplayNode {
+    enum Value: Equatable {
+        case timestamp(creation: Int32, deadline: Int32)
+        case fraction(CGFloat)
+    }
+    private struct Params: Equatable {
+        var color: UIColor
+        var value: Value
+    }
+    
+    private let hierarchyTrackingNode: HierarchyTrackingNode
+    private var inHierarchyValue: Bool = false
+    
+    private var animator: ConstantDisplayLinkAnimator?
+    private let contentNode: ASDisplayNode
+    private var particles: [ContentParticle] = []
+    
+    private var currentParams: Params?
+    
+    var reachedTimeout: (() -> Void)?
+    
+    override init() {
+        var updateInHierarchy: ((Bool) -> Void)?
+        self.hierarchyTrackingNode = HierarchyTrackingNode({ value in
+            updateInHierarchy?(value)
+        })
+        
+        self.contentNode = ASDisplayNode()
+        
+        super.init()
+        
+        self.addSubnode(self.contentNode)
+        
+        updateInHierarchy = { [weak self] value in
+            guard let strongSelf = self else {
+                return
+            }
+            strongSelf.inHierarchyValue = value
+            strongSelf.animator?.isPaused = value
+        }
+    }
+    
+    deinit {
+        self.animator?.invalidate()
+    }
+    
+    func update(color: UIColor, value: Value) {
+        let params = Params(
+            color: color,
+            value: value
+        )
+        self.currentParams = params
+        
+        self.updateValues()
+    }
+    
+    private func updateValues() {
+        guard let params = self.currentParams else {
+            return
+        }
+
+        let color = params.color
+
+        let currentTimestamp = Int32(CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970)
+        var fraction: CGFloat
+        switch params.value {
+            case let .fraction(value):
+                fraction = value
+            case let .timestamp(creation, deadline):
+                fraction = CGFloat(deadline - currentTimestamp) / CGFloat(deadline - creation)
+        }
+        fraction = max(0.0001, 1.0 - max(0.0, min(1.0, fraction)))
+      
+        let image: UIImage?
+        
+        let diameter: CGFloat = 42.0
+        let inset: CGFloat = 8.0
+        let lineWidth: CGFloat = 2.0
+
+        let timestamp = CACurrentMediaTime()
+        
+        let center = CGPoint(x: (diameter + inset) / 2.0, y: (diameter + inset) / 2.0)
+        let radius: CGFloat = (diameter - lineWidth / 2.0) / 2.0
+        
+        let startAngle: CGFloat = -CGFloat.pi / 2.0
+        let endAngle: CGFloat = -CGFloat.pi / 2.0 + 2.0 * CGFloat.pi * fraction
+        
+        let sparks = fraction > 0.05 && fraction != 1.0
+        if sparks {
+            let v = CGPoint(x: sin(endAngle), y: -cos(endAngle))
+            let c = CGPoint(x: -v.y * radius + center.x, y: v.x * radius + center.y)
+            
+            let dt: CGFloat = 1.0 / 60.0
+            var removeIndices: [Int] = []
+            for i in 0 ..< self.particles.count {
+                let currentTime = timestamp - self.particles[i].beginTime
+                if currentTime > self.particles[i].lifetime {
+                    removeIndices.append(i)
+                } else {
+                    let input: CGFloat = CGFloat(currentTime / self.particles[i].lifetime)
+                    let decelerated: CGFloat = (1.0 - (1.0 - input) * (1.0 - input))
+                    self.particles[i].alpha = 1.0 - decelerated
+                    
+                    var p = self.particles[i].position
+                    let d = self.particles[i].direction
+                    let v = self.particles[i].velocity
+                    p = CGPoint(x: p.x + d.x * v * dt, y: p.y + d.y * v * dt)
+                    self.particles[i].position = p
+                }
+            }
+            
+            for i in removeIndices.reversed() {
+                self.particles.remove(at: i)
+            }
+            
+            let newParticleCount = 1
+            for _ in 0 ..< newParticleCount {
+                let degrees: CGFloat = CGFloat(arc4random_uniform(140)) - 40.0
+                let angle: CGFloat = degrees * CGFloat.pi / 180.0
+                
+                let direction = CGPoint(x: v.x * cos(angle) - v.y * sin(angle), y: v.x * sin(angle) + v.y * cos(angle))
+                let velocity = (20.0 + (CGFloat(arc4random()) / CGFloat(UINT32_MAX)) * 4.0) * 0.3
+                
+                let lifetime = Double(0.4 + CGFloat(arc4random_uniform(100)) * 0.01)
+                
+                let particle = ContentParticle(position: c, direction: direction, velocity: velocity, alpha: 1.0, lifetime: lifetime, beginTime: timestamp)
+                self.particles.append(particle)
+            }
+        }
+        
+        image = generateImage(CGSize(width: diameter + inset, height: diameter + inset), rotatedContext: { size, context in
+            context.clear(CGRect(origin: CGPoint(), size: size))
+            context.setStrokeColor(color.cgColor)
+            context.setFillColor(color.cgColor)
+            context.setLineWidth(lineWidth)
+            context.setLineCap(.round)
+            
+            let path = CGMutablePath()
+            path.addArc(center: center, radius: radius, startAngle: startAngle, endAngle: endAngle, clockwise: true)
+            context.addPath(path)
+            context.strokePath()
+            
+            if sparks {
+                for particle in self.particles {
+                    let size: CGFloat = 2.0
+                    context.setAlpha(particle.alpha)
+                    context.fillEllipse(in: CGRect(origin: CGPoint(x: particle.position.x - size / 2.0, y: particle.position.y - size / 2.0), size: CGSize(width: size, height: size)))
+                }
+            }
+        })
+        
+        self.contentNode.contents = image?.cgImage
+        if let image = image {
+            self.contentNode.frame = CGRect(origin: CGPoint(), size: image.size)
+        }
+             
+        if fraction <= .ulpOfOne {
+            self.animator?.invalidate()
+            self.animator = nil
+        } else {
+            if self.animator == nil {
+                let animator = ConstantDisplayLinkAnimator(update: { [weak self] in
+                    self?.updateValues()
+                })
+                self.animator = animator
+                animator.isPaused = self.inHierarchyValue
+            }
+        }
+    }
+}

submodules/InviteLinksUI/Sources/ItemListInviteLinkDateLimitItem.swift

@@ -0,0 +1,401 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramUIPreferences
+import TelegramPresentationData
+import LegacyComponents
+import ItemListUI
+import PresentationDataUtils
+
+enum InviteLinkTimeLimit: Equatable {
+    case hour
+    case day
+    case week
+    case unlimited
+    case custom(Int32)
+    
+    init(position: Int) {
+        switch position {
+        case 0:
+            self = .hour
+        case 1:
+            self = .day
+        case 2:
+            self = .week
+        default:
+            self = .unlimited
+        }
+    }
+    
+    var value: Int32? {
+        switch self {
+        case .hour:
+            return 3600
+        case .day:
+            return 86400
+        case .week:
+            return 604800
+        case .unlimited:
+            return nil
+        case let .custom(value):
+            return value
+        }
+    }
+    
+    var position: Int {
+        switch self {
+        case .hour:
+            return 0
+        case .day:
+            return 1
+        case .week:
+            return 2
+        case .unlimited:
+            return 3
+        case let .custom(value):
+            let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+            let relativeValue = value - currentTime
+            if relativeValue < 3600 {
+                return 0
+            } else if relativeValue < 86400 {
+                return 1
+            } else if relativeValue < 604800 {
+                return 2
+            } else {
+                return 3
+            }
+        }
+    }
+}
+
+final class ItemListInviteLinkTimeLimitItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let value: InviteLinkTimeLimit
+    let enabled: Bool
+    let sectionId: ItemListSectionId
+    let updated: (InviteLinkTimeLimit) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, value: InviteLinkTimeLimit, enabled: Bool, sectionId: ItemListSectionId, updated: @escaping (InviteLinkTimeLimit) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.value = value
+        self.enabled = enabled
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = ItemListInviteLinkTimeLimitItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListInviteLinkTimeLimitItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+}
+
+private final class ItemListInviteLinkTimeLimitItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let lowTextNode: TextNode
+    private let mediumTextNode: TextNode
+    private let highTextNode: TextNode
+    private let unlimitedTextNode: TextNode
+    private let customTextNode: TextNode
+    private var sliderView: TGPhotoEditorSliderView?
+    
+    private var item: ItemListInviteLinkTimeLimitItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        
+        self.lowTextNode = TextNode()
+        self.lowTextNode.isUserInteractionEnabled = false
+        self.lowTextNode.displaysAsynchronously = false
+        
+        self.mediumTextNode = TextNode()
+        self.mediumTextNode.isUserInteractionEnabled = false
+        self.mediumTextNode.displaysAsynchronously = false
+        
+        self.highTextNode = TextNode()
+        self.highTextNode.isUserInteractionEnabled = false
+        self.highTextNode.displaysAsynchronously = false
+        
+        self.unlimitedTextNode = TextNode()
+        self.unlimitedTextNode.isUserInteractionEnabled = false
+        self.unlimitedTextNode.displaysAsynchronously = false
+      
+        self.customTextNode = TextNode()
+        self.customTextNode.isUserInteractionEnabled = false
+        self.customTextNode.displaysAsynchronously = false
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.lowTextNode)
+        self.addSubnode(self.mediumTextNode)
+        self.addSubnode(self.highTextNode)
+        self.addSubnode(self.unlimitedTextNode)
+        self.addSubnode(self.customTextNode)
+    }
+    
+    func updateSliderView() {
+        if let sliderView = self.sliderView, let item = self.item {
+            if case .custom = item.value {
+                sliderView.maximumValue = 3.0 + 1
+                sliderView.positionsCount = 4 + 1
+            } else {
+                sliderView.maximumValue = 3.0
+                sliderView.positionsCount = 4
+            }
+            sliderView.value = CGFloat(item.value.position)
+            
+            sliderView.isUserInteractionEnabled = item.enabled
+            sliderView.alpha = item.enabled ? 1.0 : 0.4
+            sliderView.layer.allowsGroupOpacity = !item.enabled
+        }
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let sliderView = TGPhotoEditorSliderView()
+        sliderView.enablePanHandling = true
+        sliderView.trackCornerRadius = 2.0
+        sliderView.lineSize = 4.0
+        sliderView.dotSize = 5.0
+        sliderView.minimumValue = 0.0
+        sliderView.startValue = 0.0
+        sliderView.disablesInteractiveTransitionGestureRecognizer = true
+        if let item = self.item, case .custom = item.value {
+            sliderView.maximumValue = 3.0 + 1
+            sliderView.positionsCount = 4 + 1
+        } else {
+            sliderView.maximumValue = 3.0
+            sliderView.positionsCount = 4
+        }
+        sliderView.useLinesForPositions = true
+        if let item = self.item, let params = self.layoutParams {
+            sliderView.value = CGFloat(item.value.position)
+            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.trackColor = item.theme.list.itemAccentColor
+            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+            
+            sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+            sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+        }
+        self.view.addSubview(sliderView)
+        sliderView.addTarget(self, action: #selector(self.sliderValueChanged), for: .valueChanged)
+        self.sliderView = sliderView
+        
+        self.updateSliderView()
+    }
+    
+    func asyncLayout() -> (_ item: ItemListInviteLinkTimeLimitItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        let makeLowTextLayout = TextNode.asyncLayout(self.lowTextNode)
+        let makeMediumTextLayout = TextNode.asyncLayout(self.mediumTextNode)
+        let makeHighTextLayout = TextNode.asyncLayout(self.highTextNode)
+        let makeUnlimitedTextLayout = TextNode.asyncLayout(self.unlimitedTextNode)
+        let makeCustomTextLayout = TextNode.asyncLayout(self.customTextNode)
+        
+        return { item, params, neighbors in
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            let (lowTextLayout, lowTextApply) = makeLowTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: timeIntervalString(strings: item.strings, value: 3600), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+
+            let (mediumTextLayout, mediumTextApply) = makeMediumTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: timeIntervalString(strings: item.strings, value: 86400), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (highTextLayout, highTextApply) = makeHighTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: timeIntervalString(strings: item.strings, value: 604800), font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (unlimitedTextLayout, unlimitedTextApply) = makeUnlimitedTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.strings.InviteLink_Create_TimeLimitNoLimit, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let customTextString: String
+            if case let .custom(value) = item.value {
+                let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+                let relativeValue = value - currentTime
+                if relativeValue > 0 {
+                    customTextString = timeIntervalString(strings: item.strings, value: relativeValue)
+                } else {
+                    customTextString = ""
+                }
+            } else {
+                customTextString = ""
+            }
+            
+            let (customTextLayout, customTextApply) = makeCustomTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: customTextString, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            contentSize = CGSize(width: params.width, height: 88.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    if strongSelf.backgroundNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                    }
+                    if strongSelf.topStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                    }
+                    if strongSelf.bottomStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                    }
+                    if strongSelf.maskNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    let hasCorners = itemListHasRoundedBlockLayout(params)
+                    var hasTopCorners = false
+                    var hasBottomCorners = false
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            hasTopCorners = true
+                            strongSelf.topStripeNode.isHidden = hasCorners
+                    }
+                    let bottomStripeInset: CGFloat
+                    let bottomStripeOffset: CGFloat
+                    switch neighbors.bottom {
+                    case .sameSection(false):
+                        bottomStripeInset = 0.0 //params.leftInset + 16.0
+                        bottomStripeOffset = -separatorHeight
+                        strongSelf.bottomStripeNode.isHidden = false
+                    default:
+                        bottomStripeInset = 0.0
+                        bottomStripeOffset = 0.0
+                        hasBottomCorners = true
+                        strongSelf.bottomStripeNode.isHidden = hasCorners
+                    }
+                    
+                    strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    let _ = lowTextApply()
+                    let _ = mediumTextApply()
+                    let _ = highTextApply()
+                    let _ = unlimitedTextApply()
+                    let _ = customTextApply()
+                    
+                    var textNodes: [(TextNode, CGSize)] = [(strongSelf.lowTextNode, lowTextLayout.size),
+                                                           (strongSelf.mediumTextNode, mediumTextLayout.size),
+                                                           (strongSelf.highTextNode, highTextLayout.size),
+                                                           (strongSelf.unlimitedTextNode, unlimitedTextLayout.size)]
+                    if case .custom = item.value {
+                        textNodes.insert((strongSelf.customTextNode, customTextLayout.size), at: item.value.position)
+                    }
+                    
+                    let delta = (params.width - params.leftInset - params.rightInset - 18.0 * 2.0) / CGFloat(textNodes.count - 1)
+                    for i in 0 ..< textNodes.count {
+                        let (textNode, textSize) = textNodes[i]
+                        
+                        var position = params.leftInset + 18.0 + delta * CGFloat(i)
+                        if i == textNodes.count - 1 {
+                            position -= textSize.width
+                        } else if i > 0 {
+                            position -= textSize.width / 2.0
+                        }
+                        
+                        textNode.frame = CGRect(origin: CGPoint(x: position, y: 15.0), size: textSize)
+                    }
+                    
+                    if let sliderView = strongSelf.sliderView {
+                        if themeUpdated {
+                            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+                        }
+                        
+                        sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+                        sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+                        
+                        strongSelf.updateSliderView()
+                    }
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    @objc func sliderValueChanged() {
+        guard let sliderView = self.sliderView else {
+            return
+        }
+        
+        let position = Int(sliderView.value)
+        let value = InviteLinkTimeLimit(position: position)
+        self.item?.updated(value)
+    }
+}
+

submodules/InviteLinksUI/Sources/ItemListInviteLinkItem.swift

@@ -0,0 +1,959 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramPresentationData
+import ItemListUI
+import ShimmerEffect
+import TelegramCore
+import TextNodeWithEntities
+import AccountContext
+import TextFormat
+
+func invitationAvailability(_ invite: ExportedInvitation) -> CGFloat {
+    if case let .link(_, _, _, _, isRevoked, _, date, startDate, expireDate, usageLimit, count, _, _) = invite {
+        if isRevoked {
+            return 0.0
+        }
+        let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+        var availability: CGFloat = 1.0
+        if let expireDate = expireDate {
+            let startDate = startDate ?? date
+            let fraction = CGFloat(expireDate - currentTime) / CGFloat(expireDate - startDate)
+            availability = min(fraction, availability)
+        }
+        if let usageLimit = usageLimit, let count = count {
+            let fraction = 1.0 - (CGFloat(count) / CGFloat(usageLimit))
+            availability = min(fraction, availability)
+        }
+        return max(0.0, min(1.0, availability))
+    } else {
+        return 1.0
+    }
+}
+
+private enum ItemBackgroundColor: Equatable {
+    case blue
+    case green
+    case yellow
+    case red
+    case gray
+    
+    var colors: (top: UIColor, bottom: UIColor, text: UIColor) {
+        switch self {
+            case .blue:
+                return (UIColor(rgb: 0x00b5f7), UIColor(rgb: 0x00b2f6), UIColor(rgb: 0xa7f4ff))
+            case .green:
+                return (UIColor(rgb: 0x31b73b), UIColor(rgb: 0x88d93b), UIColor(rgb: 0xc5ffe6))
+            case .yellow:
+                return (UIColor(rgb: 0xf8a953), UIColor(rgb: 0xf7a64e), UIColor(rgb: 0xfeffd7))
+            case .red:
+                return (UIColor(rgb: 0xf2656a), UIColor(rgb: 0xf25f65), UIColor(rgb: 0xffd3de))
+            case .gray:
+                return (UIColor(rgb: 0xa8b2bb), UIColor(rgb: 0xa2abb4), UIColor(rgb: 0xe3e6e8))
+        }
+    }
+}
+
+public class ItemListInviteLinkItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let invite: ExportedInvitation?
+    let share: Bool
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let tapAction: ((ExportedInvitation) -> Void)?
+    let contextAction: ((ExportedInvitation, ASDisplayNode, ContextGesture?) -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        systemStyle: ItemListSystemStyle = .legacy,
+        invite: ExportedInvitation?,
+        share: Bool,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        tapAction: ((ExportedInvitation) -> Void)?,
+        contextAction: ((ExportedInvitation, ASDisplayNode, ContextGesture?) -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.invite = invite
+        self.share = share
+        self.sectionId = sectionId
+        self.style = style
+        self.tapAction = tapAction
+        self.contextAction = contextAction
+        self.tag = tag
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            var firstWithHeader = false
+            var last = false
+            if self.style == .plain {
+                if previousItem == nil {
+                    firstWithHeader = true
+                }
+                if nextItem == nil {
+                    last = true
+                }
+            }
+            let node = ItemListInviteLinkItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListInviteLinkItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    var firstWithHeader = false
+                    var last = false
+                    if self.style == .plain {
+                        if previousItem == nil {
+                            firstWithHeader = true
+                        }
+                        if nextItem == nil {
+                            last = true
+                        }
+                    }
+                    
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView) {
+        listView.clearHighlightAnimated(true)
+        if let invite = self.invite {
+            self.tapAction?(invite)
+        }
+    }
+}
+
+public class ItemListInviteLinkItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let extractedBackgroundImageNode: ASImageNode
+
+    private let containerNode: ContextControllerSourceNode
+    private let contextSourceNode: ContextExtractedContentContainingNode
+    
+    private var extractedRect: CGRect?
+    private var nonExtractedRect: CGRect?
+    
+    private let offsetContainerNode: ASDisplayNode
+    
+    private let iconBackgroundNode: ASDisplayNode
+    private let iconNode: ASImageNode
+    private var timerNode: TimerNode?
+    
+    private let titleNode: TextNode
+    private let subtitleNode: TextNode
+    private let pricingNode: TextNodeWithEntities
+    
+    private var placeholderNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    private var currentColor: ItemBackgroundColor?
+    private var currentIsPaid: Bool?
+    private var layoutParams: (ItemListInviteLinkItem, ListViewItemLayoutParams, ItemListNeighbors, Bool, Bool)?
+    
+    public var tag: ItemListItemTag?
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        self.maskNode = ASImageNode()
+        
+        self.extractedBackgroundImageNode = ASImageNode()
+        self.extractedBackgroundImageNode.displaysAsynchronously = false
+        self.extractedBackgroundImageNode.alpha = 0.0
+        
+        self.contextSourceNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        
+        self.offsetContainerNode = ASDisplayNode()
+        
+        self.iconBackgroundNode = ASDisplayNode()
+        self.iconBackgroundNode.setLayerBlock { () -> CALayer in
+            return CAGradientLayer()
+        }
+        
+        self.iconNode = ASImageNode()
+        self.iconNode.displaysAsynchronously = false
+        self.iconNode.displayWithoutProcessing = true
+        self.iconNode.contentMode = .center
+        
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+    
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        self.subtitleNode.contentMode = .left
+        self.subtitleNode.contentsScale = UIScreen.main.scale
+        
+        self.pricingNode = TextNodeWithEntities()
+            
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.isAccessibilityElement = true
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        self.addSubnode(self.containerNode)
+        
+        self.contextSourceNode.contentNode.addSubnode(self.extractedBackgroundImageNode)
+        self.contextSourceNode.contentNode.addSubnode(self.offsetContainerNode)
+        
+        self.offsetContainerNode.addSubnode(self.iconBackgroundNode)
+        self.offsetContainerNode.addSubnode(self.iconNode)
+        self.offsetContainerNode.addSubnode(self.titleNode)
+        self.offsetContainerNode.addSubnode(self.subtitleNode)
+        self.offsetContainerNode.addSubnode(self.pricingNode.textNode)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0, let invite = item.invite, let contextAction = item.contextAction else {
+                gesture.cancel()
+                return
+            }
+            contextAction(invite, strongSelf.contextSourceNode, gesture)
+        }
+        
+        self.contextSourceNode.willUpdateIsExtractedToContextPreview = { [weak self] isExtracted, transition in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0 else {
+                return
+            }
+            
+            if isExtracted {
+                strongSelf.extractedBackgroundImageNode.image = generateStretchableFilledCircleImage(diameter: 28.0, color: item.presentationData.theme.list.plainBackgroundColor)
+            }
+            
+            if let extractedRect = strongSelf.extractedRect, let nonExtractedRect = strongSelf.nonExtractedRect {
+                let rect = isExtracted ? extractedRect : nonExtractedRect
+                transition.updateFrame(node: strongSelf.extractedBackgroundImageNode, frame: rect)
+            }
+            
+            transition.updateSublayerTransformOffset(layer: strongSelf.offsetContainerNode.layer, offset: CGPoint(x: isExtracted ? 12.0 : 0.0, y: 0.0))
+            transition.updateAlpha(node: strongSelf.extractedBackgroundImageNode, alpha: isExtracted ? 1.0 : 0.0, completion: { _ in
+                if !isExtracted {
+                    self?.extractedBackgroundImageNode.image = nil
+                }
+            })
+            transition.updateAlpha(node: strongSelf.pricingNode.textNode, alpha: isExtracted ? 0.0 : 1.0)
+        }
+    }
+    
+    public override func didLoad() {
+        super.didLoad()
+        
+        self.iconBackgroundNode.cornerRadius = 20.0
+        if let iconBackgroundLayer = self.iconBackgroundNode.layer as? CAGradientLayer {
+            iconBackgroundLayer.startPoint = CGPoint(x: 0.0, y: 0.0)
+            iconBackgroundLayer.endPoint = CGPoint(x: 0.0, y: 1.0)
+            iconBackgroundLayer.type = .axial
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListInviteLinkItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors, _ firstWithHeader: Bool, _ last: Bool) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        let makePricingLayout = TextNodeWithEntities.asyncLayout(self.pricingNode)
+        
+        let currentItem = self.layoutParams?.0
+                
+        return { item, params, neighbors, firstWithHeader, last in
+            var updatedTheme: PresentationTheme?
+        
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            let subtitleFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 14.0 / 17.0))
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+            let availability = item.invite.flatMap { invitationAvailability($0) } ?? 0.0
+            
+            let color: ItemBackgroundColor
+            let nextColor: ItemBackgroundColor
+            let transitionFraction: CGFloat
+            if let invite = item.invite, case let .link(_, _, _, _, isRevoked, _, _, _, expireDate, usageLimit, _, _, pricing) = invite {
+                if isRevoked {
+                    color = .gray
+                    nextColor = .gray
+                    transitionFraction = 0.0
+                } else if expireDate == nil && usageLimit == nil {
+                    if let _ = pricing {
+                        color = .green
+                        nextColor = .green
+                    } else {
+                        color = .blue
+                        nextColor = .blue
+                    }
+                    transitionFraction = 0.0
+                } else if availability >= 0.5 {
+                    color = .green
+                    nextColor = .yellow
+                    transitionFraction = (availability - 0.5) / 0.5
+                } else if availability > 0.0 {
+                    color = .yellow
+                    nextColor = .red
+                    transitionFraction = availability / 0.5
+                } else {
+                    color = .red
+                    nextColor = .red
+                    transitionFraction = 0.0
+                }
+            } else {
+                color = .gray
+                nextColor = .gray
+                transitionFraction = 0.0
+            }
+            
+            let colors = color.colors
+            let nextColors = nextColor.colors
+            let topIconColor: UIColor
+            let bottomIconColor: UIColor
+            if let _ = item.invite {
+                if case .green = color, item.invite?.pricing != nil {
+                    topIconColor = color.colors.bottom
+                    bottomIconColor = color.colors.top
+                } else if case .blue = color {
+                    topIconColor = item.presentationData.theme.list.itemAccentColor
+                    bottomIconColor = topIconColor
+                } else {
+                    topIconColor = nextColors.top.mixedWith(colors.top, alpha: transitionFraction)
+                    bottomIconColor = topIconColor
+                }
+            } else {
+                topIconColor = item.presentationData.theme.list.mediaPlaceholderColor
+                bottomIconColor = topIconColor
+            }
+            
+            let inviteLink = item.invite?.link?.replacingOccurrences(of: "https://", with: "") ?? ""
+            var titleText = inviteLink
+            var subtitleText: String = ""
+            var pricingAttributedText: NSMutableAttributedString?
+            var timerValue: TimerNode.Value?
+            
+            if let invite = item.invite, case let  .link(_, title, _, _, _, _, date, startDate, expireDate, usageLimit, count, requestedCount, subscriptionPricing) = invite {
+                if let title = title, !title.isEmpty {
+                    titleText = title
+                }
+                
+                let count = count ?? 0
+                let requestedCount = requestedCount ?? 0
+                
+                if count > 0 {
+                    subtitleText = item.presentationData.strings.InviteLink_PeopleJoinedShort(count)
+                } else {
+                    if let usageLimit = usageLimit, count == 0 && !availability.isZero {
+                        subtitleText = item.presentationData.strings.InviteLink_PeopleCanJoin(usageLimit)
+                    } else {
+                        if availability.isZero {
+                            subtitleText = item.presentationData.strings.InviteLink_PeopleJoinedShortNoneExpired
+                        } else if requestedCount == 0 {
+                            subtitleText = item.presentationData.strings.InviteLink_PeopleJoinedShortNone
+                        }
+                    }
+                }
+                
+                if requestedCount > 0 {
+                    if !subtitleText.isEmpty {
+                        subtitleText += ", "
+                    }
+                    subtitleText += item.presentationData.strings.MemberRequests_PeopleRequestedShort(requestedCount)
+                }
+                
+                if let subscriptionPricing {
+                    let text = NSMutableAttributedString()
+                    text.append(NSAttributedString(string: "⭐️\(subscriptionPricing.amount)\n", font: Font.semibold(17.0), textColor: item.presentationData.theme.list.itemPrimaryTextColor))
+                    text.append(NSAttributedString(string: item.presentationData.strings.InviteLink_PerMonth, font: Font.regular(13.0), textColor: item.presentationData.theme.list.itemSecondaryTextColor))
+                    if let range = text.string.range(of: "⭐️") {
+                        text.addAttribute(ChatTextInputAttributes.customEmoji, value: ChatTextInputTextCustomEmojiAttribute(interactivelySelectedFromPackId: nil, fileId: 0, file: nil, custom: .stars(tinted: false)), range: NSRange(range, in: text.string))
+                        text.addAttribute(NSAttributedString.Key.font, value: Font.semibold(15.0), range: NSRange(range, in: text.string))
+                        text.addAttribute(.baselineOffset, value: 3.5, range: NSRange(range, in: text.string))
+                    }
+                    pricingAttributedText = text
+                }
+                
+                if invite.isRevoked {
+                    if !subtitleText.isEmpty {
+                        subtitleText += " • "
+                    }
+                    subtitleText += item.presentationData.strings.InviteLink_Revoked
+                } else {
+                    var isExpired = false
+                    if let expireDate = expireDate, currentTime >= expireDate {
+                        isExpired = true
+                    }
+                    var isFull = false
+                    
+                    if let usageLimit = usageLimit {
+                        if !isExpired {
+                            let remaining = usageLimit - count
+                            if remaining > 0 && remaining != usageLimit {
+                                subtitleText += ", "
+                                subtitleText += item.presentationData.strings.InviteLink_PeopleRemaining(remaining)
+                                
+                                let fraction = CGFloat(remaining) / CGFloat(usageLimit)
+                                if abs(fraction - availability) < 0.0001 {
+                                    timerValue = .fraction(fraction)
+                                }
+                            } else if remaining == 0 {
+                                isFull = true
+                                if !subtitleText.isEmpty {
+                                    subtitleText += " • "
+                                }
+                                subtitleText += item.presentationData.strings.InviteLink_UsageLimitReached
+                            }
+                        }
+                    }
+                    if let expireDate = expireDate, !isFull {
+                        if !isExpired {
+                            if !subtitleText.isEmpty {
+                                subtitleText += " • "
+                            }
+                            let elapsedTime = expireDate - currentTime
+                            if elapsedTime >= 86400 {
+                                subtitleText += item.presentationData.strings.InviteLink_ExpiresIn(scheduledTimeIntervalString(strings: item.presentationData.strings, value: elapsedTime)).string
+                            } else {
+                                subtitleText += item.presentationData.strings.InviteLink_ExpiresIn(textForTimeout(value: elapsedTime)).string
+                            }
+                            if timerValue == nil {
+                                timerValue = .timestamp(creation: startDate ?? date, deadline: expireDate)
+                            }
+                        } else {
+                            if !subtitleText.isEmpty {
+                                subtitleText += " • "
+                            }
+                            subtitleText += item.presentationData.strings.InviteLink_Expired
+                        }
+                    }
+                }
+            } else {
+                titleText = " "
+                subtitleText = " "
+            }
+            
+            let titleAttributedString = NSAttributedString(string: titleText, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            let subtitleAttributedString = NSAttributedString(string: subtitleText, font: subtitleFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+            
+            let leftInset: CGFloat = 65.0 + params.leftInset
+            let rightInset: CGFloat = 16.0 + params.rightInset
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = subtitleAttributedString.string.isEmpty ? 18.0 : 12.0
+            case .legacy:
+                verticalInset = subtitleAttributedString.string.isEmpty ? 14.0 : 8.0
+            }
+           
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: subtitleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (pricingLayout, pricingApply) = makePricingLayout(TextNodeLayoutArguments(attributedString: pricingAttributedText, backgroundColor: nil, maximumNumberOfLines: 2, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .right, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let titleSpacing: CGFloat = 1.0
+            
+            let minHeight: CGFloat = titleLayout.size.height + verticalInset * 2.0
+            let rawHeight: CGFloat = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + subtitleLayout.size.height
+            
+            var insets: UIEdgeInsets
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            switch item.style {
+                case .plain:
+                    itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                    insets = itemListNeighborsPlainInsets(neighbors)
+                    insets.top = firstWithHeader ? 29.0 : 0.0
+                    insets.bottom = 0.0
+                case .blocks:
+                    itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                    insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let contentSize = CGSize(width: params.width, height: max(minHeight, rawHeight))
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.layoutParams = (item, params, neighbors, firstWithHeader, last)
+                                        
+                    strongSelf.accessibilityLabel = titleAttributedString.string
+                    strongSelf.accessibilityValue = subtitleAttributedString.string
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.offsetContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.contentNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.containerNode.isGestureEnabled = item.contextAction != nil
+                    
+                    let nonExtractedRect = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width - 16.0, height: layout.contentSize.height))
+                    let extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: 16.0 + params.leftInset, dy: 0.0)
+                    strongSelf.extractedRect = extractedRect
+                    strongSelf.nonExtractedRect = nonExtractedRect
+                    
+                    if strongSelf.contextSourceNode.isExtractedToContextPreview {
+                        strongSelf.extractedBackgroundImageNode.frame = extractedRect
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.frame = nonExtractedRect
+                    }
+                    strongSelf.contextSourceNode.contentRect = extractedRect
+                     
+                    if let iconBackgroundLayer = strongSelf.iconBackgroundNode.layer as? CAGradientLayer {
+                        iconBackgroundLayer.colors = [
+                            topIconColor.cgColor,
+                            bottomIconColor.cgColor
+                        ]
+                    }
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                    
+                    let isPaid = item.invite?.pricing != nil
+                    if updatedTheme != nil || strongSelf.currentIsPaid != isPaid {
+                        strongSelf.currentIsPaid = isPaid
+                        if isPaid {
+                            strongSelf.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Item List/SubscriptionLink"), color: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                        } else {
+                            strongSelf.iconNode.image = generateTintedImage(image: UIImage(bundleImageName: "Item List/InviteLink"), color: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                        }
+                    }
+                                        
+                    let transition = ContainedViewLayoutTransition.immediate
+                                        
+                    let _ = titleApply()
+                    let _ = subtitleApply()
+                    let _ = pricingApply(TextNodeWithEntities.Arguments(context: item.context, cache: item.context.animationCache, renderer: item.context.animationRenderer, placeholderColor: item.presentationData.theme.list.mediaPlaceholderColor, attemptSynchronous: false))
+                    
+                    switch item.style {
+                        case .plain:
+                            if strongSelf.backgroundNode.supernode != nil {
+                                strongSelf.backgroundNode.removeFromSupernode()
+                            }
+                            if strongSelf.topStripeNode.supernode != nil {
+                                strongSelf.topStripeNode.removeFromSupernode()
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                            }
+                            if strongSelf.maskNode.supernode != nil {
+                                strongSelf.maskNode.removeFromSupernode()
+                            }
+                            
+                            let stripeInset: CGFloat
+                            if case .none = neighbors.bottom {
+                                stripeInset = 0.0
+                            } else {
+                                stripeInset = leftInset
+                            }
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: stripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - stripeInset, height: separatorHeight))
+                            strongSelf.bottomStripeNode.isHidden = last
+                        case .blocks:
+                            if strongSelf.backgroundNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                            }
+                            if strongSelf.topStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                            }
+                            if strongSelf.maskNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                            }
+                            
+                            let hasCorners = itemListHasRoundedBlockLayout(params)
+                            var hasTopCorners = false
+                            var hasBottomCorners = false
+                            switch neighbors.top {
+                                case .sameSection(false):
+                                    strongSelf.topStripeNode.isHidden = true
+                                default:
+                                    hasTopCorners = true
+                                    strongSelf.topStripeNode.isHidden = hasCorners
+                            }
+                            let bottomStripeInset: CGFloat
+                            switch neighbors.bottom {
+                                case .sameSection(false):
+                                    bottomStripeInset = leftInset
+                                    strongSelf.bottomStripeNode.isHidden = false
+                                default:
+                                    bottomStripeInset = 0.0
+                                    hasBottomCorners = true
+                                    strongSelf.bottomStripeNode.isHidden = hasCorners
+                            }
+                            
+                            strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                            
+                            strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                            strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                            strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    }
+                    
+                    let iconSize: CGSize = CGSize(width: 40.0, height: 40.0)
+                    let iconFrame = CGRect(origin: CGPoint(x: params.leftInset + 12.0, y: floorToScreenPixels((layout.contentSize.height - iconSize.height) / 2.0)), size: iconSize)
+                    strongSelf.iconBackgroundNode.bounds = CGRect(origin: CGPoint(), size: iconSize)
+                    strongSelf.iconBackgroundNode.position = iconFrame.center
+                    strongSelf.iconNode.frame = iconFrame
+                    
+                    transition.updateTransformScale(node: strongSelf.iconBackgroundNode, scale: timerValue != nil ? 0.875 : 1.0)
+                    
+                    if let timerValue = timerValue {
+                        let timerNode: TimerNode
+                        if let current = strongSelf.timerNode {
+                            timerNode = current
+                        } else {
+                            timerNode = TimerNode()
+                            timerNode.isUserInteractionEnabled = false
+                            strongSelf.timerNode = timerNode
+                            strongSelf.offsetContainerNode.addSubnode(timerNode)
+                        }
+                        timerNode.update(color: topIconColor, value: timerValue)
+                    } else if let timerNode = strongSelf.timerNode {
+                        strongSelf.timerNode = nil
+                        timerNode.removeFromSupernode()
+                    }
+                    
+                    strongSelf.timerNode?.frame = iconFrame.insetBy(dx: -5.0, dy: -5.0)
+                    
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.subtitleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset + titleLayout.size.height + titleSpacing), size: subtitleLayout.size))
+                    transition.updateFrame(node: strongSelf.pricingNode.textNode, frame: CGRect(origin: CGPoint(x: layout.contentSize.width - rightInset - pricingLayout.size.width, y: floorToScreenPixels((layout.contentSize.height - pricingLayout.size.height) / 2.0)), size: pricingLayout.size))
+                                        
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                    
+                    if item.invite == nil {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.placeholderNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.placeholderNode = shimmerNode
+                            strongSelf.addSubnode(shimmerNode)
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+                        
+                        var shapes: [ShimmerEffectNode.Shape] = []
+                        
+                        let titleLineWidth: CGFloat = 180.0
+                        let subtitleLineWidth: CGFloat = 60.0
+                        let lineDiameter: CGFloat = 10.0
+                        
+                        let iconFrame = strongSelf.iconBackgroundNode.frame
+                        shapes.append(.circle(iconFrame))
+                        
+                        let titleFrame = strongSelf.titleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: titleFrame.minX, y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: titleLineWidth, diameter: lineDiameter))
+                        
+                        let subtitleFrame = strongSelf.subtitleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: subtitleFrame.minX, y: subtitleFrame.minY + floor((subtitleFrame.height - lineDiameter) / 2.0)), width: subtitleLineWidth, diameter: lineDiameter))
+                        
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: layout.contentSize)
+                    } else if let shimmerNode = strongSelf.placeholderNode {
+                        strongSelf.placeholderNode = nil
+                        shimmerNode.removeFromSupernode()
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.placeholderNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+}
+
+private struct ContentParticle {
+    var position: CGPoint
+    var direction: CGPoint
+    var velocity: CGFloat
+    var alpha: CGFloat
+    var lifetime: Double
+    var beginTime: Double
+    
+    init(position: CGPoint, direction: CGPoint, velocity: CGFloat, alpha: CGFloat, lifetime: Double, beginTime: Double) {
+        self.position = position
+        self.direction = direction
+        self.velocity = velocity
+        self.alpha = alpha
+        self.lifetime = lifetime
+        self.beginTime = beginTime
+    }
+}
+
+private final class TimerNode: ASDisplayNode {
+    enum Value: Equatable {
+        case timestamp(creation: Int32, deadline: Int32)
+        case fraction(CGFloat)
+    }
+    private struct Params: Equatable {
+        var color: UIColor
+        var value: Value
+    }
+    
+    private let hierarchyTrackingNode: HierarchyTrackingNode
+    private var inHierarchyValue: Bool = false
+    
+    private var animator: ConstantDisplayLinkAnimator?
+    private let contentNode: ASDisplayNode
+    private var particles: [ContentParticle] = []
+    
+    private var currentParams: Params?
+    
+    var reachedTimeout: (() -> Void)?
+    
+    override init() {
+        var updateInHierarchy: ((Bool) -> Void)?
+        self.hierarchyTrackingNode = HierarchyTrackingNode({ value in
+            updateInHierarchy?(value)
+        })
+        
+        self.contentNode = ASDisplayNode()
+        
+        super.init()
+        
+        self.addSubnode(self.contentNode)
+        
+        updateInHierarchy = { [weak self] value in
+            guard let strongSelf = self else {
+                return
+            }
+            strongSelf.inHierarchyValue = value
+            strongSelf.animator?.isPaused = value
+        }
+    }
+    
+    deinit {
+        self.animator?.invalidate()
+    }
+    
+    func update(color: UIColor, value: Value) {
+        let params = Params(
+            color: color,
+            value: value
+        )
+        self.currentParams = params
+        
+        self.updateValues()
+    }
+    
+    private func updateValues() {
+        guard let params = self.currentParams else {
+            return
+        }
+
+        let color = params.color
+
+        let currentTimestamp = Int32(CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970)
+        var fraction: CGFloat
+        switch params.value {
+            case let .fraction(value):
+                fraction = value
+            case let .timestamp(creation, deadline):
+                fraction = CGFloat(deadline - currentTimestamp) / CGFloat(deadline - creation)
+        }
+        fraction = max(0.0001, 1.0 - max(0.0, min(1.0, fraction)))
+      
+        let image: UIImage?
+        
+        let diameter: CGFloat = 42.0
+        let inset: CGFloat = 8.0
+        let lineWidth: CGFloat = 2.0
+
+        let timestamp = CACurrentMediaTime()
+        
+        let center = CGPoint(x: (diameter + inset) / 2.0, y: (diameter + inset) / 2.0)
+        let radius: CGFloat = (diameter - lineWidth / 2.0) / 2.0
+        
+        let startAngle: CGFloat = -CGFloat.pi / 2.0
+        let endAngle: CGFloat = -CGFloat.pi / 2.0 + 2.0 * CGFloat.pi * fraction
+        
+        let sparks = fraction > 0.05 && fraction != 1.0
+        if sparks {
+            let v = CGPoint(x: sin(endAngle), y: -cos(endAngle))
+            let c = CGPoint(x: -v.y * radius + center.x, y: v.x * radius + center.y)
+            
+            let dt: CGFloat = 1.0 / 60.0
+            var removeIndices: [Int] = []
+            for i in 0 ..< self.particles.count {
+                let currentTime = timestamp - self.particles[i].beginTime
+                if currentTime > self.particles[i].lifetime {
+                    removeIndices.append(i)
+                } else {
+                    let input: CGFloat = CGFloat(currentTime / self.particles[i].lifetime)
+                    let decelerated: CGFloat = (1.0 - (1.0 - input) * (1.0 - input))
+                    self.particles[i].alpha = 1.0 - decelerated
+                    
+                    var p = self.particles[i].position
+                    let d = self.particles[i].direction
+                    let v = self.particles[i].velocity
+                    p = CGPoint(x: p.x + d.x * v * dt, y: p.y + d.y * v * dt)
+                    self.particles[i].position = p
+                }
+            }
+            
+            for i in removeIndices.reversed() {
+                self.particles.remove(at: i)
+            }
+            
+            let newParticleCount = 1
+            for _ in 0 ..< newParticleCount {
+                let degrees: CGFloat = CGFloat(arc4random_uniform(140)) - 40.0
+                let angle: CGFloat = degrees * CGFloat.pi / 180.0
+                
+                let direction = CGPoint(x: v.x * cos(angle) - v.y * sin(angle), y: v.x * sin(angle) + v.y * cos(angle))
+                let velocity = (20.0 + (CGFloat(arc4random()) / CGFloat(UINT32_MAX)) * 4.0) * 0.3
+                
+                let lifetime = Double(0.4 + CGFloat(arc4random_uniform(100)) * 0.01)
+                
+                let particle = ContentParticle(position: c, direction: direction, velocity: velocity, alpha: 1.0, lifetime: lifetime, beginTime: timestamp)
+                self.particles.append(particle)
+            }
+        }
+        
+        image = generateImage(CGSize(width: diameter + inset, height: diameter + inset), rotatedContext: { size, context in
+            context.clear(CGRect(origin: CGPoint(), size: size))
+            context.setStrokeColor(color.cgColor)
+            context.setFillColor(color.cgColor)
+            context.setLineWidth(lineWidth)
+            context.setLineCap(.round)
+            
+            let path = CGMutablePath()
+            path.addArc(center: center, radius: radius, startAngle: startAngle, endAngle: endAngle, clockwise: true)
+            context.addPath(path)
+            context.strokePath()
+            
+            if sparks {
+                for particle in self.particles {
+                    let size: CGFloat = 2.0
+                    context.setAlpha(particle.alpha)
+                    context.fillEllipse(in: CGRect(origin: CGPoint(x: particle.position.x - size / 2.0, y: particle.position.y - size / 2.0), size: CGSize(width: size, height: size)))
+                }
+            }
+        })
+        
+        self.contentNode.contents = image?.cgImage
+        if let image = image {
+            self.contentNode.frame = CGRect(origin: CGPoint(), size: image.size)
+        }
+             
+        if fraction <= .ulpOfOne {
+            self.animator?.invalidate()
+            self.animator = nil
+        } else {
+            if self.animator == nil {
+                let animator = ConstantDisplayLinkAnimator(update: { [weak self] in
+                    self?.updateValues()
+                })
+                self.animator = animator
+                animator.isPaused = self.inHierarchyValue
+            }
+        }
+    }
+}

submodules/InviteLinksUI/Sources/ItemListInviteLinkUsageLimitItem.swift

@@ -0,0 +1,411 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import TelegramCore
+import TelegramUIPreferences
+import TelegramPresentationData
+import LegacyComponents
+import ItemListUI
+import PresentationDataUtils
+
+enum InviteLinkUsageLimit: Equatable {
+    case low
+    case medium
+    case high
+    case unlimited
+    case custom(Int32)
+    
+    init(position: Int) {
+        switch position {
+        case 0:
+            self = .low
+        case 1:
+            self = .medium
+        case 2:
+            self = .high
+        default:
+            self = .unlimited
+        }
+    }
+    
+    init(value: Int32?) {
+        if value == 0 {
+            self = .unlimited
+        } else if let value = value {
+            if value == 1 {
+                self = .low
+            } else if value == 10 {
+                self = .medium
+            } else if value == 100 {
+                self = .high
+            } else {
+                self = .custom(value)
+            }
+        } else {
+            self = .unlimited
+        }
+    }
+    
+    var value: Int32? {
+        switch self {
+        case .low:
+            return 1
+        case .medium:
+            return 10
+        case .high:
+            return 100
+        case .unlimited:
+            return 0
+        case let .custom(value):
+            return value
+        }
+    }
+    
+    var position: Int {
+        switch self {
+        case .low:
+            return 0
+        case .medium:
+            return 1
+        case .high:
+            return 2
+        case .unlimited:
+            return 3
+        case let .custom(value):
+            if value < 10 {
+                return 1
+            } else if value < 100 {
+                return 2
+            } else {
+                return 3
+            }
+        }
+    }
+}
+
+final class ItemListInviteLinkUsageLimitItem: ListViewItem, ItemListItem {
+    let theme: PresentationTheme
+    let strings: PresentationStrings
+    let dateTimeFormat: PresentationDateTimeFormat
+    let value: InviteLinkUsageLimit
+    let enabled: Bool
+    let sectionId: ItemListSectionId
+    let updated: (InviteLinkUsageLimit) -> Void
+    
+    init(theme: PresentationTheme, strings: PresentationStrings, dateTimeFormat: PresentationDateTimeFormat, value: InviteLinkUsageLimit, enabled: Bool, sectionId: ItemListSectionId, updated: @escaping (InviteLinkUsageLimit) -> Void) {
+        self.theme = theme
+        self.strings = strings
+        self.dateTimeFormat = dateTimeFormat
+        self.value = value
+        self.enabled = enabled
+        self.sectionId = sectionId
+        self.updated = updated
+    }
+    
+    func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = ItemListInviteLinkUsageLimitItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListInviteLinkUsageLimitItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+}
+
+private final class ItemListInviteLinkUsageLimitItemNode: ListViewItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let lowTextNode: TextNode
+    private let mediumTextNode: TextNode
+    private let highTextNode: TextNode
+    private let unlimitedTextNode: TextNode
+    private let customTextNode: TextNode
+    private var sliderView: TGPhotoEditorSliderView?
+    
+    private var item: ItemListInviteLinkUsageLimitItem?
+    private var layoutParams: ListViewItemLayoutParams?
+    
+    init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        
+        self.lowTextNode = TextNode()
+        self.lowTextNode.isUserInteractionEnabled = false
+        self.lowTextNode.displaysAsynchronously = false
+        
+        self.mediumTextNode = TextNode()
+        self.mediumTextNode.isUserInteractionEnabled = false
+        self.mediumTextNode.displaysAsynchronously = false
+        
+        self.highTextNode = TextNode()
+        self.highTextNode.isUserInteractionEnabled = false
+        self.highTextNode.displaysAsynchronously = false
+        
+        self.unlimitedTextNode = TextNode()
+        self.unlimitedTextNode.isUserInteractionEnabled = false
+        self.unlimitedTextNode.displaysAsynchronously = false
+      
+        self.customTextNode = TextNode()
+        self.customTextNode.isUserInteractionEnabled = false
+        self.customTextNode.displaysAsynchronously = false
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.lowTextNode)
+        self.addSubnode(self.mediumTextNode)
+        self.addSubnode(self.highTextNode)
+        self.addSubnode(self.unlimitedTextNode)
+        self.addSubnode(self.customTextNode)
+    }
+    
+    func updateSliderView() {
+        if let sliderView = self.sliderView, let item = self.item {
+            if case .custom = item.value {
+                sliderView.maximumValue = 3.0 + 1
+                sliderView.positionsCount = 4 + 1
+            } else {
+                sliderView.maximumValue = 3.0
+                sliderView.positionsCount = 4
+            }
+            sliderView.value = CGFloat(item.value.position)
+            
+            sliderView.isUserInteractionEnabled = item.enabled
+            sliderView.alpha = item.enabled ? 1.0 : 0.4
+            sliderView.layer.allowsGroupOpacity = !item.enabled
+        }
+    }
+    
+    override func didLoad() {
+        super.didLoad()
+        
+        let sliderView = TGPhotoEditorSliderView()
+        sliderView.enablePanHandling = true
+        sliderView.trackCornerRadius = 2.0
+        sliderView.lineSize = 4.0
+        sliderView.dotSize = 5.0
+        sliderView.minimumValue = 0.0
+        sliderView.startValue = 0.0
+        sliderView.disablesInteractiveTransitionGestureRecognizer = true
+        if let item = self.item, case .custom = item.value {
+            sliderView.maximumValue = 3.0 + 1
+            sliderView.positionsCount = 4 + 1
+        } else {
+            sliderView.maximumValue = 3.0
+            sliderView.positionsCount = 4
+        }
+        sliderView.useLinesForPositions = true
+        if let item = self.item, let params = self.layoutParams {
+            sliderView.value = CGFloat(item.value.position)
+            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+            sliderView.trackColor = item.theme.list.itemAccentColor
+            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+            
+            sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+            sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+        }
+        self.view.addSubview(sliderView)
+        sliderView.addTarget(self, action: #selector(self.sliderValueChanged), for: .valueChanged)
+        self.sliderView = sliderView
+        
+        self.updateSliderView()
+    }
+    
+    func asyncLayout() -> (_ item: ItemListInviteLinkUsageLimitItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let currentItem = self.item
+        let makeLowTextLayout = TextNode.asyncLayout(self.lowTextNode)
+        let makeMediumTextLayout = TextNode.asyncLayout(self.mediumTextNode)
+        let makeHighTextLayout = TextNode.asyncLayout(self.highTextNode)
+        let makeUnlimitedTextLayout = TextNode.asyncLayout(self.unlimitedTextNode)
+        let makeCustomTextLayout = TextNode.asyncLayout(self.customTextNode)
+        
+        return { item, params, neighbors in
+            var themeUpdated = false
+            if currentItem?.theme !== item.theme {
+                themeUpdated = true
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            
+            let (lowTextLayout, lowTextApply) = makeLowTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: "1", font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+
+            let (mediumTextLayout, mediumTextApply) = makeMediumTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: "10", font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (highTextLayout, highTextApply) = makeHighTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: "100", font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let (unlimitedTextLayout, unlimitedTextApply) = makeUnlimitedTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.strings.InviteLink_Create_UsersLimitNoLimit, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            let customTextString: String
+            if case let .custom(value) = item.value {
+                customTextString = compactNumericCountString(Int(value), decimalSeparator: item.dateTimeFormat.decimalSeparator)
+            } else {
+                customTextString = ""
+            }
+            
+            let (customTextLayout, customTextApply) = makeCustomTextLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: customTextString, font: Font.regular(13.0), textColor: item.theme.list.itemSecondaryTextColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width, height: CGFloat.greatestFiniteMagnitude), alignment: .center, lineSpacing: 0.0, cutout: nil, insets: UIEdgeInsets()))
+            
+            contentSize = CGSize(width: params.width, height: 88.0)
+            insets = itemListNeighborsGroupedInsets(neighbors, params)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            let layoutSize = layout.size
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.layoutParams = params
+                    
+                    strongSelf.backgroundNode.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                    strongSelf.topStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    strongSelf.bottomStripeNode.backgroundColor = item.theme.list.itemBlocksSeparatorColor
+                    
+                    if strongSelf.backgroundNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                    }
+                    if strongSelf.topStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                    }
+                    if strongSelf.bottomStripeNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                    }
+                    if strongSelf.maskNode.supernode == nil {
+                        strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                    }
+                    
+                    let hasCorners = itemListHasRoundedBlockLayout(params)
+                    var hasTopCorners = false
+                    var hasBottomCorners = false
+                    switch neighbors.top {
+                        case .sameSection(false):
+                            strongSelf.topStripeNode.isHidden = true
+                        default:
+                            hasTopCorners = true
+                            strongSelf.topStripeNode.isHidden = hasCorners
+                    }
+                    let bottomStripeInset: CGFloat
+                    let bottomStripeOffset: CGFloat
+                    switch neighbors.bottom {
+                    case .sameSection(false):
+                        bottomStripeInset = 0.0 //params.leftInset + 16.0
+                        bottomStripeOffset = -separatorHeight
+                        strongSelf.bottomStripeNode.isHidden = false
+                    default:
+                        bottomStripeInset = 0.0
+                        bottomStripeOffset = 0.0
+                        hasBottomCorners = true
+                        strongSelf.bottomStripeNode.isHidden = hasCorners
+                    }
+                    
+                    strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                    
+                    strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                    strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                    strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: layoutSize.width, height: separatorHeight))
+                    strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height + bottomStripeOffset), size: CGSize(width: layoutSize.width - bottomStripeInset, height: separatorHeight))
+                    
+                    let _ = lowTextApply()
+                    let _ = mediumTextApply()
+                    let _ = highTextApply()
+                    let _ = unlimitedTextApply()
+                    let _ = customTextApply()
+                    
+                    var textNodes: [(TextNode, CGSize)] = [(strongSelf.lowTextNode, lowTextLayout.size),
+                                                           (strongSelf.mediumTextNode, mediumTextLayout.size),
+                                                           (strongSelf.highTextNode, highTextLayout.size),
+                                                           (strongSelf.unlimitedTextNode, unlimitedTextLayout.size)]
+                    if case .custom = item.value {
+                        textNodes.insert((strongSelf.customTextNode, customTextLayout.size), at: item.value.position)
+                    }
+                    
+                    let delta = (params.width - params.leftInset - params.rightInset - 18.0 * 2.0) / CGFloat(textNodes.count - 1)
+                    for i in 0 ..< textNodes.count {
+                        let (textNode, textSize) = textNodes[i]
+                        
+                        var position = params.leftInset + 18.0 + delta * CGFloat(i)
+                        if i == textNodes.count - 1 {
+                            position -= textSize.width
+                        } else if i > 0 {
+                            position -= textSize.width / 2.0
+                        }
+                        
+                        textNode.frame = CGRect(origin: CGPoint(x: position, y: 15.0), size: textSize)
+                    }
+                    
+                    if let sliderView = strongSelf.sliderView {
+                        if themeUpdated {
+                            sliderView.backgroundColor = item.theme.list.itemBlocksBackgroundColor
+                            sliderView.backColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.startColor = item.theme.list.itemSwitchColors.frameColor
+                            sliderView.trackColor = item.theme.list.itemAccentColor
+                            sliderView.knobImage = PresentationResourcesItemList.knobImage(item.theme)
+                        }
+                        
+                        sliderView.frame = CGRect(origin: CGPoint(x: params.leftInset + 15.0, y: 37.0), size: CGSize(width: params.width - params.leftInset - params.rightInset - 15.0 * 2.0, height: 44.0))
+                        sliderView.hitTestEdgeInsets = UIEdgeInsets(top: -sliderView.frame.minX, left: 0.0, bottom: 0.0, right: -sliderView.frame.minX)
+                        
+                        strongSelf.updateSliderView()
+                    }
+                }
+            })
+        }
+    }
+    
+    override func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    @objc func sliderValueChanged() {
+        guard let sliderView = self.sliderView else {
+            return
+        }
+        
+        let position = Int(sliderView.value)
+        let value = InviteLinkUsageLimit(position: position)
+        self.item?.updated(value)
+    }
+}
+

submodules/InviteLinksUI/Sources/ItemListInviteRequestItem.swift

@@ -0,0 +1,877 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import TelegramUIPreferences
+import TelegramStringFormatting
+import ItemListUI
+import ShimmerEffect
+import LocalizedPeerData
+import AvatarNode
+import AccountContext
+import SolidRoundedButtonNode
+import PeerInfoAvatarListNode
+import ContextUI
+
+private let backgroundCornerRadius: CGFloat = 14.0
+
+public class ItemListInviteRequestItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let dateTimeFormat: PresentationDateTimeFormat
+    let nameDisplayOrder: PresentationPersonNameOrder
+    let importer: PeerInvitationImportersState.Importer?
+    let isGroup: Bool
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let tapAction: (() -> Void)?
+    let addAction: (() -> Void)?
+    let dismissAction: (() -> Void)?
+    let contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        dateTimeFormat: PresentationDateTimeFormat,
+        nameDisplayOrder: PresentationPersonNameOrder,
+        importer: PeerInvitationImportersState.Importer?,
+        isGroup: Bool,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        tapAction: (() -> Void)?,
+        addAction: (() -> Void)?,
+        dismissAction: (() -> Void)?,
+        contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.dateTimeFormat = dateTimeFormat
+        self.nameDisplayOrder = nameDisplayOrder
+        self.importer = importer
+        self.isGroup = isGroup
+        self.sectionId = sectionId
+        self.style = style
+        self.tapAction = tapAction
+        self.addAction = addAction
+        self.dismissAction = dismissAction
+        self.contextAction = contextAction
+        self.tag = tag
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            var firstWithHeader = false
+            var last = false
+            if self.style == .plain {
+                if previousItem == nil {
+                    firstWithHeader = true
+                }
+                if nextItem == nil {
+                    last = true
+                }
+            }
+            let node = ItemListInviteRequestItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListInviteRequestItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    var firstWithHeader = false
+                    var last = false
+                    if self.style == .plain {
+                        if previousItem == nil {
+                            firstWithHeader = true
+                        }
+                        if nextItem == nil {
+                            last = true
+                        }
+                    }
+                    
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem), firstWithHeader, last)
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = true
+    
+    public func selected(listView: ListView) {
+        listView.clearHighlightAnimated(true)
+        self.tapAction?()
+    }
+}
+
+private let avatarFont = avatarPlaceholderFont(size: floor(40.0 * 16.0 / 37.0))
+
+public class ItemListInviteRequestItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let highlightedBackgroundNode: ASDisplayNode
+    private let maskNode: ASImageNode
+
+    private let containerNode: ContextControllerSourceNode
+    private let contextSourceNode: ContextExtractedContentContainingNode
+    private let extractedBackgroundImageNode: ASImageNode
+    private let offsetContainerNode: ASDisplayNode
+
+    private var extractedRect: CGRect?
+    private var nonExtractedRect: CGRect?
+    private var extractedVerticalOffset: CGFloat?
+    
+    fileprivate let avatarNode: AvatarNode
+    private let contentWrapperNode: ASDisplayNode
+    private let titleNode: TextNode
+    private let subtitleNode: TextNode
+    private let expandedSubtitleNode: TextNode
+    private let dateNode: TextNode
+    private let measureAddNode: TextNode
+    private let addButton: SolidRoundedButtonNode
+    private let dismissButton: HighlightableButtonNode
+    
+    private var avatarTransitionNode: ASImageNode?
+    private var avatarListContainerNode: ASDisplayNode?
+    private var avatarListWrapperNode: PinchSourceContainerNode?
+    private var avatarListNode: PeerInfoAvatarListContainerNode?
+    
+    private var placeholderNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    private var layoutParams: (ItemListInviteRequestItem, ListViewItemLayoutParams, ItemListNeighbors, Bool, Bool)?
+    
+    public var tag: ItemListItemTag?
+    
+    private var isExtracted = false
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.maskNode = ASImageNode()
+        self.maskNode.isUserInteractionEnabled = false
+        
+        self.extractedBackgroundImageNode = ASImageNode()
+        self.extractedBackgroundImageNode.displaysAsynchronously = false
+        self.extractedBackgroundImageNode.alpha = 0.0
+        
+        self.contextSourceNode = ContextExtractedContentContainingNode()
+        self.containerNode = ContextControllerSourceNode()
+        
+        self.offsetContainerNode = ASDisplayNode()
+    
+        self.titleNode = TextNode()
+        self.titleNode.isUserInteractionEnabled = false
+        self.titleNode.contentMode = .left
+        self.titleNode.contentsScale = UIScreen.main.scale
+    
+        self.subtitleNode = TextNode()
+        self.subtitleNode.isUserInteractionEnabled = false
+        self.subtitleNode.contentMode = .left
+        self.subtitleNode.contentsScale = UIScreen.main.scale
+        
+        self.expandedSubtitleNode = TextNode()
+        self.expandedSubtitleNode.alpha = 0.0
+        self.expandedSubtitleNode.isUserInteractionEnabled = false
+        self.expandedSubtitleNode.contentMode = .left
+        self.expandedSubtitleNode.contentsScale = UIScreen.main.scale
+        
+        self.dateNode = TextNode()
+        self.dateNode.isUserInteractionEnabled = false
+        self.dateNode.contentMode = .left
+        self.dateNode.contentsScale = UIScreen.main.scale
+        
+        self.measureAddNode = TextNode()
+        
+        self.addButton = SolidRoundedButtonNode(theme: SolidRoundedButtonTheme(backgroundColor: .black, foregroundColor: .white), fontSize: 15.0, height: 32.0, cornerRadius: 16.0)
+        self.dismissButton = HighlightableButtonNode()
+            
+        self.highlightedBackgroundNode = ASDisplayNode()
+        self.highlightedBackgroundNode.isLayerBacked = true
+        
+        self.avatarNode = AvatarNode(font: avatarFont)
+        
+        self.contentWrapperNode = ASDisplayNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false, rotated: false, seeThrough: false)
+        
+        self.isAccessibilityElement = true
+        
+        self.containerNode.addSubnode(self.contextSourceNode)
+        self.containerNode.targetNodeForActivationProgress = self.contextSourceNode.contentNode
+        self.addSubnode(self.containerNode)
+        
+        self.contextSourceNode.contentNode.addSubnode(self.extractedBackgroundImageNode)
+        self.contextSourceNode.contentNode.addSubnode(self.offsetContainerNode)
+        
+        self.offsetContainerNode.addSubnode(self.contentWrapperNode)
+        self.contentWrapperNode.addSubnode(self.avatarNode)
+        self.contentWrapperNode.addSubnode(self.titleNode)
+        self.contentWrapperNode.addSubnode(self.subtitleNode)
+        self.contentWrapperNode.addSubnode(self.expandedSubtitleNode)
+        self.contentWrapperNode.addSubnode(self.dateNode)
+        self.contentWrapperNode.addSubnode(self.addButton)
+        self.contentWrapperNode.addSubnode(self.dismissButton)
+        
+        self.addButton.pressed = { [weak self] in
+            if let (item, _, _, _, _) = self?.layoutParams {
+                item.addAction?()
+            }
+        }
+        self.dismissButton.addTarget(self, action: #selector(self.dismissPressed), forControlEvents: .touchUpInside)
+        
+        self.containerNode.shouldBegin = { [weak self] point in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0 else {
+                return false
+            }
+            if item.importer == nil || strongSelf.addButton.frame.contains(point) || strongSelf.dismissButton.frame.contains(point)  {
+                return false
+            }
+            return true
+        }
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0, let _ = item.importer, let contextAction = item.contextAction else {
+                gesture.cancel()
+                return
+            }
+            contextAction(strongSelf.contextSourceNode, gesture)
+        }
+
+        self.contextSourceNode.willUpdateIsExtractedToContextPreview = { [weak self] isExtracted, transition in
+            guard let strongSelf = self, let item = strongSelf.layoutParams?.0, let peer = item.importer?.peer.peer else {
+                return
+            }
+            
+            strongSelf.isExtracted = isExtracted
+            
+            if isExtracted {
+                strongSelf.contextSourceNode.contentNode.customHitTest = { [weak self] point in
+                    if let strongSelf = self {
+                        if let avatarListWrapperNode = strongSelf.avatarListWrapperNode, avatarListWrapperNode.frame.contains(point) {
+                            return strongSelf.avatarListNode?.view
+                        }
+                    }
+                    return nil
+                }
+            } else {
+                strongSelf.contextSourceNode.contentNode.customHitTest = nil
+            }
+                       
+            let extractedVerticalOffset = strongSelf.extractedVerticalOffset ?? 0.0
+            if let extractedRect = strongSelf.extractedRect, let nonExtractedRect = strongSelf.nonExtractedRect {
+                let rect: CGRect
+                if isExtracted {
+                    if extractedVerticalOffset > 0.0 {
+                        rect = CGRect(x: extractedRect.minX - 16.0, y: extractedRect.minY + extractedVerticalOffset, width: extractedRect.width, height: extractedRect.height - extractedVerticalOffset)
+                    } else {
+                        rect = extractedRect
+                    }
+                } else {
+                    rect = nonExtractedRect
+                }
+                
+                let springDuration: Double = isExtracted ? 0.42 : 0.3
+                let springDamping: CGFloat = isExtracted ? 124.0 : 1000.0
+                
+                let itemBackgroundColor: UIColor
+                switch item.style {
+                    case .plain:
+                        itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                    case .blocks:
+                        itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                }
+                                
+                if !extractedVerticalOffset.isZero {
+                    let radiusTransition = ContainedViewLayoutTransition.animated(duration: 0.15, curve: .easeInOut)
+                    if isExtracted {
+                        strongSelf.extractedBackgroundImageNode.image = generateImage(CGSize(width: backgroundCornerRadius * 2.0, height: backgroundCornerRadius * 2.0), rotatedContext: { (size, context) in
+                            let bounds = CGRect(origin: CGPoint(), size: size)
+                            context.clear(bounds)
+                            
+                            context.setFillColor(itemBackgroundColor.cgColor)
+                            context.fillEllipse(in: bounds)
+                            context.fill(CGRect(x: 0.0, y: 0.0, width: size.width, height: size.height / 2.0))
+                        })?.stretchableImage(withLeftCapWidth: Int(backgroundCornerRadius), topCapHeight: Int(backgroundCornerRadius))
+                                              
+                        strongSelf.avatarNode.transform = CATransform3DIdentity
+                        var avatarInitialRect = strongSelf.avatarNode.view.convert(strongSelf.avatarNode.bounds, to: strongSelf.offsetContainerNode.supernode?.view)
+                        if strongSelf.avatarTransitionNode == nil {
+                            let targetRect = CGRect(x: extractedRect.minX - 16.0, y: extractedRect.minY, width: extractedRect.width, height: extractedRect.width)
+                            let initialScale = avatarInitialRect.width / targetRect.width
+                            avatarInitialRect.origin.y += backgroundCornerRadius / 2.0 * initialScale
+                            
+                            let avatarListWrapperNode = PinchSourceContainerNode()
+                            avatarListWrapperNode.clipsToBounds = true
+                            avatarListWrapperNode.cornerRadius = backgroundCornerRadius
+                            avatarListWrapperNode.activate = { [weak self] sourceNode in
+                                guard let strongSelf = self else {
+                                    return
+                                }
+                                strongSelf.avatarListNode?.controlsContainerNode.alpha = 0.0
+                                let pinchController = PinchController(sourceNode: sourceNode, getContentAreaInScreenSpace: {
+                                    return UIScreen.main.bounds
+                                })
+                                item.context.sharedContext.mainWindow?.presentInGlobalOverlay(pinchController)
+                            }
+                            avatarListWrapperNode.deactivated = { [weak self] in
+                                guard let strongSelf = self else {
+                                    return
+                                }
+                                strongSelf.avatarListWrapperNode?.contentNode.layer.animate(from: 0.0 as NSNumber, to: backgroundCornerRadius as NSNumber, keyPath: "cornerRadius", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.3, completion: { _ in
+                                })
+                            }
+                            avatarListWrapperNode.update(size: targetRect.size, transition: .immediate)
+                            avatarListWrapperNode.frame = CGRect(x: targetRect.minX, y: targetRect.minY, width: targetRect.width, height: targetRect.height + backgroundCornerRadius)
+                            avatarListWrapperNode.animatedOut = { [weak self] in
+                                guard let strongSelf = self else {
+                                    return
+                                }
+                                strongSelf.avatarListNode?.controlsContainerNode.alpha = 1.0
+                                strongSelf.avatarListNode?.controlsContainerNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.25)
+                            }
+                            
+                            let transitionNode = ASImageNode()
+                            transitionNode.clipsToBounds = true
+                            transitionNode.displaysAsynchronously = false
+                            transitionNode.displayWithoutProcessing = true
+                            transitionNode.image = strongSelf.avatarNode.unroundedImage
+                            transitionNode.frame = CGRect(origin: CGPoint(), size: targetRect.size)
+                            transitionNode.cornerRadius = targetRect.width / 2.0
+                            radiusTransition.updateCornerRadius(node: transitionNode, cornerRadius: 0.0)
+                            
+                            strongSelf.avatarNode.isHidden = true
+                            avatarListWrapperNode.contentNode.addSubnode(transitionNode)
+                            
+                            strongSelf.avatarTransitionNode = transitionNode
+    
+                            let avatarListContainerNode = ASDisplayNode()
+                            avatarListContainerNode.clipsToBounds = true
+                            avatarListContainerNode.frame = CGRect(origin: CGPoint(), size: targetRect.size)
+                            avatarListContainerNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+                            avatarListContainerNode.cornerRadius = targetRect.width / 2.0
+                            
+                            avatarListWrapperNode.layer.animateSpring(from: initialScale as NSNumber, to: 1.0 as NSNumber, keyPath: "transform.scale", duration: springDuration, initialVelocity: 0.0, damping: springDamping)
+                            avatarListWrapperNode.layer.animateSpring(from: NSValue(cgPoint: avatarInitialRect.center), to: NSValue(cgPoint: avatarListWrapperNode.position), keyPath: "position", duration: springDuration, initialVelocity: 0.0, damping: springDamping)
+                            
+                            radiusTransition.updateCornerRadius(node: avatarListContainerNode, cornerRadius: 0.0)
+                            
+                            let avatarListNode = PeerInfoAvatarListContainerNode(context: item.context)
+                            avatarListWrapperNode.contentNode.clipsToBounds = true
+                            avatarListNode.backgroundColor = .clear
+                            avatarListNode.peer = EnginePeer(peer)
+                            avatarListNode.firstFullSizeOnly = true
+                            avatarListNode.offsetLocation = true
+                            avatarListNode.customCenterTapAction = { [weak self] in
+                                self?.contextSourceNode.requestDismiss?()
+                            }
+                            avatarListNode.frame = CGRect(x: targetRect.width / 2.0, y: targetRect.height / 2.0, width: targetRect.width, height: targetRect.height)
+                            avatarListNode.controlsClippingNode.frame = CGRect(x: -targetRect.width / 2.0, y: -targetRect.height / 2.0, width: targetRect.width, height: targetRect.height)
+                            avatarListNode.controlsClippingOffsetNode.frame = CGRect(origin: CGPoint(x: targetRect.width / 2.0, y: targetRect.height / 2.0), size: CGSize())
+                            avatarListNode.stripContainerNode.frame = CGRect(x: 0.0, y: 13.0, width: targetRect.width, height: 2.0)
+                            avatarListNode.topShadowNode.frame = CGRect(x: 0.0, y: 0.0, width: targetRect.width, height: 44.0)
+                            
+                            avatarListContainerNode.addSubnode(avatarListNode)
+                            avatarListContainerNode.addSubnode(avatarListNode.controlsClippingOffsetNode)
+                            avatarListWrapperNode.contentNode.addSubnode(avatarListContainerNode)
+                            
+                            avatarListNode.update(size: targetRect.size, peer: EnginePeer(peer), customNode: nil, additionalEntry: .single(nil), isExpanded: true, transition: .immediate)
+                            strongSelf.offsetContainerNode.supernode?.addSubnode(avatarListWrapperNode)
+                            
+                            strongSelf.avatarListWrapperNode = avatarListWrapperNode
+                            strongSelf.avatarListContainerNode = avatarListContainerNode
+                            strongSelf.avatarListNode = avatarListNode
+                        }
+                    } else if let transitionNode = strongSelf.avatarTransitionNode, let avatarListWrapperNode = strongSelf.avatarListWrapperNode, let avatarListContainerNode = strongSelf.avatarListContainerNode {
+                        
+                        var avatarInitialRect = CGRect(origin: strongSelf.avatarNode.frame.origin, size: strongSelf.avatarNode.frame.size)
+                        let targetScale = avatarInitialRect.width / avatarListContainerNode.frame.width
+                        avatarInitialRect.origin.y += backgroundCornerRadius / 2.0 * targetScale
+                        
+                        strongSelf.avatarTransitionNode = nil
+                        strongSelf.avatarListWrapperNode = nil
+                        strongSelf.avatarListContainerNode = nil
+                        strongSelf.avatarListNode = nil
+                        
+                        avatarListContainerNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, removeOnCompletion: false, completion: { [weak avatarListContainerNode, weak avatarListWrapperNode] _ in
+                            avatarListContainerNode?.removeFromSupernode()
+                            avatarListWrapperNode?.removeFromSupernode()
+                        })
+                                                
+                        avatarListWrapperNode.layer.animate(from: 1.0 as NSNumber, to: targetScale as NSNumber, keyPath: "transform.scale", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.2, removeOnCompletion: false)
+                        avatarListWrapperNode.layer.animate(from: NSValue(cgPoint: avatarListWrapperNode.position), to: NSValue(cgPoint: avatarInitialRect.center), keyPath: "position", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.2, removeOnCompletion: false, completion: { [weak transitionNode, weak self] _ in
+                            transitionNode?.removeFromSupernode()
+                            self?.avatarNode.isHidden = false
+                        })
+    
+                        radiusTransition.updateCornerRadius(node: avatarListContainerNode, cornerRadius: avatarListContainerNode.frame.width / 2.0)
+                        radiusTransition.updateCornerRadius(node: transitionNode, cornerRadius: avatarListContainerNode.frame.width / 2.0)
+                    }
+                    
+                    let alphaTransition = ContainedViewLayoutTransition.animated(duration: 0.2, curve: .easeInOut)
+                    alphaTransition.updateAlpha(node: strongSelf.subtitleNode, alpha: isExtracted ? 0.0 : 1.0)
+                    alphaTransition.updateAlpha(node: strongSelf.expandedSubtitleNode, alpha: isExtracted ? 1.0 : 0.0)
+                    alphaTransition.updateAlpha(node: strongSelf.dateNode, alpha: isExtracted ? 0.0 : 1.0)
+                    alphaTransition.updateAlpha(node: strongSelf.addButton, alpha: isExtracted ? 0.0 : 1.0, delay: isExtracted ? 0.0 : 0.1)
+                    alphaTransition.updateAlpha(node: strongSelf.dismissButton, alpha: isExtracted ? 0.0 : 1.0, delay: isExtracted ? 0.0 : 0.1)
+                    
+                    var sublayerOffset: CGFloat = -64.0
+                    if item.style == .plain {
+                        sublayerOffset += 16.0
+                    }
+                    
+                    let offsetInitialSublayerTransform = strongSelf.offsetContainerNode.layer.sublayerTransform
+                    strongSelf.offsetContainerNode.layer.sublayerTransform = CATransform3DMakeTranslation(isExtracted ? sublayerOffset : 0.0, isExtracted ? extractedVerticalOffset : 0.0, 0.0)
+                    
+                    let initialExtractedBackgroundPosition = strongSelf.extractedBackgroundImageNode.position
+                    strongSelf.extractedBackgroundImageNode.layer.position = rect.center
+                    let initialExtractedBackgroundBounds = strongSelf.extractedBackgroundImageNode.bounds
+                    strongSelf.extractedBackgroundImageNode.layer.bounds = CGRect(origin: CGPoint(), size: rect.size)
+                    if isExtracted {
+                        strongSelf.offsetContainerNode.layer.animateSpring(from: NSValue(caTransform3D: offsetInitialSublayerTransform), to: NSValue(caTransform3D: strongSelf.offsetContainerNode.layer.sublayerTransform), keyPath: "sublayerTransform", duration: springDuration, delay: 0.0, initialVelocity: 0.0, damping: springDamping)
+                        strongSelf.extractedBackgroundImageNode.layer.animateSpring(from: NSValue(cgPoint: initialExtractedBackgroundPosition), to: NSValue(cgPoint: strongSelf.extractedBackgroundImageNode.position), keyPath: "position", duration: springDuration, delay: 0.0, initialVelocity: 0.0, damping: springDamping)
+                        strongSelf.extractedBackgroundImageNode.layer.animateSpring(from: NSValue(cgRect: initialExtractedBackgroundBounds), to: NSValue(cgRect: strongSelf.extractedBackgroundImageNode.bounds), keyPath: "bounds", duration: springDuration, initialVelocity: 0.0, damping: springDamping)
+                    } else {
+                        strongSelf.offsetContainerNode.layer.animate(from: NSValue(caTransform3D: offsetInitialSublayerTransform), to: NSValue(caTransform3D: strongSelf.offsetContainerNode.layer.sublayerTransform), keyPath: "sublayerTransform", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.2)
+                        strongSelf.extractedBackgroundImageNode.layer.animate(from: NSValue(cgPoint: initialExtractedBackgroundPosition), to: NSValue(cgPoint: strongSelf.extractedBackgroundImageNode.position), keyPath: "position", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.2)
+                        strongSelf.extractedBackgroundImageNode.layer.animate(from: NSValue(cgRect: initialExtractedBackgroundBounds), to: NSValue(cgRect: strongSelf.extractedBackgroundImageNode.bounds), keyPath: "bounds", timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, duration: 0.2)
+                    }
+
+                    if isExtracted {
+                        strongSelf.extractedBackgroundImageNode.alpha = 1.0
+                        strongSelf.extractedBackgroundImageNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.1, delay: 0.1, timingFunction: CAMediaTimingFunctionName.easeOut.rawValue)
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.alpha = 0.0
+                        strongSelf.extractedBackgroundImageNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, delay: 0.0, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, removeOnCompletion: false, completion: { [weak self] _ in
+                            if let strongSelf = self {
+                                strongSelf.extractedBackgroundImageNode.image = nil
+                                strongSelf.extractedBackgroundImageNode.layer.removeAllAnimations()
+                            }
+                        })
+                    }
+                } else {
+                    if isExtracted {
+                        strongSelf.extractedBackgroundImageNode.alpha = 1.0
+                        strongSelf.extractedBackgroundImageNode.image = generateStretchableFilledCircleImage(diameter: backgroundCornerRadius * 2.0, color: item.presentationData.theme.list.itemBlocksBackgroundColor)
+                        strongSelf.extractedBackgroundImageNode.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.1, delay: 0.1, timingFunction: CAMediaTimingFunctionName.easeOut.rawValue)
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.alpha = 0.0
+                        strongSelf.extractedBackgroundImageNode.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.2, delay: 0.0, timingFunction: CAMediaTimingFunctionName.easeInEaseOut.rawValue, removeOnCompletion: false, completion: { [weak self] _ in
+                            if let strongSelf = self {
+                                strongSelf.extractedBackgroundImageNode.image = nil
+                                strongSelf.extractedBackgroundImageNode.layer.removeAllAnimations()
+                            }
+                        })
+                    }
+                    
+                    transition.updateFrame(node: strongSelf.extractedBackgroundImageNode, frame: CGRect(origin: CGPoint(), size: rect.size))
+                    
+                    transition.updateAlpha(node: strongSelf.subtitleNode, alpha: isExtracted ? 0.0 : 1.0)
+                    transition.updateAlpha(node: strongSelf.expandedSubtitleNode, alpha: isExtracted ? 1.0 : 0.0)
+                    transition.updateAlpha(node: strongSelf.dateNode, alpha: isExtracted ? 0.0 : 1.0)
+                    
+                    transition.updateAlpha(node: strongSelf.addButton, alpha: isExtracted ? 0.0 : 1.0, delay: isExtracted ? 0.0 : 0.1)
+                    transition.updateAlpha(node: strongSelf.dismissButton, alpha: isExtracted ? 0.0 : 1.0, delay: isExtracted ? 0.0 : 0.1)
+                    
+                    var sublayerOffset: CGFloat = -16.0
+                    if item.style == .plain {
+                        sublayerOffset += 16.0
+                    }
+                    
+                    transition.updateSublayerTransformOffset(layer: strongSelf.offsetContainerNode.layer, offset: CGPoint(x: isExtracted ? sublayerOffset : 0.0, y: 0.0))
+                }
+            }
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListInviteRequestItem, _ params: ListViewItemLayoutParams, _ neighbors: ItemListNeighbors, _ firstWithHeader: Bool, _ last: Bool) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeTitleLayout = TextNode.asyncLayout(self.titleNode)
+        let makeSubtitleLayout = TextNode.asyncLayout(self.subtitleNode)
+        let makeExpandedSubtitleLayout = TextNode.asyncLayout(self.expandedSubtitleNode)
+        let makeDateLayout = TextNode.asyncLayout(self.dateNode)
+        let makeMeasureAddLayout = TextNode.asyncLayout(self.measureAddNode)
+        
+        let currentItem = self.layoutParams?.0
+                
+        return { item, params, neighbors, firstWithHeader, last in
+            var updatedTheme: PresentationTheme?
+        
+            let titleFont = Font.semibold(item.presentationData.fontSize.itemListBaseFontSize)
+            let subtitleFont = Font.regular(floor(item.presentationData.fontSize.itemListBaseFontSize * 14.0 / 17.0))
+            
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+                        
+            var titleText: String
+            var subtitleText: String
+            var expandedSubtitleText: String
+            var dateText: String
+          
+            if let importer = item.importer, let peer = importer.peer.peer.flatMap({ EnginePeer($0) }) {
+                titleText = peer.displayTitle(strings: item.presentationData.strings, displayOrder: item.nameDisplayOrder)
+                subtitleText = importer.about ?? ""
+                expandedSubtitleText = importer.about ?? " "
+                let timestamp = Int32(CFAbsoluteTimeGetCurrent() + NSTimeIntervalSince1970)
+                dateText = stringForRelativeTimestamp(strings: item.presentationData.strings, relativeTimestamp: importer.date, relativeTo: timestamp, dateTimeFormat: item.dateTimeFormat)
+            } else {
+                titleText = " "
+                subtitleText = " "
+                expandedSubtitleText = " "
+                dateText = " "
+            }
+            
+            let titleAttributedString = NSAttributedString(string: titleText, font: titleFont, textColor: item.presentationData.theme.list.itemPrimaryTextColor)
+            let subtitleAttributedString = NSAttributedString(string: subtitleText, font: subtitleFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+            let expnadedSubtitleAttributedString = NSAttributedString(string: expandedSubtitleText, font: subtitleFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+            let dateAttributedString = NSAttributedString(string: dateText, font: subtitleFont, textColor: item.presentationData.theme.list.itemSecondaryTextColor)
+            
+            let leftInset: CGFloat = 62.0 + params.leftInset
+            let rightInset: CGFloat = 16.0 + params.rightInset
+            let verticalInset: CGFloat = 9.0
+           
+            let (titleLayout, titleApply) = makeTitleLayout(TextNodeLayoutArguments(attributedString: titleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset - 44.0, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (subtitleLayout, subtitleApply) = makeSubtitleLayout(TextNodeLayoutArguments(attributedString: subtitleAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            var expandedMaxWidth = params.width - leftInset - rightInset
+            if item.style == .plain {
+                expandedMaxWidth -= 32.0
+            }
+            let (expandedSubtitleLayout, expandedSubtitleApply) = makeExpandedSubtitleLayout(TextNodeLayoutArguments(attributedString: expnadedSubtitleAttributedString, backgroundColor: nil, maximumNumberOfLines: 5, truncationType: .end, constrainedSize: CGSize(width: expandedMaxWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            let (dateLayout, dateApply) = makeDateLayout(TextNodeLayoutArguments(attributedString: dateAttributedString, backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let addButtonTitle = item.isGroup ? item.presentationData.strings.MemberRequests_AddToGroup : item.presentationData.strings.MemberRequests_AddToChannel
+            
+            let (measureAddLayout, _) = makeMeasureAddLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: addButtonTitle, font: Font.semibold(15.0), textColor: .black), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let titleSpacing: CGFloat = 1.0
+            
+            let minHeight: CGFloat = titleLayout.size.height + verticalInset * 2.0
+            var rawHeight: CGFloat = verticalInset * 2.0 + titleLayout.size.height + titleSpacing + 41.0
+            if !subtitleLayout.size.height.isZero {
+                rawHeight += subtitleLayout.size.height + 5.0
+            }
+            var insets: UIEdgeInsets
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            switch item.style {
+                case .plain:
+                    itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemPlainSeparatorColor
+                    insets = itemListNeighborsPlainInsets(neighbors)
+                    insets.top = 0.0
+                    insets.bottom = 0.0
+                case .blocks:
+                    itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                    itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                    insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            let contentSize = CGSize(width: params.width, height: max(minHeight, rawHeight))
+            let separatorHeight = UIScreenPixel
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (layout, { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.layoutParams = (item, params, neighbors, firstWithHeader, last)
+                                        
+                    strongSelf.accessibilityLabel = titleAttributedString.string
+                    strongSelf.accessibilityValue = subtitleAttributedString.string
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.offsetContainerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contentWrapperNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.contextSourceNode.contentNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                    strongSelf.containerNode.isGestureEnabled = item.contextAction != nil
+                    
+                    var nonExtractedRect = CGRect(origin: CGPoint(), size: CGSize(width: layout.contentSize.width, height: layout.contentSize.height))
+                    if case .blocks = item.style {
+                        nonExtractedRect = nonExtractedRect.inset(by: UIEdgeInsets(top: 0.0, left: params.leftInset, bottom: 0.0, right: params.rightInset))
+                    }
+                    var extractedRect: CGRect
+                    if case .blocks = item.style {
+                        extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: params.leftInset, dy: 0.0)
+                    } else {
+                        extractedRect = CGRect(origin: CGPoint(), size: layout.contentSize).insetBy(dx: params.leftInset + 16.0, dy: 0.0)
+                    }
+                    var extractedHeight = extractedRect.height + expandedSubtitleLayout.size.height - subtitleLayout.size.height
+                    var extractedVerticalOffset: CGFloat = 0.0
+                    if item.importer?.peer.peer?.smallProfileImage != nil {
+                        extractedRect.size.width = min(extractedRect.width, params.availableHeight - 20.0)
+                        extractedVerticalOffset = extractedRect.width
+                        extractedHeight += extractedVerticalOffset
+                    } else {
+                        nonExtractedRect.size.width += 16.0
+                        extractedHeight = max(108.0, extractedHeight)
+                    }
+                    
+                    extractedRect.size.height = extractedHeight - 46.0
+                    
+                    strongSelf.extractedVerticalOffset = extractedVerticalOffset
+                    strongSelf.extractedRect = extractedRect
+                    strongSelf.nonExtractedRect = nonExtractedRect
+                    
+                    if strongSelf.contextSourceNode.isExtractedToContextPreview {
+                        strongSelf.extractedBackgroundImageNode.frame = extractedRect
+                    } else {
+                        strongSelf.extractedBackgroundImageNode.frame = nonExtractedRect
+                    }
+                    strongSelf.contextSourceNode.contentRect = extractedRect
+                     
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.highlightedBackgroundNode.backgroundColor = item.presentationData.theme.list.itemHighlightedBackgroundColor
+                    }
+                                        
+                    let transition = ContainedViewLayoutTransition.immediate
+                                        
+                    let _ = titleApply()
+                    let _ = subtitleApply()
+                    let _ = expandedSubtitleApply()
+                    let _ = dateApply()
+                    
+                    switch item.style {
+                        case .plain:
+                            if strongSelf.backgroundNode.supernode != nil {
+                                strongSelf.backgroundNode.removeFromSupernode()
+                            }
+                            if strongSelf.topStripeNode.supernode != nil {
+                                strongSelf.topStripeNode.removeFromSupernode()
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                            }
+                            if strongSelf.maskNode.supernode != nil {
+                                strongSelf.maskNode.removeFromSupernode()
+                            }
+                            
+                            let stripeInset: CGFloat
+                            if case .none = neighbors.bottom {
+                                stripeInset = 0.0
+                            } else {
+                                stripeInset = leftInset
+                            }
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: stripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - stripeInset, height: separatorHeight))
+                            strongSelf.bottomStripeNode.isHidden = last
+                        case .blocks:
+                            if strongSelf.backgroundNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                            }
+                            if strongSelf.topStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                            }
+                            if strongSelf.bottomStripeNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                            }
+                            if strongSelf.maskNode.supernode == nil {
+                                strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                            }
+                            
+                            let hasCorners = itemListHasRoundedBlockLayout(params)
+                            var hasTopCorners = false
+                            var hasBottomCorners = false
+                            switch neighbors.top {
+                                case .sameSection(false):
+                                    strongSelf.topStripeNode.isHidden = true
+                                default:
+                                    hasTopCorners = true
+                                    strongSelf.topStripeNode.isHidden = hasCorners
+                            }
+                            let bottomStripeInset: CGFloat
+                            switch neighbors.bottom {
+                                case .sameSection(false):
+                                    bottomStripeInset = leftInset
+                                    strongSelf.bottomStripeNode.isHidden = false
+                                default:
+                                    bottomStripeInset = 0.0
+                                    hasBottomCorners = true
+                                    strongSelf.bottomStripeNode.isHidden = hasCorners
+                            }
+                            
+                            strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners) : nil
+                            
+                            strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                            strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                            strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                            strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset, height: separatorHeight))
+                    }
+                    
+                    let avatarSize: CGSize = CGSize(width: 40.0, height: 40.0)
+                    let avatarFrame = CGRect(origin: CGPoint(x: params.leftInset + 9.0, y: verticalInset + 2.0), size: avatarSize)
+                    strongSelf.avatarNode.frame = avatarFrame
+                    
+                    if let importer = item.importer, let peer = importer.peer.peer.flatMap({ EnginePeer($0) }) {
+                        strongSelf.avatarNode.setPeer(context: item.context, theme: item.presentationData.theme, peer: peer, overrideImage: nil, emptyColor: item.presentationData.theme.list.mediaPlaceholderColor, synchronousLoad: false, storeUnrounded: true)
+                    }
+                    
+                    transition.updateFrame(node: strongSelf.titleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: titleLayout.size))
+                    transition.updateFrame(node: strongSelf.subtitleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset + titleLayout.size.height + titleSpacing), size: subtitleLayout.size))
+                    transition.updateFrame(node: strongSelf.expandedSubtitleNode, frame: CGRect(origin: CGPoint(x: leftInset, y: verticalInset + titleLayout.size.height + titleSpacing), size: expandedSubtitleLayout.size))
+                    transition.updateFrame(node: strongSelf.dateNode, frame: CGRect(origin: CGPoint(x: params.width - rightInset - dateLayout.size.width, y: verticalInset + 2.0), size: dateLayout.size))
+                                        
+                    strongSelf.highlightedBackgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -UIScreenPixel), size: CGSize(width: params.width, height: contentSize.height + UIScreenPixel + UIScreenPixel))
+                    
+                    strongSelf.addButton.title = addButtonTitle
+                    if let _ = updatedTheme {
+                        strongSelf.addButton.updateTheme(SolidRoundedButtonTheme(theme: item.presentationData.theme))
+                    }
+                    strongSelf.dismissButton.setTitle(item.presentationData.strings.MemberRequests_Dismiss, with: Font.bold(15.0), with: item.presentationData.theme.list.itemAccentColor, for: .normal)
+                    
+                    let addWidth = measureAddLayout.size.width + 24.0
+                    let addHeight = strongSelf.addButton.updateLayout(width: addWidth, transition: .immediate)
+                    let addButtonFrame = CGRect(x: leftInset, y: contentSize.height - addHeight - 12.0, width: addWidth, height: addHeight)
+                    strongSelf.addButton.frame = addButtonFrame
+                    
+                    let dismissSize = strongSelf.dismissButton.measure(layout.size)
+                    strongSelf.dismissButton.frame = CGRect(origin: CGPoint(x: leftInset + addWidth + 24.0, y: verticalInset + contentSize.height - addHeight - 14.0), size: dismissSize)
+                    
+                    if item.importer == nil {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.placeholderNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.placeholderNode = shimmerNode
+                            if strongSelf.bottomStripeNode.supernode != nil {
+                                strongSelf.bottomStripeNode.removeFromSupernode()
+                                strongSelf.addSubnode(strongSelf.bottomStripeNode)
+                                strongSelf.insertSubnode(shimmerNode, belowSubnode: strongSelf.bottomStripeNode)
+                            } else {
+                                strongSelf.addSubnode(shimmerNode)
+                            }
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+                        
+                        var shapes: [ShimmerEffectNode.Shape] = []
+                        
+                        let titleLineWidth: CGFloat = 120.0
+                        let subtitleLineWidth: CGFloat = 180.0
+                        let dateLineWidth: CGFloat = 35.0
+                        let lineDiameter: CGFloat = 10.0
+                        
+                        let iconFrame = strongSelf.avatarNode.frame
+                        shapes.append(.circle(iconFrame))
+                        
+                        let titleFrame = strongSelf.titleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: titleFrame.minX, y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: titleLineWidth, diameter: lineDiameter))
+                        
+                        let subtitleFrame = strongSelf.subtitleNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: subtitleFrame.minX, y: subtitleFrame.minY + floor((subtitleFrame.height - lineDiameter) / 2.0)), width: subtitleLineWidth, diameter: lineDiameter))
+                        
+                        let dateFrame = strongSelf.dateNode.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: dateFrame.maxX - dateLineWidth, y: dateFrame.minY + floor((dateFrame.height - lineDiameter) / 2.0)), width: dateLineWidth, diameter: lineDiameter))
+
+                        let addFrame = strongSelf.addButton.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: addFrame.minX, y: addFrame.minY + floor((addFrame.height - addFrame.height) / 2.0)), width: addFrame.width, diameter: addFrame.height))
+                        
+                        let dismissFrame = strongSelf.dismissButton.frame
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: dismissFrame.minX, y: dismissFrame.minY + floor((dismissFrame.height - lineDiameter) / 2.0)), width: 60.0, diameter: lineDiameter))
+                        
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: layout.contentSize)
+                    } else if let shimmerNode = strongSelf.placeholderNode {
+                        strongSelf.placeholderNode = nil
+                        shimmerNode.removeFromSupernode()
+                    }
+                }
+            })
+        }
+    }
+    
+    @objc private func dismissPressed() {
+        if let (item, _, _, _, _) = self.layoutParams {
+            item.dismissAction?()
+        }
+    }
+    
+    override public func setHighlighted(_ highlighted: Bool, at point: CGPoint, animated: Bool) {
+        super.setHighlighted(highlighted, at: point, animated: animated)
+        
+        if highlighted {
+            self.highlightedBackgroundNode.alpha = 1.0
+            if self.highlightedBackgroundNode.supernode == nil {
+                var anchorNode: ASDisplayNode?
+                if self.bottomStripeNode.supernode != nil {
+                    anchorNode = self.bottomStripeNode
+                } else if self.topStripeNode.supernode != nil {
+                    anchorNode = self.topStripeNode
+                } else if self.backgroundNode.supernode != nil {
+                    anchorNode = self.backgroundNode
+                }
+                if let anchorNode = anchorNode {
+                    self.insertSubnode(self.highlightedBackgroundNode, aboveSubnode: anchorNode)
+                } else {
+                    self.addSubnode(self.highlightedBackgroundNode)
+                }
+            }
+        } else {
+            if self.highlightedBackgroundNode.supernode != nil {
+                if animated {
+                    self.highlightedBackgroundNode.layer.animateAlpha(from: self.highlightedBackgroundNode.alpha, to: 0.0, duration: 0.4, completion: { [weak self] completed in
+                        if let strongSelf = self {
+                            if completed {
+                                strongSelf.highlightedBackgroundNode.removeFromSupernode()
+                            }
+                        }
+                        })
+                    self.highlightedBackgroundNode.alpha = 0.0
+                } else {
+                    self.highlightedBackgroundNode.removeFromSupernode()
+                }
+            }
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.placeholderNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+}

submodules/InviteLinksUI/Sources/ItemListPermanentInviteLinkItem.swift

@@ -0,0 +1,796 @@
+import Foundation
+import UIKit
+import Display
+import AsyncDisplayKit
+import SwiftSignalKit
+import AccountContext
+import TelegramPresentationData
+import ItemListUI
+import SolidRoundedButtonNode
+import AnimatedAvatarSetNode
+import ShimmerEffect
+import TelegramCore
+import Markdown
+import TextFormat
+import ComponentFlow
+import MultilineTextComponent
+import TextNodeWithEntities
+
+private func actionButtonImage(color: UIColor) -> UIImage? {
+    return generateImage(CGSize(width: 24.0, height: 24.0), contextGenerator: { size, context in
+        context.clear(CGRect(origin: CGPoint(), size: size))
+        
+        context.setFillColor(color.cgColor)
+        context.fillEllipse(in: CGRect(origin: CGPoint(), size: size))
+        
+        context.setBlendMode(.clear)
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 4.0, y: 10.0), size: CGSize(width: 4.0, height: 4.0)))
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 10.0, y: 10.0), size: CGSize(width: 4.0, height: 4.0)))
+        context.fillEllipse(in: CGRect(origin: CGPoint(x: 16.0, y: 10.0), size: CGSize(width: 4.0, height: 4.0)))
+    })
+}
+
+public class ItemListPermanentInviteLinkItem: ListViewItem, ItemListItem {
+    let context: AccountContext
+    let presentationData: ItemListPresentationData
+    let systemStyle: ItemListSystemStyle
+    let invite: ExportedInvitation?
+    let count: Int32
+    let peers: [EnginePeer]
+    let displayButton: Bool
+    let separateButtons: Bool
+    let displayImporters: Bool
+    let isCall: Bool
+    let buttonColor: UIColor?
+    public let sectionId: ItemListSectionId
+    let style: ItemListStyle
+    let copyAction: (() -> Void)?
+    let shareAction: (() -> Void)?
+    let contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?
+    let viewAction: (() -> Void)?
+    let openCallAction: (() -> Void)?
+    public let tag: ItemListItemTag?
+    
+    public init(
+        context: AccountContext,
+        presentationData: ItemListPresentationData,
+        systemStyle: ItemListSystemStyle = .legacy,
+        invite: ExportedInvitation?,
+        count: Int32,
+        peers: [EnginePeer],
+        displayButton: Bool,
+        separateButtons: Bool = false,
+        displayImporters: Bool,
+        isCall: Bool = false,
+        buttonColor: UIColor?,
+        sectionId: ItemListSectionId,
+        style: ItemListStyle,
+        copyAction: (() -> Void)?,
+        shareAction: (() -> Void)?,
+        contextAction: ((ASDisplayNode, ContextGesture?) -> Void)?,
+        viewAction: (() -> Void)?,
+        openCallAction: (() -> Void)?,
+        tag: ItemListItemTag? = nil
+    ) {
+        self.context = context
+        self.presentationData = presentationData
+        self.systemStyle = systemStyle
+        self.invite = invite
+        self.count = count
+        self.peers = peers
+        self.displayButton = displayButton
+        self.separateButtons = separateButtons
+        self.displayImporters = displayImporters
+        self.isCall = isCall
+        self.buttonColor = buttonColor
+        self.sectionId = sectionId
+        self.style = style
+        self.copyAction = copyAction
+        self.shareAction = shareAction
+        self.contextAction = contextAction
+        self.viewAction = viewAction
+        self.openCallAction = openCallAction
+        self.tag = tag
+    }
+    
+    public func nodeConfiguredForParams(async: @escaping (@escaping () -> Void) -> Void, params: ListViewItemLayoutParams, synchronousLoads: Bool, previousItem: ListViewItem?, nextItem: ListViewItem?, completion: @escaping (ListViewItemNode, @escaping () -> (Signal<Void, NoError>?, (ListViewItemApply) -> Void)) -> Void) {
+        async {
+            let node = ItemListPermanentInviteLinkItemNode()
+            let (layout, apply) = node.asyncLayout()(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+            
+            node.contentSize = layout.contentSize
+            node.insets = layout.insets
+            
+            Queue.mainQueue().async {
+                completion(node, {
+                    return (nil, { _ in apply() })
+                })
+            }
+        }
+    }
+    
+    public func updateNode(async: @escaping (@escaping () -> Void) -> Void, node: @escaping () -> ListViewItemNode, params: ListViewItemLayoutParams, previousItem: ListViewItem?, nextItem: ListViewItem?, animation: ListViewItemUpdateAnimation, completion: @escaping (ListViewItemNodeLayout, @escaping (ListViewItemApply) -> Void) -> Void) {
+        Queue.mainQueue().async {
+            if let nodeValue = node() as? ItemListPermanentInviteLinkItemNode {
+                let makeLayout = nodeValue.asyncLayout()
+                
+                async {
+                    let (layout, apply) = makeLayout(self, params, itemListNeighbors(item: self, topItem: previousItem as? ItemListItem, bottomItem: nextItem as? ItemListItem))
+                    Queue.mainQueue().async {
+                        completion(layout, { _ in
+                            apply()
+                        })
+                    }
+                }
+            }
+        }
+    }
+    
+    public var selectable: Bool = false
+}
+
+public class ItemListPermanentInviteLinkItemNode: ListViewItemNode, ItemListItemNode {
+    private let backgroundNode: ASDisplayNode
+    private let topStripeNode: ASDisplayNode
+    private let bottomStripeNode: ASDisplayNode
+    private let maskNode: ASImageNode
+    
+    private let fieldNode: ASImageNode
+    private let addressNode: TextNode
+    private let fieldButtonNode: HighlightTrackingButtonNode
+    private let referenceContainerNode: ContextReferenceContentNode
+    private let containerNode: ContextControllerSourceNode
+    private let addressButtonNode: HighlightTrackingButtonNode
+    private let addressButtonIconNode: ASImageNode
+    private var addressShimmerNode: ShimmerEffectNode?
+    private var copyButtonNode: SolidRoundedButtonNode?
+    private var shareButtonNode: SolidRoundedButtonNode?
+    
+    private let avatarsButtonNode: HighlightTrackingButtonNode
+    private let avatarsContext: AnimatedAvatarSetContext
+    private var avatarsContent: AnimatedAvatarSetContext.Content?
+    private let avatarsNode: AnimatedAvatarSetNode
+    private let invitedPeersNode: TextNode
+    private var shimmerNode: ShimmerEffectNode?
+    private var absoluteLocation: (CGRect, CGSize)?
+    
+    private var justCreatedCallTextNode: TextNodeWithEntities?
+    private var justCreatedCallLeftSeparatorLayer: SimpleLayer?
+    private var justCreatedCallRightSeparatorLayer: SimpleLayer?
+    private var justCreatedCallSeparatorText: ComponentView<Empty>?
+    
+    private let activateArea: AccessibilityAreaNode
+    
+    private var item: ItemListPermanentInviteLinkItem?
+    
+    override public var canBeSelected: Bool {
+        return false
+    }
+    
+    public var tag: ItemListItemTag? {
+        return self.item?.tag
+    }
+    
+    public init() {
+        self.backgroundNode = ASDisplayNode()
+        self.backgroundNode.isLayerBacked = true
+        self.backgroundNode.backgroundColor = .white
+        
+        self.maskNode = ASImageNode()
+        
+        self.topStripeNode = ASDisplayNode()
+        self.topStripeNode.isLayerBacked = true
+        
+        self.bottomStripeNode = ASDisplayNode()
+        self.bottomStripeNode.isLayerBacked = true
+        
+        self.fieldNode = ASImageNode()
+        self.fieldNode.displaysAsynchronously = false
+        self.fieldNode.displayWithoutProcessing = true
+        
+        self.addressNode = TextNode()
+        self.addressNode.isUserInteractionEnabled = false
+        
+        self.fieldButtonNode = HighlightTrackingButtonNode()
+    
+        self.containerNode = ContextControllerSourceNode()
+        self.containerNode.animateScale = false
+        self.referenceContainerNode = ContextReferenceContentNode()
+        
+        self.addressButtonNode = HighlightTrackingButtonNode()
+        self.addressButtonIconNode = ASImageNode()
+        self.addressButtonIconNode.contentMode = .center
+        self.addressButtonIconNode.displaysAsynchronously = false
+        self.addressButtonIconNode.displayWithoutProcessing = true
+        
+        self.avatarsButtonNode = HighlightTrackingButtonNode()
+        self.avatarsContext = AnimatedAvatarSetContext()
+        self.avatarsNode = AnimatedAvatarSetNode()
+        self.invitedPeersNode = TextNode()
+                
+        self.activateArea = AccessibilityAreaNode()
+        
+        super.init(layerBacked: false, dynamicBounce: false)
+        
+        self.addSubnode(self.fieldNode)
+        self.addSubnode(self.addressNode)
+        self.addSubnode(self.fieldButtonNode)
+        self.addSubnode(self.avatarsNode)
+        self.addSubnode(self.invitedPeersNode)
+        self.addSubnode(self.avatarsButtonNode)
+        
+        self.containerNode.addSubnode(self.referenceContainerNode)
+        self.referenceContainerNode.addSubnode(self.addressButtonIconNode)
+        self.referenceContainerNode.addSubnode(self.addressButtonNode)
+        self.addSubnode(self.containerNode)
+        
+        self.addSubnode(self.activateArea)
+        
+        self.containerNode.activated = { [weak self] gesture, _ in
+            if let strongSelf = self, let item = strongSelf.item {
+                item.contextAction?(strongSelf.referenceContainerNode, gesture)
+            }
+        }
+        
+        self.fieldButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.addressNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.addressNode.alpha = 0.4
+                } else {
+                    strongSelf.addressNode.alpha = 1.0
+                    strongSelf.addressNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.fieldButtonNode.addTarget(self, action: #selector(self.fieldButtonPressed), forControlEvents: .touchUpInside)
+        
+        self.addressButtonNode.addTarget(self, action: #selector(self.addressButtonPressed), forControlEvents: .touchUpInside)
+        self.addressButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.addressButtonIconNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.addressButtonIconNode.alpha = 0.4
+                } else {
+                    strongSelf.addressButtonIconNode.alpha = 1.0
+                    strongSelf.addressButtonIconNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.copyButtonNode?.pressed = { [weak self] in
+            if let strongSelf = self, let item = strongSelf.item {
+                item.copyAction?()
+            }
+        }
+        self.shareButtonNode?.pressed = { [weak self] in
+            if let strongSelf = self, let item = strongSelf.item {
+                item.shareAction?()
+            }
+        }
+        self.avatarsButtonNode.highligthedChanged = { [weak self] highlighted in
+            if let strongSelf = self {
+                if highlighted {
+                    strongSelf.avatarsNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.invitedPeersNode.layer.removeAnimation(forKey: "opacity")
+                    strongSelf.avatarsNode.alpha = 0.4
+                    strongSelf.invitedPeersNode.alpha = 0.4
+                } else {
+                    strongSelf.avatarsNode.alpha = 1.0
+                    strongSelf.invitedPeersNode.alpha = 1.0
+                    strongSelf.avatarsNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                    strongSelf.invitedPeersNode.layer.animateAlpha(from: 0.4, to: 1.0, duration: 0.2)
+                }
+            }
+        }
+        self.avatarsButtonNode.addTarget(self, action: #selector(self.avatarsButtonPressed), forControlEvents: .touchUpInside)
+    }
+    
+    @objc private func fieldButtonPressed() {
+        if let item = self.item {
+            item.copyAction?()
+        }
+    }
+    
+    @objc private func addressButtonPressed() {
+        if let item = self.item {
+            item.contextAction?(self.referenceContainerNode, nil)
+        }
+    }
+    
+    @objc private func avatarsButtonPressed() {
+        if let item = self.item {
+            item.viewAction?()
+        }
+    }
+    
+    @objc private func justCreatedCallTextTap(_ recognizer: UITapGestureRecognizer) {
+        if case .ended = recognizer.state {
+            self.item?.openCallAction?()
+        }
+    }
+    
+    public func asyncLayout() -> (_ item: ItemListPermanentInviteLinkItem, _ params: ListViewItemLayoutParams, _ insets: ItemListNeighbors) -> (ListViewItemNodeLayout, () -> Void) {
+        let makeAddressLayout = TextNode.asyncLayout(self.addressNode)
+        let makeInvitedPeersLayout = TextNode.asyncLayout(self.invitedPeersNode)
+        let makeJustCreatedCallTextNodeLayout = TextNodeWithEntities.asyncLayout(self.justCreatedCallTextNode)
+        
+        let currentItem = self.item
+        let avatarsContext = self.avatarsContext
+        
+        return { item, params, neighbors in
+            var updatedTheme: PresentationTheme?
+            if currentItem?.presentationData.theme !== item.presentationData.theme {
+                updatedTheme = item.presentationData.theme
+            }
+            
+            let contentSize: CGSize
+            let insets: UIEdgeInsets
+            let separatorHeight = UIScreenPixel
+            let separatorRightInset: CGFloat = item.systemStyle == .glass ? 16.0 : 0.0
+            
+            let itemBackgroundColor: UIColor
+            let itemSeparatorColor: UIColor
+            
+            let leftInset = 16.0 + params.leftInset
+            let rightInset = 16.0 + params.rightInset
+            
+            let titleColor: UIColor
+            titleColor = item.presentationData.theme.list.itemInputField.primaryColor
+            
+            let alignCentrally = !(item.invite?.link?.contains("joinchat") ?? true)
+            
+            let addressFont = Font.regular(!alignCentrally && params.width == 320 ? floor(item.presentationData.fontSize.itemListBaseFontSize * 15.0 / 17.0) : item.presentationData.fontSize.itemListBaseFontSize)
+            let titleFont = Font.regular(item.presentationData.fontSize.itemListBaseFontSize)
+            
+            let constrainedWidth = alignCentrally ? params.width - leftInset - rightInset - 90.0 : params.width - leftInset - rightInset - 60.0
+            
+            let (addressLayout, addressApply) = makeAddressLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: item.invite.flatMap({ $0.link?.replacingOccurrences(of: "https://", with: "") }) ?? "", font: addressFont, textColor: titleColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .middle, constrainedSize: CGSize(width: constrainedWidth, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            let subtitle: String
+            let subtitleColor: UIColor
+            if item.count > 0 {
+                subtitle = item.presentationData.strings.InviteLink_PeopleJoined(item.count)
+                subtitleColor = item.presentationData.theme.list.itemAccentColor
+            } else {
+                subtitle = item.presentationData.strings.InviteLink_PeopleJoinedNone
+                subtitleColor = item.presentationData.theme.list.itemSecondaryTextColor
+            }
+            
+            let (invitedPeersLayout, invitedPeersApply) = makeInvitedPeersLayout(TextNodeLayoutArguments(attributedString: NSAttributedString(string: subtitle, font: titleFont, textColor: subtitleColor), backgroundColor: nil, maximumNumberOfLines: 1, truncationType: .end, constrainedSize: CGSize(width: params.width - params.rightInset - 20.0 - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude), alignment: .natural, cutout: nil, insets: UIEdgeInsets()))
+            
+            var justCreatedCallTextNodeLayout: (TextNodeLayout, (TextNodeWithEntities.Arguments?) -> TextNodeWithEntities?)?
+            if item.isCall {
+                let chevronImage = generateTintedImage(image: UIImage(bundleImageName: "Contact List/SubtitleArrow"), color: item.presentationData.theme.list.itemAccentColor)
+
+                let textFont = Font.regular(15.0)
+                let boldTextFont = Font.semibold(15.0)
+                let textColor = item.presentationData.theme.list.itemPrimaryTextColor
+                let accentColor = item.presentationData.theme.list.itemAccentColor
+                let markdownAttributes = MarkdownAttributes(
+                    body: MarkdownAttributeSet(font: textFont, textColor: textColor),
+                    bold: MarkdownAttributeSet(font: boldTextFont, textColor: textColor),
+                    link: MarkdownAttributeSet(font: textFont, textColor: accentColor),
+                    linkAttribute: { contents in
+                        return (TelegramTextAttributes.URL, contents)
+                    }
+                )
+                let justCreatedCallTextAttributedString = parseMarkdownIntoAttributedString(item.presentationData.strings.InviteLink_CreatedGroupCallFooter, attributes: markdownAttributes).mutableCopy() as! NSMutableAttributedString
+                if let range = justCreatedCallTextAttributedString.string.range(of: ">"), let chevronImage {
+                    justCreatedCallTextAttributedString.addAttribute(.attachment, value: chevronImage, range: NSRange(range, in: justCreatedCallTextAttributedString.string))
+                }
+
+                justCreatedCallTextNodeLayout = makeJustCreatedCallTextNodeLayout(TextNodeLayoutArguments(
+                    attributedString: justCreatedCallTextAttributedString,
+                    backgroundColor: nil,
+                    maximumNumberOfLines: 0,
+                    truncationType: .end,
+                    constrainedSize: CGSize(width: params.width - params.rightInset - 20.0 - leftInset - rightInset, height: CGFloat.greatestFiniteMagnitude),
+                    alignment: .center,
+                    lineSpacing: 0.28,
+                    cutout: nil,
+                    insets: UIEdgeInsets()
+                ))
+            }
+            
+            let avatarsContent = avatarsContext.update(peers: item.peers, animated: false)
+            
+            let verticalInset: CGFloat
+            switch item.systemStyle {
+            case .glass:
+                verticalInset = 16.0
+            case .legacy:
+                verticalInset = 16.0
+            }
+            
+            let fieldHeight: CGFloat = 52.0
+            let fieldSpacing: CGFloat = 16.0
+            let buttonHeight: CGFloat = 50.0
+            let justCreatedCallSeparatorSpacing: CGFloat = 16.0
+            let justCreatedCallTextSpacing: CGFloat = 45.0
+            
+            var height = verticalInset * 2.0 + fieldHeight + fieldSpacing + buttonHeight + 54.0
+
+            if let justCreatedCallTextNodeLayout {
+                height += justCreatedCallTextSpacing - 2.0
+                height += justCreatedCallTextNodeLayout.0.size.height
+            }
+            
+            switch item.style {
+            case .plain:
+                itemBackgroundColor = item.presentationData.theme.list.plainBackgroundColor
+                itemSeparatorColor = .clear
+                insets = UIEdgeInsets()
+            case .blocks:
+                itemBackgroundColor = item.presentationData.theme.list.itemBlocksBackgroundColor
+                itemSeparatorColor = item.presentationData.theme.list.itemBlocksSeparatorColor
+                insets = itemListNeighborsGroupedInsets(neighbors, params)
+            }
+            
+            if !item.displayImporters {
+                height -= 57.0
+            }
+            if !item.displayButton {
+                height -= 63.0
+            }
+            
+            contentSize = CGSize(width: params.width, height: height)
+            
+            let layout = ListViewItemNodeLayout(contentSize: contentSize, insets: insets)
+            
+            return (ListViewItemNodeLayout(contentSize: contentSize, insets: insets), { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.item = item
+                    strongSelf.avatarsContent = avatarsContent
+                    
+                    strongSelf.activateArea.frame = CGRect(origin: CGPoint(x: params.leftInset, y: 0.0), size: CGSize(width: params.width - params.leftInset - params.rightInset, height: layout.contentSize.height))
+//                    strongSelf.activateArea.accessibilityLabel = item.title
+//                    strongSelf.activateArea.accessibilityValue = item.label
+                    strongSelf.activateArea.accessibilityTraits = []
+                    
+                    if let _ = updatedTheme {
+                        strongSelf.topStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.bottomStripeNode.backgroundColor = itemSeparatorColor
+                        strongSelf.backgroundNode.backgroundColor = itemBackgroundColor
+                        strongSelf.fieldNode.image = generateStretchableFilledCircleImage(diameter: item.systemStyle == .glass ? 52.0 : 18.0, color: item.presentationData.theme.list.itemInputField.backgroundColor)
+                        strongSelf.addressButtonIconNode.image = actionButtonImage(color: item.presentationData.theme.list.itemInputField.controlColor)
+                    }
+                                        
+                    let _ = addressApply()
+                    let _ = invitedPeersApply()
+                    
+                    switch item.style {
+                    case .plain:
+                        if strongSelf.backgroundNode.supernode != nil {
+                            strongSelf.backgroundNode.removeFromSupernode()
+                        }
+                        if strongSelf.topStripeNode.supernode != nil {
+                            strongSelf.topStripeNode.removeFromSupernode()
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 0)
+                        }
+                        if strongSelf.maskNode.supernode != nil {
+                            strongSelf.maskNode.removeFromSupernode()
+                        }
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: leftInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - leftInset, height: separatorHeight))
+                    case .blocks:
+                        if strongSelf.backgroundNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.backgroundNode, at: 0)
+                        }
+                        if strongSelf.topStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.topStripeNode, at: 1)
+                        }
+                        if strongSelf.bottomStripeNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.bottomStripeNode, at: 2)
+                        }
+                        if strongSelf.maskNode.supernode == nil {
+                            strongSelf.insertSubnode(strongSelf.maskNode, at: 3)
+                        }
+                        
+                        let hasCorners = itemListHasRoundedBlockLayout(params)
+                        var hasTopCorners = false
+                        var hasBottomCorners = false
+                        switch neighbors.top {
+                            case .sameSection(false):
+                                strongSelf.topStripeNode.isHidden = true
+                            default:
+                                hasTopCorners = true
+                                strongSelf.topStripeNode.isHidden = hasCorners
+                        }
+                        let bottomStripeInset: CGFloat
+                        switch neighbors.bottom {
+                            case .sameSection(false):
+                                bottomStripeInset = leftInset
+                                strongSelf.bottomStripeNode.isHidden = false
+                            default:
+                                bottomStripeInset = 0.0
+                                hasBottomCorners = true
+                                strongSelf.bottomStripeNode.isHidden = hasCorners
+                        }
+                        
+                        strongSelf.maskNode.image = hasCorners ? PresentationResourcesItemList.cornersImage(item.presentationData.theme, top: hasTopCorners, bottom: hasBottomCorners, glass: item.systemStyle == .glass) : nil
+                        
+                        strongSelf.backgroundNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: contentSize.height + min(insets.top, separatorHeight) + min(insets.bottom, separatorHeight)))
+                        strongSelf.maskNode.frame = strongSelf.backgroundNode.frame.insetBy(dx: params.leftInset, dy: 0.0)
+                        strongSelf.topStripeNode.frame = CGRect(origin: CGPoint(x: 0.0, y: -min(insets.top, separatorHeight)), size: CGSize(width: params.width, height: separatorHeight))
+                        strongSelf.bottomStripeNode.frame = CGRect(origin: CGPoint(x: bottomStripeInset, y: contentSize.height - separatorHeight), size: CGSize(width: params.width - bottomStripeInset - params.rightInset - separatorRightInset, height: separatorHeight))
+                    }
+                    
+                    let fieldFrame = CGRect(origin: CGPoint(x: leftInset, y: verticalInset), size: CGSize(width: params.width - leftInset - rightInset, height: fieldHeight))
+                    strongSelf.fieldNode.frame = fieldFrame
+                    strongSelf.fieldButtonNode.frame = fieldFrame
+                    
+                    strongSelf.addressNode.frame = CGRect(origin: CGPoint(x: fieldFrame.minX + (alignCentrally ? floorToScreenPixels((fieldFrame.width - addressLayout.size.width) / 2.0) : 14.0), y: fieldFrame.minY + floorToScreenPixels((fieldFrame.height - addressLayout.size.height) / 2.0) + 1.0), size: addressLayout.size)
+                    
+                    strongSelf.containerNode.frame = CGRect(origin: CGPoint(x: params.width - rightInset - 38.0 - 14.0, y: verticalInset), size: CGSize(width: 52.0, height: 52.0))
+                    strongSelf.addressButtonNode.frame = strongSelf.containerNode.bounds
+                    strongSelf.referenceContainerNode.frame =  strongSelf.containerNode.bounds
+                    strongSelf.addressButtonIconNode.frame = strongSelf.containerNode.bounds
+                    
+                    strongSelf.addressButtonNode.isHidden = item.contextAction == nil
+                    strongSelf.addressButtonIconNode.isHidden = item.contextAction == nil
+                      
+                    var effectiveSeparateButtons = item.separateButtons
+                    if let invite = item.invite, invitationAvailability(invite).isZero {
+                        effectiveSeparateButtons = false
+                    }
+                    
+                    let copyButtonNode: SolidRoundedButtonNode
+                    if let currentCopyButtonNode = strongSelf.copyButtonNode {
+                        copyButtonNode = currentCopyButtonNode
+                    } else {
+                        let buttonTheme: SolidRoundedButtonTheme
+                        if let buttonColor = item.buttonColor {
+                            buttonTheme = SolidRoundedButtonTheme(backgroundColor: buttonColor, foregroundColor: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                        } else {
+                            buttonTheme = SolidRoundedButtonTheme(theme: item.presentationData.theme)
+                        }
+                        copyButtonNode = SolidRoundedButtonNode(theme: buttonTheme, glass: item.systemStyle == .glass, height: 52.0, cornerRadius: item.systemStyle == .glass ? 26.0 : 11.0)
+                        copyButtonNode.title = item.presentationData.strings.InviteLink_CopyShort
+                        copyButtonNode.pressed = { [weak self] in
+                            self?.item?.copyAction?()
+                        }
+                        strongSelf.addSubnode(copyButtonNode)
+                        strongSelf.copyButtonNode = copyButtonNode
+                    }
+                    
+                    let shareButtonNode: SolidRoundedButtonNode
+                    if let currentShareButtonNode = strongSelf.shareButtonNode {
+                        shareButtonNode = currentShareButtonNode
+                    } else {
+                        let buttonTheme: SolidRoundedButtonTheme
+                        if let buttonColor = item.buttonColor {
+                            buttonTheme = SolidRoundedButtonTheme(backgroundColor: buttonColor, foregroundColor: item.presentationData.theme.list.itemCheckColors.foregroundColor)
+                        } else {
+                            buttonTheme = SolidRoundedButtonTheme(theme: item.presentationData.theme)
+                        }
+                        shareButtonNode = SolidRoundedButtonNode(theme: buttonTheme, glass: item.systemStyle == .glass, height: 52.0, cornerRadius: item.systemStyle == .glass ? 26.0 : 11.0)
+                        if let invite = item.invite, invitationAvailability(invite).isZero {
+                            shareButtonNode.title = item.presentationData.strings.InviteLink_ReactivateLink
+                        } else {
+                            shareButtonNode.title = effectiveSeparateButtons ? item.presentationData.strings.InviteLink_ShareShort : item.presentationData.strings.InviteLink_Share
+                        }
+                        shareButtonNode.pressed = { [weak self] in
+                            self?.item?.shareAction?()
+                        }
+                        strongSelf.addSubnode(shareButtonNode)
+                        strongSelf.shareButtonNode = shareButtonNode
+                    }
+                    
+                    let buttonSpacing: CGFloat = 8.0
+                    var buttonWidth = contentSize.width - leftInset - rightInset
+                    var shareButtonOriginX = leftInset
+                    if effectiveSeparateButtons {
+                        buttonWidth = (buttonWidth - buttonSpacing) / 2.0
+                        shareButtonOriginX = leftInset + buttonWidth + buttonSpacing
+                    }
+                    
+                    let _ = copyButtonNode.updateLayout(width: buttonWidth, transition: .immediate)
+                    copyButtonNode.frame = CGRect(x: leftInset, y: verticalInset + fieldHeight + fieldSpacing, width: buttonWidth, height: buttonHeight)
+                    
+                    let _ = shareButtonNode.updateLayout(width: buttonWidth, transition: .immediate)
+                    shareButtonNode.frame = CGRect(x: shareButtonOriginX, y: verticalInset + fieldHeight + fieldSpacing, width: buttonWidth, height: buttonHeight)
+
+                    if let justCreatedCallTextNodeLayout {
+                        if let justCreatedCallTextNode = justCreatedCallTextNodeLayout.1(TextNodeWithEntities.Arguments(
+                            context: item.context,
+                            cache: item.context.animationCache,
+                            renderer: item.context.animationRenderer,
+                            placeholderColor: .gray,
+                            attemptSynchronous: true
+                        )) {
+                            if strongSelf.justCreatedCallTextNode !== justCreatedCallTextNode {
+                                strongSelf.justCreatedCallTextNode?.textNode.removeFromSupernode()
+                                strongSelf.justCreatedCallTextNode = justCreatedCallTextNode
+                                
+                                strongSelf.addSubnode(justCreatedCallTextNode.textNode)
+                                
+                                justCreatedCallTextNode.textNode.view.addGestureRecognizer(UITapGestureRecognizer(target: strongSelf, action: #selector(strongSelf.justCreatedCallTextTap(_:))))
+                            }
+                            
+                            let justCreatedCallTextNodeFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - justCreatedCallTextNodeLayout.0.size.width) / 2.0), y: shareButtonNode.frame.maxY + justCreatedCallTextSpacing), size: CGSize(width: justCreatedCallTextNodeLayout.0.size.width, height: justCreatedCallTextNodeLayout.0.size.height))
+                            justCreatedCallTextNode.textNode.frame = justCreatedCallTextNodeFrame
+
+                            let justCreatedCallSeparatorText: ComponentView<Empty>
+                            if let current = strongSelf.justCreatedCallSeparatorText {
+                                justCreatedCallSeparatorText = current
+                            } else {
+                                justCreatedCallSeparatorText = ComponentView()
+                                strongSelf.justCreatedCallSeparatorText = justCreatedCallSeparatorText
+                            }
+                            
+                            let justCreatedCallLeftSeparatorLayer: SimpleLayer
+                            if let current = strongSelf.justCreatedCallLeftSeparatorLayer {
+                                justCreatedCallLeftSeparatorLayer = current
+                            } else {
+                                justCreatedCallLeftSeparatorLayer = SimpleLayer()
+                                strongSelf.justCreatedCallLeftSeparatorLayer = justCreatedCallLeftSeparatorLayer
+                                strongSelf.layer.addSublayer(justCreatedCallLeftSeparatorLayer)
+                            }
+                            
+                            let justCreatedCallRightSeparatorLayer: SimpleLayer
+                            if let current = strongSelf.justCreatedCallRightSeparatorLayer {
+                                justCreatedCallRightSeparatorLayer = current
+                            } else {
+                                justCreatedCallRightSeparatorLayer = SimpleLayer()
+                                strongSelf.justCreatedCallRightSeparatorLayer = justCreatedCallRightSeparatorLayer
+                                strongSelf.layer.addSublayer(justCreatedCallRightSeparatorLayer)
+                            }
+                            
+                            justCreatedCallLeftSeparatorLayer.backgroundColor = item.presentationData.theme.list.itemPlainSeparatorColor.cgColor
+                            justCreatedCallRightSeparatorLayer.backgroundColor = item.presentationData.theme.list.itemPlainSeparatorColor.cgColor
+                            
+                            let justCreatedCallSeparatorTextSize = justCreatedCallSeparatorText.update(
+                                transition: .immediate,
+                                component: AnyComponent(MultilineTextComponent(
+                                    text: .plain(NSAttributedString(string: item.presentationData.strings.SendInviteLink_PremiumOrSendSectionSeparator, font: Font.regular(15.0), textColor: item.presentationData.theme.list.itemSecondaryTextColor))
+                                )),
+                                environment: {},
+                                containerSize: CGSize(width: params.width - leftInset - rightInset, height: 100.0)
+                            )
+                            let justCreatedCallSeparatorTextFrame = CGRect(origin: CGPoint(x: floor((params.width - justCreatedCallSeparatorTextSize.width) * 0.5), y: shareButtonNode.frame.maxY + justCreatedCallSeparatorSpacing), size: justCreatedCallSeparatorTextSize)
+                            if let justCreatedCallSeparatorTextView = justCreatedCallSeparatorText.view {
+                                if justCreatedCallSeparatorTextView.superview == nil {
+                                    strongSelf.view.addSubview(justCreatedCallSeparatorTextView)
+                                }
+                                justCreatedCallSeparatorTextView.frame = justCreatedCallSeparatorTextFrame
+                            }
+                            
+                            let separatorWidth: CGFloat = 72.0
+                            let separatorSpacing: CGFloat = 10.0
+                            
+                            justCreatedCallLeftSeparatorLayer.frame = CGRect(origin: CGPoint(x: justCreatedCallSeparatorTextFrame.minX - separatorSpacing - separatorWidth, y: justCreatedCallSeparatorTextFrame.midY + 1.0), size: CGSize(width: separatorWidth, height: UIScreenPixel))
+                            justCreatedCallRightSeparatorLayer.frame = CGRect(origin: CGPoint(x: justCreatedCallSeparatorTextFrame.maxX + separatorSpacing, y: justCreatedCallSeparatorTextFrame.midY + 1.0), size: CGSize(width: separatorWidth, height: UIScreenPixel))
+                        }
+                    } else if let justCreatedCallTextNode = strongSelf.justCreatedCallTextNode {
+                        strongSelf.justCreatedCallTextNode = nil
+                        justCreatedCallTextNode.textNode.removeFromSupernode()
+
+                        strongSelf.justCreatedCallLeftSeparatorLayer?.removeFromSuperlayer()
+                        strongSelf.justCreatedCallLeftSeparatorLayer = nil
+
+                        strongSelf.justCreatedCallRightSeparatorLayer?.removeFromSuperlayer()
+                        strongSelf.justCreatedCallRightSeparatorLayer = nil
+
+                        strongSelf.justCreatedCallSeparatorText?.view?.removeFromSuperview()
+                        strongSelf.justCreatedCallSeparatorText = nil
+                    }
+                    
+                    var totalWidth = invitedPeersLayout.size.width
+                    var leftOrigin: CGFloat = floorToScreenPixels((params.width - invitedPeersLayout.size.width) / 2.0)
+                    let avatarSpacing: CGFloat = 21.0
+                    if let avatarsContent = strongSelf.avatarsContent {
+                        let avatarsSize = strongSelf.avatarsNode.update(context: item.context, content: avatarsContent, itemSize: CGSize(width: 32.0, height: 32.0), animated: true, synchronousLoad: true)
+                        
+                        if !avatarsSize.width.isZero {
+                            totalWidth += avatarsSize.width + avatarSpacing
+                        }
+                        
+                        let avatarsNodeFrame = CGRect(origin: CGPoint(x: floorToScreenPixels((params.width - totalWidth) / 2.0), y: fieldFrame.maxY + 87.0), size: avatarsSize)
+                        strongSelf.avatarsNode.frame = avatarsNodeFrame
+                        if !avatarsSize.width.isZero {
+                            leftOrigin = avatarsNodeFrame.maxX + avatarSpacing
+                        }
+                    }
+                    
+                    strongSelf.invitedPeersNode.frame = CGRect(origin: CGPoint(x: leftOrigin, y: fieldFrame.maxY + 92.0), size: invitedPeersLayout.size)
+                    
+                    strongSelf.avatarsButtonNode.frame = CGRect(x: floorToScreenPixels((params.width - totalWidth) / 2.0), y: fieldFrame.maxY + 87.0, width: totalWidth, height: 32.0)
+                    strongSelf.avatarsButtonNode.isUserInteractionEnabled = !item.peers.isEmpty && item.invite != nil
+                    
+                    strongSelf.addressButtonNode.isUserInteractionEnabled = item.invite != nil
+                    strongSelf.fieldButtonNode.isUserInteractionEnabled = item.invite != nil
+                    strongSelf.addressButtonIconNode.alpha = item.invite != nil ? 1.0 : 0.0
+                    
+                    
+                    strongSelf.copyButtonNode?.isUserInteractionEnabled = item.invite != nil
+                    strongSelf.copyButtonNode?.alpha = item.invite != nil ? 1.0 : 0.4
+                    strongSelf.copyButtonNode?.isHidden = !item.displayButton || !effectiveSeparateButtons
+                    
+                    strongSelf.shareButtonNode?.isUserInteractionEnabled = item.invite != nil
+                    strongSelf.shareButtonNode?.alpha = item.invite != nil ? 1.0 : 0.4
+                    strongSelf.shareButtonNode?.isHidden = !item.displayButton
+                    
+                    strongSelf.avatarsButtonNode.isHidden = !item.displayImporters
+                    strongSelf.avatarsNode.isHidden = !item.displayImporters || item.invite == nil
+                    strongSelf.invitedPeersNode.isHidden = !item.displayImporters || item.invite == nil
+                    
+                    if item.invite == nil {
+                        let shimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.shimmerNode {
+                            shimmerNode = current
+                        } else {
+                            shimmerNode = ShimmerEffectNode()
+                            strongSelf.shimmerNode = shimmerNode
+                            strongSelf.insertSubnode(shimmerNode, belowSubnode: strongSelf.fieldNode)
+                        }
+                        shimmerNode.frame = CGRect(origin: CGPoint(), size: layout.contentSize)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            shimmerNode.updateAbsoluteRect(rect, within: size)
+                        }
+                        
+                        let lineWidth: CGFloat = 180.0
+                        let lineDiameter: CGFloat = 12.0
+                        let titleFrame = strongSelf.invitedPeersNode.frame
+                        
+                        var shapes: [ShimmerEffectNode.Shape] = []
+                        shapes.append(.roundedRectLine(startPoint: CGPoint(x: floor(titleFrame.center.x - lineWidth / 2.0), y: titleFrame.minY + floor((titleFrame.height - lineDiameter) / 2.0)), width: lineWidth, diameter: lineDiameter))
+                        shimmerNode.update(backgroundColor: item.presentationData.theme.list.itemBlocksBackgroundColor, foregroundColor: item.presentationData.theme.list.mediaPlaceholderColor, shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: shapes, size: layout.contentSize)
+                        
+                        let addressShimmerNode: ShimmerEffectNode
+                        if let current = strongSelf.addressShimmerNode {
+                            addressShimmerNode = current
+                        } else {
+                            addressShimmerNode = ShimmerEffectNode()
+                            strongSelf.addressShimmerNode = addressShimmerNode
+                            strongSelf.insertSubnode(addressShimmerNode, aboveSubnode: strongSelf.fieldNode)
+                        }
+                        addressShimmerNode.frame = strongSelf.fieldNode.frame.insetBy(dx: 18.0, dy: 0.0)
+                        if let (rect, size) = strongSelf.absoluteLocation {
+                            addressShimmerNode.updateAbsoluteRect(CGRect(x: rect.minX + strongSelf.fieldNode.frame.minX + 18.0, y: rect.minY + strongSelf.fieldNode.frame.minY, width: strongSelf.fieldNode.frame.width - 18.0 * 2.0, height: strongSelf.fieldNode.frame.height), within: size)
+                        }
+                        
+                        let addressLineWidth: CGFloat = strongSelf.fieldNode.frame.width - 100.0
+                        var addressShapes: [ShimmerEffectNode.Shape] = []
+                        addressShapes.append(.roundedRectLine(startPoint: CGPoint(x: floor(addressShimmerNode.frame.width / 2.0 - addressLineWidth / 2.0), y: 16.0 + floor((22.0 - lineDiameter) / 2.0)), width: addressLineWidth, diameter: lineDiameter))
+                        addressShimmerNode.update(backgroundColor: item.presentationData.theme.list.itemInputField.backgroundColor, foregroundColor: item.presentationData.theme.list.itemInputField.controlColor.mixedWith(item.presentationData.theme.list.itemInputField.backgroundColor, alpha: 0.7), shimmeringColor: item.presentationData.theme.list.itemBlocksBackgroundColor.withAlphaComponent(0.4), shapes: addressShapes, size: addressShimmerNode.frame.size)
+
+                    } else {
+                        if let shimmerNode = strongSelf.shimmerNode {
+                            strongSelf.shimmerNode = nil
+                            shimmerNode.removeFromSupernode()
+                        }
+                        if let shimmerNode = strongSelf.addressShimmerNode {
+                            strongSelf.shimmerNode = nil
+                            shimmerNode.removeFromSupernode()
+                        }
+                    }
+                }
+            })
+        }
+    }
+    
+    override public func animateInsertion(_ currentTimestamp: Double, duration: Double, options: ListViewItemAnimationOptions) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.4)
+    }
+    
+    override public func animateAdded(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 0.0, to: 1.0, duration: 0.2)
+    }
+    
+    override public func animateRemoved(_ currentTimestamp: Double, duration: Double) {
+        self.layer.animateAlpha(from: 1.0, to: 0.0, duration: 0.15, removeOnCompletion: false)
+    }
+    
+    override public func updateAbsoluteRect(_ rect: CGRect, within containerSize: CGSize) {
+        var rect = rect
+        rect.origin.y += self.insets.top
+        self.absoluteLocation = (rect, containerSize)
+        if let shimmerNode = self.addressShimmerNode {
+            shimmerNode.updateAbsoluteRect(CGRect(x: rect.minX + self.fieldNode.frame.minX + 18.0, y: rect.minY + self.fieldNode.frame.minY, width: self.fieldNode.frame.width - 18.0 * 2.0, height: self.fieldNode.frame.height), within: containerSize)
+        }
+        if let shimmerNode = self.shimmerNode {
+            shimmerNode.updateAbsoluteRect(rect, within: containerSize)
+        }
+    }
+}